Replaced all std containers with my custom wrappers

BansheeEngine/Include/BsBuiltinMaterialManager.h

@@ -39,7 +39,7 @@ namespace BansheeEngine
 		void setActive(const CM::String& renderSystemName);
 
 	private:
-		std::unordered_map<CM::String, BuiltinMaterialFactory*> mAvailableFactories;
+		CM::unordered_map<CM::String, BuiltinMaterialFactory*>::type mAvailableFactories;
 		BuiltinMaterialFactory* mActiveFactory;
 	};
 }

BansheeEngine/Include/BsDebugDraw.h

@@ -47,7 +47,7 @@ namespace BansheeEngine
 		CM::HMaterial mTriangleMaterial;
 		CM::HMaterial mLineMaterial;
 
-		std::vector<DebugDrawCommand> mCommands;
+		CM::vector<DebugDrawCommand>::type mCommands;
 
 		static const int VertexSize = 16;
 

BansheeEngine/Include/BsGUILayout.h

@@ -96,8 +96,8 @@ namespace BansheeEngine
 		bool _isDirty();
 
 	protected:
-		std::vector<GUILayoutEntry> mChildren;	
-		std::vector<CM::Int2> mOptimalSizes;
+		CM::vector<GUILayoutEntry>::type mChildren;	
+		CM::vector<CM::Int2>::type mOptimalSizes;
 		UINT32 mOptimalWidth;
 		UINT32 mOptimalHeight;
 

BansheeEngine/Include/BsGUIManager.h

@@ -18,10 +18,10 @@ namespace BansheeEngine
 				:isDirty(true)
 			{ }
 
-			std::vector<CM::HMesh> cachedMeshes;
-			std::vector<CM::HMaterial> cachedMaterials;
-			std::vector<GUIWidget*> cachedWidgetsPerMesh;
-			std::vector<GUIWidget*> widgets;
+			CM::vector<CM::HMesh>::type cachedMeshes;
+			CM::vector<CM::HMaterial>::type cachedMaterials;
+			CM::vector<GUIWidget*>::type cachedWidgetsPerMesh;
+			CM::vector<GUIWidget*>::type widgets;
 			bool isDirty;
 		};
 
@@ -35,8 +35,8 @@ namespace BansheeEngine
 		void update();
 		void render(CM::ViewportPtr& target, CM::RenderContext& renderContext);
 	private:
-		std::vector<GUIWidget*> mWidgets;
-		std::unordered_map<const CM::Viewport*, GUIRenderData> mCachedGUIData;
+		CM::vector<GUIWidget*>::type mWidgets;
+		CM::unordered_map<const CM::Viewport*, GUIRenderData>::type mCachedGUIData;
 
 		GUIWidget* mMouseOverWidget;
 		GUIElement* mMouseOverElement;

BansheeEngine/Include/BsGUIMaterialManager.h

@@ -50,7 +50,7 @@ namespace BansheeEngine
 			UINT32 refCount;
 		};
 
-		mutable std::vector<GUIMaterial> mTextMaterials;
-		mutable std::vector<GUIMaterial> mImageMaterials;
+		mutable CM::vector<GUIMaterial>::type mTextMaterials;
+		mutable CM::vector<GUIMaterial>::type mImageMaterials;
 	};
 }

BansheeEngine/Include/BsGUISkin.h

@@ -14,6 +14,6 @@ namespace BansheeEngine
 	private:
 		static GUIElementStyle DefaultStyle;
 
-		std::unordered_map<std::string, GUIElementStyle> mStyles;
+		CM::unordered_map<std::string, GUIElementStyle>::type mStyles;
 	};
 }

BansheeEngine/Include/BsGUIWidget.h

@@ -41,7 +41,7 @@ namespace BansheeEngine
 
 		const CM::RenderWindow* getOwnerWindow() const { return mOwnerWindow; }
 		CM::Viewport* getTarget() const { return mTarget; }
-		const std::vector<GUIElement*>& getElements() const { return mElements; }
+		const CM::vector<GUIElement*>::type& getElements() const { return mElements; }
 
 		void _updateLayout();
 	protected:
@@ -65,8 +65,8 @@ namespace BansheeEngine
 
 		const CM::RenderWindow* mOwnerWindow;
 		CM::Viewport* mTarget;
-		std::vector<GUIElement*> mElements;
-		std::vector<GUIArea*> mAreas;
+		CM::vector<GUIElement*>::type mElements;
+		CM::vector<GUIArea*>::type mAreas;
 		UINT8 mDepth;
 
 		CM::Vector3 mLastFramePosition;
@@ -75,8 +75,8 @@ namespace BansheeEngine
 
 		mutable bool mWidgetIsDirty;
 		mutable CM::Rect mBounds;
-		mutable std::vector<CM::HMesh> mCachedMeshes;
-		mutable std::vector<CM::HMaterial> mCachedMaterials;
+		mutable CM::vector<CM::HMesh>::type mCachedMeshes;
+		mutable CM::vector<CM::HMaterial>::type mCachedMaterials;
 
 		const GUISkin* mSkin;
 		static GUISkin DefaultSkin;

BansheeEngine/Include/BsOverlayManager.h

@@ -31,6 +31,6 @@ namespace BansheeEngine
 		void detachOverlay(const CM::Viewport* target, const Overlay* overlay);
 		void detachOverlayFromAll(const Overlay* overlay);
 
-		std::unordered_map<const CM::Viewport*, std::set<const Overlay*, OverlayComparer>> mOverlaysPerTarget;
+		CM::unordered_map<const CM::Viewport*, CM::set<const Overlay*, OverlayComparer>::type>::type mOverlaysPerTarget;
 	};
 }

BansheeEngine/Include/BsSprite.h

@@ -92,7 +92,7 @@ namespace BansheeEngine
 
 	protected:
 		mutable CM::Rect mBounds;
-		mutable std::vector<SpriteRenderElement> mCachedRenderElements;
+		mutable CM::vector<SpriteRenderElement>::type mCachedRenderElements;
 
 		void updateBounds() const;
 		void clearMesh() const;

BansheeEngine/Source/BsDebugDraw.cpp

@@ -104,7 +104,7 @@ namespace BansheeEngine
 		UINT32 lineVertexOffset = 0;
 		UINT32 triangleIndexOffset = 0;
 		UINT32 triangleVertexOffset = 0;
-		std::vector<DebugDrawCommand> newCommands;
+		vector<DebugDrawCommand>::type newCommands;
 		for(auto& command : mCommands)
 		{
 			if(command.type == DebugDrawType::Line)

BansheeEngine/Source/BsGUIManager.cpp

@@ -38,7 +38,7 @@ namespace BansheeEngine
 		UINT32 numQuads;
 		UINT32 depth;
 		Rect bounds;
-		std::vector<GUIGroupElement> elements;
+		vector<GUIGroupElement>::type elements;
 	};
 
 	GUIManager::GUIManager()
@@ -199,11 +199,11 @@ namespace BansheeEngine
 				return aDepth > bDepth || (aDepth ==bDepth && a.element > b.element); 
 			};
 
-			std::set<GUIGroupElement, std::function<bool(const GUIGroupElement&, const GUIGroupElement&)>> allElements(elemComp);
+			set<GUIGroupElement, std::function<bool(const GUIGroupElement&, const GUIGroupElement&)>>::type allElements(elemComp);
 
 			for(auto& widget : renderData.widgets)
 			{
-				const std::vector<GUIElement*>& elements = widget->getElements();
+				const vector<GUIElement*>::type& elements = widget->getElements();
 
 				for(auto& element : elements)
 				{
@@ -217,7 +217,7 @@ namespace BansheeEngine
 
 			// Group the elements in such a way so that we end up with a smallest amount of
 			// meshes, without breaking back to front rendering order
-			std::unordered_map<UINT64, std::vector<GUIMaterialGroup>> materialGroups;
+			unordered_map<UINT64, vector<GUIMaterialGroup>::type>::type materialGroups;
 			for(auto& elem : allElements)
 			{
 				GUIElement* guiElem = elem.element;
@@ -235,13 +235,13 @@ namespace BansheeEngine
 				// If this is a new material, add a new list of groups
 				auto findIterMaterial = materialGroups.find(materialId);
 				if(findIterMaterial == end(materialGroups))
-					materialGroups[materialId] = std::vector<GUIMaterialGroup>();
+					materialGroups[materialId] = vector<GUIMaterialGroup>::type();
 
 				// Try to find a group this material will fit in:
 				//  - Group that has a depth value same or one below elements depth will always be a match
 				//  - Otherwise, we search higher depth values as well, but we only use them if no elements in between those depth values
 				//    overlap the current elements bounds.
-				std::vector<GUIMaterialGroup>& allGroups = materialGroups[materialId];
+				vector<GUIMaterialGroup>::type& allGroups = materialGroups[materialId];
 				GUIMaterialGroup* foundGroup = nullptr;
 				for(auto groupIter = allGroups.rbegin(); groupIter != allGroups.rend(); ++groupIter)
 				{
@@ -319,7 +319,7 @@ namespace BansheeEngine
 				// requires all elements to be unique
 			};
 
-			std::set<GUIMaterialGroup*, std::function<bool(GUIMaterialGroup*, GUIMaterialGroup*)>> sortedGroups(groupComp);
+			set<GUIMaterialGroup*, std::function<bool(GUIMaterialGroup*, GUIMaterialGroup*)>>::type sortedGroups(groupComp);
 			for(auto& material : materialGroups)
 			{
 				for(auto& group : material.second)
@@ -403,7 +403,7 @@ namespace BansheeEngine
 	{
 #if CM_DEBUG_MODE
 		// Checks if all referenced windows actually exist
-		std::vector<RenderWindow*> activeWindows = RenderWindowManager::instance().getRenderWindows();
+		vector<RenderWindow*>::type activeWindows = RenderWindowManager::instance().getRenderWindows();
 		for(auto& widget : mWidgets)
 		{
 			auto iterFind = std::find(begin(activeWindows), end(activeWindows), widget->getOwnerWindow());
@@ -447,7 +447,7 @@ namespace BansheeEngine
 					Vector4 vecLocalPos = worldTfrm.inverse() * vecScreenPos;
 					Int2 localPos(Math::RoundToInt(vecLocalPos.x), Math::RoundToInt(vecLocalPos.y));
 
-					std::vector<GUIElement*> sortedElements = widget->getElements();
+					vector<GUIElement*>::type sortedElements = widget->getElements();
 					std::sort(sortedElements.begin(), sortedElements.end(), 
 						[](GUIElement* a, GUIElement* b)
 					{

BansheeEngine/Source/BsTextSprite.cpp

@@ -20,8 +20,8 @@ namespace BansheeEngine
 		if(textData == nullptr)
 			return;
 
-		const std::vector<TextUtility::TextLine>& lines = textData->getLines();
-		const std::vector<UINT32>& quadsPerPage = textData->getNumQuadsPerPage();
+		const CM::vector<TextUtility::TextLine>::type& lines = textData->getLines();
+		const CM::vector<UINT32>::type& quadsPerPage = textData->getNumQuadsPerPage();
 
 		UINT32 curHeight = 0;
 		for(auto& line : lines)
@@ -49,7 +49,7 @@ namespace BansheeEngine
 		if(mCachedRenderElements.size() < quadsPerPage.size())
 			mCachedRenderElements.resize(quadsPerPage.size());
 
-		const std::vector<HTexture>& texturePages = textData->getTexturePages();
+		const CM::vector<HTexture>::type& texturePages = textData->getTexturePages();
 		UINT32 texPage = 0;
 		for(auto& cachedElem : mCachedRenderElements)
 		{

BansheeForwardRenderer/Source/BsForwardRenderer.cpp

@@ -37,7 +37,7 @@ namespace BansheeEngine
 		const vector<HCamera>::type& allCameras = gSceneManager().getAllCameras();
 
 		// Find all unique render targets
-		std::unordered_set<RenderTargetPtr> renderTargets;
+		unordered_set<RenderTargetPtr>::type renderTargets;
 		for(auto& camera : allCameras)
 		{
 			RenderTargetPtr target = camera->getViewport()->getTarget();

CamelotCore/Include/CmApplication.h

@@ -26,7 +26,7 @@ namespace CamelotFramework
 
 		RENDER_WINDOW_DESC primaryWindowDesc;
 
-		std::vector<String> importers;
+		vector<String>::type importers;
 
 		String resourceCacheDirectory;
 	};

CamelotCore/Include/CmCommandQueue.h

@@ -229,7 +229,7 @@ namespace CamelotFramework
 		UINT32 mCommandQueueIdx;
 
 		static UINT32 MaxCommandQueueIdx;
-		static std::unordered_set<QueueBreakpoint, QueueBreakpoint::HashFunction, QueueBreakpoint::EqualFunction> SetBreakpoints;
+		static unordered_set<QueueBreakpoint, QueueBreakpoint::HashFunction, QueueBreakpoint::EqualFunction>::type SetBreakpoints;
 		CM_STATIC_MUTEX(CommandQueueBreakpointMutex);
 
 		static void breakIfNeeded(UINT32 queueIdx, UINT32 commandIdx);

CamelotCore/Include/CmGpuBuffer.h

@@ -53,7 +53,7 @@ namespace CamelotFramework
 			UINT32 refCount;
 		};
 
-		std::unordered_map<GPU_BUFFER_DESC, GpuBufferReference*, GpuBufferView::HashFunction, GpuBufferView::EqualFunction> mBufferViews;
+		unordered_map<GPU_BUFFER_DESC, GpuBufferReference*, GpuBufferView::HashFunction, GpuBufferView::EqualFunction>::type mBufferViews;
 
 	protected:
 		GpuBufferType mType;

CamelotCore/Include/CmRenderSystemCapabilities.h

@@ -251,7 +251,7 @@ namespace CamelotFramework
 		/// GPU Vendor
 		GPUVendor mVendor;
 
-		static std::vector<CamelotFramework::String> msGPUVendorStrings;
+		static vector<CamelotFramework::String>::type msGPUVendorStrings;
 		static void initVendorStrings();
 
 		/// The number of world matrices available

CamelotCore/Include/CmRenderSystemManager.h

@@ -15,7 +15,7 @@ namespace CamelotFramework
 
 		void registerRenderSystemFactory(RenderSystemFactoryPtr factory);
 	private:
-		std::vector<RenderSystemFactoryPtr> mAvailableFactories;
+		vector<RenderSystemFactoryPtr>::type mAvailableFactories;
 	};
 }
 

CamelotCore/Include/CmRenderWindowManager.h

@@ -13,12 +13,12 @@ namespace CamelotFramework
 		*/
 		RenderWindowPtr create(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow);
 
-		std::vector<RenderWindow*> getRenderWindows() const;
+		vector<RenderWindow*>::type getRenderWindows() const;
 	protected:
 		friend class RenderWindow;
 
 		CM_MUTEX(mWindowMutex);
-		std::vector<RenderWindow*> mCreatedWindows;
+		vector<RenderWindow*>::type mCreatedWindows;
 
 		virtual RenderWindowPtr createImpl(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow) = 0;
 

CamelotCore/Include/CmRendererManager.h

@@ -23,7 +23,7 @@ namespace CamelotFramework
 
 		void registerFactory(RendererFactoryPtr factory);
 	private:
-		std::vector<RendererFactoryPtr> mAvailableFactories;
+		vector<RendererFactoryPtr>::type mAvailableFactories;
 
 		RendererPtr mActiveRenderer;
 	};

CamelotCore/Include/CmTextUtility.h

@@ -57,7 +57,7 @@ namespace CamelotFramework
 			 * 			
 			 *			One character is represented with a single quad. Some pages might be empty.
 			 */
-			std::vector<UINT32> getNumQuadsPerPage() const;
+			vector<UINT32>::type getNumQuadsPerPage() const;
 
 			/**
 			 * @brief	Fills the vertex/uv/index buffers for the specified page, with all the character data
@@ -100,18 +100,18 @@ namespace CamelotFramework
 		public:
 			~TextData();
 
-			const std::vector<TextLine>& getLines() const { return mLines; }
-			const std::vector<HTexture>& getTexturePages() const { return mTexturePages; }
-			const std::vector<UINT32>& getNumQuadsPerPage() const  { return mQuadsPerPage; }
+			const vector<TextLine>::type& getLines() const { return mLines; }
+			const vector<HTexture>::type& getTexturePages() const { return mTexturePages; }
+			const vector<UINT32>::type& getNumQuadsPerPage() const  { return mQuadsPerPage; }
 			UINT32 getWidth() const;
 			UINT32 getHeight() const;
 
 		private:
 			friend class TextUtility;
 
-			std::vector<UINT32> mQuadsPerPage;
-			std::vector<TextLine> mLines;
-			std::vector<HTexture> mTexturePages;
+			vector<UINT32>::type mQuadsPerPage;
+			vector<TextLine>::type mLines;
+			vector<HTexture>::type mTexturePages;
 		};
 
 		static std::shared_ptr<TextUtility::TextData> getTextData(const String& text, const HFont& font, UINT32 fontSize, UINT32 width = 0, UINT32 height = 0, bool wordWrap = false);

CamelotCore/Include/CmTexture.h

@@ -208,7 +208,7 @@ namespace CamelotFramework {
 			UINT32 refCount;
 		};
 
-		std::unordered_map<TEXTURE_VIEW_DESC, TextureViewReference*, TextureView::HashFunction, TextureView::EqualFunction> mTextureViews;
+		unordered_map<TEXTURE_VIEW_DESC, TextureViewReference*, TextureView::HashFunction, TextureView::EqualFunction>::type mTextureViews;
 
     protected:
 		friend class TextureManager;

CamelotCore/Source/CmCommandQueue.cpp

@@ -150,8 +150,8 @@ namespace CamelotFramework
 
 	UINT32 CommandQueueBase::MaxCommandQueueIdx = 0;
 
-	std::unordered_set<CommandQueueBase::QueueBreakpoint, CommandQueueBase::QueueBreakpoint::HashFunction, 
-		CommandQueueBase::QueueBreakpoint::EqualFunction> CommandQueueBase::SetBreakpoints;
+	unordered_set<CommandQueueBase::QueueBreakpoint, CommandQueueBase::QueueBreakpoint::HashFunction, 
+		CommandQueueBase::QueueBreakpoint::EqualFunction>::type CommandQueueBase::SetBreakpoints;
 
 	inline size_t CommandQueueBase::QueueBreakpoint::HashFunction::operator()(const QueueBreakpoint& v) const
 	{

CamelotCore/Source/CmRenderSystemCapabilities.cpp

@@ -73,7 +73,7 @@ namespace CamelotFramework {
 	{
 	}
 	//---------------------------------------------------------------------
-	std::vector<CamelotFramework::String> RenderSystemCapabilities::msGPUVendorStrings;
+	vector<CamelotFramework::String>::type RenderSystemCapabilities::msGPUVendorStrings;
 	//---------------------------------------------------------------------
 	GPUVendor RenderSystemCapabilities::vendorFromString(const String& vendorString)
 	{

CamelotCore/Source/CmRenderWindowManager.cpp

@@ -31,7 +31,7 @@ namespace CamelotFramework
 		}
 	}
 
-	std::vector<RenderWindow*> RenderWindowManager::getRenderWindows() const
+	vector<RenderWindow*>::type RenderWindowManager::getRenderWindows() const
 	{
 		CM_LOCK_MUTEX(mWindowMutex);
 

CamelotCore/Source/CmTextUtility.cpp

@@ -151,9 +151,9 @@ namespace CamelotFramework
 		return word;
 	}
 
-	std::vector<UINT32> TextUtility::TextLine::getNumQuadsPerPage() const
+	vector<UINT32>::type TextUtility::TextLine::getNumQuadsPerPage() const
 	{
-		std::vector<UINT32> quadsPerPage;
+		vector<UINT32>::type quadsPerPage;
 		for(auto wordIter = mWords.begin(); wordIter != mWords.end(); ++wordIter)
 		{
 			if(!wordIter->isSpacer())

CamelotD3D11RenderSystem/Include/CmD3D11InputLayoutManager.h

@@ -55,7 +55,7 @@ namespace CamelotFramework
 		static const int DECLARATION_BUFFER_SIZE = 1024;
 		static const int NUM_ELEMENTS_TO_PRUNE = 64;
 
-		std::unordered_map<VertexDeclarationKey, InputLayoutEntry*, HashFunc, EqualFunc> mInputLayoutMap;
+		unordered_map<VertexDeclarationKey, InputLayoutEntry*, HashFunc, EqualFunc>::type mInputLayoutMap;
 
 		bool mWarningShown;
 		UINT32 mLastUsedCounter;

CamelotD3D11RenderSystem/Source/CmD3D11Device.cpp

@@ -124,7 +124,7 @@ namespace CamelotFramework
 
 		D3D11_INFO_QUEUE_FILTER filter;
 		ZeroMemory(&filter, sizeof(D3D11_INFO_QUEUE_FILTER));
-		std::vector<D3D11_MESSAGE_SEVERITY> severityList;
+		vector<D3D11_MESSAGE_SEVERITY>::type severityList;
 
 		switch(exceptionsErrorLevel)
 		{

CamelotD3D9Renderer/Source/CmD3D9RenderSystem.cpp

@@ -371,7 +371,7 @@ namespace CamelotFramework
 
 		// Read all the buffer data so we can assign it. Not the most efficient way of accessing data
 		// but it is required in order to have standardized buffer interface.
-		std::unordered_map<UINT32, UINT8*> bufferData;
+		unordered_map<UINT32, UINT8*>::type bufferData;
 
 		for(auto& curParam : paramDesc.params)
 		{

CamelotFreeImgImporter/Include/CmFreeImgImporter.h

@@ -37,7 +37,7 @@ namespace CamelotFramework
 		virtual HResource import(const String& filePath, ConstImportOptionsPtr importOptions);
 	private:
 		vector<String>::type mExtensions;
-		std::unordered_map<String, int> mExtensionToFID;
+		unordered_map<String, int>::type mExtensionToFID;
 
 		String magicNumToExtension(const UINT8* magic, UINT32 maxBytes) const;
 		TextureDataPtr importRawImage(DataStreamPtr fileData);

CamelotGLRenderer/Source/GLSL/include/CmGLSLProgramPipelineManager.h

@@ -37,7 +37,7 @@ namespace CamelotFramework
 			bool operator()(const ProgramPipelineKey &a, const ProgramPipelineKey &b) const;
 		};
 
-		typedef std::unordered_map<ProgramPipelineKey, GLSLProgramPipeline, ProgramPipelineKeyHashFunction, ProgramPipelineKeyEqual> ProgramPipelineMap;
+		typedef unordered_map<ProgramPipelineKey, GLSLProgramPipeline, ProgramPipelineKeyHashFunction, ProgramPipelineKeyEqual>::type ProgramPipelineMap;
 		ProgramPipelineMap mPipelines;
 	};
 }

CamelotUtility/Include/CmBinarySerializer.h

@@ -96,12 +96,12 @@ namespace CamelotFramework
 			UINT32 typeId;
 		};
 
-		std::unordered_map<void*, UINT32> mObjectAddrToId;
+		unordered_map<void*, UINT32>::type mObjectAddrToId;
 		UINT32 mLastUsedObjectId;
-		std::vector<ObjectToEncode> mObjectsToEncode;
+		vector<ObjectToEncode>::type mObjectsToEncode;
 		int mTotalBytesWritten;
 
-		std::unordered_map<UINT32, ObjectToDecode> mObjectMap;
+		unordered_map<UINT32, ObjectToDecode>::type mObjectMap;
 
 		UINT32 getObjectSize(IReflectable* object);
 

CamelotUtility/Include/CmLog.h

@@ -63,7 +63,7 @@ namespace CamelotFramework
 		void flush();
 
 	private:
-		std::vector<LogEntry*> mEntries;
+		vector<LogEntry*>::type mEntries;
 
 		bool mAutoSave;
 		bool mSuppressFileOutput;

CamelotUtility/Include/CmRTTIType.h

@@ -288,7 +288,7 @@ namespace CamelotFramework
 		void throwCircularRefException(const String& myType, const String& otherType) const;
 
 	private:
-		std::vector<RTTIField*> mFields;
+		vector<RTTIField*>::type mFields;
 	};
 
 	/**

CamelotUtility/Include/CmString.h

@@ -312,7 +312,7 @@ namespace CamelotFramework {
         Strings must not contain spaces since space is used as a delimiter in
         the output.
     */
-    CM_UTILITY_EXPORT String toString(const std::vector<CamelotFramework::String>& val);
+    CM_UTILITY_EXPORT String toString(const vector<CamelotFramework::String>::type& val);
 
     /** Converts a String to a float. 
     @returns

CamelotUtility/Include/CmWorkQueue.h

@@ -34,7 +34,7 @@ namespace CamelotFramework
 	class CM_UTILITY_EXPORT WorkQueue
 	{
 	protected:
-		typedef std::map<String, UINT16> ChannelMap;
+		typedef map<String, UINT16>::type ChannelMap;
 		ChannelMap mChannelMap;
 		UINT16 mNextChannel;
 		CM_MUTEX(mChannelMapMutex)

CamelotUtility/Source/CmBinarySerializer.cpp

@@ -63,7 +63,7 @@ namespace CamelotFramework
 		}
 
 		// Encode pointed to objects and their value types
-		std::unordered_set<UINT32> serializedObjects;
+		unordered_set<UINT32>::type serializedObjects;
 		while(true)
 		{
 			auto iter = mObjectsToEncode.begin();

CamelotUtility/Source/CmString.cpp

@@ -595,10 +595,10 @@ namespace CamelotFramework {
 		return stream.str();
 	}
 	//-----------------------------------------------------------------------
-	String toString(const std::vector<CamelotFramework::String>& val)
+	String toString(const vector<CamelotFramework::String>::type& val)
 	{
 		stringstream stream;
-		std::vector<CamelotFramework::String>::const_iterator i, iend, ibegin;
+		vector<CamelotFramework::String>::type::const_iterator i, iend, ibegin;
 		ibegin = val.begin();
 		iend = val.end();
 		for (i = ibegin; i != iend; ++i)