include/EDoc/Logger.h

Go to the documentation of this file.

/*******************************************************************************

   Copyright (C) 2007 by Brendon Costa

   This library is free software; you can redistribute it and/or modify 
   it under the terms of the "LGPL Like" License defined in the file COPYING 
   that should have been distributed along with this source.

   This library is distributed in the hope that it will be useful, 
   but WITHOUT ANY WARRANTY; without even the implied warranty of 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

   You should have received a copy of the "LGPL Like" License 
   along with this library; see the file COPYING. if not, it can be 
   obtained from the EDoc++ website: 
   http://edoc.sourceforge.net/license.html

*******************************************************************************/
#ifndef EDOC_LOGGER_H
#define EDOC_LOGGER_H

#include "EDoc/LogLevels.h"

#include <sstream>
#include <iostream>
#include <fstream>

// The default log level to use.
#ifndef EDOC_DEFAULT_LOG_LEVEL
   //#define EDOC_DEFAULT_LOG_LEVEL   EDOC_LOG_LEVEL_ERROR
   //#define EDOC_DEFAULT_LOG_LEVEL   EDOC_LOG_LEVEL_WARNING
   #define EDOC_DEFAULT_LOG_LEVEL   EDOC_LOG_LEVEL_INFO
   //#define EDOC_DEFAULT_LOG_LEVEL   EDOC_LOG_LEVEL_DEBUG
   //#define EDOC_DEFAULT_LOG_LEVEL   EDOC_LOG_LEVEL_FINE
   //#define EDOC_DEFAULT_LOG_LEVEL   EDOC_LOG_LEVEL_FINER
   //#define EDOC_DEFAULT_LOG_LEVEL   EDOC_LOG_LEVEL_FINEST
#endif

namespace EDoc
{
   //===========================================================================
   /** \brief Simple logging singleton class.
    */
   class Logger
   {
   public:

      //------------------------------------------------------------------------
      /** \brief Singleton accessor.
       */
      static inline Logger* Instance()
      {
         if (instance == NULL)
         {
            instance = new Logger();
         }

         return instance;
      }

      //------------------------------------------------------------------------
      /** \brief Deletes singleton.
       */
      static void Destroy()
      {
         if (instance)
         {
            delete instance;
            instance = NULL;
         }
      }
      
      //------------------------------------------------------------------------
      /** \brief Destructor.
       */
      ~Logger();
      
      //------------------------------------------------------------------------
      /** \brief If true log to stdout.
       */
      bool use_stdout;

      //------------------------------------------------------------------------
      /** \brief If true log to stderr.
       */
      bool use_stderr;
      
      //------------------------------------------------------------------------
      /** \brief Ensure it does not log to any files.
       */
      void ClearUseFile();

      //------------------------------------------------------------------------
      /** \brief If true log to a file.
       */
      bool GetUseFile() const;

      //------------------------------------------------------------------------
      /** \brief If logging to a file returns true and also returns the name of
       * the file being logged to.
       */
      bool GetLogFileName(std::string& filename_out) const;

      //------------------------------------------------------------------------
      /** \brief Set the name of the file to log to.
       */
      bool SetLogFilename(std::string filename_in);

      //------------------------------------------------------------------------
      /** \brief Set the name of the file to log to including the full path.
       */
      bool SetLogFilenameFullyQualified(std::string filename_in);

      //------------------------------------------------------------------------
      /** \brief Logs a message to all appropiate output sources.
       */
      inline void LogMessage(const std::string& message)
      {
         if (use_file)
         {
            // If the log file has not yet been created, then create it to log 
            // this message and all future messages.
            if (!file_initialised)
            {
               InitialiseFile();
            }

            file << message << ::std::endl;
         }

         if (use_stdout)
         {
            std::cout << message << ::std::endl;
         }

         if (use_stderr)
         {
            std::cerr << message << ::std::endl;
         }
      }

      //------------------------------------------------------------------------

   private:

      //------------------------------------------------------------------------
      /** \brief Constructor.
       */
      Logger();

      //------------------------------------------------------------------------
      /** \brief Called to setup the file to be logged to.
       */
      void InitialiseFile();

      //------------------------------------------------------------------------
      /** \brief If true log to file.
       */
      bool use_file;

      //------------------------------------------------------------------------
      /** \brief Name of file being loged to.
       */
      std::string filename;

      //------------------------------------------------------------------------
      /** \brief Output stream for file to log to.
       */
      std::ofstream file;

      //------------------------------------------------------------------------
      /** \brief True if the file to log to has been initialized false if needs
       * to be opened before logging.
       */
      bool file_initialised;

      //------------------------------------------------------------------------
      /** \brief Singleton instance for logger.
       */
      static Logger* instance;
      
      //------------------------------------------------------------------------

   };
   //===========================================================================
}

#endif // EDOC_LOGGER_H



//==============================================================================
//==============================================================================
#undef EDOC_LOG_MESSAGE
#undef EDOC_IMPL_LOG_LEVEL
#undef EDOC_Fatal
#undef EDOC_Error
#undef EDOC_Warning
#undef EDOC_Info
#undef EDOC_Debug
#undef EDOC_Fine
#undef EDOC_Finer
#undef EDOC_Finest
//==============================================================================
//==============================================================================



//==============================================================================
/** \brief If the user did not request otherwise then log the level.
 */
#ifndef EDOC_LOG_WRITE_LEVEL
   #define EDOC_LOG_WRITE_LEVEL(Level, LevelString) << LevelString << ":"
#endif


//==============================================================================
/** \brief If the user did not request otherwise then log the filename.
 */
#ifndef EDOC_LOG_WRITE_FILENAME
   #define EDOC_LOG_WRITE_FILENAME << __FILE__ << ":"
#endif


//==============================================================================
/** \brief If the user did not request otherwise then log the line number.
 */
#ifndef EDOC_LOG_WRITE_LINE
   #define EDOC_LOG_WRITE_LINE << __LINE__ << ":"
#endif

//==============================================================================
/** \brief If the user did not request otherwise then log the function name.
 */
#define EDOC_LOG_WRITE_FUNCTION

#ifndef EDOC_LOG_WRITE_FUNCTION
   #define EDOC_LOG_WRITE_FUNCTION << __FUNCTION__ << "():"
#endif


//==============================================================================
/** \brief If the user did not request otherwise then log the message.
 */
#ifndef EDOC_LOG_WRITE_MESSAGE
   #define EDOC_LOG_WRITE_MESSAGE(Message) << " " << Message
#endif


//==============================================================================
/** \brief 
 */
#define EDOC_LOG_MESSAGE(Level, LevelString, Message) \
{ \
   ::std::ostringstream stream_jh8732rhb; \
   stream_jh8732rhb \
      EDOC_LOG_WRITE_LEVEL(Level, LevelString) \
      EDOC_LOG_WRITE_FILENAME \
      EDOC_LOG_WRITE_LINE \
      EDOC_LOG_WRITE_FUNCTION \
      EDOC_LOG_WRITE_MESSAGE(Message) \
      << std::flush; \
   EDoc::Logger::Instance()->LogMessage(stream_jh8732rhb.str()); \
}

//==============================================================================
/** \brief Set the default log level.
 */
#ifndef EDOC_LOG_LEVEL
   #define EDOC_IMPL_LOG_LEVEL   EDOC_DEFAULT_LOG_LEVEL
#else
   // Use the log level defined.
   #define EDOC_IMPL_LOG_LEVEL   EDOC_LOG_LEVEL
#endif


//==============================================================================
/** Create macros for all log levels compiling out code for those outside the
 * log level being used.
 */
#if EDOC_IMPL_LOG_LEVEL <= EDOC_LOG_LEVEL_FATAL
   #define EDOC_Fatal(Message)   EDOC_LOG_MESSAGE(EDOC_LOG_LEVEL_FATAL, "FATAL  ", Message)
#else
   #define EDOC_Fatal(Message) 
#endif

#if EDOC_IMPL_LOG_LEVEL <= EDOC_LOG_LEVEL_ERROR
   #define EDOC_Error(Message)   EDOC_LOG_MESSAGE(EDOC_LOG_LEVEL_ERROR, "ERROR  ", Message)
#else
   #define EDOC_Error(Message) 
#endif

#if EDOC_IMPL_LOG_LEVEL <= EDOC_LOG_LEVEL_WARNING
   #define EDOC_Warning(Message) EDOC_LOG_MESSAGE(EDOC_LOG_LEVEL_WARNING, "WARNING", Message)
#else
   #define EDOC_Warning(Message) 
#endif

#if EDOC_IMPL_LOG_LEVEL <= EDOC_LOG_LEVEL_INFO
   #define EDOC_Info(Message)    EDOC_LOG_MESSAGE(EDOC_LOG_LEVEL_INFO, "INFO   ", Message)
#else
   #define EDOC_Info(Message) 
#endif

#if EDOC_IMPL_LOG_LEVEL <= EDOC_LOG_LEVEL_DEBUG
   #define EDOC_Debug(Message)   EDOC_LOG_MESSAGE(EDOC_LOG_LEVEL_DEBUG, "DEBUG  ", Message)
#else
   #define EDOC_Debug(Message) 
#endif

#if EDOC_IMPL_LOG_LEVEL <= EDOC_LOG_LEVEL_FINE
   #define EDOC_Fine(Message)    EDOC_LOG_MESSAGE(EDOC_LOG_LEVEL_FINE, "FINE   ", Message)
#else
   #define EDOC_Fine(Message) 
#endif

#if EDOC_IMPL_LOG_LEVEL <= EDOC_LOG_LEVEL_FINER
   #define EDOC_Finer(Message)   EDOC_LOG_MESSAGE(EDOC_LOG_LEVEL_FINER, "FINER  ", Message)
#else
   #define EDOC_Finer(Message) 
#endif

#if EDOC_IMPL_LOG_LEVEL <= EDOC_LOG_LEVEL_FINEST
   #define EDOC_Finest(Message)  EDOC_LOG_MESSAGE(EDOC_LOG_LEVEL_FINEST, "FINEST ", Message)
#else
   #define EDOC_Finest(Message) 
#endif

---