d9/d5c/Date_8cpp_source.html

 #include <samchon/library/Date.hpp>

 #include <array>

 #include <samchon/WeakString.hpp>
 #include <samchon/library/StringUtil.hpp>

 using namespace std;
 using namespace samchon;
 using namespace samchon::library;

 chrono::system_clock::time_point Date::TP_1970 = chrono::system_clock::from_time_t(0);

 /* --------------------------------------------------------------------------
     CONSTRUCTORS
 -------------------------------------------------------------------------- */
 //CONSTRUCTORS
 Date::Date()
     : super(chrono::system_clock::now())
     //: super(chrono::system_clock::now())
 {
 }
 Date::Date(const super &date)
     : super(date)
 {
 }
 Date::Date(super &&date)
     : super(move(date))
 {
 }

 Date::Date(int year, int month, int date)
 {
     set(year, month, date);
 }
 Date::Date(const string &str)
     : Date(WeakString(str))
 {
 }
 Date::Date(const WeakString &wStr)
 {
     set(wStr);
 }
 Date::Date(long long linuxTime)
     : super(chrono::system_clock::from_time_t(linuxTime))
 {
 }

 //SEMI-CONSTRUCTORS
 void Date::set(const string &str)
 {
     set(WeakString(str));
 }
 void Date::set(const WeakString &wStr)
 {
     WeakString val = wStr.trim();

     int year, month, date;

     //시분초까지 있을 때
     if (val.find(" ") != std::string::npos)
         val = val.between(std::string(), " ");

     //년월일 설정
     vector<WeakString> &ymdVec = val.split("-");
     year = stoi(ymdVec[0].str());
     month = stoi(ymdVec[1].str());
     date = stoi(ymdVec[2].str());

     set(year, month, date);
 }
 void Date::set(int year, int month, int date) //날짜, 시간 설정
 {
     array<int, 12> &monthArray = calcLastDates(year);

     if (month > 12)
         throw invalid_argument("month is over 12");
     if (date > monthArray[month - 1])
         throw invalid_argument("date is over expiration date");

     long long linuxTime = calcSeconds(year, month, date) - (calcSeconds(1970, 1, 1) + 9 * 60 * 60);
     set(linuxTime);
 };
 void Date::set(long long linuxTime)
 {
     *this = chrono::system_clock::from_time_t(linuxTime);

     /*long long prevTime = toLinuxTime();

     this->operator+=(chrono::seconds(linuxTime));
     this->operator-=(chrono::seconds(prevTime));*/
 }

 /* --------------------------------------------------------------------------
     HIDDEN METHODS
 -------------------------------------------------------------------------- */
 auto Date::calcLastDates(int year) -> array<int, 12>
 {
     //Last dates of each month
     static array<int, 12> monthArray = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

     //When the year contains leaf month, then make expiration date of Feburary to 29
     if (year % 4 == 0)
         if (!(year % 100 == 0 && year % 400 != 0))
             monthArray[1] = 29;

     return monthArray;
 }
 long long Date::calcSeconds(int year, int month, int date)
 {
     array<int, 12> &monthArray = calcLastDates(year);
     long long total;

     //연, 월, 일의 총 일수   total = (year - 1) * 365 + ((year - 1) / 4) - ((year - 1) / 100) + ((year - 1) / 400);

    //달수만큼 날자를 더함
   for (int i = 0; i < month - 1; i++)
        total += monthArray[i];
    total += date;

    //일자에 3,600을 곱한다
  total = (total * 24 * 60 * 60);
    return total;
}

/* --------------------------------------------------------------------------
    SETTERS OF EACH COMPONENT
-------------------------------------------------------------------------- */
//SET METHODS
void Date::setYear(int year)
{
    int month = getMonth();
    int newDate = getDate();

    //윤달에 29일인데 addYear을 하려는 경우
  if
        (
            month == 2 && newDate == 29 //현재가 윤달 29일
            &&
            !(
                year == 4 &&
                !((year % 100 == 0 && year % 400 != 0))
            ) //바꿀 연도의 2월은 윤달이 아님
       )
        newDate = 28;

    set(year, month, newDate);
}
void Date::setMonth(int month)
{
    if (month > 12)
        throw invalid_argument("month is over 12");

    //달력
   int year = getYear();
    int newDate = getDate();

    array<int, 12> &monthArray = calcLastDates(year);

    //해당 월의 마지막 일을 초과할 때, 조정한다
  //EX-> 4월인데 31일이면 4월 30일로 조정
    if (newDate > monthArray[month - 1])
        newDate = monthArray[month - 1];

    set(year, month, newDate);
}
void Date::setDate(int val)
{
    set(getYear(), getMonth(), val);
}

//ADD METHODS
void Date::addYear(int val)
{
    //현재가 2012년 2월 29일(윤달)인데 1년을 추가하면 2013년 2월 28일로 변함
    setYear(getYear() + val);
}
void Date::addMonth(int val)
{
    //현재가 3월 31일인데 1월이 추가되면 날짜는 4월 30일로 변한다
   int newYear = getYear();
    int newMonth = getMonth() + val;
    int newDate = getDate();

    if (newMonth > 12)
    {
        newYear = newYear + (newMonth - 1) / 12;
        newMonth = newMonth % 12;
    }

    //달력
   std::array<int, 12> &monthArray = calcLastDates(newYear);

    //해당 월의 마지막 일을 초과할 때, 조정한다
  //EX-> 4월인데 31일이면 4월 30일로 조정
    if (newDate > monthArray[newMonth - 1])
        newDate = monthArray[newMonth - 1];

    set(newYear, newMonth, newDate);
}
void Date::addWeek(int val)
{
    addDate(7 * val);
}
void Date::addDate(int val)
{
    operator+=(chrono::hours(24 * val));
}

/* --------------------------------------------------------------------------
    GETTERS AND TO_STRING
-------------------------------------------------------------------------- */
auto Date::toLinuxTime() const -> long long
{
    std::chrono::system_clock::duration duration = *this - TP_1970;
    std::chrono::seconds seconds = std::chrono::duration_cast<std::chrono::seconds>(duration);

    return seconds.count();
}
int Date::getYear() const
{
    auto &tm = toTM();
    return tm.tm_year + 1900;
}
int Date::getMonth() const
{
    auto &tm = toTM();
    return tm.tm_mon + 1;
}
int Date::getDay() const
{
    auto &tm = toTM();
    return tm.tm_wday;
}
int Date::getDate() const
{
    auto &tm = toTM();
    return tm.tm_mday;
}

auto Date::toTM() const -> struct tm
{
    struct tm tm;
    time_t tt = chrono::system_clock::to_time_t(*this);
    localtime_s(&tm, &tt);

    return tm;
}
auto Date::toString() const -> std::string
{
    return StringUtil::substitute
        (
            "{1}-{2}-{3}",
            getYear(), getMonth(), getDate()
        );
}
     total = (year - 1) * 365 + ((year - 1) / 4) - ((year - 1) / 100) + ((year - 1) / 400);

     //달수만큼 날자를 더함   for (int i = 0; i < month - 1; i++)
        total += monthArray[i];
    total += date;

    //일자에 3,600을 곱한다
  total = (total * 24 * 60 * 60);
    return total;
}

/* --------------------------------------------------------------------------
    SETTERS OF EACH COMPONENT
-------------------------------------------------------------------------- */
//SET METHODS
void Date::setYear(int year)
{
    int month = getMonth();
    int newDate = getDate();

    //윤달에 29일인데 addYear을 하려는 경우
  if
        (
            month == 2 && newDate == 29 //현재가 윤달 29일
            &&
            !(
                year == 4 &&
                !((year % 100 == 0 && year % 400 != 0))
            ) //바꿀 연도의 2월은 윤달이 아님
       )
        newDate = 28;

    set(year, month, newDate);
}
void Date::setMonth(int month)
{
    if (month > 12)
        throw invalid_argument("month is over 12");

    //달력
   int year = getYear();
    int newDate = getDate();

    array<int, 12> &monthArray = calcLastDates(year);

    //해당 월의 마지막 일을 초과할 때, 조정한다
  //EX-> 4월인데 31일이면 4월 30일로 조정
    if (newDate > monthArray[month - 1])
        newDate = monthArray[month - 1];

    set(year, month, newDate);
}
void Date::setDate(int val)
{
    set(getYear(), getMonth(), val);
}

//ADD METHODS
void Date::addYear(int val)
{
    //현재가 2012년 2월 29일(윤달)인데 1년을 추가하면 2013년 2월 28일로 변함
    setYear(getYear() + val);
}
void Date::addMonth(int val)
{
    //현재가 3월 31일인데 1월이 추가되면 날짜는 4월 30일로 변한다
   int newYear = getYear();
    int newMonth = getMonth() + val;
    int newDate = getDate();

    if (newMonth > 12)
    {
        newYear = newYear + (newMonth - 1) / 12;
        newMonth = newMonth % 12;
    }

    //달력
   std::array<int, 12> &monthArray = calcLastDates(newYear);

    //해당 월의 마지막 일을 초과할 때, 조정한다
  //EX-> 4월인데 31일이면 4월 30일로 조정
    if (newDate > monthArray[newMonth - 1])
        newDate = monthArray[newMonth - 1];

    set(newYear, newMonth, newDate);
}
void Date::addWeek(int val)
{
    addDate(7 * val);
}
void Date::addDate(int val)
{
    operator+=(chrono::hours(24 * val));
}

/* --------------------------------------------------------------------------
    GETTERS AND TO_STRING
-------------------------------------------------------------------------- */
auto Date::toLinuxTime() const -> long long
{
    std::chrono::system_clock::duration duration = *this - TP_1970;
    std::chrono::seconds seconds = std::chrono::duration_cast<std::chrono::seconds>(duration);

    return seconds.count();
}
int Date::getYear() const
{
    auto &tm = toTM();
    return tm.tm_year + 1900;
}
int Date::getMonth() const
{
    auto &tm = toTM();
    return tm.tm_mon + 1;
}
int Date::getDay() const
{
    auto &tm = toTM();
    return tm.tm_wday;
}
int Date::getDate() const
{
    auto &tm = toTM();
    return tm.tm_mday;
}

auto Date::toTM() const -> struct tm
{
    struct tm tm;
    time_t tt = chrono::system_clock::to_time_t(*this);
    localtime_s(&tm, &tt);

    return tm;
}
auto Date::toString() const -> std::string
{
    return StringUtil::substitute
        (
            "{1}-{2}-{3}",
            getYear(), getMonth(), getDate()
        );
}
     for (int i = 0; i < month - 1; i++)
         total += monthArray[i];
     total += date;

     //일자에 3,600을 곱한다  total = (total * 24 * 60 * 60);
    return total;
}

/* --------------------------------------------------------------------------
    SETTERS OF EACH COMPONENT
-------------------------------------------------------------------------- */
//SET METHODS
void Date::setYear(int year)
{
    int month = getMonth();
    int newDate = getDate();

    //윤달에 29일인데 addYear을 하려는 경우
  if
        (
            month == 2 && newDate == 29 //현재가 윤달 29일
            &&
            !(
                year == 4 &&
                !((year % 100 == 0 && year % 400 != 0))
            ) //바꿀 연도의 2월은 윤달이 아님
       )
        newDate = 28;

    set(year, month, newDate);
}
void Date::setMonth(int month)
{
    if (month > 12)
        throw invalid_argument("month is over 12");

    //달력
   int year = getYear();
    int newDate = getDate();

    array<int, 12> &monthArray = calcLastDates(year);

    //해당 월의 마지막 일을 초과할 때, 조정한다
  //EX-> 4월인데 31일이면 4월 30일로 조정
    if (newDate > monthArray[month - 1])
        newDate = monthArray[month - 1];

    set(year, month, newDate);
}
void Date::setDate(int val)
{
    set(getYear(), getMonth(), val);
}

//ADD METHODS
void Date::addYear(int val)
{
    //현재가 2012년 2월 29일(윤달)인데 1년을 추가하면 2013년 2월 28일로 변함
    setYear(getYear() + val);
}
void Date::addMonth(int val)
{
    //현재가 3월 31일인데 1월이 추가되면 날짜는 4월 30일로 변한다
   int newYear = getYear();
    int newMonth = getMonth() + val;
    int newDate = getDate();

    if (newMonth > 12)
    {
        newYear = newYear + (newMonth - 1) / 12;
        newMonth = newMonth % 12;
    }

    //달력
   std::array<int, 12> &monthArray = calcLastDates(newYear);

    //해당 월의 마지막 일을 초과할 때, 조정한다
  //EX-> 4월인데 31일이면 4월 30일로 조정
    if (newDate > monthArray[newMonth - 1])
        newDate = monthArray[newMonth - 1];

    set(newYear, newMonth, newDate);
}
void Date::addWeek(int val)
{
    addDate(7 * val);
}
void Date::addDate(int val)
{
    operator+=(chrono::hours(24 * val));
}

/* --------------------------------------------------------------------------
    GETTERS AND TO_STRING
-------------------------------------------------------------------------- */
auto Date::toLinuxTime() const -> long long
{
    std::chrono::system_clock::duration duration = *this - TP_1970;
    std::chrono::seconds seconds = std::chrono::duration_cast<std::chrono::seconds>(duration);

    return seconds.count();
}
int Date::getYear() const
{
    auto &tm = toTM();
    return tm.tm_year + 1900;
}
int Date::getMonth() const
{
    auto &tm = toTM();
    return tm.tm_mon + 1;
}
int Date::getDay() const
{
    auto &tm = toTM();
    return tm.tm_wday;
}
int Date::getDate() const
{
    auto &tm = toTM();
    return tm.tm_mday;
}

auto Date::toTM() const -> struct tm
{
    struct tm tm;
    time_t tt = chrono::system_clock::to_time_t(*this);
    localtime_s(&tm, &tt);

    return tm;
}
auto Date::toString() const -> std::string
{
    return StringUtil::substitute
        (
            "{1}-{2}-{3}",
            getYear(), getMonth(), getDate()
        );
}
     total = (total * 24 * 60 * 60);
     return total;
 }

 /* --------------------------------------------------------------------------
     SETTERS OF EACH COMPONENT
 -------------------------------------------------------------------------- */
 //SET METHODS
 void Date::setYear(int year)
 {
     int month = getMonth();
     int newDate = getDate();

     //윤달에 29일인데 addYear을 하려는 경우  if
        (
            month == 2 && newDate == 29 //현재가 윤달 29일
            &&
            !(
                year == 4 &&
                !((year % 100 == 0 && year % 400 != 0))
            ) //바꿀 연도의 2월은 윤달이 아님
       )
        newDate = 28;

    set(year, month, newDate);
}
void Date::setMonth(int month)
{
    if (month > 12)
        throw invalid_argument("month is over 12");

    //달력
   int year = getYear();
    int newDate = getDate();

    array<int, 12> &monthArray = calcLastDates(year);

    //해당 월의 마지막 일을 초과할 때, 조정한다
  //EX-> 4월인데 31일이면 4월 30일로 조정
    if (newDate > monthArray[month - 1])
        newDate = monthArray[month - 1];

    set(year, month, newDate);
}
void Date::setDate(int val)
{
    set(getYear(), getMonth(), val);
}

//ADD METHODS
void Date::addYear(int val)
{
    //현재가 2012년 2월 29일(윤달)인데 1년을 추가하면 2013년 2월 28일로 변함
    setYear(getYear() + val);
}
void Date::addMonth(int val)
{
    //현재가 3월 31일인데 1월이 추가되면 날짜는 4월 30일로 변한다
   int newYear = getYear();
    int newMonth = getMonth() + val;
    int newDate = getDate();

    if (newMonth > 12)
    {
        newYear = newYear + (newMonth - 1) / 12;
        newMonth = newMonth % 12;
    }

    //달력
   std::array<int, 12> &monthArray = calcLastDates(newYear);

    //해당 월의 마지막 일을 초과할 때, 조정한다
  //EX-> 4월인데 31일이면 4월 30일로 조정
    if (newDate > monthArray[newMonth - 1])
        newDate = monthArray[newMonth - 1];

    set(newYear, newMonth, newDate);
}
void Date::addWeek(int val)
{
    addDate(7 * val);
}
void Date::addDate(int val)
{
    operator+=(chrono::hours(24 * val));
}

/* --------------------------------------------------------------------------
    GETTERS AND TO_STRING
-------------------------------------------------------------------------- */
auto Date::toLinuxTime() const -> long long
{
    std::chrono::system_clock::duration duration = *this - TP_1970;
    std::chrono::seconds seconds = std::chrono::duration_cast<std::chrono::seconds>(duration);

    return seconds.count();
}
int Date::getYear() const
{
    auto &tm = toTM();
    return tm.tm_year + 1900;
}
int Date::getMonth() const
{
    auto &tm = toTM();
    return tm.tm_mon + 1;
}
int Date::getDay() const
{
    auto &tm = toTM();
    return tm.tm_wday;
}
int Date::getDate() const
{
    auto &tm = toTM();
    return tm.tm_mday;
}

auto Date::toTM() const -> struct tm
{
    struct tm tm;
    time_t tt = chrono::system_clock::to_time_t(*this);
    localtime_s(&tm, &tt);

    return tm;
}
auto Date::toString() const -> std::string
{
    return StringUtil::substitute
        (
            "{1}-{2}-{3}",
            getYear(), getMonth(), getDate()
        );
}
     if
         (
             month == 2 && newDate == 29 //현재가 윤달 29일
             &&
             !(
                 year == 4 &&
                 !((year % 100 == 0 && year % 400 != 0))
             ) //바꿀 연도의 2월은 윤달이 아님       )
        newDate = 28;

    set(year, month, newDate);
}
void Date::setMonth(int month)
{
    if (month > 12)
        throw invalid_argument("month is over 12");

    //달력
   int year = getYear();
    int newDate = getDate();

    array<int, 12> &monthArray = calcLastDates(year);

    //해당 월의 마지막 일을 초과할 때, 조정한다
  //EX-> 4월인데 31일이면 4월 30일로 조정
    if (newDate > monthArray[month - 1])
        newDate = monthArray[month - 1];

    set(year, month, newDate);
}
void Date::setDate(int val)
{
    set(getYear(), getMonth(), val);
}

//ADD METHODS
void Date::addYear(int val)
{
    //현재가 2012년 2월 29일(윤달)인데 1년을 추가하면 2013년 2월 28일로 변함
    setYear(getYear() + val);
}
void Date::addMonth(int val)
{
    //현재가 3월 31일인데 1월이 추가되면 날짜는 4월 30일로 변한다
   int newYear = getYear();
    int newMonth = getMonth() + val;
    int newDate = getDate();

    if (newMonth > 12)
    {
        newYear = newYear + (newMonth - 1) / 12;
        newMonth = newMonth % 12;
    }

    //달력
   std::array<int, 12> &monthArray = calcLastDates(newYear);

    //해당 월의 마지막 일을 초과할 때, 조정한다
  //EX-> 4월인데 31일이면 4월 30일로 조정
    if (newDate > monthArray[newMonth - 1])
        newDate = monthArray[newMonth - 1];

    set(newYear, newMonth, newDate);
}
void Date::addWeek(int val)
{
    addDate(7 * val);
}
void Date::addDate(int val)
{
    operator+=(chrono::hours(24 * val));
}

/* --------------------------------------------------------------------------
    GETTERS AND TO_STRING
-------------------------------------------------------------------------- */
auto Date::toLinuxTime() const -> long long
{
    std::chrono::system_clock::duration duration = *this - TP_1970;
    std::chrono::seconds seconds = std::chrono::duration_cast<std::chrono::seconds>(duration);

    return seconds.count();
}
int Date::getYear() const
{
    auto &tm = toTM();
    return tm.tm_year + 1900;
}
int Date::getMonth() const
{
    auto &tm = toTM();
    return tm.tm_mon + 1;
}
int Date::getDay() const
{
    auto &tm = toTM();
    return tm.tm_wday;
}
int Date::getDate() const
{
    auto &tm = toTM();
    return tm.tm_mday;
}

auto Date::toTM() const -> struct tm
{
    struct tm tm;
    time_t tt = chrono::system_clock::to_time_t(*this);
    localtime_s(&tm, &tt);

    return tm;
}
auto Date::toString() const -> std::string
{
    return StringUtil::substitute
        (
            "{1}-{2}-{3}",
            getYear(), getMonth(), getDate()
        );
}
         )
         newDate = 28;

     set(year, month, newDate);
 }
 void Date::setMonth(int month)
 {
     if (month > 12)
         throw invalid_argument("month is over 12");

     //달력   int year = getYear();
    int newDate = getDate();

    array<int, 12> &monthArray = calcLastDates(year);

    //해당 월의 마지막 일을 초과할 때, 조정한다
  //EX-> 4월인데 31일이면 4월 30일로 조정
    if (newDate > monthArray[month - 1])
        newDate = monthArray[month - 1];

    set(year, month, newDate);
}
void Date::setDate(int val)
{
    set(getYear(), getMonth(), val);
}

//ADD METHODS
void Date::addYear(int val)
{
    //현재가 2012년 2월 29일(윤달)인데 1년을 추가하면 2013년 2월 28일로 변함
    setYear(getYear() + val);
}
void Date::addMonth(int val)
{
    //현재가 3월 31일인데 1월이 추가되면 날짜는 4월 30일로 변한다
   int newYear = getYear();
    int newMonth = getMonth() + val;
    int newDate = getDate();

    if (newMonth > 12)
    {
        newYear = newYear + (newMonth - 1) / 12;
        newMonth = newMonth % 12;
    }

    //달력
   std::array<int, 12> &monthArray = calcLastDates(newYear);

    //해당 월의 마지막 일을 초과할 때, 조정한다
  //EX-> 4월인데 31일이면 4월 30일로 조정
    if (newDate > monthArray[newMonth - 1])
        newDate = monthArray[newMonth - 1];

    set(newYear, newMonth, newDate);
}
void Date::addWeek(int val)
{
    addDate(7 * val);
}
void Date::addDate(int val)
{
    operator+=(chrono::hours(24 * val));
}

/* --------------------------------------------------------------------------
    GETTERS AND TO_STRING
-------------------------------------------------------------------------- */
auto Date::toLinuxTime() const -> long long
{
    std::chrono::system_clock::duration duration = *this - TP_1970;
    std::chrono::seconds seconds = std::chrono::duration_cast<std::chrono::seconds>(duration);

    return seconds.count();
}
int Date::getYear() const
{
    auto &tm = toTM();
    return tm.tm_year + 1900;
}
int Date::getMonth() const
{
    auto &tm = toTM();
    return tm.tm_mon + 1;
}
int Date::getDay() const
{
    auto &tm = toTM();
    return tm.tm_wday;
}
int Date::getDate() const
{
    auto &tm = toTM();
    return tm.tm_mday;
}

auto Date::toTM() const -> struct tm
{
    struct tm tm;
    time_t tt = chrono::system_clock::to_time_t(*this);
    localtime_s(&tm, &tt);

    return tm;
}
auto Date::toString() const -> std::string
{
    return StringUtil::substitute
        (
            "{1}-{2}-{3}",
            getYear(), getMonth(), getDate()
        );
}
     int year = getYear();
     int newDate = getDate();

     array<int, 12> &monthArray = calcLastDates(year);

     //해당 월의 마지막 일을 초과할 때, 조정한다  //EX-> 4월인데 31일이면 4월 30일로 조정
    if (newDate > monthArray[month - 1])
        newDate = monthArray[month - 1];

    set(year, month, newDate);
}
void Date::setDate(int val)
{
    set(getYear(), getMonth(), val);
}

//ADD METHODS
void Date::addYear(int val)
{
    //현재가 2012년 2월 29일(윤달)인데 1년을 추가하면 2013년 2월 28일로 변함
    setYear(getYear() + val);
}
void Date::addMonth(int val)
{
    //현재가 3월 31일인데 1월이 추가되면 날짜는 4월 30일로 변한다
   int newYear = getYear();
    int newMonth = getMonth() + val;
    int newDate = getDate();

    if (newMonth > 12)
    {
        newYear = newYear + (newMonth - 1) / 12;
        newMonth = newMonth % 12;
    }

    //달력
   std::array<int, 12> &monthArray = calcLastDates(newYear);

    //해당 월의 마지막 일을 초과할 때, 조정한다
  //EX-> 4월인데 31일이면 4월 30일로 조정
    if (newDate > monthArray[newMonth - 1])
        newDate = monthArray[newMonth - 1];

    set(newYear, newMonth, newDate);
}
void Date::addWeek(int val)
{
    addDate(7 * val);
}
void Date::addDate(int val)
{
    operator+=(chrono::hours(24 * val));
}

/* --------------------------------------------------------------------------
    GETTERS AND TO_STRING
-------------------------------------------------------------------------- */
auto Date::toLinuxTime() const -> long long
{
    std::chrono::system_clock::duration duration = *this - TP_1970;
    std::chrono::seconds seconds = std::chrono::duration_cast<std::chrono::seconds>(duration);

    return seconds.count();
}
int Date::getYear() const
{
    auto &tm = toTM();
    return tm.tm_year + 1900;
}
int Date::getMonth() const
{
    auto &tm = toTM();
    return tm.tm_mon + 1;
}
int Date::getDay() const
{
    auto &tm = toTM();
    return tm.tm_wday;
}
int Date::getDate() const
{
    auto &tm = toTM();
    return tm.tm_mday;
}

auto Date::toTM() const -> struct tm
{
    struct tm tm;
    time_t tt = chrono::system_clock::to_time_t(*this);
    localtime_s(&tm, &tt);

    return tm;
}
auto Date::toString() const -> std::string
{
    return StringUtil::substitute
        (
            "{1}-{2}-{3}",
            getYear(), getMonth(), getDate()
        );
}
     //EX-> 4월인데 31일이면 4월 30일로 조정
     if (newDate > monthArray[month - 1])
         newDate = monthArray[month - 1];

     set(year, month, newDate);
 }
 void Date::setDate(int val)
 {
     set(getYear(), getMonth(), val);
 }

 //ADD METHODS
 void Date::addYear(int val)
 {
     //현재가 2012년 2월 29일(윤달)인데 1년을 추가하면 2013년 2월 28일로 변함
     setYear(getYear() + val);
 }
 void Date::addMonth(int val)
 {
     //현재가 3월 31일인데 1월이 추가되면 날짜는 4월 30일로 변한다   int newYear = getYear();
    int newMonth = getMonth() + val;
    int newDate = getDate();

    if (newMonth > 12)
    {
        newYear = newYear + (newMonth - 1) / 12;
        newMonth = newMonth % 12;
    }

    //달력
   std::array<int, 12> &monthArray = calcLastDates(newYear);

    //해당 월의 마지막 일을 초과할 때, 조정한다
  //EX-> 4월인데 31일이면 4월 30일로 조정
    if (newDate > monthArray[newMonth - 1])
        newDate = monthArray[newMonth - 1];

    set(newYear, newMonth, newDate);
}
void Date::addWeek(int val)
{
    addDate(7 * val);
}
void Date::addDate(int val)
{
    operator+=(chrono::hours(24 * val));
}

/* --------------------------------------------------------------------------
    GETTERS AND TO_STRING
-------------------------------------------------------------------------- */
auto Date::toLinuxTime() const -> long long
{
    std::chrono::system_clock::duration duration = *this - TP_1970;
    std::chrono::seconds seconds = std::chrono::duration_cast<std::chrono::seconds>(duration);

    return seconds.count();
}
int Date::getYear() const
{
    auto &tm = toTM();
    return tm.tm_year + 1900;
}
int Date::getMonth() const
{
    auto &tm = toTM();
    return tm.tm_mon + 1;
}
int Date::getDay() const
{
    auto &tm = toTM();
    return tm.tm_wday;
}
int Date::getDate() const
{
    auto &tm = toTM();
    return tm.tm_mday;
}

auto Date::toTM() const -> struct tm
{
    struct tm tm;
    time_t tt = chrono::system_clock::to_time_t(*this);
    localtime_s(&tm, &tt);

    return tm;
}
auto Date::toString() const -> std::string
{
    return StringUtil::substitute
        (
            "{1}-{2}-{3}",
            getYear(), getMonth(), getDate()
        );
}
     int newYear = getYear();
     int newMonth = getMonth() + val;
     int newDate = getDate();

     if (newMonth > 12)
     {
         newYear = newYear + (newMonth - 1) / 12;
         newMonth = newMonth % 12;
     }

     //달력   std::array<int, 12> &monthArray = calcLastDates(newYear);

    //해당 월의 마지막 일을 초과할 때, 조정한다
  //EX-> 4월인데 31일이면 4월 30일로 조정
    if (newDate > monthArray[newMonth - 1])
        newDate = monthArray[newMonth - 1];

    set(newYear, newMonth, newDate);
}
void Date::addWeek(int val)
{
    addDate(7 * val);
}
void Date::addDate(int val)
{
    operator+=(chrono::hours(24 * val));
}

/* --------------------------------------------------------------------------
    GETTERS AND TO_STRING
-------------------------------------------------------------------------- */
auto Date::toLinuxTime() const -> long long
{
    std::chrono::system_clock::duration duration = *this - TP_1970;
    std::chrono::seconds seconds = std::chrono::duration_cast<std::chrono::seconds>(duration);

    return seconds.count();
}
int Date::getYear() const
{
    auto &tm = toTM();
    return tm.tm_year + 1900;
}
int Date::getMonth() const
{
    auto &tm = toTM();
    return tm.tm_mon + 1;
}
int Date::getDay() const
{
    auto &tm = toTM();
    return tm.tm_wday;
}
int Date::getDate() const
{
    auto &tm = toTM();
    return tm.tm_mday;
}

auto Date::toTM() const -> struct tm
{
    struct tm tm;
    time_t tt = chrono::system_clock::to_time_t(*this);
    localtime_s(&tm, &tt);

    return tm;
}
auto Date::toString() const -> std::string
{
    return StringUtil::substitute
        (
            "{1}-{2}-{3}",
            getYear(), getMonth(), getDate()
        );
}
     std::array<int, 12> &monthArray = calcLastDates(newYear);

     //해당 월의 마지막 일을 초과할 때, 조정한다  //EX-> 4월인데 31일이면 4월 30일로 조정
    if (newDate > monthArray[newMonth - 1])
        newDate = monthArray[newMonth - 1];

    set(newYear, newMonth, newDate);
}
void Date::addWeek(int val)
{
    addDate(7 * val);
}
void Date::addDate(int val)
{
    operator+=(chrono::hours(24 * val));
}

/* --------------------------------------------------------------------------
    GETTERS AND TO_STRING
-------------------------------------------------------------------------- */
auto Date::toLinuxTime() const -> long long
{
    std::chrono::system_clock::duration duration = *this - TP_1970;
    std::chrono::seconds seconds = std::chrono::duration_cast<std::chrono::seconds>(duration);

    return seconds.count();
}
int Date::getYear() const
{
    auto &tm = toTM();
    return tm.tm_year + 1900;
}
int Date::getMonth() const
{
    auto &tm = toTM();
    return tm.tm_mon + 1;
}
int Date::getDay() const
{
    auto &tm = toTM();
    return tm.tm_wday;
}
int Date::getDate() const
{
    auto &tm = toTM();
    return tm.tm_mday;
}

auto Date::toTM() const -> struct tm
{
    struct tm tm;
    time_t tt = chrono::system_clock::to_time_t(*this);
    localtime_s(&tm, &tt);

    return tm;
}
auto Date::toString() const -> std::string
{
    return StringUtil::substitute
        (
            "{1}-{2}-{3}",
            getYear(), getMonth(), getDate()
        );
}
     //EX-> 4월인데 31일이면 4월 30일로 조정
     if (newDate > monthArray[newMonth - 1])
         newDate = monthArray[newMonth - 1];

     set(newYear, newMonth, newDate);
 }
 void Date::addWeek(int val)
 {
     addDate(7 * val);
 }
 void Date::addDate(int val)
 {
     operator+=(chrono::hours(24 * val));
 }

 /* --------------------------------------------------------------------------
     GETTERS AND TO_STRING
 -------------------------------------------------------------------------- */
 auto Date::toLinuxTime() const -> long long
 {
     std::chrono::system_clock::duration duration = *this - TP_1970;
     std::chrono::seconds seconds = std::chrono::duration_cast<std::chrono::seconds>(duration);

     return seconds.count();
 }
 int Date::getYear() const
 {
     auto &tm = toTM();
     return tm.tm_year + 1900;
 }
 int Date::getMonth() const
 {
     auto &tm = toTM();
     return tm.tm_mon + 1;
 }
 int Date::getDay() const
 {
     auto &tm = toTM();
     return tm.tm_wday;
 }
 int Date::getDate() const
 {
     auto &tm = toTM();
     return tm.tm_mday;
 }

 auto Date::toTM() const -> struct tm
 {
     struct tm tm;
     time_t tt = chrono::system_clock::to_time_t(*this);
     localtime_s(&tm, &tt);

     return tm;
 }
 auto Date::toString() const -> std::string
 {
     return StringUtil::substitute
         (
             "{1}-{2}-{3}",
             getYear(), getMonth(), getDate()
         );
 }
samchon::library::Date::TP_1970
static std::chrono::system_clock::time_point TP_1970
time_point for 1970-01-01 09:00:00
Definition: Date.hpp:48

samchon::library::Date::getYear
auto getYear() const  -> int
Get year of the Date.
Definition: Date.cpp:221

samchon::library::Date::setDate
virtual void setDate(int)
Definition: Date.cpp:168

samchon::library::Date::toLinuxTime
auto toLinuxTime() const  -> long long
Converts the Date to linux_time.
Definition: Date.cpp:214

samchon::library::Date::toTM
auto toTM() const  -> struct::tm
Converts the Date to struct tm.
Definition: Date.cpp:242

std
Definition: RWMutex.hpp:4

samchon::WeakString::split
auto split(const WeakString &delim) const  -> std::vector< WeakString >
Generates substrings.
Definition: WeakString.cpp:212

samchon::library::Date::calcSeconds
static auto calcSeconds(int year, int month, int date) -> long long
Calculates how many seconds have flowen since 0000-01-01 00:00:00.
Definition: Date.cpp:109

samchon::library
Package of libraries.
Definition: library.hpp:84

samchon::library::Date::addDate
virtual void addDate(int)
Add days to the Date.
Definition: Date.cpp:206

samchon::WeakString::find
auto find(const WeakString &delim, size_t startIndex=NULL) const  -> size_t
Finds first occurence in string.
Definition: WeakString.cpp:91

samchon::library::Date::setYear
virtual void setYear(int)
Set year of the Date.
Definition: Date.cpp:131

samchon::library::Date::getDate
auto getDate() const  -> int
Get the day in month of the Date.
Definition: Date.cpp:236

samchon::library::Date::addYear
virtual void addYear(int)
Add years to the Date.
Definition: Date.cpp:174

samchon::library::StringUtil::substitute
static auto substitute(const std::string &format, const T &val, const _Args &...args) -> std::string
Substitutes "{n}" tokens within the specified string with the respective arguments passed in...
Definition: StringUtil.hpp:55

samchon::library::Date::Date
Date()
Default Constructor.
Definition: Date.cpp:18

samchon::library::Date::setMonth
virtual void setMonth(int)
Set month of the Date.
Definition: Date.cpp:150

samchon::library::Date::addMonth
virtual void addMonth(int)
Add months to the Date.
Definition: Date.cpp:179

samchon::WeakString::trim
auto trim(const std::vector< std::string > &delims) const  -> WeakString
Removes all designated characters from the beginning and end of the specified string.
Definition: WeakString.cpp:374

samchon::library::Date::set
void set(const std::string &)
Setter by string.

samchon::library::Date::getMonth
auto getMonth() const  -> int
Get month of the Date.
Definition: Date.cpp:226

samchon::library::Date::calcLastDates
static auto calcLastDates(int year) -> std::array< int, 12 >
Calculates and gets an array of final date of each month for that year.
Definition: Date.cpp:97

samchon::library::Date::toString
virtual auto toString() const  -> std::string
Converts the Date to std::string.
Definition: Date.cpp:250

samchon::library::Date::addWeek
virtual void addWeek(int)
Add weeks to the Date.
Definition: Date.cpp:202

samchon::WeakString::between
auto between(const WeakString &start={}, const WeakString &end={}) const  -> WeakString
Generates a substring.
Definition: WeakString.cpp:194

samchon::library::Date::getDay
auto getDay() const  -> int
Get the day in week of the Date.
Definition: Date.cpp:231

samchon
Top level namespace of products built from samchon.
Definition: ByteArray.hpp:7

samchon::WeakString
A string class only references characeters, reference only.
Definition: WeakString.hpp:32