Layer.hh

#ifndef LAYER_HH
#define LAYER_HH
#include <string>
#include <map>
#include <vector>

#include "Params.hh"
#include "loggers.hh"

class OCTETSTRING;
class CHARSTRING;

class Layer {
  std::vector<Layer*> upperLayers;
  std::vector<Layer*> lowerLayers;
protected:
  std::string type;
public:
  Layer(const std::string& p_type) : upperLayers(), lowerLayers(), type(std::string(p_type.begin(), p_type.end())) {};
  virtual ~Layer() { upperLayers.clear(); lowerLayers.clear(); };
  void deleteLayer() { };
public:
  inline void addUpperLayer(Layer* p_layer) { 
    //loggers::loggers::log(">>> Layer::addUpperLayer");
    if (p_layer != NULL) {
      loggers::loggers::log("Layer::addUpperLayer: %s is upper layer of %s", p_layer->to_string().c_str(), to_string().c_str());
      upperLayers.push_back(p_layer);
      loggers::loggers::log(" Layer::addUpperLayer: %s is loweer layer of %s", to_string().c_str(), p_layer->to_string().c_str());
      p_layer->lowerLayers.push_back(this);
    };
  };
  void removeUpperLayer(Layer* p_layer) {  };

  virtual void sendData(const OCTETSTRING& data, const Params& params) {};
  virtual void receiveData(OCTETSTRING& data, Params& info) {};

  inline const std::string& to_string() const { return type; };

protected:
  inline void toAllLayers(std::vector<Layer*>&layers, OCTETSTRING& data, Params& info) {
    //loggers::loggers::log_msg(">>> Layer::toAllLayer: ", data);
    loggers::loggers::log(">>> Layer::toAllLayer: %d", layers.size());
    for (std::vector<Layer*>::const_iterator it = layers.cbegin(); it != layers.cend(); ++it) {
      Layer * p = *it;
      p->receiveData(data, info);
    } // End of 'for' statement
  };
  inline void toAllUpperLayers(OCTETSTRING& data, Params& info) { toAllLayers(upperLayers, data, info); }
  inline void toAllLowerLayers(OCTETSTRING& data, Params& info) { toAllLayers(lowerLayers, data, info); }
  inline void receiveToAllLayers(OCTETSTRING& data, Params& info) { toAllLayers(upperLayers, data, info); }
  inline void sendToAllLayers(OCTETSTRING& data, Params& info)  { toAllLayers(lowerLayers, data, info); }
};


template <typename TPort> class TLayer : public Layer {
  typedef std::vector<TPort*> TPortList;
  typedef typename std::vector<TPort*>::iterator TPortListIterator;

  TPortList upperPorts;
  
public:
  TLayer(const std::string& p_type) : Layer(p_type), upperPorts() {};
  void addUpperPort(TPort * p_port) { upperPorts.push_back(p_port); };
  void removeUpperPort(TPort*);

protected:
  template <typename TMessage> void toAllUpperPorts(const TMessage& m, const Params& param) {
    loggers::loggers::log(">>> TLayer::toAllUpperPorts: %d", upperPorts.size());
    for(TPortListIterator it=upperPorts.begin(); it<upperPorts.end(); ++it){
      (*it)->receiveMsg(m, param);
    }
  }
};


class LayerFactory {
public:
  LayerFactory(){}
  virtual Layer * createLayer(const std::string & type, const std::string & param) = 0;
};

class LayerStackBuilder {
  typedef std::map<std::string, LayerFactory*> LayerFactoryMap;

  static LayerStackBuilder * _instance;
  std::map<std::string, LayerFactory*> _fs;
private:
  LayerStackBuilder(); // can not be created manually
public:
  static LayerStackBuilder * GetInstance();
  static void RegisterLayerFactory(const std::string & type, LayerFactory * f);

public:
  void registerLayerFactory(const std::string & type, LayerFactory * f);
  Layer* createLayerStack(const char*);
};

#endif