gdate.cpp

Go to the documentation of this file.

//
// Copyright (C) 2017 Graeme Walker
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program 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 General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
// ===
//
// gdate.cpp
//

#include "gdef.h"
#include "gdate.h"
#include "gdebug.h"
#include <ctime>
#include <iomanip>
#include <sstream>

int G::Date::yearUpperLimit()
{
    return 2035 ; // see mktime()
}

int G::Date::yearLowerLimit()
{
    return 1970 ; // see mktime()
}

G::Date::Date()
{
    init( G::DateTime::utc(G::DateTime::now()) ) ;
}

G::Date::Date( G::EpochTime t )
{
    init( G::DateTime::utc(t) ) ;
}

G::Date::Date( G::EpochTime t , const LocalTime & )
{
    init( G::DateTime::local(t) ) ;
}

G::Date::Date( const G::DateTime::BrokenDownTime & tm )
{
    init( tm ) ;
}

G::Date::Date( const LocalTime & )
{
    init( G::DateTime::local(G::DateTime::now()) ) ;
}

G::Date::Date( int year , G::Date::Month month , int day_of_month )
{
    G_ASSERT( year >= yearLowerLimit() ) ;
    G_ASSERT( year <= yearUpperLimit() ) ;
    m_year = year ;

    G_ASSERT( day_of_month > 0 ) ;
    G_ASSERT( day_of_month < 32 ) ;
    m_day = day_of_month ;

    G_ASSERT( month >= 1 ) ;
    G_ASSERT( month <= 12 ) ;
    m_month = month ;

    m_weekday_set = false ;
}

void G::Date::init( const G::DateTime::BrokenDownTime & tm )
{
    m_year = tm.tm_year + 1900 ;
    m_month = tm.tm_mon + 1 ;
    m_day = tm.tm_mday ;
    m_weekday_set = false ;
    m_weekday = sunday ;
}

std::string G::Date::string( Format format ) const
{
    std::ostringstream ss ;
    if( format == yyyy_mm_dd_slash )
    {
        ss << yyyy() << "/" << mm() << "/" << dd() ;
    }
    else if( format == yyyy_mm_dd )
    {
        ss << yyyy() << mm() << dd() ;
    }
    else if( format == mm_dd )
    {
        ss << mm() << dd() ;
    }
    else
    {
        G_ASSERT( "enum error" == 0 ) ;
    }
    return ss.str() ;
}

int G::Date::monthday() const
{
    return m_day ;
}

std::string G::Date::dd() const
{
    std::ostringstream ss ;
    ss << std::setw(2) << std::setfill('0') << m_day ; 
    return ss.str() ;
}

std::string G::Date::mm() const
{
    std::ostringstream ss ;
    ss << std::setw(2) << std::setfill('0') << m_month ; 
    return ss.str() ;
}

G::Date::Weekday G::Date::weekday() const
{
    if( ! m_weekday_set )
    {
        G::DateTime::BrokenDownTime tm ;
        tm.tm_year = m_year - 1900 ;
        tm.tm_mon = m_month - 1 ;
        tm.tm_mday = m_day ;
        tm.tm_hour = 12 ;
        tm.tm_min = 0 ;
        tm.tm_sec = 0 ;
        tm.tm_wday = 0 ; // ignored
        tm.tm_yday = 0 ; // ignored
        tm.tm_isdst = 0 ; // ignored

        G::DateTime::BrokenDownTime out = G::DateTime::utc(G::DateTime::epochTime(tm)) ;

        const_cast<Date*>(this)->m_weekday_set = true ;
        const_cast<Date*>(this)->m_weekday = Weekday(out.tm_wday) ;
    }
    return m_weekday ;
}

std::string G::Date::weekdayName( bool brief ) const
{
    if( weekday() == sunday ) return brief ? "Sun" : "Sunday" ;
    if( weekday() == monday ) return brief ? "Mon" : "Monday" ;
    if( weekday() == tuesday ) return brief ? "Tue" : "Tuesday" ;
    if( weekday() == wednesday ) return brief ? "Wed" : "Wednesday" ;
    if( weekday() == thursday ) return brief ? "Thu" : "Thursday" ;
    if( weekday() == friday ) return brief ? "Fri" : "Friday" ;
    if( weekday() == saturday ) return brief ? "Sat" : "Saturday" ;
    return "" ;
}

G::Date::Month G::Date::month() const
{
    return Month(m_month) ;
}

std::string G::Date::monthName( bool brief ) const
{
    if( month() == january ) return brief ? "Jan" : "January" ;
    if( month() == february ) return brief ? "Feb" : "February" ;
    if( month() == march ) return brief ? "Mar" : "March" ;
    if( month() == april ) return brief ? "Apr" : "April" ;
    if( month() == may ) return brief ? "May" : "May" ;
    if( month() == june ) return brief ? "Jun" : "June" ;
    if( month() == july ) return brief ? "Jul" : "July" ;
    if( month() == august ) return brief ? "Aug" : "August" ;
    if( month() == september ) return brief ? "Sep" : "September" ;
    if( month() == october ) return brief ? "Oct" : "October" ;
    if( month() == november ) return brief ? "Nov" : "November" ;
    if( month() == december ) return brief ? "Dec" : "December" ;
    return "" ;
}

int G::Date::year() const
{
    return m_year ;
}

std::string G::Date::yyyy() const
{
    std::ostringstream ss ;
    ss << std::setw(4) << std::setfill('0') << m_year ; 
    return ss.str() ;
}

G::Date & G::Date::operator++()
{
    ++m_day ;
    if( m_day == (lastDay(m_month,m_year)+1) )
    {
        m_day = 1 ;
        ++m_month ;
        if( m_month == 13 )
        {
            m_month = 1 ;
            ++m_year ;
        }
    }
    if( m_weekday_set )
    {
        if( m_weekday == saturday )
            m_weekday = sunday ;
        else
            m_weekday = Weekday(int(m_weekday)+1) ;
    }
    return *this ;
}

G::Date & G::Date::operator--()
{
    if( m_day == 1 )
    {
        if( m_month == 1 )
        {
            m_year-- ;
            m_month = 12 ;
        }
        else
        {
            m_month-- ;
        }

        m_day = lastDay( m_month , m_year ) ;
    }
    else
    {
        m_day-- ;
    }
    if( m_weekday_set )
    {
        if( m_weekday == sunday )
            m_weekday = saturday ;
        else
            m_weekday = Weekday(int(m_weekday)-1) ;
    }
    return *this ;
}

int G::Date::lastDay( int month , int year )
{
    int end = 30 ;
    if( month == 1 || 
        month == 3 || 
        month == 5 || 
        month == 7 ||
        month == 8 || 
        month == 10 || 
        month == 12 )
    {
        end = 31 ;
    }
    else if( month == 2 )
    {
        end = isLeapYear(year) ? 29 : 28 ;
    }
    return end ;
}

bool G::Date::isLeapYear( int y )
{
    return y >= 1800 && ( y % 400 == 0 || ( y % 100 != 0 && y % 4 == 0 ) ) ;
}

bool G::Date::operator==( const Date &other ) const
{
    return
        year() == other.year() &&
        month() == other.month() &&
        monthday() == other.monthday() ;
}

bool G::Date::operator!=( const Date &other ) const
{
    return !( other == *this ) ;
}

/// \file gdate.cpp