Log.h

#ifndef __PHOTOS_LOG_CLASS_HEADER__
#define __PHOTOS_LOG_CLASS_HEADER__
 
#include <iostream>
#include <string>
#include <sstream>
#include <stdlib.h>
#include <list>
#include "Photos.h"
 
using std::stringstream;
using std::string;
using std::streambuf;
using std::ostream;
using std::list;
using std::cout;
using std::endl;
 
namespace Photospp {
 
  extern void (*PHOERR)(int, const char*, double);
  extern void (*PHOREP)();
 
  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; }
 
    // TEMPORARY
    static void LogPhlupa(int from, int to)  { phlupy.ipoinm = from; phlupy.ipoin = to; }
 
    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(NULL, 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;          }
 
    static void PHOERR(int IMES, const char* TEXT, double DATA);
 
    static void PHOREP();
 
  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 = " ";
      unsigned 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(long unsigned int size, const char* filename, int line)
  {
    void* ptr = (void*)malloc(size);
    Photos::Log::NewPointer((unsigned long)ptr, size, filename, line);
    return (ptr);
  }
 
  inline void  operator delete(void* p)
  {
    Photos::Log::DeletePointer((unsigned long)p);
    free(p);
  }
 
#define new new(__FILE__, __LINE__)
 
#endif //_LOG_DEBUG_MODE_
 
} // namespace Photospp
#endif