LoggerRules.h

Go to the documentation of this file.

#ifndef LOGGERRULES_H_
#define LOGGERRULES_H_

#include "DataEntry.h"
#include "EventEntry.h"
#include "SyslogEntry.h"

class Rule
{
public:
    virtual ~Rule( void )
    {}
    ;

    virtual bool check( const LogEntry *entry ) = 0;

    virtual Str toString( void ) = 0;

    virtual void activate();

    virtual void deactivate();

    virtual bool isActive();

protected:

    Rule( void );

private:
    // Note that the copy constructor below is private and not given a body.
    // Any attempt to call it will return a compiler error.
    Rule( const Rule& old ); // disallow copy constructor

    bool active_;

};

class AndRule : public Rule
{
public:
    AndRule( Rule *ruleOneIn,
             Rule *ruleTwoIn,
             Rule *ruleThreeIn = NULL,
             Rule *ruleFourIn = NULL,
             Rule *ruleFiveIn = NULL,
             Rule *ruleSizIn = NULL,
             Rule *ruleSevenIn = NULL );

    virtual ~AndRule( void );

    virtual bool check( const LogEntry *entry );

    virtual Str toString( void );

private:
    // Note that the copy constructor below is private and not given a body.
    // Any attempt to call it will return a compiler error.
    AndRule( const AndRule& old ); // disallow copy constructor

    Rule *ruleOne_, *ruleTwo_, *ruleThree_, *ruleFour_, *ruleFive_, *ruleSix_, *ruleSeven_;
};

class OrRule : public Rule
{
public:
    OrRule( Rule *ruleOneIn,
            Rule *ruleTwoIn,
            Rule *ruleThreeIn = NULL,
            Rule *ruleFourIn = NULL,
            Rule *ruleFiveIn = NULL );

    virtual ~OrRule( void );

    virtual bool check( const LogEntry *entry );

    virtual Str toString( void );

private:
    // Note that the copy constructor below is private and not given a body.
    // Any attempt to call it will return a compiler error.
    OrRule( const OrRule& old ); // disallow copy constructor

    Rule *ruleOne_, *ruleTwo_, *ruleThree_, *ruleFour_, *ruleFive_ ;
};

class NotRule : public Rule
{
public:
    NotRule( Rule *ruleIn );

    virtual ~NotRule( void );

    virtual bool check( const LogEntry *entry );

    virtual Str toString( void );

private:
    // Note that the copy constructor below is private and not given a body.
    // Any attempt to call it will return a compiler error.
    NotRule( const NotRule& old ); // disallow copy constructor

    Rule *rule_;
};

class TypeRule : public Rule
{
public:
    TypeRule( LogEntry::Type typeIn );

    virtual ~TypeRule( void );

    virtual bool check( const LogEntry *entry );

    virtual Str toString( void );

private:

    LogEntry::Type type_;
};

class EventTypeRule : public Rule
{
public:
    EventTypeRule( EventEntry::EventType eventIn );

    virtual ~EventTypeRule( void );

    virtual bool check( const LogEntry *entry );

    virtual Str toString( void );

private:

    EventEntry::EventType eventType_;
};

class SyslogSeverityRule : public Rule
{
public:
    SyslogSeverityRule( Syslog::Severity sev, bool orGreater = true );

    virtual ~SyslogSeverityRule( void );

    virtual bool check( const LogEntry *entry );

    virtual Str toString( void );

private:

    Syslog::Severity severity_;
    bool orGreater_;
};

class SyslogStartRule : public Rule
{
public:
    SyslogStartRule( const Str& start );

    virtual ~SyslogStartRule( void );

    virtual bool check( const LogEntry *entry );

    virtual Str toString( void );

private:

    Str start_;
};

class DataWriteRule : public Rule
{
public:
    DataWriteRule( bool dataWrite );

    virtual ~DataWriteRule( void );

    virtual bool check( const LogEntry *entry );

    virtual Str toString( void );

private:

    bool dataWrite_;
};

class DataNameRule : public DataWriteRule
{
public:
    DataNameRule( const Str& dataName, bool dataWrite = true );

    virtual ~DataNameRule( void );

    virtual bool check( const LogEntry *entry );

    virtual Str toString( void );

private:

    const Str dataName_;
    unsigned short code_;
    unsigned int slateElementURICount_;
};
#endif /*LOGGERRULES_H_*/