Update virtual machine.

kwh3884858 · kwh3884858 · commit 6f2ad5aa86ca · 2021-07-03T23:57:19.000+08:00
diff --git a/Algorithms/Dictionary.h b/Algorithms/Dictionary.h
@@ -200,7 +200,7 @@ namespace Algorithm
 		Node* node;;
 
 		Stack<Node*> stack;
-		stack.push(mRoot);
+		stack.Push(mRoot);
 
 		int currentPos = 0;
 		while (stack.count() != 0)
@@ -209,11 +209,11 @@ namespace Algorithm
 
 			if (node->mLeft != nullptr)
 			{
-				stack.push(node->mLeft);
+				stack.Push(node->mLeft);
 			}
 			if (node->mRight != nullptr)
 			{
-				stack.push(node->mRight);
+				stack.Push(node->mRight);
 			}
 
 			keyArray[currentPos] = node->mKey;
diff --git a/Algorithms/Stack.h b/Algorithms/Stack.h
@@ -6,22 +6,22 @@ namespace Algorithm {
 	class Stack
 	{
 	private:
-		static const int DEFAULTCAPACITY;
+		static const int DEFAULTCapacity;
 	public:
 		Stack();
 		~Stack();
 
-		void push(const T& value);
-		T pop();
-		void clear();
+		void Push(const T& value);
+		T Pop();
+		void Clear();
 
-		int count()const;
-		int capacity()const;
+		int Count()const;
+		int Capacity()const;
 
 	private:
-		bool initialize(int size);
-		bool reallocation();
-		bool isCapacityEnough()const;
+		bool Initialize(int size);
+		bool Reallocation();
+		bool IsCapacityEnough()const;
 
 		T* mStack;
 		int mCount;
@@ -31,7 +31,7 @@ namespace Algorithm {
 	//-------------------define
 	
 	template<typename T>
-	const int Stack<T>::DEFAULTCAPACITY = 1;
+	const int Stack<T>::DEFAULTCapacity = 1;
 	
 	template<typename T>
 	inline Stack<T>::Stack()
@@ -41,21 +41,21 @@ namespace Algorithm {
 		mCapacity = 0;
 		mStack = nullptr;
 
-		initialize(DEFAULTCAPACITY);
+		Initialize(DEFAULTCapacity);
 	}
 
 	template<typename T>
 	inline Stack<T>::~Stack()
 	{
-		clear();
+		Clear();
 	}
 
 	template<typename T>
-	inline void Stack<T>::push(const T & value)
+	inline void Stack<T>::Push(const T & value)
 	{
-		if (isCapacityEnough() == false)
+		if (IsCapacityEnough() == false)
 		{
-			reallocation();
+			Reallocation();
 		}
 
 		mStack[mCount] = value;
@@ -65,7 +65,7 @@ namespace Algorithm {
 	}
 
 	template<typename T>
-	inline T Stack<T>::pop()
+	inline T Stack<T>::Pop()
 	{
 		if (mCount <= 0)
 		{
@@ -80,7 +80,7 @@ namespace Algorithm {
 	}
 
 	template<typename T>
-	inline void Stack<T>::clear()
+	inline void Stack<T>::Clear()
 	{
 		if (mStack != nullptr)
 		{
@@ -96,19 +96,19 @@ namespace Algorithm {
 	}
 
 	template<typename T>
-	inline int Stack<T>::count() const
+	inline int Stack<T>::Count() const
 	{
 		return mCount;
 	}
 
 	template<typename T>
-	inline int Stack<T>::capacity() const
+	inline int Stack<T>::Capacity() const
 	{
 		return mCapacity;
 	}
 
 	template<typename T>
-	inline bool Stack<T>::initialize(int size)
+	inline bool Stack<T>::Initialize(int size)
 	{
 		if (size <= 0)
 		{
@@ -125,7 +125,7 @@ namespace Algorithm {
 	}
 
 	template<typename T>
-	inline bool Stack<T>::reallocation()
+	inline bool Stack<T>::Reallocation()
 	{
 		if (mCapacity == 0)
 		{
@@ -149,7 +149,7 @@ namespace Algorithm {
 	}
 
 	template<typename T>
-	inline bool Stack<T>::isCapacityEnough() const
+	inline bool Stack<T>::IsCapacityEnough() const
 	{
 		return mCount < mCapacity;
 	}
diff --git a/Algorithms/String.h b/Algorithms/String.h
@@ -25,18 +25,19 @@ namespace Algorithm
         friend bool operator==(const StringBase<T>& lhs, const StringBase<T>& rhs);
 
         StringBase();
-         StringBase(const StringBase& value);
-         StringBase(const T* value, unsigned int size);
-         StringBase(const T* value);
+        StringBase(const StringBase& value);
+        StringBase(const T* value, unsigned int size);
+        StringBase(const T* value);
+        StringBase(T value);
         ~StringBase();
 
-        T operator[](int index) const;
-        T operator[](unsigned int index) const;
+        T& operator[](int index);
+        const T& operator[](int index) const;
+        T& operator[](unsigned int index);
+        const T& operator[](unsigned int index) const;
         StringBase<T>& operator=(const StringBase<T>& rhs);
         StringBase<T>& operator=(const T* rhs);
-         //bool operator==(const T* rhs)const;
-         bool operator==(const StringBase<T>& rhs)const;
-        //bool operator!=(const T* rhs)const;
+        bool operator==(const StringBase<T>& rhs)const;
         bool operator!=(const StringBase<T>& rhs)const;
 
         void Add(T value);
@@ -83,19 +84,37 @@ namespace Algorithm
         }
     }
 
+    template<typename T>
+    inline StringBase<T>::StringBase(T value)
+    {
+        m_string.Add(value);
+    }
+
     template<typename T>
     Algorithm::StringBase<T>::~StringBase()
     {
     }
 
     template<typename T>
-    T Algorithm::StringBase<T>::operator[](int index)const
+    inline T& StringBase<T>::operator[](int index)
+    {
+        return const_cast<T&>(const_cast<const StringBase<T>*>(this)[index]);
+    }
+
+    template<typename T>
+    inline const T& Algorithm::StringBase<T>::operator[](int index)const
     {
         return m_string[index];
     }
 
     template<typename T>
-    inline T StringBase<T>::operator[](unsigned int index)const
+    inline T& StringBase<T>::operator[](unsigned int index)
+    {
+        return const_cast<T&>(const_cast<const StringBase<T>*>(this)[index]);
+    }
+
+    template<typename T>
+    inline const T& StringBase<T>::operator[](unsigned int index)const
     {
         return m_string[index];
     }
diff --git a/Algorithms/Vector.h b/Algorithms/Vector.h
@@ -29,11 +29,12 @@ namespace Algorithm
 
         bool IsExist(const T& element)const;
 
-		T& operator[](int index)const;
+		T& operator[](int index);
+		const T& operator[](int index)const;
 		Vector<T>& operator=(const Vector& rhs);
 
 		//For Algorithm
-		bool Swap(const int lhs, const int rhs);
+		//bool Swap(const int lhs, const int rhs);
 		T* Begin();
         const T* Begin()const;
         T* End();
@@ -179,7 +180,13 @@ namespace Algorithm
     }
 
 	template<typename T>
-	inline T& Vector<T>::operator[](int index) const
+	inline T& Vector<T>::operator[](int index)
+	{
+		return const_cast<T&>(const_cast<const Vector<T>*>(this)[index]);
+	}
+
+	template<typename T>
+	inline const T& Vector<T>::operator[](int index) const
 	{
         assert(index >= 0 && index < m_count);
 		return m_content[index];
diff --git a/Engine/VirtualMachine/XenonVirtualMachine.cpp b/Engine/VirtualMachine/XenonVirtualMachine.cpp
diff --git a/Engine/VirtualMachine/XenonVirtualMachine.h b/Engine/VirtualMachine/XenonVirtualMachine.h

Original file line number	Diff line number	Diff line change
`@@ -200,7 +200,7 @@ namespace Algorithm`
`200`	`200`	`Node* node;;`
`201`	`201`
`202`	`202`	`Stack<Node*> stack;`
`203`		`- stack.push(mRoot);`
	`203`	`+ stack.Push(mRoot);`
`204`	`204`
`205`	`205`	`int currentPos = 0;`
`206`	`206`	`while (stack.count() != 0)`
`@@ -209,11 +209,11 @@ namespace Algorithm`
`209`	`209`
`210`	`210`	`if (node->mLeft != nullptr)`
`211`	`211`	`{`
`212`		`- stack.push(node->mLeft);`
	`212`	`+ stack.Push(node->mLeft);`
`213`	`213`	`}`
`214`	`214`	`if (node->mRight != nullptr)`
`215`	`215`	`{`
`216`		`- stack.push(node->mRight);`
	`216`	`+ stack.Push(node->mRight);`
`217`	`217`	`}`
`218`	`218`
`219`	`219`	`keyArray[currentPos] = node->mKey;`
Original file line number	Diff line number	Diff line change
`@@ -6,22 +6,22 @@ namespace Algorithm {`
`6`	`6`	`class Stack`
`7`	`7`	`{`
`8`	`8`	`private:`
`9`		`- static const int DEFAULTCAPACITY;`
	`9`	`+ static const int DEFAULTCapacity;`
`10`	`10`	`public:`
`11`	`11`	`Stack();`
`12`	`12`	`~Stack();`
`13`	`13`
`14`		`- void push(const T& value);`
`15`		`- T pop();`
`16`		`- void clear();`
	`14`	`+ void Push(const T& value);`
	`15`	`+ T Pop();`
	`16`	`+ void Clear();`
`17`	`17`
`18`		`- int count()const;`
`19`		`- int capacity()const;`
	`18`	`+ int Count()const;`
	`19`	`+ int Capacity()const;`
`20`	`20`
`21`	`21`	`private:`
`22`		`- bool initialize(int size);`
`23`		`- bool reallocation();`
`24`		`- bool isCapacityEnough()const;`
	`22`	`+ bool Initialize(int size);`
	`23`	`+ bool Reallocation();`
	`24`	`+ bool IsCapacityEnough()const;`
`25`	`25`
`26`	`26`	`T* mStack;`
`27`	`27`	`int mCount;`
`@@ -31,7 +31,7 @@ namespace Algorithm {`
`31`	`31`	`//-------------------define`
`32`	`32`
`33`	`33`	`template<typename T>`
`34`		`- const int Stack<T>::DEFAULTCAPACITY = 1;`
	`34`	`+ const int Stack<T>::DEFAULTCapacity = 1;`
`35`	`35`
`36`	`36`	`template<typename T>`
`37`	`37`	`inline Stack<T>::Stack()`
`@@ -41,21 +41,21 @@ namespace Algorithm {`
`41`	`41`	`mCapacity = 0;`
`42`	`42`	`mStack = nullptr;`
`43`	`43`
`44`		`- initialize(DEFAULTCAPACITY);`
	`44`	`+ Initialize(DEFAULTCapacity);`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`template<typename T>`
`48`	`48`	`inline Stack<T>::~Stack()`
`49`	`49`	`{`
`50`		`- clear();`
	`50`	`+ Clear();`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`template<typename T>`
`54`		`- inline void Stack<T>::push(const T & value)`
	`54`	`+ inline void Stack<T>::Push(const T & value)`
`55`	`55`	`{`
`56`		`- if (isCapacityEnough() == false)`
	`56`	`+ if (IsCapacityEnough() == false)`
`57`	`57`	`{`
`58`		`- reallocation();`
	`58`	`+ Reallocation();`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`mStack[mCount] = value;`
`@@ -65,7 +65,7 @@ namespace Algorithm {`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`template<typename T>`
`68`		`- inline T Stack<T>::pop()`
	`68`	`+ inline T Stack<T>::Pop()`
`69`	`69`	`{`
`70`	`70`	`if (mCount <= 0)`
`71`	`71`	`{`
`@@ -80,7 +80,7 @@ namespace Algorithm {`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`template<typename T>`
`83`		`- inline void Stack<T>::clear()`
	`83`	`+ inline void Stack<T>::Clear()`
`84`	`84`	`{`
`85`	`85`	`if (mStack != nullptr)`
`86`	`86`	`{`
`@@ -96,19 +96,19 @@ namespace Algorithm {`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`template<typename T>`
`99`		`- inline int Stack<T>::count() const`
	`99`	`+ inline int Stack<T>::Count() const`
`100`	`100`	`{`
`101`	`101`	`return mCount;`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`template<typename T>`
`105`		`- inline int Stack<T>::capacity() const`
	`105`	`+ inline int Stack<T>::Capacity() const`
`106`	`106`	`{`
`107`	`107`	`return mCapacity;`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`template<typename T>`
`111`		`- inline bool Stack<T>::initialize(int size)`
	`111`	`+ inline bool Stack<T>::Initialize(int size)`
`112`	`112`	`{`
`113`	`113`	`if (size <= 0)`
`114`	`114`	`{`
`@@ -125,7 +125,7 @@ namespace Algorithm {`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`template<typename T>`
`128`		`- inline bool Stack<T>::reallocation()`
	`128`	`+ inline bool Stack<T>::Reallocation()`
`129`	`129`	`{`
`130`	`130`	`if (mCapacity == 0)`
`131`	`131`	`{`
`@@ -149,7 +149,7 @@ namespace Algorithm {`
`149`	`149`	`}`
`150`	`150`
`151`	`151`	`template<typename T>`
`152`		`- inline bool Stack<T>::isCapacityEnough() const`
	`152`	`+ inline bool Stack<T>::IsCapacityEnough() const`
`153`	`153`	`{`
`154`	`154`	`return mCount < mCapacity;`
`155`	`155`	`}`