ConnectionsProjection.h

Go to the documentation of this file.

#ifndef CONNECTIONSPROJECTION_H_
#define CONNECTIONSPROJECTION_H_

#include "SimNetwork.h"
#include "SimObject.h"
#include "SimObjectPopulation.h"
#include "WiringMethodSelector.h"
#include "ConnectionIterator.h"

#include <utility>

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

using std::pair;
using std::make_pair;


class ConnectionsProjection {
    public:


        ConnectionsProjection(
            shared_ptr<SimObjectPopulation> source,
            shared_ptr<SimObjectPopulation> destination,
            SimObjectFactory &connector,
            ConnectionIterator &iterator,
            WiringMethod *wiring = NULL,
            bool collectIDs = false,
            bool collectPairs = false);



        ConnectionsProjection(
            shared_ptr<SimObjectPopulation> source,
            shared_ptr<SimObjectPopulation> destination,
            ConnObjectFactory &connector,
            ConnectionIterator &iterator,
            WiringMethod *wiring = NULL,
            bool collectIDs = false,
            bool collectPairs = false);


        ConnectionsProjection(
            const SimObjectPopulation &source,
            const SimObjectPopulation &destination,
            ConnectionIterator &iterator,
            WiringMethod *wiring = NULL,
            bool collectPairs = false);


        ConnectionsProjection(
            const SimObjectPopulation &source,
            const SimObjectPopulation &destination,
            Time &delay,
            bool collectPairs = false);

        virtual ~ConnectionsProjection() { /*NOOP*/ };


        SimObject::ID::Packed operator [] (int idx) const {
            if (collectIDs)
                return (*connector_ids)[idx];
            else {
                return SimObject::ID().packed(); // invalid sim object id
            }
        };


        SimObject::ID operator() (int idx) const {
            if (collectIDs)
                return SimObject::ID((*connector_ids)[idx]);
            else {
                return SimObject::ID::Invalid; // invalid sim object id
            }
        };


        pair<SimObject::ID, SimObject::ID> prePostPair(int idx) const {
            if (collectPairs)
                return (*connectPairs)[idx];
            else
                return make_pair(SimObject::ID(), SimObject::ID()); // invalid id pair
        }
        ;


        SimObject * object(int idx) const {
            if (collectIDs)
                return net->object((*connector_ids)[idx]);
            else
                return NULL;
        };

        const vector<SimObject::ID::Packed> & idVector() const {
            return *connector_ids;
        };

        size_t size() const {
            if (collectIDs)
                return connector_ids->size();
            else
                return (*connector_ids)[0];
        };

    protected:
        SimNetwork *net;

        bool collectIDs;

        bool collectPairs;

        SimObject::ID::Vector connector_ids;

        WiringMethod::ConnectPairsVector connectPairs;

};

#endif /*CONNECTIONSPROJECTION_H_*/

---