Implemented operator overloads for Reflection

src/include/Reflection/ReflectionProperty.h

@@ -20,8 +20,19 @@ namespace B3D{
 			ReflectionProperty(std::string key, T defaultValue, ReflectionType type, ReflectionDataTable * containerTable, void* extData = NULL, bool archivable = true, bool locked = false, bool propertyHidden = false);
 			ReflectionProperty(void);
 			~ReflectionProperty(void);
+			
+			T getValue();
+			T getValueClone();
+			T* getValuePtr();
+
+			void setValue(T);
+
 			void dispose();
 
+			//Too many
+			#include "ReflectionProperty_op_overload.h"
+
+
 		private:
 			std::string propertyName;
 			bool archivable;

src/include/Reflection/ReflectionProperty_impl.h

@@ -47,4 +47,27 @@ void ReflectionProperty<T>::dispose()
 		delete extData;
 		extData = NULL;
 	}
+}
+
+template<class T>
+T ReflectionProperty<T>::getValueClone()
+{
+	return T(value);
+}
+
+template<class T>
+T ReflectionProperty<T>::getValue()
+{
+	return *value;
+}
+
+template<class T>
+T* ReflectionProperty<T>::getValuePtr()
+{
+	return value;
+}
+
+template<class T>
+void ReflectionProperty<T>::setValue(T value){
+	this=value;
 }

src/include/Reflection/ReflectionProperty_op_overload.h

@@ -0,0 +1,175 @@
+			//Operator Overloads
+			T operator()()
+			{
+				return *value;
+			}
+			//Assignment Operators
+			T operator=(T nVal)
+			{
+				(*value) = nVal;
+				return *value;
+			}
+
+			T operator+=(T nVal)
+			{
+				(*value) += nVal;
+				return *value;
+			}
+
+			T operator-=(T nVal)
+			{
+				(*value)-= nVal;
+				return *value;
+			}
+
+			T operator/=(T nVal)
+			{
+				(*value) /= nVal;
+				return *value;
+			}
+			
+			T operator*=(T nVal)
+			{
+				(*value) *= nVal;
+				return *value;
+			}
+
+			T operator%=(T nVal)
+			{
+				(*value) %= nVal;
+				return *value;
+			}
+
+			T operator^=(T nVal)
+			{
+				(*value) ^= nVal;
+				return *value;
+			}
+
+			T operator&=(T nVal)
+			{
+				(*value) &= nVal;
+				return *value;
+			}
+
+			T operator|=(T nVal)
+			{
+				(*value) |= nVal;
+				return *value;
+			}
+
+			T operator>>=(T nVal)
+			{
+				(*value) >>= nVal;
+				return *value;
+			}
+
+			T operator<<=(T nVal)
+			{
+				(*value) <<= nVal;
+				return *value;
+			}
+
+
+			//Mathematical Operations
+			T operator+(T nVal)
+			{
+				return (*value) + nVal;
+			}
+
+			T operator-(T nVal)
+			{
+				return (*value) - nVal;
+			}
+
+			T operator*(T nVal)
+			{
+				return (*value) - nVal;
+			}
+
+			T operator/(T nVal)
+			{
+				return (*value) / nVal;
+			}
+
+			T operator%(T nVal)
+			{
+				return (*value) % nVal;
+			}
+
+			//Boolean operations
+			bool operator==(T nVal)
+			{
+				return (*value) == nVal;
+			}
+
+			bool operator!=(T nVal)
+			{
+				return (*value) != nVal;
+			}
+
+			bool operator<(T nVal)
+			{
+				return (*value) < nVal;
+			}
+
+			bool operator<=(T nVal)
+			{
+				return (*value) <= nVal;
+			}
+
+			bool operator>(T nVal)
+			{
+				return (*value) > nVal;
+			}
+
+			bool operator>=(T nVal)
+			{
+				return (*value) >= nVal;
+			}
+
+			T operator&&(T nVal)
+			{
+				return (*value) && nVal;
+			}
+
+			T operator||(T nVal)
+			{
+				return (*value) && nVal;
+			}
+
+			T operator!()
+			{
+				return !(*value);
+			}
+
+			//Bitwise operations
+			T operator&(T nVal)
+			{
+				return (*value) && nVal;
+			}
+
+			T operator|(T nVal)
+			{
+				return (*value) && nVal;
+			}
+
+			T operator>>(T nVal)
+			{
+				return (*value) >> nVal;
+			}
+
+			T operator<<(T nVal)
+			{
+				return (*value) << nVal;
+			}
+
+			T operator^(T nVal)
+			{
+				return (*value) ^ nVal;
+			}
+
+			T operator~()
+			{
+				return ~(*value);
+			}