Slate.h

Go to the documentation of this file.

#ifndef SLATE_H_
#define SLATE_H_

#include "component/Component.h"
#include "data/DataAccess.h"
#include "data/DataAccessor.h"
#include "data/DataValue.h"
#include "data/ElementURI.h"
#include "data/SimpleDataElement.h"
#include "data/UniversalURI.h"
#include "logger/Logger.h"
#include "utils/Mutex.h"
#include "utils/Str.h"

#ifdef ERROR  // A workaround for wingdi.h
#undef ERROR
#endif

class DataReader;
class DataValue;
class DataWriter;
class InStream;
class LogWriter;
class SimpleDataElement;
class UniversalDataReader;
class UniversalDataWriter;

template<typename S, typename T> class FastMap;

typedef FastMap<const ElementURI, DataElement*> DataElementMap;
typedef FastMap<const ElementURI, UniversalDataElement*> UniversalMap;

typedef FastMap<const Str, DataAccess*> DataAccessMap;
typedef FastMap<const Str, ElementURI*> ElementURIMap;
typedef FastMap<const Str, CodedStr*> NameMap;

template<typename T> class FlexArray;

typedef FlexArray<DataAccess*> DataAccessArray;
typedef FlexArray<DataAccess*> DataAccessList;
typedef FlexArray<ElementURI*> ElementURIArray;
typedef FlexArray<ElementURI*> ElementURIList;
typedef FlexArray<CodedStr*> NameArray;
typedef FlexArray<CodedStr*> NameList;

class Slate
{
public:

    static void Construct();

    static DataAccess* GetDataAccess( const unsigned short& code );

    static DataAccess* GetDataAccess( const DataAccessor& dataAccessor, UniversalDataElement* universal = NULL );

    static unsigned short GetDataAccessCount()
    {
        return NextDataAccessCode_;
    }

    static DataAccess* RegisterDataAccess( DataAccess* dataAccess );

    static DataElement* GetElement( const unsigned short& uriCode );

    static DataElement* GetElement( const ElementURI& elementURI );

    static ElementURI* GetElementURI( const unsigned short& code );

    static ElementURI* GetElementURI( const ElementURI& elementURI );

    static unsigned int GetElementURICount();

    static void CodifyElementURI( ElementURI& elementURI );

    static ElementURI* RegisterElementURI( ElementURI* elementURI );

    static void DeRegisterElementURI( ElementURI* elementURI );

    static ElementURI* FindElementURI( const Str& str );

    static  unsigned short GetElementURICode( const char* chars );

    static CodedStr* GetName( const unsigned short& code );

    static CodedStr* FindCodedName( const Str& name );

    static CodedStr& GetCodedName( const Str& name );

    static void MapDataElement( ElementURI* elementURI, DataElement* dataElement );

    static CodedStr* RegisterCodedName( CodedStr* name );

    static DataReader* NewInputReader( const Str& uriPart,
                                       Component* owner, const DataValue* defaultValue, bool deleteDefaultValue = true );
    static DataReader* NewInputReader( const ElementURI &elementURI,
                                       Component* owner, const DataValue* defaultValue, bool deleteDefaultValue = true );

    // Creates a writer for this component's output (and a dataElement)
    static DataWriter* NewOutputWriter( const Str& uriPart,
                                        Component* owner,
                                        DataValue* initialValue );
    static DataWriter* NewOutputWriter( const ElementURI &elementURI,
                                        Component* owner,
                                        DataValue* initialValue );

    // Creates a reader for some other component's declared output
    static DataReader* NewReader( const Str &componentName, const Str& uriPart,
                                  Component* owner, const DataValue* defaultValue, bool deleteDefaultValue = true ); // TODO: __attribute__( ( deprecated ) ); // ("Use Component::newDataReader with DataURI arg instead.") ));
    static DataReader* NewReader( const ElementURI &elementURI,
                                  Component* owner, const DataValue* defaultValue, bool deleteDefaultValue = true ); // TODO: __attribute__( ( deprecated ) ); // ("Use Component::newDataReader with DataURI arg instead.") ));

    // Creates a reader for any universal outputs
    // Also creates a UniversalDataElement if a suitable one does not exist
    static UniversalDataReader* NewUniversalReader( const UniversalURI &universalURI,
            Component* owner, const DataValue* defaultValue, bool deleteDefaultValue = true ); // TODO: __attribute__( ( deprecated ) ); // ("Use Component::newUniversalReader with UniversalURI arg instead.") ));

    // Creates a writer for this component's universal output (and a dataElement)
    // Also creates a UniversalDataElement if a suitable one does not exist
    static UniversalDataWriter* NewUniversalWriter( const UniversalURI &universalURI,
            Component* owner, DataValue* initialValue,
            const float accuracy = DataElement::NO_ACCURACY ); // TODO: __attribute__( ( deprecated ) ); // ("Use Component::newUniversalWriter with UniversalURI arg instead.") ));

    // Creates a writer for some other component's declared input
    static DataWriter* NewWriter( const Str &componentName, const Str& uriPart,
                                  Component* owner ); // TODO: __attribute__( ( deprecated ) ); // ("Use Component::newDataWriter with DataURI arg instead.") ));
    static DataWriter* NewWriter( const ElementURI &elementURI,
                                  Component* owner ); // TODO: __attribute__( ( deprecated ) ); // ("Use Component::newDataWriter with DataURI arg instead.") ));

    static DataElement* NewDataElement( const ElementURI &elementURI,
                                        Component* owner,
                                        const Unit& unit, BinaryDataType binaryType,
                                        const float accuracy = DataElement::NO_ACCURACY );

    static UniversalDataElement *NewUniversalElement( const UniversalURI &universalURI,
            Component* owner, const Unit& unit, BinaryDataType binaryType );


    template<typename T>
    inline static bool ReadOnce( const Str& componentName, const Str& uriPart,
                                 const Unit& unit, T& readTo, Logger& logger,
                                 Syslog::Severity severity = Syslog::CRITICAL )
    {
        return ReadOnce( ElementURI( componentName, uriPart ), unit, readTo,
                         logger, severity );
    }
    template<typename T> static bool ReadOnce( const ElementURI& elementURI,
            const Unit& unit, T& readTo, Logger& logger,
            Syslog::Severity severity = Syslog::CRITICAL );

    inline static bool ReadOnce( const Str& componentName, const Str& uriPart,
                                 DataValue& readTo, Logger& logger, Syslog::Severity severity =
                                     Syslog::CRITICAL )
    {
        return ReadOnce( ElementURI( componentName, uriPart ), readTo, logger,
                         severity );
    }

    static bool ReadOnce( const ElementURI& elementURI, DataValue& readTo,
                          Logger& logger, Syslog::Severity severity = Syslog::CRITICAL );
    template<typename T> static bool ReadOnce( const unsigned short & uriCode,
            const Unit& unit, T& readTo, Logger& logger,
            Syslog::Severity severity = Syslog::CRITICAL );
    template<typename T> static bool WriteOnce( const Str& uriPart,
            Component* owner, const Unit& unit, const T& writeThis );
    static bool WriteOnce( const Str& uriPart, Component* owner,
                           const DataValue& writeThis );
    template<typename T> static bool WriteOnce( const unsigned short & uriCode,
            Component* actor, const Unit& unit, const T& writeThis );
    static bool WriteOnce( const unsigned short & uriCode, Component* actor,
                           const DataValue& writeThis );
    // Called during initialization, to build up slate table entries based on
    // previous outputs -- allowing continious logging across multiple
    // runs and re-initialization of dataValues.
    static void ReadDirectory( const Str& dirFilename );
    // Called only by unserialize, to allow multiple directory scans.
    static void ClearDirectory();

    static bool IsDirectoryRead()
    {
        return DirectoryRead_;
    }

    // Enables logging of directory entries.
    // Not called by unseriailize, for example.
    static void EnableDirectoryWrites();
    // Called by Unit Tests.
    static void SimulateDirectoryWrites();
    // Called by DirectoryWriter to log all the directory entries
    static void WriteDirectory( LogWriter* rewriteTo = NULL, bool forceLog =
                                    false );
    static const unsigned short NO_LOG_FORMAT = 0x0000;

private:
    Slate()
    {
    }

    ;
    static DataElement* NewDataElement( const ElementURI& elementURI,
                                        Component* owner, DataValue* initialValue, float accuracy =
                                            DataElement::NO_ACCURACY );
    static UniversalDataElement* NewUniversalElement(
        const UniversalURI& universalURI, Component* owner,
        const DataValue* testValue );
    static bool ReadHeader( InStream& inStream );
    static void WriteDataAccessEntry( DataAccess* dataAccess,
                                      LogWriter* rewriteTo = NULL, bool forceWrite = false );
    static void WriteElementURIEntry( ElementURI* elementURI,
                                      LogWriter* rewriteTo = NULL, bool forceWrite = false );
    static void WriteNameEntry( CodedStr* codeName, LogWriter* rewriteTo = NULL,
                                bool forceWrite = false );
    static bool DirectoryWritesEnabled_;
    static bool DirectoryWritesSimulated_;
    static unsigned short NextDataAccessCode_;
    static unsigned short NextElementURICode_;
    static unsigned short NextNameCode_;
    static bool DirectoryRead_;
    static Logger* Logger_;
    static DataElementMap* DataElementMap_;
    static UniversalMap* UniversalMap_;
    static DataAccessMap* DataAccessMap_;
    static ElementURIMap* ElementURIMap_;
    static NameMap* NameMap_;
    static DataAccessArray* DataAccessArray_;
    static DataAccessArray* DataAccessList_;
    static ElementURIArray* ElementURIArray_;
    static ElementURIList* ElementURIList_;
    static int ElementURICount_;
    static NameArray* NameArray_;
    static NameList* NameList_;
    static Mutex DataAccessMutex_; // Makes DataAccess read/writes calls thread-sage
    static Mutex ElementMutex_; // Makes ElementURI read/writes thread sage
    static Mutex NameMutex_;
    class StaticDestructor
    {
    public:
        virtual ~StaticDestructor();
    };
    static StaticDestructor StaticDestructor_;

    static void ConfigureNewDataElement( Component* owner, const ElementURI& elementURI,
                                         DataElement*& dataElement );

    friend class Supervisor;
    friend class Unserialize;

    static void Uninitialize();

};

#endif /*SLATE_H_*/