---

configuration.C

Go to the documentation of this file.

// $Id: configuration_C-source.html,v 1.1 2001/04/16 17:42:57 dvermeir Exp $
#include <string>
#include <algorithm>
#include <stdlib.h> // for strtol()
#include "configuration.h"
#include "datepattern.h"
#include "path.h"
#include "domain.h"

Configuration::Configuration(): format_(NONE), max_level_(0), select_(0) {
}

Configuration::~Configuration() {
delete select_;
}

void
Configuration::add_expression(Expression* e) {
if (e) {
  if (!select_)
    select_ = new AndExpression();
  select_->add(e);
  }
}

unsigned int
Configuration::parse(istream& is) {
string  word; // first word on the line
bool    ok(true);
criteria_.clear();
unsigned int lineno(1);
while (is >> word) { // while we can read the first word of a line
  if (word.size() && word[0]=='#') { // comment, just skip until the end of the line
    string junk;
    getline(is,junk);
    }
  else if (word=="format") {
    if (format_!=NONE) // a format_ is already there
      return lineno;
    ok = parse_format(is);
    }
  else if (word=="select")
    ok = parse_select(is);
  else if (word=="exclude")
    ok = parse_exclude(is);
  else
    return lineno;
  if (!ok)
    return lineno;
  ++lineno;
  }
return 0;
}

bool
Configuration::parse_format(istream& is) {
format_ = parse_criterium(is);
if (format_ == NONE)
  return false;
criteria_.insert(format_);
if (parse_levels(is,levels_))  {
  if (levels_.size()==0) { // insert default
    levels_.insert(1);
    levels_.insert(2);
    levels_.insert(3);
    }
  // compute max_level_
  max_level_ = *(max_element(levels_.begin(),levels_.end()));
  }
return true;
}

bool
Configuration::parse_select(istream& is) {
Expression* e(parse_expression(is));
if (e) {
  add_expression(e);
  return true;
  }
return false;
}


Expression*
Configuration::parse_expression(istream& is) {
CRITERIUM crit = parse_criterium(is);
if (crit == NONE)
  return false;
criteria_.insert(crit);
string pattern; // rest of line
if (!getline(is,pattern))
  return false;
// remove leading blanks or tabs
if (pattern.size()) { // remove leading and trailing blanks and tabs
  string::size_type n0(pattern.find_first_not_of(" \t"));
  if (n0)
    pattern.erase(0,n0);
  if (pattern.size()) {
    string::size_type n1(pattern.find_last_not_of(" \t"));
    if (n1<(pattern.size()-1)) 
      pattern.erase(n1+1);
    }
  }
if (pattern.size()==0)
  return false;
switch (crit) {
  case DATE: {
    DatePattern dp;
    if (!dp.parse(pattern))
      return false;
    return new DateExpression(dp);
    }
    break;
  case DOMAIN: {
    Domain d;
    if (!d.parse(pattern))
      return false;
    return new DomainExpression(d);
    }
    break;
  case PATH: {
    Path p;
    if (!p.parse(pattern))
      return false;
    return new PathExpression(p);
    }
    break;
  default: return false;
  }
}

bool
Configuration::parse_exclude(istream& is) {
Expression* e(parse_expression(is));
if (e) {
  add_expression(new NotExpression(e));
  return true;
  }
return false;
}

Configuration::CRITERIUM
Configuration::parse_criterium(istream& is) {
string word;
if (is >> word) {
  if (word=="path")
    return PATH;
  else if (word=="date")
    return DATE;
  else if (word=="domain")
    return DOMAIN;
  else 
    return NONE;
  }
return NONE;
}

bool
Configuration::parse_levels(istream& is,set<unsigned int>& levels) {
levels.clear();
string line;
if (!getline(is,line))
  return false;
const char* cline(line.c_str());
const char* start(0);
// The const_cast is needed because strtol's 3rd is wrongly types as char**.
char* end(const_cast<char*>(cline));

while (start!=end) {
  start = end;
  long l = strtol(start,&end,10);
  if (start!=end) {
    if (l<0)
      return false;
    unsigned int u1(static_cast<unsigned int>(l));
    levels.insert(u1);
    if (*end=='-') { // a range like 1-4
      start = end+1;
      if (*start=='\0') // syntax error: something like '1-'
        return false;
      long l2 = strtol(start,&end,10);
      if (start==end) // syntax error: something like '1-asda'
        return false;
      if (l2<0)
        return false;
      unsigned int u2(static_cast<unsigned int>(l2));
      for (unsigned int u=u1+1; u<=u2; ++u) 
        levels.insert(u);
      }
    }
  }
return true;
}

ostream&
operator<<(ostream& os,const Configuration& conf) {
os << "format " <<  conf.format() << " ";
copy(conf.levels().begin(),conf.levels().end(),ostream_iterator<unsigned int>(os," "));
os << "\n";
if (conf.select()) 
  os << *(conf.select());
return os;
}

ostream&
operator<<(ostream& os,const Configuration::CRITERIUM& c) {
switch (c) {
  case Configuration::DATE: os << "date"; break;
  case Configuration::DOMAIN: os << "domain"; break;
  case Configuration::PATH: os << "path"; break;
  case Configuration::NONE: os << "none"; break;
  default: os << "ERROR!!!"; break;
  }
return os;
}

---

httpstats-stage04 [ 7 April, 2001]