ScheduledEventsQueue.h

#ifndef ScheduledEventsQueue_H_
#define ScheduledEventsQueue_H_

#include "globals.h"

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

#include <list>
using std::list;

#include <vector>
using std::vector;

#include <queue>
using std::priority_queue;

#include <assert.h>


class ScheduledEventsQueue
{

public:

    /* \param chunkSize Constant used for internal memory management.
     *                   Should increase with increasing
     *                   expected number of spikes.
     */
    ScheduledEventsQueue(int chunkSize = EVENT_BUFFER_CHUNK_SIZE );

    virtual ~ScheduledEventsQueue();


    void scheduleEvent(event_target_group_id_t etg, Time t);

        struct Node
        {
                event_target_group_id_t etg;
                Time time;
                Node *next;
        };

        class NodeCompare {
        public:
                bool operator()(Node const * left, Node const * right) const {
                        return left->time > right->time;
                }
        };

    inline Node * top();

    Time topTime();

    inline void pop();


    void reset();


    bool empty() const {
        return event_queue.empty();
    }

protected:

    void init();

    priority_queue<Node*, vector<Node*>, NodeCompare > event_queue;

    Node *getFreeNode(void);

    vector< Node* > chunkBuffer;

    Node *currentFreeChunk;

    int  nextFreeNodeIdx;

    size_t nextFreeChunkIdx;

    Node* recycledNodes;

    int chunkSize;

    double fillitup[32];
};

inline ScheduledEventsQueue::Node * ScheduledEventsQueue::top()
{
        return event_queue.top();
}

inline Time ScheduledEventsQueue::topTime()
{
        return event_queue.top()->time;
}


inline void ScheduledEventsQueue::pop()
{
        Node *n = event_queue.top();
        n->next = recycledNodes;
        recycledNodes = n;
        event_queue.pop();
}

inline void ScheduledEventsQueue::scheduleEvent(event_target_group_id_t etg, Time t)
{
        Node *n = getFreeNode();
        n->etg = etg;
        n->time = t;
        event_queue.push(n);
}



#endif /*ScheduledEventsQueue_H_*/