DataIO.hpp

Go to the documentation of this file.

/******************************************************************************
* 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 Header File
 
Author: Alex Reynolds
*/
#ifndef DATA_MANAGEMENT_DATA_IO_HPP
#define DATA_MANAGEMENT_DATA_IO_HPP
 
#include <type_traits>
#include <stdio.h>
#if CLOCKWERK_ALLOW_STD_STRING
#include <string>
#endif
#if CLOCKWERK_ALLOW_VECTOR
#include <vector>
#endif
#include <array>
#include <iostream>
 
#include "DataIOBase.h"
#include "core/clockwerkerrors.h"
#include "logging/SimLogger.h"
#include "utils/stringutils.hpp"
 
namespace clockwerk {

    template <typename T> 
    class DataIO : public DataIOBase {
    public:
        DataIO(GraphTreeObject* data_parent, const char* data_name, T initial_value);
        DataIO(GraphTreeObject* data_parent, const char* data_name);
        DataIO(GraphTreeObject* data_parent);
        DataIO();
        ~DataIO() {};

        int dataSize() override {return sizeof(T);}

        void mapToPointer(T* data_source) {_data_ptr = data_source; _data = this; _writeAllowed = true; _root = true;}

        int16 operator()(const T &new_value);

        T* getRootDataPointer();

        void resetMap() {_data_ptr = &_root_data; DataIOBase::resetMap();}

        const T& operator()() const;

#if CLOCKWERK_ALLOW_STD_STRING
#if CLOCKWERK_ALLOW_VECTOR
        int16 log(void* logger);

        int16 header(void* logger);
#endif
#endif
        virtual int16 getValueAsString(char* retval, size_t size) override;

        virtual int16 setValueFromString(const char* value) override;
    protected:
        T _root_data;

        void* tmp_ptr;
 
        // A series of functions to output values as strings
        int16 _asString(double val, char* retval, size_t size) {return numberToString(val, retval, size);}
        int16 _asString(bool val, char* retval, size_t size) {return numberToString((int64)val, retval, size);}
        int16 _asString(int8 val, char* retval, size_t size) {return numberToString((int64)val, retval, size);}
        int16 _asString(int16 val, char* retval, size_t size) {return numberToString((int64)val, retval, size);}
        int16 _asString(int32 val, char* retval, size_t size) {return numberToString((int64)val, retval, size);}
        int16 _asString(int64 val, char* retval, size_t size) {return numberToString((int64)val, retval, size);}
        int16 _asString(uint8 val, char* retval, size_t size) {return numberToString((int64)val, retval, size);}
        int16 _asString(uint16 val, char* retval, size_t size) {return numberToString((int64)val, retval, size);}
        int16 _asString(uint32 val, char* retval, size_t size) {return numberToString((int64)val, retval, size);}
        int16 _asString(uint64 val, char* retval, size_t size) {return numberToString((int64)val, retval, size);}
        int16 _asString(void* val, char* retval, size_t size) {return numberToString((int64)val, retval, size);}
        int16 _asString(char* val, char* retval, size_t size) {
            if(strlen(val) < size) {
                strcpy(retval, val);
                return NO_ERROR;
            } else {
                return ERROR_MAX_MSG_SIZE;
            }
        }
        int16 _asString(const GraphTreeObject &val, char* retval, size_t size) {return val.str(retval, size);}
        template <typename Tn, size_t N>
        int16 _asString(const std::array<Tn, N>& val, char* retval, size_t size) {
            return numberToString(val, retval, size);
        }
#if CLOCKWERK_ALLOW_VECTOR
        template <typename Tn>
        int16 _asString(const std::vector<Tn>& val, char* retval, size_t size) {
            if(retval == nullptr) {return ERROR_NULLPTR;}
 
            bool dimensions_error = false;
            uint32 val_idx = 0;
            int num_chars_filled = 0;
            while (val_idx < val.size() && !dimensions_error) {
                // Call number to string conversion, starting at open space in our buffer
                int16 err = numberToString(val[val_idx], retval + num_chars_filled, size - num_chars_filled);
                if(err) {dimensions_error = true;}
 
                if(!dimensions_error) {
                    // Calculate updated parameters
                    num_chars_filled = strnlen(retval, size);
 
                    // Add in comma to separate values
                    if(size - num_chars_filled > 1) {
                        if(val_idx < val.size() - 1) {
                            strcpy(retval + num_chars_filled, ",");
                            num_chars_filled += 1;
                        }
                    } else {
                        dimensions_error = true;
                    }
                }
 
                val_idx++;
            }
 
            if(dimensions_error) {return ERROR_DIMENSIONS;}
            return NO_ERROR;
        }
#endif
        template <uint32 R, uint32 C> 
        int16 _asString(const Matrix<R, C> &val, char* retval, size_t size) {
            return val.str(retval, size);
        }
#if CLOCKWERK_ALLOW_STD_STRING
        int16 _asString(const std::string val, char* retval, size_t size) {
            if(val.size() < size) {
                strcpy(retval, val.c_str());
                return NO_ERROR;
            } else {
                return ERROR_MAX_MSG_SIZE;
            }
        }
#endif
 
        // A series of functions to set values from strings
        int16 _fromString(const char* setval, bool& retval);
        int16 _fromString(const char* setval, int8& retval);
        int16 _fromString(const char* setval, int16& retval);
        int16 _fromString(const char* setval, int32& retval);
        int16 _fromString(const char* setval, int64& retval);
        int16 _fromString(const char* setval, uint8& retval);
        int16 _fromString(const char* setval, uint16& retval);
        int16 _fromString(const char* setval, uint32& retval);
        int16 _fromString(const char* setval, uint64& retval);
        int16 _fromString(const char* setval, float& retval);
        int16 _fromString(const char* setval, double& retval);
        int16 _fromString(const char* setval, void* retval);
        int16 _fromString(const char* setval, char* retval) {return ERROR_BUFFER_NOT_IMPLEMENTED;}
        int16 _fromString(const char* setval, GraphTreeObject& retval);
        template <uint32 R, uint32 C> 
        int16 _fromString(const char* setval, Matrix<R, C>& retval) {
            return retval.fromStr(setval);
        }
        template <typename Tn, long unsigned int N> 
        int16 _fromString(const char* setval, std::array<Tn, N>& retval) {
            return setArrayFromString(setval, retval.data(), N);
        }
#if CLOCKWERK_ALLOW_VECTOR
        template <typename Tn> 
        int16 _fromString(const char* setval, std::vector<Tn>& retval) {
            return setArrayFromString(setval, retval.data(), retval.size());
        }
#endif
#if CLOCKWERK_ALLOW_STD_STRING
        int16 _fromString(const char* setval, std::string& retval) {retval = std::string(setval); return NO_ERROR;}
#endif
    };
 
    template <typename T>
    int16 DataIO<T>::operator()(const T &new_value) {
        tmp_ptr = writePtr();

        if(tmp_ptr == nullptr) {
            return ERROR_WRITE_PERMISSION;
        }
        *(T*)tmp_ptr = new_value;
 
        return NO_ERROR;
    }
 
    template <typename T>
    const T& DataIO<T>::operator()() const {
        return *(T*)read();
    }
 
    template <typename T>
    DataIO<T>::DataIO(GraphTreeObject* data_parent, const char* data_name, T initial_value)
        : _root_data(initial_value) {
 
        DataIOBase::_data_ptr = &_root_data;

        DataIOBase::parent(data_parent);
        DataIOBase::name(data_name);

        _typeID(_root_data);
 
        _loggable = true;
    }
 
    template <typename T>
    DataIO<T>::DataIO(GraphTreeObject* data_parent, const char* data_name)
        : _root_data() {
 
        DataIOBase::_data_ptr = &_root_data;

        DataIOBase::parent(data_parent);
        DataIOBase::name(data_name);

        _typeID(_root_data);
 
        _loggable = true;
    }
 
    template <typename T>
    DataIO<T>::DataIO(GraphTreeObject* data_parent)
        : _root_data() {
 
        DataIOBase::_data_ptr = &_root_data;

        DataIOBase::parent(data_parent);

        _typeID(_root_data);
 
        if(_type_id == POINTER || _type_id == UNDEFINED) {
            _loggable = true;
        } else {
            _loggable = true;
        }
    }
 
    template <typename T>
    DataIO<T>::DataIO()
        : _root_data() {
            DataIOBase::_data_ptr = &_root_data;

        _typeID(_root_data);
 
        _loggable = true;
    }
 
    template <typename T>
    T* DataIO<T>::getRootDataPointer() {
        return (T*)DataIOBase::read();
    }
 
#if CLOCKWERK_ALLOW_STD_STRING
#if CLOCKWERK_ALLOW_VECTOR
    template <typename T>
    int16 DataIO<T>::log(void* logger) {
        return ((SimLogger*)logger)->writeToBuffer(*getRootDataPointer());
    }
 
    template <typename T>
    int16 DataIO<T>::header(void* logger) {
        return ((SimLogger*)logger)->writeHeaders(*getRootDataPointer());
    }
#endif
#endif
    
    template <typename T>
    int16 DataIO<T>::getValueAsString(char* retval, size_t size) {
        return _asString(operator()(), retval, size);
    }
 
    template <typename T>
    int16 DataIO<T>::setValueFromString(const char* value) {
        int16 err = _fromString(value, _root_data);
 
        if(err) {return err;}
 
        operator()(_root_data);
        return NO_ERROR;
    }
 
    template <typename T>
    int16 DataIO<T>::_fromString(const char* setval, bool& retval) {
        int64 tmp;
        int16 err = numberFromString(setval, tmp);
        if(err) {return err;}
        retval = static_cast<bool>(tmp);
 
        return NO_ERROR;
    }
    template <typename T>
    int16 DataIO<T>::_fromString(const char* setval, int8& retval) {
        int64 tmp;
        int16 err = numberFromString(setval, tmp);
        if(err) {return err;}
        retval = static_cast<int8>(tmp);
 
        return NO_ERROR;
    }
    template <typename T>
    int16 DataIO<T>::_fromString(const char* setval, int16& retval) {
        int64 tmp;
        int16 err = numberFromString(setval, tmp);
        if(err) {return err;}
        retval = static_cast<int16>(tmp);
 
        return NO_ERROR;
    }
    template <typename T>
    int16 DataIO<T>::_fromString(const char* setval, int32& retval) {
        int64 tmp;
        int16 err = numberFromString(setval, tmp);
        if(err) {return err;}
        retval = static_cast<int32>(tmp);
 
        return NO_ERROR;
    }
    template <typename T>
    int16 DataIO<T>::_fromString(const char* setval, int64& retval) {
        return numberFromString(setval, retval);
    }
    template <typename T>
    int16 DataIO<T>::_fromString(const char* setval, uint8& retval) {
        int64 tmp;
        int16 err = numberFromString(setval, tmp);
        if(err) {return err;}
        retval = static_cast<uint8>(tmp);
 
        return NO_ERROR;
    }
    template <typename T>
    int16 DataIO<T>::_fromString(const char* setval, uint16& retval) {
        int64 tmp;
        int16 err = numberFromString(setval, tmp);
        if(err) {return err;}
        retval = static_cast<uint16>(tmp);
 
        return NO_ERROR;
    }
    template <typename T>
    int16 DataIO<T>::_fromString(const char* setval, uint32& retval) {
        int64 tmp;
        int16 err = numberFromString(setval, tmp);
        if(err) {return err;}
        retval = static_cast<uint32>(tmp);
 
        return NO_ERROR;
    }
    template <typename T>
    int16 DataIO<T>::_fromString(const char* setval, uint64& retval) {
        uint64 tmp = atoi(setval);
        retval = (T)tmp;
 
        return NO_ERROR;
    }
 
    template <typename T>
    int16 DataIO<T>::_fromString(const char* setval, float& retval) {
        return numberFromString(setval, retval);
    }
 
    template <typename T>
    int16 DataIO<T>::_fromString(const char* setval, double& retval) {
        return numberFromString(setval, retval);
    }
 
    template <typename T>
    int16 DataIO<T>::_fromString(const char* setval, void* retval) {
        int64 tmp = atoi(setval);
        retval = (void*)tmp;
 
        return NO_ERROR;
    }
 
    template <typename T>
    int16 DataIO<T>::_fromString(const char* setval, GraphTreeObject& retval) {
        return retval.fromStr(setval);
    }
 
}
 
#endif