DataIOBase.h

/******************************************************************************
* Copyright (c) ATTX LLC 2024. All Rights Reserved.
*
* This software and associated documentation (the "Software") are the 
* proprietary and confidential information of ATTX, LLC. 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, LLC.
******************************************************************************/
/*
Data IO Base File
 
Author: Alex Reynolds
*/
#ifndef DATA_IO_BASE_H
#define DATA_IO_BASE_H
 
#include <vector>
#include <array>
#include <stdint.h>
 
#include "GraphTreeObject.h"
#include "core/clockwerkerrors.h"
#include "core/Matrix.hpp"
 
namespace clockwerk {
 
    /// This enumeration stores information on the data type held within
    /// the DataIO object. The storage defines data types primarily for
    /// logging, which is used in simulation.
    enum dataio_types_e : unsigned char {
        INTEGER,
        FLOATING_POINT,
        VECTOR,
        ARRAY,
        MATRIX,
        GRAPH_TREE,
        POINTER,
        STD_STRING,
        UNDEFINED
    };
 
    /// The Data IO Base class is designed to provide the basic interface
    /// of the Data IO class (see documentation in DataIO.hpp) without 
    /// requiring templating. This implementation is to allow for generic
    /// access to Data IO objects without needing to know or declare the 
    /// template in the resulting class.
    class DataIOBase : public GraphTreeObject {
    public:
        /// Default constructor
        DataIOBase() : data(this), _writeAllowed(true), _root(true) {_graph_tree_type = DATAIO;}
        ~DataIOBase() {};
 
        /// Functions to manipulate write permissions on DataIO object 
        void allowWrite() {_writeAllowed = true;}
        void blockWrite() {_writeAllowed = false;}
        bool writeAllowed() {return _writeAllowed;}
 
        /// @brief   Function to map DataIO object to new upstream data source
        /// @param   data_source     New upstream data source to which object will be mapped
        /// @note    Blocks writing via this DataIO object
        void mapTo(DataIOBase &data_source) {data = &data_source; _root = false;}
 
        /// @param   Function to break data mapping and reset object to its own internal data
        /// @note    Resets write permission to true
        void resetMap() {data = this; _writeAllowed = true;  _root = true;}
 
        /// @brief   Function to write value to mapped location -- root data or map
        /// @return  Void pointer to data held by object
        void* writePtr();
 
        /// @brief   Function to read value from mapped location -- root data or map
        /// @return  Void pointer to data held by object
        void* read();
 
        /// @brief Function to return the type of data held by the DataIO
        /// @return Type of data held by the DataIO according to dataio_types_e
        uint8_t dataType() {return _type_id;}
    protected:
        /// @brief Overloaded functions to identify type held by DataIO
        /// @param var The variable used to identify type
        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);
        template <typename T> void _typeID(std::vector<T> var);
        template <typename T, long unsigned int N> void _typeID(std::array<T, N> var);
        template <typename T, unsigned int R, unsigned int C> void _typeID(Matrix<T, R, C> var);
        void _typeID(std::string &var);
        void _typeID(const GraphTreeObject &var);
        void _typeID(void* var);
        void _typeID(int var);
 
        /// Pointer to data held by the object -- by default, this will point internally
        /// to _default_data, but can be set to point to another object
        DataIOBase* data;
 
        /// Generic pointer to hold any data type -- will be resolved to point to actual
        /// object in inherited class
        void* _data_ptr = nullptr;
 
        /// Variable to indicate whether writing is allowed to this variable
        /// Set to false upon mapping by default
        bool _writeAllowed;
 
        /// Variable to indicate whether variable in question is root data source
        /// or not
        bool _root;
 
        /// Variable to store the type of data that the DataIO object is holding.
        /// Valid types are documented in the enum and determined at runtime.
        /// Runtime determination is necessary because of derived types of GraphTreeObject
        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;}
    template <typename T>
    void DataIOBase::_typeID(std::vector<T> var) {_type_id = VECTOR;}
    template <typename T, long unsigned int N>
    void DataIOBase::_typeID(std::array<T, N> var) {_type_id = ARRAY;}
    template <typename T, unsigned int R, unsigned int C>
    void DataIOBase::_typeID(Matrix<T, R, C> var) {_type_id = MATRIX;}
 
}
 
#endif