#include <ELlimitsTable.h>

Public Member Functions
bool	add (const ELextendedID &xid)

	ELlimitsTable ()

ELlimitsTable &	operator= (const ELlimitsTable &t)

void	setInterval (const ELstring &id, int interval)

void	setInterval (const ELseverityLevel &sev, int interval)

void	setLimit (const ELstring &id, int n)

void	setLimit (const ELseverityLevel &sev, int n)

void	setTableLimit (int n)

void	setTimespan (const ELstring &id, int n)

void	setTimespan (const ELseverityLevel &sev, int n)

void	wipe ()

void	zero ()

	~ELlimitsTable ()

Protected Attributes
ELmap_counts	counts

ELmap_limits	limits

int	severityIntervals [ELseverityLevel::nLevels]

int	severityLimits [ELseverityLevel::nLevels]

int	severityTimespans [ELseverityLevel::nLevels]

int	tableLimit

int	wildcardInterval

int	wildcardLimit

int	wildcardTimespan

Friends
class	ELdestination

class	ELoutput

Detailed Description

Definition at line 60 of file ELlimitsTable.h.

Constructor & Destructor Documentation

edm::service::ELlimitsTable::ELlimitsTable ( )

Definition at line 41 of file ELlimitsTable.cc.

References MessageLogger_cfi::cerr, gen::k, edm::ELseverityLevel::nLevels, severityIntervals, severityLimits, and severityTimespans.

 : wildcardLimit   ( -1 )
 , wildcardInterval( -1 )
 , wildcardTimespan( -1 )
 , tableLimit      ( -1 )
 , limits          (    )
 , counts          (    )
 {
 
 #ifdef ELlimitsTableCONSTRUCTOR_TRACE
   std::cerr << "Constructor for ELlimitsTable\n";
 #endif
 
   for ( int k = 0;  k < ELseverityLevel::nLevels;  ++k )  {
     severityLimits[k]    = -1;                // JvR 99-06-10
     severityIntervals[k]    = -1;             
     severityTimespans[k] = -1;
   }
 
 }  // ELlimitsTable()

edm::service::ELlimitsTable::~ELlimitsTable ( )

Definition at line 63 of file ELlimitsTable.cc.

References MessageLogger_cfi::cerr.

                                {
 
 #ifdef ELlimitsTableCONSTRUCTOR_TRACE
   std::cerr << "Destructor for ELlimitsTable\n";
 #endif
 
 }  // ~ELlimitsTable()

Member Function Documentation

bool edm::service::ELlimitsTable::add ( const ELextendedID & xid )

Definition at line 79 of file ELlimitsTable.cc.

References EnergyCorrector::c, MessageLogger_cfi::cerr, counts, edm::ELseverityLevel::getLevel(), edm::ELextendedID::id, checklumidiff::l, limits, edm::ELextendedID::severity, severityIntervals, severityLimits, severityTimespans, tableLimit, wildcardInterval, wildcardLimit, and wildcardTimespan.

Referenced by edm::service::ELoutput::log(), counter.Counter::register(), SequenceTypes.Task::remove(), and SequenceTypes.Task::replace().

                                                    {
 
 #ifdef ELlimitsTableATRACE
   std::cerr << "&&&--- adding to limits table: " << xid.id << '\n';
 #endif
 
   ELmap_counts::iterator c = counts.find( xid );
 
   if ( c == counts.end() )  {  // no such entry yet
 
     #ifdef ELlimitsTableATRACE
     std::cerr << "&&&    no such entry yet in counts \n";
     #endif
 
     // if the counts table is "full", then this will never be rejected
     // and info will not be kept so why go through significant work: 
     if ( tableLimit > 0  && static_cast<int>(counts.size()) >= tableLimit ) {
       return true;
     }
     int lim;
     int ivl;
     int ts;
     ELmap_limits::iterator l = limits.find( xid.id );
 
     if ( l != limits.end() )  { // use limits previously established for this id
       lim = (*l).second.limit;
       ivl = (*l).second.interval;
       ts  = (*l).second.timespan;
       if ( lim < 0 )  {                                    // jvr 6/17/99
         lim = severityLimits[xid.severity.getLevel()];
         if ( lim < 0 )  {
           lim = wildcardLimit;
         }
       }
       if ( ivl < 0 )  {                                    
         ivl = severityIntervals[xid.severity.getLevel()];
         if ( ivl < 0 )  {
           ivl = wildcardInterval;           // mf 11/02/07
         }
       }
       if ( ts < 0 )  {
         ts = severityTimespans[xid.severity.getLevel()];
         if (ts < 0 )  {
           ts = wildcardTimespan;
         }
         limits[xid.id] = LimitAndTimespan( lim, ts );
       }
       #ifdef ELlimitsTableATRACE
       std::cerr << "&&&    Entry found in limits: limit = " << lim
            << " interval = " << ivl
            << " timespan = " << ts << '\n';
       #endif
       // change log 9/29/10:  Do not put this into limits table
    } else  {   // establish and use limits new to this id
       lim = severityLimits   [xid.severity.getLevel()];
       ivl = severityIntervals[xid.severity.getLevel()];
       ts  = severityTimespans[xid.severity.getLevel()];
       #ifdef ELlimitsTableATRACE
       std::cerr << "&&&    Limit taken from severityLimits: " << lim << '\n'
            << "&&&    Interval taken from severityLimits: " << ivl << '\n';
       #endif
       if ( lim < 0 )  {
         lim = wildcardLimit;
         #ifdef ELlimitsTableATRACE
         std::cerr << "&&&    Limit reset to wildcard limit: " << lim << '\n';
         #endif
       }
       if ( ivl < 0 )  {
         ivl = wildcardInterval;
         #ifdef ELlimitsTableATRACE
         std::cerr << "&&&    Interval reset to wildcard interval: " << ivl << '\n';
         #endif
       }
       #ifdef ELlimitsTableATRACE
       std::cerr << "&&&    Timespan taken from severityTimespans: " << ts << '\n';
       #endif
       if ( ts < 0 )  {
         ts = wildcardTimespan;
         #ifdef ELlimitsTableATRACE
         std::cerr << "&&&    timespan reset to wildcard timespan: " << ts << '\n';
         #endif
       }
 
       // change log 9/29/10 DO not save id's future limits:
     }
 
     // save, if possible, this xid's initial entry:
     if ( tableLimit < 0  || static_cast<int>(counts.size()) < tableLimit )
       counts[xid] = CountAndLimit( lim, ts, ivl );
     c = counts.find( xid );
   }
 
   return  ( c == counts.end() )
         ? true               // no limit filtering can be applied
         : (*c).second.add()  // apply limit filtering
         ;
 
 }  // add()

ELlimitsTable & edm::service::ELlimitsTable::operator= ( const ELlimitsTable & t )

Definition at line 253 of file ELlimitsTable.cc.

References limits, edm::ELseverityLevel::nLevels, severityTimespans, wildcardLimit, and wildcardTimespan.

                                                                    {
 
   if(this == &t) {
     return  *this; // self assignment
   }
   limits = t.limits;  // The non-trivial operator= for a map!
 
   for ( int lev = 0;  lev < ELseverityLevel::nLevels;  ++lev )  {
     severityTimespans[lev] = t.severityTimespans[lev];
     severityTimespans[lev] = t.severityTimespans[lev];
   }
 
   wildcardLimit    = t.wildcardLimit;
   wildcardTimespan = t.wildcardTimespan;
 
   return  *this;
 
 }  // operator=()

void edm::service::ELlimitsTable::setInterval	(	const ELstring &	id,
		int	interval
	)

Definition at line 227 of file ELlimitsTable.cc.

References hcalTTPDigis_cfi::id, limits, and wildcardInterval.

Referenced by edm::service::ELdestination::setInterval().

                                                                     {
   if ( id[0] == '*' )  wildcardInterval    = interval;
   else                 limits[id].interval = interval;
 }

void edm::service::ELlimitsTable::setInterval	(	const ELseverityLevel &	sev,
		int	interval
	)

Definition at line 233 of file ELlimitsTable.cc.

References edm::ELseverityLevel::getLevel(), and severityIntervals.

                                                                             {
   severityIntervals[sev.getLevel()] = interval;
 }

void edm::service::ELlimitsTable::setLimit	(	const ELstring &	id,
		int	n
	)

Definition at line 217 of file ELlimitsTable.cc.

References hcalTTPDigis_cfi::id, limits, gen::n, and wildcardLimit.

Referenced by edm::service::ELdestination::setLimit().

                                                           {
   if ( id[0] == '*' )  wildcardLimit    = n;
   else                 limits[id].limit = n;
 }

void edm::service::ELlimitsTable::setLimit	(	const ELseverityLevel &	sev,
		int	n
	)

Definition at line 223 of file ELlimitsTable.cc.

References edm::ELseverityLevel::getLevel(), gen::n, and severityLimits.

                                                                   {
   severityLimits[sev.getLevel()] = n;
 }

void edm::service::ELlimitsTable::setTableLimit ( int n )

Definition at line 76 of file ELlimitsTable.cc.

References gen::n, and tableLimit.

Referenced by edm::service::ELdestination::setTableLimit().

76 { tableLimit = n; }

edm::service::ELlimitsTable::tableLimit

int tableLimit

Definition: ELlimitsTable.h:103

gen::n

int n

Definition: Cascade2Hadronizer.cc:79

void edm::service::ELlimitsTable::setTimespan	(	const ELstring &	id,
		int	n
	)

Definition at line 238 of file ELlimitsTable.cc.

References hcalTTPDigis_cfi::id, limits, gen::n, and wildcardTimespan.

Referenced by edm::service::ELdestination::setTimespan().

                                                              {
   if ( id[0] == '*' )  wildcardTimespan    = n;
   else                 limits[id].timespan = n;
 }

void edm::service::ELlimitsTable::setTimespan	(	const ELseverityLevel &	sev,
		int	n
	)

Definition at line 244 of file ELlimitsTable.cc.

References edm::ELseverityLevel::getLevel(), gen::n, and severityTimespans.

                                                                      {
   severityTimespans[sev.getLevel()] = n;
 }

void edm::service::ELlimitsTable::wipe ( )

Definition at line 183 of file ELlimitsTable.cc.

References counts, mps_fire::i, limits, edm::ELseverityLevel::nLevels, severityIntervals, severityLimits, severityTimespans, wildcardLimit, and wildcardTimespan.

Referenced by edm::service::ELstatistics::wipe(), and edm::service::ELdestination::wipe().

                           {
   // This clears everything -- counts and aggregate counts for severity levels
   // and for individual ID's, as well as any limits established, the limit
   // for "*" all messages, and the collection of severity defaults.  wipe()
   // does not not affect thresholds.
 
   limits.erase( limits.begin(), limits.end() );
   ELmap_counts::iterator i;
   for ( i = counts.begin();  i != counts.end();  ++i )  {
     (*i).second.limit = -1;
     (*i).second.n = (*i).second.aggregateN = 0;
   }
 
   wildcardLimit    = -1;
   wildcardTimespan = -1;
   for ( int lev = 0;  lev < ELseverityLevel::nLevels;  ++lev )  {
     severityLimits   [lev] = -1;
     severityIntervals[lev] = -1;
     severityTimespans[lev] = -1;
   }
 
 }

void edm::service::ELlimitsTable::zero ( )

Definition at line 207 of file ELlimitsTable.cc.

References counts, and mps_fire::i.

Referenced by edm::service::ELstatistics::clearSummary(), edm::service::ELstatistics::zero(), and edm::service::ELdestination::zero().

                           {
   // This clears counts but not aggregate counts for severity levels
   // and for individual ID's.
 
   ELmap_counts::iterator i;
   for ( i = counts.begin();  i != counts.end();  ++i )
     (*i).second.n = 0;
 }