Remastered-Collection/REDALERT/LINK.CPP

//
// 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/LINK.CPP 1     3/03/97 10:25a 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 : LINK.CPP                                                     *
 *                                                                                             *
 *                   Programmer : Joe L. Bostic                                                *
 *                                                                                             *
 *                   Start Date : 01/15/95                                                     *
 *                                                                                             *
 *                  Last Update : January 19, 1995 [JLB]                                       *
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 *   LinkClass::Add -- This object adds itself to the given list                               *
 *   LinkClass::Add_Head -- This gadget makes itself the head of the given list.               *
 *   LinkClass::Add_Tail -- Add myself to the end of the given list.                           *
 *   LinkClass::Get_Next -- Fetches the next object in list.                                   *
 *   LinkClass::Get_Prev -- Fetches previous object in linked list.                            *
 *   LinkClass::Head_Of_List -- Finds the head of the list.                                    *
 *   LinkClass::LinkClass -- Copy constructor for linked list object.                          *
 *   LinkClass::Remove -- Removes the specified object from the list.                          *
 *   LinkClass::Tail_Of_List -- Scans for the object at the end of the list.                   *
 *   LinkClass::Zap -- Forces the link pointers to NULL.                                       *
 *   LinkClass::operator= -- Assignment operator for linked list class object.                 *
 *   LinkClass::~LinkClass -- Default destructor for linked list object.                       *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#include "function.h"
#include "link.h"


/***********************************************************************************************
 * LinkClass::LinkClass -- Copy constructor for linked list object.                            *
 *                                                                                             *
 *    This copy constructor, unlike the assignment operator, doesn't have to deal with an      *
 *    already initialized and legal link object to the left of the "=". It merely puts the     *
 *    destination object into the same list as the source object.                              *
 *                                                                                             *
 * INPUT:   link  -- Reference to the object on the right of the "=".                          *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   01/16/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
LinkClass::LinkClass(LinkClass const & link) :
	Next(0), Prev(0)
{
	/*
	**	Add this object to the same list that the copy object
	**	resides in.
	*/
	Add((LinkClass &)link);
}


/***********************************************************************************************
 * LinkClass::~LinkClass -- Default destructor for linked list object.                         *
 *                                                                                             *
 *    This default destructor will remove the object from any linked list it may be part of.   *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   01/15/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
LinkClass::~LinkClass(void)
{
	Remove();
}


/***********************************************************************************************
 * LinkClass::Zap -- Forces the link pointers to NULL.                                         *
 *                                                                                             *
 *    This routine will "zap" out the link pointers. This is usually necessary when the link   *
 *    pointers start in an undefined state, but we KNOW that they aren't pointing to anything  *
 *    valid. In such a case it becomes necessary to zap them so that when the object is added  *
 *    to a list, it will be added correctly.                                                   *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   01/19/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
void LinkClass::Zap(void)
{
	Next = 0;
	Prev = 0;
}


/***********************************************************************************************
 * LinkClass::operator= -- Assignment operator for linked list class object.                   *
 *                                                                                             *
 *    The assignment operator makes sure that the previous and next pointers remain valid.     *
 *    Because this class only consists of pointers, the assignment operator doesn't actually   *
 *    transfer any data from the source object. It merely makes the destination object part    *
 *    of the same list as the source object. In essence, this is transferring information      *
 *    but not the actual values.                                                               *
 *                                                                                             *
 *    If the destination object is already part of another list, it is removed from that list  *
 *    before being added to the source object's list. This ensures that either list remains    *
 *    in a valid condition.                                                                    *
 *                                                                                             *
 * INPUT:   link  -- The object to the right of the "=" operator.                              *
 *                                                                                             *
 * OUTPUT:  Returns a reference to the rightmost object -- per standard assignment rules.      *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   01/16/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
LinkClass & LinkClass::operator = (LinkClass const & link)
{
	if (&link == this) return(*this);

	Remove();
	Add((LinkClass &)link);

	return(*this);
}


/***********************************************************************************************
 * LinkClass::Get_Next -- Fetches the next object in list.                                     *
 *                                                                                             *
 *    This routine will return with a pointer to the next object in the list. If there are     *
 *    no more objects, then NULL is returned.                                                  *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with pointer to next object in list or NULL if at end of list.             *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   01/15/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
LinkClass * LinkClass::Get_Next(void) const
{
	return(Next);
}


/***********************************************************************************************
 * LinkClass::Get_Prev -- Fetches previous object in linked list.                              *
 *                                                                                             *
 *    Use this routine to get a pointer to the previous object in the linked list. If there    *
 *    are no previous objects (such as at the head of the list), then NULL is returned.        *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with a pointer to the previous object in the list or NULL if none.         *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   01/15/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
LinkClass * LinkClass::Get_Prev(void) const
{
	return(Prev);
}


/***********************************************************************************************
 * LinkClass::Head_Of_List -- Finds the head of the list.                                      *
 *                                                                                             *
 *    Use this routine to scan for and return a reference to the object at the head of the     *
 *    list.                                                                                    *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with a reference to the object at the head of the list.                    *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   01/19/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
LinkClass & LinkClass::Head_Of_List(void)
{
	LinkClass * link = this;
	while (link->Prev) {
		link = link->Prev;
		if (link == this) break;		// Safety check
	}
	return(*link);
}


/***********************************************************************************************
 * LinkClass::Tail_Of_List -- Scans for the object at the end of the list.                     *
 *                                                                                             *
 *    Use this routine to scan for and return a reference to the object at the end of the      *
 *    list.                                                                                    *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with a reference to the object at the end of the list.                     *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   01/19/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
LinkClass & LinkClass::Tail_Of_List(void)
{
	LinkClass * link = this;
	while (link->Next) {
		link = link->Next;
		if (link == this) break;		// Safety check
	}
	return(*link);
}


/***********************************************************************************************
 * LinkClass::Add -- This object adds itself to the given list                                 *
 *                                                                                             *
 *    Use this routine to add a link object to the list, but to be added right after the       *
 *    given link. This allows inserting a link in the middle of the chain. A quite necessary   *
 *    ability if the chain is order dependant (e.g., the gadget system).                       *
 *                                                                                             *
 * INPUT:   list -- gadget object to add this one to                                           *
 *                                                                                             *
 * OUTPUT:  Returns with a pointer to the head of the list.                                    *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   01/19/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
LinkClass & LinkClass::Add(LinkClass & list)
{
	LinkClass * ptr;

	/*
	**	Save ptr to next gadget.
	*/
	ptr = list.Next;

	/*
	**	Link myself in after 'list'.
	*/
	list.Next = this;
	Prev = &list;

	/*
	**	Link myself to next gadget, if there is one.
	*/
	Next = ptr;
	if (ptr) {
		ptr->Prev = this;
	}

	return(Head_Of_List());
}


/***********************************************************************************************
 * LinkClass::Add_Head -- This gadget makes itself the head of the given list.                 *
 *                                                                                             *
 * INPUT:   list -- the list to make myself the head of                                        *
 *                                                                                             *
 * OUTPUT:  Returns with a reference to the object at the head of the list. This should be     *
 *          the same object that is passed in.                                                 *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   01/19/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
LinkClass & LinkClass::Add_Head(LinkClass & list)
{
	LinkClass * ptr;

	/*
	**	Get head of given list.
	*/
	ptr = &list.Head_Of_List();

	/*
	**	Link myself in front of it.
	*/
	ptr->Prev = this;
	Next = ptr;
	Prev = NULL;

	return(*this);
}


/***********************************************************************************************
 * LinkClass::Add_Tail -- Add myself to the end of the given list.                             *
 *                                                                                             *
 * INPUT:   list -- list to add myself to                                                      *
 *                                                                                             *
 * OUTPUT:  the head of the list                                                               *
 *                                                                                             *
 * WARNINGS:   The previous and next pointers for the added object MUST have been properly     *
 *             initialized for this routine to work correctly.                                 *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   01/15/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
LinkClass & LinkClass::Add_Tail(LinkClass & list)
{
	LinkClass * ptr;

	/*
	**	Get head of given list.
	*/
	ptr = &list.Tail_Of_List();

	/*
	**	Link myself in front of it.
	*/
	ptr->Next = this;
	Prev = ptr;
	Next = NULL;

	return(Head_Of_List());
}


/***********************************************************************************************
 * LinkClass::Remove -- Removes the specified object from the list.                            *
 *                                                                                             *
 *    This routine will remove the specified object from the list of objects. Because of the   *
 *    previous and next pointers, it is possible to remove an object from the list without     *
 *    knowing the head of the list. To do this, just call Remove() with the parameter of       *
 *    "this".                                                                                  *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with the new head of list.                                                 *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   01/15/1995 JLB : Created.                                                                 *
 *=============================================================================================*/
LinkClass * LinkClass::Remove(void)
{
	LinkClass * head = &Head_Of_List();
	LinkClass * tail = &Tail_Of_List();

	if (Prev) {
		Prev->Next = Next;
	}
	if (Next) {
		Next->Prev = Prev;
	}
	Prev = 0;
	Next = 0;

	if (head==this) {
		if (tail==this) {
			return(0);
		}
		return(&tail->Head_Of_List());
	}
	return(head);
}