Debug.H

Go to the documentation of this file.

/* Copyright 2000-2018 Matt Flax <flatmax@flatmax.org>
   This file is part of GTK+ IOStream class set

   GTK+ IOStream is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GTK+ IOStream is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You have received a copy of the GNU General Public License
   along with GTK+ IOStream
 */
#ifndef DEBUG_H_
#define DEBUG_H_

#include <stdio.h>

#include <errno.h>

#ifndef uint
typedef unsigned int uint;
#endif

#ifdef NO_ERROR
#if (NO_ERROR!=0)
#error "NO_ERROR previously defined but not equal to zero"
#endif
#else
#define NO_ERROR 0 
#endif

#ifndef DEBUG_ERROR_OFFSET
#define  DEBUG_ERROR_OFFSET -39901 
#endif

// Values between -39 900 and -1 are reserved for the user.
#ifndef WSOLA_ERROR_OFFSET
#define  WSOLA_ERROR_OFFSET -40001 
#endif

#ifndef SOX_ERROR_OFFSET
#define SOX_ERROR_OFFSET -40020 
#endif

#ifndef JACK_ERROR_OFFSET
#define JACK_ERROR_OFFSET -40040 
#endif

#ifndef DECOMPOSITION_ERROR_OFFSET
#define DECOMPOSITION_ERROR_OFFSET -40080 
#endif

#ifndef AUDIOMASKER_ERROR_OFFSET
#define AUDIOMASKER_ERROR_OFFSET -40090 
#endif

#ifndef OVERLAPADD_ERROR_OFFSET
#define OVERLAPADD_ERROR_OFFSET -40110 
#endif

#ifndef IIO_ERROR_OFFSET
#define IIO_ERROR_OFFSET -40150 
#endif

#ifndef DIRSCAN_ERROR_OFFSET
#define DIRSCAN_ERROR_OFFSET -40200 
#endif

#ifndef THREAD_ERROR_OFFSET
#define THREAD_ERROR_OFFSET -40300 
#endif

#ifndef DRAGNDROP_ERROR_OFFSET
#define DRAGNDROP_ERROR_OFFSET -40400 
#endif

#ifndef ALSA_ERROR_OFFSET
#define ALSA_ERROR_OFFSET -40500 
#endif

#ifndef IIR_ERROR_OFFSET
#define IIR_ERROR_OFFSET -40600 
#endif

#ifndef FIR_ERROR_OFFSET
#define FIR_ERROR_OFFSET -40650 
#endif

// #ifndef DSF_ERROR_OFFSET
// #define DSF_ERROR_OFFSET -40650
// #endif

#define MAX_ERROR_OFFSET DEBUG_ERROR_OFFSET 
#define MIN_ERROR_OFFSET (FIR_ERROR_OFFSET-1000) 
//#define MIN_ERROR_OFFSET (DSF_ERROR_OFFSET-1000) 

#include <map>
#include <string>
#include <string.h>

class Debug {
    #define MALLOC_ERROR DEBUG_ERROR_OFFSET-0 
protected:
    std::map<int, std::string> errors; 
public:
    Debug() {
#ifndef NDEBUG
        errors[NO_ERROR]=std::string("No error. ");
        errors[MALLOC_ERROR]=std::string("Couldn't allocate the memory error. ");
#endif
    }
    virtual ~Debug() {}

#ifdef NDEBUG
    inline
#endif

    virtual int evaluateError(int errorNum) {
#ifndef NDEBUG
      if (errorNum!=NO_ERROR)
        if (errors.find(errorNum)==errors.end()) // if we don't have this error then perhaps it is a system error ?
          fprintf(stderr, "Error : %d strerror reports : %s ", errorNum, strerror(errno));
        else
          fprintf(stderr, "Error : %d %s ", errorNum, errors[errorNum].c_str());
#endif
        return errorNum;
    }

#ifdef NDEBUG
    inline
#endif

    virtual int evaluateError(int errorNum, std::string append) {
#ifndef NDEBUG
        evaluateError(errorNum);
        fprintf(stderr, "%s", append.c_str());
#endif
        return errorNum;
    }

    std::string getErrorString(int errorNum){
        if (errors.find(errorNum)==errors.end()) // if the error doesn't exist, then return an unknown error std::string.
            return std::string("Unknown Error");
        return errors[errorNum];
    }
};

#if !defined(DEBUG_OUTPUT) || !defined(DEBUG_LOCAL_OUTPUT)
class Debugger {
public:
    enum {NOTHING} endl;

    Debugger &operator<<(const char*str){
        return *this;
    }

    Debugger &operator<<(const int nothing){
        return *this;
    }

};
#include <streambuf>
#include <ostream>
template <class cT, class traits = std::char_traits<cT> >
class basic_nullbuf: public std::basic_streambuf<cT, traits> {
    typename traits::int_type overflow(typename traits::int_type c) {
        return traits::not_eof(c); // indicate success
    }
};

template <class cT, class traits = std::char_traits<cT> >
class basic_onullstream: public std::basic_ostream<cT, traits> {
public:
    basic_onullstream(): std::basic_ios<cT, traits>(&m_sbuf), std::basic_ostream<cT, traits>(&m_sbuf) {
        //init(&m_sbuf);
    }

private:
    basic_nullbuf<cT, traits> m_sbuf;
};

typedef basic_onullstream<char> NullStream;
static NullStream nullstream;
#endif

#ifdef DEBUG_OUTPUT
#define Debugger std::cout
// #else
// #define Debugger nullstream
#endif

#ifdef DEBUG_LOCAL_OUTPUT
#define DebuggerLocal std::cout
// #else
// #define DebuggerLocal nullstream
#endif
#endif // DEBUG_H_