Some cleanup

Include/RmlUi/Core/DataModel.h

@@ -45,19 +45,10 @@ class Element;
 
 class RMLUICORE_API DataModel : NonCopyMoveable {
 public:
-	DataModel(DataTypeRegister* type_register) : type_register(type_register) {}
-
-	DataTypeRegister& GetTypeRegister() { return *type_register; }
+	bool Bind(String name, void* ptr, VariableDefinition* variable, VariableType type);
 
-	template<typename T> bool BindScalar(String name, T* ptr) {
-		return Bind(name, ptr, type_register->GetOrAddScalar<T>(), VariableType::Scalar);
-	}
-	template<typename T> bool BindStruct(String name, T* ptr) {
-		return Bind(name, ptr, type_register->Get<T>(), VariableType::Struct);
-	}
-	template<typename T> bool BindArray(String name, T* ptr) {
-		return Bind(name, ptr, type_register->Get<T>(), VariableType::Array);
-	}
+	Variable GetVariable(const String& address_str) const;
+	Variable GetVariable(const Address& address) const;
 
 	template<typename T>
 	bool GetValue(const Address& address, T& out_value) const {
@@ -66,9 +57,6 @@ public:
 		return variable && variable.Get(variant) && variant.GetInto<T>(out_value);
 	}
 
-	Variable GetVariable(const String& address_str) const;
-	Variable GetVariable(const Address& address) const;
-
 	void DirtyVariable(const String& variable_name);
 	bool UpdateVariable(const String& variable_name);
 
@@ -86,11 +74,8 @@ public:
 
 	// Todo: Make private
 	DataControllers controllers;
-private:
-	bool Bind(String name, void* ptr, VariableDefinition* variable, VariableType type);
-
-	DataTypeRegister* type_register;
 
+private:
 	UnorderedMap<String, Variable> variables;
 
 	using ScopedAliases = UnorderedMap< Element*, SmallUnorderedMap<String, Address> >;
@@ -104,34 +89,41 @@ private:
 
 class RMLUICORE_API DataModelHandle {
 public:
-	DataModelHandle(DataModel* model) : model(model) {}
+	DataModelHandle() : model(nullptr), type_register(nullptr) {}
+	DataModelHandle(DataModel* model, DataTypeRegister* type_register) : model(model), type_register(type_register) {
+		RMLUI_ASSERT(model && type_register);
+	}
 
 	void UpdateControllers() {
-		RMLUI_ASSERT(model);
 		model->controllers.Update(*model);
 	}
-
 	void UpdateViews() {
-		RMLUI_ASSERT(model);
 		model->UpdateViews();
 	}
 
-	bool UpdateVariable(const String& variable_name)
-	{
-		RMLUI_ASSERT(model);
+	bool UpdateVariable(const String& variable_name) {
 		return model->UpdateVariable(variable_name);
 	}
-	void DirtyVariable(const String& variable_name)
-	{
-		RMLUI_ASSERT(model);
+	void DirtyVariable(const String& variable_name) {
 		model->DirtyVariable(variable_name);
 	}
-	DataModel* GetModel() { return model; }
 
-	explicit operator bool() { return model != nullptr; }
+	template<typename T> bool BindScalar(String name, T* ptr) {
+		return model->Bind(name, ptr, type_register->GetOrAddScalar<T>(), VariableType::Scalar);
+	}
+	template<typename T> bool BindStruct(String name, T* ptr) {
+		return model->Bind(name, ptr, type_register->Get<T>(), VariableType::Struct);
+	}
+	template<typename T> bool BindArray(String name, T* ptr) {
+		return model->Bind(name, ptr, type_register->Get<T>(), VariableType::Array);
+	}
+
+	explicit operator bool() { return model && type_register; }
 
 private:
 	DataModel* model;
+	DataTypeRegister* type_register;
+
 };
 
 }

Include/RmlUi/Core/DataVariable.h

@@ -40,21 +40,21 @@ namespace Core {
 class Variable;
 
 template<typename T>
-struct is_valid_scalar {
-	static constexpr bool value = std::is_convertible<T, byte>::value
-		|| std::is_convertible<T, char>::value
-		|| std::is_convertible<T, float>::value
-		|| std::is_convertible<T, int>::value
-		|| std::is_convertible<T, String>::value
-		|| std::is_convertible<T, Vector2f>::value
-		|| std::is_convertible<T, Vector3f>::value
-		|| std::is_convertible<T, Vector4f>::value
-		|| std::is_convertible<T, Colourb>::value
-		|| std::is_convertible<T, Colourf>::value
-		|| std::is_convertible<T, char*>::value
-		|| std::is_convertible<T, void*>::value;
+struct is_valid_scalar_base {
+	static constexpr bool value = std::is_arithmetic<T>::value
+		|| std::is_same<T, String>::value
+		|| std::is_same<T, Vector2f>::value
+		|| std::is_same<T, Vector3f>::value
+		|| std::is_same<T, Vector4f>::value
+		|| std::is_same<T, Colourb>::value
+		|| std::is_same<T, Colourf>::value
+		|| std::is_same<T, char*>::value
+		|| std::is_same<T, void*>::value;
 };
 
+template<typename T>
+struct is_valid_scalar : is_valid_scalar_base<typename std::remove_cv<T>::type> {};
+
 enum class VariableType { Scalar, Array, Struct };
 
 struct AddressEntry {

Samples/basic/databinding/src/main.cpp

@@ -128,7 +128,7 @@ struct MyData {
 	std::vector<int> indices = { 1, 2, 3, 4, 5 };
 } my_data;
 
-Rml::Core::DataModelHandle my_model_handle(nullptr);
+Rml::Core::DataModelHandle my_model;
 
 
 
@@ -136,12 +136,10 @@ Rml::Core::DataModelHandle my_model_handle(nullptr);
 
 bool SetupDataBinding(Rml::Core::Context* context)
 {
-	my_model_handle = context->CreateDataModel("my_model");
-	if (!my_model_handle)
+	my_model = context->CreateDataModel("my_model");
+	if (!my_model)
 		return false;
 
-	Rml::Core::DataModel& my_model = *my_model_handle.GetModel();
-
 	my_model.BindScalar("hello_world", &my_data.hello_world);
 	my_model.BindScalar("rating", &my_data.rating);
 	my_model.BindScalar("good_rating", &my_data.good_rating);
@@ -174,23 +172,23 @@ std::unique_ptr<DemoWindow> demo_window;
 
 void GameLoop()
 {
-	my_model_handle.UpdateControllers();
+	my_model.UpdateControllers();
 
-	if(my_model_handle.UpdateVariable("rating"))
+	if(my_model.UpdateVariable("rating"))
 	{
 		my_data.good_rating = (my_data.rating > 50);
-		my_model_handle.DirtyVariable("good_rating");
+		my_model.DirtyVariable("good_rating");
 
 		size_t new_size = my_data.rating / 10 + 1;
 		if(new_size != my_data.indices.size())
 		{
 			my_data.indices.resize(new_size);
 			std::iota(my_data.indices.begin(), my_data.indices.end(), int(new_size));
-			my_model_handle.DirtyVariable("indices");
+			my_model.DirtyVariable("indices");
 		}
 	}
 
-	my_model_handle.UpdateViews();
+	my_model.UpdateViews();
 
 	demo_window->Update();
 	context->Update();

Source/Core/Context.cpp

@@ -790,11 +790,11 @@ void Context::SetInstancer(ContextInstancer* _instancer)
 
 DataModelHandle Context::CreateDataModel(String name)
 {
-	auto result = data_models.emplace(name, std::make_unique<DataModel>( &GetDataTypeRegister() ));
+	auto result = data_models.emplace(name, std::make_unique<DataModel>());
 	if (result.second)
-		return DataModelHandle(result.first->second.get());
+		return DataModelHandle(result.first->second.get(), &GetDataTypeRegister());
 
-	return DataModelHandle(nullptr);
+	return DataModelHandle();
 }
 
 // Internal callback for when an element is removed from the hierarchy.

Source/Core/DataModel.cpp

@@ -289,12 +289,13 @@ static struct TestDataVariables {
 			}
 		}
 
-		DataModel model(&types);
+		DataModel model;
+		DataModelHandle handle(&model, &types);
 
 		SmartData data;
 		data.fun.x = "Hello, we're in SmartData!";
 
-		model.BindStruct("data", &data);
+		handle.BindStruct("data", &data);
 
 		{
 			std::vector<String> test_addresses = { "data.more_fun[1].magic[3]", "data.fun.x", "data.valid" };