datetime.h

Go to the documentation of this file.

 
#pragma once
 
#include <chrono>
#include <ctime>
#include <promeki/core/namespace.h>
#include <promeki/core/string.h>
#include <promeki/core/error.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DateTime {
        public:
                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 DateTime fromString(const String &str, const char *fmt = DefaultFormat, Error *err = nullptr) {
                        std::tm tm = {};
                        tm.tm_isdst = -1;
                        const char *result = strptime(str.cstr(), fmt, &tm);
                        if(result == nullptr) {
                                if(err != nullptr) *err = Error::Invalid;
                                return DateTime();
                        }
                        if(err != nullptr) *err = Error::Ok;
                        return DateTime(tm);
                }
 
                static DateTime fromNow(const String &description);
 
                static String strftime(const std::tm &tm, const char *format = DefaultFormat);
 
                DateTime() { }
 
                DateTime(const Value &val) : _value(val) { }
 
                DateTime(std::tm val) : _value(std::chrono::system_clock::from_time_t(std::mktime(&val))) { }
 
                DateTime(time_t val) : _value(std::chrono::system_clock::from_time_t(val)) { }
 
                DateTime operator+(const DateTime &other) const {
                        return DateTime(_value + other._value.time_since_epoch());
                }
 
                DateTime operator-(const DateTime &other) const {
                        return DateTime(_value - other._value.time_since_epoch());
                }
 
                DateTime &operator+=(const DateTime &other) {
                        _value += other._value.time_since_epoch();
                        return *this;
                }
 
                DateTime &operator-=(const DateTime &other) {
                        _value -= other._value.time_since_epoch();
                        return *this;
                }
 
                DateTime operator+(double seconds) const {
                        return DateTime(_value + std::chrono::duration_cast<std::chrono::system_clock::duration>(
                                        std::chrono::duration<double>(seconds)));
                }
 
                DateTime operator-(double seconds) const {
                        return DateTime(_value - std::chrono::duration_cast<std::chrono::system_clock::duration>(
                                        std::chrono::duration<double>(seconds)));
                }
 
                DateTime &operator+=(double seconds) {
                        _value += std::chrono::duration_cast<std::chrono::system_clock::duration>(
                                        std::chrono::duration<double>(seconds));
                        return *this;
                }
 
                DateTime& operator-=(double seconds) {
                        _value -= std::chrono::duration_cast<std::chrono::system_clock::duration>(
                                        std::chrono::duration<double>(seconds));
                        return *this;
                }
 
                bool operator==(const DateTime &other) const {
                        return _value == other._value;
                }
 
                bool operator!=(const DateTime &other) const {
                        return _value != other._value;
                }
 
                bool operator<(const DateTime &other) const {
                        return _value < other._value;
                }
 
                bool operator<=(const DateTime &other) const {
                        return _value <= other._value;
                }
 
                bool operator>(const DateTime &other) const {
                        return _value > other._value;
                }
 
                bool operator>=(const DateTime& other) const {
                        return _value >= other._value;
                }
 
                String toString(const char *format = DefaultFormat) const;
 
                operator String() const {
                        return toString();
                }
 
                time_t toTimeT() const {
                        return std::chrono::system_clock::to_time_t(_value);
                }
 
                double toDouble() const {
                        return std::chrono::duration_cast<std::chrono::duration<double>>(
                                _value.time_since_epoch()).count();
                }
 
                Value value() const {
                        return _value;
                }
 
        private:
                Value   _value;
};
 
 
PROMEKI_NAMESPACE_END