wireless_channel_manager.hpp

#ifndef CHANNEL_MANAGER_H
#define CHANNEL_MANAGER_H

#include <map>
#include <set>
using namespace std;
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/utility.hpp>

#include "utility.hpp"

class WirelessChannel;
typedef boost::shared_ptr<WirelessChannel> WirelessChannelPtr;
class PhysicalLayer;
typedef boost::shared_ptr<PhysicalLayer> PhysicalLayerPtr;
typedef boost::shared_ptr<PhysicalLayer const> ConstPhysicalLayerPtr;
class WirelessCommSignal;
typedef boost::shared_ptr<WirelessCommSignal> WirelessCommSignalPtr;
class Simulator;
typedef Simulator* SimulatorPtr;
class SignalListeners;
typedef boost::shared_ptr<SignalListeners> SignalListenersPtr;
class ListenerSignals;
typedef boost::shared_ptr<ListenerSignals> ListenerSignalsPtr;

typedef map<t_uint,WirelessChannelPtr> ChannelIdMap;
typedef multimap<WirelessChannelPtr,PhysicalLayerPtr> ChannelObserver;
typedef multimap<PhysicalLayerPtr,WirelessChannelPtr> SenderChannel;

class WirelessChannelManager : boost::noncopyable,
   public boost::enable_shared_from_this<WirelessChannelManager> {
public:
   typedef boost::shared_ptr<WirelessChannelManager> 
      WirelessChannelManagerPtr;

   static inline WirelessChannelManagerPtr create();
   
   void recvSignal(PhysicalLayerPtr sender, 
      WirelessCommSignalPtr signal);

   void passSignalToReceiver(PhysicalLayerPtr receiver, 
      WirelessCommSignalPtr signal) const;

   bool attachAsSender(PhysicalLayerPtr physicalLayer, t_uint channelId);

   bool attachAsListener(PhysicalLayerPtr physicalLayer, t_uint channelId);

   bool detachAsSender(PhysicalLayerPtr physicalLayer, t_uint channelId);

   bool detachAsListener(PhysicalLayerPtr physicalLayer, t_uint channelId);

   void addChannel(t_uint channelId, WirelessChannelPtr channel);

   bool removeChannel(t_uint channelId);

protected:

   WirelessChannelManager();

private:

   static const bool m_DEBUG_SIGNAL_STRENGTH = false;

   ChannelIdMap m_channels;

   ChannelObserver m_listeners;

   SenderChannel m_senders;

   void sendSignalOnChannel(ConstPhysicalLayerPtr sender, 
      WirelessCommSignalPtr signal, WirelessChannelPtr channel);

   t_uint getChannelId(WirelessChannelPtr channel) const;

};
typedef boost::shared_ptr<WirelessChannelManager> 
   WirelessChannelManagerPtr;
typedef boost::shared_ptr<WirelessChannelManager const> 
   ConstWirelessChannelManagerPtr;

// Inline Functions

inline WirelessChannelManagerPtr WirelessChannelManager::create()
{
   WirelessChannelManagerPtr p(new WirelessChannelManager());
   return p;
}

// Overloaded Operators

#endif // CHANNEL_MANAGER_H

---