MappingBase.h

#ifndef FUNCTION_H_
#define FUNCTION_H_

#include <omnetpp.h>
#include <map>
#include <set>
#include <string>
#include <algorithm>
#include <assert.h>
#include <FWMath.h>

#include "Interpolation.h"


class Dimension {
protected:
  typedef std::map<std::string, int>DimensionIDMap;
  typedef std::map<int, std::string>DimensionNameMap;

  static DimensionIDMap& dimensionIDs();

  static DimensionNameMap& dimensionNames();

  static int& nextFreeID();

  static int getDimensionID(const std::string& name);

  int id;

protected:

public:
  static const Dimension time;

  static const Dimension frequency;

public:
  Dimension():
    id(0)
  {}

  Dimension(const std::string& name);

  static Dimension& time_static();

  static Dimension& frequency_static();

  bool operator==(const Dimension& other) const;

  bool operator<(const Dimension& other) const;

  bool operator<=(const Dimension& other) const { return id <= other.id; }
  bool operator>(const Dimension& other) const { return id > other.id; }
  bool operator>=(const Dimension& other) const { return id >= other.id; }
  bool operator!=(const Dimension& other) const { return id != other.id; }

  std::string getName() const{
    static DimensionNameMap& dimensionNames = Dimension::dimensionNames();
    return dimensionNames.find(id)->second;
  }

  int getID() const { return id; }

  friend std::ostream& operator<<(std::ostream& out, const Dimension& d) {
      return (out << d.getName() << "(" << d.id << ")");
    }
};

class DimensionSet:public std::set<Dimension> {
public:
  static const DimensionSet timeDomain;

  static const DimensionSet timeFreqDomain;
public:
  DimensionSet() {}

  DimensionSet(const Dimension& d){
    this->insert(d);
  }
  DimensionSet(const Dimension& d1, const Dimension& d2){
    this->insert(d1);
    this->insert(d2);
  }
  DimensionSet(const Dimension& d1, const Dimension& d2, const Dimension& d3){
    this->insert(d1);
    this->insert(d2);
    this->insert(d3);
  }

  bool isSubSet(const DimensionSet& other) const{
    if(this->size() < other.size())
      return false;

    return std::includes(this->begin(), this->end(), other.begin(), other.end());
  }

  bool isRealSubSet(const DimensionSet& other) const{
    if(this->size() <= other.size())
      return false;

    return std::includes(this->begin(), this->end(), other.begin(), other.end());
  }

  void addDimension(const Dimension& d) {
    this->insert(d);
  }

  bool hasDimension(const Dimension& d) const{
    return this->count(d) > 0;
  }

  bool operator==(const DimensionSet& o){
    if(size() != o.size())
      return false;

    return std::equal(begin(), end(), o.begin());
  }
};

class Argument{
protected:

  simtime_t time;

  std::pair<Dimension, double> values[10];

  unsigned int count;

public:
  typedef std::pair<Dimension, double>* iterator;
  typedef const std::pair<Dimension, double>* const_iterator;

protected:
  iterator insertValue(iterator pos, const Dimension& dim, double value, bool ignoreUnknown = false);

public:
  Argument(simtime_t timeVal = 0);

  Argument(const DimensionSet& dims, simtime_t timeVal = 0);

  simtime_t getTime() const;

  void setTime(simtime_t time);

  bool hasArgVal(const Dimension& dim) const;

  double getArgValue(const Dimension& dim) const;

  void setArgValue(const Dimension& dim, double value);

  void setArgValues(const Argument& o, bool ignoreUnknown = false);

  bool isSamePosition(const Argument& other) const;

  bool operator==(const Argument& o) const;

  bool isClose(const Argument& o, double epsilon = 0.000001) const;

  bool operator<(const Argument& o) const;

  double compare(const Argument& o, const DimensionSet& dims) const;

  DimensionSet getDimensions() const {
    DimensionSet res(Dimension::time_static());

    for(unsigned int i = 0; i < count; i++)
      res.addDimension(values[i].first);

    return res;
  }

  friend std::ostream& operator<<(std::ostream& out, const Argument& d) {
    out << "(" << d.time;

    for(unsigned int i = 0; i < d.count; i++){
      out << ", " << d.values[i].second;
    }
      return (out << ")");
    }

  void operator=(const Argument& o);

  iterator begin() { return values; }
  const_iterator begin() const { return values; }


  iterator end() { return values + count; }
  const_iterator end() const { return values + count; }

  iterator find(const Dimension& dim);
  const_iterator find(const Dimension& dim) const;

  iterator lower_bound(const Dimension& dim);
  const_iterator lower_bound(const Dimension& dim) const;
};

class NoNextIteratorException {};

class ConstMappingIterator {
public:
  virtual ~ConstMappingIterator() {}

  virtual const Argument& getNextPosition() const = 0;

  virtual void jumpTo(const Argument& pos) = 0;

  virtual void jumpToBegin() = 0;

  virtual void iterateTo(const Argument& pos) = 0;

  virtual void next() = 0;

  virtual bool inRange() const = 0;

  virtual bool hasNext() const = 0;

  virtual const Argument& getPosition() const = 0;

  virtual double getValue() const = 0;
};

class Mapping;

class ConstMapping {
protected:
  DimensionSet dimensions;

private:
  template<class T>
  std::string toString(T v, unsigned int length){
    char* tmp = new char[255];
    sprintf(tmp, "%.2f", v);

    std::string result(tmp);
    delete[] tmp;
    while(result.length() < length)
      result += " ";
    return result;
  }

  std::string toString(simtime_t v, unsigned int length){
    return toString(SIMTIME_DBL(v), length);
  }

public:

  ConstMapping():
    dimensions(Dimension::time_static()) {}

  ConstMapping(const DimensionSet& dimSet):
    dimensions(dimSet) {

    assert(dimSet.hasDimension(Dimension::time_static()));
  }

  virtual ~ConstMapping() {}

  virtual double getValue(const Argument& pos) const = 0;

  virtual ConstMappingIterator* createConstIterator() = 0;

  virtual ConstMappingIterator* createConstIterator(const Argument& pos) = 0;

  virtual ConstMapping* constClone() const = 0;

  double operator[](const Argument& pos) const {
    return getValue(pos);
  }

  const DimensionSet& getDimensionSet() const {
    return dimensions;
  }

  template<class stream>
  void print(stream& out) {
    ConstMapping& m = *this;
    Dimension otherDim;
    const DimensionSet& dims = m.getDimensionSet();
    out << "Mapping domain: time";
    for(DimensionSet::iterator it = dims.begin(); it != dims.end(); ++it) {
      if(*it != Dimension::time){
        otherDim = *it;
        out << ", " << *it;
      }
    }
    out << endl;

    ConstMappingIterator* it = m.createConstIterator();

    if(!it->inRange()) {
      out << "Mapping is empty." << endl;
      return;
    }

    Argument min = it->getPosition();
    Argument max = it->getPosition();

    std::set<simtime_t> timePositions;
    std::set<double> otherPositions;

    timePositions.insert(it->getPosition().getTime());
    if(dims.size() == 2){
      otherPositions.insert(it->getPosition().begin()->second);
    }

    while(it->hasNext()) {
      it->next();
      const Argument& pos = it->getPosition();

      min.setTime(std::min(min.getTime(), pos.getTime()));
      max.setTime(std::max(max.getTime(), pos.getTime()));

      timePositions.insert(pos.getTime());

      for(Argument::const_iterator itA = pos.begin(); itA != pos.end(); ++itA) {
        if(dims.size() == 2){
          otherPositions.insert(itA->second);
        }
        min.setArgValue(itA->first, std::min(min.getArgValue(itA->first), itA->second));
        max.setArgValue(itA->first, std::max(max.getArgValue(itA->first), itA->second));
      }
    }
    delete it;

    if(dims.size() > 2) {
      out << "domain - min=" << min << " max=" << max << endl;
      return;
    }

    out << "------+---------------------------------------------------------" << endl;
    out << "o\\t   | ";
    std::set<simtime_t>::const_iterator tIt;
    for(tIt = timePositions.begin();
      tIt != timePositions.end(); ++tIt)
    {
      out << m.toString(*tIt * 1000, 6) << " ";
    }
    out << endl;
    out << "------+---------------------------------------------------------" << endl;

    it = m.createConstIterator();


    if(dims.size() == 1) {
      out << "value" << " | ";
      while(it->inRange()) {
        out << m.toString(FWMath::mW2dBm(it->getValue()), 6) << " ";

        if(!it->hasNext()) {
          break;
        }
        it->next();
      }
    } else {
      tIt = timePositions.begin();
      std::set<double>::const_iterator fIt = otherPositions.begin();
      out << m.toString(*fIt, 5) << " | ";
      while(it->inRange()) {
        if(*fIt != it->getPosition().getArgValue(otherDim)) {
          ++fIt;
          out << endl << m.toString(*fIt, 5) << " | ";
          tIt = timePositions.begin();
          assert(*fIt == it->getPosition().getArgValue(otherDim));
        }

        while(*tIt < it->getPosition().getTime()){
          ++tIt;
          out << "      ";
        }

        out << m.toString(FWMath::mW2dBm(it->getValue()), 6) << " ";

        if(!it->hasNext()) {
          break;
        }
        it->next();
      }
    }
    out << endl << "------+---------------------------------------------------------" << endl;

  }
};


class MappingIterator:public ConstMappingIterator {

public:
  virtual ~MappingIterator() {}
  virtual void setValue(double value) = 0;
};


class Mapping:public ConstMapping {
public:
  enum InterpolationMethod {
    STEPS,
    NEAREST,
    LINEAR
  };

protected:

public:

  Mapping(const DimensionSet& dims):
    ConstMapping(dims) {}

  Mapping():
      ConstMapping() {}

  virtual ~Mapping() {}

  virtual void setValue(const Argument& pos, double value) = 0;

  virtual void appendValue(const Argument& pos, double value) {
    setValue(pos, value);
  }

  virtual MappingIterator* createIterator() = 0;

  virtual MappingIterator* createIterator(const Argument& pos) = 0;

  virtual ConstMappingIterator* createConstIterator() {
    return createIterator();
  }

  virtual ConstMappingIterator* createConstIterator(const Argument& pos) {
    return createIterator(pos);
  }



  virtual Mapping* clone() const = 0;

  virtual ConstMapping* constClone() const { return clone(); }


};


//###################################################################################
//#                     default Mapping implementations                              #
//###################################################################################

class SimpleConstMappingIterator:public ConstMappingIterator {
protected:
  ConstMapping* mapping;

  DimensionSet dimensions;

  Argument position;

  typedef std::set<Argument> KeyEntrySet;

  const KeyEntrySet* keyEntries;

  KeyEntrySet::const_iterator nextEntry;

public:
  SimpleConstMappingIterator(ConstMapping* mapping,
                 const std::set<Argument>* keyEntries,
                 const Argument& start);

  SimpleConstMappingIterator(ConstMapping* mapping,
                 const std::set<Argument>* keyEntries);

  virtual const Argument& getNextPosition() const {
    if(nextEntry == keyEntries->end())
      throw NoNextIteratorException();

    return *nextEntry;
  }

  virtual void jumpTo(const Argument& pos) {
    position.setArgValues(pos, true);
    nextEntry = keyEntries->upper_bound(position);
  }

  virtual void jumpToBegin(){
    nextEntry = keyEntries->begin();

    if(nextEntry == keyEntries->end()) {
      position = Argument(dimensions);
    } else {
      position = *nextEntry;
      ++nextEntry;
    }
  }

  virtual void iterateTo(const Argument& pos) {
    position.setArgValues(pos, true);
    while(nextEntry != keyEntries->end() && !(position < *nextEntry))
      ++nextEntry;

  }

  virtual void next() {
    if(nextEntry == keyEntries->end())
      throw NoNextIteratorException();

    position = *nextEntry;
    ++nextEntry;
  }

  virtual bool inRange() const {
    return !(keyEntries->empty()
         || (*(keyEntries->rbegin()) < position)
         || (position < *(keyEntries->begin())));
  }

  virtual bool hasNext() const { return nextEntry != keyEntries->end(); }

  virtual const Argument& getPosition() const { return position; }

  virtual double getValue() const { return mapping->getValue(position); }
};

class SimpleConstMapping:public ConstMapping {
protected:
  typedef std::set<Argument> KeyEntrySet;

  KeyEntrySet keyEntries;

protected:

  void createKeyEntries(const Argument& from, const Argument& to, const Argument& step, Argument& pos);

  void createKeyEntries(const Argument& from, const Argument& to, const Argument& step,
              DimensionSet::const_iterator curDim, Argument& pos);

public:
  virtual ConstMappingIterator* createConstIterator() {
    return new SimpleConstMappingIterator(this, &keyEntries);
  }

  virtual ConstMappingIterator* createConstIterator(const Argument& pos) {
    return new SimpleConstMappingIterator(this, &keyEntries, pos);
  }

public:
  SimpleConstMapping(const DimensionSet& dims):
    ConstMapping(dims) {}

  SimpleConstMapping(const DimensionSet& dims,
             const Argument& key):
    ConstMapping(dims){

    initializeArguments(key);
  }

  SimpleConstMapping(const DimensionSet& dims,
             const Argument& key1, const Argument& key2):
    ConstMapping(dims){

    initializeArguments(key1, key2);
  }

  SimpleConstMapping(const DimensionSet& dims,
             const Argument& min, const Argument& max, const Argument& interval):
    ConstMapping(dims){

    initializeArguments(min, max, interval);
  }

  void initializeArguments(const Argument& key){
    keyEntries.clear();
    keyEntries.insert(key);
  }

  void initializeArguments(const Argument& key1, const Argument& key2){
    keyEntries.clear();
    keyEntries.insert(key1);
    keyEntries.insert(key2);
  }

  void initializeArguments(const Argument& min,
               const Argument& max,
               const Argument& interval);

  virtual double getValue(const Argument& pos) const = 0;

  ConstMapping* constClone() const  = 0;
};




#endif /*FUNCTION_H_*/