#ifndef debug_h
#define debug_h

#include <string>
#include <iostream>
#include <typeinfo>

#define debug0  if (true) {} else std::cerr

#ifdef NDEBUG
    #define debug if (true) {} else std::cerr
    #define debug_TRACE (void) 0
    #define debug_TRACE_PRETTY (void) 0
    #define debug_TRACE_LINE (void) 0
#else
    #define debug               debug_t()
    #define debug_TRACE         debug_trace_t debug_trace_tmp( __FUNCTION__, __FILE__, __LINE__)
    #define debug_TRACE_PRETTY  debug_trace_t debug_trace_tmp( __PRETTY_FUNCTION__, __FILE__, __LINE__)
    #define debug_TRACE_LINE    debug_trace_line( __FUNCTION__, __FILE__, __LINE__)
#endif

#define debug_SR(x)  debug_VL(x)
#define debug_VL(x)  #x
#define debug_PLACE  "File '" __FILE__ "', line " debug_SR( __LINE__) ". "

const std::string&	debug_prefix();

struct debug_t
{
    debug_t();
    ~debug_t();
    mutable std::ostream&   stream;
};

template< class T>
const debug_t& operator << ( const debug_t& out, const T& t)
{
    out.stream << t;
    return out;
}

struct  debug_trace_t
{
    debug_trace_t( const char* name, const char* file, int line);
    ~debug_trace_t();
};


#ifdef NDEBUG
    inline void debug_output_backtraces( std::ostream&) {}
    inline void debug_output_backtraces()               {}
    inline int  debug_level_set( int)                   { return 0; }
#else
    void    debug_output_backtraces( std::ostream& out);
    void    debug_output_backtraces();  // output using debug
    void    debug_trace_line( const char* fn, const char* file, int line);
    int     debug_level_set( int newlevel); /* returns old level */
#endif

/* debug_count is a class template that maintains a count
of the number of its instances, and outputs diagnostics
whenever it is created/destroyed, being careful to protect
the increments/decrements with a mutex.
Intended to check for leaks of objects. Typically used as
a base class - the class is empty in non-debug builds, so
the empty base class optimisation will ensure that there
is no space wasted.
*/
#ifdef NDEBUG
    template< class T>
    struct debug_count {};
#else
    
    void    debug_count_increment( int& count, const std::type_info& type);
    void    debug_count_decrement( int& count, const std::type_info& type);
    
    template< class T>
    struct debug_count
    {
        static int count;
        debug_count()
        {
            debug_count_increment( this->count, typeid( T));
        }
        debug_count( const debug_count&)
        {
            debug_count_increment( this->count, typeid( T));
        }
        ~debug_count()
        {
            debug_count_decrement( this->count, typeid( T));
        }
    };
#endif

#endif