log_stream_manager.hpp

#ifndef LOG_STREAM_MANAGER_H
#define LOG_STREAM_MANAGER_H

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <iomanip>
using namespace std;
#include <boost/shared_ptr.hpp>
#include <boost/utility.hpp>

#include "communication_layer.hpp"
#include "utility.hpp"

class Packet;
typedef boost::shared_ptr<Packet> PacketPtr;
class NodeId;

class LogStreamManager : boost::noncopyable {
private:

   enum LogEvents {
      LogEvents_PktSend, 
      LogEvents_PktRecv, 
      LogEvents_Stats, 
      LogEvents_UserDefined, 
      LogEvents_Debug 
   };
   friend ostream& operator<< (ostream& s, const LogEvents& logEvent);

public:
   typedef LogStreamManager* LogStreamManagerPtr;

   static inline LogStreamManagerPtr instance();

   void logPktSendItem(const NodeId& nodeId,
      const CommunicationLayer::Types& layer, const Packet& recvPkt);

   void logPktRecvItem(const NodeId& nodeId,
      const CommunicationLayer::Types& layer, const Packet& recvPkt);

   /*
   void logEnergyItem();

   void logNewSenseEventItem();

   void logSensedEventItem();
   */

   void logStatsItem(const string& statsKeyString, 
      const string& statsValueString);

   void logStatsItem(const NodeId& nodeId, 
      const string& statsKeyString, const string& statsValueString);

   void logUserDefinedItem(const string& userString);

   void logDebugItem(const string& debugString);

   inline void setAllStreams(ostreamPtr newStream);

   inline void setPktSendStream(ostreamPtr newStream);

   inline void setPktRecvStream(ostreamPtr newStream);

   inline void setEnergyStream(ostreamPtr newStream);

   inline void setNewSenseEventStream(ostreamPtr newStream);

   inline void setSensedEventStream(ostreamPtr newStream);

   inline void setStatsStream(ostreamPtr newStream);

   inline void setUserDefinedStream(ostreamPtr newStream);

   inline void setDebugStream(ostreamPtr newStream);

private:

   static LogStreamManagerPtr m_instance;

   ostreamPtr m_pktSendStream;

   ostreamPtr m_pktRecvStream;

   ostreamPtr m_energyStream;

   ostreamPtr m_newSenseEventStream;

   ostreamPtr m_sensedEventStream;

   ostreamPtr m_statsStream;

   ostreamPtr m_userDefinedStream;

   ostreamPtr m_debugStream;

   LogStreamManager();

   ~LogStreamManager();

   string currentTimeString() const;

   string layerString(const CommunicationLayer::Types& layer) const;

   string eventString(const LogEvents& event) const;

   string nodeIdString(const NodeId& nodeId) const;

};
typedef LogStreamManager* LogStreamManagerPtr;

// Inline Functions

inline LogStreamManagerPtr LogStreamManager::instance()
{
   // See the Singleton design pattern for an explanation.
   if(m_instance == 0) {
      m_instance = new LogStreamManager();
   }
   return m_instance;
}

inline void LogStreamManager::setAllStreams(ostreamPtr newStream)
{
   assert(newStream != 0);

   setPktSendStream(newStream);
   setPktRecvStream(newStream);
   setEnergyStream(newStream);
   setNewSenseEventStream(newStream);
   setSensedEventStream(newStream);
   setStatsStream(newStream);
   setUserDefinedStream(newStream);
   setDebugStream(newStream);
}

inline void LogStreamManager::setPktSendStream(ostreamPtr newStream)
{
   assert(newStream != 0);
   m_pktSendStream = newStream;
}

inline void LogStreamManager::setPktRecvStream(ostreamPtr newStream)
{
   assert(newStream != 0);
   m_pktRecvStream = newStream;
}

inline void LogStreamManager::setEnergyStream(ostreamPtr newStream)
{
   assert(newStream != 0);
   m_energyStream = newStream;
}

inline void LogStreamManager::setNewSenseEventStream(ostreamPtr newStream)
{
   assert(newStream != 0);
   m_newSenseEventStream = newStream;
}

inline void LogStreamManager::setSensedEventStream(ostreamPtr newStream)
{
   assert(newStream != 0);
   m_sensedEventStream = newStream;
}

inline void LogStreamManager::setStatsStream(ostreamPtr newStream)
{
   assert(newStream != 0);
   m_statsStream = newStream;
}

inline void LogStreamManager::setUserDefinedStream(ostreamPtr newStream)
{
   assert(newStream != 0);
   m_userDefinedStream = newStream;
}

inline void LogStreamManager::setDebugStream(ostreamPtr newStream)
{
   assert(newStream != 0);
   m_debugStream = newStream;
}

// Overloaded Operators

inline ostream& operator<< (ostream& s, 
      const LogStreamManager::LogEvents& logEvent)
{

   switch (logEvent) {
      case LogStreamManager::LogEvents_PktSend:
         s << "pktSend";
         break;
      case LogStreamManager::LogEvents_PktRecv:
         s << "pktRecv";
         break;
      case LogStreamManager::LogEvents_Stats:
         s << "stats";
         break;
      case LogStreamManager::LogEvents_UserDefined:
         s << "userDefined";
         break;
      case LogStreamManager::LogEvents_Debug:
         s << "debug";
         break;
   }

   return s;

}

#endif // LOG_STREAM_MANAGER_H

---