Log.h

#ifndef __LOG_CLASS_HEADER__
#define __LOG_CLASS_HEADER__

#include <iostream>
#include <string>
#include <sstream>
#include <stdlib.h>
#include <cstring>
#include <list>

using std::stringstream;
using std::string;
using std::streambuf;
using std::ostream;
using std::list;
using std::cout;
using std::endl;

namespace Tauolapp
{

class Log
{
public:
  static void Summary();

  static void SummaryAtExit()              { atexit(Summary);      }

  static void AddDecay(int type);

  static ostream& Debug(unsigned short int code=0, bool count=true);
  static ostream& Info(bool count=true);
  static ostream& Warning(bool count=true);
  static ostream& Error(bool count=true);

  static void LogInfo   (bool flag=true)  { iAction=flag;         }
  static void LogWarning(bool flag=true)  { wAction=flag;         }
  static void LogError  (bool flag=true)  { eAction=flag;         }

  static void LogAll    (bool flag=true)  { iAction=wAction=eAction=flag; dRangeS=0; dRangeE=65535; }

  static void LogDebug(unsigned short s=0,unsigned short e=65535)         { dRangeS=s; dRangeE=e;   }

  static void Assert(bool check, char *text=NULL);

  static void Fatal(string text, unsigned short int code=0);
  static void Fatal(unsigned short int code=0)                            { Fatal("",code);       }

  static void RedirectOutput(void (*func)(), ostream& where=*out);
  static void RedirectOutput(ostream& where=*out);
  static void RevertOutput()                      { std::cout.rdbuf(bCout); std::cerr.rdbuf(bCerr); }

  static void IgnoreFailedAssert(bool flag=true)                           { asAction=!flag;        }

  static void IgnoreRedirection(bool flag=true)                            { rAction=!flag;         }

  static void IgnoreFatal(unsigned short s=0,unsigned short e=65535) { faRangeS=s; faRangeE=e; }

  static void SetOutput(ostream *newOut)                                    { out=newOut;           }
  static void SetOutput(ostream &newOut)                                    { out=&newOut;          }

  static void SetWarningLimit(int x)                                        { warnLimit=x;          }

protected:
  static streambuf *bCout,*bCerr;
  static ostream *out;
  static stringstream buf;
  static int  warnLimit;
  static int  decays[4];
  static int  dCount,dRangeS,dRangeE,faCount,faRangeS,faRangeE;
  static int  iCount, wCount, eCount, asCount, asFailedCount;
  static bool iAction,wAction,eAction,asAction,rAction;
protected:
  typedef struct
  {
    unsigned long address;
    unsigned long size;
    char  file[64];
    unsigned long line;
  } Pointer;
  static list<Pointer*> *PointerList;
public:
#ifdef _LOG_DEBUG_MODE_
  static void NewPointer(unsigned long address,  unsigned long size,  const char *file, unsigned long line)
  {
    if(!PointerList)
    {
      PointerList = new list<Pointer *>();
      atexit(PrintAllocatedPointers);
    }
    Pointer *info = new Pointer();
    info->address = address;
    info->size    = size;
    info->line    = line;
    strncpy(info->file, file, 63);
    PointerList->push_front(info);
  }
  static void DeletePointer(unsigned long address)
  {
    if(!PointerList) return;
    for(list<Pointer*>::iterator i = PointerList->begin(); i!=PointerList->end(); i++)
    {
      if((*i)->address == address)
      {
        PointerList->remove((*i));
        break;
      }
    }
  }
  static bool PointerCompare(Pointer *one, Pointer *two)
  {
    int eq = strcmp(one->file,two->file);
    if(eq<0) return true;
    else if(eq>0) return false;
    return (one->line <= two->line);
  }
  static void PrintAllocatedPointers()
  {
    if(!PointerList) return;
    int pointers=0,buf=0;
    unsigned long total=0;
    char *lastS=" ";
    int lastL=0;
    if(PointerList->size()==0)
    {
      cout<<"----------------------------UNFREED MEMORY POINTERS----------------------------\n";
      cout<<"                                 ... NONE ...\n";
      cout<<"-------------------------------------------------------------------------------\n";
      return;
    }
    PointerList->sort(PointerCompare);
    cout<<"---------------------------UNFREED MEMORY POINTERS---------------------------\n";
    for(list<Pointer*>::iterator i = PointerList->begin(); i!=PointerList->end(); i++)
    {
      total+=(*i)->size;
      ++pointers;
      if(strcmp(lastS,(*i)->file)==0)
      {
        if(lastL==(*i)->line)
        {
          printf("%56s%10lub (%lu)\n"," ",(*i)->size,(*i)->address);
          continue;
        }
      }
      lastS=(*i)->file;
      lastL=(*i)->line;
      printf("%s%n:",(*i)->file,&buf);
      printf("%-*lu%10lub (%lu)\n",55-buf,(*i)->line,(*i)->size,(*i)->address);
    }
    cout<<endl<<total<<"\tbytes"<<endl;
    cout<<pointers<<"\tpointers"<<endl;
    cout<<"-------------------------------------------------------------------------------\n";
  };
#endif //_LOG_DEBUG_MODE_
};

#ifdef _LOG_DEBUG_MODE_

inline void* operator new(size_t size, const char *filename, int line)
{
  void *ptr = (void *)malloc(size);
  Log::NewPointer((unsigned long)ptr, size, filename, line);
  return(ptr);
}

inline void  operator delete(void *p)
{
  Log::DeletePointer((unsigned long)p);
  free(p);
}

#define new new(__FILE__, __LINE__)

#endif //_LOG_DEBUG_MODE_

} // namespace Tauolapp
#endif