EventEntry.h

Go to the documentation of this file.

#ifndef EVENTENTRY_H_
#define EVENTENTRY_H_

#include "LogEntry.h"

#include "component/FailureMode.h"

class Component;
class DataElement;
class RingBufferVoid;

class EventEntry : public LogEntry
{
public:

    typedef enum
    {
        START_CYCLE = 0,            
        SET_DATA_ACCURACY = 1 << 2, 
        SET_DATA_STATE = 2 << 2,    
        COMPONENT_ACTION = 3 << 2,  
    } EventType;
    static const int EVENT_TYPE_MASK = 3 << 2;

    typedef enum
    {
        NO_DATA_STATE_CHANGE = 0,
        DATA_STATE_CHANGE_UNAVAILABLE = 2,
        DATA_STATE_CHANGE_AVAILABLE = 4,
        DATA_STATE_CHANGE_ORPHANED = 8,
        DATA_STATE_CHANGE_UNORPHANED = 16,
        DATA_STATE_CHANGE_SET_BEST = 32,  
        DATA_STATE_CHANGE_INVALID = 64,
        DATA_STATE_CHANGE_VALID = 128,
    } DataStateChange;

    typedef enum
    {
        COMPONENT_LOAD = 0,             
        COMPONENT_MISSION_RUN = 1 << 2, 
        COMPONENT_FAIL = 2 << 2,        
    } ComponentAction;
    static const int COMPONENT_ACTION_MASK = 3 << 2;

    EventEntry( Component* actor,
                DataElement* dataElement,
                const EventType eventType );

    EventEntry( Component* actor,
                DataElement* dataElement,
                const DataStateChange dataStateChange );

    EventEntry( Component* actor,
                const bool loaded );

    EventEntry( Component* actor,
                const int loop );

    EventEntry( Component* actor,
                const FailureMode::FailType failure,
                const int failCount );

    virtual ~EventEntry();

    void* operator new( size_t size );

    void operator delete( void* p );

    const void setAccuracy( const double& accuracy )
    {
        accuracy_ = accuracy;
    }

    const double& getAccuracy( void ) const
    {
        return accuracy_;
    }

    static EventEntry* Read( Timestamp& timeBase, Timespan& timeAdjust, InStream &inStream, unsigned short firstWord, Logger& logger );

    virtual unsigned int write( Timestamp& timeBase, OutStream& logStream ) const;

    virtual Str toString( const Unit* unit = NULL ) const;

    static const char* EventTypeToString( EventType theAction );

    static const char* StateChangeToString( DataStateChange dataStateChange );

    unsigned short getActorCode() const
    {
        return actorCode_;
    }

    ComponentAction getComponentAction( void ) const
    {
        return componentAction_;
    }

    unsigned short getDataElementCode( void ) const
    {
        return dataElementCode_;
    }

    EventType getEventType( void ) const
    {
        return eventType_;
    }

    DataStateChange getDataStateChange( void ) const
    {
        return dataStateChange_;
    }

    void setDataStateChange( const DataStateChange dataStateChange )
    {
        dataStateChange_ = dataStateChange;
    }

    int getRunLoop() const
    {
        return runLoop_;
    }

    bool getLoaded() const
    {
        return loaded_;
    }

    FailureMode::FailType getFailureMode() const
    {
        return failureMode_;
    }

    int getFailCount() const
    {
        return failCount_;
    }

protected:

    EventEntry( const Timestamp& timestamp,
                const unsigned short actorCode,       // Arg1
                const unsigned short dataElementCode, // Arg2
                const EventType action,               // Arg3
                const double& accuracy = 0.0 );       // Arg5

    EventEntry( const Timestamp& timestamp,
                const unsigned short actorCode,        // Arg1
                const unsigned short dataElementCode,  // Arg2
                const DataStateChange dataStateChange, // Arg4
                const double& accuracy = 0.0 );        // Arg5

    EventEntry( const Timestamp& timestamp,
                const unsigned short actorCode,        // Arg1
                const bool loaded );                   // Arg2

    EventEntry( const Timestamp& timestamp,
                const unsigned short actorCode,        // Arg1
                const int loop );                      // Arg2

    EventEntry( const Timestamp& timestamp,
                const unsigned short actorCode,       // Arg1
                const FailureMode::FailType failure,  // Arg2
                const int failCount );                // Arg5

    unsigned short actorCode_;

    union
    {
        unsigned short dataElementCode_;
        bool loaded_;
        int runLoop_;
        FailureMode::FailType failureMode_;
    };

    EventType eventType_;

    union
    {
        DataStateChange dataStateChange_;
        ComponentAction componentAction_;
    };

    union
    {
        double accuracy_;
        int failCount_;
    };

    virtual const Str makeComponentActionString() const;

    virtual const Str makeDataValueString() const;

    static RingBufferVoid* MallocRing_;

    class StaticDestructor
    {
    public:
        ~StaticDestructor();
    };

    static EventEntry::StaticDestructor StaticDestructor_;

};

#endif /*EVENTENTRY_H_*/