3 files changed, 181 insertions, 3 deletions

diff --git a/src/BlockTypeRegistry.cpp b/src/BlockTypeRegistry.cpp
index 45ad20082..cc6945e27 100644
--- a/src/BlockTypeRegistry.cpp
+++ b/src/BlockTypeRegistry.cpp
@@ -56,6 +56,33 @@ AString BlockInfo::hintValue(
 
 
 
+void BlockInfo::setHint(const AString & aHintKey, const AString & aHintValue)
+{
+	mHints[aHintKey] = aHintValue;
+
+	// Warn if the hint is already provided by a callback (aHintValue will be ignored when evaluating the hint):
+	auto itrC = mHintCallbacks.find(aHintKey);
+	if (itrC != mHintCallbacks.end())
+	{
+		LOGINFO("Setting a static hint %s for block type %s, but there's already a callback for that hint. The static hint will be ignored.",
+			aHintKey.c_str(), mBlockTypeName.c_str()
+		);
+	}
+}
+
+
+
+
+
+void BlockInfo::removeHint(const AString & aHintKey)
+{
+	mHints.erase(aHintKey);
+}
+
+
+
+
+
 ////////////////////////////////////////////////////////////////////////////////
 // BlockTypeRegistry:
 
@@ -123,6 +150,43 @@ void BlockTypeRegistry::removeAllByPlugin(const AString & aPluginName)
 
 
 
+void BlockTypeRegistry::setBlockTypeHint(
+	const AString & aBlockTypeName,
+	const AString & aHintKey,
+	const AString & aHintValue
+)
+{
+	cCSLock lock(mCSRegistry);
+	auto blockInfo = mRegistry.find(aBlockTypeName);
+	if (blockInfo == mRegistry.end())
+	{
+		throw NotRegisteredException(aBlockTypeName, aHintKey, aHintValue);
+	}
+	blockInfo->second->setHint(aHintKey, aHintValue);
+}
+
+
+
+
+
+void BlockTypeRegistry::removeBlockTypeHint(
+	const AString & aBlockTypeName,
+	const AString & aHintKey
+)
+{
+	cCSLock lock(mCSRegistry);
+	auto blockInfo = mRegistry.find(aBlockTypeName);
+	if (blockInfo == mRegistry.end())
+	{
+		return;
+	}
+	blockInfo->second->removeHint(aHintKey);
+}
+
+
+
+
+
 ////////////////////////////////////////////////////////////////////////////////
 // BlockTypeRegistry::AlreadyRegisteredException:
 
@@ -151,3 +215,24 @@ AString BlockTypeRegistry::AlreadyRegisteredException::message(
 		aPreviousRegistration->pluginName().c_str()
 	);
 }
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// BlockTypeRegistry::NotRegisteredException:
+
+BlockTypeRegistry::NotRegisteredException::NotRegisteredException(
+	const AString & aBlockTypeName,
+	const AString & aHintKey,
+	const AString & aHintValue
+):
+	Super(Printf(
+		"Attempting to set a hint of nonexistent BlockTypeName.\n\tBlockTypeName = %s\n\tHintKey = %s\n\tHintValue = %s",
+		aBlockTypeName.c_str(),
+		aHintKey.c_str(),
+		aHintValue.c_str()
+	))
+{
+}
diff --git a/src/BlockTypeRegistry.h b/src/BlockTypeRegistry.h
index 6a24445c5..3fbcc44c2 100644
--- a/src/BlockTypeRegistry.h
+++ b/src/BlockTypeRegistry.h
@@ -40,7 +40,7 @@ public:
 
 
 	/** Retrieves the value associated with the specified hint for this specific BlockTypeName and BlockState.
-	Queries callbacks first, then hints if a callback doesn't exist.
+	Queries hint callbacks first, then static hints if a callback doesn't exist.
 	Returns an empty string if hint not found at all. */
 	AString hintValue(
 		const AString & aHintName,
@@ -52,6 +52,15 @@ public:
 	const AString & blockTypeName() const { return mBlockTypeName; }
 	std::shared_ptr<cBlockHandler> handler() const { return mHandler; }
 
+	/** Sets (creates or updates) a static hint.
+	Hints provided by callbacks are unaffected by this - callbacks are "higher priority", they overwrite anything set here.
+	Logs an info message if the hint is already provided by a hint callback. */
+	void setHint(const AString & aHintKey, const AString & aHintValue);
+
+	/** Removes a hint.
+	Silently ignored if the hint hasn't been previously set. */
+	void removeHint(const AString & aHintKey);
+
 
 private:
 
@@ -64,10 +73,12 @@ private:
 	/** The callbacks to call for various interaction. */
 	std::shared_ptr<cBlockHandler> mHandler;
 
-	/** Optional hints for any subsystem to use, such as "IsSnowable" -> "1". */
+	/** Optional static hints for any subsystem to use, such as "IsSnowable" -> "1".
+	Hint callbacks are of higher priority than mHints - if a hint is provided by a mHintCallback, its value in mHints is ignored. */
 	std::map<AString, AString> mHints;
 
-	/** The callbacks for dynamic evaluation of hints, such as "LightValue" -> function(BlockTypeName, BlockState). */
+	/** The callbacks for dynamic evaluation of hints, such as "LightValue" -> function(BlockTypeName, BlockState).
+	Hint callbacks are of higher priority than mHints - if a hint is provided by a mHintCallback, its value in mHints is ignored. */
 	std::map<AString, HintCallback> mHintCallbacks;
 };
 
@@ -86,6 +97,7 @@ class BlockTypeRegistry
 public:
 	// fwd:
 	class AlreadyRegisteredException;
+	class NotRegisteredException;
 
 
 	/** Creates an empty new instance of the block type registry */
@@ -109,6 +121,22 @@ public:
 	/** Removes all registrations done by the specified plugin. */
 	void removeAllByPlugin(const AString & aPluginName);
 
+	/** Sets (adds or overwrites) a single Hint value for a BlockType.
+	Throws NotRegisteredException if the BlockTypeName is not registered. */
+	void setBlockTypeHint(
+		const AString & aBlockTypeName,
+		const AString & aHintKey,
+		const AString & aHintValue
+	);
+
+	/** Removes a previously registered single Hint value for a BlockType.
+	Throws NotRegisteredException if the BlockTypeName is not registered.
+	Silently ignored if the Hint hasn't been previously set. */
+	void removeBlockTypeHint(
+		const AString & aBlockTypeName,
+		const AString & aHintKey
+	);
+
 
 private:
 
@@ -156,3 +184,31 @@ private:
 		std::shared_ptr<BlockInfo> aNewRegistration
 	);
 };
+
+
+
+
+
+/** The exception thrown from BlockTypeRegistry::setBlockTypeHint() if the block type has not been registered before. */
+class BlockTypeRegistry::NotRegisteredException: public std::runtime_error
+{
+	using Super = std::runtime_error;
+
+public:
+
+	/** Creates a new instance of the exception that provides info on both the original registration and the newly attempted
+	registration that caused the failure. */
+	NotRegisteredException(
+		const AString & aBlockTypeName,
+		const AString & aHintKey,
+		const AString & aHintValue
+	);
+
+	// Simple getters:
+	const AString & blockTypeName() const { return mBlockTypeName; }
+
+
+private:
+
+	const AString mBlockTypeName;
+};
diff --git a/tests/BlockTypeRegistry/BlockTypeRegistryTest.cpp b/tests/BlockTypeRegistry/BlockTypeRegistryTest.cpp
index c2d8717e5..3479e55d7 100644
--- a/tests/BlockTypeRegistry/BlockTypeRegistryTest.cpp
+++ b/tests/BlockTypeRegistry/BlockTypeRegistryTest.cpp
@@ -64,6 +64,42 @@ static void testSimpleReg()
 
 
 
+/** Tests setting and removing a BlockType hint. */
+static void testHintSetRemove()
+{
+	LOGD("Testing hint addition and removal...");
+
+	// Register the block type:
+	BlockTypeRegistry reg;
+	AString blockTypeName("test:block1");
+	AString pluginName("testPlugin");
+	AString hint1("testHint1");
+	AString hint1Value("value1");
+	AString hint2("testHint2");
+	AString hint2Value("value2");
+	std::shared_ptr<cBlockHandler> handler(new cBlockHandler(0x12345678));
+	std::map<AString, AString> hints = {{hint1, hint1Value}};
+	std::map<AString, BlockInfo::HintCallback> hintCallbacks;
+	reg.registerBlockType(pluginName, blockTypeName, handler, hints, hintCallbacks);
+
+	// Modify the hints:
+	auto blockInfo = reg.blockInfo(blockTypeName);
+	reg.setBlockTypeHint(blockTypeName, hint2, hint2Value);
+	TEST_EQUAL(blockInfo->hintValue(hint2, BlockState()), hint2Value);  // Was created successfully
+	reg.setBlockTypeHint(blockTypeName, hint1, "testValue2");
+	TEST_EQUAL(blockInfo->hintValue(hint1, BlockState()), "testValue2");  // Was updated successfully
+	reg.removeBlockTypeHint(blockTypeName, hint2);
+	TEST_EQUAL(blockInfo->hintValue(hint2, BlockState()), "");  // Was removed successfully
+
+	// Test the error reporting:
+	TEST_THROWS(reg.setBlockTypeHint("nonexistent", "hint", "value"), BlockTypeRegistry::NotRegisteredException);
+	reg.removeBlockTypeHint(blockTypeName, "nonexistent");  // Should fail silently
+}
+
+
+
+
+
 /** Tests that the plugin-based information is used correctly for registration.
 Registers two different block types with two different plugins, then tries to re-register them from a different plugin.
 Finally removes the registration through removeAllByPlugin() and checks its success. */
@@ -190,6 +226,7 @@ static void testThreadLocking()
 static void testBlockTypeRegistry()
 {
 	testSimpleReg();
+	testHintSetRemove();
 	testPlugins();
 	testHintCallbacks();
 	testThreadLocking();