/*
 * Project: MoleCuilder
 * Description: creates and alters molecular systems
 * Copyright (C)  2010 University of Bonn. All rights reserved.
 * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
 */

/*
 * logger.cpp
 *
 *  Created on: Oct 19, 2009
 *      Author: metzler
 */

// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

//#include "CodePatterns/MemDebug.hpp"

#include <fstream>
#include <iostream>
#include "CodePatterns/logger.hpp"
#include "CodePatterns/Verbose.hpp"
#include "CodePatterns/Singleton_impl.hpp"


int logger::verbosity = 2;
ostream* logger::nix = NULL;
ostream* logger::defaultout = NULL;
ostream* logger::out = NULL;

/**
 * Constructor. Do not use this function. Use getInstance() instead.
 *
 * \return logger instance
 */
logger::logger()
{
  nix = new ofstream("/dev/null");
  defaultout = &cout;
  out = defaultout;
};

/**
 * Destructor. Better use purgeInstance().
 */
logger::~logger()
{
  delete nix;
  out = NULL;   // we are not responsible if out got changed
  defaultout = NULL; // do not delete cout
}

CONSTRUCT_SINGLETON(logger)

/**
 * Sets the verbosity.
 *
 * \param verbosityLevel verbosity
 */
void logger::setVerbosity(int verbosityLevel) {
  verbosity = verbosityLevel;
}

/**
 * Gets the verbosity.
 *
 * \return verbosity level
 */
int logger::getVerbosity()
{
  return verbosity;
}

/** Sets a new output stream.
 *
 * \param _newout new output stream, if NULL we set to defaultout
 */
void logger::setOutputStream(ostream *_newout)
{
  if(_newout != NULL)
    out = _newout;
  else
    out = defaultout;
}

/**
 * Operator for the Binary(arg) call.
 * Constructs temporary a Verbose class object, wherein the Binary is stored.
 * Then << is called, which calls Binary's print which adds the tabs and logs
 * the stream.
 * \param &ost stream to extend
 * \param &m pointer to created Binary object
 * \return &ost
 */
ostream& operator<<(class logger& l, const Verbose& v)
{
  int verbosityLevel = l.verbosity;
  l.nix->clear();
  if (v.DoOutput(verbosityLevel)) {
    v.print(*logger::out);
    return *logger::out;
  } else
    return *l.nix;
};
ostream& operator<<(class logger* l, const Verbose& v)
{
  int verbosityLevel = l->verbosity;
  l->nix->clear();
  if (v.DoOutput(verbosityLevel)) {
    v.print(*logger::out);
    return *logger::out;
  } else
    return *l->nix;
};