Debug.h

# ifndef Conjecture_Debug_h
# define Conjecture_Debug_h Conjecture_Debug_h

// Insert SVN header substitution variable here
// Class Champion: Unassigned

#include "Root.h"
#include <iostream>
#include <sstream>

namespace Conjecture {

    class Debug : public Root {
        public:

            typedef enum {
                DEBUG_LEVEL_NONE          = 0x00,   
                DEBUG_LEVEL_ERROR         = 0x01,   
                DEBUG_LEVEL_WARNING       = 0x02,   
                DEBUG_LEVEL_INFO          = 0x04,   
                DEBUG_LEVEL_IMAGES_BASIC  = 0x40,   
                DEBUG_LEVEL_IMAGES_FULL   = 0x80,   
                DEBUG_LEVEL_ALL           = 0xFF    
            } verboseLevel;

            static Debug &getHandle(void) {
                static Debug *singleton = new Debug();
                return *singleton;
            }

            inline void setLogStream(std::ostream &s) {
                this->_outStream = &s;
            }

            inline void toggleLevel(verboseLevel l) {
                this->_level = static_cast<verboseLevel>(l | this->_level);
            }

            inline void untoggleLevel(verboseLevel l) {
                this->_level = static_cast<verboseLevel>((~l) & this->_level);
            }

            inline void setLevel(verboseLevel l) {
                this->_level = l;
            }

            inline bool isInLevel(verboseLevel l) {
                if ((l & this->_level) != 0) {
                    return true;
                }
                return false;
            }

            virtual void header(verboseLevel l);

            virtual Debug & operator<< (const std::string &str);
            
            virtual Debug & operator<< (const char *str);

        protected:
            verboseLevel            _level;           
            inline std::ostream* outStream() { return this->_outStream; }

            inline const char *levelToString(verboseLevel l) const {
                switch (l) {
                  case DEBUG_LEVEL_ERROR:
                    return (const char *)"ERROR:: ";
                  case DEBUG_LEVEL_WARNING:
                    return (const char *)"WARNING: ";
                  case DEBUG_LEVEL_INFO:
                    return (const char *)"Info: ";
                  case DEBUG_LEVEL_IMAGES_BASIC:
                    return (const char *)"Image (basic): ";
                  case DEBUG_LEVEL_IMAGES_FULL:
                    return (const char *)"Image (full): ";
                  default:
                    return (const char *)"Unknown: ";
                }
                // should never happen
                return NULL;
            }

            virtual ~Debug();

      private:
            std::ostream            *_outStream;      
            Debug();

            void operator=(Debug &);

            Debug(const Debug &);
    };

#ifdef ENABLE_LOG
 #define LOG(level, message) \
    if (Debug::getHandle().isInLevel(Conjecture::Debug::level)) { \
            Debug::getHandle().header(libglass::Log::level); \
            std::stringstream ___s; \
            ___s << message; \
            l << ___s.str(); \
        } \
    }
#else
 #define LOG(l, level, message)
#endif


} // namespace

#endif

---