In This Package:

Manager.cc

Go to the documentation of this file.

#include "Manager.hh"
#include "FormString.hh"
#include <iostream>
#include <fstream>
#include <cassert>

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

using namespace Logging;

ClassImp(Manager)

Logging::Manager::Manager()
{
   // At first creation, start up a default stream with a default rule that everything goes there.
  AttachStream("*","stdout");
}

Logging::Manager::~Manager()
{
  std::map<std::string,std::ofstream*>::iterator it;
  for(it = mOpenFiles.begin(); it!= mOpenFiles.end(); it++) {
    (it->second)->flush();
    (it->second)->close();
    delete(it->second);
  }
  mOpenFiles.clear();
}

void Logging::Manager::ResetRules()
{
  mLevelRules.clear();
  mStreamRules.clear();
  ApplyRules();
}

void Logging::Manager::SetLevel(std::string logpattern, Level lvl)
{
  LevelRule lr;
  lr.mLogPattern = logpattern;
  lr.mLevel      = lvl;
  mLevelRules.push_back(lr);
  ApplyRules();
}

void Logging::Manager::AttachStream(std::string logpattern, std::string streamname)
{
  StreamRule sr;
  sr.mLogPattern = logpattern;
  sr.mStreamName = streamname;
  mStreamRules.push_back(sr);
  ApplyRules();
}

LogStream& Logging::Manager::GetStream( std::string name )
{
  // Find an old one by this name
  std::map<std::string,LogStream>::iterator it = mLogStreams.find(name);
  if(it != mLogStreams.end()) return it->second;
  
  mLogStreams[name] = LogStream(name); // Make a new one
        return mLogStreams[name];  
}

std::ostream* Logging::Manager::GetOStream( std::string name )
{
  std::map<std::string,std::ofstream*>::iterator it = mOpenFiles.find(name);
  if(it != mOpenFiles.end()) return it->second;

  // OK, it doesn't exist. Create the file.
  std::ofstream* newstream = 0;

  if(name.find('%')==std::string::npos) {
    // Just create a new file; replace any existing file.
    newstream = new std::ofstream(name.c_str(), std::ios_base::out | std::ios_base::trunc);
  } else {
    // Use a log file number. Increment until we find an empty file.
    std::string trialname = name;  
    std::string::size_type p = trialname.find_last_of('%');
    int num = 1;
    int notexist=0;
    
    // Attempt to just name it the base name.
    trialname = name;
    trialname.replace(p,1,"");
    static struct stat stats;
    notexist = stat(trialname.c_str(),&stats);
    
    while(notexist==0) {
      // Ok, that file exists,so replace % with .001 and try again. (Then .002, etc)
      trialname = name;
      trialname.replace(p,1,FormString(".%03d",num++));
      notexist = stat(trialname.c_str(),&stats);
    }

    newstream = new std::ofstream(trialname.c_str(), std::ios_base::out | std::ios_base::trunc);
  }
  
  assert(newstream);
  assert(newstream->good());
  
  mOpenFiles[name]=newstream;
  return newstream;
}

void Logging::Manager::RegisterLog( Log* log )
{
  mLogs.insert(log);
        ApplyRules(log);
}


void Logging::Manager::DeRegisterLog( Log* log )
{
  mLogs.erase(log);
}

void Logging::Manager::ApplyRules()
{
  std::set<Log*>::iterator it;
  for(it = mLogs.begin(); it!= mLogs.end(); it++) ApplyRules(*it);
}


bool PatternMatches(const std::string& pattern, const std::string& target)
{
  // Poor man's pattern matcher.
  // Match thing to thing
  if(pattern==target) return true;
  // Match blah* to blahanything
  std::string::size_type starpos = pattern.find_first_of('*',0);
  if(starpos != std::string::npos) {
                 // There was a wildcard. See if the substring before matches.
    if(pattern.compare(0,starpos, target,0,starpos) ==0) return true;
  }
  return false;
}


void Logging::Manager::ApplyRules(Log* log)
{
  // The core of the configuration utility. 
  // Try to apply all the currently-cached rules, in order, to the the given log.

  log->ResetStreams(); // Clear out any existing streams.
        for(unsigned int i=0; i< mStreamRules.size(); i++) {
                if(PatternMatches(mStreamRules[i].mLogPattern, log->GetName())) {
                        log->ConnectStream(
                         &GetStream(mStreamRules[i].mStreamName) 
                         );
    }
  }

  log->Enable(Logging::kDefault); // Set to default level  
  for(unsigned int i=0; i< mLevelRules.size(); i++) {
                if(PatternMatches(mLevelRules[i].mLogPattern, log->GetName())) {
                        log->Enable(mLevelRules[i].mLevel);
    }
  }


}

---