3.52/src/utilities/Log.h

Go to the documentation of this file.

//****************************************************************************
//*                   This file is part of PandaRoot.                        *
//*                                                                          *
//*            PandaRoot is distributed under the terms of the               *
//*              GNU General Public License (GPL) version 3,                 *
//*                 copied verbatim in the file "LICENSE".                   *
//*                                                                          *
//*  Copyright (C) 2006 - 2024 FAIR GmbH and copyright holders of PandaRoot  *
//*     The copyright holders are listed in the file "COPYRIGHTHOLDERS".     *
//*               The authors are listed in the file "AUTHORS".              *
//****************************************************************************

//****************************************************************************
//*                   This file is part of PandaRoot.                        *
//*                                                                          *
//*            PandaRoot is distributed under the terms of the               *
//*              GNU General Public License (GPL) version 3,                 *
//*                 copied verbatim in the file "LICENSE".                   *
//*                                                                          *
//*  Copyright (C) 2006 - 2024 FAIR GmbH and copyright holders of PandaRoot  *
//*     The copyright holders are listed in the file "COPYRIGHTHOLDERS".     *
//*               The authors are listed in the file "AUTHORS".              *
//****************************************************************************

#ifndef __PHOTOS_LOG_CLASS_HEADER__
#define __PHOTOS_LOG_CLASS_HEADER__

#include <iostream>
#include <string>
#include <sstream>
#include <stdlib.h>
#include <list>
#include "Photos.h"
// TEMPORARY
#include "f_Init.h"

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

namespace Photospp {

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 = nullptr);

  static void Fatal(string text, unsigned short int code = 0);
  static void Fatal(unsigned short int code = 0) { Fatal(nullptr, 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 = " ";
    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