SyncComponent.h

Go to the documentation of this file.

#ifndef SYNCCOMPONENT_H_
#define SYNCCOMPONENT_H_

#include "Component.h"

class SyncComponent: public Component
{
public:

    friend class ScriptSyncComponent;
    friend class SyncStarterComponent;
    friend class SyncSimulatorComponent;
    friend class SyncSensorComponent;
    friend class SyncDerivationComponent;
    friend class SyncNavigationComponent;
    friend class SyncEstimationComponent;
    friend class SyncMissionComponent;
    friend class SyncControlComponent;
    friend class SyncMaintainerComponent;
    friend class SyncServoComponent;
    friend class SyncTestComponent;
    friend class SyncReporterComponent;
    friend class SyncLoggerComponent;

    class CycleOrder
    {
    public:
        CycleOrder( int orderPreference ) :
            orderPreference_( orderPreference )
        {
        }
        operator int() const
        {
            return orderPreference_;
        }
        bool operator ==( const CycleOrder& otherPreference ) const
        {
            return orderPreference_ == otherPreference.orderPreference_;
        }
        bool operator !=( const CycleOrder& otherPreference ) const
        {
            return orderPreference_ != otherPreference.orderPreference_;
        }
        bool operator <( const CycleOrder& otherPreference ) const
        {
            return orderPreference_ < otherPreference.orderPreference_;
        }
    private:
        int orderPreference_;
    };

    static const int CYCLE_INCREMENT;
    static const int CYCLE_REPEAT_OFFSET;

    static const CycleOrder CYCLE_STARTER;
    static const CycleOrder CYCLE_SIMULATOR;
    static const CycleOrder CYCLE_SENSOR;
    static const CycleOrder CYCLE_DERIVATION;
    static const CycleOrder CYCLE_ESTIMATION;
    static const CycleOrder CYCLE_NAVIGATION;
    static const CycleOrder CYCLE_MISSION_MANAGER;
    static const CycleOrder CYCLE_MISSION;
    static const CycleOrder CYCLE_CONTROL;
    static const CycleOrder CYCLE_SERVO;
    static const CycleOrder CYCLE_TEST;
    static const CycleOrder CYCLE_REPORTER;
    static const CycleOrder CYCLE_LOGGER;

    CycleOrder getCycleOrder( void )
    {
        return cycleOrder_;
    }

    void setRepeating( bool repeating )
    {
        repeating_ = repeating;
    }

    int getDivisor( ) const
    {
        return divisor_;
    }

    int getModulo( ) const
    {
        return modulo_;
    }

private:

    SyncComponent( const Str& name, const Module* module, CycleOrder cycleOrder,
                   int divisor = 1, int modulo = 0 )
        : Component( name, COMPONENT_SYNC, module ),
          cycleOrder_( cycleOrder ),
          repeater_( false ),
          repeating_( false ),
          divisor_( divisor ),
          modulo_( modulo )
    {}

    CycleOrder cycleOrder_;
    bool repeater_;
    bool repeating_;

    int divisor_;
    int modulo_;

protected:
    void setRepeater( bool repeater )
    {
        repeater_ = repeater;
    }

public:
    bool isRepeater()
    {
        return repeater_;
    }

    bool isRepeating()
    {
        return repeating_;
    }

};

class SyncStarterComponent: public SyncComponent
{
protected:
    SyncStarterComponent( const Str& name, const Module* module )
        : SyncComponent( name, module, CYCLE_STARTER )
    {}
};

class SyncSimulatorComponent: public SyncComponent
{
protected:
    SyncSimulatorComponent( const Str& name, const Module* module,
                            int divisor = 1, int modulo = 0 )
        : SyncComponent( name, module, CYCLE_SIMULATOR, divisor, modulo )
    {}
};

class SyncSensorComponent: public SyncComponent
{
protected:
    SyncSensorComponent( const Str& name, const Module* module,
                         int divisor = 1, int modulo = 0 )
        : SyncComponent( name, module, CYCLE_SENSOR, divisor, modulo )
    {}
};

class SyncDerivationComponent: public SyncComponent
{
protected:
    SyncDerivationComponent( const Str& name, const Module* module,
                             int divisor = 1, int modulo = 0 )
        : SyncComponent( name, module, CYCLE_DERIVATION, divisor, modulo )
    {}
};

class SyncNavigationComponent: public SyncComponent
{
protected:
    SyncNavigationComponent( const Str& name, const Module* module,
                             int divisor = 1, int modulo = 0 )
        : SyncComponent( name, module, CYCLE_NAVIGATION, divisor, modulo )
    {}
};

class SyncEstimationComponent: public SyncComponent
{
protected:
    SyncEstimationComponent( const Str& name, const Module* module,
                             int divisor = 1, int modulo = 0 )
        : SyncComponent( name, module, CYCLE_ESTIMATION, divisor, modulo )
    {}
};

class SyncMissionComponent: public SyncComponent
{
protected:
    SyncMissionComponent( const Str& name, const Module* module )
        : SyncComponent( name, module, CYCLE_MISSION )
    {}
};

class SyncControlComponent: public SyncComponent
{
protected:
    SyncControlComponent( const Str& name, const Module* module,
                          int divisor = 1, int modulo = 0 )
        : SyncComponent( name, module, CYCLE_CONTROL, divisor, modulo )
    {}
};

class SyncMaintainerComponent: public SyncComponent
{
protected:
    SyncMaintainerComponent( const Str& name, const Module* module,
                             CycleOrder cycleOrder, int divisor = 1, int modulo = 0 )
        : SyncComponent( name, module, cycleOrder, divisor, modulo )
    {}
};

class SyncServoComponent: public SyncComponent
{
protected:
    SyncServoComponent( const Str& name, const Module* module,
                        int divisor = 1, int modulo = 0 )
        : SyncComponent( name, module, CYCLE_SERVO, divisor, modulo )
    {}
};

class SyncTestComponent: public SyncComponent
{
protected:
    SyncTestComponent( const Str& name, const Module* module,
                       int divisor = 1, int modulo = 0 )
        : SyncComponent( name, module, CYCLE_TEST, divisor, modulo )
    {}
};

class SyncReporterComponent: public SyncComponent
{
protected:
    SyncReporterComponent( const Str& name, const Module* module,
                           int divisor = 1, int modulo = 0 )
        : SyncComponent( name, module, CYCLE_REPORTER, divisor, modulo )
    {}
};

class SyncLoggerComponent: public SyncComponent
{
protected:
    SyncLoggerComponent( const Str& name, const Module* module )
        : SyncComponent( name, module, CYCLE_LOGGER )
    {}
};

typedef FlexArray<SyncComponent*> ListOfSyncComponents;


#endif /* SYNCCOMPONENT_H_ */