datetime.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <chrono>
#include <ctime>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/error.h>
#include <promeki/result.h>
#include <promeki/duration.h>
#include <promeki/datatype.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DataStream;
 
class DateTime {
        public:
                PROMEKI_DATATYPE(DateTime, DataTypeDateTime, 1)
 
                
                static constexpr int64_t Invalid = INT64_MIN;
 
                Error writeToStream(DataStream &s) const;
                template <uint32_t V> static Result<DateTime> readFromStream(DataStream &s);
 
                constexpr static const char *DefaultFormat = "%F %T";
 
                using Value = std::chrono::system_clock::time_point;
 
                static DateTime now() { return DateTime(std::chrono::system_clock::now()); }
 
                static Result<DateTime> fromString(const String &str) {
                        return fromString(str, DefaultFormat);
                }
 
                static Result<DateTime> fromString(const String &str, const char *fmt) {
                        if (str == "invalid") return makeResult(DateTime());
                        std::tm tm = {};
                        tm.tm_isdst = -1;
                        const char *result = strptime(str.cstr(), fmt, &tm);
                        if (result == nullptr) return makeError<DateTime>(Error::ParseFailed);
                        return makeResult(DateTime(tm));
                }
 
                static DateTime fromNow(const String &description);
 
                static String strftime(const std::tm &tm, const char *format = DefaultFormat);
 
                DateTime() = default;
 
                DateTime(const Value &val)
                    : _ns(std::chrono::duration_cast<std::chrono::nanoseconds>(val.time_since_epoch()).count()) {}
 
                DateTime(std::tm val)
                    : _ns(std::chrono::duration_cast<std::chrono::nanoseconds>(
                                  std::chrono::system_clock::from_time_t(std::mktime(&val)).time_since_epoch())
                                  .count()) {}
 
                DateTime(time_t val)
                    : _ns(std::chrono::duration_cast<std::chrono::nanoseconds>(
                                  std::chrono::system_clock::from_time_t(val).time_since_epoch())
                                  .count()) {}
 
                bool isValid() const { return _ns != Invalid; }
 
                void invalidate() { _ns = Invalid; }
 
                Duration operator-(const DateTime &other) const {
                        if (!isValid() || !other.isValid()) return Duration();
                        return Duration::fromNanoseconds(_ns - other._ns);
                }
 
                DateTime operator+(const Duration &d) const {
                        DateTime r(*this);
                        r += d;
                        return r;
                }
 
                DateTime operator-(const Duration &d) const {
                        DateTime r(*this);
                        r -= d;
                        return r;
                }
 
                DateTime &operator+=(const Duration &d) {
                        if (!isValid() || !d.isValid()) {
                                _ns = Invalid;
                        } else {
                                _ns += d.nanoseconds();
                        }
                        return *this;
                }
 
                DateTime &operator-=(const Duration &d) {
                        if (!isValid() || !d.isValid()) {
                                _ns = Invalid;
                        } else {
                                _ns -= d.nanoseconds();
                        }
                        return *this;
                }
 
                DateTime operator+(double seconds) const {
                        DateTime r(*this);
                        r += seconds;
                        return r;
                }
 
                DateTime operator-(double seconds) const {
                        DateTime r(*this);
                        r -= seconds;
                        return r;
                }
 
                DateTime &operator+=(double seconds) {
                        if (isValid()) _ns += static_cast<int64_t>(seconds * 1'000'000'000.0);
                        return *this;
                }
 
                DateTime &operator-=(double seconds) {
                        if (isValid()) _ns -= static_cast<int64_t>(seconds * 1'000'000'000.0);
                        return *this;
                }
 
                bool operator==(const DateTime &other) const { return _ns == other._ns; }
 
                bool operator!=(const DateTime &other) const { return _ns != other._ns; }
 
                bool operator<(const DateTime &other) const { return _ns < other._ns; }
 
                bool operator<=(const DateTime &other) const { return _ns <= other._ns; }
 
                bool operator>(const DateTime &other) const { return _ns > other._ns; }
 
                bool operator>=(const DateTime &other) const { return _ns >= other._ns; }
 
                String toString(const char *format = DefaultFormat) const;
 
                operator String() const { return toString(); }
 
                time_t toTimeT() const {
                        if (!isValid()) return 0;
                        return std::chrono::system_clock::to_time_t(value());
                }
 
                double toDouble() const {
                        if (!isValid()) return 0.0;
                        return static_cast<double>(_ns) / 1'000'000'000.0;
                }
 
                int64_t nanoseconds() const { return _ns; }
 
                Value value() const {
                        return Value(std::chrono::duration_cast<std::chrono::system_clock::duration>(
                                std::chrono::nanoseconds(_ns)));
                }
 
        private:
                int64_t _ns = Invalid;
};
 
 
PROMEKI_NAMESPACE_END
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::DateTime);
 
#endif // PROMEKI_ENABLE_CORE