Signal_.h

#ifndef SIGNAL_H_
#define SIGNAL_H_

#include <omnetpp.h>
#include "Move.h"
#include "Mapping.h"
#include <list>

class Signal {
public:
  typedef ConcatConstMapping<std::multiplies<double> > MultipliedMapping;
  typedef std::list<ConstMapping*> ConstMappingList;

protected:

  simtime_t signalStart;
  simtime_t signalLength;
  simtime_t propDelay;

  Move senderMovement;

  ConstMapping* power;

  Mapping* bitrate;

  Mapping* txBitrate;

  ConstMappingList attenuations;

  MultipliedMapping* rcvPower;

protected:
  void markRcvPowerOutdated() {
    if(rcvPower){
      if(propDelay != 0) {
        assert(rcvPower->getRefMapping() != power);
        delete rcvPower->getRefMapping();
      }
      delete rcvPower;
      rcvPower = 0;
    }
  }
public:

  Signal(simtime_t start = -1.0, simtime_t length = -1.0);

  Signal(const Signal& o);

  const Signal& operator=(const Signal& o);

  ~Signal();

  simtime_t getSignalStart() const;

  Move getMove() const;

  void setMove(Move& move);

  simtime_t getSignalLength() const;

  simtime_t getPropagationDelay() const;

  void setPropagationDelay(simtime_t delay);

  void setTransmissionPower(ConstMapping* power);

  void setBitrate(Mapping* bitrate);

  void addAttenuation(ConstMapping* att) {
    //assert the attenuation wasn't already added to the list before
    assert(std::find(attenuations.begin(), attenuations.end(), att) == attenuations.end());

    attenuations.push_back(att);

    if(rcvPower)
      rcvPower->addMapping(att);
  }

  ConstMapping* getTransmissionPower() {
    return power;
  }

  const ConstMapping* getTransmissionPower() const {
    return power;
  }

  Mapping* getBitrate() {
    return bitrate;
  }

  const ConstMappingList& getAttenuation() const {
    return attenuations;
  }

  MultipliedMapping* getReceivingPower() {
    if(!rcvPower)
    {
      ConstMapping* tmp = power;
      if(propDelay != 0) {
        tmp = new ConstDelayedMapping(power, propDelay);
      }
      rcvPower = new MultipliedMapping(tmp,
                        attenuations.begin(),
                        attenuations.end(),
                        false, 0.0);
    }

    return rcvPower;
  }
};

#endif /*SIGNAL_H_*/