log_stream_manager.hpp

RFID reader 语 tag 模拟器

 #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