ConnObjectValueGenerator.h

Go to the documentation of this file.

#ifndef CONNOBJECTVALUEGENERATOR_H_
#define CONNOBJECTVALUEGENERATOR_H_

#include "SimObjectPopulation.h"
#include "RandomDistribution.h"

class ConnObjectValueGenerator
{
public:
    ConnObjectValueGenerator();

    virtual ~ConnObjectValueGenerator();


    virtual void init(const SimObjectPopulation &src_pop,
                      const SimObjectPopulation &dst_pop,
                      RandomEngine *rnd=NULL) = 0;


    virtual double generate(size_t src_idx, size_t dst_idx, RandomEngine *rnd) = 0;

    virtual ConnObjectValueGenerator* clone(void) const = 0;

};


/*
class PyConnObjectValueGenerator
{
public:
    PyConnObjectValueGenerator();

    virtual ~PyConnObjectValueGenerator();

    virtual void init( SimObjectPopulation &src_pop, SimObjectPopulation &dst_pop, RandomEngine *rnd=NULL )
    {
        //NOOP
    };

    virtual double generate( size_t src_idx, size_t dst_idx, RandomEngine *rnd )
    {
        return 0.0;
    };
};
*/
template< typename S, typename D >
class ConnObjectValueGeneratorSpecialization : public ConnObjectValueGenerator
{
public:
    ConnObjectValueGeneratorSpecialization()
        : m_sourcePopulation(NULL), m_destinationPopulation(NULL), rnd_eng(NULL)
    {}


    virtual void init( SimObjectPopulation const& src, SimObjectPopulation const& dst, RandomEngine *rnd=NULL )
    {
        m_sourcePopulation = dynamic_cast< const S* >( &src );
        if( m_sourcePopulation == NULL ) {
            throw( PCSIM::ConstructionException( boost::str( boost::format("ConnObjectValueGeneratorSpecialization<%1%>::init") % typeid(S).name() ),
                                                 boost::str( boost::format("Source population must be a %1% or derived type (not %2%).") % typeid(S).name() % typeid(src).name() ) ) );
        }
        m_destinationPopulation = dynamic_cast< const D* >( &dst );
        if( m_destinationPopulation == NULL ) {
            throw( PCSIM::ConstructionException( boost::str( boost::format("ConnObjectValueGeneratorSpecialization<%1%>::init") % typeid(D).name()  ),
                                                 boost::str( boost::format("Destination population must be a %1% or derived type (not %2%).")% typeid(D).name() % typeid(dst).name() ) ) );
        }

        rnd_eng=rnd;
    };

    virtual double generate( size_t src_idx, size_t dst_idx, RandomEngine *rnd )
    {
        return 0.0;
    };

protected:
    const S* m_sourcePopulation;
    const D* m_destinationPopulation;
    RandomEngine *rnd_eng;
};

class PlainConnObjectValueGenerator
    : public ConnObjectValueGeneratorSpecialization<SimObjectPopulation, SimObjectPopulation>
{
};

#include "SpatialSimObjectPopulation.h"

class SpatialConnObjectValueGenerator
    : public ConnObjectValueGeneratorSpecialization<SpatialSimObjectPopulation, SpatialSimObjectPopulation>
{
};

#include "SpatialFamilyPopulation.h"

class FamilyConnObjectValueGenerator
    : public ConnObjectValueGeneratorSpecialization<SpatialFamilyPopulation, SpatialFamilyPopulation>
{
};

#include "AugmentedSpatialPopulation.h"

class AttributeConnObjectValueGenerator 
    : public ConnObjectValueGeneratorSpecialization<AugmentedSpatialPopulation, AugmentedSpatialPopulation>
{
};

#endif /*CONNOBJECTVALUEGENERATOR_H_*/

---