root/trunk/Time.java

/*-**************************************************************************************
 *                                                                                      Time.java                                                                       
 *
 * CLASS: Time                                                                                          Andres J. Tack  
 *                                                                                                                      February, 2005  
 *                                                                                                                      SIGSoft, ACM @ UIUC     
 *                                                                                      
 * This is an object to store time; it may be relative, it can be absolute.  At the     
 * core, it tracks minutes, hours, and seconds.                                         
 *                                                                                      
 *      METHODS AVAILABLE:                                                              
 *      Constructors:           - Time()  Defaults to zero time.                        
 *                              - Time(hours, minutes, seconds)  Initializes            
 *                                                                              
 *      Operations:             
 *                      equalsTime(Time)                doesNotEqualTime(Time)
 *                      getSumWithTime(Time)    sumTogetherWithTime(Time)
 *                      assignTime(Time)                
 *                      isLessThanTime(Time)    isLessThanOrEqualToTime(Time)
 *                      isGreaterThanTime(Time) isGreaterThanOrEqualToTime(Time)
 *                                                                                      
 *      Accessors:              - getSeconds()                                          
 *                              - getMinutes()                                          
 *                              - getHours()                                    
 *                                                                                      
 *      Other:                  - timeDifferenceBetween(time2) Get a Time object        
 *                                      representing the difference between the         
 *                                      current object and time2.       
 ****************************************************************************************/
public class Time
{


/**
 * DEFAULT CONSTRUCTOR
 *
 * The default time is zeros all across.
 */
public Time()
{
        hours = 0;
        minutes = 0;
        seconds = 0;
}

/**
 * CONSTRUCTOR
 * @param givenHour Of type int, represents hours of time.
 * @param givenMinute Of type int, represents minutes of time.
 * @param givenSecond Of type int, represents seconds...
 *
 * This constructor will create a Time object with valid value.
 */
public Time(int givenHours, int givenMinutes, int givenSeconds)
{       
        // Initialize everything to zero.
        hours = minutes = seconds = 0;
        // Check for bad values; note that we assume positives.
        for ( this.seconds = givenSeconds;
                  this.seconds >= 60;
                  seconds -= 60 )
                ++minutes;
        
        for ( this.minutes += givenMinutes;
                  this.minutes >= 60;
                  this.minutes -= 60 )
                ++hours;
        
        this.hours += givenHours;
}


/**
 * METHOD timeDifferenceFrom
 * @param time2 The other end of the time difference.
 *
 * Returns a Time object with value equivalent to the time difference
 * between the parameter and the current instance.  The order of the time does not matter.
 */
public Time timeDifferenceFrom(Time time2)
{
        // We always want the lesser time to be the parameter!
        // This because our algorithm works this way.
        if ( time2.isGreaterThanTime(this) )
                return time2.timeDifferenceFrom(this);
        else
        {
                // Start by subtracting the hours simply
                int hoursDiff = this.hours - time2.hours;
                
                
                // Now we check to see if minutes are inverted.
                // We don't have to worry about taking the hours less than
                // zero because we know THIS is the greater time.
                int minutesDiff;
                
                if ( time2.minutes > this.minutes )     {
                        hoursDiff--;
                        minutesDiff = 60 - ( time2.minutes - this.minutes );
                }
                else
                        minutesDiff = this.minutes - time2.minutes;
                        
                
                // Repeat the above for seconds.
                int secondsDiff;
                
                if ( time2.seconds > this.seconds )     {
                        minutesDiff--;
                        secondsDiff = 60 - ( time2.seconds - this.seconds );
                }
                else
                        secondsDiff = this.seconds - time2.seconds;
                
                // We return the difference.
                Time diffTime = new Time( hoursDiff, minutesDiff, secondsDiff );
                return diffTime;
        }
}

/**
 * equalsTime(Time otherTime)
 *
 * @param otherTime This is the other time considered in the test.
 * 
 * Two times are equal if all of their components are equal (hours,
 * minutes, seconds).  In all other cases, the comparison is false.
 */
public boolean equalsTime(Time otherTime)
{
        // Check for any difference in time members.
        if ( otherTime.hours != this.hours              ||
                  otherTime.minutes != this.minutes     ||
                  otherTime.seconds != this.seconds )
                return false;

        // If we get this far, these Times are equal
        else
                return true;
}




/**
 *  doesNotEqualTime( Time operand2 )
 *
 *      @param operand2 The other time to be considered in this test.
 *
 *  Form: Time != Time
 */
public boolean doesNotEqualTime(Time otherTime)
{
        return !(this.equalsTime(otherTime));
}




/*-
 * getSumWithTime( Time operand2 )
 *
 *      Equivalent to the + operator, this performs the addition of 'this' time and
 *  the parameterized time.  The result is not assigned to 'this'.
 *
 *      @param operand2 This is the other time being summed with the current.
 * 
 * Seconds are kept less than sixty, always.  Minutes are kept less than sixty.
 * Hours are NOT capped.  You can have as many hours as you want.
 */
public Time getSumWithTime( Time operand2 )
{
                // These three ints hold the sums of the different time components
                int secondsAdded = 0;
                int minutesAdded = 0;
                int hoursAdded = 0;
                
        // We start out at the smallest level, adding seconds.
                secondsAdded = this.seconds + operand2.seconds;
        
        // Now see if we need to normalize below 60 again for SECONDS
        if (secondsAdded >= 60)  {
            // We depend on the fact that every Time object should be normalized.
            minutesAdded += 1;
            secondsAdded -= 60;
        }
        
        // Repeat above for minutes
        minutesAdded += this.minutes + operand2.minutes;
        if ( minutesAdded >= 60 )    {
            hoursAdded += 1;
            minutesAdded -= 60;
        }
        
        // Hours are simple; we can have as many as necessary.
        hoursAdded += this.hours + operand2.hours;
                
                
                // We return the time object which we got.
                Time sumTime = new Time(hoursAdded, minutesAdded, secondsAdded);
                return sumTime;
}
    

    
/**
 * sumTogetherWithTime( Time operand2 )
 *
 *      @param operand2 This is the time with which 'this' will be summed.
 *
 *      @returns this
 * 
 * This performs the correct addition of two Time objects.  Seconds
 * are kept less than sixty, always.  Minutes are kept less than sixty.
 * Hours are NOT capped.  You can have as many hours as you want.
 *
 * The result of the addition, in this case, is stored in THIS object.
 */
public Time sumTogetherWithTime ( Time operand2 )
{
        this.seconds = this.getSumWithTime(operand2).seconds;
        this.minutes = this.getSumWithTime(operand2).minutes;
        this.hours = this.getSumWithTime(operand2).hours;
        
        return this;
}



/*-
 * assignTime( Time newTime )
 *
 * @param newTime The new time which will be assigned to 'this'
 * 
 * The assignment is a simple copy of one Time to another.
 */
public void assignTime( Time newTime )
{
        this.seconds = newTime.seconds;
        this.minutes = newTime.minutes;
        this.hours = newTime.hours;
}



/*_
 *      isLessThanTime( Time operand2 )
 *
 *      @param operand2 The other time which is being tested against this one.
 *
 *      @returns true if 'this' is less than operand2
 *      @returns false otherwise
 *
 *      Relational operator, works like the times of day. (16:50:04 is less than 17:05:06)
 */
public boolean isLessThanTime ( Time operand2 )
{
        if ( this.hours < operand2.hours )
                return true;
        else if ( this.hours == operand2.hours )        {
                if ( this.minutes < operand2.minutes )
                        return true;
                else if ( this.minutes == operand2.minutes )    {
                        if ( this.seconds < operand2.seconds )
                                return true;
                        else
                                return false;
                }
                else
                        return false;
        }
        else
                return false;
}



/*_
 *      isLessThanOrEqualToTime( Time operand2 )
 *
 *      @param operand2 the other time which is being tested against this one.
 *
 *      @returns true if 'this' is less than or equal to operand2
 *      @returns false otherwise.
 *
 * Relational operator, works like the times of day.
 */
public boolean isLessThanOrEqualToTime( Time operand2 )
{
        if (    this.isLessThanTime(operand2)   ||
                        this.equalsTime(operand2)       )
                return true;
        else
                return false;
}


/*_
 *      isGreaterThanTime( Time operand2 )
 *
 *      @param operand2 The other time that 'this' is being compared to.
 *
 *      @returns true if 'this' is strictly greater than operand2
 *      @returns false otherwise
 *
 *      Relational operator, works like the times of day. (18:50:04 is greater than 17:05:06)
 */
public boolean isGreaterThanTime( Time operand2 )
{
        if (    !(this.isLessThanTime(operand2) )       &&
                        !(this.equalsTime(operand2)     )       )
                return true;
        else
                return false;
}



/*_
 * isGreaterThanOrEqualToTime( Time operand2 )
 *
 *      @param operand2 The other time that 'this' is being compared to.
 *
 *      @returns true if 'this' is either greater than or equal to operand2.
 *      @returns false otherwise
 *
 * Relational operator, works like the times of day. (16:50:04 is less than 17:05:06)
 */
public boolean isGreaterThanOrEqualToTime( Time operand2 )
{
        if (    !( this.isLessThanTime(operand2) )      )
                return true;
        else
                return false;
}



/*_
 * METHOD: getSeconds()
 *
 * Accessor Function.
 */
public int getSeconds()
{
        return seconds;
}


/*_
 * METHOD: getMinutes()
 *
 * Accessor Function.
 */
public int getMinutes()
{
        return minutes;
}


/*_
 * METHOD: getHours()
 *
 * Accessor Function.
 */
public int getHours()
{
        return hours;
}

    
/***********************************/
/****** DATA MEMBERS BELOW!!! ******/
/***********************************/
        private int hours;
        private int minutes;
        private int seconds;
}