PySimObjectStub.h

Go to the documentation of this file.

#ifndef PySimObjectStub_H_
#define PySimObjectStub_H_

#include "pcsim_hash.h"

#include <utility>
using   std::pair;
using std::make_pair;

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

#include "SimObject.h"
#include "SpikeSender.h"
#include "PCSIMException.h"

class PySimObjectStub : public SimObject, public MultipleOutputSpikeSender
{
    SIMOBJECT( PySimObjectStub , AdvancePhase::One )

public:
    typedef hash_map< size_t, SimObject::PortType, PCSIM::hash<size_t> > port_list_t;

    PySimObjectStub() :
            n_analog_input_ports(0),
            n_analog_output_ports(0),
            n_spiking_input_ports(0),
            n_spiking_output_ports(0)
    {
        
    }
    ;

    virtual ~PySimObjectStub()
    {}
    ;

    virtual void defineOutputPort(port_t p, SimObject::PortType port_type)
    {
        pair< port_list_t::iterator, bool > r = output_ports.insert(make_pair(p, port_type));
        r.first->second = port_type;
        if (r.second) {
            if (port_type == spiking) {
                n_spiking_output_ports ++;
                defineSpikeOutputPort(p);
            } else if (port_type == analog)
                n_analog_output_ports ++;
        }
    }

    virtual void defineInputPort(port_t p, SimObject::PortType port_type)
    {
        pair< port_list_t::iterator, bool > r = input_ports.insert(make_pair(p, port_type));
        r.first->second = port_type;
        if (r.second) {
            if (port_type == spiking)
                n_spiking_input_ports ++;
            else if (port_type == analog)
                n_analog_input_ports ++;
        }
    }

    virtual int nSpikeInputPorts() const
    {
        return n_spiking_input_ports;
    };

    virtual int nSpikeOutputPorts() const
    {
        return n_spiking_output_ports;
    };

    virtual int nAnalogInputPorts() const
    {
        return n_analog_input_ports;
    };

    virtual int nAnalogOutputPorts() const
    {
        return n_analog_output_ports;
    };

    virtual SimObject::PortType outputPortType(port_t p) const
    {
        port_list_t::const_iterator it;
        if ((it = output_ports.find(p)) != output_ports.end())
            return it->second;
        else
            return undefined;
    };

    virtual SimObject::PortType inputPortType(port_t p) const
    {
        port_list_t::const_iterator it;
        if ((it = input_ports.find(p)) != input_ports.end())
            return it->second;
        else
            return undefined;
    };

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


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


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

    //@

    //


    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;
    };
    
    /* 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;
    }


    //


    virtual double getAnalogOutput(analog_port_id_t port = 0) const
    {
        return 0;
    };

    virtual void setAnalogInput(double value, analog_port_id_t port = 0)
    {
        NOOP
    };
    
    virtual bool owned_by_net()
    {
      return false;     
    }
    

    void setSpike(port_t p, AdvanceInfo &ai )
    {
        getSpikePort(p)->setSpike( ai );
    };

protected:

    port_list_t output_ports;
    port_list_t input_ports;

    int n_analog_input_ports;
    int n_analog_output_ports;
    int n_spiking_input_ports;
    int n_spiking_output_ports;

};

#endif /*PySimObjectStub_H_*/

---