collectioncollection.cpp

Go to the documentation of this file.

/*
  Zipios++ - a small C++ library that provides easy access to .zip files.

  Copyright (C) 2000-2007  Thomas Sondergaard
  Copyright (C) 2015  Made to Order Software Corporation

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
*/

#include "zipios++/collectioncollection.hpp"

#include "zipios++/zipiosexceptions.hpp"

#include "zipios_common.hpp"


namespace zipios
{


namespace
{

void matchEntry(CollectionCollection::vector_t collections, std::string const& name, FileEntry::pointer_t& cep, FileCollection::pointer_t& file_collection, CollectionCollection::MatchPath matchpath)
{
    for(auto it = collections.begin(); it != collections.end(); ++it)
    {
        cep = (*it)->getEntry(name, matchpath);
        if(cep)
        {
            file_collection = *it;
            return;
        }
    }
    cep.reset();
    file_collection.reset();
}

} // no name namespace


CollectionCollection::CollectionCollection()
{
    m_valid = true; // we are valid even though we are empty!
}


CollectionCollection::CollectionCollection(CollectionCollection const& src)
    : FileCollection(src)
{
    m_collections.reserve(src.m_collections.size());
    for(auto it = src.m_collections.begin(); it != src.m_collections.end(); ++it)
    {
        m_collections.push_back((*it)->clone());
    }
}


CollectionCollection& CollectionCollection::operator = (CollectionCollection const& rhs)
{
    FileCollection::operator = (rhs);

    if(this != &rhs)
    {
        m_collections.clear();
        // A call to the CollectionCollection::size() function has side
        // effects, try to avoid them at this time
        //m_collections.reserve(rhs.m_collections.size());
        for(auto it = rhs.m_collections.begin(); it != rhs.m_collections.end(); ++it)
        {
            m_collections.push_back((*it)->clone());
        }
    }

    return *this;
}


FileCollection::pointer_t CollectionCollection::clone() const
{
    return FileCollection::pointer_t(new CollectionCollection(*this));
}


CollectionCollection::~CollectionCollection()
{
    close();
}


bool CollectionCollection::addCollection(FileCollection const& collection)
{
    mustBeValid();

    if(this == &collection || !collection.isValid())
    {
        return false;
    }

    m_collections.push_back(collection.clone());

    return true;
}


bool CollectionCollection::addCollection(FileCollection::pointer_t collection)
{
    if(!collection)
    {
        // TBD: should we return false instead?
        throw InvalidException("CollectionCollection::addCollection(): called with a null collection pointer");
    }

    return addCollection(*collection);
}


void CollectionCollection::close()
{
    // make sure to close all the children first
    // (although I would imagine that the m_collections.clear() should
    // be enough, unless someone else has a refenrence to another one
    // of the sub-collections--but I do not think one can get such as
    // reference at this point, remember that the addCollection()
    // creates a clone of the collection being added.)
    for(auto it = m_collections.begin(); it != m_collections.end(); ++it)
    {
        // each collection in the collection must be valid since we
        // may hit any one of them
        (*it)->close();
    }
    m_collections.clear();

    FileCollection::close();
}


FileEntry::vector_t CollectionCollection::entries() const
{
    mustBeValid();

    FileEntry::vector_t all_entries;
    for(auto it = m_collections.begin(); it != m_collections.end(); ++it)
    {
        all_entries += (*it)->entries();
    }

    return all_entries;
}


FileEntry::pointer_t CollectionCollection::getEntry(std::string const& name, MatchPath matchpath) const
{
    mustBeValid();

    // Returns the first matching entry.
    FileCollection::pointer_t file_colection;
    FileEntry::pointer_t cep;

    matchEntry(m_collections, name, cep, file_colection, matchpath);

    return cep;
}


CollectionCollection::stream_pointer_t CollectionCollection::getInputStream(std::string const& entry_name, MatchPath matchpath)
{
    mustBeValid();

    FileCollection::pointer_t file_collection;
    FileEntry::pointer_t cep;

    matchEntry(m_collections, entry_name, cep, file_collection, matchpath);

    return cep ? file_collection->getInputStream(entry_name) : nullptr;
}


size_t CollectionCollection::size() const
{
    mustBeValid();

    size_t sz(0);
    for(auto it = m_collections.begin(); it != m_collections.end(); ++it)
    {
        sz += (*it)->size();
    }

    return sz;
}


void CollectionCollection::mustBeValid() const
{
    // self must be valid
    FileCollection::mustBeValid();

    for(auto it = m_collections.begin(); it != m_collections.end(); ++it)
    {
        // each collection in the collection must be valid since we
        // may hit any one of them
        (*it)->mustBeValid();
    }
}


} // zipios namespace

// Local Variables:
// mode: cpp
// indent-tabs-mode: nil
// c-basic-offset: 4
// tab-width: 4
// End:

// vim: ts=4 sw=4 et