Date.h

/*
 * Copyright (C) 2004-2008 Marc Boris Duerner
 * 
 * This library 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 2.1 of the License, or (at your option) any later version.
 * 
 * As a special exception, you may use this file as part of a free
 * software library without restriction. Specifically, if other files
 * instantiate templates or use macros or inline functions from this
 * file, or you compile this file and link it with other files to
 * produce an executable, this file does not by itself cause the
 * resulting executable to be covered by the GNU General Public
 * License. This exception does not however invalidate any other
 * reasons why the executable file might be covered by the GNU Library
 * General Public License.
 * 
 * This library 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 this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef PT_DATE_H
#define PT_DATE_H

#include <Pt/Api.h>
#include <Pt/String.h>
#include <string>
#include <stdexcept>

namespace Pt {

class SerializationInfo;

class PT_API InvalidDate : public std::runtime_error
{
    public:
        InvalidDate();

        ~InvalidDate() throw()
        {}
};

PT_API std::string dateToString(const Date& date);

PT_API Date dateFromString(const std::string& s);

PT_API void greg2jul(unsigned& jd, int y, int m, int d);

PT_API void jul2greg(unsigned jd, int& y, int& m, int& d);

class Date
{
    public:
        enum Month
        {
            Jan = 1, Feb, Mar,  Apr, May, Jun,
            Jul, Aug, Sep, Oct, Nov, Dec
        };

        enum WeekDay
        {
            Sun = 0, Mon, Tue, Wed, Thu, Fri, Sat
        };

        static const unsigned DaysPerYear = 365;

        static const unsigned DaysPerLeapYear = 366;

        static const unsigned DaysOfJan = 31;

        static const unsigned DaysOfFeb = 28;

        static const unsigned DaysOfLeapFeb = 29;

        static const unsigned DaysOfMar = 31;

        static const unsigned DaysOfApr = 30;

        static const unsigned DaysOfMay = 31;

        static const unsigned DaysOfJun = 30;

        static const unsigned DaysOfJul = 31;

        static const unsigned DaysOfAug = 31;

        static const unsigned DaysOfSep = 30;

        static const unsigned DaysOfOct = 31;

        static const unsigned DaysOfNov = 30;

        static const unsigned DaysOfDec = 31;

    public:
        Date()
        : _julian(0)
        {}

        Date(const Date& date)
        : _julian(date._julian)
        {}

        Date(int y, unsigned m, unsigned d)
        : _julian(0)
        {
            greg2jul(_julian, y, m, d);
        }

        explicit Date(unsigned julianDays)
        : _julian(julianDays)
        {}

        Date& operator=(const Date& date)
        { _julian = date._julian; return *this; }

        void setJulian(unsigned d)
        { _julian=d; }

        unsigned julian() const
        { return _julian; }

        void set(int y, unsigned m, unsigned d)
        {
            greg2jul(_julian, y, m, d);
        }

        void get(int& year, unsigned& month, unsigned& day) const;

        unsigned day() const;

        unsigned month() const;

        int year() const;

        unsigned dayOfWeek() const;

        unsigned daysInMonth() const;

        unsigned dayOfYear() const;

        bool isLeapYear() const;

        void addDays(int n)
        { _julian += n; }

        void addMonths(int n)
        {
          int y = 0;
          unsigned m = 0, d = 0;
          get(y, m, d);
          
          m += n % 12;
          y += n / 12;
          
          if ( m > 12 )
          {
            m -= 12;
            y += 1;
          }

          set(y, m, d);
        }

        void addYears(int n)
        {
          int y = 0;
          unsigned m = 0, d = 0;
          get(y, m, d);
          y += n;
          set(y, m, d);
        }

        std::string toIsoString() const
        { return dateToString(*this); }

        static Date fromIsoString(const std::string& s)
        { return dateFromString(s); }

        Date& operator+=(int days)
        { _julian += days; return *this; }

        Date& operator-=(int days)
        { _julian -= days; return *this; }

        Date& operator++()
        { _julian++; return *this; }

        Date& operator--()
        { _julian--; return *this; }

        static bool isValid(int y, int m, int d);

        static bool isLeapYear(int year);

    private:
        unsigned _julian;
};

PT_API void operator >>=(const SerializationInfo& si, Date& date);

PT_API void operator <<=(SerializationInfo& si, const Date& date);


inline bool operator==(const Date& a, const Date& b)
{ return a.julian() == b.julian(); }

inline bool operator!=(const Date& a, const Date& b)
{ return a.julian() != b.julian(); }

inline bool operator<(const Date& a, const Date& b)
{ return a.julian() < b.julian(); }

inline bool operator<=(const Date& a, const Date& b)
{ return a.julian() <= b.julian(); }

inline bool operator>(const Date& a, const Date& b)
{ return a.julian() > b.julian(); }

inline bool operator>=(const Date& a, const Date& b) 
{ return a.julian() >= b.julian(); }

inline Date operator+(const Date& d, int days)
{ return Date(d.julian() + days); }

inline Date operator+(int days, const Date& d)
{ return Date(days + d.julian()); }

inline int operator-(const Date& a, const Date& b)
{ return a.julian() - b.julian(); }


inline void Date::get(int& y, unsigned& m, unsigned& d) const
{
    int mon, day_;
    jul2greg(_julian, y, mon, day_);
    m = mon;
    d = day_;
}


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


inline unsigned Date::day() const
{
    int d,m,y;
    jul2greg(_julian, y ,m, d);
    return d;
}


inline unsigned Date::month() const
{
    int d,m,y;
    jul2greg(_julian, y, m, d);
    return m;
}


inline int Date::year() const
{
    int d,m,y;
    jul2greg(_julian, y, m, d);
    return y;
}


inline unsigned Date::dayOfWeek() const
{
    return (_julian+1) % 7;
}


inline unsigned Date::daysInMonth() const
{
    static const unsigned char monthDays[13]=
    {
        0,31,28,31,30,31,30,31,31,30,31,30,31
    };

    int y, m, d;
    jul2greg(_julian, y, m, d);

    if( m==2 && isLeapYear(y) )
        return 29;

    return monthDays[m];
}


inline unsigned Date::dayOfYear() const
{
    int y,m,d;
    unsigned jd;
    jul2greg(_julian,y,m,d);

    greg2jul(jd,y,1,1);
    return _julian-jd+1;
}


inline bool Date::isLeapYear() const
{
    int d,m,y;
    jul2greg(_julian,y,m,d);
    return isLeapYear(y);
}


inline bool Date::isValid(int, int m, int d)
{
    if(m<1 || m>12 || d<1 || d>31)
    {
        return false;
    }

    return true;
}

} // namespace Pt

#endif // PT_DATE_H