Logger.hpp

Go to the documentation of this file.

/*
Copyright 2007, 2008, 2009, 2010, 2011 Instituto de Sistemas e Robotica, Instituto Superior Tecnico

This file is part of MeRMaID.

MeRMaID is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

MeRMaID 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.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with MeRMaID.  If not, see <http://www.gnu.org/licenses/>.
*/



/**
 * @Filename Logger.hpp
 * @Description Logger declaration
 * @Status Finished
 * @Version $Id: Logger.hpp 1 2011-03-04 18:13:18Z jreis $
 * @Maintainer Joao Reis (joaocgreis@gmail.com)
 */

#ifndef LOGGER_HPP
#define LOGGER_HPP



/**
 * Enables a prototype for quick profiling of code, based on the logger.
 * This was just an experiment, but it's already done so I'll let it be.
 */
#undef MERMAID_LOGGER_QUICK_PROFILING

// Compile time Logger configurations
/**
 * Disables the shortcuts to the reporting levels, for speed purposes.
 * Please mind that this will not affect any of the methods called log.
 */
#undef MERMAID_LOGGER_DISABLE_REPORTING
// If we really need it, we could create another class, DummyLogger,
// that completely implemented the logger with empty methods.
// Then we would only need to change the lines where the logger is crated.



#include <ctime>
#include <fstream>
#include <list>
#include <map>
#include <set>
#include <sstream>
#include <stack>
#include <string>

#ifdef MERMAID_LOGGER_QUICK_PROFILING
#include <sys/time.h>
#include <time.h>
#endif //MERMAID_LOGGER_QUICK_PROFILING

#include "ace/Synch.h"

#include <boost/foreach.hpp>
#define foreach BOOST_FOREACH


#include <DataBox.hpp>



/**
 * Logs an ERROR using a <code>std::ostringstream</code>.
 * This macro crates a temporary <code>std::ostringstream</code>, inserts
 * <code>message</code> into it and calls the method <code>error</code>
 * from the logger you specified.
 * @see mermaid::support::logging::Logger.error()
 * @param logger The logger to use. Must evaluate to an instance of
 * <code>mermaid::support::logging::Logger</code>
 * @param message Somethog to be inserted into the
 * <code>std::ostringstream</code>. May contain more <code><<</code> operators.
 */
#define LERROR(logger, message) {std::ostringstream tmp; tmp << message; (logger)->error(tmp.str());}
/**
 * Logs a WARN using a <code>std::ostringstream</code>.
 * This macro crates a temporary <code>std::ostringstream</code>, inserts
 * <code>message</code> into it and calls the method <code>warn</code>
 * from the logger you specified.
 * @see mermaid::support::logging::Logger.warn()
 * @param logger The logger to use. Must evaluate to an instance of
 * <code>mermaid::support::logging::Logger</code>
 * @param message Somethog to be inserted into the
 * <code>std::ostringstream</code>. May contain more <code><<</code> operators.
 */
#define LWARN(logger, message) {std::ostringstream tmp; tmp << message; (logger)->warn(tmp.str());}
/**
 * Logs an INFO using a <code>std::ostringstream</code>.
 * This macro crates a temporary <code>std::ostringstream</code>, inserts
 * <code>message</code> into it and calls the method <code>info</code>
 * from the logger you specified.
 * @see mermaid::support::logging::Logger.info()
 * @param logger The logger to use. Must evaluate to an instance of
 * <code>mermaid::support::logging::Logger</code>
 * @param message Somethog to be inserted into the
 * <code>std::ostringstream</code>. May contain more <code><<</code> operators.
 */
#define LINFO(logger, message) {std::ostringstream tmp; tmp << message; (logger)->info(tmp.str());}

#ifndef MERMAID_LOGGER_DISABLE_REPORTING
/**
 * Logs a BEGIN using a <code>std::ostringstream</code>.
 * This macro crates a temporary <code>std::ostringstream</code>, inserts
 * <code>message</code> into it and calls the method <code>begin</code>
 * from the logger you specified.
 * @see mermaid::support::logging::Logger.begin()
 * @param logger The logger to use. Must evaluate to an instance of
 * <code>mermaid::support::logging::Logger</code>
 * @param message Somethog to be inserted into the
 * <code>std::ostringstream</code>. May contain more <code><<</code> operators.
 */
#define LBEGIN(logger, message) {std::ostringstream tmp; tmp << message; (logger)->begin(tmp.str());}
/**
 * Logs a SEPARATOR using a <code>std::ostringstream</code>.
 * This macro crates a temporary <code>std::ostringstream</code>, inserts
 * <code>message</code> into it and calls the method <code>separator</code>
 * from the logger you specified.
 * @see mermaid::support::logging::Logger.separator()
 * @param logger The logger to use. Must evaluate to an instance of
 * <code>mermaid::support::logging::Logger</code>
 * @param message Somethog to be inserted into the
 * <code>std::ostringstream</code>. May contain more <code><<</code> operators.
 */
#define LSEPARATOR(logger, message) {std::ostringstream tmp; tmp << message; (logger)->separator(tmp.str());}
/**
 * Logs a STEP using a <code>std::ostringstream</code>.
 * This macro crates a temporary <code>std::ostringstream</code>, inserts
 * <code>message</code> into it and calls the method <code>step</code>
 * from the logger you specified.
 * @see mermaid::support::logging::Logger.step()
 * @param logger The logger to use. Must evaluate to an instance of
 * <code>mermaid::support::logging::Logger</code>
 * @param message Somethog to be inserted into the
 * <code>std::ostringstream</code>. May contain more <code><<</code> operators.
 */
#define LSTEP(logger, message) {std::ostringstream tmp; tmp << message; (logger)->step(tmp.str());}
/**
 * Logs an END using a <code>std::ostringstream</code>.
 * This macro crates a temporary <code>std::ostringstream</code>, inserts
 * <code>message</code> into it and calls the method <code>end</code>
 * from the logger you specified.
 * @see mermaid::support::logging::Logger.end()
 * @param logger The logger to use. Must evaluate to an instance of
 * <code>mermaid::support::logging::Logger</code>
 * @param message Somethog to be inserted into the
 * <code>std::ostringstream</code>. May contain more <code><<</code> operators.
 */
#define LEND(logger, message) {std::ostringstream tmp; tmp << message; (logger)->end(tmp.str());}
#else
/** Disabled by MERMAID_LOGGER_DISABLE_REPORTING in compile time */
#define LBEGIN(logger, message) {}
/** Disabled by MERMAID_LOGGER_DISABLE_REPORTING in compile time */
#define LSEPARATOR(logger, message) {}
/** Disabled by MERMAID_LOGGER_DISABLE_REPORTING in compile time */
#define LSTEP(logger, message) {}
/** Disabled by MERMAID_LOGGER_DISABLE_REPORTING in compile time */
#define LEND(logger, message) {}
#endif // MERMAID_LOGGER_DISABLE_REPORTING



namespace mermaid
{
  namespace support
  {
    /// Namespace for the Logging Framework.
    namespace logging
    {
      using boost::shared_ptr;
      
      /**
       * @enum LogLevel
       * @Description The LogLevel enum lists all the logger levels.
       * @Author Joao Reis
       */
      enum LogLevel {
        // Error levels
        LOG_ERROR, /**< Error level (Error levels group) */
        LOG_WARN, /**< Warn level (Error levels group) */
        LOG_INFO, /**< Info level (Error levels group) */
        // Reporting levels
        LOG_BEGIN, /**< Begin level (Reporting levels group) */
        LOG_STEP, /**< Step level (Reporting levels group) */
        LOG_SEPARATOR, /**< Separator level (Reporting levels group) */
        LOG_END /**< End level (Reporting levels group) */
      };
      
      
      
      /**
       * @Class LogMessage
       * @Description This class represents a message of the logger.
       *
       * The LogMessage is sent by the Logger class to the LogOutput(s).
       * @Author Joao Reis
       */
      class LogMessage
      {
        public:
          /**
          * @Description Creates a new LogMessage.
          * @Argument logLevel The level of the message.
          * @Argument time The time when the message was issued.
          * @Argument indentation Indentation level of the message for
          * reporting levels.
          * @Argument prefix The logger prefix when the message was issued.
          * @Argument message The message to log.
          * @Author Joao Reis
          */
          LogMessage (const LogLevel& logLevel,
                      const time_t& time,
                      const int& indentation,
                      const std::string& prefix,
                      const std::string& message) :
              logLevel_ (logLevel),
              time_ (time),
              indentation_ (indentation),
              prefix_ (prefix),
              message_ (message) {
          }
          /**
          * @Description Gets the LogLevel of the message.
          * @Returns The LogLevel of the message.
          * @Author Joao Reis
          */
          inline const LogLevel& getLogLevel() const {
            return logLevel_;
          }
          /**
          * @Description Gets the time when the message was issued.
          * @Returns The time when the message was issued.
          * @Author Joao Reis
          */
          inline const time_t& getTime() const {
            return time_;
          }
          /**
          * @Description Gets the indentation of the message.
          * @Returns The indentation of the message.
          * @Author Joao Reis
          */
          inline const int& getIndentation() const {
            return indentation_;
          }
          /**
          * @Description Gets the prefix of the logger when the message was issued.
          * @Returns The prefix of the logger.
          * @Author Joao Reis
          */
          inline const std::string& getPrefix() const {
            return prefix_;
          }
          /**
          * @Description Gets the message.
          * @Returns The actual message.
          * @Author Joao Reis
          */
          inline const std::string& getMessage() const {
            return message_;
          }
          
        private:
          LogLevel logLevel_;
          time_t time_;
          int indentation_;
          std::string prefix_;
          std::string message_;
      };
      
      
      
      /**
       * @Class LogOutput
       * @Description LogOutput is something that handles the Logger output.
       *
       * LogOutput is an abstract class, where all the LogMessage's
       * generated by the Logger go.
       * @Author Joao Reis
       */
      class LogOutput
      {
        public:
          /**
           * @Description Logs a message generated by the logger.
           * @Argument logMessage the message to log.
           * @Author Joao Reis
           */
          virtual void outputMessage (const LogMessage& logMessage) = 0;
          virtual ~LogOutput() {}
      };
      
      
      
      /**
       * @Class Logger
       * @Description Main class of the logger framework.
       * @Author Joao Reis
       */
      class Logger
      {
        public:
          // Knowledge about the levels should be all contained in the
          // LogLevels enum, but the logger also knows about them.
          // To minimize the number of classes that know about the
          // levels, only methods that don't depend on them are maked
          // virtual. Shortcuts should stay in this base class.
          
          /**
           * @Description Sets the prefix of the Logger.
           *
           * Each Logger can have exactly one prefix that is printed
           * before every message.
           * @Argument prefix The prefix to use.
           * @Author Joao Reis
           */
          virtual void setPrefix (const std::string& prefix) = 0;
          
          
          
          /**
           * @Description Enables a specific output for a specific log level.
           * @Argument logLevel The logLevel to associate.
           * @Argument logOutput The logOutput to associate with the logLevel.
           * @Author Joao Reis
           */
          virtual void enableLogLevel (const LogLevel& logLevel,
                                       shared_ptr<LogOutput> logOutput) = 0;
          /**
           * @Description Enables the error levels (LOG_ERROR, LOG_WARN and LOG_INFO) for the given output.
           * @Argument logOutput Will enable the levels for this logOutput.
           * @Author Joao Reis
           */
          void enableErrorLogLevels (shared_ptr<LogOutput> logOutput);
          /**
           * @Description Enables the reporting levels (LOG_BEGIN, LOG_END, LOG_STEP and LOG_SEPARATOR) for the given output.
           * @Argument logOutput Will enable the levels for this logOutput.
           * @Author Joao Reis
           */
          void enableReportingLogLevels (shared_ptr<LogOutput> logOutput);
          /**
           * @Description Enables all levels for the given output.
           * @Argument logOutput Will enable the levels for this logOutput.
           * @Author Joao Reis
           */
          void enableAllLogLevels (shared_ptr<LogOutput> logOutput);
          /**
           * @Description Disables a specified output for a specific level.
           * @Argument logLevel The logOutput will be disabled only for this level.
           * @Argument logOutput The logOutput to disble for the logLevel.
           * @Author Joao Reis
           */
          virtual void disableLogLevel (const LogLevel& logLevel,
                                        shared_ptr<LogOutput> logOutput) = 0;
          /**
           * @Description Disables all outputs for the specified logLevel.
           * @Argument logLevel All the outputs of this level will be disabled.
           * @Author Joao Reis
           */
          virtual void disableLogLevel (const LogLevel& logLevel) = 0;
          /**
           * @Description Disables all levels for the given output.
           * @Argument logOutput Will disable the levels for this logOutput.
           * @Author Joao Reis
           */
          void disableAllLogLevels (shared_ptr<LogOutput> logOutput);
          /**
           * @Description Disables all outputs for all the levels, completely stopping the Logger.
           *
           * This method will stop the logger if you need it. It is
           * necessary because you cannot delete the logger, it is always a shared_ptr.
           * @Author Joao Reis
           */
          void disableAllLogLevels();
          
          
          
          /**
           * @Description Logs a message, given in the form of a string.
           *
           * This is the main method of the logger, all the others
           * just call this one internally.
           *
           * Please mind that this method is not affected by MERMAID_LOGGER_DISABLE_REPORTING.
           * @Argument logLevel The log level to use.
           * @Argument message The message to log.
           * @Author Joao Reis
           */
          virtual void log (const LogLevel& logLevel,
                            const std::string& message) = 0;
          /**
           * @Description Logs a DataBox.
           *
           * Please mind that this method is not affected by MERMAID_LOGGER_DISABLE_REPORTING.
           * @Argument logLevel The log level to use.
           * @Argument message The message to log.
           * @Author Joao Reis
           */
          void log (const LogLevel& logLevel,
                    const mermaid::support::data::DataBox& message);
                    
                    
                    
          /**
          * @Description Logs a string with the level LOG_ERROR.
          * @Argument message The message to log.
          * @Author Joao Reis
          */
          void error (const std::string& message);
          /**
          * @Description Logs a string with the level LOG_WARN.
          * @Argument message The message to log.
          * @Author Joao Reis
          */
          void warn (const std::string& message);
          /**
          * @Description Logs a string with the level LOG_INFO.
          * @Argument message The message to log.
          * @Author Joao Reis
          */
          void info (const std::string& message);
          /**
          * @Description Logs a string with the level LOG_BEGIN.
          * @Argument message The message to log.
          * @Author Joao Reis
          */
          void begin (const std::string& message = "");
          /**
          * @Description Logs a string with the level LOG_SEPARATOR.
          * @Argument message The message to log.
          * @Author Joao Reis
          */
          void separator (const std::string& message = "");
          /**
          * @Description Logs a string with the level LOG_STEP.
          * @Argument message The message to log.
          * @Author Joao Reis
          */
          void step (const std::string& message);
          /**
          * @Description Logs a string with the level LOG_END.
          * @Argument message The message to log.
          * @Author Joao Reis
          */
          void end (const std::string& message = "");
          
          
          
        protected:
          Logger() {};
          // virtual ~Logger() {};
          // needed by effc++, hated by shared_ptr
      };
      
      
      
      /**
      * @Class ThreadSafeLogger
      * @Description Thread safe implementation of the logger.
      * @Author Joao Reis
      */
      class ThreadSafeLogger : public Logger
      {
        public:
          /**
          * @Description Creates a new ThreadSafeLogger with an empty prefix.
          * @Returns A shared_ptr to the new Logger.
          * @Author Joao Reis
          */
          static shared_ptr<Logger> build();
          /**
          * @Description Creates a new ThreadSafeLogger with the given prefix.
          * @Returns A shared_ptr to the new Logger.
          * @Argument prefix The prefix to use.
          * @Author Joao Reis
          */
          static shared_ptr<Logger> build (const std::string& prefix);
          
          
          
          /**
          * @Description Sets the prefix of the ThreadSafeLogger.
          *
          * Each Logger can have exactly one prefix that is printed
          * before every message.
          * @Argument prefix The prefix to use.
          * @Author Joao Reis
          */
          virtual void setPrefix (const std::string& prefix);
          
          
          
          /**
          * @Description Enables a specific output for a specific log level.
          * @Argument logLevel The logLevel to associate.
          * @Argument logOutput The logOutput to associate with the logLevel.
          * @Author Joao Reis
          */
          virtual void enableLogLevel (const LogLevel& logLevel,
                                       shared_ptr<LogOutput> logOutput);
          /**
          * @Description Disables a specified output for a specific level.
          * @Argument logLevel The logOutput will be disabled only for this level.
          * @Argument logOutput The logOutput to disble for the logLevel.
          * @Author Joao Reis
          */
          virtual void disableLogLevel (const LogLevel& logLevel,
                                        shared_ptr<LogOutput> logOutput);
          /**
          * @Description Disables all outputs for the specified logLevel.
          * @Argument logLevel All the outputs of this level will be disabled.
          * @Author Joao Reis
          */
          virtual void disableLogLevel (const LogLevel& logLevel);
          
          
          
          /**
          * @Description Logs a message, given in the form of a string.
          *
          * This is the main method of the logger, all the others
          * just call this one internally.
          *
          * Please mind that this method is not affected by MERMAID_LOGGER_DISABLE_REPORTING.
          * @Argument logLevel The log level to use.
          * @Argument message The message to log.
          * @Author Joao Reis
          */
          virtual void log (const LogLevel& logLevel,
                            const std::string& message);
                            
                            
                            
        private:
          ThreadSafeLogger();
          ThreadSafeLogger (const std::string& prefix);
          
          ACE_RW_Mutex mutex_;
          int indentation_;
          std::string prefix_;
          std::map <LogLevel, std::list<shared_ptr<LogOutput> > > levelOutputs_;
      };
      
      
      
      /**
       * @Class FastLogger
       * @Description Fast implementation of the logger, without any thread
       * synchronization.
       * @Author Joao Reis
       */
      class FastLogger : public Logger
      {
        public:
          /**
           * @Description Creates a new FastLogger with an empty prefix.
           * @Returns A shared_ptr to the new Logger.
           * @Author Joao Reis
           */
          static shared_ptr<Logger> build();
          /**
           * @Description Creates a new FastLogger with the given prefix.
           * @Returns A shared_ptr to the new Logger.
           * @Argument prefix The prefix to use.
           * @Author Joao Reis
           */
          static shared_ptr<Logger> build (const std::string& prefix);
          
          
          
          /**
           * @Description Sets the prefix of the FastLogger.
           *
           * Each Logger can have exactly one prefix that is printed
           * before every message.
           * @Argument prefix The prefix to use.
           * @Author Joao Reis
           */
          virtual void setPrefix (const std::string& prefix);
          
          
          
          /**
           * @Description Enables a specific output for a specific log level.
           * @Argument logLevel The logLevel to associate.
           * @Argument logOutput The logOutput to associate with the logLevel.
           * @Author Joao Reis
           */
          virtual void enableLogLevel (const LogLevel& logLevel,
                                       shared_ptr<LogOutput> logOutput);
          /**
           * @Description Disables a specified output for a specific level.
           * @Argument logLevel The logOutput will be disabled only for this level.
           * @Argument logOutput The logOutput to disble for the logLevel.
           * @Author Joao Reis
           */
          virtual void disableLogLevel (const LogLevel& logLevel,
                                        shared_ptr<LogOutput> logOutput);
          /**
           * @Description Disables all outputs for the specified logLevel.
           * @Argument logLevel All the outputs of this level will be disabled.
           * @Author Joao Reis
           */
          virtual void disableLogLevel (const LogLevel& logLevel);
          
          
          
          /**
           * @Description Logs a message, given in the form of a string.
           *
           * This is the main method of the logger, all the others
           * just call this one internally.
           *
           * Please mind that this method is not affected by MERMAID_LOGGER_DISABLE_REPORTING.
           * @Argument logLevel The log level to use.
           * @Argument message The message to log.
           * @Author Joao Reis
           */
          virtual void log (const LogLevel& logLevel,
                            const std::string& message);
                            
                            
                            
        private:
          FastLogger();
          FastLogger (const std::string& prefix);
          
          int updateIndentation_ (const LogLevel& logLevel);
          int indentation_;
          std::string prefix_;
          std::map <LogLevel, std::list<shared_ptr<LogOutput> > > levelOutputs_;
#ifdef MERMAID_LOGGER_QUICK_PROFILING
          std::stack<struct timeval> beginTimes_;
#endif //MERMAID_LOGGER_QUICK_PROFILING
      };
      
      
      
      /**
       * @Class ThreadSafeOutput
       * @Description Adds mutual exclusion to another output.
       * @Author Joao Reis
       */
      class ThreadSafeOutput : public LogOutput
      {
        public:
          /**
           * @Description ThreadSafeOutput
           * @Argument output The output to guard.
           * @Returns A shared_ptr to the new ThreadSafeOutput.
           * @Author Joao Reis
           */
          static shared_ptr<ThreadSafeOutput> build (shared_ptr<LogOutput> output);
          /**
           * @Description Logs a message generated by the logger.
           * @Argument logMessage the message to log.
           * @Author Joao Reis
           */
          void outputMessage (const LogMessage& logMessage);
          
        private:
          ThreadSafeOutput (shared_ptr<LogOutput> output);
          ACE_Mutex mutex_;
          shared_ptr<LogOutput> output_;
      };
      
      
      
      /**
      * @Class TerminalOutput
      * @Description Prints LogMessage's to the standard output.
      * @Author Joao Reis
      */
      class TerminalOutput : public LogOutput
      {
        public:
          /**
          * @Description Gets the TerminalOutput.
          * Beware that the TerminalOutput is a singleton accessible only
          * through a ThreadSafeOutput.
          * @Returns A shared_ptr to the new TerminalOutput.
          * @Author Joao Reis
          */
          static shared_ptr<ThreadSafeOutput> build();
          /**
          * @Description Logs a message generated by the logger.
          * @Argument logMessage the message to log.
          * @Author Joao Reis
          */
          void outputMessage (const LogMessage& logMessage);
          
        private:
          TerminalOutput() {}
          static shared_ptr<ThreadSafeOutput> instance_;
      };
      
      
      
      /**
      * @Class FileOutput
      * @Description Appends LogMessage's to a file.
      * @Author Joao Reis
      */
      class FileOutput : public LogOutput
      {
        public:
          /**
          * @Description Creates a new FileOutput for the given file.
          * Beware that only one file output should exist for each file.
          * You are responsible to sychronize that output with a
          * ThreadSafeOutput if you need.
          * @Returns A shared_ptr to the new FileOutput.
          * @Argument fileName The name of the file to append to.
          * @Author Joao Reis
          */
          static shared_ptr<FileOutput> build (std::string fileName);
          /**
          * @Description Logs a message generated by the logger.
          * @Argument logMessage the message to log.
          * @Author Joao Reis
          */
          void outputMessage (const LogMessage& logMessage);
          
        private:
          FileOutput (std::string fileName);
          std::string fileName_;
          std::ofstream fileStream_;
      };
      
      
      
      /**
      * @Class LogScope
      * @Description LogScope is a helper to use the logger.
      *
      * LogScope automatically makes the end level calls
      * within it's destructor.
      * @Author Joao Reis
      */
      class LogScope
      {
        public:
          /**
          * @Description Constructor: No begin message and empty end message.
          * This is only used to call begin and call end automatically
          * when the object goes out of scope.
          * @Argument logger The logger to use.
          * @Author Joao Reis
          */
          LogScope (shared_ptr<Logger> logger);
          /**
          * @Description Constructor: Only a begin message.
          * @Argument logger The logger to use.
          * @Argument beginMessage The message to log with level LOG_BEGIN right away.
          * @Author Joao Reis
          */
          LogScope (shared_ptr<Logger> logger,
                    const std::string& beginMessage);
          /**
          * @Description Constructor: Begin and end messages.
          * @Argument logger The logger to use.
          * @Argument beginMessage The message to log with level LOG_BEGIN right away.
          * @Argument endMessage The message to log with level LOG_END when the class is destroyed.
          * @Author Joao Reis
          */
          LogScope (shared_ptr<Logger> logger,
                    const std::string& beginMessage,
                    const std::string& endMessage);
          ~LogScope();
        private:
          shared_ptr<Logger> logger_;
          std::string endMessage_;
          bool shouldShowMessage_;
          
          LogScope (LogScope &logScope);
      };
      
      
      
      namespace LogAux
      {
        using std::set;
        using std::string;
        using std::ostringstream;
        
        inline string toStr (const set<string>& strings)
        {
          ostringstream s;
          s << "[";
          bool isFirst = true;
          foreach (string t, strings) {
            if (!isFirst)
              s << ",";
            s << " " << t;
            isFirst = false;
          }
          s << " ]";
          return s.str();
        }
      }
      
      
      
      // Logger inline methods
      
      inline void Logger::log (const LogLevel& logLevel,
                               const mermaid::support::data::DataBox& message)
      {
        log (logLevel, static_cast<std::string> (message));
      }
      
      
      
      inline void Logger::error (const std::string& message)
      {
        log (LOG_ERROR, message);
      }
      inline void Logger::warn (const std::string& message)
      {
        log (LOG_WARN, message);
      }
      inline void Logger::info (const std::string& message)
      {
        log (LOG_INFO, message);
      }
#ifndef MERMAID_LOGGER_DISABLE_REPORTING
      inline void Logger::begin (const std::string& message)
      {
        log (LOG_BEGIN, message);
      }
      inline void Logger::separator (const std::string& message)
      {
        log (LOG_SEPARATOR, message);
      }
      inline void Logger::step (const std::string& message)
      {
        log (LOG_STEP, message);
      }
      inline void Logger::end (const std::string& message)
      {
        log (LOG_END, message);
      }
#else
      inline void Logger::begin (const std::string& message) {}
      inline void Logger::separator (const std::string& message) {}
      inline void Logger::step (const std::string& message) {}
      inline void Logger::end (const std::string& message) {}
#endif // MERMAID_LOGGER_DISABLE_REPORTING
    }
  }
}

#endif // LOGGER_HPP