IntraProcessCounter.h

// -*- indent-tabs-mode: nil -*-

// IntraProcessCounter.h

#ifndef __IntraProcessCounter__
#define __IntraProcessCounter__

#include <map>
#include <queue>

#include <arc/Thread.h>

#include <arc/Counter.h>

namespace Arc {


  class IntraProcessCounter
    : public Counter {

  public:


    IntraProcessCounter(int limit, int excess);


    virtual ~IntraProcessCounter();


    virtual int getLimit();


    virtual int setLimit(int newLimit);


    virtual int changeLimit(int amount);



    virtual int getExcess();


    virtual int setExcess(int newExcess);


    virtual int changeExcess(int amount);


    virtual int getValue();


    virtual CounterTicket reserve(int amount = 1,
                                  Glib::TimeVal duration = ETERNAL,
                                  bool prioritized = false,
                                  Glib::TimeVal timeOut = ETERNAL);

  protected:



    virtual void cancel(IDType reservationID);


    virtual void extend(IDType& reservationID,
                        Glib::TimeVal& expiryTime,
                        Glib::TimeVal duration = ETERNAL);

  private:


    IntraProcessCounter(const IntraProcessCounter& unique);


    void operator=(const IntraProcessCounter& unique);


    int unsafeGetValue();


    int unsafeCancel(IDType reservationID);


    IDType unsafeReserve(int amount, Glib::TimeVal duration);


    Glib::TimeVal unsafeGetNextExpiration();


    int limit;


    int excess;


    int value;


    IDType nextReservationID;


    std::map<IDType, int> reservations;


    std::priority_queue<ExpirationReminder> selfExpiringReservations;


    Glib::Mutex synchMutex;


    Glib::Cond synchCond;

  };

}

#endif