---

SOMELibCatalog.cpp

/********************************************************************
** Copyright (C) 2000 SOMELib Project
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Library 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
** Library General Public License for more details.
**
** You should have received a copy of the GNU Library 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 "SOMELibCatalog.h"
#include "limits.h"
#include <algorithm>
#ifdef _DEBUG
#include <iostream>
#endif

SOME::LibCatalog::LibCatalog(SOME::BasicDynLib* l):
        lib(l),
        class_index_cache(UINT_MAX)
{
    typedef void (*initSOMELibCatalog_FUNC)(SOME::LibCatalog*);
    initSOMELibCatalog_FUNC foo = (initSOMELibCatalog_FUNC) l->getFunction("initSOMELibCatalog");
    (*foo)(this);
}

SOME::LibCatalog::~LibCatalog()
{
    //delete lib;
}



const std::string& SOME::LibCatalog::getPath() const
{
    return lib->getFilePath();
}

void SOME::LibCatalog::setLibTitle(const std::string& t)
{
    title = t;
}

void SOME::LibCatalog::setVersion(const std::string& v)
{
    version = v;
}

SOME::ClassCatalog *SOME::LibCatalog::addClassCatalog(const std::string& classname, const std::string& category, SOME::ClassCatalog::ConstructFunc def, SOME::ClassCatalog::ConstructFunc one, SOME::ClassCatalog::ConstructFunc two)
{
#ifdef _DEBUG
    std::cout << "Adding class: " << classname << ", category: " << category << std::endl;
#endif
    SOME::ClassCatalog class_info(classname, category, def, one, two);

    //QUESTION: Does this produce a copy of class_info, why not use pointers?
    classes.push_back(class_info);

    return &classes.back();
}

bool SOME::LibCatalog::hasClass(const std::string& classname)
{
    for (ClassContainer::size_type i = 0; i < classes.size(); i++)
    {
        if (classes[i].getClassName() == classname)
        {
            class_index_cache = i;
            return true;
        }
    }
    class_index_cache = UINT_MAX;
    return false;
}

const SOME::ClassCatalog& SOME::LibCatalog::getClass(const std::string& classname)
{
    if (class_index_cache != UINT_MAX && class_index_cache < classes.size())
        if (classes[class_index_cache].getClassName() == classname)
            return classes[class_index_cache];

    for (ClassContainer::size_type i = 0; i < classes.size(); i++)
    {
        if (classes[i].getClassName() == classname)
        {
            class_index_cache = i;
            return classes[i];
        }
    }

    throw ClassDoesNotExist(title, classname);
}

SOME::LibCatalog::ClassContainer SOME::LibCatalog::getCategory(const std::string& category)
{
    ClassContainer results;

    for (ClassContainer::size_type i = 0; i < classes.size(); i++)
    {

        if (classes[i].getCategory() == category)
            results.push_back(classes[i]);
    }

    return results;
}

SOME::LibCatalog::ClassContainer SOME::LibCatalog::getByCategory(const std::string& key, const std::string& value )
{
    ClassContainer results;

    for (ClassContainer::size_type i = 0; i < classes.size(); i++)
    {
        if (classes[i].infoEquals(key, value))
            results.push_back(classes[i]);
    }

    return results;
}

SOME::LibCatalog::ClassContainer SOME::LibCatalog::getByCategory( std::map < std::string, std::string > & keys )
{
    ClassContainer results;

    for (ClassContainer::size_type i = 0; i < classes.size(); i++)
    {
        std::map < std::string, std::string > ::iterator i2 = keys.begin();
        bool match = true;
        for (; match && i2 != keys.end(); i2++ )
        {
            match = classes[i].infoEquals((*i2).first, (*i2).second);

        }

        if (match)
            results.push_back(classes[i]);
    }

    return results;
}

std::set < std::string > SOME::LibCatalog::enumCategory( const std::string& key )
{
    std::set < std::string > results;
    for (ClassContainer::size_type i = 0; i < classes.size(); i++)
    {
        //values are unique
        results.insert(classes[i].getCategory(key));
    }

    return results;
}

std::set < std::string > SOME::LibCatalog::enumCategory( const std::string& key, std::map < std::string, std::string > &catmap )
{
    std::set < std::string > results;
    for (ClassContainer::size_type i = 0; i < classes.size(); i++)
    {
        std::map < std::string, std::string > ::iterator i2 = catmap.begin();
        bool match = true;
        for (; match && i2 != catmap.end(); i2++ )
        {
            match = classes[i].infoEquals((*i2).first, (*i2).second);

        }

        //values are unique
        if (match)
            results.insert(classes[i].getCategory(key));
    }

    return results;
}

---