SimLogger.h

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.
******************************************************************************/
/*
Logger header file
 
Author: Alex Reynolds
*/
#include "configuration.h"
 
#if CLOCKWERK_ALLOW_VECTOR
#if CLOCKWERK_ALLOW_STD_STRING
 
#ifndef LOGGING_SIM_LOGGER_H
#define LOGGING_SIM_LOGGER_H
 
#include <vector>
#include <array>
#include <string>
 
#include "architecture/GraphTreeObject.h"
#include "core/clockwerkerrors.h"
#include "core/Matrix.hpp"
 
namespace clockwerk {
 
    enum vector_select_e {
        BOOL,
        INT,
        UINT,
        FLOAT,
        DOUBLE,
        STRING
    };
 
    class Executive;




    class SimLogger : public GraphTreeObject {
    public:
        SimLogger(GraphTreeObject &parent, const std::string &filename="output.csv", unsigned int buffer_size=1);
        virtual ~SimLogger() {close();}

        unsigned int bufferSize() {return _buffer_size;}
        int bufferSize(unsigned int buffer_size);

        std::string filename() {return _filename;}
        int filename(const std::string &name);

        std::string outDir() {return _output_directory;}
        int outDir(const std::string &directory);

        virtual int setup(const std::string &file_name) {return NO_ERROR;}

        int addParameter(GraphTreeObject &parameter, const std::string &param_name,
                        bool recursive = false);

        int addParameter(const std::string &parameter, const std::string &param_name,
                        bool recursive = false);

        virtual int lockForLogging();

        virtual int log();

        virtual int close();
 
        int writeHeaders(const bool &val) {return writeHeaders((uint64)val);}
        int writeHeaders(const int8 &val) {return writeHeaders((int64)val);}
        int writeHeaders(const int16 &val) {return writeHeaders((int64)val);}
        int writeHeaders(const int32 &val) {return writeHeaders((int64)val);}
        int writeHeaders(const int64 &val) {_group_idx.push_back(-1); _headers.push_back(_current_name); return NO_ERROR;}
        int writeHeaders(const uint8 &val) {return writeHeaders((uint64)val);}
        int writeHeaders(const uint16 &val) {return writeHeaders((uint64)val);}
        int writeHeaders(const uint32 &val) {return writeHeaders((uint64)val);}
        int writeHeaders(const uint64 &val) {_group_idx.push_back(-1); _headers.push_back(_current_name); return NO_ERROR;}
        int writeHeaders(const double &val) {_group_idx.push_back(-1); _headers.push_back(_current_name); return NO_ERROR;}
        int writeHeaders(const GraphTreeObject &val);
        int writeHeaders(void* val) {_group_idx.push_back(-1); _headers.push_back(_current_name); return NO_ERROR;}
        int writeHeaders(const std::string &val) {_group_idx.push_back(-1); _headers.push_back(_current_name); return NO_ERROR;}
 
        template <typename T> int writeHeaders(const std::vector<T> &val);
        template <typename T, long unsigned int N> int writeHeaders(const std::array<T, N> &val);
 
        template <unsigned int R, unsigned int C> int writeHeaders(const Matrix<R, C> &val);

        int writeToBuffer(const bool &val);
        int writeToBuffer(const int8 &val) {return writeToBuffer((int64)val);}
        int writeToBuffer(const int16 &val) {return writeToBuffer((int64)val);}
        int writeToBuffer(const int32 &val) {return writeToBuffer((int64)val);}
        int writeToBuffer(const int64 &val);
        int writeToBuffer(const uint8 &val) {return writeToBuffer((uint64)val);}
        int writeToBuffer(const uint16 &val) {return writeToBuffer((uint64)val);}
        int writeToBuffer(const uint32 &val) {return writeToBuffer((uint64)val);}
        int writeToBuffer(const uint64 &val);
        int writeToBuffer(const float &val);
        int writeToBuffer(const double &val);
        int writeToBuffer(const std::string &val); 
        int writeToBuffer(void* val);
        int writeToBuffer(GraphTreeObject &val);

        template <typename T> int writeToBuffer(const std::vector<T> &val);
        template <typename T, long unsigned int N> int writeToBuffer(const std::array<T, N> &val);
 
        template <unsigned int R, unsigned int C> int writeToBuffer(const Matrix<R, C> &val);
 
    protected:
        void _fillBuffers();

        virtual int _createSetupFile() {return NO_ERROR;}

        virtual int _writeToFile() {return NO_ERROR;}

        std::vector<GraphTreeObject*> _logged_nodes;
        std::vector<std::string> _log_names;
        std::string _current_name;

        std::string _filename;
        std::string _output_directory;

        unsigned int _buffer_size = 10;
        unsigned int _buffer_write_idx = 0;
        unsigned int _buffer_read_idx = 0;
        std::vector<std::vector<bool>> _bool_vector;            
        std::vector<std::vector<int64>> _int_vector;              
        std::vector<std::vector<uint64>> _uint_vector;    
        std::vector<std::vector<float>> _float_vector;          
        std::vector<std::vector<double>> _double_vector;        
        std::vector<std::vector<std::string>> _string_vector;   

        bool _locked;
        unsigned int _seq_idx = 0;
        std::vector<std::string> _headers;
        std::vector<unsigned int> _sequence;
        std::vector<vector_select_e> _type;

        struct Group {
            long unsigned int size;     
            std::string group_name;     
        };
        std::vector<int> _group_idx;    
        std::vector<Group> _groups;
    };
 
 
    template <typename T>
    int SimLogger::writeToBuffer(const std::vector<T> &val) {
        int err;
        for(unsigned int i = 0; i < val.size(); i++) {
            err = writeToBuffer(val[i]);
            if(err) {
                return err;
            }
        }
        return NO_ERROR;
    }
 
    template <typename T, long unsigned int N>
    int SimLogger::writeToBuffer(const std::array<T, N> &val) {
        int err;
        for(unsigned int i = 0; i < N; i++) {
            err = writeToBuffer(val[i]);
            if(err) {
                return err;
            }
        }
        return NO_ERROR;
    }
 
    template <unsigned int R, unsigned int C> 
    int SimLogger::writeToBuffer(const Matrix<R, C> &val) {
        int err;
        unsigned int i, j;
        for(i = 0; i < R; i++) {
            for(j = 0; j < C; j++) {
                err = writeToBuffer(val.values[i][j]);
                if(err) {
                    return err;
                }
            }
        } 
        return NO_ERROR;
    }
 
    template <typename T>
    int SimLogger::writeHeaders(const std::vector<T> &val) {
        _groups.push_back({val.size(), _current_name});
 
        for(unsigned int i = 0; i < val.size(); i++) {
            _headers.push_back(_current_name + "_" + std::to_string(i));
            _group_idx.push_back(_groups.size() - 1);
        }
        return NO_ERROR;
    }
 
    template <typename T, long unsigned int N>
    int SimLogger::writeHeaders(const std::array<T, N> &val) {
        _groups.push_back({val.size(), _current_name});
 
        for(unsigned int i = 0; i < N; i++) {
            _headers.push_back(_current_name + "_" + std::to_string(i));
            _group_idx.push_back(_groups.size() - 1);
        }
        return NO_ERROR;
    }
 
    template <unsigned int R, unsigned int C> 
    int SimLogger::writeHeaders(const Matrix<R, C> &val) { 
        _groups.push_back({R*C, _current_name});
 
        unsigned int i, j;
        for(i = 0; i < R; i++) {
            for(j = 0; j < C; j++) {
                if(C == 1) {
                    _headers.push_back(_current_name + "_" + std::to_string(i));
                    _group_idx.push_back(_groups.size() - 1);
                } else {
                    _headers.push_back(_current_name + "_" + std::to_string(i) + "_" + std::to_string(j));
                    _group_idx.push_back(_groups.size() - 1);
                }
            }
        } 
        return NO_ERROR;
    }
 
}
 
#endif
#endif
#endif