SimObjectRegistry.h

Go to the documentation of this file.

#ifndef SIMOBJECTREGISTRY_H_
#define SIMOBJECTREGISTRY_H_

#include "SimEngine.h"
#include "pcsim_hash.h"
#include "PCSIMException.h"

namespace PCSIM {
    class ObjectRegistryException : public PCSIM::Exception {
        public:
            ObjectRegistryException( string method, string msg ) :  PCSIM::Exception( method, msg ) {}
            ;
            virtual string name() const {
                return string("PCSIM::ObjectRegistryException");
            };
    };
}

#include <typeinfo>
using std::type_info;

#include <map>
using std::map;

#include <string>
using std::string;

#include <limits>


class SimObjectRegistry {

    public:
        SimObjectRegistry();
        virtual ~SimObjectRegistry();

        class FirstIndexOf {
            public:
                static object_type_t AdvancePhase1;
                static object_type_t SpikeDriven;
                static object_type_t AdvancePhase2;
                static object_type_t NoAdvance;
        };

        object_type_t registerSimObject( SimObject *obj, AdvancePhase::enum_t phase, string const& name= string(""), string const& description = string("") );

        void finalize();
        size_t nRegisteredObjectTypes(void);

        SimObject const& getObject( object_type_t tid );
        SimObjectFactory const& getSimObjectFactory( string name );
        
    private:
        vector< vector< SimObject* > > reg_per_phase;
        vector< SimObject* > reg_orderd;
        hash_map< const char*, object_type_t > type_id_map;
        hash_map< string, SimObject*, PCSIM::hash<string> > name_factory_map;
        vector< SimObjectInformation* > simObjInfo;
};

inline size_t SimObjectRegistry::nRegisteredObjectTypes(void) {
    return reg_orderd.size();
}

extern SimObjectRegistry *theSimObjectRegistry;

object_type_t registerSimObject( SimObject *obj, AdvancePhase::enum_t phase, string const& name= string(""), string const& description = string("") );


#define REGISTER_SCALAR_FIELD( _class_, _type_, _field_, _desc_ ) \
        if( std::numeric_limits<_type_>::is_specialized ) \
           _class_::registerField( ScalarField< _type_ >( #_field_, _desc_, ( (char*)(&(_class_::model._field_))-(char*)(&_class_::model) ) ) );


#define BEGIN_REGISTER_OBJECT( T, desc, advtype )                                 \
        T T::model;                                                               \
        SimObjectInformation *T::simObjectInfo = NULL;                            \
        object_type_t T::type = 0;                                                \
        void T::registerSimObject() {                                             \
                T::type = ::registerSimObject(&T::model, advtype::enumval, #T, desc );\
        }                                                                         \
        void T::registerFields(void) {                                            \



#define END_REGISTER_OBJECT( T ) }

#endif /*SIMOBJECTREGISTRY_H_*/

---