Root::RegularFormula Class Reference

#include <RegularFormula.h>

Inheritance diagram for Root::RegularFormula:

Collaboration diagram for Root::RegularFormula:

Public Member Functions
	RegularFormula ()
	RegularFormula (const char *name, const char *expression)
virtual	~RegularFormula ()
	RegularFormula (const Root::RegularFormula &other)
RegularFormula &	operator= (const RegularFormula &other)
Int_t	setFormula (const char *expression)
unsigned int	getNPars () const
const std::list< TString > &	getParNames () const

Private Member Functions
void	parseExpression (const char *expression, TString &expr)

Private Attributes
TString	m_expr
std::list< TString >	m_par

Detailed Description

Definition at line 22 of file RegularFormula.h.

Constructor & Destructor Documentation

RegularFormula() [1/3]

Root::RegularFormula::RegularFormula

(

)

RegularFormula() [2/3]

Root::RegularFormula::RegularFormula	(	const char *	name,
		const char *	expression )

Definition at line 28 of file RegularFormula.cxx.

  : TFormula(name,"1") 
{
  (void) setFormula(expression);
}

~RegularFormula()

Root::RegularFormula::~RegularFormula ( )

virtual

Definition at line 34 of file RegularFormula.cxx.

{
}

RegularFormula() [3/3]

Root::RegularFormula::RegularFormula

(

const Root::RegularFormula &

other

)

Definition at line 39 of file RegularFormula.cxx.

  : TFormula(other)
  , m_expr(other.m_expr)
  , m_par(other.m_par)
{
}

Member Function Documentation

getNPars()

unsigned int Root::RegularFormula::getNPars ( ) const

inline

Definition at line 35 of file RegularFormula.h.

{ return m_par.size(); }

getParNames()

const std::list< TString > & Root::RegularFormula::getParNames ( ) const

inline

Definition at line 36 of file RegularFormula.h.

{ return m_par; }

operator=()

Root::RegularFormula & Root::RegularFormula::operator=

(

const RegularFormula &

other

)

Definition at line 48 of file RegularFormula.cxx.

{
  if (&other==this) {
    return *this;
  }
 
  TFormula::operator=(other) ;
  m_expr = other.m_expr;
  m_par  = other.m_par;
 
  return *this ;
}

parseExpression()

void Root::RegularFormula::parseExpression ( const char * expression, TString & expr )

private

Definition at line 63 of file RegularFormula.cxx.

{ 
  expr = expression;
  TString parStr(expression);
 
  TRegexp specialChars("[+-/*%&=!><()|]+");
  int lastIdx = -1;
  do {
    //search for special characters and determine if they're escaped
    lastIdx = parStr.Index(specialChars, lastIdx+1);
    if (lastIdx >= 0) {
      bool needsReplacement = false;
      if (lastIdx > 0) {
    //if a match is found and it's not the first character of the string
    char isEscape = parStr[lastIdx-1];
    if (isEscape == '\\') {
      //this is an escpaed special character, keep it but remove escape
      // both on parStr as well as in expr
      parStr = parStr.Remove(lastIdx-1, 1);
      expr = expr.Remove(lastIdx-1, 1);
      needsReplacement = false;
      lastIdx--; //we removed one character from the string
    } else {
      needsReplacement = true;
    }
      } else {
    //matched the first character
    needsReplacement = true;
      }
 
      if (needsReplacement) {
    //not escaped, just replace with a space to allow parameters parsing below
    parStr = parStr.Replace(lastIdx, 1, " ");
      }
    }
  } while (lastIdx >= 0);
 
  TMsgLogger mylogger( "RegularFormula" );
  mylogger << kINFO << "Now parsing regular expression : " << expression << GEndl;
  mylogger << kINFO << "Please be aware that Cling errors are expected and aren't inherently a problem" << GEndl;
 
  TFormula analyzer("analyzer","1");
  TObjArray* parArr = parStr.Tokenize(" ");
  for (int count(0), i(0); i<parArr->GetEntries(); ++i) {
    TString myPar = ((TObjString*)parArr->At(i))->GetString();
    if ( 0==analyzer.Compile(myPar.Data()) || 
         0==analyzer.Compile(Form("%s(1)",myPar.Data())) ) {
      continue;
    } else {
      std::list<TString>::iterator itrF = std::find(m_par.begin(),m_par.end(),myPar);
      if (itrF==m_par.end()) {
        expr = expr.ReplaceAll(myPar,Form("[%d]",count));
        m_par.push_back(myPar);
        count++;
      }
    }
  }
  delete parArr;
 
  mylogger << kINFO << "Number of interpreted input parameters : " << m_par.size() << GEndl;
  mylogger << kINFO << "Parsed regular expression : " << expr << GEndl;  
}

setFormula()

Int_t Root::RegularFormula::setFormula

(

const char *

expression

)

Definition at line 128 of file RegularFormula.cxx.

{
  m_par.clear();
  this->parseExpression(expression,m_expr);
  return this->Compile(m_expr.Data());
}

Member Data Documentation

m_expr

TString Root::RegularFormula::m_expr

private

Definition at line 42 of file RegularFormula.h.

m_par

std::list<TString> Root::RegularFormula::m_par

private

Definition at line 43 of file RegularFormula.h.

---

The documentation for this class was generated from the following files:

• RegularFormula.h
• RegularFormula.cxx