slogcxx.h

Go to the documentation of this file.

#ifndef SLOGCXX_H // Include guard
#define SLOGCXX_H

// C headers
#include <cassert>

// C++ headers
#include <string>
#include <vector>

#include <iostream>
#include <fstream>

// MACROS 


// This avoids warning of unused arguments when prefixed with USUSED
#ifndef UNUSED
#ifdef __GNUC__
#define UNUSED __attribute((__unused__))
#else

// FIX: Can we or do we need something like this for Win32/VC++?
#define UNUSED
#endif
#endif // ifndef UNUSED

#define EXIT_DEBUG(why) std::cerr << "EXIT_DEBUG called at " \
  << __FILE__ << ":" << __LINE__<<": in function '" <<__FUNCTION__ << "'\n" \
  << "  STATED REASON: " << why << std::endl;                           \
  exit(EXIT_FAILURE);

#if !defined (NLOG)
#define WHERE Where(__FILE__,__LINE__,__FUNCTION__)
#endif

// Where class


#ifndef NLOG
class Where {
 public: 
    Where(const std::string &_file, const int _lineno, const std::string &_function);
    inline std::string const &getFile() const {return file;};
    inline int const &getLineno() const {return lineno;};
    inline std::string const &getFunction() const {return function;};
 private:
    std::string file;   
    int lineno;         
    std::string function;       
};
#endif // NLOG

// ENUMS

// FIX: these may need to be const int values.

enum LogLevelsEnum { 
  // Kurt's names
  ALWAYS=INT_MIN, // Only use for entries()
  TERSE=1,
  TRACE,
  VERBOSE,
  BOMBASTIC,
  NEVER = INT_MAX // Only use for entries()
};



// The main slog class


#if !defined(NLOG)
class Slog {
 public:
  Slog(const std::string &filename="", const std::string &indentStr=" ", 
       const bool append=true, const bool enableXml=true, const bool enableTime=true);
  ~Slog();



  void setLevel(const int lvl) {assert(0<=lvl);logLevel=lvl;} 
  int getLevel() {return logLevel;}
  int inc() {return ++logLevel;}
  int dec() {--logLevel; if (0>logLevel) logLevel=0; return logLevel;}



  void enableTime() {timeEnabled=true;};
  void disableTime() {timeEnabled=false;};
  bool getTimeStatus() {return timeEnabled;};



  void enableXml() {xmlEnabled=true;}; 
  void disableXml() {xmlEnabled=false;};  
  bool getXmlStatus() {return xmlEnabled;};

  bool entry(const int lvl, const std::string str); 

  bool where(const std::string &file, const int lineno, const std::string &function);



  // The following messages are for controlling what the << log messages do
  void setMsgLevel(const int lvl) {assert(0<=lvl);msgLevel=lvl;}
  int getMsgLevel() {return msgLevel;}
  int incMsg() {return ++msgLevel;}
  int decMsg() {--msgLevel; if (0>msgLevel) msgLevel=0; return msgLevel;}






  bool partial(const int lvl, const std::string str); 
  bool complete();  



  void setStateIndent(const std::string &str) {stateIndent=str;};
  std::string getStateIndent() {return stateIndent;};
  std::string indent();
  std::string getStateNumberStr();
  std::string getCurScope() {if (0==getStateDepth()) return ""; return stateStack[stateStack.size()-1];}

  void pushState(std::string scope, int msgLvl = -1);
  std::string popState();
  void writeState(bool flat=true);
  int getStateDepth() {return stateStack.size();};



  // P 65 of EC++ 2nd ed wants the const.
  // FIX: is there any point in having an op=?  Should it be just an assert false?
  Slog& operator=(UNUSED const Slog& rhs) {
    std::cerr << "Slog op=!" << std::endl;
    assert ("WTF... do not copy!");
    return *this;
  }

 private:
  int logLevel; 
  int msgLevel; 
  std::string curStr; 
  bool xmlEnabled; 
  bool timeEnabled; 
  // FIX: how should time stamp formats be controlled?

  std::string stateIndent; 
  std::vector<std::string> stateStack; 
  std::vector<int> msgLvlStack; 
  
  std::ofstream logFile; 

}; // end Slog class


Slog& operator<<(Slog&s, Slog&(*manip)(Slog&)); 

Slog& endl(Slog& s); 
Slog& decl(Slog& s); 
Slog& incl(Slog& s); 

// Logging operators for basic types
Slog& operator<< (Slog &s, const int &r); 
Slog& operator<< (Slog &s, const size_t &r); 
Slog& operator<< (Slog &s, const char *str); 
Slog& operator<< (Slog &s, const std::string &str); 

// FIX: can this be made to work?
/* Quote from nntp:

"You can't overload operators that involve only built in types. At
least one operand must be of class/struct/enum type. Pointers are
considered built in types, even if they point to user-defined
types. Thus you cannot overload any operator that works exclusively on
pointers."
*/

//Slog* operator<< (Slog *s, const char *str);
//Slog* foo (Slog *s, const char *str);
//int foo(Slog &s);
//int foo(Slog *s);

Slog& operator<< (Slog &s, const char &c); 
Slog& operator<< (Slog &s, const short &sh); 
Slog& operator<< (Slog &s, const long &l); 
//Slog& operator<< (Slog &s, const long long &ll); //!< Insert a long long character
Slog& operator<< (Slog &s, const float &f); 
Slog& operator<< (Slog &s, const double &d); 

Slog& operator<< (Slog &s, const Where &w); 


class LogState {
 public:
  LogState(Slog *logInstance, const std::string &scope, int msgLvl = -1);
  std::string pop(); 
  ~LogState();
 private:
  Slog *log; 
  bool popped; 
};

#endif // !defined(NLOG)


// MODE TO ALLOW CODE TO STAY WITH MINIMAL COST

#if defined(NLOG)
#  include <slogcxx-nlog.h>
#endif

#endif // SLOGCXX_H

---