Registry.h

Go to the documentation of this file.

#ifndef REGISTRY_H
#define REGISTRY_H

#include <nmstl_util.h>
#include "Exceptions.h"

BOREALIS_NAMESPACE_BEGIN;

template<typename BaseClass = void, typename Key = string> class RegistryInfo;

template<typename Key>
class RegistryInfo<void, Key>
{
  protected:
    RegistryInfo(string class_name, Key key) :
        _class_name(class_name), _key(key.empty() ? class_name : key) {}

  public:
    virtual ~RegistryInfo() {}

    string getClassName() const { return _class_name; }
    Key getKey() const { return _key; }

    virtual string as_string() const
    {
        return( _class_name == to_string( _key )
                                 ? _class_name
                                 : ( to_string( _key ) + "->" + _class_name ));
    }

  private:
    string _class_name;
    Key    _key;
};


template<typename BaseClass, typename Key>
class RegistryInfo : public RegistryInfo<void, Key>
{
  protected:
    RegistryInfo(string class_name, Key key) :
        RegistryInfo<void, Key>(class_name, key)
    {}

  public:
    virtual BaseClass *instantiate() const = 0;
};



template<typename BaseClass, typename Subclass, typename Key = string>
class SimpleRegistryInfo : public RegistryInfo<BaseClass>
{
  public:
    SimpleRegistryInfo( Key  key = Key() ) :
        RegistryInfo<BaseClass>( to_string( typeid( Subclass )), key) {}

    virtual BaseClass *instantiate() const { return( new Subclass ); }
};


#define AURORA_DECLARE_REG_CLASS(BaseClass, Subclass) \
  private: \
    static const SimpleRegistryInfo<BaseClass, Subclass> _aurora_info; \
    static bool _aurora_registered;

#define AURORA_DEFINE_REG_CLASS(BaseClass, Subclass) \
    const SimpleRegistryInfo<BaseClass, Subclass> Subclass::_aurora_info; \
    bool Subclass::_aurora_registered = \
        (Borealis::Registry<BaseClass>::get().add(_aurora_info), true);

#define AURORA_DEFINE_REG_CLASS_WITH_KEY(BaseClass, Subclass, Key) \
    const SimpleRegistryInfo<BaseClass, Subclass> Subclass::_aurora_info(Key); \
    bool Subclass::_aurora_registered = \
        (Borealis::Registry<BaseClass>::get().add(_aurora_info), true);


#define AURORA_DECLARE_REG_CLASS_WITH_INFO(RegistryClass, Subclass) \
  private: \
    static bool _aurora_registered;

#define AURORA_DEFINE_REG_CLASS_WITH_INFO(RegistryClass, Subclass, info) \
    bool Subclass::_aurora_registered = \
        (Borealis::RegistryClass::get().add(info), true);




template< typename  BaseClass,
          typename  _Info = RegistryInfo<BaseClass>,
          typename  Key   = string
        >
class Registry
{
    typedef  Registry<BaseClass, _Info, Key>  Me;
    typedef  map<Key, const _Info *>          InfoMap;

  public:
    typedef  _Info  Info;

    static Registry<BaseClass, Info>  &get()
    {
        static Me it;
        return it;
    }

    Registry() : _my_type( "Registry<" + to_string( typeid( BaseClass )) + ">" )
    {
        INFO   << "Creating " << _my_type;
    }

    void add( const Info &info )
    {
        DEBUG << "Adding " << info << " to " << _my_type;

        _infos[ info.getKey() ] = &info;
    }

    string as_string() const
    {
        string ret;
        ret << _my_type << "{";

        for ( typename InfoMap::const_iterator  i  = _infos.begin();
                                                i != _infos.end(); ++i )
        {
            if ( i != _infos.begin() )
            {   ret << ",";
            }

            ret << *(i->second);
        }

        ret << "}";

        return( ret );
    }

    const Info *forKey( Key  key ) const
    {
        return( lookup( _infos, key ));
    }

  private:
    InfoMap  _infos;
    string   _my_type;
};

BOREALIS_NAMESPACE_END;

#endif                            // REGISTRY_H

---