#include <ELlimitsTable.h>

Public Member Functions
bool	add (const ELextendedID &xid)

	ELlimitsTable ()

ELlimitsTable &	operator= (const ELlimitsTable &t)

void	setInterval (const std::string &id, int interval)

void	setInterval (const messagelogger::ELseverityLevel &sev, int interval)

void	setLimit (const std::string &id, int n)

void	setLimit (const messagelogger::ELseverityLevel &sev, int n)

void	setTableLimit (int n)

void	setTimespan (const std::string &id, int n)

void	setTimespan (const messagelogger::ELseverityLevel &sev, int n)

void	wipe ()

void	zero ()

	~ELlimitsTable ()

Protected Attributes
ELmap_counts	counts

ELmap_limits	limits

int	severityIntervals [messagelogger::ELseverityLevel::nLevels]

int	severityLimits [messagelogger::ELseverityLevel::nLevels]

int	severityTimespans [messagelogger::ELseverityLevel::nLevels]

int	tableLimit

int	wildcardInterval

int	wildcardLimit

int	wildcardTimespan

Friends
class	ELdestination

class	ELoutput

Detailed Description

Definition at line 57 of file ELlimitsTable.h.

Constructor & Destructor Documentation

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

Definition at line 38 of file ELlimitsTable.cc.

References EcnaPython_AdcPeg12_S1_10_R170298_1_0_150_Dee0::cerr, isotrackApplyRegressor::k, edm::messagelogger::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 < messagelogger::ELseverityLevel::nLevels; ++k) {
         severityLimits[k] = -1;  // JvR 99-06-10
         severityIntervals[k] = -1;
         severityTimespans[k] = -1;
       }
 
     }  // ELlimitsTable()

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

Definition at line 52 of file ELlimitsTable.cc.

References EcnaPython_AdcPeg12_S1_10_R170298_1_0_150_Dee0::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 65 of file ELlimitsTable.cc.

References c, EcnaPython_AdcPeg12_S1_10_R170298_1_0_150_Dee0::cerr, counts, edm::messagelogger::ELseverityLevel::getLevel(), edm::ELextendedID::id, cmsLHEtoEOSManager::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 233 of file ELlimitsTable.cc.

References limits, edm::messagelogger::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 < messagelogger::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 std::string &	id,
		int	interval
	)

Definition at line 207 of file ELlimitsTable.cc.

References gpuClustering::id, MergeJob_cfg::interval, 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 messagelogger::ELseverityLevel &	sev,
		int	interval
	)

Definition at line 214 of file ELlimitsTable.cc.

References edm::messagelogger::ELseverityLevel::getLevel(), MergeJob_cfg::interval, and severityIntervals.

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

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

Definition at line 196 of file ELlimitsTable.cc.

References gpuClustering::id, limits, dqmiodumpmetadata::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 messagelogger::ELseverityLevel &	sev,
		int	n
	)

Definition at line 203 of file ELlimitsTable.cc.

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

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

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

Definition at line 63 of file ELlimitsTable.cc.

References dqmiodumpmetadata::n, and tableLimit.

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

63 { tableLimit = n; }

edm::service::ELlimitsTable::tableLimit

int tableLimit

Definition: ELlimitsTable.h:96

dqmiodumpmetadata.n

int n

Definition: dqmiodumpmetadata.py:28

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

Definition at line 218 of file ELlimitsTable.cc.

References gpuClustering::id, limits, dqmiodumpmetadata::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 messagelogger::ELseverityLevel &	sev,
		int	n
	)

Definition at line 225 of file ELlimitsTable.cc.

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

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

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

Definition at line 165 of file ELlimitsTable.cc.

References counts, mps_fire::i, limits, edm::messagelogger::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 < messagelogger::ELseverityLevel::nLevels; ++lev) {
         severityLimits[lev] = -1;
         severityIntervals[lev] = -1;
         severityTimespans[lev] = -1;
       }
     }

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

Definition at line 187 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;
     }