SimObjectPool.h

Go to the documentation of this file.

#ifndef SIMELEMENTPOOL_H_
#define SIMELEMENTPOOL_H_


#include "SimObject.h"

#include <vector>
using std::vector;

class SimObjectPool
{
public:

    SimObjectPool( int nTypes );

    virtual ~SimObjectPool();

    local_objectid_t addObject( SimObjectFactory const& objFactory, RandomEngine *rng  );

    local_objectid_t addObject( SimObjectFactory const& objFactory  );

    SimObject *getObject(object_type_t otype, local_objectid_t oid);


    void updateObjects( bool dtHasChanged, double dt );

    int numOfTypes() { return pool.size(); };

    int numOfObjects( object_type_t type );

    inline object_type_t getLastTypeId();

protected:
    typedef vector< vector< SimObject* > > eng_type_pool_t ;

public:

    // typedef vector<SimObject *>::const_iterator SimObjectIterator;
    class SimObjectIterator
    {
    public:
        SimObjectIterator( vector<SimObject*> *vec_=NULL, size_t idx_=0):
                vec(vec_), idx(idx_)
        { /*NOOP*/ };

        SimObject** operator->()
        {
            return &((*vec)[idx]);
        }

        SimObject* operator*()
        {
            return ((*vec)[idx]);
        }

        inline bool operator!=(const SimObjectIterator& other)
        {
            return ( idx != other.idx || vec!=other.vec );
        }

        inline SimObjectIterator& operator++()
        {
            idx++;
            return *this;
        }

        inline local_objectid_t getLocalID(void)
        {
            return idx;
        };

    private:
        vector<SimObject*> *vec;
        size_t idx;
    };



    inline SimObjectIterator beginObject(object_type_t type )
    {
        if( type < pool.size() ) {
            return SimObjectIterator( &(pool[type]), 0 );
        } else {
            return NULL;
        }
    }
    /* \param type Integer ID specifying the type of objects
     */
    inline SimObjectIterator endObject( object_type_t type )
    {
        if( type < pool.size() )
            return SimObjectIterator( &(pool[type]), pool[type].size() );
        else
            return NULL;
    }


protected:

    //inline local_objectid_t addObject( SimObject *o )
    //{
    //    return  addObject( o, o->getObjectTypeID() );
    //};

    local_objectid_t addObject(SimObject *o, object_type_t type);

    eng_type_pool_t pool;

private:
    bool fieldsOfSomeObjectChanged;

    SimObject::BlockAllocator _blockAllocator;


};

inline local_objectid_t SimObjectPool::addObject( SimObjectFactory const& objFactory, RandomEngine *rng )
{
    SimObject::setAllocator( _blockAllocator );
    return  addObject( objFactory.create( rng ), objFactory.getObjectTypeID() );
}

inline local_objectid_t SimObjectPool::addObject( SimObjectFactory const& objFactory  )
{
    SimObject::setAllocator( _blockAllocator );
    return  addObject( objFactory.create(), objFactory.getObjectTypeID() );
}

inline int SimObjectPool::numOfObjects( object_type_t type )
{
    if( type < pool.size() )
        return pool[type].size();
    else
        return 0;
}

inline object_type_t SimObjectPool::getLastTypeId()
{
    return pool.size()-1;
}

#endif /* SIMELEMENTPOOL_H_ */

---