DataElement.h

Go to the documentation of this file.

#ifndef DATAELEMENT_H_
#define DATAELEMENT_H_

#include <exception>

#include "data/DataValue.h"
#include "data/UniversalURI.h"
#include "data/DataReader.h"
#include "data/DataWriter.h"
#include "utils/FlexArray.h"
#include "utils/Mutex.h"
#include "utils/Str.h"

class Component;
class CodedStr;
class Slate;
class Unit;
class UniversalDataElement;

class DataElement
{

    friend class CommandLine; // for access to getDataValue
    friend class DataAccess;
    friend class DataEntry; // for access to getDataValue
    friend class MissionStateLogger; // for access to getDataValue
    friend class Slate; // for ReadOnce operations
    friend class UniversalDataElement;

public:

    class UninitializedException
    {
    public:
        UninitializedException( /*const Str& message*/ )
        //: message_( message )
        {
            //message_ = message;
        }

        virtual ~UninitializedException() throw()
        {}

        const char* what() const throw()
        {
            //return message_.cStr();
            return "DataElement not active";
        }

    private:
        //Str message_;
    };

    static const float NO_ACCURACY;

    virtual ~DataElement();

    DataReader* findReader( const ElementURI& uri );

    DataWriter* findWriter( const ElementURI& uri );

    const ElementURI& getUri( void ) const;

    virtual const Timestamp& getTimestamp() const
    {
        return timestamp_;
    };

    //-- Functions dealing with the element's "state" ---------------

    virtual bool isUnavailable( void ) const;

    virtual bool isInvalid( void ) const;

    virtual bool isOwnersFailed( void ) const;

    bool setUnavailable( bool unavailable, DataWriter* notifier );
    bool setUnavailable( bool unavailable, Component* notifier );

    bool setInvalid( bool invalid, DataWriter* notifier );
    bool setInvalid( bool invalid, Component* notifier );

    virtual void setTimestamp( const Timestamp& timestamp = Timestamp::NOT_SET_TIME );

    virtual bool isOrphaned( void ) const;

    virtual bool isOwnersActive( void ) const;

    virtual bool isActivatable( void ) const;

    virtual bool isActive( void ) const;

    bool isBest( DataAccessor::RequestStrategy strategy = DataAccessor::MIN_ERROR ) const;

    const Unit* getUnit( void ) const;

    virtual bool isUniversal( ) const
    {
        return false;
    }

    //-- Registration functions -------------------------------------
    void registerUniversal( UniversalDataElement *abstract );

    UniversalDataElement* getUniversal( void ) const
    {
        return universal_;
    }

    void registerReader( DataReader *reader );

    void unregisterReader( DataReader *reader );

    unsigned int readerCount() const;

    bool hasReaders( void ) const
    {
        return 0 < readerCount();
    }

    bool isDataRequested();

    bool isImplemented();

    void registerWriter( DataWriter *writer );

    void unregisterWriter( DataWriter *writer );

    unsigned int writerCount() const;

    bool hasWriters( void ) const
    {
        return 0 < writerCount();
    }

    //===============================================================
    // Logging functions
    virtual void registerRead( DataReader &reader );
    virtual void registerWrite( DataWriter &writer, bool changed );

    //===============================================================
    // Universal interactions
    void registerChangePending( DataWriter* writer );
    void registerChangeDone( Component* notifier );
    void registerChangeDone( void );

    //===============================================================
    virtual bool get( DataReader &reader, const Unit& unit, bool& readTo ) throw( UninitializedException );
    virtual bool get( DataReader &reader, const Unit& unit, unsigned char& readTo ) throw( UninitializedException );
    virtual bool get( DataReader &reader, const Unit& unit, double& readTo ) throw( UninitializedException );
    virtual bool get( DataReader &reader, const Unit& unit, float& readTo ) throw( UninitializedException );
    virtual bool get( DataReader &reader, const Unit& unit, int &readTo ) throw( UninitializedException );
    virtual bool get( DataReader &reader, DataValue& readTo ) throw( UninitializedException );

    virtual const double asDouble( DataReader &reader, const Unit& unit ) throw( UninitializedException );
    virtual const int asInt( DataReader &reader, const Unit& unit ) throw( UninitializedException );
    virtual const Str asString( DataReader &reader, const Unit& unit ) throw( UninitializedException );

    virtual float getAccuracy( const Unit& unit ) const throw( UninitializedException ) = 0;

    virtual float getWrittenAccuracy( const Unit& unit ) const
    {
        return unit.getScaled( writtenAccuracy_ );
    }

    //===============================================================
    virtual bool set( DataWriter &writer, const Unit& unit, const bool value, const Timestamp& timestamp = Timestamp::NOT_SET_TIME );
    virtual bool set( DataWriter &writer, const Unit& unit, const unsigned char value, const Timestamp& timestamp = Timestamp::NOT_SET_TIME );
    virtual bool set( DataWriter &writer, const Unit& unit, const double value, const Timestamp& timestamp = Timestamp::NOT_SET_TIME );
    virtual bool set( DataWriter &writer, const Unit& unit, const float value, const Timestamp& timestamp = Timestamp::NOT_SET_TIME );
    virtual bool set( DataWriter &writer, const Unit& unit, const int value, const Timestamp& timestamp = Timestamp::NOT_SET_TIME );
    virtual bool set( DataWriter &writer, const DataValue& value, const Timestamp& timestamp = Timestamp::NOT_SET_TIME );

    virtual bool setWithAccuracy( DataWriter &writer, const Unit& unit, const bool value, const float accuracy, const Timestamp& timestamp = Timestamp::NOT_SET_TIME );
    virtual bool setWithAccuracy( DataWriter &writer, const Unit& unit, const unsigned char value, const float accuracy, const Timestamp& timestamp = Timestamp::NOT_SET_TIME );
    virtual bool setWithAccuracy( DataWriter &writer, const Unit& unit, const double value, const float accuracy, const Timestamp& timestamp = Timestamp::NOT_SET_TIME );
    virtual bool setWithAccuracy( DataWriter &writer, const Unit& unit, const int value, const float accuracy, const Timestamp& timestamp = Timestamp::NOT_SET_TIME );
    virtual bool setWithAccuracy( DataWriter &writer, const DataValue& value, const float accuracy, const Timestamp& timestamp = Timestamp::NOT_SET_TIME );

    //===============================================================
    virtual bool setAccuracy( DataWriter &writer, const Unit& unit, const float accuracy );

    virtual float getBaseAccuracy() const = 0;

    virtual const Unit* getBaseUnit()
    {
        return baseUnit_;
    }

    virtual size_t getTypeSize()
    {
        return typeSize_;
    }

    virtual bool wasTouchedSinceLastRun( const Component* component );

    float getPower()
    {
        return power_;
    }

    float getError()
    {
        return getBaseAccuracy();
    }

    float getLatency()
    {
        return latency_;
    }

    float getFrequency()
    {
        return frequency_;
    }

    void setPower( float power )
    {
        power_ = power;
    }

    void setLatency( float latency )
    {
        latency_ = latency;
    }

    void setFrequency( float frequency )
    {
        frequency_ = frequency;
    }

protected:

    DataElement( const ElementURI& name, const Unit* baseUnit, size_t typeSize );

    bool setWrittenAccuracy();

    ElementURI name_;                

    //UniversalElementQueue universalQueue_;
    // Really just one UniversalElement.
    UniversalDataElement* universal_;

    DataWriter *notifier_;

    FlexArray<DataWriter*> writers_;            
    FlexArray<DataReader*> readers_;            

    bool unavailable_;

    bool invalid_;

    bool wasOrphaned_;

    Mutex mutex_;

    float writtenAccuracy_;

    Timestamp timestamp_;

    virtual DataValue* getDataValue( void ) const = 0;

    virtual void setDataValue( DataValue* dataValue ) = 0;

    virtual float setAccuracy( const Unit& unit, float accuracy ) = 0;

    bool hasBeenSet_;

    const Unit* baseUnit_;

    virtual void setBaseUnit( const Unit* baseUnit )
    {
        baseUnit_ = baseUnit;
    }

    size_t typeSize_;

    virtual void setTypeSize( const size_t typeSize )
    {
        typeSize_ = typeSize;
    }

    float power_;

    float latency_;

    float frequency_;

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

};

typedef FlexArray<DataElement*> DataElementList;

#endif /*DATAELEMENT_H_*/