BeTimeUtilities.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------+
|
|   Supplied under applicable software license agreement.
|
|   Copyright (c) 2018 Bentley Systems, Incorporated. All rights reserved.
|
+---------------------------------------------------------------------------------------*/
#pragma once


#include "Bentley.h"
#include "WString.h"
#include <time.h>
#include <chrono>

struct _FILETIME;
struct tm;

BEGIN_BENTLEY_NAMESPACE


/*=================================================================================**/
struct BeTimeUtilities
    {

    BENTLEYDLL_EXPORT static UInt64 QueryMillisecondsCounter ();

    BENTLEYDLL_EXPORT static double QuerySecondsCounter () {return QueryMillisecondsCounter() / 1000.0;}

    BENTLEYDLL_EXPORT static UInt32 QueryMillisecondsCounterUInt32 () {return (UInt32)((0xffffffff & QueryMillisecondsCounter()));}



    BENTLEYDLL_EXPORT static UInt64 GetCurrentTimeAsUnixMillis ();

    static double GetCurrentTimeAsUnixMillisDouble () {return (double)(Int64)GetCurrentTimeAsUnixMillis();}

    BENTLEYDLL_EXPORT static double GetCurrentTimeAsUnixMillisDoubleWithDelay ();

    BENTLEYDLL_EXPORT static UInt64 GetCurrentTimeAsUnixMillisWithDelay ();


    BENTLEYDLL_EXPORT static BentleyStatus UnixMillisToString (WStringP timeStrP, WStringP dateStrP, double inputTime);

    BENTLEYDLL_EXPORT static UInt64 ConvertFiletimeToUnixMillis (_FILETIME const& f);

    static double ConvertFiletimeToUnixMillisDouble (_FILETIME const& f) {return (double)(Int64)ConvertFiletimeToUnixMillis(f);}

    BENTLEYDLL_EXPORT static void ConvertUnixMillisToFiletime (_FILETIME& f, UInt64 u);

    BENTLEYDLL_EXPORT static void ConvertUnixTimeToFiletime (_FILETIME& f, time_t t);

    static void ConvertUnixMillisToFiletime (_FILETIME& f, double u) {return ConvertUnixMillisToFiletime(f, (UInt64)u);}

    BENTLEYDLL_EXPORT static UInt64 ConvertTmToUnixMillis (tm const& t);

    BENTLEYDLL_EXPORT static BentleyStatus ConvertUnixMillisToTm (struct tm& t, UInt64 umillis);

    static double ConvertTmToUnixMillisDouble (tm const& t) {return (double)(Int64)ConvertTmToUnixMillis(t);}

    BENTLEYDLL_EXPORT static BentleyStatus AdjustUnixMillisForLocalTime (UInt64& u);

    BENTLEYDLL_EXPORT static BentleyStatus ConvertUnixMillisToLocalTime (struct tm& localTime, UInt64 unixMilliseconds);

    //  Superficial type conversions. These functions do not rebase or convert the time value, they just cast it to an equivalent type.
    BENTLEYDLL_EXPORT static void UInt64AsFileTime (_FILETIME&, UInt64 i);
    BENTLEYDLL_EXPORT static void Int64AsFileTime (_FILETIME&, Int64 i);
    BENTLEYDLL_EXPORT static UInt64 FileTimeAsUInt64 (_FILETIME const& f);
    BENTLEYDLL_EXPORT static Int64 FileTimeAsInt64 (_FILETIME const& f);
    };


/*=================================================================================**/
struct StopWatch : NonCopyableClass
    {
private:
    WString     m_description;
    UInt64      m_start;
    UInt64      m_stop;
    UInt64      m_frequency;

protected:
    BENTLEYDLL_EXPORT void SetFrequency();

public:
    BENTLEYDLL_EXPORT static UInt64 Now();
    void Init(bool start) {m_start=m_stop=0; SetFrequency(); if (start) Start();}
    explicit StopWatch (WCharCP description = L"", bool startImmediately=false) : m_description (description)   {Init(startImmediately);}
    StopWatch (Utf8CP description, bool startImmediately) : m_description (description, true) {Init(startImmediately);}
        StopWatch (bool startImmediately) : m_description (L"") {Init(startImmediately);}
    WString GetDescription() {return m_description;}

    void Start(){m_start = Now();}
    void Stop() {m_stop = Now();}

    double GetCurrentSeconds() {return (Now() - m_start) / (double)m_frequency;}

    double GetElapsedSeconds() {return (m_stop - m_start) / (double)m_frequency;}
    };

//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct BeDuration : std::chrono::steady_clock::duration
{
    DEFINE_T_SUPER(std::chrono::steady_clock::duration)
    typedef std::chrono::nanoseconds Nanoseconds;
    typedef std::chrono::milliseconds Milliseconds;
    typedef std::chrono::seconds Seconds;

    constexpr BeDuration() : T_Super(0) {}    
    constexpr BeDuration(Seconds val) : T_Super(val) {} // allow implicit conversion
    constexpr BeDuration(Milliseconds val) : T_Super(val) {} // allow implicit conversion
    constexpr BeDuration(Nanoseconds val) : T_Super(val) {} // allow implicit conversion
    constexpr BeDuration(std::chrono::duration<double,BeDuration::period> val) : T_Super(std::chrono::duration_cast<T_Super>(val)) {}
    BeDuration(int) = delete; // Note: you must specifiy units!
    BeDuration(double) = delete; // Note: you must specifiy units!

    constexpr static BeDuration FromSeconds(double val) {return BeDuration(std::chrono::duration_cast<T_Super>(std::chrono::duration<double>(val)));}

    constexpr static BeDuration FromMilliseconds(int64_t val) {return BeDuration(Milliseconds(val));}
    
    constexpr operator double() const {return std::chrono::duration_cast<std::chrono::duration<double>>(*this).count();}

    constexpr double ToSeconds() const {return (double) *this;}

    constexpr operator Milliseconds() const {return std::chrono::duration_cast<Milliseconds>(*this);}
    constexpr operator Seconds() const {return std::chrono::duration_cast<Seconds>(*this);}

    bool IsZero() const {return 0 == count();}

    bool IsTowardsFuture() const {return 0 < count();}

    bool IsTowardsPast() const {return 0 > count();}

    BENTLEYDLL_EXPORT void Sleep();
};

//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
struct BeTimePoint : std::chrono::steady_clock::time_point
{
    DEFINE_T_SUPER(std::chrono::steady_clock::time_point)
    using T_Super::time_point;

    static BeTimePoint Now() {return std::chrono::steady_clock::now();}

    static BeTimePoint FromNow(BeDuration val) {return Now()+val;}

    static BeTimePoint BeforeNow(BeDuration val) {return Now()-val;}

    BeTimePoint::rep GetTicks() const {return time_since_epoch().count();}

    bool IsValid() const {return 0 != GetTicks();}
                                              
    bool IsInFuture() const {return IsValid() && (Now() < *this);}

    bool IsInPast() const {return IsValid() && (Now() > *this);}
};





END_BENTLEY_NAMESPACE