From 02fbf1686565ace00df5af938d95fbe18783fc37 Mon Sep 17 00:00:00 2001 From: Mattes D Date: Fri, 23 Aug 2019 16:17:05 +0200 Subject: Added BlockState implementation for 1.13 support. --- src/BlockState.cpp | 167 +++++++++++++++++++++++++++++++++++++++++++++++++++++ src/BlockState.h | 90 +++++++++++++++++++++++++++++ src/CMakeLists.txt | 2 + 3 files changed, 259 insertions(+) create mode 100644 src/BlockState.cpp create mode 100644 src/BlockState.h (limited to 'src') diff --git a/src/BlockState.cpp b/src/BlockState.cpp new file mode 100644 index 000000000..4e2607bd3 --- /dev/null +++ b/src/BlockState.cpp @@ -0,0 +1,167 @@ +#include "Globals.h" +#include "BlockState.h" + + + + + +BlockState::BlockState(): + mChecksum(initializeChecksum()) +{ + // Nothing needed yet +} + + + + + +BlockState::BlockState(const AString & aKey, const AString & aValue): + mState({{aKey, aValue}}), + mChecksum(initializeChecksum()) +{ +} + + + + + +BlockState::BlockState(std::initializer_list> aKeysAndValues): + mState(aKeysAndValues), + mChecksum(initializeChecksum()) +{ +} + + + + + +BlockState::BlockState(const std::map & aKeysAndValues): + mState(aKeysAndValues), + mChecksum(initializeChecksum()) +{ +} + + + + + +BlockState::BlockState(std::map && aKeysAndValues): + mState(std::move(aKeysAndValues)), + mChecksum(initializeChecksum()) +{ +} + + + + + +BlockState::BlockState(const BlockState & aCopyFrom, std::initializer_list> aAdditionalKeysAndValues): + mState(aCopyFrom.mState) +{ + for (const auto & kav: aAdditionalKeysAndValues) + { + mState[kav.first] = kav.second; + } + mChecksum = initializeChecksum(); +} + + + + + +BlockState::BlockState(const BlockState & aCopyFrom, const std::map & aAdditionalKeysAndValues): + mState(aCopyFrom.mState) +{ + for (const auto & kav: aAdditionalKeysAndValues) + { + mState[kav.first] = kav.second; + } + mChecksum = initializeChecksum(); +} + + + + + +bool BlockState::operator ==(const BlockState & aOther) const +{ + // Fast-fail if the checksums differ or differrent counts: + if ((mChecksum != aOther.mChecksum) || (mState.size() != aOther.mState.size())) + { + return false; + } + + // Slow-check everything if the checksums match: + return std::equal(mState.begin(), mState.end(), aOther.mState.begin()); +} + + + + + +const AString & BlockState::value(const AString & aKey) const +{ + auto itr = mState.find(aKey); + if (itr == mState.end()) + { + static AString empty; + return empty; + } + return itr->second; +} + + + + + +UInt32 BlockState::initializeChecksum() +{ + removeEmptyKeys(); + + // Calculate the checksum as a XOR of all mState keys' and values' checksums + // This way we don't depend on the std::map's ordering + UInt32 res = 0; + for (const auto & kv: mState) + { + auto partial = partialChecksum(kv.first) ^ partialChecksum(kv.second); + res = res ^ partial; + } + return res; +} + + + + + +void BlockState::removeEmptyKeys() +{ + for (auto itr = mState.begin(); itr != mState.end();) + { + if (itr->second.empty()) + { + itr = mState.erase(itr); + } + else + { + ++itr; + } + } +} + + + + + +UInt32 BlockState::partialChecksum(const AString & aString) +{ + UInt32 shift = 0; + UInt32 res = 0; + for (auto ch: aString) + { + UInt32 v = static_cast(ch); + v = v << shift; + shift = (shift + 1) % 24; + res = res ^ v; + } + return res; +} diff --git a/src/BlockState.h b/src/BlockState.h new file mode 100644 index 000000000..3b0575f0e --- /dev/null +++ b/src/BlockState.h @@ -0,0 +1,90 @@ +#pragma once + +#include + + + + + +/** Represents the state of a single block (previously known as "block meta"). +The state consists of a map of string -> string, plus a mechanism for fast equality checks between two BlockState instances. +Once a BlockState instance is created, it is then immutable - there's no way of changing it, only by creating a (modified) copy. +A BlockState instance can be created from hard-coded data or from dynamic data: + BlockState bs({{"key1", "value1"}, {key2", "value2"}}); // Hard-coded + - or - + std::map map({{"key1", "value1"}, {key2", "value2"}}); + map["key3"] = "value3"; + BlockState bs(map); // From dynamic data +*/ +class BlockState +{ +public: + + /** Creates a new instance with an empty map. */ + BlockState(); + + /** Creates a new instance consisting of a single key-value pair. + If the value is empty, it is not stored wihin the map. */ + BlockState(const AString & aKey, const AString & aValue); + + /** Creates a new instance initialized with several (hard-coded) key-value pairs. + Any key with an empty value is not stored within the map. */ + BlockState(std::initializer_list> aKeysAndValues); + + /** Creates a new instance initialized with several (dynamic) key-value pairs. + Makes a copy of aKeysAndValues for this object. + Any key with an empty value is not stored within the map. */ + BlockState(const std::map & aKeysAndValues); + + /** Creates a new instance initialized with several (dynamic) key-value pairs. + Any key with an empty value is not stored within the map. */ + BlockState(std::map && aKeysAndValues); + + /** Creates a copy of the specified BlockState with the (hard-coded) additional keys and values added to it. + Any key in aAdditionalKeysAndValues that is already present in aCopyFrom is overwritten with the aAdditionalKeysAndValues' one. + Any key with an empty value is not stored in the map. + (it's possible to erase a key from aCopyFrom by setting it to empty string in aAdditionalKeysAndValues). */ + BlockState(const BlockState & aCopyFrom, std::initializer_list> aAdditionalKeysAndValues); + + /** Creates a copy of the specified BlockState with the (dynamic) additional keys and values added to it. + Any key in aAdditionalKeysAndValues that is already present in aCopyFrom is overwritten with the aAdditionalKeysAndValues' one. + Any key with an empty value is not stored in the map. + (it's possible to erase a key from aCopyFrom by setting it to empty string in aAdditionalKeysAndValues). */ + BlockState(const BlockState & aCopyFrom, const std::map & aAdditionalKeysAndValues); + + /** Fast equality check. */ + bool operator ==(const BlockState & aOther) const; + + /** Fast inequality check. */ + bool operator !=(const BlockState & aOther) const + { + return !(operator ==(aOther)); + } + + /** Returns the value at the specified key. + If the key is not present, returns an empty string. */ + const AString & value(const AString & aKey) const; + + +protected: + + /** The state, represented as a string->string map. */ + std::map mState; + + /** The checksum used for the fast equality check. + This is calculated upon creation. */ + UInt32 mChecksum; + + + /** Normalizes mState and calculates the checksum from it. + Removes all the empty values from mState. + Used only from constructors. */ + UInt32 initializeChecksum(); + + /** Removes all the keys from mState that have an empty value. */ + void removeEmptyKeys(); + + /** Calculates the partial checksum of a single string. + Used from within initializeChecksum(). */ + UInt32 partialChecksum(const AString & aString); +}; diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index d23fe388d..dd92a969c 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -17,6 +17,7 @@ SET (SRCS BlockArea.cpp BlockID.cpp BlockInfo.cpp + BlockState.cpp BlockTypeRegistry.cpp BrewingRecipes.cpp Broadcaster.cpp @@ -84,6 +85,7 @@ SET (HDRS BlockID.h BlockInServerPluginInterface.h BlockInfo.h + BlockState.h BlockTracer.h BlockTypeRegistry.h BrewingRecipes.h -- cgit v1.2.3