date.hpp

/*
  ANCH Framework: ANother C++ Hack is a C++ framework based on C++11 standard
  Copyright (C) 2012 Vincent Lachenal

  This file is part of ANCH Framework.

  ANCH Framework is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  ANCH Framework is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with ANCH Framework.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _ANCH_DATE_DATE_H_
#define _ANCH_DATE_DATE_H_

#include <memory>
#include <mutex>
#include <chrono>
#include <ctime>


namespace anch {
  namespace date {

    class DateFormatter;
    namespace formatter {
      class IDatePartFormatter;
    }

    class Date {

      friend class formatter::IDatePartFormatter;
      friend class DateFormatter;

      // Attributes +
    private:
      static std::mutex _mutex;

      std::int64_t _timestamp;

      int32_t _years = 0;

      uint16_t _months = 0;

      uint16_t _ydays = 0;

      uint16_t _mdays = 0;

      uint16_t _wdays = 0;

      uint16_t _hours = 0;

      uint16_t _minutes = 0;

      uint16_t _seconds = 0;

      uint16_t _milliseconds = 0;

      uint16_t _microseconds = 0;

      uint16_t _nanoseconds = 0;
      // Attributes -

      // Constructors +
    public:
      Date(bool init = true);

      Date(const Date& date);

      Date(const std::time_t& time);

      Date(const std::tm* const time);
      // Constructors -

      // Destructor +
    public:
      virtual ~Date();
      // Destructor -

      // Methods +
    private:
      template<typename R, typename P>
      void initialize(const std::chrono::duration<R,P>& duration) noexcept {
        _nanoseconds = static_cast<uint16_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count() % 1000);
        _microseconds = static_cast<uint16_t>(std::chrono::duration_cast<std::chrono::microseconds>(duration).count() % 1000);
        _milliseconds = static_cast<uint16_t>(std::chrono::duration_cast<std::chrono::milliseconds>(duration).count() % 1000);
      }

      void initialize(const std::tm* const time);

      void computeTimestamp();

      inline void computeTm(std::tm& time) const {
        time.tm_sec = _seconds;
        time.tm_min = _minutes;
        time.tm_hour = _hours;
        time.tm_mday = _mdays;
        time.tm_mon = _months;
        time.tm_year = _years - 1900;
      }

    public:
      inline bool after(const Date& date) const noexcept {
        return _timestamp > date._timestamp;
      }

      inline bool before(const Date& date) const noexcept {
        return _timestamp < date._timestamp;
      }

      inline bool equals(const Date& date) const noexcept {
        return _timestamp == date._timestamp;
      }
      // Methods -


      // Operators +
    public:
      inline bool operator > (const Date& date) const noexcept {
        return after(date);
      }

      inline bool operator >= (const Date& date) const noexcept {
        return (after(date) || equals(date));
      }

      inline bool operator < (const Date& date) const noexcept {
        return before(date);
      }

      inline bool operator <= (const Date& date) const noexcept {
        return (before(date) || equals(date));
      }

      inline bool operator == (const Date& date) const noexcept {
        return equals(date);
      }

      inline bool operator != (const Date& date) const noexcept {
        return !equals(date);
      }

      inline operator std::time_t() const noexcept {
        std::tm time;
        computeTm(time);
        return std::mktime(&time);
      }

      inline operator std::tm() const noexcept {
        std::tm time;
        computeTm(time);
        return time;
      }
      // Operators -

    };

  }
}

#endif // _ANCH_DATE_DATE_H_