/* This file provides the implementation for class Day.

------------------------------------------------------------------*/

#include "Day.h"

/*-----------------------------------------------------------------
   This function overloads the assignment operator for Day values.

   Receive: DayExp, the Day value being assigned
   Return:  The Day object with its data member set equal
              to the data member in DayExp
------------------------------------------------------------------*/

Day& Day::operator=(const Day& DayExp)
{
   DayValue_ = DayExp.DayValue_;// set DayValue_ member in this
                                //   object to that in DayExp
   return *this;                // return this object
}

/*-----------------------------------------------------------------
   This function (destructively) prefix-increments a Day object.

   Return:  The Day object containing this function,
              with DayValue changed to the next value
------------------------------------------------------------------*/

Day Day::operator++(void)
{
  switch(DayValue_)            // change DayValue to its successor
  {
    case Sunday:
      DayValue_ = Monday;
      break;
    case Monday:
      DayValue_ = Tuesday;
      break;
    case Tuesday:
      DayValue_ = Wednesday;
      break;
    case Wednesday:
      DayValue_ = Thursday;
      break;
    case Thursday:
      DayValue_ = Friday;
      break;
    case Friday:
      DayValue_ = Saturday;
      break;
    case Saturday:             // unless it's the final valid DayName
      DayValue_ = DayOverflow;
      break;
    default:
      cerr << "*** ++: erroneous Day value received!\n";
  }
  return *this;
}

/*----------------------------------------------------------------
   This function (destructively) postfix-increments a Day object.

   Return:  The Day object containing this function,
            with DayValue changed to the next value.
-----------------------------------------------------------------*/

Day Day::operator++(int)
{
  switch(DayValue_)            // change DayValue to its successor
  {
    case Sunday:
      DayValue_ = Monday;
      return Sunday;
    case Monday:
      DayValue_ = Tuesday;
      return Monday;
    case Tuesday:
      DayValue_ = Wednesday;
      return Tuesday;
    case Wednesday:
      DayValue_ = Thursday;
      return Wednesday;
    case Thursday:
      DayValue_ = Friday;
      return Thursday;
    case Friday:
      DayValue_ = Saturday;
      return Friday;
    case Saturday:            // unless it's the final valid DayName
      DayValue_ = DayOverflow;
      return Saturday;
    default:
      cerr << "*** ++: erroneous Day value received!\n";
      return DayOverflow;
  }
}

/*-----------------------------------------------------------------
   This function (nondestructively) returns the day after its
      Day object, wrapping around from Saturay to Sunday.

   Return:  The Day value that follows the value of this
            Day object.
------------------------------------------------------------------*/

Day Day::Next(void) const
{
  switch(DayValue_)     // return the DayName that follows DayValue_
  {
    case Sunday:
      return Monday;
    case Monday:
      return Tuesday;
    case Tuesday:
      return Wednesday;
    case Wednesday:
      return Thursday;
    case Thursday:
      return Friday;
    case Friday:
      return Saturday;
    case Saturday:
      return Sunday;    // ...wrapping around for the last DayName
    default:
      cerr << "*** Next: erroneous Day value received!\n";
      return DayOverflow;
  }
}

// ... remaining definitions are left as exercises ...