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>
#include <cstdlib>
 
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);
          
          y += n / 12;
 
          unsigned deltaM = static_cast<unsigned>( std::abs(n) % 12 );
 
          if(n < 0)
          {
              if(m <= deltaM)
              {
                  m += 12;
                  y -= 1;
              }
 
              m -= deltaM;
          }
          else
          {
              m += deltaM;
 
              if(m > 12)
              {
                  m -= 12;
                  y += 1;
              }
          }
 
          Date dt(y, m, 1);
          unsigned maxDays = dt.daysInMonth();
          if(d > maxDays)
          {
              d = maxDays;
          }
 
          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