Trace.h

Go to the documentation of this file.

#ifndef CARMA_UTIL_TRACE_H
#define CARMA_UTIL_TRACE_H



#include <sstream>

#include "carma/util/FacilityType.h"


namespace log4cpp {
    class Category;
}


// **** MACRO DEFINITIONS ****


#define CARMA_TRACELINE " From " << __FILE__ << ":" <<  __LINE__ << ": "


#define CARMA_TRACE(traceObject, priorityLevel, message)                   \
  {                                                                        \
    carma::util::Trace * const carmaUtilTraceTO = traceObject;             \
    const carma::util::Trace::TraceLevel carmaUtilTracePL = priorityLevel; \
                                                                           \
    if ( (carmaUtilTraceTO != 0) &&                                        \
         (carmaUtilTraceTO->willWrite( carmaUtilTracePL )) ) {             \
      ::std::ostringstream carmaUtilTraceOss;                              \
                                                                           \
      carmaUtilTraceOss << CARMA_TRACELINE << message;                     \
                                                                           \
      carmaUtilTraceTO->write( carmaUtilTracePL, carmaUtilTraceOss );      \
    }                                                                      \
  }


#define CARMA_CPTRACE(priorityLevel, message)                              \
  {                                                                        \
    const carma::util::Trace::TraceLevel carmaUtilTracePL = priorityLevel; \
    carma::util::Trace * const carmaUtilTraceTO =                          \
      carma::util::Trace::getProgramTraceIfWillWrite( carmaUtilTracePL );  \
                                                                           \
    if ( carmaUtilTraceTO != 0 ) {                                         \
      ::std::ostringstream carmaUtilTraceOss;                              \
                                                                           \
      carmaUtilTraceOss << CARMA_TRACELINE << message;                     \
                                                                           \
      carmaUtilTraceTO->write( carmaUtilTracePL, carmaUtilTraceOss );      \
    }                                                                      \
  }


#define CPTRACE(priorityLevel, message) CARMA_CPTRACE(priorityLevel, message)


namespace carma {
  namespace util {

    class Trace {
    public:

      typedef enum {
          TRACE0   = 1,
          TRACE1   = 1,
          TRACE2   = 2,
          TRACE3   = 3,
          TRACE4   = 4,
          TRACE5   = 5,
          TRACE6   = 6,
          TRACE7   = 7,
          TRACEALL = 7  // Deprecated
      } TraceLevel;

      typedef enum {
          STDOUT,
          FILE,
          SYSLOG,
          SIMPLE
      } TraceDestination;

      Trace(TraceLevel traceLevel,
            const std::string& traceDestination, bool traceVerbose=true,
        const std::string& objectName="Trace",
        carma::util::facilityType facility = DEFAULT_FACILITY
        );

      virtual ~Trace();

      static carma::util::Trace * getProgramTrace();

      static carma::util::Trace * getProgramTraceIfAvailable();
      
      static carma::util::Trace *
      getProgramTraceIfWillWrite( TraceLevel traceLevel );

      void setObjectTraceLevel(const TraceLevel traceLevel);

      // output methods
      void writeStdout(const std::string& debugMessage);

      void writeStdout(const std::ostringstream &debugMessage);

      void writeFile(const std::string& debugMessage);

      void writeFile(const std::ostringstream &debugMessage);

      void writeSysLog(const std::string& debugMessage);

      void writeSysLog(const std::ostringstream &debugMessage);

      void write(TraceLevel traceLevel, const std::string& debugMessage);

      void write(TraceLevel traceLevel, const std::ostringstream &debugMessage);

      TraceDestination getDestination() const
      {
        return traceDestination_;
      }

      bool willWrite( TraceLevel traceLevel ) const;

    private:
      // used to obtain machine name for syslog category
      // must be declared early so that it is initialised early
      const ::std::string systemNodeName_;

      // destination where Trace output will be sent
      const TraceDestination traceDestination_;

      // trace level for the Trace object
      TraceLevel traceLevel_;

      // Set verbose in tracing, defaults to true
      // If false, uses log4cpp::SimpleLayout
      const bool traceVerbose_;

      // categories for sending trace information
      log4cpp::Category & sysLogCategory;
      log4cpp::Category & fileCategory;
      log4cpp::Category & ostreamCategory;

      // methods for actually writing to stdout/file/syslog
      void stdoutMethod(const std::string & debugMessage);
      void fileMethod(const std::string & debugMessage);
      void sysLogMethod(const std::string & debugMessage);
      void writeMethod(TraceLevel traceLevel, const std::string & debugMessage);

    }; // end class Trace


    // define output methods as inline functions
#ifdef NOTRACE
    inline void Trace::writeStdout(const std::string& debugMessage) {}
    inline void Trace::writeStdout(const std::ostringstream &debugMessage) {}
    inline void Trace::writeFile(const std::string& debugMessage) {}
    inline void Trace::writeFile(const std::ostringstream &debugMessage) {}
    inline void Trace::writeSysLog(const std::string& debugMessage) {}
    inline void Trace::writeSysLog(const std::ostringstream &debugMessage) {}
    inline void Trace::write(const std::string& debugMessage) {}
    inline void Trace::write(const std::ostringstream &debugMessage) {}
#else

    inline void Trace::writeStdout(const std::string& debugMessage)
    {
      stdoutMethod(debugMessage);
    }

    inline void Trace::writeStdout(const std::ostringstream &debugMessage)
    {
      stdoutMethod(debugMessage.str());
    }

    inline void Trace::writeFile(const std::string& debugMessage)
    {
      fileMethod(debugMessage);
    }

    inline void Trace::writeFile(const std::ostringstream &debugMessage)
    {
      fileMethod(debugMessage.str());
    }

    inline void Trace::writeSysLog(const std::string& debugMessage)
    {
      sysLogMethod(debugMessage);
    }

    inline void Trace::writeSysLog(const std::ostringstream &debugMessage)
    {
      sysLogMethod(debugMessage.str());
    }

    inline void Trace::write(TraceLevel traceLevel,
                         const std::string& debugMessage)
    {
      writeMethod(traceLevel, debugMessage);
    }

    inline void Trace::write(TraceLevel traceLevel,
                         const std::ostringstream &debugMessage)
    {
      writeMethod(traceLevel, debugMessage.str());
    }

#endif // #ifndef TRACE_ON

  } // end namespace util
} // end namespace carma

#endif // #ifndef CARMA_UTIL_TRACE_H