PropagatedSpikeBuffer.h

#ifndef PROPAGATEDSPIKEBUFFER_H_
#define PROPAGATEDSPIKEBUFFER_H_

// IMPORTED FROM PCSIM SOURCE CODE  http://www.lsm.tugraz.at/pcsim/

//#include "globaldefinitions.h"
//#include "SimParameter.h"

#include <iostream>
using std::cout;
using std::endl;

#include <list>
using std::list;

#include <vector>
using std::vector;

#include <assert.h>

typedef int spikegroupid_t ;

typedef unsigned short int delay_t;

typedef unsigned short int delaystep_t;

#define PROPAGATED_SPIKE_BUFFER_CHUNK_SIZE 1024

class PropagatedSpikeBuffer
{

public:


    PropagatedSpikeBuffer(int minDelay,
                          int maxDelay,
                          int chunkSize = PROPAGATED_SPIKE_BUFFER_CHUNK_SIZE );

    virtual ~PropagatedSpikeBuffer();


    void scheduleSpikeTargetGroup(spikegroupid_t stg, delaystep_t delay);

    struct StgNode
    {
        spikegroupid_t stg;
        delaystep_t delay;
        StgNode *next;
    };

    class const_iterator
    {
    public:
        const_iterator(): node(NULL) {};
        const_iterator(StgNode *n): node(n) {};

        StgNode* operator->() { return node; }
        spikegroupid_t operator*() { return node->stg; }

        bool operator==(const const_iterator& other) { return ( this->node == other.node ); }

        bool operator!=(const const_iterator& other) { return ( this->node != other.node ); }

        inline const_iterator& operator++() { node = node->next; return *this; }

    private:
        StgNode *node;
    };


    const_iterator beginSpikeTargetGroups(int stepOffset = 0)
    {
#ifdef DEBUG
        // this assertion fails if stepOffset < -length()
        if (const_iterator( ringBufferFront[ (currIdx + stepOffset + length() ) % length()  ] ) != NULL)
            //        cout << "in beginSTG currT=" << currT << " stepOffset=" << stepOffset << endl;
            assert( (currIdx + stepOffset + length() ) % length() >= 0 );
#endif
        return const_iterator( ringBufferFront[ (currIdx + stepOffset + length() ) % length()  ] );
    };

    const_iterator endSpikeTargetGroups()
    {
        return const_iterator(NULL);
    };

    void nextTimeStep();


    void reset(int minDelay, int maxDelay);

    inline size_t length() { return ringBufferFront.size(); };

    // PropagatedSpikeBuffer & operator=(const PropagatedSpikeBuffer &src);

private :

    void init(size_t maxDelaySteps);

    StgNode *getFreeNode(void);

    int currIdx ;

    vector< StgNode* > ringBufferFront;

    vector< StgNode* > ringBufferBack;

    vector< StgNode* > chunkBuffer;

    StgNode *currentFreeChunk;

    int  nextFreeSrgNodeIdx;

    size_t nextFreeChunkIdx;

    StgNode* recycledNodes;

    int chunkSize;

    int currT;

    double fillitup[32];
};

#endif /*PROPAGATEDSPIKEBUFFER_H_*/