MissionItem.h

Go to the documentation of this file.

#ifndef MISSIONITEM_H_
#define MISSIONITEM_H_

#include "component/ComponentRegistry.h"
#include "component/Behavior.h"
#include "data/Double.h"
#include "data/Location.h"
#include "logger/Logger.h"

class Aggregate;
class Component;
class DefineBehavior;
class MissionNode;
class Trigger;
class ValueClause;

class MissionItem
{
public:

    virtual ~MissionItem();

    static MissionItem* Instance( MissionItem* parent, MissionNode* node,
                                  unsigned int tablePos, Logger& logger );

    Aggregate* getAggregate() const
    {
        return aggregate_ ? ( Aggregate* )component_ : NULL;
    }

    Behavior* getComponent() const
    {
        return component_;
    }

    void setComponent( Behavior* component )
    {
        component_ = component;
    }

    bool isParallel()
    {
        return parallel_;
    }

    void setParallel( bool parallel )
    {
        parallel_ = parallel;
    }

    bool isSequence()
    {
        return sequence_;
    }

    void setSequence( bool sequence )
    {
        sequence_ = sequence;
    }

    bool isAggregate() const
    {
        return aggregate_;
    }

    bool isCompletable()
    {
        return ( isSequence() || ( isAggregate() && !isParallel() ) );
    }

    unsigned int getTablePosition()
    {
        return tablePos_;
    }

    // returns Boolean BREAK clause
    ValueClause* getBreakClause()
    {
        return breakClause_;
    }

    // returns Boolean WHEN clause
    ValueClause* getWhenClause()
    {
        return whenClause_;
    }

    // returns Boolean WHEN clause
    ValueClause* getWhileClause()
    {
        return whileClause_;
    }

    // returns Boolean PREEMPTIVE clause
    ValueClause* getPreemptiveClause()
    {
        return preemptiveClause_;
    }

    // indicates if the clause is preemptive
    bool isPreemptive();

    void setRepeatIndex( int repeatIndex );

    int getRepeatIndex()
    {
        return repeatIndex_;
    }

    int getRepeatLimit()
    {
        return repeatLimit_;
    }

    unsigned int getTablePos()
    {
        return tablePos_;
    }

    // Returns true if the item's missionState is BEHAVIOR_ACTIVE,
    // Or is equal to the indicated activeItem,
    // Or has a whenClause or whileClause true,
    // But not an breakClause true!
    bool isActive( MissionItem* activeItem );

    void initialize();

    void run();

    bool runIfUnsatisfied();

    bool satisfied();

    void preempted();

    void uninitialize( /*PCaller& pCaller*/ );

    bool isTimedOut()
    {
        return timedOut_;
    }

    bool isInitialized()
    {
        return initialized_;
    }

    const Timestamp& getStartTime() const
    {
        return startTime_;
    }

    MissionItem* getParent() const
    {
        return parentItem_;
    }

    void addCall();

    void removeCall();

    DataReader* findArgReader( const Str& argName ) const;

protected:
    MissionItem( MissionItem* parent, unsigned int tablePos );

    // Initializer
    void initializeFromScript( MissionNode* node, Logger& logger );

    // Interpret Repeat attribute
    void interpretRepeat( MissionNode* node, const Str& name, Logger& logger );

    // Interpret RunIn elements
    void interpretRunIn( MissionNode* node, const Str& name, Logger& logger );

    MissionItem* findItemByRefId( const Str& refId ) const;

    void putDefineBehavior( const Str& name, DefineBehavior* defineBehavior );

    DefineBehavior* findDefineBehavior( const Str& name ) const;

    MissionItem* parentItem_;

    unsigned int tablePos_;

    Behavior* component_;

    bool sequence_;

    bool parallel_;

    bool aggregate_;

    ValueClause* breakClause_;

    ValueClause* whenClause_;

    ValueClause* whileClause_;

    ValueClause* preemptiveClause_;

    int callCount_;

    int repeatIndex_;

    int repeatLimit_;

    DataReader* repeatArgReader_;

    Timestamp startTime_;

    bool timedOut_;

    DataReader* timeoutArgReader_;

    MissionItem* timeoutItem_;

    FastMap<const Str, DefineBehavior*>* defineBehaviors_;

    bool preempted_;

    bool initialized_;

    MissionNode* node_;

    bool ignoreWhenWhile_;

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

    void setCompleted();

    void setTimedOut();

};



#endif /*MISSIONITEM_H_*/