ChannelInfo.h

#ifndef CHANNELINFO_H_
#define CHANNELINFO_H_

#include <list>
#include <omnetpp.h>
#include "AirFrame_m.h"

class ChannelInfo {

protected:

  typedef std::pair<simtime_t, AirFrame*> AirFrameTimePair;
  typedef std::list<AirFrameTimePair> AirFrameTimeList;
  typedef std::map<simtime_t, AirFrameTimeList > AirFrameMatrix;

  template<class C, class ItMatrix, class ItList>
  class BaseIntersectionIterator
  {
  public:
    C* intervals;

    simtime_t from;

    simtime_t to;

    ItMatrix endIt;

    ItList startIt;

    bool alreadyNext;

  public:

    BaseIntersectionIterator(C* airFrames, simtime_t from, simtime_t to) :
      intervals(airFrames), from(from), to(to)
    {
      // begin at the smallest end-time-entry fulfilling the intersection
      // condition 1
      endIt = intervals->lower_bound(from);

      if(endIt != intervals->end()) {
        startIt = endIt->second.begin();
      }
      //we are already pointing at the first unchecked interval
      alreadyNext = true;
    }

    AirFrame* next()
    {
      if(endIt == intervals->end())
        return 0;

      // "alreadyNext" indicates that some previous iterator function has
      // already increased the intern iterators to a yet unchecked values.
      // This happens after initialization of the iterator and when an
      // element is erased.
      if(alreadyNext)
        alreadyNext = false;
      else
        startIt++;


      while(endIt != intervals->end())
      {
        // while there are entries left at the current end-time
        while(startIt != endIt->second.end())
        {
          // check if this entry fulfilles the intersection condition
          // 2 (condition 1 is already fulfilled in the constructor by
          // the start-value of the end-time-iterator)
          if(startIt->first <= to) {
            return startIt->second;
          }
          startIt++;
        }

        endIt++;
        if(endIt == intervals->end())
          return 0;

        startIt = endIt->second.begin();

      }

      return 0;
    }
  };

  typedef BaseIntersectionIterator
        <const AirFrameMatrix,
         AirFrameMatrix::const_iterator,
         AirFrameTimeList::const_iterator> ConstIntersectionIterator;

  class IntersectionIterator:
      public BaseIntersectionIterator<AirFrameMatrix,
                      AirFrameMatrix::iterator,
                      AirFrameTimeList::iterator>
  {
  private:
    typedef BaseIntersectionIterator<AirFrameMatrix,
                     AirFrameMatrix::iterator,
                     AirFrameTimeList::iterator> Base;
  public:
    IntersectionIterator(AirFrameMatrix* airFrames,
               simtime_t from,
               simtime_t to) :
      Base(airFrames, from, to)
    {}

    void eraseAirFrame()
    {
      assert(endIt != intervals->end());
      assert(startIt != endIt->second.end());

      //erase AirFrame from list
      startIt = endIt->second.erase(startIt);

      //check if we've deleted the last entry in the list
      if(startIt == endIt->second.end())
      {
        //check if we deleted the only entry in the list
        if(endIt->second.empty()) {
          intervals->erase(endIt++); //delete list from map
        } else {
          endIt++;
        }

        //increase to a valid value if we are not done
        if(endIt != intervals->end()) {
          startIt = endIt->second.begin();
        }
      }
      alreadyNext = true;
    }
  };

  AirFrameMatrix activeAirFrames;

  AirFrameMatrix inactiveAirFrames;

  typedef std::map<AirFrame*, simtime_t> AirFrameStartMap;

  AirFrameStartMap airFrameStarts;

  simtime_t earliestInfoPoint;

  simtime_t recordStartTime;

public:
  typedef std::list<AirFrame*> AirFrameVector;

protected:
  void assertNoIntersections();


  void getIntersections( const AirFrameMatrix& airFrames,
               simtime_t from, simtime_t to,
               AirFrameVector& outVector) const;

  bool isIntersecting( const AirFrameMatrix& airFrames,
             simtime_t from, simtime_t to) const;

  void addToInactives(AirFrame* a, simtime_t startTime, simtime_t endTime);

  void deleteAirFrame(AirFrameMatrix& airFrames,
            AirFrame* a,
            simtime_t startTime, simtime_t endTime);

  simtime_t findEarliestInfoPoint();

  void checkAndCleanInterval(simtime_t startTime, simtime_t endTime);

  bool canDiscardInterval(simtime_t startTime, simtime_t endTime);

  void checkAndCleanFrom(simtime_t start) {
    //nothing to do
    if(inactiveAirFrames.empty())
      return;

    //take last ended inactive airframe as end of interval
    checkAndCleanInterval(start, inactiveAirFrames.rbegin()->first);
  }

public:
  ChannelInfo():
    earliestInfoPoint(-1),
    recordStartTime(-1)
  {}

  virtual ~ChannelInfo() {}

  void addAirFrame(AirFrame* a, simtime_t startTime);

  simtime_t removeAirFrame(AirFrame* a);

  void getAirFrames(simtime_t from, simtime_t to, AirFrameVector& out) const;

  simtime_t getEarliestInfoPoint()
  {
    assert(!isChannelEmpty() || earliestInfoPoint == -1);

    return earliestInfoPoint;
  }

  void startRecording(simtime_t start)
  {
    // clean up until old record start
    if(recordStartTime > -1) {
      recordStartTime = start;
      checkAndCleanInterval(0, recordStartTime);
    } else {
      recordStartTime = start;
    }
  }

  void stopRecording()
  {
    if(recordStartTime > -1) {
      simtime_t old = recordStartTime;
      recordStartTime = -1;
      checkAndCleanFrom(old);
    }
  }

  bool isRecording() const
  {
    return recordStartTime > -1;
  }

  bool isChannelEmpty() const {
    assert(recordStartTime != -1
         || activeAirFrames.empty() == airFrameStarts.empty());

    return airFrameStarts.empty();
  }
};

#endif /*CHANNELINFO_H_*/