SimObject.h

Go to the documentation of this file.

#ifndef SIMOBJECT_H_
#define SIMOBJECT_H_

#include "SpikeEvent.h"
#include "SimObjectCloneFactory.h"
#include "ScalarField.h"
#include "FieldRegistry.h"
#include "SimObjectInformation.h"
#include "AdvancePhase.h"
#include "AdvanceInfo.h"

#ifndef SWIG

#include <iostream>
using std::ostream;

#endif

#include <vector>

#include <limits>

#include <boost/shared_ptr.hpp>
using boost::shared_ptr;


#define ADVANCEFLAG_HASSPIKED 1


#define ADVANCEFLAG_DEACTIVATE 2


#define SPIKEHITFLAG_ACTIVATE 1


#define RESETFLAG_ACTIVATE 1

class SimObject;
class SimObjectRegistry;
class SimNetwork;
class SingleThreadSimEngine;
class SimObjectIDSortedVector;
 
#include "RandomEngine.h"

#ifndef SWIG
#define SIMOBJECT( T, A ) \
private: \
        friend struct A; \
protected: \
        static object_type_t type; \
        friend class SimObjectRegistry; \
        virtual void setObjectTypeID(object_type_t tid) { type = tid; } \
        static SimObjectInformation *simObjectInfo; \
        virtual void setSimObjectInformation( SimObjectInformation *info ) { simObjectInfo = info; }; \
public: \
        virtual SimObjectInformation const*getSimObjectInformation(void) { return simObjectInfo; }; \
public: \
        typedef SimObjectCloneFactory<T> CloneFactory; \
        static T model; \
        virtual SimObject* create(void) const { T* o = new T(*this); o->deepCopy(this); return o; }; \
        virtual SimObject* create(RandomEngine *) const { T* o = new T(*this); o->deepCopy(this); return o; }; \
        virtual object_type_t getObjectTypeID(void) const { return type; }; \
        static object_type_t objectTypeID(void) { return type; }; \
        static void registerField( Field const& f ) { simObjectInfo->getFieldRegistry().registerField(f); }; \
        static void registerFields(void); \
        static void registerSimObject(void); \

#endif

class SimObject : public SimObjectFactory
{
public:

    //


#ifndef SWIG
    class ID
    {
    public :

        typedef long long Packed;

        typedef shared_ptr< std::vector< Packed > > Vector;

        explicit ID( nodeid_t nid,  engineid_t eid, object_type_t tid, local_objectid_t oid ) :
                localid(oid), node(nid), type(tid), eng(eid)
        { /* NOOP */ };

        ID(void) :
                localid(INVALID_LOCAL_OBJECT_ID), node(INVALID_NODE_ID), type(INVALID_OBJECT_TYPE_ID), eng(INVALID_LOCAL_ENGINE_ID)
        { /* NOOP */ };

        typedef SimObjectIDSortedVector SortedVector;

        explicit ID( const Packed &pid )
        {
            *this = *((const ID*)(&pid));
        };

        static SimObject::ID makeID( const Packed &pid )
        {
            return *((ID*)(&pid));
        };

        bool operator<(const ID &other) const
        {
            if (this->node == other.node) {
                if (this->eng == other.eng) {
                    if (this->type == other.type) {
                        return this->localid < other.localid;
                    }
                    return this->type < other.type;
                }
                return this->eng < other.eng;
            }
            return this->node < other.node;
        }
        
        bool isInTheSameSTEngineWith(const ID &other) const
        {
                return ( this->eng == other.eng ) &&
                   ( this->node == other.node );        
        }

        local_objectid_t localid ;

        nodeid_t node ;

        object_type_t type;

        engineid_t eng ;

        Packed packed();
        
        bool operator==(const ID& other) const;

        bool operator!=(const ID& other) const;

        string toString(void) const;

        static const ID Invalid;
    };

#endif

    //


public:
    SimObject(engineid_t eid=0);

    virtual ~SimObject();

    //@

    //


public:
    typedef enum { spiking, analog, undefined } PortType;
    virtual int nSpikeInputPorts() const { return 0; };
    virtual int nSpikeOutputPorts() const { return 0; };
    virtual int nAnalogInputPorts() const { return 0; };
    virtual int nAnalogOutputPorts() const { return 0; };
    virtual PortType outputPortType(port_t p) const { return undefined; };
    virtual PortType inputPortType(port_t p) const { return undefined; };

    //@

    //


    virtual int init(InitializeInfo *ii) { return 0; };

    virtual int check(void) { return 0; };

    /* \param dt The simulation time step with in seconds.
    */
    virtual int adjust( double dt ) { return 0; };

    virtual int reset( double dt ) { return 0; };


    virtual int advance( AdvanceInfo const& ) { return 0; };

#ifndef SWIG
    //


    virtual void incoming(SimObject *sender, ID const& snd, ID const& self, SimNetwork & net) { 
        incoming(sender);
    };

    virtual void outgoing(SimObject *receiver, ID const& rec, ID const& self, SimNetwork & net ) {
        outgoing(receiver); 
    };
    

    virtual void outgoing(SimObject *receiver) {};
    

    virtual void incoming(SimObject *sender) {};
    

    
    //


public:

    virtual int spikeHit( spikeport_t port, SpikeEvent const& spike ) { return 0; };

    /* This function should return the amount of delay for incoming spike
    * messages which the SimObject wants to be handled by the global spike
    * exchange mechanism.
    */
    virtual double getManagedDelay() const { return 0; }


    //


#endif

public:
    
#ifndef SWIG
    virtual int getFieldOffset(string const& fieldname);
#endif
    
    virtual double getAnalogOutput(analog_port_id_t port = 0) const { return 0; };

    virtual void setAnalogInput(double value, analog_port_id_t port = 0) { /* NOOP */ };

#ifndef SWIG


    virtual bool owned_by_net() {
        return true;
    }
    
    

    virtual SimObject * getChainedObject() {
        return NULL;
    }
    
    virtual bool toBeActivated()
    {
        return false;   
    }
    
    virtual SimObject * getInputTarget(int target_id = 0) {
                return this;
        }
        
        virtual void deepCopy(const SimObject *obj)
        {               
        }

    //


protected:
    friend class SimObjectRegistry;
    static object_type_t type;
    virtual void setObjectTypeID(object_type_t tid) { /* NOOP */ };

    static SimObjectInformation *simObjectInfo;
    virtual void setSimObjectInformation( SimObjectInformation *info ) { simObjectInfo = info; };
public:
    virtual SimObjectInformation const*getSimObjectInformation(void) { return simObjectInfo; };
    Field const* findField(string const & fieldname);
    void setScalarField( Field const*f, double v);
    double getScalarField( Field const*f);

    //


public:
    //static const SingleThreadSimEngine *getSimEngine(void);

    //static const SimNetwork &getSimNetwork(void);

    //static const Time dt(void);

    //static const Time &t(void);

protected:
    //friend class SingleThreadSimEngine;
    //static void setSimEngine( SingleThreadSimEngine * eng );

private:

    // static boost::thread_specific_ptr<SingleThreadSimEngine> threadSafeEnginePtr;

    // static void noCleanUp(SingleThreadSimEngine *e) { };

    //


    //

    
public:

    class BlockAllocator
    {
    public:
        BlockAllocator( size_t blockSize = SIMOBJECT_ALLOCATOR_BLOCK_SIZE );
        ~BlockAllocator();
        void *allocate( size_t size );
    private:
        size_t blk_sz;
        std::vector< void* > mem_block;
        char *free_pos;
        size_t num_free_bytes;
    };

    void static setAllocator( BlockAllocator & ba );

    void *operator new(size_t sz);
    void operator delete(void *, size_t);

    void *operator new[](size_t sz);
    void operator delete[](void *, size_t);

private:

    static BlockAllocator defaultAllocator;
    static BlockAllocator *currentAllocator;

#endif
    
};

#ifndef SWIG

typedef std::vector< SimObject* > SpikeReceiverList;

ostream& operator<<(ostream &s, const SimObject::ID &id);

#endif

#endif /*SIMOBJECT_H_*/

---