source: XMLIO_V2/dev/dev_rv/src/XMLIO/logger.hpp @ 120

#ifndef __XMLIO_LOGGER__
#define __XMLIO_LOGGER__

// Entête Poco logging
#include <Poco/Logger.h>
#include <Poco/PatternFormatter.h>
#include <Poco/FormattingChannel.h>
#include <Poco/ConsoleChannel.h>
#include <Poco/FileChannel.h>
#include <Poco/Message.h>

#include <Poco/AutoPtr.h>

#include <csignal>

#ifdef __GNUC__
#include <execinfo.h>
#include <cxxabi.h>
#endif // __GNUC__

// Classes utilisées issues de Poco
using Poco::Logger;
using Poco::PatternFormatter;
using Poco::FormattingChannel;
using Poco::ConsoleChannel;
using Poco::FileChannel;
using Poco::Message;

using Poco::AutoPtr;

namespace XMLIOSERVER
{
   class ILogger
   {
      public :

         ILogger()
         {
            // TODO Créer une sortie fichier.
            AutoPtr<PatternFormatter> pf = new PatternFormatter("[%Y-%m-%d %H:%M:%S] %t");
            AutoPtr<ConsoleChannel> cc = new ConsoleChannel();
            AutoPtr<FormattingChannel> pFCConsole = new FormattingChannel(pf);
            pFCConsole->setChannel(cc);
            pFCConsole->open();
            Logger::create("ConsoleLogger", pFCConsole, Message::PRIO_INFORMATION);

            signal(SIGSEGV, SigHandler);
         }

         static void ShowBTrace(std::ostream& out = std::clog)
         {
#ifdef __GNUC__
            int status = 0;
            string value;
            void *stack_addrs[20] = {NULL};
            size_t stack_depth = backtrace(stack_addrs, 20);
            char **stack_strings = backtrace_symbols(stack_addrs, stack_depth);

            out << "Trace : " << std::endl;
            for (size_t i = 2, j = 0; i < stack_depth; i++)
            {
               value.assign(stack_strings[i]);
               size_t bpos = value.find ('('), epos = value.find ('+');
               if ((bpos != string::npos) and (epos != string::npos))
               {
                  char* demangled_name = abi::__cxa_demangle(value.substr(bpos+1, epos-bpos-1).c_str(), 0, 0, &status);
                  if (status == 0) out << "   "  << ++j << " -> "  << (demangled_name) << std::endl;
                  else out << "   "  << ++j << " -> "  << value.substr(bpos+1, epos-bpos-1) << std::endl;
                  free(demangled_name);
               }
            }

            free(stack_strings);
#endif // __GNUC__
         }

         static void SigHandler(int _sigValue)
         {
            std::cerr << "============= Erreur =============" << std::endl;
            std::cerr << "Signal " << _sigValue << " reçu !" << std::endl;
            ShowBTrace(std::cerr);
            std::cerr << "==================================" << std::endl;
            exit(EXIT_FAILURE);
         }


         static Logger & GetConsoleLogger(void) {return (Logger::get("ConsoleLogger"));}

         ~ILogger(void)
         { /* Ne rien faire de plus */ }

   }; // class XMLIOLogger

   // Initialisation de la classe de Logging
   ILogger LOGGER;

   /////////////////////////////////////////////////////////////////////
   unsigned int Indent = 0;
   const char*  Increm = "   ";

   std::ostream& NIndent(std::ostream& out)
   {
      static unsigned int LineNB = 1;
      out<< LineNB++ << ". ";
      for(unsigned int i = 0;i < Indent; i++) out << Increm;
      return(out);
   }

   std::ostream& IncIndent(std::ostream& out) { Indent++; return (NIndent(out)); }
   std::ostream& DecEndl(std::ostream& out) { Indent--; return (out); }
   /////////////////////////////////////////////////////////////////////

} // namespace XMLIOSERVER

#define   ERROR(MSG)   (XMLIOSERVER::ILogger::GetConsoleLogger().error(MSG))
#define   WARNING(MSG) (XMLIOSERVER::ILogger::GetConsoleLogger().warning(MSG))
#define   INFO(MSG)    (XMLIOSERVER::ILogger::GetConsoleLogger().information(MSG))
// A compléter.

#endif // __XMLIO_LOGGER__