Simplified the database.

include/ehs/db/DbVar.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "ehs/Types.h"
-#include "DbType.h"
 #include "ehs/Serializer.h"
 
 namespace ehs
@@ -13,20 +12,18 @@ namespace ehs
 	{
 	private:
 		friend class DbObject;
-		friend class DbVarTmpl;
 
 		UInt_64 hashId;
 		DbObject *parent;
-		DbVarTmpl *master;
+		Byte *value;
 		UInt_64 size;
-		Byte *data;
 
 	public:
 		~DbVar();
 
 		DbVar();
 
-		DbVar(UInt_64 hashId, DbVarTmpl *master);
+		DbVar(UInt_64 hashId, const DbVarTmpl *master);
 
 		DbVar(DbVar &&var) noexcept;
 
@@ -40,14 +37,66 @@ namespace ehs
 
 		UInt_64 GetHashId() const;
 
+		template<typename T>
+		void SetValueArray(const T* const newValue, const UInt_64 newSize)
+		{
+			size = sizeof(T) * newSize;
+
+			value = new Byte[size];
+
+			Util::Copy(value, newValue, size);
+		}
+
+		template<typename T = Char_8>
+		void SetValueStr(const T * const newValue)
+		{
+			size = sizeof(T) * Str<Char_8, UInt_64>::Len(newValue);
+
+			value = new Byte[size];
+
+			Util::Copy(value, newValue, size);
+		}
+
+		template<typename T = Char_8, typename I = UInt_64>
+		void SetValueStr(const Str<T, I>& newValue)
+		{
+			size = newValue.Size(true);
+
+			value = new Byte[size];
+
+			Util::Copy(value, &newValue[0], size);
+		}
+
+		template<typename T>
+		void SetValue(const Byte* newValue)
+		{
+			size = sizeof(T);
+
+			value = new Byte[size];
+
+			Util::Copy(value, newValue, size);
+		}
+
+		template<typename T>
+		T* GetValueArray() const
+		{
+			return (T*)value;
+		}
+
+		template<typename T = Char_8, typename I = UInt_64>
+		Str<T, I> GetValueStr() const
+		{
+			return {(T*)value, size / sizeof(T)};
+		}
+
+		template<typename T>
+		T GetValue() const
+		{
+			return *(T*)value;
+		}
+
 		UInt_64 GetSize() const;
 
-		void SetData(UInt_64 newSize, const Byte* newData);
-
-		void SetData(const Byte* newData);
-
-		Byte* GetData() const;
-
 	private:
 		void Serialize(Serializer<UInt_64> &data) const;