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

#ifndef __XMLIO_LOGGER__
#define __XMLIO_LOGGER__

#include <csignal>

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

using std::string;

namespace XMLIOSERVER
{
   class ILogger : public std::ostringstream
   {
      private :

         ILogger(void)
         { signal(SIGSEGV, SigHandler); }

      private : /* static */

         static ILogger LOGGER;

      public : /* static */

         static ILogger& GetLogger(void) { return (ILogger::LOGGER); }

         static void Flush(std::ostream& out = std::clog)
         { ILogger::GetLogger().flush(out); }

         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);
         }

      public :

         void flush(std::ostream& out = std::clog)
         { out << str() << std::endl; str(""); }

         ~ILogger(void) { this->flush(); }

   }; // class XMLIOLogger

   // Initialisation de la classe de Logging
   ILogger 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)\
   (ILogger::GetLogger() << __FILE__ << ":" << __LINE__ << ": error : "   << MSG << std::endl)
#define   WARNING(MSG)\
   (ILogger::GetLogger() << __FILE__ << ":" << __LINE__ << ": warning : " << MSG << std::endl)
#define   INFO(MSG)\
   (ILogger::GetLogger() << __FILE__ << ":" << __LINE__ << ": info : "    << MSG << std::endl)
// A compléter.

#endif // __XMLIO_LOGGER__