ChannelInfo.h

#ifndef CHANNELINFO_H_
#define CHANNELINFO_H_

#include <list>
#include <map>
#include <omnetpp.h>

#include "MiXiMDefs.h"
#include "MiXiMAirFrame.h"

class MIXIM_API ChannelInfo {
public:
    typedef MiximAirFrame  airframe_t;
  typedef airframe_t*    airframe_ptr_t;
  static const_simtime_t invalidSimTime;

  struct airframe_filter_fctr {
    virtual ~airframe_filter_fctr() {}

    virtual bool pass(const airframe_ptr_t& a) const {
      return true;
    }
    };
protected:
  typedef std::map<simtime_t, std::multimap<simtime_t, airframe_ptr_t> > AirFrameMatrix;

  struct c_min_start_time_fctr {
    bool operator() (const AirFrameMatrix::value_type& a, const AirFrameMatrix::value_type& b) {
      return a.second.key_comp()(a.second.begin()->first, b.second.begin()->first);
    }
  };

  template<typename C, typename ItMatrix = typename C::const_iterator, typename ItSubMatrix = typename C::mapped_type::const_iterator>
  class BaseIntersectionIterator
  {
  public:
    typedef typename ItSubMatrix::value_type value_type;
    typedef typename ItSubMatrix::reference  reference;
    typedef typename ItSubMatrix::pointer    pointer;

    typedef BaseIntersectionIterator<C, ItMatrix, ItSubMatrix> iterator;

    typedef std::bidirectional_iterator_tag iterator_category;
    typedef ptrdiff_t                       difference_type;

  protected:
    friend class ChannelInfo;
    typedef BaseIntersectionIterator<C, ItMatrix, ItSubMatrix> _Self;
    //typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr;
    //typedef const _Rb_tree_node<_Tp>*           _Link_type;

    C* intervals;

    simtime_t_cref from;

    simtime_t_cref to;

    ItMatrix endIt;

    ItSubMatrix startIt;
    ItSubMatrix startItEnd;

      _Self& jumpToNextValid(ItMatrix endItEnd)
      {
      for (; endIt != endItEnd; startIt = endIt->second.begin()) {
        // while there are entries left at the current end-time
        if (startIt != startItEnd) {
          // check if this entry fulfills the intersection condition
          // 2 (condition 1 is already fulfilled in the constructor by
          // the start-value of the end-time-iterator)
          return *this;
        }
        if (++endIt != endItEnd) {
          startItEnd = endIt->second.upper_bound(to);
        }
      }

      intervals = NULL;
      return *this;
      }
  public:
    BaseIntersectionIterator(C* airFrames, simtime_t_cref from, simtime_t_cref to) :
      intervals(airFrames), from(from), to(to), endIt(), startIt(), startItEnd()
    {
      // begin at the smallest end-time-entry fulfilling the intersection
      // condition 1
      if (intervals) {
        endIt = intervals->lower_bound(from);
        if(endIt != intervals->end()) {
          startIt    = endIt->second.begin();
          startItEnd = endIt->second.upper_bound(to);
          jumpToNextValid(intervals->end());
        }
        else {
          intervals = NULL;
          startIt   = startItEnd;
        }
      }
      else {
        startIt = startItEnd;
      }
      //we are already pointing at the first unchecked interval
    }
    BaseIntersectionIterator(const iterator& __it) :
      intervals(__it.intervals), from(__it.from), to(__it.to), endIt(__it.endIt), startIt(__it.startIt),  startItEnd(__it.startItEnd)
    { }

    reference
      operator*() const
    {
      if(intervals == NULL || endIt == intervals->end() || startIt == startItEnd)
        return NULL;
      return startIt.operator*();
    }

    pointer
      operator->() const
    {
      if(intervals == NULL || endIt == intervals->end() || startIt == startItEnd)
        return NULL;
      return startIt.operator->();
    }

    _Self&
    operator++()
    {
      if (!intervals)
        return *this;

      const ItMatrix endItEnd = intervals->end();
      if(endIt == endItEnd) {
        intervals = NULL;
        return *this;
      }

      if (startIt != startItEnd)
        ++startIt;

      return jumpToNextValid(endItEnd);
    }

    _Self
    operator++(int)
      {
      _Self __tmp = *this;
      ++(*this);
      return __tmp;
      }

      bool
      operator==(const _Self& __x) const
      {
        if (intervals == NULL) {
          if (__x.intervals == NULL)
            return true;
          return (__x.endIt == __x.intervals->end() || __x.startIt == __x.startItEnd); // we have no next element
        }
        if (__x.intervals == NULL) {
          return (endIt == intervals->end() || startIt == endIt->second.end()); // we have no next element
        }
        if( (endIt == intervals->end() && __x.endIt == __x.intervals->end()) || (startIt == startItEnd && __x.startIt == __x.startItEnd) )
          return true;
        return intervals == __x.intervals && from == __x.from && to == __x.to && endIt == __x.endIt && startIt == __x.startIt && startItEnd == __x.startItEnd;
      }

      bool
      operator!=(const _Self& __x) const
      { return !(*this == __x); }
  };

  typedef BaseIntersectionIterator<const AirFrameMatrix,
                   AirFrameMatrix::const_iterator,
                   AirFrameMatrix::mapped_type::const_iterator> const_iterator;

  const static const_iterator cConstItEnd;

  const_iterator end() const {
    return cConstItEnd;
  }

  typedef BaseIntersectionIterator<AirFrameMatrix,
                   AirFrameMatrix::iterator,
                   AirFrameMatrix::mapped_type::iterator> iterator;

  const static iterator cItEnd;
  iterator end() {
    return cItEnd;
  }

  void erase(const iterator& __position) {
    assert(__position.endIt   != __position.intervals->end());
    assert(__position.startIt != __position.startItEnd);

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

    //check if we deleted the only entry in the list
    if(__position.endIt->second.empty()) {
      __position.intervals->erase(__position.endIt); //delete list from map
    }
  }

  AirFrameMatrix activeAirFrames;

  AirFrameMatrix inactiveAirFrames;

  typedef std::map<long, simtime_t> AirFrameStartMap;

  AirFrameStartMap airFrameStarts;

  simtime_t recordStartTime;

public:
  typedef std::list<airframe_ptr_t> AirFrameVector;

protected:
  void assertNoIntersections() const;


  static void getIntersections( const AirFrameMatrix&     airFrames
                                , simtime_t_cref            from
                                , simtime_t_cref            to
                                , AirFrameVector&           outVector
                                , airframe_filter_fctr *const fctrFilter = NULL)
  {
      const_iterator itEnd = cConstItEnd;
      for (const_iterator it(&airFrames, from, to); it != itEnd; ++it) {
          if (fctrFilter != NULL) {
              if (!fctrFilter->pass(it->second))
                  continue;
          }
          outVector.push_back(it->second);
      }
  }

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

  void addToInactives(airframe_ptr_t a, simtime_t_cref startTime, simtime_t_cref endTime);

  static void deleteAirFrame(AirFrameMatrix& airFrames,
                             airframe_ptr_t  a,
                             simtime_t_cref  startTime, simtime_t_cref endTime);

  simtime_t findEarliestInfoPoint(simtime_t_cref returnTimeIfEmpty = invalidSimTime) const;

  void checkAndCleanInterval(simtime_t_cref startTime, simtime_t_cref endTime);

  bool canDiscardInterval(simtime_t_cref startTime, simtime_t_cref endTime);

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

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

public:
  ChannelInfo()
    : activeAirFrames()
    , inactiveAirFrames()
    , airFrameStarts()
    , recordStartTime(invalidSimTime)
  {}

  virtual ~ChannelInfo() {}

  void addAirFrame(airframe_ptr_t a, simtime_t_cref startTime);

  simtime_t removeAirFrame(airframe_ptr_t a, simtime_t_cref returnTimeIfEmpty = invalidSimTime);

  void getAirFrames( simtime_t_cref            from
                     , simtime_t_cref            to
                     , AirFrameVector&           out
                     , airframe_filter_fctr *const fctrFilter = NULL) const
  {
      //check for intersecting inactive AirFrames
      getIntersections(inactiveAirFrames, from, to, out, fctrFilter);

      //check for intersecting active AirFrames
      getIntersections(activeAirFrames, from, to, out, fctrFilter);
  }

  simtime_t getEarliestInfoPoint(simtime_t_cref returnTimeIfEmpty = invalidSimTime) const
  {
    return findEarliestInfoPoint(returnTimeIfEmpty);
  }

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

  void stopRecording()
  {
    if(recordStartTime >= SIMTIME_ZERO) {
      simtime_t old = recordStartTime;
      recordStartTime = invalidSimTime;
      checkAndCleanFrom(old);
    }
  }

  bool isRecording() const
  {
    return recordStartTime >= SIMTIME_ZERO;
  }

  bool isChannelEmpty() const {
    return airFrameStarts.empty();
  }
};

#endif /*CHANNELINFO_H_*/