229 lines
7.8 KiB
C++
229 lines
7.8 KiB
C++
#ifndef U_CORE_PROPERTY_H
|
|
#define U_CORE_PROPERTY_H
|
|
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <typeinfo>
|
|
#include <typeindex> // Added
|
|
#include <boost/serialization/nvp.hpp>
|
|
#include <boost/lexical_cast.hpp>
|
|
#include "Core/Archives.h"
|
|
#include "Core/Signal.h"
|
|
#include "Core/Object.h"
|
|
|
|
namespace uLib {
|
|
|
|
/**
|
|
* @brief Base class for properties to allow runtime listing and identification.
|
|
*/
|
|
class PropertyBase : public Object {
|
|
public:
|
|
virtual ~PropertyBase() {}
|
|
virtual const std::string& GetName() const = 0;
|
|
virtual const char* GetTypeName() const = 0;
|
|
virtual std::string GetValueAsString() const = 0;
|
|
virtual std::type_index GetTypeIndex() const = 0; // Added
|
|
|
|
// Signal support
|
|
signals:
|
|
virtual void Updated() override { ULIB_SIGNAL_EMIT(PropertyBase::Updated); }
|
|
|
|
// Serialization support for different uLib archives
|
|
virtual void serialize(Archive::xml_oarchive & ar, const unsigned int version) = 0;
|
|
virtual void serialize(Archive::xml_iarchive & ar, const unsigned int version) = 0;
|
|
virtual void serialize(Archive::text_oarchive & ar, const unsigned int version) = 0;
|
|
virtual void serialize(Archive::text_iarchive & ar, const unsigned int version) = 0;
|
|
virtual void serialize(Archive::hrt_oarchive & ar, const unsigned int version) = 0;
|
|
virtual void serialize(Archive::hrt_iarchive & ar, const unsigned int version) = 0;
|
|
virtual void serialize(Archive::log_archive & ar, const unsigned int version) = 0;
|
|
};
|
|
|
|
/**
|
|
* @brief Template class for typed properties.
|
|
*/
|
|
template <typename T>
|
|
class Property : public PropertyBase {
|
|
public:
|
|
// PROXY: Use an existing variable as back-end storage
|
|
Property(Object* owner, const std::string& name, T* valuePtr)
|
|
: m_owner(owner), m_name(name), m_value(valuePtr), m_own(false) {
|
|
if (m_owner) {
|
|
m_owner->RegisterProperty(this);
|
|
}
|
|
}
|
|
|
|
// MANAGED: Create and own internal storage
|
|
Property(Object* owner, const std::string& name, const T& defaultValue = T())
|
|
: m_owner(owner), m_name(name), m_value(new T(defaultValue)), m_own(true) {
|
|
if (m_owner) {
|
|
m_owner->RegisterProperty(this);
|
|
}
|
|
}
|
|
|
|
virtual ~Property() {
|
|
if (m_own) delete m_value;
|
|
}
|
|
|
|
// Identification
|
|
virtual const std::string& GetName() const override { return m_name; }
|
|
virtual const char* GetTypeName() const override { return typeid(T).name(); }
|
|
virtual std::type_index GetTypeIndex() const override { return std::type_index(typeid(T)); }
|
|
|
|
|
|
std::string GetValueAsString() const override {
|
|
try {
|
|
return boost::lexical_cast<std::string>(*m_value);
|
|
} catch (const boost::bad_lexical_cast&) {
|
|
std::stringstream ss;
|
|
ss << *m_value;
|
|
return ss.str();
|
|
}
|
|
}
|
|
|
|
// Accessors
|
|
const T& Get() const { return *m_value; }
|
|
void Set(const T& value) {
|
|
if (*m_value != value) {
|
|
*m_value = value;
|
|
ULIB_SIGNAL_EMIT(Property<T>::PropertyChanged);
|
|
this->Updated();
|
|
if (m_owner) m_owner->Updated();
|
|
}
|
|
}
|
|
|
|
// Operators for seamless usage
|
|
operator const T&() const { return *m_value; }
|
|
Property& operator=(const T& value) {
|
|
Set(value);
|
|
return *this;
|
|
}
|
|
|
|
// Signals
|
|
signals:
|
|
virtual void PropertyChanged() { ULIB_SIGNAL_EMIT(Property<T>::PropertyChanged); }
|
|
|
|
// Serialization
|
|
template <class ArchiveT>
|
|
void serialize_impl(ArchiveT & ar, const unsigned int version) {
|
|
ar & boost::serialization::make_nvp(m_name.c_str(), *m_value);
|
|
}
|
|
|
|
void serialize(Archive::xml_oarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
|
|
void serialize(Archive::xml_iarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
|
|
void serialize(Archive::text_oarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
|
|
void serialize(Archive::text_iarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
|
|
void serialize(Archive::hrt_oarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
|
|
void serialize(Archive::hrt_iarchive & ar, const unsigned int v) override { serialize_impl(ar, v); }
|
|
void serialize(Archive::log_archive & ar, const unsigned int v) override { serialize_impl(ar, v); }
|
|
|
|
private:
|
|
std::string m_name;
|
|
T* m_value;
|
|
bool m_own;
|
|
Object* m_owner;
|
|
};
|
|
|
|
/**
|
|
* @brief Conveninent typedefs for common property types.
|
|
*/
|
|
typedef Property<std::string> StringProperty;
|
|
typedef Property<int> IntProperty;
|
|
typedef Property<unsigned int> UIntProperty;
|
|
typedef Property<long> LongProperty;
|
|
typedef Property<unsigned long> ULongProperty;
|
|
typedef Property<float> FloatProperty;
|
|
typedef Property<double> DoubleProperty;
|
|
typedef Property<Bool_t> BoolProperty;
|
|
|
|
/**
|
|
* @brief Macro to simplify property declaration within a class.
|
|
* Usage: ULIB_PROPERTY(float, Width, 1.0f)
|
|
* It creates a raw member m_Width and a Property proxy Width.
|
|
*/
|
|
#define ULIB_PROPERTY(type, name, defaultValue) \
|
|
type m_##name = defaultValue; \
|
|
Property<type> name = Property<type>(this, #name, &m_##name);
|
|
|
|
|
|
} // namespace uLib
|
|
|
|
namespace uLib {
|
|
namespace Archive {
|
|
class property_register_archive;
|
|
} // namespace Archive
|
|
} // namespace uLib
|
|
|
|
namespace boost {
|
|
namespace archive {
|
|
namespace detail {
|
|
template <>
|
|
class interface_oarchive<uLib::Archive::property_register_archive>
|
|
: public uLib_interface_oarchive<uLib::Archive::property_register_archive> {};
|
|
} // namespace detail
|
|
} // namespace archive
|
|
} // namespace boost
|
|
|
|
namespace uLib {
|
|
namespace Archive {
|
|
|
|
/**
|
|
* @brief A special archive that creates and registers Property proxies
|
|
* for any member it encounters wrapped in HRP().
|
|
*/
|
|
class property_register_archive :
|
|
public boost::archive::detail::common_oarchive<property_register_archive>
|
|
{
|
|
Object* m_Object;
|
|
public:
|
|
friend class boost::archive::detail::interface_oarchive<property_register_archive>;
|
|
friend class boost::archive::save_access;
|
|
|
|
typedef boost::archive::detail::common_oarchive<property_register_archive> detail_common_oarchive;
|
|
|
|
property_register_archive(Object* obj) :
|
|
boost::archive::detail::common_oarchive<property_register_archive>(boost::archive::no_header),
|
|
m_Object(obj) {}
|
|
|
|
// Core logic: encounter HRP -> Create Dynamic Property
|
|
template<class T>
|
|
void save_override(const boost::serialization::hrp<T> &t) {
|
|
if (m_Object) {
|
|
// We use const_cast because we are just creating a proxy to the member
|
|
m_Object->RegisterDynamicProperty(
|
|
new Property<T>(m_Object, t.name(), &const_cast<boost::serialization::hrp<T>&>(t).value())
|
|
);
|
|
}
|
|
}
|
|
|
|
// Handle standard NVPs by recursing (important for base classes)
|
|
template<class T>
|
|
void save_override(const boost::serialization::nvp<T> &t) {
|
|
boost::archive::detail::common_oarchive<property_register_archive>::save_override(t.const_value());
|
|
}
|
|
|
|
// Ignore everything else
|
|
template<class T> void save_override(const T &t) {}
|
|
|
|
// Required attribute overrides for common_oarchive
|
|
void save_override(const boost::archive::object_id_type & t) {}
|
|
void save_override(const boost::archive::object_reference_type & t) {}
|
|
void save_override(const boost::archive::version_type & t) {}
|
|
void save_override(const boost::archive::class_id_type & t) {}
|
|
void save_override(const boost::archive::class_id_optional_type & t) {}
|
|
void save_override(const boost::archive::class_id_reference_type & t) {}
|
|
void save_override(const boost::archive::class_name_type & t) {}
|
|
void save_override(const boost::archive::tracking_type & t) {}
|
|
};
|
|
|
|
/**
|
|
* @brief Convenience macro to automatically activate and register all HRP members
|
|
* as uLib properties. Usage: ULIB_ACTIVATE_PROPERTIES(obj)
|
|
*/
|
|
#define ULIB_ACTIVATE_PROPERTIES(obj) \
|
|
{ uLib::Archive::property_register_archive _ar_tmp(&(obj)); (obj).serialize(_ar_tmp, 0); }
|
|
|
|
} // namespace Archive
|
|
} // namespace uLib
|
|
|
|
#endif // U_CORE_PROPERTY_H
|