time_delta.h

#ifndef _MY_TIME_DELTA_
#define _MY_TIME_DELTA_
 
#include <string>
#include <sstream>
#include <vector>
#include <cmath>
 
#include "datetime_exceptions.h"
#include "datetime_constants.h"
 
namespace EZ
{
    class TimeDelta
    {
        // 累計秒
 
        long long m_totalSeconds = 0;
        long long m_totalDays = 0;
 
        // 累計秒を分解したもの
        long long m_seconds = 0;
        long long m_minutes = 0;
        long long m_hours = 0;
        // long long m_days = 0;
        // 月の日数は一定でない。年の日数も一定でない（閏年があるため）
        // long long m_months = 0;
        // long long m_years = 0;
 
    public:
        TimeDelta()
        {
        }
 
        TimeDelta(const long long &totalSeconds)
            : m_totalSeconds(totalSeconds)
        {
            parseTotalSeconds();
        }
 
        TimeDelta(const TimeDelta &origin)
        {
            m_totalSeconds = origin.totalSeconds();
            parseTotalSeconds();
        }
 
        TimeDelta(const long long &days, const long long &hours, const long long &minutes, const long long &seconds)
        {
            set(days, hours, minutes, seconds);
        }
 
        ~TimeDelta()
        {
        }
 
        void set(const long long &days, const long long &hours, const long long &minutes, const long long &seconds)
        {
            m_totalSeconds = ((days * 24 + hours) * 60 + minutes) * 60 + seconds;
            parseTotalSeconds();
        }
        long long totalSeconds() const
        {
            return m_totalSeconds;
        }
        long long totalMinutes() const
        {
            return m_totalSeconds / 60;
        }
        long long totalHours() const
        {
            return m_totalSeconds / 3600;
        }
        long long totalDays() const
        {
            return m_totalDays;
        }
        long long totalWeeks() const
        {
            return m_totalDays / 7;
        }
        std::vector<long long> toVector() const
        {
            return {m_totalDays, m_hours, m_minutes, m_seconds};
        }
        std::string str() const
        {
            std::stringstream ss;
            ss << "TimeDelta("
               << "days=" << m_totalDays
               << ", hours=" << m_hours
               << ", minutes=" << m_minutes
               << ", seconds=" << m_seconds
               << ")";
            return ss.str();
        }
 
        TimeDelta operator+() const
        {
            return TimeDelta(m_totalSeconds);
        }
        TimeDelta operator-() const
        {
            return TimeDelta(-m_totalSeconds);
        }
        TimeDelta operator+(const TimeDelta &right) const
        {
            return m_totalSeconds + right.totalSeconds();
        }
        TimeDelta operator+(const long long &right) const
        {
            long long retSeconds = m_totalSeconds + right;
            return TimeDelta(retSeconds);
        }
 
        TimeDelta operator-(const TimeDelta &right) const
        {
            return operator+(-right.totalSeconds());
        }
        TimeDelta operator-(const long long &right) const
        {
            return operator+(-right);
        }
        TimeDelta operator*(const double &right) const
        {
            long long retSeconds = double(m_totalSeconds) * right;
            return TimeDelta(retSeconds);
        }
        double operator/(const TimeDelta &right) const
        {
            if (std::abs(right.totalSeconds()) < DatetimeConstants::DOUBLE_EPSILON)
            {
                throw DatetimeException("ERROR: Could not divide by nearly ZERO value.");
            }
            return double(m_totalSeconds) / right.totalSeconds();
        }
        TimeDelta operator/(const double &right) const
        {
            if (std::abs(right) < DatetimeConstants::DOUBLE_EPSILON)
            {
                throw DatetimeException("ERROR: Could not divide by nearly ZERO value.");
            }
            long long retSeconds = double(m_totalSeconds) / right;
            return TimeDelta(retSeconds);
        }
 
        TimeDelta &operator+=(const long long &right)
        {
            m_totalSeconds += right;
            parseTotalSeconds();
            return *this;
        }
        TimeDelta &operator+=(const TimeDelta &right)
        {
            return operator+=(right.totalSeconds());
        }
 
        TimeDelta &operator-=(const long long &right)
        {
            return operator+=(-right);
        }
        TimeDelta &operator-=(const TimeDelta &right)
        {
            return operator+=(-right.totalSeconds());
        }
 
        TimeDelta &operator*=(const double &right)
        {
            m_totalSeconds = double(m_totalSeconds) * right;
            parseTotalSeconds();
            return *this;
        }
 
        TimeDelta &operator/=(const double &right)
        {
            return operator*=(1.0 / right);
        }
 
    private:
        void parseTotalSeconds()
        {
            long long remainedSecondsOfDay = m_totalSeconds % (24 * 3600);
            m_hours = remainedSecondsOfDay / 3600;
            m_minutes = remainedSecondsOfDay % 3600 / 60;
            m_seconds = remainedSecondsOfDay % 3600 % 60;
            m_totalDays = m_totalSeconds / (24 * 3600);
        }
    };
 
    bool operator==(const TimeDelta &left, const TimeDelta &right)
    {
        return left.totalSeconds() == right.totalSeconds();
    }
 
    bool operator==(const TimeDelta &left, const long long &right)
    {
        return left.totalSeconds() == right;
    }
 
    bool operator==(const long long &left, const TimeDelta &right)
    {
        return left == right.totalSeconds();
    }
 
    bool operator!=(const TimeDelta &left, const TimeDelta &right)
    {
        return !operator==(left, right);
    }
 
    bool operator!=(const TimeDelta &left, const long long &right)
    {
        return !operator==(left, right);
    }
 
    bool operator!=(const long long &left, const TimeDelta &right)
    {
        return !operator==(left, right);
    }
 
    bool operator>(const TimeDelta &left, const long long &right)
    {
        return left.totalSeconds() > right;
    }
 
    bool operator>(const long long &left, const TimeDelta &right)
    {
        return left > right.totalSeconds();
    }
 
    bool operator<(const TimeDelta &left, const long long &right)
    {
        return left.totalSeconds() < right;
    }
 
    bool operator<(const long long &left, const TimeDelta &right)
    {
        return left < right.totalSeconds();
    }
 
    bool operator>=(const TimeDelta &left, const long long &right)
    {
        return left == right || left > right;
    }
 
    bool operator>=(const long long &left, const TimeDelta &right)
    {
        return left == right || left > right;
    }
 
    bool operator<=(const TimeDelta &left, const long long &right)
    {
        return left == right || left < right;
    }
 
    bool operator<=(const long long &left, const TimeDelta &right)
    {
        return left == right || left < right;
    }
 
    std::ostream &operator<<(std::ostream &stream, const TimeDelta &timeDelta)
    {
        stream << timeDelta.str();
        return stream;
    }
 
    const TimeDelta operator*(const double &left, const TimeDelta right)
    {
        return TimeDelta(double(right.totalSeconds()) * left);
    }
}
#endif