libH/Debug.hpp

Go to the documentation of this file.

/*
  
  Copyright (c) 2007, Tim Burrell
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at 

        http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and 
  limitations under the License. 
  
*/

#ifndef __Debug_h
#define __Debug_h

#if HAVE_CONFIG_H
#include "config.h"
#endif

#include "Exception.hpp"
#include <iostream>
#include <ostream>
#include <fstream>
#include <string>

// Namespace

namespace H {
        
// Define's, typedefs

#define debugOutput(out) \
        std::cout << out; \
        if (Debug::mLogToFile) { \
                Debug::mLogFile.open(Debug::mLogPath.c_str(), std::ios::app); \
                if (Debug::mLogFile.is_open()) { \
                        Debug::mLogFile << out; \
                        Debug::mLogFile.close(); \
                } \
        } \
        return dbg

// Class Definition

class Debug {
public:
        inline static bool              getEnabled() { return mDebug; };
        
        inline static int               getVerbosity() { return mVerbosity; };
        
        inline static void              setEnabled(bool Enable) { mDebug = Enable; };
        
        inline static void              setLog(std::string const & LogFile);
        
        inline static void              setVerbosity(int Verbosity) { mVerbosity = Verbosity; };
        
        inline friend const Debug&      operator << (const Debug & dbg, const char * s);
        inline friend const Debug&      operator << (const Debug & dbg, const std::string & s);
        inline friend const Debug&      operator << (const Debug & dbg, const char c);
        inline friend const Debug&      operator << (const Debug & dbg, const int d);
        inline friend const Debug&      operator << (const Debug & dbg, const unsigned int d);
        inline friend const Debug&      operator << (const Debug & dbg, const long l);
        inline friend const Debug&      operator << (const Debug & dbg, const long long ll);
        inline friend const Debug&      operator << (const Debug & dbg, const bool b);
        inline friend const Debug&      operator << (const Debug & dbg, const unsigned long l);
        inline friend const Debug&      operator << (const Debug & dbg, const unsigned long long ll);
        inline friend const Debug&      operator << (const Debug & dbg, const double lf);
        inline friend const Debug&      operator << (const Debug & dbg, std::ostream&(*f)(std::ostream&)); // for endl

        inline static bool              testPrint(const Debug& dbg) { return ((dbg.mDebug) && (dbg.mVerbosity >= dbg.mThisVerbosity)); };
        
        Debug(int ThisVerbosity);
        virtual ~Debug();
        
private:
        static bool                     mDebug;                 
        static std::ofstream            mLogFile;               
        static std::string              mLogPath;               
        static bool                     mLogToFile;             
        int                             mThisVerbosity;         
        static int                      mVerbosity;             
};


inline void Debug::setLog(std::string const & LogFile) {
        Debug::mLogFile.open(LogFile.c_str(), std::ios::app);
        if (!Debug::mLogFile.is_open()) {
                Debug::mLogPath = "";
                Debug::mLogToFile = false;
                throw H::Exception("Invalid Debug Log [" + LogFile + "] Specified! -- Logging to File Disabled", __FILE__, __FUNCTION__, __LINE__);
        }
        Debug::mLogPath = LogFile;
        Debug::mLogToFile = true;
        Debug::mLogFile.close();
}

inline const Debug& operator << (const Debug & dbg, const std::string & out) {
        debugOutput(out);
}

inline const Debug& operator << (const Debug & dbg, const char * out) {
        debugOutput(out);
}

inline const Debug& operator << (const Debug & dbg, const char out) {
        debugOutput(out);
}

inline const Debug& operator << (const Debug & dbg, const int out) {
        debugOutput(out);
}

inline const Debug& operator << (const Debug & dbg, const unsigned int out) {
        debugOutput(out);
}

inline const Debug& operator << (const Debug & dbg, const long out) {
        debugOutput(out);
}

inline const Debug& operator << (const Debug & dbg, const long long out) {
        debugOutput(out);
}

inline const Debug& operator << (const Debug & dbg, const bool out) {
        debugOutput(out);
}

inline const Debug& operator << (const Debug & dbg, const unsigned long out) {
        debugOutput(out);
}

inline const Debug& operator << (const Debug & dbg, const unsigned long long out) {
        debugOutput(out);
}

inline const Debug& operator << (const Debug & dbg, const double out) {
        debugOutput(out);
}

inline const Debug& operator << (const Debug & dbg, std::ostream&(* out)(std::ostream &)) {
        debugOutput(out);
}

static const Debug dbg0(0); 
static const Debug dbg1(1); 
static const Debug dbg2(2); 
static const Debug dbg3(3); 
static const Debug dbg4(4); 
static const Debug dbg5(5); 

#define cdbg    if (H::Debug::testPrint(dbg0)) H::dbg0
#define cdbg1   if (H::Debug::testPrint(dbg1)) H::dbg1
#define cdbg2   if (H::Debug::testPrint(dbg2)) H::dbg2
#define cdbg3   if (H::Debug::testPrint(dbg3)) H::dbg3
#define cdbg4   if (H::Debug::testPrint(dbg4)) H::dbg4
#define cdbg5   if (H::Debug::testPrint(dbg5)) H::dbg5
                                
} // H namespace


#endif // __Debug_h

---