LogTrace.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// $Id$
//
// Copyright 2008, 2009, 2010, 2011, 2012  Antonio Franchi and Paolo Stegagno    
//
// This file is part of MIP.
//
// MIP 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 3 of the License, or
// (at your option) any later version.
//
// MIP 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 should have received a copy of the GNU General Public License
// along with MIP. If not, see <http://www.gnu.org/licenses/>.
//
// Contact info: antonio.franchi@tuebingen.mpg.de stegagno@diag.uniroma1.it
//
// ----------------------------------------------------------------------------




/* @{ */


#ifndef __LOG_TRACE_H_
#define __LOG_TRACE_H_

#ifdef MIP_HOST_APPLE
#include <applePatch.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <iostream>
#include <string>
#include <sstream>
#include <fstream>

#define COL_NORMAL "\033[0m"
#define COL_BLACK "\033[22;30m"
#define COL_RED "\033[22;31m"
#define COL_GREEN "\033[22;32m"
#define COL_BROWN "\033[22;33m"
#define COL_BLUE "\033[22;34m"
#define COL_MAGENTA "\033[22;35m"
#define COL_CYAN "\033[22;36m"
#define COL_GRAY "\033[22;37m"
#define COL_DARK_GRAY "\033[01;30m"
#define COL_LIGHT_RED "\033[01;31m"
#define COL_LIGHT_GREEN "\033[01;32m"
#define COL_YELLOW "\033[01;33m"
#define COL_LIGHT_BLUE "\033[01;34m"
#define COL_LIGHT_MAGENTA "\033[01;35m"
#define COL_LIGH_CYAN "\033[01;36m"
#define COL_WHITE "\033[01;37m"

#define COLORIZE(string,NEW_COLOR) NEW_COLOR << string << COL_NORMAL

#define MIP_DEBUG_STATIC(debLevel,_staticLevel,message) \
{ \
  if(debLevel <= _staticLevel) { \
    std::cout << "\033[01;31m" << "[MIPDEBUG] " << "\033[0m" << message << std::endl; \
  } \
}

#define MIP_DEBUG(debLevel,message) \
{ \
  if(debLevel <= getDebugLevel()) { \
    stringstream MIP_DEBUG_ss; \
    MIP_DEBUG_ss << message; \
    debug(debLevel,MIP_DEBUG_ss.str()); \
  } \
}

#define MIP_INFO(message) \
{ \
stringstream MIP_INFO_ss; \
MIP_INFO_ss << message; \
info(MIP_INFO_ss.str()); \
}

#define MIP_WARNING(message) \
{ \
stringstream MIP_WARNING_ss; \
MIP_WARNING_ss << message; \
warning(MIP_WARNING_ss.str()); \
}

#define MIP_FATAL(message) \
{ \
stringstream MIP_FATAL_ss; \
MIP_FATAL_ss << message; \
fatal(MIP_FATAL_ss.str()); \
}

#define MIP_STATIC_DEBUG(classname,debLevel,message) \
{ \
stringstream MIP_DEBUG_ss; \
MIP_DEBUG_ss << "(" << classname << "): "  << message; \
LogTrace::debug(debLevel,MIP_DEBUG_ss.str()); \
}

#define MIP_STATIC_INFO(classname, message) \
{ \
stringstream MIP_INFO_ss; \
MIP_INFO_ss << "(" << classname << "): " << message; \
LogTrace::info(MIP_INFO_ss.str()); \
}

#define MIP_STATIC_WARNING(classname,message) \
{ \
stringstream MIP_WARNING_ss; \
MIP_WARNING_ss << "(" << classname << "): "  << message; \
LogTrace::warning(MIP_WARNING_ss.str()); \
}

#define MIP_STATIC_FATAL(classname,message) \
{ \
stringstream MIP_FATAL_ss; \
MIP_FATAL_ss << "(" << classname << "): "  << message; \
LogTrace::fatal(MIP_FATAL_ss.str()); \
}

using namespace std;

extern stringstream tstream;

// class LogTrace : public stringstream{
//  private:
//   stringstream trace;
//   fstream    log;
//  public:
//   LogTrace(string logFileName=0){
//    if(logFileName != ""){
//     log.open(logFileName.c_str(), fstream::out);
//     if(!log.is_open()){
//      cout << "WIP-warning: unable to open " << logFileName << endl;
//     }
//    }
//   }
//   
//   ~LogTrace(){
//    if(log.is_open()){
//     log.close();
//    }
//   }
// 
// // //   friend ostream& operator<<(ostream& Ostr, const LogTrace& lt);
// // //   friend istream& operator>>(istream& Istr, LogTrace& lt);
// 
//   
// //   istream& operator>>(istream& in, LogTrace& lt){
// //    if (in.good()){
// //     lt.trace << in;
// //    }
// //    return in;
// //   }
// //   
// //   void flush (){
// //    cout << trace;
// //    fflush(stdout);
// //   }
// // 
// //   
// //   friend ostream& operator<<(ostream&, const LogTrace&){
// //    out << "(" << c.myReal << "," << c.myImag << ")";
// //    return out;
// //    
// //   }
// };

// had to move code to cpp, because include CommonOptions.h resulted in circular include depend.
class LogTrace {

 public:
  static void fatal(const string& fatalMessage);

  static void warning(const string& warningMessage);

  static void info(const string& infoMessage);

  static void debug(int level, const string& infoMessage, int customLevel=0);

    static int getDebugLevel(int customLevel);
};

class MIPObject{
 private:
  int _customDebugLevel;
 public:
  
  MIPObject(){
   _customDebugLevel = 0;
  }
  
  virtual string getObjectName() const=0;


  void fatal(const string& fatalMessage) const {
   stringstream ss;
   ss << "(" << getObjectName() << "): " << fatalMessage;
   LogTrace::fatal(ss.str());
  }
   
  
  void warning(const string& warningMessage) const {
   stringstream ss;
   ss << "(" << getObjectName() << "): " << warningMessage;
   LogTrace::warning(ss.str());
  }
  
  void info(const string& infoMessage) const {
   stringstream ss;
   ss << "(" << getObjectName() << "): " << infoMessage;
   LogTrace::info(ss.str());
  }
  
  void debug(int level, const string& debugMessage) const {
   stringstream ss;
   ss << "(" << getObjectName() << "): " << debugMessage;
   LogTrace::debug(level,ss.str(),_customDebugLevel);
  }

  void setCustomDebugLevel(int customDebugLevel){
   _customDebugLevel = customDebugLevel;
  }

    int getDebugLevel(){
      return LogTrace::getDebugLevel(_customDebugLevel);
    }
};





#endif

/* @} */