datapoint.h

#ifndef _DATAPOINT_H
#define _DATAPOINT_H
/*
 * Fledge
 *
 * Copyright (c) 2018 OSisoft, LLC
 *
 * Released under the Apache 2.0 Licence
 *
 * Author: Mark Riddoch, Massimiliano Pinto
 */
#include <string>
#include <sstream>
#include <iomanip>
#include <cfloat>
#include <vector>
#include <logger.h>
#include <dpimage.h>
#include <databuffer.h>
#include <rapidjson/document.h>
#include "string_utils.h"
 
class Datapoint;
class DatapointValue {
    public:
        DatapointValue(const std::string& value)
        {
            m_value.str = new std::string(value);
            m_type = T_STRING;
        };
        DatapointValue(const long value)
        {
            m_value.i = value;
            m_type = T_INTEGER;
        };
        DatapointValue(const double value)
        {
            m_value.f = value;
            m_type = T_FLOAT;
        };
        DatapointValue(const std::vector<double>& values)
        {
            m_value.a = new std::vector<double>(values);
            m_type = T_FLOAT_ARRAY;
        };
 
        DatapointValue(std::vector<Datapoint*>*& values, bool isDict)
        {
            m_value.dpa = values;
            m_type = isDict? T_DP_DICT : T_DP_LIST;
        }
 
        DatapointValue(const DPImage& value)
        {
            m_value.image = new DPImage(value);
            m_type = T_IMAGE;
        }
 
        DatapointValue(const DataBuffer& value)
        {
            m_value.dataBuffer = new DataBuffer(value);
            m_type = T_DATABUFFER;
        }
 
        DatapointValue(DPImage *value)
        {
            m_value.image = value;
            m_type = T_IMAGE;
        }
 
        DatapointValue(DataBuffer *value)
        {
            m_value.dataBuffer = value;
            m_type = T_DATABUFFER;
        }
 
        DatapointValue(const std::vector< std::vector<double> *>& values)
        {
            m_value.a2d = new std::vector< std::vector<double>* >;
            for (auto row : values)
            {
                std::vector<double> *nrow = new std::vector<double>;
                for (auto& d : *row)
                {
                    nrow->push_back(d);
                }
                m_value.a2d->push_back(nrow);
            }
            m_type = T_2D_FLOAT_ARRAY;
        };
 
        DatapointValue(const DatapointValue& obj);
 
        DatapointValue& operator=(const DatapointValue& rhs);
 
        ~DatapointValue();
 
                void setValue(std::string value)
                {
                        if(m_value.str)
                        {
                                delete m_value.str;
                        }
                        m_value.str = new std::string(value);
                        m_type = T_STRING;
                }
    
        void setValue(long value)
        {
            m_value.i = value;
            m_type = T_INTEGER;
        }
 
        void setValue(double value)
        {
            m_value.f = value;
            m_type = T_FLOAT;
        }
 
        void setValue(const DPImage& value)
        {
            m_value.image = new DPImage(value);
            m_type = T_IMAGE;
        }
 
        std::string toString() const;
 
        std::string toStringValue() const { return *m_value.str; };
 
        long toInt() const { return m_value.i; };
        double toDouble() const { return m_value.f; };
 
        // Supported Data Tag Types
        typedef enum DatapointTag
        {
            T_STRING,
            T_INTEGER,
            T_FLOAT,
            T_FLOAT_ARRAY,
            T_DP_DICT,
            T_DP_LIST,
            T_IMAGE,
            T_DATABUFFER,
            T_2D_FLOAT_ARRAY
        } dataTagType;
 
        dataTagType getType() const
        {
            return m_type;
        }
 
        std::string getTypeStr() const
        {
            switch(m_type)
            {
                case T_STRING: return std::string("STRING");
                case T_INTEGER: return std::string("INTEGER");
                case T_FLOAT: return std::string("FLOAT");
                case T_FLOAT_ARRAY: return std::string("FLOAT_ARRAY");
                case T_DP_DICT: return std::string("DP_DICT");
                case T_DP_LIST: return std::string("DP_LIST");
                case T_IMAGE: return std::string("IMAGE");
                case T_DATABUFFER: return std::string("DATABUFFER");
                case T_2D_FLOAT_ARRAY: return std::string("2D_FLOAT_ARRAY");
                default: return std::string("INVALID");
            }
        }
 
        std::vector<Datapoint*>*& getDpVec()
        {
            return m_value.dpa;
        }
 
        std::vector<double>*& getDpArr()
        {
            return m_value.a;
        }
 
        std::vector<std::vector<double>* >*& getDp2DArr()
        {
            return m_value.a2d;
        }
 
        DPImage *getImage()
        {
            return m_value.image;
        }
 
        DataBuffer *getDataBuffer()
        {
            return m_value.dataBuffer;
        }
 
    private:
        void deleteNestedDPV();
        const std::string   escape(const std::string& str) const;
        union data_t {
            std::string*        str;
            long            i;
            double          f;
            std::vector<double>*    a;
            std::vector<Datapoint*>
                        *dpa;
            DPImage         *image;
            DataBuffer      *dataBuffer;
            std::vector< std::vector<double>* >
                        *a2d;
            } m_value;
        DatapointTag    m_type;
};
 
class Datapoint {
    public:
        Datapoint(const std::string& name, DatapointValue& value) : m_name(name), m_value(value)
        {
        }
 
        ~Datapoint()
        {
        }
        std::string toJSONProperty()
        {
            std::string rval = "\"" + escape(m_name) + "\":";
            rval += m_value.toString();
 
            return rval;
        }
 
        const std::string getName() const
        {
            return m_name;
        }
 
        void setName(std::string name)
        {
            m_name = name;
        }
 
        const DatapointValue getData() const
        {
            return m_value;
        }
 
        DatapointValue& getData()
        {
            return m_value;
        }
 
        std::vector<Datapoint*>* parseJson(const std::string& json);
        std::vector<Datapoint*>* recursiveJson(const rapidjson::Value& document);
 
    private:
        std::string     m_name;
        DatapointValue      m_value;
};
#endif