BaseDecider.h

/*
 * BaseDecider.h
 *
 *  Created on: 24.02.2009
 *      Author: karl
 */

#ifndef BASEDECIDER_H_
#define BASEDECIDER_H_

#include "Decider.h"

#define deciderEV (ev.isDisabled()||!debug) ? ev : ev << "[Host " << myIndex << "] - PhyLayer(Decider): "

class BaseDecider: public Decider {
public:
  enum BaseDeciderControlKinds {
    PACKET_DROPPED = 22100,
    LAST_BASE_DECIDER_CONTROL_KIND
  };

protected:

  enum SignalState {
    NEW,
    EXPECT_HEADER,
    EXPECT_END,
  };

  double sensitivity;

  typedef std::pair<AirFrame*, int> ReceivedSignal;

  ReceivedSignal currentSignal;

  bool isChannelIdle;

  typedef struct{
    ChannelSenseRequest* first;
    simtime_t second;
    simtime_t canAnswerAt;

    ChannelSenseRequest* getRequest() const { return first; }
    void setRequest(ChannelSenseRequest* request) { first = request; }
    simtime_t getSenseStart() const { return second; }
    void setSenseStart(simtime_t start) { second = start; }
    simtime_t getAnswerTime() const { return canAnswerAt; }
    void setAnswerTime(simtime_t answerAt) { canAnswerAt = answerAt; }
  } CSRInfo;

  CSRInfo currentChannelSenseRequest;

  int myIndex;

  bool debug;

public:
  BaseDecider(DeciderToPhyInterface* phy, double sensitivity,
        int myIndex, bool debug):
    Decider(phy),
    sensitivity(sensitivity),
    isChannelIdle(true),
    myIndex(myIndex),
    debug(debug)
  {
    currentSignal.first = 0;
    currentSignal.second = NEW;
    currentChannelSenseRequest.first = 0;
    currentChannelSenseRequest.second = -1;
    currentChannelSenseRequest.canAnswerAt = -1;
  }

  virtual ~BaseDecider() {}

public:
  virtual simtime_t processSignal(AirFrame* frame);

  virtual ChannelState getChannelState();

  virtual simtime_t handleChannelSenseRequest(ChannelSenseRequest* request);



protected:
  virtual simtime_t processNewSignal(AirFrame* frame);

  virtual simtime_t processSignalHeader(AirFrame* frame) {
    opp_error("BaseDecider does not handle Signal headers!");
    return notAgain;
  }

  virtual simtime_t processSignalEnd(AirFrame* frame);

  virtual simtime_t processUnknownSignal(AirFrame* frame) {
    opp_error("Unknown state for the AirFrame with ID %d", frame->getId());
    return notAgain;
  }

  virtual int getSignalState(AirFrame* frame);

  virtual simtime_t handleNewSenseRequest(ChannelSenseRequest* request);

  virtual void handleSenseRequestEnd(CSRInfo& requestInfo);

  virtual void setChannelIdleStatus(bool isIdle);

  virtual simtime_t canAnswerCSR(const CSRInfo& requestInfo);

  virtual double calcChannelSenseRSSI(simtime_t start, simtime_t end);

  virtual void answerCSR(CSRInfo& requestInfo);

  virtual void channelStateChanged();

  virtual void getChannelInfo(simtime_t start, simtime_t end,
                AirFrameVector& out);

  //------Utility methods------------

  virtual Mapping* calculateSnrMapping(AirFrame* frame);

  virtual Mapping* calculateRSSIMapping(  simtime_t start,
                      simtime_t end,
                      AirFrame* exclude = 0);
};

#endif /* BASEDECIDER_H_ */