ddcTime.h

Go to the documentation of this file.

//-*- Mode: C++ -*-
//
//  DDC originally by Alexey Sokirko
//  Changes and modifications 2011-2018 by Bryan Jurish
//
//  This file is part of DDC
// 
//  DDC is free software: you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
// 
//  DDC is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Lesser General Public License for more details.
// 
//  You should have received a copy of the GNU Lesser General Public License
//  along with DDC.  If not, see <http://www.gnu.org/licenses/>.
//
#ifndef DDC_TIME_H
#define DDC_TIME_H

#include "../CommonLib/ddcConfig.h"
#include <time.h>
#include <string>
#include <map>
#include <vector>

//======================================================================
// constants

extern const size_t DDCDateBufferSize;

extern const size_t DDCTimeBufferSize;

//======================================================================
// DDCTime : 1-second resolution clock
struct DDCTimeUnix
{
    //----------------------------------------------------------------------
    // Data
    time_t m_t;

    //----------------------------------------------------------------------
    // constructors etc

    DDCTimeUnix()
    {};

    DDCTimeUnix(const time_t time_)
    { Set(time_); };

    DDCTimeUnix(const DDCTimeUnix& X)
        : m_t(X.m_t)
    {};

    virtual ~DDCTimeUnix()
    {};

    inline static DDCTimeUnix Now()
    {
        DDCTimeUnix t;
        t.Set();
        return t;
    };

    inline void Set()
    { time(&m_t); };

    inline void Set(const time_t time_)
    { m_t = time_; };

    inline void Set(const DDCTimeUnix& t)
    { Set(t.m_t); };

    //----------------------------------------------------------------------
    // API

    inline time_t Time() const
    { return m_t; };

    struct tm CalendarTime() const;

    virtual void DateTime(char* DateBuf, char* TimeBuf) const;

    inline std::string DateStr() const
    {
        char DateBuf[DDCDateBufferSize];
        this->DateTime(DateBuf, NULL);
        return std::string(DateBuf);
    };

    inline std::string TimeStr() const
    {
        char TimeBuf[DDCTimeBufferSize];
        this->DateTime(NULL,TimeBuf);
        return std::string(TimeBuf);
    };

    double Elapsed(const DDCTimeUnix& t0) const;
};

//======================================================================
// DDCTimeHiRes : nanosecond-resolution clock
#ifdef HAVE_CLOCK_GETTIME
struct DDCTimeHiRes : public DDCTimeUnix
{
    //----------------------------------------------------------------------
    // Data
    struct timespec m_ts;

    //----------------------------------------------------------------------
    // constructors etc

    DDCTimeHiRes()
    {};

    DDCTimeHiRes(const struct timespec &ts_)
    { Set(ts_); };

    DDCTimeHiRes(const DDCTimeHiRes& t)
    { Set(t.m_ts); };

    DDCTimeHiRes(const DDCTimeUnix& t)
    { Set(t.m_t); };

    virtual ~DDCTimeHiRes()
    {};

    inline static DDCTimeHiRes Now()
    {
        DDCTimeHiRes t;
        t.Set();
        return t;
    };
    
    inline void Set()
    {
        clock_gettime(CLOCK_REALTIME, &m_ts);
        DDCTimeUnix::Set(m_ts.tv_sec);
    };

    inline void Set(const time_t time_)
    {
        DDCTimeUnix::Set(time_);
        m_ts.tv_sec  = time_;
        m_ts.tv_nsec = 0;
    };

    inline void Set(const struct timespec &ts_)
    {
        m_t  = ts_.tv_sec;
        m_ts = ts_;
    };

    inline void Set(const DDCTimeUnix& t)
    { Set(t.m_t); };

    inline void Set(const DDCTimeHiRes& t)
    { *this = t; };

    //----------------------------------------------------------------------
    // API

    /* inherited: get low-resultion time_t time */
    //time_t Time() const;

    /* inherited: get (low-resolution) calendar time; adapted from old RmlGetCurrentTime() */
    //struct tm CalendarTime() const;

    virtual void DateTime(char* DateBuf, char* TimeBuf) const;

    /* inherited: get date string in ISO-8601 format (YYYY-MM-DD) */
    //inline std::string DateStr() const

    // inline std::string TimeStr() const

    double Elapsed(const DDCTimeHiRes& t0) const;
};

#else /* !defined(HAVE_CLOCK_GETTIME) */

typedef struct DDCTimeUnix DDCTimeHiRes;

#endif /* defined(HAVE_CLOCK_GETTIME) */

#ifdef DDC_USE_HIRES_CLOCK

typedef struct DDCTimeHiRes DDCTime;
#else

typedef struct DDCTimeUnix DDCTime;
#endif

//======================================================================
// DDCTimeAvg : exponential moving average
struct DDCTimeAvg
{
    //----------------------------------------------------------------------
    // typedefs

    typedef size_t DelayT;

    typedef double ValueT;

    typedef DDCTimeHiRes TimeT;

    typedef std::map<DelayT,ValueT> MapT;

    //----------------------------------------------------------------------
    // data
    
    MapT  m_map;

    TimeT m_t;

    ValueT m_total;

    size_t m_n;
    
    //----------------------------------------------------------------------
    // constructors etc.

    DDCTimeAvg(DelayT delay1=60, DelayT delay2=300, DelayT delay3=900, ValueT val=0)
        : m_total(0), m_n(0)
    {
        SetDelays(delay1,delay2,delay3,val);
        m_t.Set();
    };

    DDCTimeAvg(const std::vector<DelayT>& delays, ValueT val=0)
        : m_total(0), m_n(0)
    {
        SetDelays(delays,val);
        m_t.Set();
    };

    DDCTimeAvg(const DDCTimeAvg& X)
        : m_map(X.m_map), m_t(X.m_t), m_total(X.m_total), m_n(X.m_n)
    {};

    void reset(ValueT val=0);

    inline void clear()
    {
        m_map.clear();
        reset();
    };

    //----------------------------------------------------------------------
    // manipulation

    void SetDelays(const std::vector<DelayT>& delays, ValueT val=0);

    void SetDelays(DelayT delay1=60, DelayT delay2=300, DelayT delay3=900, ValueT val=0);

    inline void SetDelays(const MapT& delayMap)
    { m_map = delayMap; };

    MapT& Append(ValueT sample, const TimeT& when, size_t n=1);

    inline MapT& Append(ValueT sample=0)
    { return Append(sample, TimeT::Now()); };

    inline void AppendTotal(ValueT sample)
    { m_total += sample; };

    inline DDCTimeAvg& operator+=(const DDCTimeAvg& x)
    { if (x.m_n > 0) Append(x.Total()); return *this;};

    inline void Scrub()
    { Append(0,TimeT::Now(),0); };

    //----------------------------------------------------------------------
    // access
    
    inline const MapT& Values() const
    { return m_map; };

    inline const TimeT& Time() const
    { return m_t; };

    inline ValueT Total() const
    { return m_total; };

    inline ValueT Average() const
    { return m_n==0 ? m_total : (m_total / (ValueT)m_n); };

    inline ValueT tAverage() const
    { return m_map.begin()->second; };

    std::string toJsonArray() const;

    std::string toJsonMap() const;
};




//======================================================================
// Functions

        
#endif /* DDC_TIME_H */

/*--- emacs style variables ---
 * Local Variables:
 *  mode: C++
 *  c-file-style: "ellemtel"
 *  c-basic-offset: 4
 *  tab-width: 8
 *  indent-tabs-mode: nil
 * End:
 */