Remastered-Collection/REDALERT/FTIMER.H

//
// Copyright 2020 Electronic Arts Inc.
//
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
// software: you can redistribute it and/or modify it under the terms of 
// the GNU General Public License as published by the Free Software Foundation, 
// either version 3 of the License, or (at your option) any later version.

// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
// in the hope that it will be useful, but with permitted additional restrictions 
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
// distributed with this program. You should have received a copy of the 
// GNU General Public License along with permitted additional restrictions 
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection

/* $Header: /CounterStrike/FTIMER.H 1     3/03/97 10:24a Joe_bostic $ */
/***********************************************************************************************
 ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
 ***********************************************************************************************
 *                                                                                             *
 *                 Project Name : Command & Conquer                                            *
 *                                                                                             *
 *                    File Name : FTIMER.H                                                     *
 *                                                                                             *
 *                   Programmer : Joe L. Bostic                                                *
 *                                                                                             *
 *                   Start Date : 03/16/95                                                     *
 *                                                                                             *
 *                  Last Update : July 6, 1996 [JLB]                                           *
 *                                                                                             *
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 *   BasicTimerClass<T>::BasicTimerClass -- Constructor for basic timer class.                 *
 *   BasicTimerClass<T>::operator () -- Function operator for timer object.                    *
 *   BasicTimerClass<T>::operator long -- Conversion to long operator.                         *
 *   BasicTimerClass<T>::~BasicTimerClass -- Destructor for basic timer object.                *
 *   TTimerClass<T>::Is_Active -- Checks to see if the timer is counting.                      *
 *   TTimerClass<T>::Start -- Starts (resumes) a stopped timer.                                *
 *   TTimerClass<T>::Stop -- Stops the current timer from incrementing.                        *
 *   TTimerClass<T>::TTimerClass -- Constructor for timer class object.                        *
 *   TTimerClass<T>::operator () -- Function operator for timer object.                        *
 *   TTimerClass<T>::operator long -- Conversion operator for timer object.                    *
 *   CDTimerClass<T>::CDTimerClass -- Constructor for count down timer.                        *
 *   CDTimerClass<T>::Is_Active -- Checks to see if the timer object is active.                *
 *   CDTimerClass<T>::Start -- Starts (resumes) the count down timer.                          *
 *   CDTimerClass<T>::Stop -- Stops (pauses) the count down timer.                             *
 *   CDTimerClass<T>::operator () -- Function operator for the count down timer.               *
 *   CDTimerClass<T>::operator long -- Conversion to long operator function.                   *
 *   CDTimerClass<T>::~CDTimerClass -- Destructor for the count down timer object.             *
 *   TTimerClass<T>::Value -- Returns with the current value of the timer.                     *
 *   CDTimerClass<T>::Value -- Fetches the current value of the countdown timer.               *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#ifndef FTIMER_H
#define FTIMER_H


/*
**	The "bool" integral type was defined by the C++ committee in
**	November of '94. Until the compiler supports this, use the following
**	definition.
*/
#ifndef __BORLANDC__
#ifndef TRUE_FALSE_DEFINED
#define TRUE_FALSE_DEFINED
enum {false=0,true=1};
typedef int bool;
#endif
#endif


/**********************************************************************
**	This class is solely used as a parameter to a constructor that does
**	absolutely no initialization to the object being constructed. By using
**	this method, it is possible to load and save data directly from a
**	class that has virtual functions. The construction process automatically
**	takes care of initializing the virtual function table pointer and the
**	rest of the constructor doesn't initialize any data members. After loading
**	into a class object, simply perform an in-place new operation.
*/
#ifndef NOINITCLASS
#define NOINITCLASS
struct NoInitClass {
	public:
		void operator () (void) const {};
};
#endif


/*
**	This is a timer class that watches a constant rate timer (specified by the parameter
**	type class) and provides basic timer functionality. It is possible to set the start value
**	WITHOUT damaging or otherwise affecting any other timer that may be built upon the same
**	specified timer class object. Treat an object of this type as if it were a "magic" integral
**	long that automatically advances at the speed of the timer class object controlling it.
*/
// Let lint know that non-virtual destructor is OK for this class.
//lint -esym(1509,BasicTimerClass)
template<class T>
class BasicTimerClass {
 	public:
		// Constructor allows assignment as if class was integral 'long' type.
		BasicTimerClass(unsigned long set=0);
		BasicTimerClass(NoInitClass const & );

		~BasicTimerClass(void);

		// Fetch current value of timer.
		unsigned long Value(void) const;

		// Conversion operator to allow consistent treatment with integral types.
		operator unsigned long(void) const;

		// Function operator to allow timer object definition to be cascaded.
		unsigned long operator () (void) const;

	protected:
		T Timer;			// Timer regulator (ticks at constant rate).
		unsigned long Started;	// Time started.
};


template<class T>
inline BasicTimerClass<T>::BasicTimerClass(NoInitClass const & )
{
}


/***********************************************************************************************
 * BasicTimerClass<T>::BasicTimerClass -- Constructor for basic timer class.                   *
 *                                                                                             *
 *    This is the constructor for the basic timer class object. It sets the timer counting     *
 *    up from zero at the rate of the controlling timer class object.                          *
 *                                                                                             *
 * INPUT:   set   -- Alternate initial start value for the counter. If not specified, then     *
 *                   the timer is assumed to start at zero and count upwards.                  *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   02/05/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
//lint -esym(1403,BasicTimerClass<class FrameTimerClass>::Timer)
//lint -esym(1403,BasicTimerClass<class SystemTimerClass>::Timer)
template<class T>
inline BasicTimerClass<T>::BasicTimerClass(unsigned long set) :
	Started(Timer()-set)
{
}


/***********************************************************************************************
 * BasicTimerClass<T>::~BasicTimerClass -- Destructor for basic timer object.                  *
 *                                                                                             *
 *    The destructor for the basic timer object doesn't have to do anything.                   *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   02/05/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
template<class T>
inline BasicTimerClass<T>::~BasicTimerClass(void)
{
}


template<class T>
inline unsigned long BasicTimerClass<T>::Value(void) const
{
	return(Timer()-Started);
}


/***********************************************************************************************
 * BasicTimerClass<T>::operator long -- Conversion to long operator.                           *
 *                                                                                             *
 *    This conversion operator allows the basic timer object to function in much the same      *
 *    manner as the integral "long" type. One can assign a long with a timer object and the    *
 *    actual value of the timer is extracted from the object and used.                         *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with the timer value expressed as a long.                                  *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   02/05/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
template<class T>
inline BasicTimerClass<T>::operator unsigned long(void) const
{
	return(Timer()-Started);
}


/***********************************************************************************************
 * BasicTimerClass<T>::operator () -- Function operator for timer object.                      *
 *                                                                                             *
 *    This function operator allows the timer to also serve as the parameter type class for    *
 *    additional timer objects. This allows one to instantiate a controlling timer class that  *
 *    can control (e.g., turn on or off) all timers that are based upon it.                    *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns the current timer value expressed as a long.                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   02/05/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
template<class T>
inline unsigned long BasicTimerClass<T>::operator () (void) const
{
	return(Timer()-Started);
}


/*
**	This timer class functions similarly to the basic timer class. In addition to the
**	normal timer operation, this class has the ability to be stopped and started at
**	will. If you have no need to start or stop the timer, then use the basic timer
**	class instead.
*/
template<class T>
class TTimerClass : public BasicTimerClass<T> {
 	public:
		// Constructor allows assignment as if class was integral 'long' type.
		TTimerClass(unsigned long set=0);
		TTimerClass(NoInitClass const & x);

		~TTimerClass(void) {};

		// Fetches current value of timer.
		unsigned long Value(void) const;

		// Conversion operator to allow consistent treatment with integral types.
		operator unsigned long(void) const;

		// Function operator to allow timer object definition to be cascaded.
		unsigned long operator () (void) const;

		// Stops (pauses) the timer.
		void Stop(void);

		// Starts (resumes) the timer.
		void Start(void);

		// Queries whether the timer is currently active.
		bool Is_Active(void) const;

	private:
		unsigned long Accumulated;				//	Total accumulated ticks.
};


template<class T>
inline TTimerClass<T>::TTimerClass(NoInitClass const & x) :
	BasicTimerClass<T>(x)
{
}


/***********************************************************************************************
 * TTimerClass<T>::TTimerClass -- Constructor for timer class object.                          *
 *                                                                                             *
 *    This is the constructor for the advanced timer class object. This object class can start *
 *    or stop the timer under user control.                                                    *
 *                                                                                             *
 * INPUT:   set   -- The initial value to set the timer to. If no value is specified, then     *
 *                   the timer is assumed to start from zero.                                  *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   02/05/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
template<class T>
inline TTimerClass<T>::TTimerClass(unsigned long set) :
	BasicTimerClass<T>(set),
	Accumulated(0)
{
}


/***********************************************************************************************
 * TTimerClass<T>::Value -- Returns with the current value of the timer.                       *
 *                                                                                             *
 *    This routine will return with the current value of the timer. It takes into account      *
 *    whether the timer has stopped or not so as to always return the correct value regardless *
 *    of that condition.                                                                       *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with the current value of the timer.                                       *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/06/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
template<class T>
inline unsigned long TTimerClass<T>::Value(void) const
{
	unsigned long value = Accumulated;
	if (Started != 0xFFFFFFFFU) {
		value += BasicTimerClass<T>::Value();
	}
	return(value);
}


/***********************************************************************************************
 * TTimerClass<T>::operator long -- Conversion operator for timer object.                      *
 *                                                                                             *
 *    This conversion operator allows this timer object to function as an "rvalue" of a "long" *
 *    type. This is consistent with the integral "long" value. It is possible to assign a      *
 *    timer object to a long and have the long initialized with the current value of the       *
 *    timer.                                                                                   *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with the current time value expressed as a long.                           *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   02/05/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
template<class T>
inline TTimerClass<T>::operator unsigned long(void) const
{
	unsigned long value = Accumulated;
	if (Started != 0xFFFFFFFFU) {
		value += BasicTimerClass<T>::Value();
	}
	return(value);
}


/***********************************************************************************************
 * TTimerClass<T>::operator () -- Function operator for timer object.                          *
 *                                                                                             *
 *    This function operator for the timer class allows this timer class to be used as the     *
 *    template parameter for other timer class objects. With this ability, one can control     *
 *    several timers (e.g., start or stop them) by using a single controlling timer class      *
 *    that other timers are instantiated from.                                                 *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with the current time expressed as a long.                                 *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   02/05/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
template<class T>
inline unsigned long TTimerClass<T>::operator () (void) const
{
	unsigned long value = Accumulated;
	if (Started != 0xFFFFFFFFU) {
		value += BasicTimerClass<T>::Value();
	}
	return(value);
}


/***********************************************************************************************
 * TTimerClass<T>::Stop -- Stops the current timer from incrementing.                          *
 *                                                                                             *
 *    This routine will stop (pause) the timer from further increments. To cause the timer     *
 *    to begin anew, call the Start() function.                                                *
 *                                                                                             *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   02/05/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
template<class T>
void TTimerClass<T>::Stop(void)
{
	if (Started != 0xFFFFFFFFU) {
		Accumulated += BasicTimerClass<T>::operator unsigned long();
		Started = 0xFFFFFFFFU;
	}
}


/***********************************************************************************************
 * TTimerClass<T>::Start -- Starts (resumes) a stopped timer.                                  *
 *                                                                                             *
 *    This routine will resume a timer that was previously stopped with the Stop() function.   *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   02/06/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
template<class T>
void TTimerClass<T>::Start(void)
{
	if (Started == 0xFFFFFFFFU) {
		Started = Timer();
	}
}


/***********************************************************************************************
 * TTimerClass<T>::Is_Active -- Checks to see if the timer is counting.                        *
 *                                                                                             *
 *    Since this timer can be paused, this routine is used to examine the timer to see if it   *
 *    is currently paused or active. If the timer is active, then the return value will be     *
 *    true.                                                                                    *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  bool; Is this timer currently active?                                              *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   02/06/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
template<class T>
inline bool TTimerClass<T>::Is_Active(void) const
{
	return(Started != 0xFFFFFFFFU);
}


/*
**	This timer counts down from the specified (or constructed) value down towards zero.
**	The countdown rate is controlled by the timer object specified. This timer object can
**	be started or stopped. It can also be tested to see if it has expired or not. An expired
**	count down timer is one that has value of zero. You can treat this class object as if it
**	were an integral "magic" long that automatically counts down toward zero.
*/
template<class T>
class CDTimerClass : public BasicTimerClass<T> {
	public:
		// Constructor allows assignment as if class was integral 'long' type.
		CDTimerClass(unsigned long set=0);
		CDTimerClass(NoInitClass const & x);

		~CDTimerClass(void);

		// Fetches current value of count down timer.
		unsigned long Value(void) const;

		// Conversion operator to allow consistent treatment with integral types.
		operator unsigned long(void) const;

		// Function operator to allow timer object definition to be cascaded.
		unsigned long operator () (void) const;

		// Stops (pauses) the timer.
		void Stop(void);

		// Starts (resumes) the timer.
		void Start(void);

		// Queries whether the timer is currently active.
		bool Is_Active(void) const;

		bool Was_Started(void) const { return WasStarted; }

	private:
		unsigned long DelayTime;			// Ticks remaining before countdown timer expires.
		bool WasStarted;
};


template<class T>
inline CDTimerClass<T>::CDTimerClass(NoInitClass const & x) :
	BasicTimerClass<T>(x), WasStarted(false)
{
}


/***********************************************************************************************
 * CDTimerClass<T>::CDTimerClass -- Constructor for count down timer.                          *
 *                                                                                             *
 *    This is the constructor for the count down timer object. The optional starting value     *
 *    can be used to initiate the timer. Because of this constructor it is possible to assign  *
 *    a long to a count down timer object in order to begin the countdown process.             *
 *                                                                                             *
 * INPUT:   set   -- The initial starting value for the countdown timer.                       *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   02/06/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
template<class T>
inline CDTimerClass<T>::CDTimerClass(unsigned long set) :
	BasicTimerClass<T>(0),
	DelayTime(set),
	WasStarted(false)
{
}


/***********************************************************************************************
 * CDTimerClass<T>::~CDTimerClass -- Destructor for the count down timer object.               *
 *                                                                                             *
 *    The destructor for the count down timer object does nothing.                             *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   02/06/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
template<class T>
inline CDTimerClass<T>::~CDTimerClass(void)
{
}


/***********************************************************************************************
 * CDTimerClass<T>::Value -- Fetches the current value of the countdown timer.                 *
 *                                                                                             *
 *    Use this routine to fetch the current value of the timer. It takes into consideration    *
 *    whether the timer has been stopped or not. It returns the correct value regardless of    *
 *    this condition.                                                                          *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with the correct value of this count down timer.                           *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/06/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
template<class T>
inline unsigned long CDTimerClass<T>::Value(void) const
{
	unsigned long remain = DelayTime;
	if (Started != 0xFFFFFFFFU) {
		unsigned long value = BasicTimerClass<T>::Value();
		if (value < remain) {
			return(remain - value);
		} else {
			return(0);
		}
	}
	return(remain);
}


/***********************************************************************************************
 * CDTimerClass<T>::operator long -- Conversion to long operator function.                     *
 *                                                                                             *
 *    This conversion operator allows the count down timer object to be used as if it were     *
 *    a "magic" long that automatically counted downward at the controller class tick rate.    *
 *    The count down object can be used in any place that an rvalue long could be used.        *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with the current count down time expressed in the form of a long value.    *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   02/06/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
template<class T>
inline CDTimerClass<T>::operator unsigned long(void) const
{
	unsigned long remain = DelayTime;
	if (Started != 0xFFFFFFFFU) {
		unsigned long value = BasicTimerClass<T>::Value();
		if (value < remain) {
			return(remain - value);
		} else {
			return(0);
		}
	}
	return(remain);
}


/***********************************************************************************************
 * CDTimerClass<T>::operator () -- Function operator for the count down timer.                 *
 *                                                                                             *
 *    This is the function operator for the count down timer object. By supporting this        *
 *    function operator, this class (or one derived from this class) could be used as the      *
 *    controlling timer to the timer templates.                                                *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with the current count down time expressed in the form of a long.          *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   02/06/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
template<class T>
inline unsigned long CDTimerClass<T>::operator () (void) const
{
	unsigned long remain = DelayTime;
	if (Started != 0xFFFFFFFFU) {
		unsigned long value = BasicTimerClass<T>::Value();
		if (value < remain) {
			return(remain - value);
		} else {
			return(0);
		}
	}
	return(remain);
}


/***********************************************************************************************
 * CDTimerClass<T>::Stop -- Stops (pauses) the count down timer.                               *
 *                                                                                             *
 *    This routine is used to stop (pause) the count down timer object. A timer object paused  *
 *    in this fashion will be resumed by a call to Start() or by assigning a new count down    *
 *    value to the timer.                                                                      *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   02/06/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
template<class T>
void CDTimerClass<T>::Stop(void)
{
	if (Started != 0xFFFFFFFFU) {
		DelayTime = *this;
		Started = 0xFFFFFFFFU;
	}
}


/***********************************************************************************************
 * CDTimerClass<T>::Start -- Starts (resumes) the count down timer.                            *
 *                                                                                             *
 *    This routine is used to start (resume) the count down timer that was previously stopped  *
 *    with the Stop() function. The timer will also resume when a new timer value is assigned. *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   02/06/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
template<class T>
void CDTimerClass<T>::Start(void)
{
	WasStarted = true;

	if (Started == 0xFFFFFFFFU) {
		Started = Timer();
	}
}


/***********************************************************************************************
 * CDTimerClass<T>::Is_Active -- Checks to see if the timer object is active.                  *
 *                                                                                             *
 *    Because the timer object counting can be stopped, this routine is used to determine      *
 *    if the timer is currently paused or active.                                              *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  bool; Is the timer currently active?                                               *
 *                                                                                             *
 * WARNINGS:   Note that if the timer has counted down to zero, then it may be active, but     *
 *             the value will, naturally, not change.                                          *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   02/06/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
template<class T>
inline bool CDTimerClass<T>::Is_Active(void) const
{
	return(Started != 0xFFFFFFFFU);
}

#endif