mirror of
https://github.com/electronicarts/CnC_Remastered_Collection
synced 2024-04-29 09:52:36 +12:00
03416d24e1
Initial commit of original Tiberian Dawn and Red Alert source code converted to build as DLLs, and compatible with the release version of Command & Conquer Remastered.
273 lines
16 KiB
C++
273 lines
16 KiB
C++
//
|
|
// 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: F:\projects\c&c\vcs\code\queue.h_v 2.16 16 Oct 1995 16:45:50 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 : QUEUE.H *
|
|
* *
|
|
* Programmer : Joe L. Bostic *
|
|
* *
|
|
* Start Date : 12/08/94 *
|
|
* *
|
|
* Last Update : December 9, 1994 [JLB] *
|
|
* *
|
|
*---------------------------------------------------------------------------------------------*
|
|
* Functions: *
|
|
* QueueClass<T,size>::Add -- Add object to queue. *
|
|
* QueueClass<T,size>::First -- Fetches reference to first object in list. *
|
|
* QueueClass<T,size>::Init -- Initializes queue to empty state. *
|
|
* QueueClass<T,size>::Next -- Throws out the head of the line. *
|
|
* QueueClass<T,size>::operator[] -- Fetches reference to sub object in queue. *
|
|
* QueueClass<T,size>::QueueClass -- Default constructor for QueueClass objects. *
|
|
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
|
|
|
#ifndef QUEUE_H
|
|
#define QUEUE_H
|
|
|
|
#include "mission.h"
|
|
#include "target.h"
|
|
#include "defines.h"
|
|
|
|
//#pragma warn -inl
|
|
|
|
/*
|
|
** This class implements a classic FIFO queue (also known as - standing in line). Objects
|
|
** are added to the end (tail) of the line. Objects are removed from the start (first) of
|
|
** the line. A keyboard buffer is a good example of a common computer use of a queue. There
|
|
** is no provision for "taking cuts" or leaving the line once an object has been added.
|
|
**
|
|
** The implementation uses a circular list of objects. This allows adding and deleting of
|
|
** elements without any maintenance moves of remaining objects that would otherwise be
|
|
** necessary in a simple array storage method. A side effect of this means that accessing the
|
|
** internal array directly is not allowed. Supporting functions are provided for this purpose.
|
|
**
|
|
** WARNING WARNING WARNING WARNING!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
** The size parameter MUST be an exact power of two (2, 4, 8, 16, etc.) otherwise the internal
|
|
** indexing algorithm will fail.
|
|
*/
|
|
template<class T, int size>
|
|
class QueueClass
|
|
{
|
|
public:
|
|
/*
|
|
** This is the count of the number of objects in the queue. If this count is zero,
|
|
** then the operator[], First(), and Next() functions are undefined. Check this
|
|
** value BEFORE calling these functions.
|
|
*/
|
|
const int Count;
|
|
|
|
//-------------- Functions --------------------
|
|
QueueClass(void); // Default constructor.
|
|
|
|
/*
|
|
** The bracket subscript operator functions similarly to the way a normal subscript
|
|
** operator works except that entry [0] matches the first-in-line and entry
|
|
** [Count-1] matches the last-in-line. This is ensured regardless of the actual position
|
|
** of the object in the circular internal list.
|
|
*/
|
|
T & operator[](int);
|
|
|
|
/*
|
|
** This function will return a reference to the "head of the line" object.
|
|
*/
|
|
T & First(void);
|
|
|
|
/*
|
|
** This function clears the list of objects.
|
|
*/
|
|
void Init(void);
|
|
|
|
/*
|
|
** This function discards the head-of-the-line object and advances all the remaining
|
|
** objects up by one. Mnemonic: Imagine a broadway audition and the director yells
|
|
** "NEXT!"
|
|
*/
|
|
int Next(void);
|
|
|
|
/*
|
|
** This will add an object to the tail of the line. If there is no more room to add
|
|
** the object, then false will be returned.
|
|
*/
|
|
int Add(T const &);
|
|
|
|
private:
|
|
int Head; // Index of element in list the longest.
|
|
int Tail; // Index where next new addition will go.
|
|
|
|
T Array[size]; // Raw array of objects.
|
|
};
|
|
|
|
|
|
/***********************************************************************************************
|
|
* QueueClass<T,size>::QueueClass -- Default constructor for QueueClass objects. *
|
|
* *
|
|
* This default constructor for QueueClass objects initializes the queue to an empty *
|
|
* state. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 12/09/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T, int size>
|
|
inline QueueClass<T,size>::QueueClass(void) : Count(0)
|
|
{
|
|
Init();
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* QueueClass<T,size>::Init -- Initializes queue to empty state. *
|
|
* *
|
|
* This function resets the queue to an empty state. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 12/09/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T, int size>
|
|
inline void QueueClass<T,size>::Init(void)
|
|
{
|
|
((int &)Count) = 0;
|
|
Head = 0;
|
|
Tail = 0;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* QueueClass<T,size>::Add -- Add object to queue. *
|
|
* *
|
|
* This function is used to add an object to the tail of the line. If the queue cannot *
|
|
* accept any more entries, then the object won't be added and false will be returned. *
|
|
* *
|
|
* INPUT: object -- The object that is to be added to the queue. *
|
|
* *
|
|
* OUTPUT: bool; Was the object added successfully? *
|
|
* *
|
|
* WARNINGS: If the queue is full, then the object won't be added. Be sure to check for this.*
|
|
* *
|
|
* HISTORY: *
|
|
* 12/09/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T, int size>
|
|
inline int QueueClass<T,size>::Add(T const &q)
|
|
{
|
|
if (Count < size) {
|
|
Array[Tail] = q;
|
|
Tail = (Tail + 1) & (size-1);
|
|
((int &)Count) = Count + 1;
|
|
return(true);
|
|
}
|
|
Mono_Printf( "Queue Add failed Count %d size %d tail %d head %d \n",
|
|
Count, size, Tail, Head );
|
|
return (false);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* QueueClass<T,size>::Next -- Throws out the head of the line. *
|
|
* *
|
|
* This routine is used to discard the object at the head of the line. All remaining *
|
|
* objects "move up" one. No actual movement occurs, merely the index is adjusted, but *
|
|
* the affect is that the next oldest object in the queue will now be returned with the *
|
|
* next call to the First() function. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: Returns the number of object remaining in the queue. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 12/09/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T, int size>
|
|
inline int QueueClass<T,size>::Next(void)
|
|
{
|
|
if (Count) {
|
|
Head = (Head + 1) & (size-1);
|
|
((int &)Count) = Count - 1;
|
|
}
|
|
return (Count);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* QueueClass<T,size>::operator[] -- Fetches reference to sub object in queue. *
|
|
* *
|
|
* Use this routine to examine individual objects within the queue. The oldest object in *
|
|
* the queue is referenced by an index value of zero. The newest object in the queue is *
|
|
* referenced by a value of Count-1. If there are no objects in the queue, then this *
|
|
* operator is undefined. Although this operator allows examination of the queue, there is *
|
|
* no corresponding ability to insert or delete objects from the middle of the queue. *
|
|
* *
|
|
* INPUT: index -- The index into the queue of objects. Valid values range from zero to *
|
|
* Count-1. All other values return an undefined reference! *
|
|
* *
|
|
* OUTPUT: Returns with a reference to the object indicated by the index. *
|
|
* *
|
|
* WARNINGS: Check to make sure that Count is not zero before using this operator. Failure *
|
|
* to do so will return a reference to an undefined object. *
|
|
* *
|
|
* HISTORY: *
|
|
* 12/09/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T, int size>
|
|
inline T & QueueClass<T,size>::operator[](int index)
|
|
{
|
|
return Array[(Head + index) & (size-1)];
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* QueueClass<T,size>::First -- Fetches reference to first object in list. *
|
|
* *
|
|
* This routine is used to fetch the first object in the list (head of the line). This *
|
|
* object is the oldest in the list. Typical use of this function is to get and process *
|
|
* the first object so that it may be discarded with the Next() function in order to bring *
|
|
* subsequent objects to the first position. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: Returns with a reference to the oldest object in the queue. *
|
|
* *
|
|
* WARNINGS: If there are no objects in the queue, then this function returns an undefined *
|
|
* reference. Be sure to check Count against zero before calling this function. *
|
|
* *
|
|
* HISTORY: *
|
|
* 12/09/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
template<class T, int size>
|
|
inline T & QueueClass<T,size>::First(void)
|
|
{
|
|
return Array[Head];
|
|
}
|
|
|
|
#endif
|