SeanOMik
/
libki
mirror of https://github.com/SeanOMik/libki.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

This commit is contained in:
Joshua Scott 2018-12-01 17:16:40 +00:00
parent 34bc3d30bc
commit 6a213c18d4
19 changed files with 189 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
include/ki/pclass/Property.h
View File

@ -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,
const PropertyBase &that);
IProperty(PropertyClass &object,
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,
const DynamicPropertyBase &that);
IDynamicProperty(PropertyClass &object,
const IDynamicProperty &that);
bool is_dynamic() const override;
virtual std::size_t get_element_count() const = 0;

6
include/ki/pclass/PropertyClass.h
View File

@ -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;

30
include/ki/pclass/PropertyList.h
View File

@ -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;
PropertyBase *operator->() const;
IProperty &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 PropertyBase *operator->() const;
const IProperty &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);
const PropertyBase &get_property(int index) const;
IProperty &get_property(int index);
const IProperty &get_property(int index) const;
PropertyBase &get_property(const std::string &name);
const PropertyBase &get_property(const std::string &name) const;
IProperty &get_property(const std::string &name);
const IProperty &get_property(const std::string &name) const;
PropertyBase &get_property(hash_t hash);
const PropertyBase &get_property(hash_t hash) const;
IProperty &get_property(hash_t hash);
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::map<std::string, PropertyBase *> m_property_name_lookup;
std::map<hash_t, PropertyBase *> m_property_hash_lookup;
std::vector<IProperty *> m_properties;
std::map<std::string, IProperty *> m_property_name_lookup;
std::map<hash_t, IProperty *> m_property_hash_lookup;
};
}
}

8
include/ki/pclass/StaticProperty.h
View File

@ -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))
{}

15
include/ki/pclass/TypeSystem.h
View File

@ -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;
};
}
}

9
include/ki/pclass/VectorProperty.h
View File

@ -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++)

33
include/ki/pclass/types/ClassType.h
View File

@ -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
*/
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>());
const auto &properties = object.get_properties();
for (auto it = properties.begin(); it != properties.end(); ++it)
it->write_value_to(stream);
return dynamic_cast<const PropertyClass &>(value.get<ClassT>());
}
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>());
auto &properties = object.get_properties();
for (auto it = properties.begin(); it != properties.end(); ++it)
it->read_value_from(stream);
return dynamic_cast<PropertyClass &>(value.get<ClassT>());
}
};
}

2
include/ki/pclass/types/EnumType.h
View File

@ -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);
};
}
}

8
include/ki/pclass/types/Type.h
View File

@ -18,8 +18,6 @@ namespace pclass
*/
class Type
{
friend class TypeSystem;
public:
enum class kind
{
@ -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;

6
include/ki/serialization/SerializerBinary.h
View File

@ -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;

38
include/ki/util/BitStream.h
View File

@ -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;
/**

26
src/pclass/ClassType.cpp
View File

@ -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
m_base_class = dynamic_cast<const ClassTypeBase *>(base_class);
// Cast the base class up to a IClassType pointer
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

42
src/pclass/Property.cpp
View File

@ -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,
const PropertyBase &that)
IProperty::IProperty(PropertyClass &object,
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,
const DynamicPropertyBase &that)
: PropertyBase(object, that)
IDynamicProperty::IDynamicProperty(PropertyClass &object,
const IDynamicProperty &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.");

2
src/pclass/PropertyClass.cpp
View File

@ -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);
}

22
src/pclass/PropertyList.cpp
View File

@ -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()))

9
src/pclass/Type.cpp
View File

@ -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;
}

17
src/pclass/TypeSystem.cpp
View File

@ -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();

16
src/serialization/SerializerBinary.cpp
View File

@ -6,10 +6,10 @@ 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;
@ -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>();

64
src/util/BitStream.cpp
View File

@ -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;
}