MappingUtils.h

/*
 * SignalInterfaces.h
 *
 *  Created on: 26.08.2008
 *      Author: karl wessel
 */

#ifndef SIGNALINTERFACES_H_
#define SIGNALINTERFACES_H_

#include "MappingBase.h"

class FilledUpMapping;

template<class Base>
class BaseFilteredIterator : public Base{
protected:
  Base* origIterator;

public:
  BaseFilteredIterator(Base* orig):
    origIterator(orig) {}

  virtual ~BaseFilteredIterator() {
    delete origIterator;
  }

  virtual const Argument& getNextPosition() const { return origIterator->getNextPosition(); }

  virtual void jumpTo(const Argument& pos) { origIterator->jumpTo(pos); }

  virtual void jumpToBegin() { origIterator->jumpToBegin(); }

  virtual void iterateTo(const Argument& pos) { origIterator->iterateTo(pos); }

  virtual void next() { origIterator->next(); }

  virtual bool inRange() const { return origIterator->inRange(); }

  virtual bool hasNext() const { return origIterator->hasNext(); }

  virtual const Argument& getPosition() const { return origIterator->getPosition(); }

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

typedef BaseFilteredIterator<ConstMappingIterator> FilteredConstMappingIterator;

class FilteredMappingIterator : public BaseFilteredIterator<MappingIterator> {
public:
  FilteredMappingIterator(MappingIterator* orig):
    BaseFilteredIterator<MappingIterator>(orig) {}

  virtual ~FilteredMappingIterator() {}

  virtual void setValue(double value) { origIterator->setValue(value); }
};


template<template <class Key, class Value, class Pair, class Iterator> class Interpolator>
class TimeMappingIterator:public MappingIterator {
protected:
  typedef std::map<simtime_t, double> MapType;

  typedef typename InterpolateableMap<simtime_t, double,
                 Interpolator<simtime_t, double,
                      MapType::value_type,
                      MapType::const_iterator> >::intpl_iterator IteratorType;

  IteratorType valueIt;

  Argument position;

  Argument nextPosition;

  bool isStepMapping;

  bool atPreStep;
protected:
  void updateNextPos(){
    simtime_t t = valueIt.getNextPosition();
    if(isStepMapping && !atPreStep){
      t.setRaw(t.raw() - 1);
    }
    nextPosition.setTime(t);
  }
public:

  TimeMappingIterator(IteratorType it, bool isStepMapping):
    valueIt(it), isStepMapping(isStepMapping), atPreStep(false) {

    position.setTime(valueIt.getPosition());
    updateNextPos();
  }

  void jumpTo(const Argument& pos) {
    atPreStep = false;
    valueIt.jumpTo(pos.getTime());
    position.setTime(pos.getTime());
    nextPosition.setTime(valueIt.getNextPosition());
  }

  void iterateTo(const Argument& pos) {
    atPreStep = false;
    valueIt.iterateTo(pos.getTime());
    position.setTime(pos.getTime());
    nextPosition.setTime(valueIt.getNextPosition());
  }

  virtual void next() {
    if(isStepMapping && !atPreStep){
      valueIt.iterateTo(nextPosition.getTime());
      atPreStep = true;
    } else {
      valueIt.next();
      atPreStep = false;
    }
    position.setTime(valueIt.getPosition());
    updateNextPos();
  }

  virtual bool inRange() const {
    return valueIt.inRange();
  }

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

  virtual const Argument& getNextPosition() const {
    return nextPosition;
  }

  virtual double getValue() const {
    return *valueIt.getValue();
  }

  virtual void jumpToBegin() {
    valueIt.jumpToBegin();
    position.setTime(valueIt.getPosition());
  }

    virtual bool hasNext() const {
      return valueIt.hasNext();
    }

  virtual void setValue(double value) {
    valueIt.setValue(value);
  }
};

template<template <class Key, class Value, class Pair, class Iterator> class Interpolator>
class TimeMapping:public Mapping {
protected:
  typedef std::map<simtime_t, double> MapType;

  typedef InterpolateableMap<simtime_t, double,
                 Interpolator<simtime_t, double,
                      MapType::value_type,
                      MapType::const_iterator> > ValueMap;

  ValueMap entries;

  bool isStepMapping;
public:

  TimeMapping(InterpolationMethod intpl = LINEAR):
    Mapping(), entries(), isStepMapping(intpl == STEPS) {}

  TimeMapping(double outOfRangeVal, InterpolationMethod intpl = LINEAR):
    Mapping(), entries(outOfRangeVal), isStepMapping(intpl == STEPS) {}

  virtual Mapping* clone() const { return new TimeMapping<Interpolator>(*this); }

  virtual double getValue(const Argument& pos) const {
    return *entries.getIntplValue(pos.getTime());
  }

  virtual void setValue(const Argument& pos, double value) {
    entries[pos.getTime()] = value;
  }

  virtual MappingIterator* createIterator() {
    return new TimeMappingIterator<Interpolator>(entries.beginIntpl(), isStepMapping);
  }

  virtual MappingIterator* createIterator(const Argument& pos) {
    return new TimeMappingIterator<Interpolator>(entries.findIntpl(pos.getTime()), isStepMapping);
  }
};


class LinearIntplMappingIterator:public MappingIterator {
protected:
  ConstMappingIterator* leftIt;
  ConstMappingIterator* rightIt;

  double factor;

public:
  LinearIntplMappingIterator(ConstMappingIterator* leftIt, ConstMappingIterator* rightIt, double f);

  virtual ~LinearIntplMappingIterator();

  virtual bool hasNext() const { return false; }
  virtual bool inRange() const { return false; }

  virtual void jumpToBegin() { assert(false); }
  virtual void next() { assert(false); }

  virtual void setValue(double value) { assert(false); }

  virtual void jumpTo(const Argument& pos){
    leftIt->jumpTo(pos);
    rightIt->jumpTo(pos);
  }

  virtual void iterateTo(const Argument& pos){
    leftIt->iterateTo(pos);
    rightIt->iterateTo(pos);
  }

  virtual double getValue() const {
    double v0 = leftIt->getValue();
    double v1 = rightIt->getValue();
    return v0 + (v1 - v0) * factor;
  }

  virtual const Argument& getPosition() const {
    return leftIt->getPosition();
  }

  virtual const Argument& getNextPosition() const { assert(false); }
};

class LinearIntplMapping:public Mapping {
protected:
  ConstMapping* left;
  ConstMapping* right;

  double factor;

public:

  LinearIntplMapping(ConstMapping* left = 0, ConstMapping* right = 0, double f = 0.0):
    left(left), right(right), factor(f) {}

  virtual Mapping* clone() const{ assert(false); return 0; }

  virtual double getValue(const Argument& pos) const {
    assert(left);
    assert(right);

    double v0 = left->getValue(pos);
    double v1 = right->getValue(pos);
    return v0 + (v1 - v0) * factor;
  }

  virtual MappingIterator* createIterator() {
    assert(false);
    return 0;
  }

  virtual MappingIterator* createIterator(const Argument& pos) {
    assert(left);
    assert(right);

    return new LinearIntplMappingIterator(left->createConstIterator(pos), right->createConstIterator(pos), factor);
  }

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

template<>
class Interpolated<Mapping*> {
protected:
  LinearIntplMapping mapping;

  Mapping* value;

  bool isPointer;
public:
  bool isInterpolated;

public:
  Interpolated(const LinearIntplMapping& m):
    mapping(m), isPointer(false), isInterpolated(true) {

    value = &mapping;
  }

  Interpolated(Mapping* m, bool isIntpl = true):
    mapping(), value(m), isPointer(true), isInterpolated(isIntpl) {}

  Interpolated(const Interpolated<Mapping*>& o):
    mapping() {

    isInterpolated = o.isInterpolated;
    isPointer = o.isPointer;
    if(isPointer){
      value = o.value;
    } else {
      mapping = o.mapping;
      value = &mapping;
    }
  }

  const Interpolated<Mapping*>& operator=(const Interpolated<Mapping*>& o){
    isInterpolated = o.isInterpolated;
    isPointer = o.isPointer;
    if(isPointer){
      value = o.value;
    } else {
      mapping = o.mapping;
      value = &mapping;
    }
    return *this;
  }

  Mapping*& operator*() {
    return value;
  }

  Mapping** operator->() {
    return &value;
  }

  bool operator==(const Interpolated<Mapping*>& other) {
    return value == other.value && isInterpolated == other.isInterpolated;
  }

  bool operator!=(const Interpolated<Mapping*>& other) {
    return value != other.value || isInterpolated != other.isInterpolated;
  }
};

template<>
class Linear<double, Mapping*, std::map<double, Mapping*>::value_type, std::map<double, Mapping*>::const_iterator> {
public:
  typedef std::map<double, Mapping*>::const_iterator InputIterator;

  typedef Interpolated<Mapping*> interpolated;
protected:

  PairLess<std::map<double, Mapping*>::value_type, double> comp;


  bool continueOutOfRange;
  Mapping* outOfRangeVal;

public:
  Linear():
    continueOutOfRange(true) {}

  Linear(Mapping* oorv):
    continueOutOfRange(false), outOfRangeVal(oorv) {}

  void setOutOfRangeVal(Mapping* oorv) { outOfRangeVal = oorv; }

  static double linearInterpolationFactor(const double& t,
                    const double& t0, const double& t1){
    return (t - t0) / (t1 - t0);
  }

  interpolated operator()(const InputIterator& first,
              const InputIterator& last,
              const double& pos) const{

    InputIterator right = std::upper_bound(first, last, pos, comp);

    return operator()(first, last, pos, right);
  }

  interpolated operator()(const InputIterator& first,
              const InputIterator& last,
              const double& pos,
              InputIterator upperBound) const{
    if(first == last){
      if(continueOutOfRange)
        return interpolated(0);
      else
        return interpolated(outOfRangeVal);
    }

    if(upperBound == first){
      if(continueOutOfRange)
        return interpolated(upperBound->second);
      else
        return interpolated(outOfRangeVal);
    }

    InputIterator right = upperBound;
    InputIterator left = --upperBound;

    if(left->first == pos)
      return interpolated(left->second, false);

    if(right == last){
      if(continueOutOfRange)
        return interpolated(left->second);
      else
        return interpolated(outOfRangeVal);
    }

    double fact = linearInterpolationFactor(pos, left->first, right->first);

    return interpolated(LinearIntplMapping(left->second, right->second, fact));
  }
};

class ConstantSimpleConstMapping : public SimpleConstMapping {
protected:
  double value;

public:
  ConstantSimpleConstMapping(const DimensionSet& dims, double val):
    SimpleConstMapping(dims), value(val) {}

  ConstantSimpleConstMapping(const DimensionSet& dims,
                 const Argument& key,
                 double val):
    SimpleConstMapping(dims, key), value(val) {}

  virtual double getValue(const Argument& pos) const {
    return value;
  }

  double getValue() const {
    return value;
  }

  void setValue(double val) { value = val; }

  ConstMapping* constClone() const  {
    return new ConstantSimpleConstMapping(dimensions, value);
  }
};

class ConstMappingIteratorWrapper : public MappingIterator {
protected:
  ConstMappingIterator* iterator;
public:
  ConstMappingIteratorWrapper(ConstMappingIterator* it):
    iterator(it) {}

  virtual ~ConstMappingIteratorWrapper() {
    if(iterator)
      delete iterator;
  }

  virtual void setValue(double value) { assert(false); }

  virtual const Argument& getNextPosition() const { return iterator->getNextPosition(); }

  virtual void jumpTo(const Argument& pos) { iterator->jumpTo(pos); }

  virtual void jumpToBegin() { iterator->jumpToBegin(); }

  virtual void iterateTo(const Argument& pos) { iterator->iterateTo(pos); }

  virtual void next() { iterator->next(); }

  virtual bool inRange() const { return iterator->inRange(); }

  virtual bool hasNext() const { return iterator->hasNext(); }

  virtual const Argument& getPosition() const { return iterator->getPosition(); }

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

class ConstMappingWrapper : public Mapping {
protected:
  ConstMapping* mapping;

public:
  ConstMappingWrapper(ConstMapping* m):
    Mapping(m->getDimensionSet()), mapping(m) {}

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

  virtual MappingIterator* createIterator() {
    return new ConstMappingIteratorWrapper(mapping->createConstIterator());
  }

  virtual MappingIterator* createIterator(const Argument& pos) {
    return new ConstMappingIteratorWrapper(mapping->createConstIterator(pos));
  }

  virtual double getValue(const Argument& pos) const { return mapping->getValue(pos); }

  virtual ConstMappingIterator* createConstIterator() {
    return mapping->createConstIterator();
  }

  virtual ConstMappingIterator* createConstIterator(const Argument& pos) {
    return mapping->createConstIterator(pos);
  }

  virtual ConstMapping* constClone() const { return mapping->constClone(); }

  virtual Mapping* clone() const {
    return new ConstMappingWrapper(mapping->constClone());
  }
};

template<template <class Key, class Value,
          class Pair,
          class iterator> class Interpolator>
class MultiDimMapping;

template<template <class Key, class Value,
          class Pair,
          class iterator> class Interpolator>
class MultiDimMappingIterator:public MappingIterator {
protected:
  typedef InterpolateableMap<double, Mapping*,
                 Interpolator<double, Mapping*,
                        std::map<double, Mapping*>::value_type,
                        std::map<double, Mapping*>::const_iterator> > MapType;
  typedef typename MapType::intpl_iterator IteratorType;

  MultiDimMapping<Interpolator>& mapping;

  IteratorType valueIt;

  typename MapType::interpolated subMapping;

  MappingIterator* subIterator;

  Argument position;

  Argument nextPosition;

protected:

  void updateSubIterator(const Argument& pos) {
    typename MapType::interpolated subM = valueIt.getValue();
    if(subM != subMapping) {
      if(subIterator)
        delete subIterator;

      subMapping = subM;
      if(*subMapping)
        subIterator = (*subMapping)->createIterator(pos);
      else
        subIterator = 0;
    } else {
      if(subIterator)
        subIterator->jumpTo(pos);
    }
  }

  void updateSubIterator() {
    typename MapType::interpolated subM = valueIt.getValue();
    if(subM != subMapping) {
      if(subIterator)
        delete subIterator;

      subMapping = subM;
      if(*subMapping){
        if(subMapping.isInterpolated)
          subIterator = (*subMapping)->createIterator(position);
        else
          subIterator = (*subMapping)->createIterator();
      }else
        subIterator = 0;
    } else {
      if(subIterator)
        subIterator->jumpToBegin();
    }
  }

  void updateNextPosition(){
    bool intp = subMapping.isInterpolated;

    bool noSubIt = false;
    bool hasNoNext = false;
    if(!intp){
      noSubIt = !subIterator;
      if(!noSubIt)
        hasNoNext = !subIterator->hasNext();
    }
    if(intp || noSubIt || hasNoNext){
      if(valueIt.hasNext()){
        ConstMappingIterator* tmp = (*valueIt.getNextValue())->createConstIterator();
        nextPosition.setArgValues(tmp->getPosition());
        delete tmp;
      }else{
        nextPosition = position;
      }
      nextPosition.setArgValue(mapping.myDimension, valueIt.getNextPosition());

    } else {
      nextPosition.setArgValues(subIterator->getNextPosition());
    }
  }

public:
  MultiDimMappingIterator(MultiDimMapping<Interpolator>& mapping):
    mapping(mapping),
    valueIt(mapping.entries.beginIntpl()),
    subMapping(0), subIterator(0),
    position(){

    subMapping = valueIt.getValue();
    if(!subMapping.isInterpolated && *subMapping) {
      subIterator = (*subMapping)->createIterator();
      position = subIterator->getPosition();
      position.setArgValue(mapping.myDimension, valueIt.getPosition());
    } else {
      position = Argument(mapping.dimensions);
    }
    nextPosition = position;

    updateNextPosition();
  }

  MultiDimMappingIterator(MultiDimMapping<Interpolator>& mapping, const Argument& pos):
    mapping(mapping),
    valueIt(mapping.entries.findIntpl(pos.getArgValue(mapping.myDimension))),
    subMapping(0), subIterator(0),
    position(){

    subMapping = valueIt.getValue();
    if(*subMapping){
      subIterator = (*subMapping)->createIterator(pos);
    }

    position = pos;
    nextPosition = position;
    updateNextPosition();

  }

  virtual ~MultiDimMappingIterator() {
    if(subIterator)
      delete subIterator;
  }

    void jumpTo(const Argument& pos){
    double argVal = pos.getArgValue(mapping.myDimension);

    if(argVal != valueIt.getPosition() && pos.hasArgVal(mapping.myDimension)) {
      valueIt.jumpTo(argVal);
      updateSubIterator(pos);
    } else {
      if(subIterator)
        subIterator->jumpTo(pos);
    }

    position.setArgValues(pos);
    nextPosition.setArgValues(position);
    updateNextPosition();
  }

  void iterateTo(const Argument& pos){
    double argVal = pos.getArgValue(mapping.myDimension);

    if(argVal != valueIt.getPosition() && pos.hasArgVal(mapping.myDimension)) {
      valueIt.iterateTo(argVal);
      updateSubIterator(pos);
    } else {
      if(subIterator)
        subIterator->iterateTo(pos);
    }

    position.setArgValues(pos);
    updateNextPosition();
  }

  virtual void next(){
    if(!subMapping.isInterpolated && subIterator && subIterator->hasNext()) {
      subIterator->next();
    } else {
      valueIt.next();
      updateSubIterator();
    }


    if(subIterator)
      position.setArgValues(subIterator->getPosition());

    position.setArgValue(mapping.myDimension, valueIt.getPosition());

    updateNextPosition();
  }

  virtual bool inRange() const {
    return valueIt.inRange() && (subMapping.isInterpolated || (subIterator && subIterator->inRange()));
  }

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

  virtual const Argument& getNextPosition() const {
    return nextPosition;
  }

  virtual double getValue() const {
    if(subIterator)
      return subIterator->getValue();
    else
      return 0.0;
  }

  virtual void jumpToBegin(){
    valueIt.jumpToBegin();
    updateSubIterator();
    if(subIterator)
      position.setArgValues(subIterator->getPosition());

    position.setArgValue(mapping.myDimension, valueIt.getPosition());
    updateNextPosition();
  }

    virtual bool hasNext() const {
      return valueIt.hasNext() or (subIterator and subIterator->hasNext() and valueIt.inRange());
    }

  virtual void setValue(double value){
    if(subMapping.isInterpolated) {
      valueIt.setValue(mapping.createSubSignal());
      updateSubIterator(position);
    }
    subIterator->setValue(value);
  }
};



template<template <class Key, class Value,
          class Pair,
          class iterator> class Interpolator>
class MultiDimMapping:public Mapping {
protected:
  typedef InterpolateableMap<double, Mapping*,
                 Interpolator<double, Mapping*,
                        std::map<double, Mapping*>::value_type,
                        std::map<double, Mapping*>::const_iterator> > SubFunctionMap;

  ConstantSimpleConstMapping* outOfRangeMapping;

  ConstMappingWrapper* wrappedOORMapping;

  SubFunctionMap entries;

  Dimension myDimension;

  friend class MultiDimMappingIterator<Interpolator>;

  bool isMaster;

protected:
  MultiDimMapping(const DimensionSet& myDims, Dimension myDim, InterpolationMethod intpl = STEPS):
      Mapping(myDims),
      outOfRangeMapping(0),
      wrappedOORMapping(0),
      entries(),
      myDimension(myDim),
      isMaster(false) {}

  MultiDimMapping(const DimensionSet& myDims, Dimension myDim,
          ConstantSimpleConstMapping* oorm,
          ConstMappingWrapper* wrappedoorm,
          InterpolationMethod intpl = STEPS):
      Mapping(myDims),
      outOfRangeMapping(oorm),
      wrappedOORMapping(wrappedoorm),
      entries(wrappedOORMapping),
      myDimension(myDim),
      isMaster(false) {}

  MultiDimMapping(const MultiDimMapping<Interpolator>& o,
          ConstantSimpleConstMapping* oorm,
          ConstMappingWrapper* wrappedoorm):
    Mapping(o),
    outOfRangeMapping(oorm),
    wrappedOORMapping(wrappedoorm),
    entries(o.entries),
    myDimension(o.myDimension),
    isMaster(false){

    entries.setOutOfRangeVal(wrappedOORMapping);

    copySubMappings(o);
  }

  Mapping* createSubSignal() const{
    DimensionSet::const_iterator it = dimensions.find(myDimension);
    Dimension nextDim = *(--it);
    if(wrappedOORMapping == 0) {
      if(nextDim == Dimension::time)
        return new TimeMapping<Interpolator>();
      else
        return new MultiDimMapping<Interpolator>(dimensions, nextDim, LINEAR);
    } else {
      if(nextDim == Dimension::time)
        return new TimeMapping<Interpolator>(outOfRangeMapping->getValue());
      else
        return new MultiDimMapping<Interpolator>(dimensions, nextDim,
                       outOfRangeMapping,
                       wrappedOORMapping, LINEAR);
    }
  }

  void copySubMappings(const MultiDimMapping& o){
    DimensionSet::const_iterator dimIt = dimensions.find(myDimension);
    Dimension nextDim = *(--dimIt);

    if(nextDim == Dimension::time_static())
    {
      for(typename SubFunctionMap::iterator it = entries.begin();
        it != entries.end(); it++)
      {
        it->second = new TimeMapping<Interpolator>(*(static_cast<TimeMapping<Interpolator>*>(it->second)));
      }
    } else
    {
      for(typename SubFunctionMap::iterator it = entries.begin();
        it != entries.end(); it++)
      {
        if(outOfRangeMapping == 0) {
          it->second = new MultiDimMapping<Interpolator>(*(static_cast<MultiDimMapping<Interpolator>*>(it->second)));
        } else {
          it->second = new MultiDimMapping<Interpolator>(*(static_cast<MultiDimMapping<Interpolator>*>(it->second)),
                           outOfRangeMapping,
                           wrappedOORMapping);
        }
      }
    }
  }

public:
  MultiDimMapping(const DimensionSet& myDims, InterpolationMethod intpl = STEPS):
    Mapping(myDims),
    outOfRangeMapping(0),
    wrappedOORMapping(0),
    entries(),
    isMaster(true){

    myDimension = *(dimensions.rbegin());
  }

  MultiDimMapping(const DimensionSet& myDims, double oorv, InterpolationMethod intpl = STEPS):
    Mapping(myDims),
    outOfRangeMapping(new ConstantSimpleConstMapping(myDims, oorv)),
    wrappedOORMapping(new ConstMappingWrapper(outOfRangeMapping)),
    entries(wrappedOORMapping),
    isMaster(true) {

    myDimension = *(dimensions.rbegin());
  }

  MultiDimMapping(const MultiDimMapping<Interpolator>& o):
    Mapping(o),
    outOfRangeMapping(o.outOfRangeMapping),
    wrappedOORMapping(o.wrappedOORMapping),
    entries(o.entries),
    myDimension(o.myDimension),
    isMaster(true){

    if(outOfRangeMapping != 0){
      outOfRangeMapping = new ConstantSimpleConstMapping(dimensions, o.outOfRangeMapping->getValue());
      wrappedOORMapping = new ConstMappingWrapper(outOfRangeMapping);
      entries.setOutOfRangeVal(wrappedOORMapping);
    }


    copySubMappings(o);
  }

  const MultiDimMapping& operator=(const MultiDimMapping<Interpolator>& o){
    for(typename SubFunctionMap::iterator it = entries.begin();
      it != entries.end(); it++) {

      if(it->second)
        delete it->second;
    }

    dimensions = o.dimensions;
    entries = o.entries;
    myDimension = o.myDimension;
    outOfRangeMapping = o.outOfRangeMapping;
    wrappedOORMapping = o.wrappedOORMapping;
    isMaster = true;

    if(outOfRangeMapping != 0){
      outOfRangeMapping = new ConstantSimpleConstMapping(dimensions, o.outOfRangeMapping->getValue());
      wrappedOORMapping = new ConstMappingWrapper(outOfRangeMapping);
      entries.setOutOfRangeVal(wrappedOORMapping);
    }

    copySubMappings(o);

    return *this;
  }

  virtual Mapping* clone() const { return new MultiDimMapping<Interpolator>(*this); }

  virtual ~MultiDimMapping() {
      for(typename SubFunctionMap::iterator it = entries.begin();
        it != entries.end(); it++) {

        if(it->second)
          delete it->second;
      }

      if(isMaster) {
        if(outOfRangeMapping)
          delete outOfRangeMapping;
        if(wrappedOORMapping)
          delete wrappedOORMapping;
      }
    }

  virtual double getValue(const Argument& pos) const {
    assert(pos.hasArgVal(myDimension));
    double argVal = pos.getArgValue(myDimension);

    Interpolated<Mapping*> subM = entries.getIntplValue(argVal);

    if(!(*subM))
      return double();

    return (*subM)->getValue(pos);
  }

  virtual void setValue(const Argument& pos, double value) {
    double argVal = pos.getArgValue(myDimension);

      typename SubFunctionMap::iterator posIt = entries.lower_bound(argVal);

    if(posIt == entries.end() || posIt->first != argVal) {
      Mapping* subF = createSubSignal();
        posIt = entries.insert(posIt, typename SubFunctionMap::value_type(argVal, subF));
      }

      posIt->second->setValue(pos, value);
  }

  virtual MappingIterator* createIterator() {
    return new MultiDimMappingIterator<Interpolator>(*this);
  }

  virtual MappingIterator* createIterator(const Argument& pos) {
    return new MultiDimMappingIterator<Interpolator>(*this, pos);
  }


  Dimension getDimension() { return myDimension; }
};





class FilledUpMappingIterator : public MultiDimMappingIterator<Linear>{
public:
  FilledUpMappingIterator(FilledUpMapping& mapping);

  FilledUpMappingIterator(FilledUpMapping& mapping, const Argument& pos);

  virtual void setValue(double value) {
    assert(false);
  }
};

class FilledUpMapping : public MultiDimMapping<Linear> {
//--------members----------
public:
  typedef std::set<double> KeySet;
  typedef std::map<Dimension, KeySet > KeyMap;
protected:
  Mapping* fillRef;
  const KeyMap* keys;

//--------methods----------
protected:
  void fillRefIfNecessary() {
    KeyMap::const_iterator it = keys->find(myDimension);

    if(it == keys->end())
      return;

    fillRef = createSubSignal();

    for (KeySet::const_iterator keyIt = it->second.begin();
       keyIt != it->second.end(); ++keyIt)
    {
      entries.insert(entries.end(), SubFunctionMap::value_type(*keyIt, fillRef));
    }
  }

  FilledUpMapping(const DimensionSet& myDims, Dimension myDim, const KeyMap* keys, InterpolationMethod intpl = STEPS):
    MultiDimMapping<Linear>(myDims, myDim, intpl), fillRef(0), keys(keys)
  {
    fillRefIfNecessary();
  }

  Mapping* createSubSignal() const{
    DimensionSet::const_iterator it = dimensions.find(myDimension);
    Dimension nextDim = *(--it);
    if(nextDim == Dimension::time)
      return new TimeMapping<Linear>();
    else
      return new FilledUpMapping(dimensions, nextDim, keys, LINEAR);
  }
public:
  FilledUpMapping(ConstMapping* source, const DimensionSet& dims, const KeyMap* keys):
    MultiDimMapping<Linear>(dims), fillRef(0), keys(keys)
  {
    ConstMappingIterator* it = source->createConstIterator();

    if(it->inRange())
    {
      fillRefIfNecessary();

      while(it->inRange()){
        appendValue(it->getPosition(), it->getValue());

        if(!it->hasNext())
          break;

        it->next();
      }
    }

    delete it;

    keys = 0;
  }

  virtual ~FilledUpMapping(){
    if(fillRef != 0){
      delete fillRef;
      entries.clear();
    }
  }

  virtual void appendValue(const Argument& pos, double value) {
    assert(keys != 0);

    if(fillRef != 0)
    {
      fillRef->appendValue(pos, value);
    }
    else
    {
      double argVal = pos.getArgValue(myDimension);

      SubFunctionMap::iterator posIt = entries.lower_bound(argVal);

      if(posIt == entries.end() || posIt->first != argVal) {
        Mapping* subF = createSubSignal();
        posIt = entries.insert(posIt, SubFunctionMap::value_type(argVal, subF));
      }

      posIt->second->appendValue(pos, value);
    }

  }

  virtual MappingIterator* createIterator() {
    return new FilledUpMappingIterator(*this);
  }

  virtual MappingIterator* createIterator(const Argument& pos) {
    return new FilledUpMappingIterator(*this, pos);
  }
};

class MappingUtils {
public:
  typedef std::list<ConstMapping*> MappingBuffer;
private:
  static MappingBuffer mappingBuffer;

private:
  static void freeMappingBuffer(ConstMapping* m){
    MappingBuffer::iterator it = std::find(mappingBuffer.begin(), mappingBuffer.end(), m);
    if(it != mappingBuffer.end()){
      delete m;
      mappingBuffer.erase(it);
    }
  }

  static ConstMapping* setMappingBuffer(ConstMapping* mapping){

    mappingBuffer.push_front(mapping);
    return mapping;
  }

  static ConstMapping* createCompatibleMapping(ConstMapping& src, ConstMapping& dst);

  static bool iterateToNext(ConstMappingIterator* it1, ConstMappingIterator* it2);

public:

  static Mapping* createMapping(const DimensionSet& domain = DimensionSet(Dimension::time_static()),
                  Mapping::InterpolationMethod intpl = Mapping::LINEAR);

  static Mapping* createMapping(double outOfRangeValue,
                  const DimensionSet& domain = DimensionSet(Dimension::time_static()),
                  Mapping::InterpolationMethod intpl = Mapping::LINEAR);

  template<class Operator>
  static Mapping* applyElementWiseOperator(ConstMapping& f1, ConstMapping& f2,
                       const Argument& intvlStart,
                       const Argument& intvlEnd,
                       Operator op){

    return 0;
  }

  template<class Operator>
  static Mapping* applyElementWiseOperator(ConstMapping& f1, ConstMapping& f2, Operator op,
                       double outOfRangeVal = 0.0,
                       bool contOutOfRange = true){


    ConstMapping* f2Comp = createCompatibleMapping(f2, f1);
    ConstMapping* f1Comp = createCompatibleMapping(f1, f2);

    const DimensionSet& domain = f1Comp->getDimensionSet();

    Mapping* result = 0;
    if(contOutOfRange)
      result = MappingUtils::createMapping(domain);
    else
      result = MappingUtils::createMapping(outOfRangeVal, domain);

    ConstMappingIterator* itF1 = f1Comp->createConstIterator();
    ConstMappingIterator* itF2 = f2Comp->createConstIterator();

    if(!itF1->inRange() && !itF2->inRange()){
      delete itF1;
      delete itF2;
      return result;
    }

    MappingIterator* itRes = 0;

    if(itF1->inRange() && (!itF2->inRange() || itF1->getPosition() < itF2->getPosition())){
      itF2->jumpTo(itF1->getPosition());
    } else {
      itF1->jumpTo(itF2->getPosition());
    }

    itRes = result->createIterator(itF1->getPosition());

    while(itF1->inRange() || itF2->inRange()) {
      assert(itF1->getPosition().isSamePosition(itF2->getPosition()));

      double prod = op(itF1->getValue(), itF2->getValue());
      //result->setValue(itF1->getPosition(), prod);
      itRes->setValue(prod);

      if(!iterateToNext(itF1, itF2))
        break;

      itRes->iterateTo(itF1->getPosition());
    }

    delete itF1;
    delete itF2;
    delete itRes;

    freeMappingBuffer(f2Comp);
    freeMappingBuffer(f1Comp);

    return result;
  }



  static Mapping* multiply(ConstMapping& f1, ConstMapping& f2);
  static Mapping* add(ConstMapping& f1, ConstMapping& f2);
  static Mapping* subtract(ConstMapping& f1, ConstMapping& f2);
  static Mapping* divide(ConstMapping& f1, ConstMapping& f2);

  static Mapping* multiply(ConstMapping& f1, ConstMapping& f2, double outOfRangeVal);
  static Mapping* add(ConstMapping& f1, ConstMapping& f2, double outOfRangeVal);
  static Mapping* subtract(ConstMapping& f1, ConstMapping& f2, double outOfRangeVal);
  static Mapping* divide(ConstMapping& f1, ConstMapping& f2, double outOfRangeVal);

  static double findMax(ConstMapping& m);

  static double findMax(ConstMapping& m, const Argument& min, const Argument& max);

  static double findMin(ConstMapping& m);

  static double findMin(ConstMapping& m, const Argument& min, const Argument& max);


  /*
  static Mapping* multiply(ConstMapping& f1, ConstMapping& f2, const Argument& from, const Argument& to);
  static Mapping* add(ConstMapping& f1, ConstMapping& f2, const Argument& from, const Argument& to);
  static Mapping* subtract(ConstMapping& f1, ConstMapping& f2, const Argument& from, const Argument& to);
  static Mapping* divide(ConstMapping& f1, ConstMapping& f2, const Argument& from, const Argument& to);
  */


  static void addDiscontinuity(Mapping* m,
                 const Argument& pos, double value,
                 simtime_t limitTime, double limitValue);

  static simtime_t pre(simtime_t t);

  static simtime_t post(simtime_t t);
};



class ConcatConstMappingIterator : public FilteredConstMappingIterator{
//--------members----------
protected:
  ConstMapping* baseMapping;

public:
  ConcatConstMappingIterator(ConstMapping* baseMapping):
    FilteredConstMappingIterator(baseMapping->createConstIterator()),
    baseMapping(baseMapping) {}

  ConcatConstMappingIterator(ConstMapping* baseMapping, const Argument& pos):
    FilteredConstMappingIterator(baseMapping->createConstIterator(pos)),
    baseMapping(baseMapping) {}

  virtual ~ConcatConstMappingIterator() {
    delete baseMapping;
  }
};

template<class Operator>
class ConcatConstMapping: public ConstMapping {
protected:
  typedef std::pair<Dimension, Argument::const_iterator> DimIteratorPair;
  typedef std::list<ConstMapping*> MappingSet;
  MappingSet mappings;
  ConstMapping* refMapping;

  bool continueOutOfRange;
  double oorValue;

  Operator op;
public:
  template<class Iterator>
  ConcatConstMapping(ConstMapping* refMapping,
             Iterator first, Iterator last,
             bool continueOutOfRange = true,
             double oorValue = 0.0,
             Operator op = Operator()):
    ConstMapping(refMapping->getDimensionSet()),
    refMapping(refMapping),
    continueOutOfRange(continueOutOfRange),
    oorValue(oorValue),
    op(op)
  {
    while(first != last){
      mappings.push_back(*first);
      ++first;
    }
  }

  ConcatConstMapping(ConstMapping* refMapping, ConstMapping* other,
             bool continueOutOfRange = true,
             double oorValue = 0.0,
             Operator op = Operator()):
    ConstMapping(refMapping->getDimensionSet()),
    refMapping(refMapping),
    continueOutOfRange(continueOutOfRange),
    oorValue(oorValue),
    op(op)
  {
    mappings.push_back(other);
  }

  void addMapping(ConstMapping* m) {
    mappings.push_back(m);
  }

  virtual double getValue(const Argument& pos) const {
    MappingSet::const_iterator it = mappings.begin();
    double res = refMapping->getValue(pos);

    for (MappingSet::const_iterator it = mappings.begin();
       it != mappings.end(); ++it)
    {
      res = op(res, (*it)->getValue(pos));
    }

    return res;
  }

  Mapping* createConcatenatedMapping(){
    assert(!mappings.empty());

    MappingSet::const_iterator it = mappings.begin();

    Mapping* result = MappingUtils::applyElementWiseOperator(*refMapping, **it, op,
                                 oorValue, continueOutOfRange);

    while(++it != mappings.end()){
      Mapping* buf = result;
      result = MappingUtils::applyElementWiseOperator(*buf, **it, op,
                              oorValue, continueOutOfRange);
      delete buf;
    }

    return result;
  }

  virtual ConstMappingIterator* createConstIterator() {
    if(mappings.empty()) {
      return refMapping->createConstIterator();
    }
    return new ConcatConstMappingIterator(createConcatenatedMapping());
  }

  virtual ConstMappingIterator* createConstIterator(const Argument& pos) {
    if(mappings.empty()) {
      return refMapping->createConstIterator(pos);
    }
    return new ConcatConstMappingIterator(createConcatenatedMapping(), pos);
  }

  virtual ConstMapping* constClone() const {
    return new ConcatConstMapping(*this);
  }

  ConstMapping* getRefMapping() {
    return refMapping;
  }
};

template<class Base, class Iterator>
class BaseDelayedIterator: public Base {
protected:
  simtime_t delay;

  Argument position;
  Argument nextPosition;
protected:
  Argument undelayPosition(const Argument& pos) const{
    Argument res(pos);
    res.setTime(res.getTime() - delay);
    return res;
  }

  Argument delayPosition(const Argument& pos) const {
    Argument res(pos);
      res.setTime(res.getTime() + delay);
      return res;
  }

  void updatePosition() {
    nextPosition = delayPosition(this->origIterator->getNextPosition());
    position = delayPosition(this->origIterator->getPosition());
  }

public:
  BaseDelayedIterator(Iterator* it, simtime_t delay):
    Base(it), delay(delay) {

    updatePosition();
  }

  virtual ~BaseDelayedIterator() {}

  virtual const Argument& getNextPosition() const { return nextPosition; }

  virtual void jumpTo(const Argument& pos) {
    this->origIterator->jumpTo(undelayPosition(pos));
    updatePosition();
  }

  virtual void jumpToBegin() {
    this->origIterator->jumpToBegin();
    updatePosition();
  }

  virtual void iterateTo(const Argument& pos) {
    this->origIterator->iterateTo(undelayPosition(pos));
    updatePosition();
  }

  virtual void next() {
    this->origIterator->next();
    updatePosition();
  }

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

typedef BaseDelayedIterator<FilteredConstMappingIterator, ConstMappingIterator> ConstDelayedMappingIterator;

typedef BaseDelayedIterator<FilteredMappingIterator, MappingIterator> DelayedMappingIterator;

template<class Base>
class BaseDelayedMapping: public Base {
protected:
  Base* mapping;
  simtime_t delay;


protected:
  Argument delayPosition(const Argument& pos) const {
    Argument res(pos);
    res.setTime(res.getTime() - delay);
    return res;
  }

public:
  BaseDelayedMapping(Base* mapping, simtime_t delay):
    Base(mapping->getDimensionSet()), mapping(mapping), delay(delay) {}

  virtual ~BaseDelayedMapping() {}

  virtual double getValue(const Argument& pos) const {
    return mapping->getValue(delayPosition(pos));
  }

  virtual ConstMappingIterator* createConstIterator() {
    return new ConstDelayedMappingIterator(mapping->createConstIterator(), delay);
  }

  virtual ConstMappingIterator* createConstIterator(const Argument& pos) {
    return new ConstDelayedMappingIterator(mapping->createConstIterator(delayPosition(pos)), delay);
  }

  virtual simtime_t getDelay() const {
    return delay;
  }

  virtual void delayMapping(simtime_t d) {
    delay = d;
  }
};

class ConstDelayedMapping: public BaseDelayedMapping<ConstMapping> {
public:
  ConstDelayedMapping(ConstMapping* mapping, simtime_t delay):
    BaseDelayedMapping<ConstMapping>(mapping, delay) {}

  virtual ~ConstDelayedMapping() {}

  virtual ConstMapping* constClone() const {
    return new ConstDelayedMapping(mapping->constClone(), delay);
  }
};

class DelayedMapping: public BaseDelayedMapping<Mapping> {
public:
  DelayedMapping(Mapping* mapping, simtime_t delay):
    BaseDelayedMapping<Mapping>(mapping, delay) {}

  virtual ~DelayedMapping() {}

  virtual void setValue(const Argument& pos, double value) {
    mapping->setValue(delayPosition(pos), value);
  }

  virtual Mapping* clone() const {
    return new DelayedMapping(mapping->clone(), delay);
  }

  virtual MappingIterator* createIterator() {
    return new DelayedMappingIterator(mapping->createIterator(), delay);
  }

  virtual MappingIterator* createIterator(const Argument& pos) {
    return new DelayedMappingIterator(mapping->createIterator(delayPosition(pos)), delay);
  }
};


Mapping* operator*(ConstMapping& f1, ConstMapping& f2);
Mapping* operator/(ConstMapping& f1, ConstMapping& f2);
Mapping* operator+(ConstMapping& f1, ConstMapping& f2);
Mapping* operator-(ConstMapping& f1, ConstMapping& f2);

#endif /* SIGNALINTERFACES_H_ */