etc: Change naming convention for base classes (prefix with "I")

include/ki/pclass/Property.h

@@ -10,19 +10,19 @@ namespace pclass
 	/**
  	 * TODO: Documentation
 	 */
-	class PropertyBase
+	class IProperty
 	{
 	public:
 		// Do not allow copy assignment. Once a property has been constructed,
 		// it shouldn't be able to change.
-		PropertyBase & operator=(const PropertyBase &that) = delete;
+		virtual IProperty &operator=(const IProperty &that) = delete;
 
-		PropertyBase(PropertyClass &object,
+		IProperty(PropertyClass &object,
 			const std::string &name, const Type &type);
-		virtual ~PropertyBase() {}
+		virtual ~IProperty() {}
 
-		PropertyBase(PropertyClass &object,
+		IProperty(PropertyClass &object,
-			const PropertyBase &that);
+			const IProperty &that);
 
 		const PropertyClass &get_instance() const;
 		std::string get_name() const;
@@ -51,19 +51,19 @@ namespace pclass
 	/**
 	 * TODO: Documentation
 	 */
-	class DynamicPropertyBase : public PropertyBase
+	class IDynamicProperty : public IProperty
 	{
 	public:
 		// Do not allow copy assignment. Once a property has been constructed,
 		// it shouldn't be able to change.
-		DynamicPropertyBase & operator=(const DynamicPropertyBase &that) = delete;
+		IDynamicProperty & operator=(const IDynamicProperty &that) = delete;
 
-		DynamicPropertyBase(PropertyClass &object,
+		IDynamicProperty(PropertyClass &object,
 			const std::string &name, const Type &type);
-		virtual ~DynamicPropertyBase() {}
+		virtual ~IDynamicProperty() {}
 
-		DynamicPropertyBase(PropertyClass &object,
+		IDynamicProperty(PropertyClass &object,
-			const DynamicPropertyBase &that);
+			const IDynamicProperty &that);
 
 		bool is_dynamic() const override;
 		virtual std::size_t get_element_count() const = 0;

include/ki/pclass/PropertyClass.h

@@ -19,7 +19,7 @@
 	: base(that)
 
 #define DERIVED_PCLASS(derived, base) class derived : public base
-#define PCLASS(n) DERIVED_PCLASS(n, _KI_PCLASS)
+#define PCLASS(derived) DERIVED_PCLASS(derived, _KI_PCLASS)
 
 #define PCLASS_CONSTRUCTOR(derived) \
 _KI_PCLASS_CONSTRUCTOR(derived) \
@@ -60,7 +60,7 @@ namespace pclass
 	 */
 	class PropertyClass
 	{
-		friend PropertyBase;
+		friend IProperty;
 
 	public:
 		explicit PropertyClass(const Type &type, const TypeSystem &type_system);
@@ -77,7 +77,7 @@ namespace pclass
 		virtual void on_created() const {}
 
 	protected:
-		void add_property(PropertyBase &prop);
+		void add_property(IProperty &prop);
 
 	private:
 		const Type *m_type;

include/ki/pclass/PropertyList.h

@@ -8,7 +8,7 @@ namespace ki
 namespace pclass
 {
 	class PropertyClass;
-	class PropertyBase;
+	class IProperty;
 
 	/**
 	 * TODO: Documentation
@@ -26,8 +26,8 @@ namespace pclass
 			friend PropertyList;
 
 		public:
-			PropertyBase &operator*() const;
+			IProperty &operator*() const;
-			PropertyBase *operator->() const;
+			IProperty *operator->() const;
 			iterator &operator++();
 			iterator operator++(int);
 			bool operator==(const iterator &that) const;
@@ -48,8 +48,8 @@ namespace pclass
 			friend PropertyList;
 
 		public:
-			const PropertyBase &operator*() const;
+			const IProperty &operator*() const;
-			const PropertyBase *operator->() const;
+			const IProperty *operator->() const;
 			const_iterator &operator++();
 			const_iterator operator++(int);
 			bool operator==(const const_iterator &that) const;
@@ -67,14 +67,14 @@ namespace pclass
 		bool has_property(const std::string &name) const;
 		bool has_property(hash_t hash) const;
 
-		PropertyBase &get_property(int index);
+		IProperty &get_property(int index);
-		const PropertyBase &get_property(int index) const;
+		const IProperty &get_property(int index) const;
 
-		PropertyBase &get_property(const std::string &name);
+		IProperty &get_property(const std::string &name);
-		const PropertyBase &get_property(const std::string &name) const;
+		const IProperty &get_property(const std::string &name) const;
 
-		PropertyBase &get_property(hash_t hash);
+		IProperty &get_property(hash_t hash);
-		const PropertyBase &get_property(hash_t hash) const;
+		const IProperty &get_property(hash_t hash) const;
 
 		iterator begin();
 		const_iterator begin() const;
@@ -83,12 +83,12 @@ namespace pclass
 		const_iterator end() const;
 
 	protected:
-		void add_property(PropertyBase &prop);
+		void add_property(IProperty &prop);
 
 	private:
-		std::vector<PropertyBase *> m_properties;
+		std::vector<IProperty *> m_properties;
-		std::map<std::string, PropertyBase *> m_property_name_lookup;
+		std::map<std::string, IProperty *> m_property_name_lookup;
-		std::map<hash_t, PropertyBase *> m_property_hash_lookup;
+		std::map<hash_t, IProperty *> m_property_hash_lookup;
 	};
 }
 }

include/ki/pclass/StaticProperty.h

@@ -326,7 +326,7 @@ namespace pclass
 	 * TODO: Documentation
 	 */
 	template <typename ValueT>
-	class StaticProperty : public PropertyBase
+	class StaticProperty : public IProperty
 	{
 		// Allow helper utilities access to m_value
 		friend value_object_helper<ValueT>;
@@ -339,19 +339,19 @@ namespace pclass
 
 		StaticProperty(PropertyClass &object,
 			const std::string &name, const Type &type)
-			: PropertyBase(object, name, type)
+			: IProperty(object, name, type)
 			, m_value(value_helper<ValueT>::construct(type))
 		{}
 
 		StaticProperty(PropertyClass &object,
 			const std::string &name, const Type &type, ValueT value)
-			: PropertyBase(object, name, type)
+			: IProperty(object, name, type)
 		{
 			m_value = value;
 		}
 
 		StaticProperty(PropertyClass &object, const StaticProperty<ValueT> &that)
-			: PropertyBase(object, that)
+			: IProperty(object, that)
 			, m_value(value_helper<ValueT>::copy(that))
 		{}
 

include/ki/pclass/TypeSystem.h

@@ -21,7 +21,6 @@ namespace pclass
 		~TypeSystem();
 
 		const HashCalculator &get_hash_calculator() const;
-		void set_hash_calculator(HashCalculator *hash_calculator);
 
 		bool has_type(const std::string &name) const;
 		bool has_type(hash_t hash) const;
@@ -51,7 +50,7 @@ namespace pclass
 		}
 
 		template <typename EnumT>
-		EnumType<EnumT> *define_enum(const std::string &name)
+		EnumType<EnumT> &define_enum(const std::string &name)
 		{
 			/*
 			auto *type = new EnumType<EnumT>(name, this);
@@ -70,6 +69,12 @@ namespace pclass
 	protected:
 		void define_type(Type *type);
 
+	private:
+		TypeList m_types;
+		TypeNameMap m_type_name_lookup;
+		TypeHashMap m_type_hash_lookup;
+		HashCalculator *m_hash_calculator;
+
 		template <class ClassT>
 		ClassType<ClassT> &define_class(
 			const std::string &name, const Type *base_class)
@@ -83,12 +88,6 @@ namespace pclass
 			define_type(type);
 			return *type;
 		}
-
-	private:
-		TypeList m_types;
-		TypeNameMap m_type_name_lookup;
-		TypeHashMap m_type_hash_lookup;
-		HashCalculator *m_hash_calculator;
 	};
 }
 }

include/ki/pclass/VectorProperty.h

@@ -300,8 +300,11 @@ namespace pclass
 	};
 	/// @endcond
 
+	/**
+	 *
+	 */
 	template <typename ValueT>
-	class VectorProperty : public std::vector<ValueT>, public DynamicPropertyBase
+	class VectorProperty : public std::vector<ValueT>, public IDynamicProperty
 	{
 	public:
 		// Do not allow copy assignment. Once a property has been constructed,
@@ -310,12 +313,12 @@ namespace pclass
 
 		VectorProperty(PropertyClass &object,
 			const std::string &name, const Type &type)
-			: DynamicPropertyBase(object, name, type)
+			: IDynamicProperty(object, name, type)
 		{}
 
 		VectorProperty(PropertyClass &object,
 			const VectorProperty<ValueT> &that)
-			: DynamicPropertyBase(object, that)
+			: IDynamicProperty(object, that)
 		{
 			// Copy vector values into this vector
 			for (auto i = 0; i < this->size(); i++)

include/ki/pclass/types/ClassType.h

@@ -12,24 +12,31 @@ namespace pclass
 	/**
 	 * TODO: Documentation
 	 */
-	class ClassTypeBase : public Type
+	class IClassType : public Type
 	{
 	public:
-		ClassTypeBase(const std::string &name,
+		IClassType(const std::string &name,
 			const Type *base_class, const TypeSystem &type_system);
-		virtual ~ClassTypeBase() {}
+		virtual ~IClassType() {}
+
+		void write_to(BitStream &stream, const Value &value) const override;
+		void read_from(BitStream &stream, Value &value) const override;
 
 		bool inherits(const Type &type) const;
 
+	protected:
+		virtual const PropertyClass &get_object_from_value(const Value &value) const = 0;
+		virtual PropertyClass &get_object_from_value(Value &value) const = 0;
+
 	private:
-		const ClassTypeBase *m_base_class;
+		const IClassType *m_base_class;
 	};
 
 	/**
-	* TODO: Documentation
+	 * TODO: Documentation
-	*/
+	 */
 	template <class ClassT>
-	class ClassType : public ClassTypeBase
+	class ClassType : public IClassType
 	{
 		// Ensure that ClassT inherits PropertyClass
 		static_assert(std::is_base_of<PropertyClass, ClassT>::value, "ClassT must inherit PropertyClass!");
@@ -37,27 +44,21 @@ namespace pclass
 	public:
 		ClassType(const std::string &name,
 			const Type *base_class, const TypeSystem &type_system)
-			: ClassTypeBase(name, base_class, type_system) {}
+			: IClassType(name, base_class, type_system) {}
 
 		PropertyClass *instantiate() const override
 		{
 			return new ClassT(*this, get_type_system());
 		}
 
-		void write_to(BitStream &stream, const Value &value) const override
+		const PropertyClass& get_object_from_value(const Value& value) const override
 		{
-			const auto &object = dynamic_cast<const PropertyClass &>(value.get<ClassT>());
+			return dynamic_cast<const PropertyClass &>(value.get<ClassT>());
-			const auto &properties = object.get_properties();
-			for (auto it = properties.begin(); it != properties.end(); ++it)
-				it->write_value_to(stream);
 		}
 
-		void read_from(BitStream &stream, Value &value) const override
+		PropertyClass& get_object_from_value(Value& value) const override
 		{
-			auto &object = dynamic_cast<PropertyClass &>(value.get<ClassT>());
+			return dynamic_cast<PropertyClass &>(value.get<ClassT>());
-			auto &properties = object.get_properties();
-			for (auto it = properties.begin(); it != properties.end(); ++it)
-				it->read_value_from(stream);
 		}
 	};
 }

include/ki/pclass/types/EnumType.h

@@ -26,7 +26,7 @@ namespace pclass
 		static_assert(std::is_enum<EnumT>::value, "EnumT must be an enum!");
 
 	public:
-		EnumType(std::string name, hash_t hash, TypeSystem *type_system);
+		EnumType(const std::string &name, const TypeSystem &type_system);
 	};
 }
-}
+}

include/ki/pclass/types/Type.h

@@ -18,8 +18,6 @@ namespace pclass
 	 */
 	class Type
 	{
-		friend class TypeSystem;
-
 	public:
 		enum class kind
 		{
@@ -42,7 +40,7 @@ namespace pclass
 		};
 
 		Type(const std::string &name, const TypeSystem &type_system);
-		virtual ~Type() { }
+		virtual ~Type() {}
 
 		std::string get_name() const;
 		hash_t get_hash() const;
@@ -60,12 +58,6 @@ namespace pclass
 		std::string m_name;
 		hash_t m_hash;
 		const TypeSystem &m_type_system;
-
-		/**
-		 * Called by a TypeSystem instance when it's HashCalculator
-		 * is changed.
-		 */
-		virtual void update_hash();
 	};
 
 	typedef std::vector<Type *> TypeList;

include/ki/serialization/SerializerBinary.h

@@ -41,7 +41,7 @@ namespace serialization
 		 * @param is_file Determines whether or not to write type sizes, and property headers.
 		 * @param flags Determines how serialized data is formatted.
 		 */
-		explicit SerializerBinary(const pclass::TypeSystem *type_system,
+		explicit SerializerBinary(const pclass::TypeSystem &type_system,
 			bool is_file, flags flags);
 		virtual ~SerializerBinary() {}
 
@@ -51,11 +51,11 @@ namespace serialization
 	protected:
 		virtual void presave_object(const pclass::PropertyClass *object, BitStream &stream) const;
 		void save_object(const pclass::PropertyClass *object, BitStream &stream) const;
-		void save_property(const pclass::PropertyBase &prop, BitStream &stream) const;
+		void save_property(const pclass::IProperty &prop, BitStream &stream) const;
 
 		virtual void preload_object(pclass::PropertyClass *&dest, BitStream &stream) const;
 		void load_object(pclass::PropertyClass *&dest, BitStream &stream) const;
-		void load_property(pclass::PropertyBase &prop, BitStream &stream) const;
+		void load_property(pclass::IProperty &prop, BitStream &stream) const;
 
 	private:
 		const pclass::TypeSystem *m_type_system;

include/ki/util/BitStream.h

@@ -15,7 +15,7 @@ namespace ki
 	/**
 	 *
 	 */
-	class BitBufferBase
+	class IBitBuffer
 	{
 		friend BitBufferSegment;
 
@@ -53,7 +53,7 @@ namespace ki
 			void set_bit(int bit);
 		};
 
-		virtual ~BitBufferBase() {};
+		virtual ~IBitBuffer() {};
 
 		/**
 		 * @returns 
@@ -153,9 +153,9 @@ namespace ki
 	};
 
 	/**
-	 * 
+	 * TODO: Documentation
 	 */
-	class BitBuffer : public BitBufferBase
+	class BitBuffer : public IBitBuffer
 	{
 	public:
 		explicit BitBuffer(std::size_t buffer_size = KI_BITBUFFER_DEFAULT_SIZE);
@@ -176,23 +176,23 @@ namespace ki
 		void resize(std::size_t new_size) override;
 
 		/**
-		 * @copydoc BitBufferBase::read<ValueT>(buffer_pos, uint8_t)
+		 * @copydoc IBitBuffer::read<ValueT>(buffer_pos, uint8_t)
 		 */
 		template <typename ValueT>
 		ValueT read(const buffer_pos position,
 			const uint8_t bits = bitsizeof<ValueT>::value) const
 		{
-			return BitBufferBase::read<ValueT>(position, bits);
+			return IBitBuffer::read<ValueT>(position, bits);
 		}
 
 		/**
-		 * @copydoc BitBufferBase::write<ValueT>(ValueT, buffer_pos, uint8_t)
+		 * @copydoc IBitBuffer::write<ValueT>(ValueT, buffer_pos, uint8_t)
 		 */
 		template <typename ValueT>
 		void write(const ValueT value, const buffer_pos position,
 			const uint8_t bits = bitsizeof<ValueT>::value)
 		{
-			return BitBufferBase::write<ValueT>(value, position, bits);
+			return IBitBuffer::write<ValueT>(value, position, bits);
 		}
 
 	protected:
@@ -205,12 +205,12 @@ namespace ki
 	};
 	
 	/**
-	 *
+	 * TODO: Documentation
 	 */
-	class BitBufferSegment : public BitBufferBase
+	class BitBufferSegment : public IBitBuffer
 	{
 	public:
-		BitBufferSegment(BitBufferBase &buffer, buffer_pos from, std::size_t bitsize);
+		BitBufferSegment(IBitBuffer &buffer, buffer_pos from, std::size_t bitsize);
 
 		std::size_t size() const override;
 		void resize(std::size_t new_size) override;
@@ -218,23 +218,23 @@ namespace ki
 		BitBufferSegment *segment(buffer_pos from, std::size_t bitsize) override;
 
 		/**
-		 * @copydoc BitBufferBase::read<ValueT>(buffer_pos, uint8_t)
+		 * @copydoc IBitBuffer::read<ValueT>(buffer_pos, uint8_t)
 		 */
 		template <typename ValueT>
 		ValueT read(const buffer_pos position,
 			const uint8_t bits = bitsizeof<ValueT>::value) const
 		{
-			return BitBufferBase::read<ValueT>(position, bits);
+			return IBitBuffer::read<ValueT>(position, bits);
 		}
 
 		/**
-		 * @copydoc BitBufferBase::write<ValueT>(ValueT, buffer_pos, uint8_t)
+		 * @copydoc IBitBuffer::write<ValueT>(ValueT, buffer_pos, uint8_t)
 		 */
 		template <typename ValueT>
 		void write(const ValueT value, const buffer_pos position,
 			const uint8_t bits = bitsizeof<ValueT>::value)
 		{
-			return BitBufferBase::write<ValueT>(value, position, bits);
+			return IBitBuffer::write<ValueT>(value, position, bits);
 		}
 
 	protected:
@@ -242,7 +242,7 @@ namespace ki
 		void write(uint64_t value, buffer_pos position, uint8_t bits) override;
 
 	private:
-		BitBufferBase *m_buffer;
+		IBitBuffer *m_buffer;
 		buffer_pos m_from;
 		std::size_t m_bitsize;
 	};
@@ -255,7 +255,7 @@ namespace ki
 	public:
 		using stream_pos = BitBuffer::buffer_pos;
 
-		explicit BitStream(BitBufferBase &buffer);
+		explicit BitStream(IBitBuffer &buffer);
 		virtual ~BitStream();
 
 		BitStream(const BitStream &that);
@@ -281,7 +281,7 @@ namespace ki
 		/**
 		* @returns The BitBuffer that the stream is reading/writing to.
 		*/
-		BitBufferBase &buffer() const;
+		IBitBuffer &buffer() const;
 
 		/**
 		 * Reads a value from the buffer.
@@ -333,7 +333,7 @@ namespace ki
 		void write_copy(uint8_t *src, std::size_t bitsize);
 
 	private:
-		BitBufferBase *m_buffer;
+		IBitBuffer *m_buffer;
 		stream_pos m_position;
 
 		/**

src/pclass/ClassType.cpp

@@ -6,7 +6,7 @@ namespace ki
 {
 namespace pclass
 {
-	ClassTypeBase::ClassTypeBase(const std::string& name,
+	IClassType::IClassType(const std::string& name,
 		const Type* base_class, const TypeSystem& type_system)
 		: Type(name, type_system)
 	{
@@ -19,16 +19,32 @@ namespace pclass
 			if (base_class->get_kind() != kind::CLASS)
 				throw runtime_error("base_class must be a class type!");
 
-			// Cast the base class up to a ClassTypeBase pointer
+			// Cast the base class up to a IClassType pointer
-			m_base_class = dynamic_cast<const ClassTypeBase *>(base_class);
+			m_base_class = dynamic_cast<const IClassType *>(base_class);
 			if (!m_base_class)
-				throw runtime_error("base_class must inherit ClassTypeBase!");
+				throw runtime_error("base_class must inherit IClassType!");
 		}
 		else
 			m_base_class = nullptr;
 	}
 
-	bool ClassTypeBase::inherits(const Type &type) const
+	void IClassType::write_to(BitStream &stream, const Value &value) const
+	{
+		const auto &object = get_object_from_value(value);
+		const auto &properties = object.get_properties();
+		for (auto it = properties.begin(); it != properties.end(); ++it)
+			it->write_value_to(stream);
+	}
+
+	void IClassType::read_from(BitStream &stream, Value &value) const
+	{
+		auto &object = get_object_from_value(value);
+		auto &properties = object.get_properties();
+		for (auto it = properties.begin(); it != properties.end(); ++it)
+			it->read_value_from(stream);
+	}
+
+	bool IClassType::inherits(const Type &type) const
 	{
 		// Types do not technically inherit from themselves, but it is more useful
 		// if they report that they do since these checks are to make sure that objects

src/pclass/Property.cpp

@@ -7,7 +7,7 @@ namespace ki
 {
 namespace pclass
 {
-	PropertyBase::PropertyBase(PropertyClass &object,
+	IProperty::IProperty(PropertyClass &object,
 		const std::string &name, const Type &type)
 	{
 		m_instance = &object;
@@ -23,8 +23,8 @@ namespace pclass
 		object.add_property(*this);
 	}
 
-	PropertyBase::PropertyBase(PropertyClass &object, 
+	IProperty::IProperty(PropertyClass &object, 
-		const PropertyBase &that)
+		const IProperty &that)
 	{
 		m_instance = &object;
 		m_name = that.m_name;
@@ -36,81 +36,81 @@ namespace pclass
 		object.add_property(*this);
 	}
 
-	const PropertyClass &PropertyBase::get_instance() const
+	const PropertyClass &IProperty::get_instance() const
 	{
 		return *m_instance;
 	}
 
-	std::string PropertyBase::get_name() const
+	std::string IProperty::get_name() const
 	{
 		return m_name;
 	}
 
-	hash_t PropertyBase::get_name_hash() const
+	hash_t IProperty::get_name_hash() const
 	{
 		return m_name_hash;
 	}
 
-	hash_t PropertyBase::get_full_hash() const
+	hash_t IProperty::get_full_hash() const
 	{
 		return m_full_hash;
 	}
 
-	const Type &PropertyBase::get_type() const
+	const Type &IProperty::get_type() const
 	{
 		return *m_type;
 	}
 
-	bool PropertyBase::is_pointer() const
+	bool IProperty::is_pointer() const
 	{
 		return false;
 	}
 
-	bool PropertyBase::is_dynamic() const
+	bool IProperty::is_dynamic() const
 	{
 		return false;
 	}
 
-	DynamicPropertyBase::DynamicPropertyBase(PropertyClass &object,
+	IDynamicProperty::IDynamicProperty(PropertyClass &object,
 		const std::string& name, const Type& type)
-		: PropertyBase(object, name, type)
+		: IProperty(object, name, type)
 	{}
 
-	DynamicPropertyBase::DynamicPropertyBase(PropertyClass &object,
+	IDynamicProperty::IDynamicProperty(PropertyClass &object,
-		const DynamicPropertyBase &that)
+		const IDynamicProperty &that)
-		: PropertyBase(object, that)
+		: IProperty(object, that)
 	{}
 
-	bool DynamicPropertyBase::is_dynamic() const
+	bool IDynamicProperty::is_dynamic() const
 	{
 		return true;
 	}
 
-	Value DynamicPropertyBase::get_value() const
+	Value IDynamicProperty::get_value() const
 	{
 		// The caller must specify an index
 		throw runtime_error("Called get_value() on a dynamic property. Use get_value(index) instead.");
 	}
 
-	const PropertyClass *DynamicPropertyBase::get_object() const
+	const PropertyClass *IDynamicProperty::get_object() const
 	{
 		// The caller must specify an index
 		throw runtime_error("Called get_object() on a dynamic property. Use get_object(index) instead.");
 	}
 
-	void DynamicPropertyBase::set_object(PropertyClass *object)
+	void IDynamicProperty::set_object(PropertyClass *object)
 	{
 		// The caller must specify an index
 		throw runtime_error("Called set_object() on a dynamic property. Use set_object(index) instead.");
 	}
 
-	void DynamicPropertyBase::write_value_to(BitStream &stream) const
+	void IDynamicProperty::write_value_to(BitStream &stream) const
 	{
 		// The caller must specify an index
 		throw runtime_error("Called write_value_to() on a dynamic property. Use write_value_to(index) instead.");
 	}
 
-	void DynamicPropertyBase::read_value_from(BitStream &stream)
+	void IDynamicProperty::read_value_from(BitStream &stream)
 	{
 		// The caller must specify an index
 		throw runtime_error("Called read_value_from() on a dynamic property. Use read_value_from(index) instead.");

src/pclass/PropertyClass.cpp

@@ -42,7 +42,7 @@ namespace pclass
 		return new PropertyClass(*this);
 	}
 
-	void PropertyClass::add_property(PropertyBase &prop)
+	void PropertyClass::add_property(IProperty &prop)
 	{
 		m_properties.add_property(prop);
 	}

src/pclass/PropertyList.cpp

@@ -8,12 +8,12 @@ namespace ki
 {
 namespace pclass
 {
-	PropertyBase &PropertyList::iterator::operator*() const
+	IProperty &PropertyList::iterator::operator*() const
 	{
 		return m_list->get_property(m_index);
 	}
 
-	PropertyBase *PropertyList::iterator::operator->() const
+	IProperty *PropertyList::iterator::operator->() const
 	{
 		return &operator*();
 	}
@@ -48,12 +48,12 @@ namespace pclass
 		m_index = index;
 	}
 
-	const PropertyBase &PropertyList::const_iterator::operator*() const
+	const IProperty &PropertyList::const_iterator::operator*() const
 	{
 		return m_list->get_property(m_index);
 	}
 
-	const PropertyBase *PropertyList::const_iterator::operator->() const
+	const IProperty *PropertyList::const_iterator::operator->() const
 	{
 		return &operator*();
 	}
@@ -105,7 +105,7 @@ namespace pclass
 			!= m_property_hash_lookup.end();
 	}
 
-	PropertyBase &PropertyList::get_property(const int index)
+	IProperty &PropertyList::get_property(const int index)
 	{
 		if (index >= 0 && index < m_properties.size())
 			return *m_properties[index];
@@ -116,7 +116,7 @@ namespace pclass
 		throw runtime_error(oss.str());
 	}
 
-	PropertyBase& PropertyList::get_property(const std::string& name)
+	IProperty& PropertyList::get_property(const std::string& name)
 	{
 		const auto it = m_property_name_lookup.find(name);
 		if (it != m_property_name_lookup.end())
@@ -127,7 +127,7 @@ namespace pclass
 		throw runtime_error(oss.str());
 	}
 
-	PropertyBase& PropertyList::get_property(const hash_t hash)
+	IProperty& PropertyList::get_property(const hash_t hash)
 	{
 		const auto it = m_property_hash_lookup.find(hash);
 		if (it != m_property_hash_lookup.end())
@@ -140,7 +140,7 @@ namespace pclass
 		throw runtime_error(oss.str());
 	}
 
-	const PropertyBase &PropertyList::get_property(const int index) const
+	const IProperty &PropertyList::get_property(const int index) const
 	{
 		if (index >= 0 && index < m_properties.size())
 			return *m_properties[index];
@@ -151,7 +151,7 @@ namespace pclass
 		throw runtime_error(oss.str());
 	}
 
-	const PropertyBase& PropertyList::get_property(const std::string &name) const
+	const IProperty& PropertyList::get_property(const std::string &name) const
 	{
 		const auto it = m_property_name_lookup.find(name);
 		if (it != m_property_name_lookup.end())
@@ -162,7 +162,7 @@ namespace pclass
 		throw runtime_error(oss.str());
 	}
 
-	const PropertyBase &PropertyList::get_property(const hash_t hash) const
+	const IProperty &PropertyList::get_property(const hash_t hash) const
 	{
 		const auto it = m_property_hash_lookup.find(hash);
 		if (it != m_property_hash_lookup.end())
@@ -195,7 +195,7 @@ namespace pclass
 		return const_iterator(*this, m_properties.size());
 	}
 
-	void PropertyList::add_property(PropertyBase &prop)
+	void PropertyList::add_property(IProperty &prop)
 	{
 		// Make sure a property with the same name as another isn't being added
 		if (has_property(prop.get_name()))

src/pclass/Type.cpp

@@ -60,13 +60,6 @@ namespace pclass
 		throw runtime_error(oss.str());
 	}
 
-	void Type::update_hash()
-	{
-		m_hash = m_type_system
-			.get_hash_calculator()
-			.calculate_type_hash(m_name);
-	}
-
 	void assert_type_match(
 		const Type &expected,
 		const Type &actual,
@@ -77,7 +70,7 @@ namespace pclass
 		if (allow_inheritance &&
 			expected.get_kind() == Type::kind::CLASS)
 		{
-			const auto &actual_class = dynamic_cast<const ClassTypeBase &>(actual);
+			const auto &actual_class = dynamic_cast<const IClassType &>(actual);
 			if (actual_class.inherits(expected))
 				return;
 		}

src/pclass/TypeSystem.cpp

@@ -90,26 +90,9 @@ namespace pclass
 		// Make sure the hash calculator isn't null
 		if (m_hash_calculator == nullptr)
 			throw runtime_error("TypeSystem::get_hash_calculator() called but hash calculator is null.");
-
 		return *m_hash_calculator;
 	}
 
-	void TypeSystem::set_hash_calculator(HashCalculator* hash_calculator)
-	{
-		// Update the hash calculator
-		m_hash_calculator = hash_calculator;
-
-		// Iterate through all types and recalculate their hash
-		m_type_hash_lookup.clear();
-		for (auto it = m_types.begin(); it != m_types.end(); ++it)
-		{
-			// Add the new hash to lookup
-			auto *type = *it;
-			type->update_hash();
-			m_type_hash_lookup[type->get_hash()] = type;
-		}
-	}
-
 	bool TypeSystem::has_type(const std::string &name) const
 	{
 		return m_type_name_lookup.find(name) != m_type_name_lookup.end();

src/serialization/SerializerBinary.cpp

@@ -6,16 +6,16 @@ namespace ki
 {
 namespace serialization
 {
-	SerializerBinary::SerializerBinary(const pclass::TypeSystem* type_system,
+	SerializerBinary::SerializerBinary(const pclass::TypeSystem &type_system,
 		const bool is_file, const flags flags)
 	{
-		m_type_system = type_system;
+		m_type_system = &type_system;
 		m_is_file = is_file;
 		m_flags = flags;
 		m_root_object = nullptr;
 	}
 
-	void SerializerBinary::save(const pclass::PropertyClass* object, BitStream &stream)
+	void SerializerBinary::save(const pclass::PropertyClass *object, BitStream &stream)
 	{
 		// Write the serializer flags
 		if (FLAG_IS_SET(m_flags, flags::WRITE_SERIALIZER_FLAGS))
@@ -164,7 +164,7 @@ namespace serialization
 		stream.seek(BitStream::stream_pos(stream.tell().as_bytes(), 0));
 	}
 
-	void SerializerBinary::save_property(const pclass::PropertyBase &prop, BitStream &stream) const
+	void SerializerBinary::save_property(const pclass::IProperty &prop, BitStream &stream) const
 	{
 		// Remember where we started writing the property data
 		const auto start_pos = stream.tell();
@@ -181,9 +181,9 @@ namespace serialization
 		auto &property_type = prop.get_type();
 		if (prop.is_dynamic())
 		{
-			// Cast the property to a DynamicPropertyBase
+			// Cast the property to a IDynamicProperty
 			const auto &dynamic_property =
-				dynamic_cast<const pclass::DynamicPropertyBase &>(prop);
+				dynamic_cast<const pclass::IDynamicProperty &>(prop);
 
 			// Write the number of elements
 			stream.write<uint32_t>(dynamic_property.get_element_count());
@@ -239,7 +239,7 @@ namespace serialization
 		BitStream &stream, const std::size_t size)
 	{
 		// Create a new stream that reads a segment of the stream given to us
-		BitBufferBase *buffer = stream.buffer().segment(stream.tell(), size * 8);
+		IBitBuffer *buffer = stream.buffer().segment(stream.tell(), size * 8);
 		auto segment_stream = BitStream(*buffer);
 		stream.seek(stream.tell() + size * 8, false);
 
@@ -380,13 +380,13 @@ namespace serialization
 		stream.seek(BitStream::stream_pos(stream.tell().as_bytes(), 0), false);
 	}
 
-	void SerializerBinary::load_property(pclass::PropertyBase &prop, BitStream &stream) const
+	void SerializerBinary::load_property(pclass::IProperty &prop, BitStream &stream) const
 	{
 		auto &property_type = prop.get_type();
 		if (prop.is_dynamic())
 		{
 			auto &dynamic_property =
-				dynamic_cast<pclass::DynamicPropertyBase &>(prop);
+				dynamic_cast<pclass::IDynamicProperty &>(prop);
 
 			// How many elements are there in this dynamic property?
 			const auto element_count = stream.read<uint32_t>();

src/util/BitStream.cpp

@@ -6,39 +6,39 @@
 
 namespace ki
 {
-	BitBufferBase::buffer_pos::buffer_pos(const uint32_t byte, const int bit)
+	IBitBuffer::buffer_pos::buffer_pos(const uint32_t byte, const int bit)
 	{
 		m_byte = byte;
 		set_bit(bit);
 	}
 
-	BitBufferBase::buffer_pos::buffer_pos(const buffer_pos& cp)
+	IBitBuffer::buffer_pos::buffer_pos(const buffer_pos& cp)
 	{
 		m_byte = cp.m_byte;
 		set_bit(cp.m_bit);
 	}
 
-	uint32_t BitBufferBase::buffer_pos::as_bytes() const
+	uint32_t IBitBuffer::buffer_pos::as_bytes() const
 	{
 		return m_byte + (m_bit > 0 ? 1 : 0);
 	}
 
-	uint32_t BitBufferBase::buffer_pos::as_bits() const
+	uint32_t IBitBuffer::buffer_pos::as_bits() const
 	{
 		return (m_byte * 8) + m_bit;
 	}
 
-	uint32_t BitBufferBase::buffer_pos::get_byte() const
+	uint32_t IBitBuffer::buffer_pos::get_byte() const
 	{
 		return m_byte;
 	}
 
-	uint8_t BitBufferBase::buffer_pos::get_bit() const
+	uint8_t IBitBuffer::buffer_pos::get_bit() const
 	{
 		return m_bit;
 	}
 
-	void BitBufferBase::buffer_pos::set_bit(int bit)
+	void IBitBuffer::buffer_pos::set_bit(int bit)
 	{
 		if (bit < 0)
 		{
@@ -55,7 +55,7 @@ namespace ki
 			m_bit = bit;
 	}
 
-	BitBufferBase::buffer_pos BitBufferBase::buffer_pos::operator+(
+	IBitBuffer::buffer_pos IBitBuffer::buffer_pos::operator+(
 		const buffer_pos &rhs) const
 	{
 		return buffer_pos(
@@ -63,7 +63,7 @@ namespace ki
 		);
 	}
 
-	BitBufferBase::buffer_pos BitBufferBase::buffer_pos::operator-(
+	IBitBuffer::buffer_pos IBitBuffer::buffer_pos::operator-(
 		const buffer_pos &rhs) const
 	{
 		return buffer_pos(
@@ -71,7 +71,7 @@ namespace ki
 		);
 	}
 
-	BitBufferBase::buffer_pos BitBufferBase::buffer_pos::operator+(
+	IBitBuffer::buffer_pos IBitBuffer::buffer_pos::operator+(
 		const int& rhs) const
 	{
 		return buffer_pos(
@@ -79,7 +79,7 @@ namespace ki
 		);
 	}
 
-	BitBufferBase::buffer_pos BitBufferBase::buffer_pos::operator-(
+	IBitBuffer::buffer_pos IBitBuffer::buffer_pos::operator-(
 		const int& rhs) const
 	{
 		return buffer_pos(
@@ -87,7 +87,7 @@ namespace ki
 		);
 	}
 
-	BitBufferBase::buffer_pos& BitBufferBase::buffer_pos::operator+=(
+	IBitBuffer::buffer_pos& IBitBuffer::buffer_pos::operator+=(
 		const buffer_pos rhs)
 	{
 		m_byte += rhs.m_byte;
@@ -95,7 +95,7 @@ namespace ki
 		return *this;
 	}
 
-	BitBufferBase::buffer_pos& BitBufferBase::buffer_pos::operator-=(
+	IBitBuffer::buffer_pos& IBitBuffer::buffer_pos::operator-=(
 		const buffer_pos rhs)
 	{
 		m_byte -= rhs.m_byte;
@@ -103,51 +103,51 @@ namespace ki
 		return *this;
 	}
 
-	BitBufferBase::buffer_pos& BitBufferBase::buffer_pos::operator+=(const int bits)
+	IBitBuffer::buffer_pos& IBitBuffer::buffer_pos::operator+=(const int bits)
 	{
 		set_bit(m_bit + bits);
 		return *this;
 	}
 
-	BitBufferBase::buffer_pos& BitBufferBase::buffer_pos::operator-=(const int bits)
+	IBitBuffer::buffer_pos& IBitBuffer::buffer_pos::operator-=(const int bits)
 	{
 		set_bit(m_bit - bits);
 		return *this;
 	}
 
-	BitBufferBase::buffer_pos& BitBufferBase::buffer_pos::operator++()
+	IBitBuffer::buffer_pos& IBitBuffer::buffer_pos::operator++()
 	{
 		set_bit(m_bit + 1);
 		return *this;
 	}
 
-	BitBufferBase::buffer_pos& BitBufferBase::buffer_pos::operator--()
+	IBitBuffer::buffer_pos& IBitBuffer::buffer_pos::operator--()
 	{
 		set_bit(m_bit - 1);
 		return *this;
 	}
 
-	BitBufferBase::buffer_pos BitBufferBase::buffer_pos::operator++(int increment)
+	IBitBuffer::buffer_pos IBitBuffer::buffer_pos::operator++(int increment)
 	{
 		auto copy(*this);
 		++(*this);
 		return copy;
 	}
 
-	BitBufferBase::buffer_pos BitBufferBase::buffer_pos::operator--(int increment)
+	IBitBuffer::buffer_pos IBitBuffer::buffer_pos::operator--(int increment)
 	{
 		auto copy(*this);
 		--(*this);
 		return copy;
 	}
 
-	BitBufferSegment *BitBufferBase::segment(
+	BitBufferSegment *IBitBuffer::segment(
 		const buffer_pos from, const std::size_t bitsize)
 	{
 		return new BitBufferSegment(*this, from, bitsize);
 	}
 
-	void BitBufferBase::write_copy(uint8_t *src,
+	void IBitBuffer::write_copy(uint8_t *src,
 		buffer_pos position, const std::size_t bitsize)
 	{
 		auto bits_left = bitsize;
@@ -160,7 +160,7 @@ namespace ki
 		}
 	}
 
-	void BitBufferBase::read_copy(uint8_t *dst,
+	void IBitBuffer::read_copy(uint8_t *dst,
 		buffer_pos position, const std::size_t bitsize) const
 	{
 		auto bits_left = bitsize;
@@ -242,7 +242,8 @@ namespace ki
 			const uint8_t bit_mask = (1 << bit_count) - 1 << position.get_bit();
 
 			// Read the bits from the current byte and position them on the least-signficant bit
-			const uint8_t bits_value = (m_buffer[position.get_byte()] & bit_mask) >> position.get_bit();
+			const auto &buffer_value = m_buffer[position.get_byte()];
+			const uint8_t bits_value = (buffer_value & bit_mask) >> position.get_bit();
 
 			// Position the value of the bits we just read based on how many bits of the value 
 			// we've already read
@@ -274,14 +275,17 @@ namespace ki
 			// Find the bit-mask based on how many bits are being written, and how many bits we've
 			// already written
 			const uint8_t written_bits = bits - unwritten_bits;
-			const auto bit_mask = static_cast<uint64_t>((1 << bit_count) - 1) << written_bits;
+			auto bit_mask_abs = static_cast<uint64_t>((1 << bit_count) - 1);
+			const auto bit_mask_rel = bit_mask_abs << written_bits;
 
 			// Get the bits from the value and position them at the current bit position
-			uint8_t value_byte = ((value & bit_mask) >> written_bits) & 0xFF;
+			uint8_t value_byte = ((value & bit_mask_rel) >> written_bits) & 0xFF;
 			value_byte <<= position.get_bit();
+			bit_mask_abs <<= position.get_bit();
 
 			// Write the bits into the byte we're currently at
-			m_buffer[position.get_byte()] |= value_byte;
+			auto &current_value = m_buffer[position.get_byte()];
+			current_value = current_value & (~bit_mask_abs & 0xFF) | value_byte;
 			unwritten_bits -= bit_count;
 
 			// Move forward the number of bits we just wrote
@@ -289,7 +293,7 @@ namespace ki
 		}
 	}
 
-	BitBufferSegment::BitBufferSegment(BitBufferBase& buffer,
+	BitBufferSegment::BitBufferSegment(IBitBuffer& buffer,
 		const buffer_pos from, const std::size_t bitsize)
 	{
 		m_buffer = &buffer;
@@ -343,7 +347,7 @@ namespace ki
 		m_buffer->write(value, m_from + position, bits);
 	}
 
-	BitStream::BitStream(BitBufferBase &buffer)
+	BitStream::BitStream(IBitBuffer &buffer)
 	{
 		m_buffer = &buffer;
 		m_position = stream_pos(0, 0);
@@ -367,7 +371,7 @@ namespace ki
 		return *this;
 	}
 
-	BitBufferBase::buffer_pos BitStream::tell() const
+	IBitBuffer::buffer_pos BitStream::tell() const
 	{
 		return m_position;
 	}
@@ -384,7 +388,7 @@ namespace ki
 		return m_buffer->size();
 	}
 
-	BitBufferBase &BitStream::buffer() const
+	IBitBuffer &BitStream::buffer() const
 	{
 		return *m_buffer;
 	}