reading.h

#ifndef _READING_H
#define _READING_H
/*
 * Fledge storage client.
 *
 * Copyright (c) 2018 OSisoft, LLC
 *
 * Released under the Apache 2.0 Licence
 *
 * Author: Mark Riddoch, Massimiliano Pinto
 */
#include <datapoint.h>
#include <string>
#include <ctime>
#include <vector>
#include <sys/time.h>
#include <rapidjson/document.h>

#define DEFAULT_DATE_TIME_FORMAT      "%Y-%m-%d %H:%M:%S"
#define COMBINED_DATE_STANDARD_FORMAT "%Y-%m-%dT%H:%M:%S"
#define ISO8601_DATE_TIME_FORMAT      "%Y-%m-%d %H:%M:%S +0000"
#define DATE_TIME_BUFFER_LEN          52

class Reading {
    public:
        Reading(const std::string& asset, Datapoint *value);
        Reading(const std::string& asset, std::vector<Datapoint *> values);
        Reading(const std::string& asset, std::vector<Datapoint *> values, const std::string& ts);
        Reading(const std::string& asset, const std::string& datapoints);
        Reading(const Reading& orig);

        ~Reading(); // This should bbe virtual
        void                addDatapoint(Datapoint *value);
        Datapoint           *removeDatapoint(const std::string& name);
        Datapoint           *getDatapoint(const std::string& name) const;
        std::string         toJSON(bool minimal = false) const;
        std::string         getDatapointsJSON() const;
        // Return AssetName
        const std::string&              getAssetName() const { return m_asset; };
        // Set AssetName
        void                setAssetName(std::string assetName) { m_asset = assetName; };
        unsigned int            getDatapointCount() { return m_values.size(); };
        void                removeAllDatapoints();
        // Return Reading datapoints
        const std::vector<Datapoint *>  getReadingData() const { return m_values; };
        // Return refrerence to Reading datapoints
        std::vector<Datapoint *>&   getReadingData() { return m_values; };
        bool                hasId() const { return m_has_id; };
        unsigned long           getId() const { return m_id; };
        unsigned long           getTimestamp() const { return (unsigned long)m_timestamp.tv_sec; };
        unsigned long           getUserTimestamp() const { return (unsigned long)m_userTimestamp.tv_sec; };
        void                setId(unsigned long id) { m_id = id; };
        void                setTimestamp(unsigned long ts) { m_timestamp.tv_sec = (time_t)ts; };
        void                setTimestamp(struct timeval tm) { m_timestamp = tm; };
        void                setTimestamp(const std::string& timestamp);
        void                getTimestamp(struct timeval *tm) { *tm = m_timestamp; };
        void                setUserTimestamp(unsigned long uTs) { m_userTimestamp.tv_sec = (time_t)uTs; };
        void                setUserTimestamp(struct timeval tm) { m_userTimestamp = tm; };
        void                setUserTimestamp(const std::string& timestamp);
        void                getUserTimestamp(struct timeval *tm) { *tm = m_userTimestamp; };

        typedef enum dateTimeFormat { FMT_DEFAULT, FMT_STANDARD, FMT_ISO8601, FMT_ISO8601MS } readingTimeFormat;

        void    getFormattedDateTimeStr(const time_t *tv_sec, char *date_time, readingTimeFormat dateFormat) const;
        // Return Reading asset time - ts time
        const std::string getAssetDateTime(readingTimeFormat datetimeFmt = FMT_DEFAULT, bool addMs = true) const;
        // Return Reading asset time - user_ts time
        const std::string getAssetDateUserTime(readingTimeFormat datetimeFmt = FMT_DEFAULT, bool addMs = true) const;
        std::string         substitute(const std::string& str);

    protected:
        Reading() {};
        Reading&            operator=(Reading const&);
        void                stringToTimestamp(const std::string& timestamp, struct timeval *ts);
        const std::string       escape(const std::string& str) const;
        std::vector<Datapoint *>    *JSONtoDatapoints(const rapidjson::Value& json);
        unsigned long           m_id;
        bool                m_has_id;
        std::string         m_asset;
        struct timeval          m_timestamp;
        struct timeval          m_userTimestamp;
        std::vector<Datapoint *>    m_values;
        // Supported date time formats for 'm_timestamp'
        static std::vector<std::string> m_dateTypes;
    private:
        // Internal class used for macro substitution
        class Macro {
            public:
                Macro(const std::string& dpname, std::string::size_type s,
                        const std::string& defValue) :
                    start(s), name(dpname), def(defValue)

                {
                };
                Macro(const std::string& dpname, std::string::size_type s) :
                    start(s), name(dpname)

                {
                };
                // Start of variable to substitute
                std::string::size_type      start;
                // Name of variable to substitute
                std::string         name;
                // Default value to substitute
                std::string         def;
        };
        void        collectMacroInfo(const std::string& str, std::vector<Macro>& macros);
};
#endif