DataIOBase.h

Go to the documentation of this file.

/******************************************************************************
* Copyright (c) ATTX INC 2025. All Rights Reserved.
*
* This software and associated documentation (the "Software") are the  
* proprietary and confidential information of ATTX, INC. The Software is 
* furnished under a license agreement between ATTX and the user organization 
* and may be used or copied only in accordance with the terms of the agreement.
* Refer to 'license/attx_license.adoc' for standard license terms.
*
* EXPORT CONTROL NOTICE: THIS SOFTWARE MAY INCLUDE CONTENT CONTROLLED UNDER THE
* INTERNATIONAL TRAFFIC IN ARMS REGULATIONS (ITAR) OR THE EXPORT ADMINISTRATION 
* REGULATIONS (EAR99). No part of the Software may be used, reproduced, or 
* transmitted in any form or by any means, for any purpose, without the express 
* written permission of ATTX, INC.
******************************************************************************/
/* 
Data IO Base File
 
Author: Alex Reynolds
*/
#ifndef DATA_MANAGEMENT_DATA_IO_BASE_H
#define DATA_MANAGEMENT_DATA_IO_BASE_H
 
#include <array>
#if CLOCKWERK_ALLOW_VECTOR
#include <vector>
#endif
 
#include "types.h"
#include "GraphTreeObject.h"
#include "core/clockwerkerrors.h"
#include "core/Matrix.hpp"
#include "architecture/Time.h"
 
namespace clockwerk {

    enum dataio_types_e : uint8 {
        INTEGER,
        FLOATING_POINT,
        VECTOR,
        ARRAY,
        MATRIX,
        GRAPH_TREE,
        POINTER,
        STD_STRING,
        UNDEFINED,
        C_STRING,
        TIME
    };

    class DataIOBase : public GraphTreeObject {
    public:
        DataIOBase() : _data(this), _writeAllowed(true), _root(true) {_graph_tree_type = DATAIO;}
        ~DataIOBase() {};

        virtual int16 syncExternal() {return ERROR_BUFFER_NOT_IMPLEMENTED;}

        virtual int dataSize() {return -1;}

        void allowWrite() {_writeAllowed = true;}
        void blockWrite() {_writeAllowed = false;}
        bool writeAllowed() {return _writeAllowed;}

        void mapTo(DataIOBase &data_source) {_data = &data_source; _root = false;}

        void resetMap() {_data = this; _writeAllowed = true;  _root = true;}

        DataIOBase* dataSource() {return _data;}

        void* writePtr();

        void* read() const;

        uint8 dataType() {return _type_id;}


        virtual int16 getValueAsString(char* retval, size_t size) {return ERROR_BUFFER_NOT_IMPLEMENTED;}

        virtual int16 setValueFromString(const char* value) {return ERROR_BUFFER_NOT_IMPLEMENTED;}
 
    protected:
        template <typename T> typename std::enable_if<std::is_integral<T>::value>::type _typeID(T var);
        template <typename T> typename std::enable_if<std::is_floating_point<T>::value>::type _typeID(T var);
#if CLOCKWERK_ALLOW_VECTOR
        template <typename T> void _typeID(std::vector<T> var);
#endif
        template <typename T, long unsigned int N> void _typeID(std::array<T, N> var);
        template <uint32 R, uint32 C> void _typeID(Matrix<R, C> var);
#if CLOCKWERK_ALLOW_STD_STRING
        void _typeID(std::string &var);
#endif
        void _typeID(const GraphTreeObject &var);
        void _typeID(const Time &var);
        void _typeID(void* var);
        void _typeID(int8 var);
        void _typeID(int16 var);
        void _typeID(int32 var);
        void _typeID(int64 var);
        void _typeID(uint8 var);
        void _typeID(uint16 var);
        void _typeID(uint32 var);
        void _typeID(uint64 var);
        void _typeID(char* var);

        DataIOBase* _data;

        void* _data_ptr = nullptr;

        bool _writeAllowed;

        bool _root;

        dataio_types_e _type_id = UNDEFINED;
    };
 
    template <typename T>
    typename std::enable_if<std::is_integral<T>::value>::type DataIOBase::_typeID(T var) {_type_id = INTEGER;}
    template <typename T>
    typename std::enable_if<std::is_floating_point<T>::value>::type DataIOBase::_typeID(T var) {_type_id = FLOATING_POINT;}
#if CLOCKWERK_ALLOW_VECTOR
    template <typename T> 
    void DataIOBase::_typeID(std::vector<T> var) {_type_id = VECTOR;}
#endif
    template <typename T, long unsigned int N> 
    void DataIOBase::_typeID(std::array<T, N> var) {_type_id = ARRAY;}
    template <uint32 R, uint32 C> 
    void DataIOBase::_typeID(Matrix<R, C> var) {_type_id = MATRIX;}
 
}
 
#endif