---

SOMEClassCatalog.h

/********************************************************************
** 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.
**
*******************************************************************/

#ifndef SOME_class_properties_HEADER
#define SOME_class_properties_HEADER

#include "UserConfig.h"
#include <string>
#include <cassert>
#include <map>
#ifdef _MSC_VER //should we just go with some_string_map?  probably not
#include "SOMEStringMap.h"
#endif

namespace SOME
{
class ClassCatalog
{
public:
    typedef void* (*ConstructFunc)();   //since our construct func's are extern "C"d they appear to have no params and must be cast

    ClassCatalog(const std::string& classname,
                 const std::string& the_category,
                 ConstructFunc def = NULL,
                 ConstructFunc one = NULL,
             ConstructFunc two = NULL):
    ctor0_func(def),
    ctor1_func(one),
    ctor2_func(two)
    {
        assert(ctor0_func != NULL || ctor1_func != NULL || ctor2_func != NULL);
        class_properties["classname"] = classname;
        class_properties["category"] = the_category;
    }

    void addCategory( std::string key, std::string value )
    {
        //you can only add class info if it does not already exist
        if (class_properties[key] == "")
            class_properties[key] = value;
    }

    std::map < std::string, std::string > getProperties()
    {
#ifdef _MSC_VER
        return class_properties.getStdMap();
#else
return class_properties;
#endif
    }
    std::string getCategory(std::string key)
    {
        return class_properties[key];
    }

    bool infoEquals( std::string key, std::string value )
    {
        return class_properties[key] == value;
    }



    const std::string& getClassName()
    {
        return class_properties["classname"];
    }
    const std::string& getCategory()
    {
        return class_properties["category"];
    }
    ConstructFunc getCtor0() const
    {
        return ctor0_func;
    }
    ConstructFunc getCtor1() const
    {
        return ctor1_func;
    }
    ConstructFunc getCtor2() const
    {
        return ctor2_func;
    }

    //here is a way to get an object without using SOMEObj

    template < class BaseClass >
    BaseClass* construct()
    {
        BaseClass * ret_ptr = 0;
        BaseClass* (*ctor0)() = (BaseClass * (*)())ctor0_func;
        if (ctor0 != NULL)
        {
            ret_ptr = (*ctor0)();
        }
        return ret_ptr;
    }

    template < class BaseClass >
    void deduce_construct(BaseClass** dest_ptr)
    {
        BaseClass* (*ctor0)() = (BaseClass * (*)())ctor0_func;
        if (ctor0 != NULL)
            *dest_ptr = (*ctor0)();
        else
            *dest_ptr = NULL;
    }



    template < class BaseClass, typename ParamType1 >
    BaseClass* construct(ParamType1& a)
    {
        BaseClass* ret_ptr = 0;
        BaseClass* (*ctor1)(ParamType1&) = (BaseClass * (*)(ParamType1&))ctor1_func;
        if (ctor1 != NULL)
        {
            ret_ptr = (*ctor1)(a);
        }
        return ret_ptr;
    }


    template < class BaseClass, typename ParamType1, typename ParamType2 >
    BaseClass* construct(ParamType1& a, ParamType2& b)
    {
        BaseClass* ret_ptr = 0;
        BaseClass* (*ctor2)(ParamType1&, ParamType2&) = (BaseClass * (*)(ParamType1&, ParamType2&))ctor2_func;
        if (ctor2 != NULL)
        {
            ret_ptr = (*ctor2)(a, b);
        }
        return ret_ptr;
    }

private:
#ifdef _MSC_VER
    StringMap class_properties;
#else
    std::map < std::string, std::string > class_properties;
#endif

    ConstructFunc ctor0_func;
    ConstructFunc ctor1_func;
    ConstructFunc ctor2_func;

};

} //namespace SOME

#endif //SOME_class_properties_HEADER

---