ex14_49.h

/***************************************************************************
 *  @file       date.h
 *  @author     Alan.W
 *  @date       15-17  JAN 2014
 *  @remark
 ***************************************************************************/
//
// Exercise 7.40:
// Choose one of the following abstractions (or an abstraction of your own choosing).
// Determine what data are needed in the class. Provide an appropriate set of constructors.
// Explain your decisions.
//
// Exercise 14.5:
// In exercise 7.40 from § 7.5.1 (p. 291) you wrote a sketch of one of the
// following classes. Decide what, if any, overloaded operators your class
// should provide.
//      -   =   <   >   <=  >=  ++  --  <<  >>  ==  !=  +=  -=
// Exercise 14.8:
// Define an output operator for the class you chose in exercise 7.40 from
// § 7.5.1 (p. 291).
//
// Exercise 14.12:
// Define an input operator for the class you used in exercise 7.40 from
// § 7.5.1 (p. 291). Be sure the operator handles input errors.
//
// Exercise 14.15:
// Should the class you chose for exercise 7.40 from § 7.5.1 (p. 291)
// define any of the arithmetic operators? If so, implement them.
// If not, explain why not.
//
//      arithmetic operators :  all non-members
//      +   :   Date + Size
//      -   :   Date - Size
//      -   :   Date - Date
//
// Exercise 14.17:
// Should the class you chose for exercise 7.40 from § 7.5.1 (p. 291) define
// the equality operators? If so, implement them. If not, explain why not.
//
// Exercise 14.19:
// Should the class you chose for exercise 7.40 from § 7.5.1 (p. 291) define
// the relational operators? If so, implement them. If not, explain why not.
//
// Exercise 14.25:
// Implement any other assignment operators your class should define.
// Explain which types should be used as operands and why.
//
// Exercise 14.49:
// Regardless of whether it is a good idea to do so, define a conversion to bool
// for the class from the previous exercise.
//

#ifndef DATE_H
#define DATE_H

#include <iostream>
#include <vector>

class Date
{
    friend  bool            operator ==(const Date& lhs, const Date& rhs);
    friend  bool            operator < (const Date &lhs, const Date &rhs);
    friend  bool            check(const Date &d);
    friend  std::ostream&   operator <<(std::ostream& os, const Date& d);
public:
    typedef std::size_t Size;

    // default constructor
    Date() = default;
    // constructor taking Size as days
    explicit Date(Size days);
    // constructor taking three Size
    Date(Size d, Size m, Size y) : day(d), month(m), year(y) { }
    // constructor taking iostream
    Date(std::istream &is, std::ostream &os);

    // copy constructor
    Date(const Date& d);
    // move constructor
    Date(Date&& d) noexcept;

    // copy operator=
    Date& operator= (const Date& d);
    // move operator=
    Date& operator= (Date&& rhs) noexcept;

    // destructor  --  in this case, user-defined destructor is not nessary.
    ~Date(){ std::cout << "destroying\n"; }

    // members
    Size toDays() const;  //not implemented yet.
    Date& operator +=(Size offset);
    Date& operator -=(Size offset);
    explicit operator bool() { return (year<4000) ? true : false; }

private:
    Size    day = 1;
    Size    month = 1;
    Size    year = 0;
};

static const Date::Size YtoD_400 = 146097;    //365*400 + 400/4 -3 == 146097
static const Date::Size YtoD_100 =  36524;    //365*100 + 100/4 -1 ==  36524
static const Date::Size YtoD_4   =   1461;    //365*4 + 1          ==   1461
static const Date::Size YtoD_1   =    365;    //365

// normal year
static const std::vector<Date::Size> monthsVec_n =
{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

// leap year
static const std::vector<Date::Size> monthsVec_l =
{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

// non-member operators:  <<  >>  -   ==  !=  <   <=  >   >=
//
std::ostream&
operator <<(std::ostream& os, const Date& d);
std::istream&
operator >>(std::istream& is, Date& d);
int
operator - (const Date& lhs, const Date& rhs);
bool
operator ==(const Date& lhs, const Date& rhs);
bool
operator !=(const Date& lhs, const Date& rhs);
bool
operator < (const Date& lhs, const Date& rhs);
bool
operator <=(const Date& lhs, const Date& rhs);
bool
operator  >(const Date& lhs, const Date& rhs);
bool
operator >=(const Date& lhs, const Date& rhs);
Date
operator - (const Date& lhs, Date::Size  rhs);
Date
operator  +(const Date& lhs, Date::Size  rhs);



//  utillities:
bool check(const Date &d);
inline bool
isLeapYear(Date::Size y);




// check if the date object passed in is valid
 inline bool
 check(const Date &d)
 {
     if(d.month==0 || d.month >12)
         return false;
     else
     {
         //    month == 1 3 5 7 8 10 12
         if(d.month==1 || d.month==3 || d.month==5 || d.month==7 ||
            d.month==8 || d.month==10|| d.month==12)
         {
             if(d.day==0 || d.day > 31) return false;
             else
                return true;
         }
         else
         {
             //    month == 4 6 9 11
             if(d.month==4 || d.month==6 || d.month==9 || d.month==11)
             {
                 if(d.day==0 || d.day > 30) return false;
                 else
                     return true;
             }
             else
             {
                 //    month == 2
                 if(isLeapYear(d.year))
                 {
                     if(d.day==0 || d.day >29)  return false;
                     else
                         return true;
                 }
                 else
                 {
                     if(d.day==0 || d.day >28)  return false;
                     else
                         return true;
                 }
             }
         }
     }
 }

 inline bool
 isLeapYear(Date::Size y)
 {
     if (!(y%400))
     {
         return true;
     }
     else
     {
         if(!(y%100))
         {
             return false;
         }
         else
             return !(y%4);
     }
 }
#endif // DATE_H