jafarDebug.hpp

/* $Id$ */

#ifndef KERNEL_JAFAR_DEBUG_HPP
#define KERNEL_JAFAR_DEBUG_HPP

#include <iostream>
#include <fstream>
#include <string>
#include <map>
#include <list>
#include <vector>

// we could use a better singleton here...
#include <boost/serialization/singleton.hpp>

namespace jafar { 
  namespace debug {

#ifndef SWIG
    
    class DebugStream;
    // special functions needed for the stream definition
    namespace details
    {
        typedef DebugStream& (*stream_function)(DebugStream& stream);
        typedef std::ios_base&(*iosbase_function)(std::ios_base&);
    }

#endif // SWIG


    class DebugStream {

    public:

      enum Level {Off              = 0, 
      Trace            = 1, 
      Warning          = 2, 
      Debug            = 3, 
      VerboseDebug     = 4, 
      VeryVerboseDebug = 5  
      };

      static void setDefaultLevel(Level level_) {
  instance().defaultLevel = level_;
      }

      static void setLevel(std::string const& module_, Level level_) {
  instance().modulesLevel[module_]=level_;
      }

      static void moduleOff(std::string const& module_) { 
  setLevel(module_, DebugStream::Off); 
      }

      static void moduleWarning(std::string const& module_) { 
  setLevel(module_, DebugStream::Warning); 
      }

      static void moduleDebug(std::string const& module_) { 
  setLevel(module_, DebugStream::Debug); 
      }

      static void moduleVerboseDebug(std::string const& module_) { 
  setLevel(module_, DebugStream::VerboseDebug); 
      }

      static void moduleVeryVerboseDebug(std::string const& module_) {
  setLevel(module_, DebugStream::VeryVerboseDebug); 
      }

      static void unsetModule(std::string const& module_) {
  instance().modulesLevel.erase(module_);
      }

      static void setOutputFile(std::string const& filename_);

      static void setDefaultStream();

#ifndef SWIG // hide these methods in the interactive interface

      static void setStream(std::ostream& os_) { 
  instance().debugStream = &os_; 
      }

      static void setup(std::string const& module_, Level level_, bool display_ = true);

      static void sendLocation(std::string const& module_, char const* file_, int line_);

      static DebugStream& instance() {
  // we could use better singleton here...
  return boost::serialization::singleton<DebugStream>::get_mutable_instance(); 

      }

#endif // SWIG

    private: 

      std::ostream* debugStream;

      std::ofstream fileStream;
      bool fsOpen;

      std::map<std::string, Level> modulesLevel;

      Level defaultLevel;

      bool debugging;

      DebugStream();
      ~DebugStream();

      bool isDebugging() const { return debugging; }

      static std::ostream& stream() { return *(instance().debugStream); }

      /*
     * The documented method
     * http://www.boost.org/doc/libs/1_49_0/libs/serialization/doc/singleton.html
     * does not seem to work. Use the following friend hack to make it work,
     * but it is not really better than previous, as it depends on something
     * which can break at any instant
     */
    friend class boost::serialization::detail::singleton_wrapper<DebugStream>;

      friend DebugStream& operator << (DebugStream& debugStream, 
               details::stream_function function);
      friend DebugStream& operator << (DebugStream& debugStream, 
               details::iosbase_function function);
      friend DebugStream& endl(DebugStream& debugStream);

      template<typename T>
      friend DebugStream& operator << (DebugStream& debugStream, 
               T const& value);
    }; // class DebugStream


#ifndef SWIG

    // special functions needed for the stream definition

    inline DebugStream& operator << (DebugStream& debugStream, details::stream_function function)
    { 
        if (debugStream.isDebugging())
    return function(debugStream);
        
  return debugStream;
    }

    inline DebugStream& operator << (DebugStream& debugStream, details::iosbase_function function)
    { 
        if (debugStream.isDebugging())
    function(debugStream.stream()); 
        
        return debugStream;
    }

    template<typename T>
    inline DebugStream& operator << (DebugStream& debugStream, T const& value)
    {
      if (debugStream.isDebugging())
        debugStream.stream() << value;

      return debugStream;
    }

    inline DebugStream& endl(DebugStream& debugStream)
    {
      if (debugStream.isDebugging())
  debugStream.stream() << std::endl;

      return debugStream;
    }

    template< typename _Type_ >
    std::ostream& operator<<(std::ostream& s, const std::list<_Type_*>& gr)
    {
      s << " ( ";
      for( typename std::list<_Type_*>::const_iterator it = gr.begin(); it != gr.end(); ++it )
      {
        if( it != gr.begin() ) s << " , ";
        s << **it;
      }
      s << " ) ";
      return s;
    }

    template< typename _Type_ >
    std::ostream& operator<<(std::ostream& s, const std::list<_Type_>& gr)
    {
      s << " ( ";
      for( typename std::list<_Type_>::const_iterator it = gr.begin(); it != gr.end(); ++it )
      {
        if( it != gr.begin() ) s << " , ";
        s << *it;
      }
      s << " ) ";
      return s;
    }
    
    template< typename _Type_ >
    std::ostream& operator<<(std::ostream& s, const std::vector<_Type_*>& gr)
    {
      s << " ( ";
      for( typename std::vector<_Type_*>::const_iterator it = gr.begin(); it != gr.end(); ++it )
      {
        if( it != gr.begin() ) s << " , ";
        s << **it;
      }
      s << " ) ";
      return s;
    }
    
    template< typename _Type_ >
    std::ostream& operator<<(std::ostream& s, const std::vector<_Type_>& gr)
    {
      s << " ( ";
      for( typename std::vector<_Type_>::const_iterator it = gr.begin(); it != gr.end(); ++it )
      {
        if( it != gr.begin() ) s << " , ";
        s << *it;
      }
      s << " ) ";
      return s;
    }

#endif // SWIG
    
  } // namespace debug
} // namespace jafar


#include "kernel/jafarMacro.hpp"

#endif // KERNEL_JAFAR_DEBUG_HPP