In This Package:

LogStream.cc

Go to the documentation of this file.

#include "LogStream.hh"
#include "Format.hh"
#include "Manager.hh"
#include <vector>
#include <fstream>
#include <iostream>
#include <cassert>

#include <cstring>

using namespace Logging;

//hxt ClassImp(LogStream)

Logging::LogStream::LogStream( std::string name )
: mName(name)
, mLevel(kEverything)
, mOStream(&std::cout)
{
}

Logging::LogStream::~LogStream()
{
  // We own the formats:
  for(unsigned int i=0;i<mFormats.size();i++) 
    delete mFormats[i];
  mFormats.clear();
}

void Logging::LogStream::ResetFormat()
{
  for(unsigned int i=0;i<mFormats.size();i++) 
    delete mFormats[i];
  mFormats.clear();
}

Logging::LogStream& 
Logging::LogStream::AddFormat( Format* fmt )
{
  mFormats.push_back(fmt);
  return (*this);
}



LogStream& Logging::LogStream::SetLevel( Level lvl )
{
        mLevel = lvl;  
  return (*this);
}



LogStream& Logging::LogStream::SetOutput( std::string filename )
{
  const char* cstr = filename.c_str();
        if( (0==strcasecmp(cstr,"cout")) 
      || (0==strcasecmp(cstr,"std::cout")) 
      || (0==strcasecmp(cstr,"stdout"))  ) {
    mOStream = &(std::cout);
    return (*this);
  } 
  if( (0==strcasecmp(cstr,"cerr")) 
      || (0==strcasecmp(cstr,"std::cerr")) 
      || (0==strcasecmp(cstr,"stderr"))  ) {
    mOStream = &(std::cerr);
    return (*this);
  } 

  // Open or get a handle to a log file:
  mOStream = Manager::Instance().GetOStream( filename );
  assert(mOStream);
  return (*this);
}

std::ostream& Logging::LogStream::GetOStream()
{
// To be used with caution! Avoid normal Entry formatting.
  assert(mOStream);
  return *mOStream;
}


void Logging::LogStream::WriteEntry( LogEntry entry )
{
  
  // Note the argument pulls a COPY of the LogEntry, so streams don't mess each other up.
  
  // First, is this message even printable by us?
  // If not, just abort. Let some other stream handle it.
        if(entry.mLevel < mLevel) return;
  
  // First, run all the formatters.
        bool good = true;
  for(unsigned int i=0;i<mFormats.size();i++) {
                good = (*mFormats[i])(entry);
          if(!good) return; // Abort if one of the processing units aborts.
  }
  // Next, carve up the entry into lines.
  
  std::vector<std::string> lines;
  {
    std::string::size_type p1=0;
    std::string::size_type p2=entry.mMsg.find_first_of('\n');
    while(p2 != std::string::npos) {
      std::string l(entry.mMsg, p1, p2-p1);
      lines.push_back(l);
      p1=p2+1;
      p2 = entry.mMsg.find_first_of('\n',p1);
    }
    p2 = entry.mMsg.length();
          if(p2>p1) {
      std::string l(entry.mMsg,p1,p2-p1);
      lines.push_back(l);
    }
  }
  
  // Finally, write out each line, applying the prefix to the first line,
  //  indenting the rest of the lines, and putting the suffix on every line.
  // FIXME this should be configuable.
  assert(mOStream);
        for(unsigned int i=0;i<lines.size(); i++) {
    if(i==0) (*mOStream) << entry.mPrefix;
    else   {
      int spaces = entry.mPrefix.length() + entry.mIndentAdj;
      for(int is=0;is<spaces;is++) (*mOStream) << " ";
    }
    
    (*mOStream) << lines[i];
    (*mOStream) << std::endl;
  }
  (*mOStream) << entry.mSuffix;
  (*mOStream).flush();
}

---