debug.hh

Go to the documentation of this file.

// Copyright (C) 2008, 2009 by Florent Lamiraux, Thomas Moulard, CNRS.
//
// This file is part of the hpp-util.
//
// This software is provided "as is" without warranty of any kind,
// either expressed or implied, including but not limited to the
// implied warranties of fitness for a particular purpose.
//
// See the COPYING file for more information.

#ifndef HPP_UTIL_DEBUG_HH
# define HPP_UTIL_DEBUG_HH
# include <cstdlib>
# include <ostream>
# include <fstream>
# include <sstream>
# include <vector>

# include <hpp/util/config.hh>
# include <hpp/util/indent.hh>

namespace hpp
{
  namespace debug
  {
    class Output;
    class JournalOutput;
    class ConsoleOutput;

    class Channel;
  } // end of namespace debug
} // end of namespace hpp.


namespace hpp
{
  namespace debug
  {
    HPP_UTIL_DLLAPI std::string getPrefix (const std::string& packageName);

    HPP_UTIL_DLLAPI std::string getFilename (const std::string& filename,
                    const std::string& packageName);

    class HPP_UTIL_DLLAPI Output
    {
    public:
      explicit Output ();
      virtual ~Output ();

      virtual void
    write (const Channel& channel,
           char const* file,
           int line,
           char const* function,
           const std::string& data) = 0;

      virtual void
    write (const Channel& channel,
           char const* file,
           int line,
           char const* function,
           const std::stringstream& data) = 0;

    protected:
      std::ostream&
    writePrefix (std::ostream& stream,
             const Channel& channel,
             char const* file,
             int line,
             char const* function);
    };

    class HPP_UTIL_DLLAPI Channel
    {
    public:
      typedef std::vector<Output*> subscribers_t;

      explicit Channel (char const* label,
            const subscribers_t& subscribers);
      virtual ~Channel ();

      void write (char const* file,
          int line,
          char const* function,
          const std::string& data);

      void write (char const* file,
          int line,
          char const* function,
                  const std::stringstream& data);

      const char* label () const;
    private:
      const char* label_;
      subscribers_t subscribers_;
    };

    class HPP_UTIL_DLLAPI JournalOutput : public Output
    {
    public:
      explicit JournalOutput (std::string filename);
      ~JournalOutput ();

      void write (const Channel& channel,
          char const* file,
          int line,
          char const* function,
          const std::string& data);

      void write (const Channel& channel,
          char const* file,
          int line,
          char const* function,
          const std::stringstream& data);

      std::string getFilename () const;

    private:
      std::string filename;
      std::string lastFunction;
      std::ofstream stream;
    };

    class HPP_UTIL_DLLAPI ConsoleOutput : public Output
    {
    public:
      explicit ConsoleOutput ();
      ~ConsoleOutput ();
      void write (const Channel& channel,
          char const* file,
          int line,
          char const* function,
          const std::string& data);
      void write (const Channel& channel,
          char const* file,
          int line,
          char const* function,
          const std::stringstream& data);
    };

    class HPP_UTIL_DLLAPI Logging
    {
    public:
      explicit Logging ();
      ~Logging ();

      ConsoleOutput console;
      JournalOutput journal;
      JournalOutput benchmarkJournal;

      Channel error;

      Channel warning;

      Channel notice;

      Channel info;

      Channel benchmark;
    };
  } // end of namespace debug
} // end of namespace hpp.


namespace hpp
{
  namespace debug
  {
    extern HPP_UTIL_DLLAPI Logging logging;
  } // end of namespace debug
} // end of namespace hpp


# ifdef HPP_DEBUG


#  define hppDebug(statement)           \
  do {                      \
    using namespace ::hpp::debug;       \
    { statement; }              \
  } while(0)

#  define hppDebugStatement(statement)      \
  statement



#  define hppDout(channel, data)                    \
  do {                                  \
    using namespace hpp;                        \
    using namespace ::hpp::debug;                   \
    std::stringstream __ss;                     \
    __ss << data << iendl;                      \
    logging.channel.write (__FILE__, __LINE__, __PRETTY_FUNCTION__,     \
               __ss);                   \
  } while (0)

#  define hppDoutFatal(channel, data)                   \
  do {                                  \
    using namespace hpp;                        \
    using namespace ::hpp::debug;                   \
    std::stringstream __ss;                     \
    __ss << data << iendl;                      \
    logging.channel.write ( __FILE__, __LINE__, __PRETTY_FUNCTION__,    \
                __ss);                  \
    ::std::exit(EXIT_FAILURE);                      \
  } while (1)


# else

#  define hppDebug(statement)           \
  do {                                          \
  } while (0)
#  define hppDebugStatement(statement)
#  define hppDout(channel, data)                \
  do {                                          \
  } while (0)
#  define hppDoutFatal(channel, data)       \
  do {                      \
    using namespace hpp;            \
    ::std::cerr << data << iendl;       \
    ::std::exit (EXIT_FAILURE);         \
  } while (1)

# endif // HPP_DEBUG

#endif