NET_Time.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        NET_Time.h
 *
 * COMMENTS:
 *  This file has helpers to convert chromiums use of time to other units of
 *  time. Chromium stores their time as microseconds since windows epoc and
 *  most other code stores time as seconds since epoch time so we need helpers
 *  to convert between the two.
 */

#ifndef __NET_TIME_H__
#define __NET_TIME_H__

#include "NET_API.h"

#include <UT/UT_StringHolder.h>

#include <limits>
#include <time.h>

#include <chrono>

template <typename Duration>
using NET_TimePoint =
    std::chrono::time_point<std::chrono::system_clock, Duration>;

// We store the time as micro seconds since unix epoch time. We store it as
// micro seconds as the creation date for cookies are stored as the primary
// key. If two cookies are created within the same second (which is likely)
// then when we save the cookies to storage its likely we will get a
// constraint failure as they will both have the same creation time.
class NET_API NET_Time
{
public:
    using Timestamp = NET_TimePoint<std::chrono::microseconds>;
    constexpr NET_Time() : myUS(std::chrono::microseconds(0)) {}

    constexpr bool isNull() const
    {
        return myUS == Timestamp(std::chrono::microseconds(0));
    }

    constexpr bool isMax() const { return myUS == Timestamp::max(); }
    constexpr bool isMin() const { return myUS == Timestamp::min(); }
    static constexpr Timestamp minT()
    {
        return Timestamp(std::chrono::microseconds(0));
    }
    static constexpr Timestamp maxT() { return Timestamp::max(); }
    static NET_Time max() { return NET_Time(maxT()); }
    static NET_Time min() { return NET_Time(minT()); }
    constexpr bool operator==(const NET_Time &time) const
    {
        return myUS == time.myUS;
    }
    constexpr bool operator!=(const NET_Time &time) const
    {
        return myUS != time.myUS;
    }
    constexpr bool operator<(const NET_Time &time) const
    {
        return myUS < time.myUS;
    }
    constexpr bool operator>(const NET_Time &time) const
    {
        return myUS > time.myUS;
    }
    constexpr bool operator<=(const NET_Time &time) const
    {
        return myUS <= time.myUS;
    }
    constexpr bool operator>=(const NET_Time &time) const
    {
        return myUS >= time.myUS;
    }

    template <class T>
    bool hasElapsed(const NET_Time &t, const T &elapse)
    {
        std::chrono::microseconds us = t.timestamp() - myUS;
        T dur = std::chrono::duration_cast<T>(us);
        return dur >= elapse;
    }

    // Convert microseconds since windows epoch time to unix time_t
    static NET_Time fromDeltaSinceWindowsEpoch(std::chrono::microseconds t);
    // Convert unix time_t to microseconds since windows epoch time
    std::chrono::microseconds toDeltaSinceWindowsEpoch() const;
    static NET_Time fromTimeT(time_t t);
    time_t toTimeT() const;

    template <typename Duration>
    static NET_Time fromTimestamp(const NET_TimePoint<Duration>& tp)
    {
        return NET_Time(tp);
    }

    // Get current time
    static NET_Time now();

    static bool fromUTCString(const UT_StringRef &time_string, NET_Time &time);
    static bool fromUTCStringToLocal(const UT_StringRef &time_string,
                                     NET_Time &time);

    UT_StringHolder toUTCString() const;

    const Timestamp &timestamp() const { return myUS; }

private:
    constexpr NET_Time(Timestamp us) : myUS(us) {}
    Timestamp myUS;
};

template <>
inline bool
NET_Time::hasElapsed(
    const NET_Time &t, const std::chrono::microseconds &us)
{
    std::chrono::microseconds diff = t.timestamp() - myUS;
    return diff >= us;
}

#endif // __NET_TIME_H__