refactor(Generals): rename OVERRIDE template class to OverridePtr to avoid macro conflict

Author: bobtista

Generals/Code/GameEngine/Include/Common/Overridable.h

@@ -31,7 +31,7 @@
 #include "Common/GameMemory.h"
 
 /*
-	In order for something to live in an OVERRIDE<> object, it must be derived from Overridable
+	In order for something to live in an OverridePtr<> object, it must be derived from Overridable
 	(publicly).
 
 	This is useful for things like templates, where we want to override the template and make sure

Generals/Code/GameEngine/Include/Common/Override.h

@@ -31,31 +31,31 @@
 #include "Common/Overridable.h"
 
 /*
-	An OVERRIDE is a replacement for a pointer of its contained type, ie, rather than containing
-	a LocomotorTemplate*, you would contain an OVERRIDE<LocomotorTemplate>.
+	An OverridePtr is a replacement for a pointer of its contained type, ie, rather than containing
+	a LocomotorTemplate*, you would contain an OverridePtr<LocomotorTemplate>.
 
-	OVERRIDE pretends in all ways (dereference via *, -> and casting to type*) to be a type*, so
+	OverridePtr pretends in all ways (dereference via *, -> and casting to type*) to be a type*, so
 	there should be very little code that needs to be rewritten to work with these.
 
 	In order to make something overridable, these are the steps:
 		1) Make the desired class derive from Overridable.
-		2) Make the container class contain an instance of OVERRIDE<Type>
+		2) Make the container class contain an instance of OverridePtr<Type>
 		3) Make the newOverride function (wherever an override is new'd) request the overridables lastOverride,
 			to ensure that no leaks are created.
 
 		See LocomotorTemplate for an example.
 */
 
-template <class T> class OVERRIDE
+template <class T> class OverridePtr
 {
 	public:
-		// Provide useful constructores to go from a T* to an OVERRIDE<T>
-		OVERRIDE(const T *overridable = nullptr);
+		// Provide useful constructores to go from a T* to an OverridePtr<T>
+		OverridePtr(const T *overridable = nullptr);
 		// Copy constructor
-		OVERRIDE(OVERRIDE<T> &overridable);
-		// Operator= for copying from another OVERRIDE and T*
-		__inline OVERRIDE &operator=( const OVERRIDE<T>& override );
-		__inline OVERRIDE &operator=( const T* overridable );
+		OverridePtr(OverridePtr<T> &overridable);
+		// Operator= for copying from another OverridePtr and T*
+		__inline OverridePtr &operator=( const OverridePtr<T>& other );
+		__inline OverridePtr &operator=( const T* overridable );
 
 		// these are the methods which we can use to access data in a pointer. (Dereference*, ->, and cast
 		// to T*). They are all overloaded to recurse to the lowest override and use that.
@@ -67,44 +67,44 @@ template <class T> class OVERRIDE
 		__inline const T *getNonOverloadedPointer( void ) const;
 
 	private:
-		// Because OVERRIDE is meant to live on the object and not in the store, it currently contains
+		// Because OverridePtr is meant to live on the object and not in the store, it currently contains
 		// a constant pointer. We could change this if it seems weird.
 		const T *m_overridable;
 };
 
 //-------------------------------------------------------------------------------------------------
 template <class T>
-OVERRIDE<T>::OVERRIDE(const T *overridable)
+OverridePtr<T>::OverridePtr(const T *overridable)
 {
 	m_overridable = overridable;
 }
 
 //-------------------------------------------------------------------------------------------------
 template <class T>
-OVERRIDE<T>::OVERRIDE(OVERRIDE<T> &overridable)
+OverridePtr<T>::OverridePtr(OverridePtr<T> &overridable)
 {
 	m_overridable = overridable.m_overridable;
 }
 
 //-------------------------------------------------------------------------------------------------
 template <class T>
-OVERRIDE<T> &OVERRIDE<T>::operator=( const OVERRIDE<T>& override )
+OverridePtr<T> &OverridePtr<T>::operator=( const OverridePtr<T>& other )
 {
-	m_overridable = override.m_overridable;
+	m_overridable = other.m_overridable;
 	return *this;
 }
 
 //-------------------------------------------------------------------------------------------------
 template <class T>
-OVERRIDE<T> &OVERRIDE<T>::operator=(const T* overridable)
+OverridePtr<T> &OverridePtr<T>::operator=(const T* overridable)
 {
 	m_overridable = overridable;
 	return *this;
 }
 
 //-------------------------------------------------------------------------------------------------
 template <class T>
-const T *OVERRIDE<T>::operator->() const
+const T *OverridePtr<T>::operator->() const
 {
 	if (!m_overridable)
 		return nullptr;
@@ -113,7 +113,7 @@ const T *OVERRIDE<T>::operator->() const
 
 //-------------------------------------------------------------------------------------------------
 template <class T>
-const T *OVERRIDE<T>::operator*() const
+const T *OverridePtr<T>::operator*() const
 {
 	if (!m_overridable)
 		return nullptr;
@@ -122,14 +122,14 @@ const T *OVERRIDE<T>::operator*() const
 
 //-------------------------------------------------------------------------------------------------
 template <class T>
-const T *OVERRIDE<T>::getNonOverloadedPointer( void ) const
+const T *OverridePtr<T>::getNonOverloadedPointer( void ) const
 {
 	return (T*) m_overridable;
 }
 
 //-------------------------------------------------------------------------------------------------
 template <class T>
-OVERRIDE<T>::operator const T*( ) const
+OverridePtr<T>::operator const T*( ) const
 {
 	return operator*();
 }

Generals/Code/GameEngine/Include/Common/Thing.h

@@ -160,7 +160,7 @@ class Thing : public MemoryPoolObject
 	// note that it is declared 'const' -- the assumption being that
 	// since ThingTemplates are shared between many, many Things, the Thing
 	// should never be able to change it.
-	OVERRIDE<ThingTemplate> m_template;	///< reference back to template database
+	OverridePtr<ThingTemplate> m_template;	///< reference back to template database
 #if defined(RTS_DEBUG)
 	AsciiString m_templateName;
 #endif

Generals/Code/GameEngine/Include/GameClient/ControlBar.h

@@ -316,7 +316,7 @@ class CommandButton : public Overridable
 
 	GUICommandType getCommandType() const { return m_command; }
 	UnsignedInt getOptions() const { return m_options; }
-	OVERRIDE<ThingTemplate> getThingTemplate() const { return m_thingTemplate; }
+	OverridePtr<ThingTemplate> getThingTemplate() const { return m_thingTemplate; }
 	const UpgradeTemplate* getUpgradeTemplate() const { return m_upgradeTemplate; }
 	const SpecialPowerTemplate* getSpecialPowerTemplate() const { return m_specialPower; }
 	RadiusCursorType getRadiusCursorType() const { return m_radiusCursor; }

Generals/Code/GameEngine/Include/GameLogic/CrateSystem.h

@@ -78,7 +78,7 @@ class CrateTemplate : public Overridable
 
 };
 
-typedef OVERRIDE<CrateTemplate> CrateTemplateOverride;
+typedef OverridePtr<CrateTemplate> CrateTemplateOverride;
 
 
 /**

Generals/Code/GameEngine/Include/GameLogic/Locomotor.h

@@ -211,7 +211,7 @@ class LocomotorTemplate : public Overridable
 	Real											m_wanderAboutPointRadius;
 };
 
-typedef OVERRIDE<LocomotorTemplate> LocomotorTemplateOverride;
+typedef OverridePtr<LocomotorTemplate> LocomotorTemplateOverride;
 
 // ---------------------------------------------------------
 class Locomotor : public MemoryPoolObject, public Snapshot

Generals/Code/GameEngine/Source/Common/INI/INIWater.cpp

@@ -118,7 +118,7 @@ void INI::parseWaterTransparencyDefinition( INI *ini )
 		// texture.
 
 		const WaterTransparencySetting* wtOriginal = TheWaterTransparency.getNonOverloadedPointer();
-		OVERRIDE<WaterTransparencySetting> wtOverride = TheWaterTransparency;
+		OverridePtr<WaterTransparencySetting> wtOverride = TheWaterTransparency;
 
 		if (wtOriginal == wtOverride)
 			return;

Generals/Code/GameEngineDevice/Source/W3DDevice/GameClient/Drawable/Draw/W3DDebrisDraw.cpp

@@ -53,7 +53,7 @@
 W3DDebrisDraw::W3DDebrisDraw(Thing *thing, const ModuleData* moduleData) : DrawModule(thing, moduleData)
 {
   m_renderObject = nullptr;
-	for (int i = 0; i < ANIM_ANIM_STATECOUNT; ++i)
+	for (int i = 0; i < ANIM_STATECOUNT; ++i)
 		m_anims[i] = nullptr;
 	m_fxFinal = nullptr;
 	m_state = ANIM_INITIAL;

GeneralsMD/Code/GameEngineDevice/Source/W3DDevice/GameClient/Drawable/Draw/W3DDebrisDraw.cpp

@@ -53,7 +53,7 @@
 W3DDebrisDraw::W3DDebrisDraw(Thing *thing, const ModuleData* moduleData) : DrawModule(thing, moduleData)
 {
   m_renderObject = nullptr;
-	for (int i = 0; i < ANIM_ANIM_STATECOUNT; ++i)
+	for (int i = 0; i < ANIM_STATECOUNT; ++i)
 		m_anims[i] = nullptr;
 	m_fxFinal = nullptr;
 	m_state = ANIM_INITIAL;