ValueClause.h

Go to the documentation of this file.

#ifndef VALUECLAUSE_H_
#define VALUECLAUSE_H_

#include "data/DataReader.h"
#include "logger/Logger.h"
#include "utils/FlexArray.h"

class MissionNode;
class MissionItem;

class ValueClause
{

public:

    typedef enum { OP_NONE,
                   OP_ADD,
                   OP_AND,
                   OP_DIV,
                   OP_EQ,
                   OP_GE,
                   OP_GT,
                   OP_LE,
                   OP_LT,
                   OP_MAX,
                   OP_MIN,
                   OP_MOD,
                   OP_MULT,
                   OP_NE,
                   OP_OR,
                   OP_POW,
                   OP_SUB,
                   OPCOUNT
                 } Operation;

    static const Str OP_NAMES[ OPCOUNT ];

    typedef enum
    {
        READER_NONE,
        READER_ELAPSED
    } ReaderOperation;

    struct ValueClauseSide
    {
        DataValue* dataValue_;
        DataReader* dataReader_;
        MissionItem* owner_;
        ReaderOperation operationReader_;
        ValueClause* subClause_;
        bool deleteDataValue_;

        ValueClauseSide()
            : dataValue_( NULL ),
              dataReader_( NULL ),
              owner_( NULL ),
              operationReader_( READER_NONE ),
              subClause_( NULL ),
              deleteDataValue_( true )
        {}

        ~ValueClauseSide()
        {
            if( NULL != dataValue_ && deleteDataValue_ )
            {
                delete dataValue_;
            }
            if( NULL != subClause_ )
            {
                delete subClause_;
            }
        }
    };

    struct ValueClauseOperation
    {
        Operation comparison_;
        ValueClauseSide rhs_;
    };

    // Simple public Constructor -- normally Static Instance Constructor is used
    ValueClause( DataValue* dataValue, Logger& logger );

    // Static Instance Constructor
    static ValueClause* Instance( MissionNode* node, bool nodeIsParent, MissionItem* owner, Logger& logger, bool isStrValue = false );

    // Used to read a DataReader
    static DataReader* ReadReader( MissionNode* node, MissionItem* owner,
                                   DataValue* defaultValue, Logger& logger, bool deleteDataValue = true );

    // Used to read a static DataValue
    static DataValue* ReadDataValue( MissionNode* unitNode, Logger& logger );

    // Used to read a Unit
    static const Unit* ReadUnit( MissionNode* unitNode, Logger& logger, bool reportErrors = true );

    // Used to read a string DataValue
    static DataValue* ReadStrValue( MissionNode* node, Logger& logger );

    // Used to read a string DataValue
    static DataValue* ReadStrValueUri( MissionNode* node, Logger& logger );

    static Str StripPastColon( Str name );

    static Str StripPastLastDot( Str name );

    // tests the boolclause for truth
    virtual bool test();

    // evaluates the clause
    virtual bool eval();

    // evaluates the clause as a simple string
    virtual bool evalStr();

    // Destructor
    virtual ~ValueClause();

    // Convenience method
    Str toString();

    // Accessor method
    DataValue* getDataValue()
    {
        return dataValue_;
    }

    // If input values have changed since last run of a component
    bool wasTouchedSinceLastRun( const Component* component );

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

    // Convenience method
    Str sideToString( ValueClauseSide& side );

    // Private Constructor
    ValueClause( Logger& logger );

    // Used by instance to read in the Comparison part of the Clause
    static Operation ReadComparison( MissionNode* node, Logger& logger );

    // Used by instance to read in an Entry (lhs or rhs) the Clause
    static bool ReadSide( MissionNode* node, ValueClauseSide& side, MissionItem* owner, Logger& logger, bool isStrValue = false );

    // Used by instance to read in an ValueClauseOperation (comparison and rhs) the Clause
    static ValueClauseOperation* ReadOperation( MissionNode* node, MissionItem* owner, Logger& logger );

    // Evaluates one side of the relationship at hand.
    bool evalSide( const ValueClauseSide& side );

    Logger& logger_;

    bool abs_;

    bool negate_;

    DataValue* dataValue_;

    ValueClauseSide lhs_;

    FlexArray<ValueClauseOperation*> operations_;

};

#endif /*VALUECLAUSE_H_*/