freLogFileController.cxx

Go to the documentation of this file.

/*=========================================================================

  Program:   F.R.E.E. - flexible registration evaluation engine
  Version:   v.1.0.0
  Date:      $Date: 2006/09/01 12:00:00 $
  Module:    $RCSfile: freLogFileController.cxx,v $
  Language:  C++



  Copyright (c) 2007 Ralf o Floca (Department of Medical Informatics,
  Institute for Medical Biometry and Informatics, University of Heidelberg,
  Germany). All rights reserved.
  See FREECopyright.txt or http://www.mi.med.uni-hd.de/free/copyright.htm
  for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/

#include "freLogFileController.h"
#include "freElementals.h"

#include <time.h>

namespace FREE
{

static std::string ActTimeStampToStr()
{
        char tbuffer [40];

  time_t now;
  time(&now);
  tm* nowTM = localtime(&now);
  
  strftime(tbuffer,20,"%m/%d/%y %H:%M:%S",nowTM);

  std::string sTimeStamp = tbuffer;

        return sTimeStamp;
};


bool
LogFileController::
StartLog()
{
  bool result = true;

  if (m_bActive)
  {
          StopLog();
          m_bActive = false;
  }
  
  result = OpenLogFile();
  if (result)
  {
          m_LogFile << m_sHeader <<std::endl;

    m_LogFile << "Log start: "+ActTimeStampToStr() << std::endl << std::endl;
          m_LogFile.flush();

          m_bActive = true;
  }

  return result;
}; 
  
bool
LogFileController::
StartLog(const std::string  sLogFileName)
{
  SetFileName(sLogFileName);
  return StartLog();
}; 

bool
LogFileController::
StopLog()
{
  bool result = true;

  if (m_bActive)
  {
          m_LogFile << std::endl << "Log stop: "+ActTimeStampToStr() << std::endl;
          m_LogFile <<"***********************************"<< std::endl << std::endl;
          m_LogFile.flush();

    result = CloseLogFile();
          if (result) m_bActive = false;
  }

  return result;
};

bool
LogFileController::
Active() const
{
  return m_bActive;
};

bool
LogFileController::
AddEntry(const std::string  sEntry, const bool bAddTimeStamp)
{
  bool result = false;
  if (m_bActive)
  {
          try
          {
            std::string  sLine;
        
            if (bAddTimeStamp) 
            {
              sLine = ActTimeStampToStr();
              sLine = sLine+" >> "+sEntry;
            }
            else sLine = sEntry;

            m_LogFile << sLine << std::endl;
            m_LogFile.flush();
            result = true;
          }
          catch (...){/* ignore all exceptions... */}
  }
  return result;
};

bool
LogFileController::
AddEntry(const std::string  sEntry)
{
  return AddEntry(sEntry,m_bInsertTime);
};

bool
LogFileController::
AddDirectEntry(const std::string  sEntry)
{
  if (!m_bActive) StartLog();
  bool result = AddEntry(sEntry);
  StopLog();
  return result;
};

void
LogFileController::
SetFileName(const std::string  sFileName)
{
  if (sFileName!=m_sFileName)
  {
          StopLog();
          m_sFileName = sFileName;
  };
};

const std::string
LogFileController::
GetFileName() const
{
  return m_sFileName;
};

void
LogFileController::
SetHeader(const std::string  sHeader)
{
  if (sHeader!=m_sHeader) m_sHeader = sHeader;
};

const std::string
LogFileController::
GetHeader() const
{
  return m_sHeader;
};

void
LogFileController::
SetInsertTimeStamp(const bool bTime)
{
  if (bTime!=m_bInsertTime) m_bInsertTime = bTime;
};

const
bool
LogFileController::
GetInsertTimeStamp() const
{
  return m_bInsertTime;
};

void
LogFileController::
SetAppendFile(const bool bAppend)
{
  m_bAppendFile = bAppend;
};

const bool
LogFileController::
GetAppendFile() const
{
  return m_bAppendFile;
};

LogFileController::
LogFileController()
{
  m_sFileName = "free.log";
  m_sHeader = "Logfile";
  m_bActive = false;
  m_bInsertTime = true;
  m_bAppendFile = true;
};


LogFileController::
LogFileController(const std::string  sFileName, const std::string  sHeader,
                                                const bool bAppend, const bool bInsertTime)
{
  m_sFileName = sFileName;
  m_sHeader = sHeader;
  m_bActive = false;
  m_bInsertTime = bInsertTime;
  m_bAppendFile = bAppend;
};

LogFileController::
~LogFileController()
{
  if (m_bActive) StopLog();
};

bool
LogFileController::
OpenLogFile()
{
  std::ios_base::openmode  iOpenFlag;

  bool result = false;

  if (!m_bActive)
  {
          if (m_bAppendFile) iOpenFlag = std::ios_base::out | std::ios_base::app;
          else iOpenFlag = std::ios_base::out | std::ios_base::trunc;
          m_LogFile.open(m_sFileName.c_str(), iOpenFlag );

          result = m_LogFile.is_open();
  }
  return result;
};

bool
LogFileController::
CloseLogFile()
{
  bool result = false;

  if (m_bActive) 
  {
          m_LogFile.close();
    result = true;
  };

  return result;
};

}//End of Namespace free

---