From a72f7ec50175a7540a38a74e0aa225db2507e5b5 Mon Sep 17 00:00:00 2001 From: Georg Hagen Date: Tue, 28 Oct 2025 16:39:11 +0100 Subject: [PATCH] Make Version more space efficient --- openVulkanoCpp/Base/Version.cpp | 65 +++++---- openVulkanoCpp/Base/Version.hpp | 224 ++++++++++++++++++++++++++++++-- tests/Base/VersionTest.cpp | 45 ++++++- 3 files changed, 299 insertions(+), 35 deletions(-) diff --git a/openVulkanoCpp/Base/Version.cpp b/openVulkanoCpp/Base/Version.cpp index 5adc194..50d59a6 100644 --- a/openVulkanoCpp/Base/Version.cpp +++ b/openVulkanoCpp/Base/Version.cpp @@ -43,7 +43,7 @@ namespace OpenVulkano } private: - static int ToNumber(std::string_view numberStr) + static int ToNumber(const std::string_view numberStr) { if (numberStr.empty()) return 0; int tmp = 0; @@ -55,7 +55,7 @@ namespace OpenVulkano { do { - size_t blockStart = offset; + const size_t blockStart = offset; while (versionStr.size() > offset && versionStr[offset] >= '0' && versionStr[offset] <= '9') offset++; comps.push_back(ToNumber(versionStr.substr(blockStart, offset - blockStart))); if (offset < versionStr.size() && versionStr[offset] != '.') break; @@ -67,7 +67,7 @@ namespace OpenVulkano { do { - size_t blockStart = offset; + const size_t blockStart = offset; while (versionStr.size() > offset && versionStr[offset] != '-' && versionStr[offset] != ' ' && versionStr[offset] != '\0') offset++; tags.emplace_back(versionStr.data() + blockStart, offset - blockStart); if (offset >= versionStr.size() || versionStr[offset] == ' ' || versionStr[offset] == '\0') break; @@ -92,14 +92,7 @@ namespace OpenVulkano } } - Version::Version(uint32_t major, uint32_t minor, uint32_t patch, const uint32_t build) - : m_versionComponents(build ? std::initializer_list{major, minor, patch, build} : std::initializer_list{major, minor, patch}) - , m_buildNumber(build) - , m_versionString(ToString(major, minor, patch, build)) - {} - - Version::Version(std::string_view versionString, bool ignoreTags) - : m_versionString(versionString) + VersionDataExtendedData::VersionDataExtendedData(const std::string_view& versionString, const bool ignoreTags) { ComponentDecodeHolder helper(versionString); if (!helper.appleBuildComponents.empty()) @@ -115,11 +108,11 @@ namespace OpenVulkano { if (std::regex_match(tag, tagRegex)) { - auto t = ReadTagValue(tag); - if (t.first == 't' || t.first == 'T') - m_timestamp = t.second; + const auto [fst, snd] = ReadTagValue(tag); + if (fst == 't' || fst == 'T') + m_timestamp = snd; else - m_buildNumber = t.second; + m_buildNumber = snd; } } } @@ -133,34 +126,54 @@ namespace OpenVulkano } } + Version::Version(uint32_t major, uint32_t minor, uint32_t patch, const uint32_t build) + : m_data(VersionDataCompact(major, minor, patch, build)) + , m_versionString(ToString(major, minor, patch, build)) + {} + + Version::Version(const std::string_view versionString, const bool ignoreTags) + : m_versionString(versionString) + { + VersionDataExtendedData data(versionString, ignoreTags); + auto compact = data.GetCompactVersion(); + if (compact) + m_data = compact.value(); + else + m_data = std::move(data); + } + //region Compare functions int Version::CompareBuildNr(const Version& other) const { - if (m_buildNumber == 0 || other.m_buildNumber == 0) return 0; - if (m_buildNumber > other.m_buildNumber) return 1; - if (m_buildNumber < other.m_buildNumber) return -1; + const uint64_t build = Build(), otherBuild = other.Build(); + if (build == 0 || otherBuild == 0) return 0; + if (build > otherBuild) return 1; + if (build < otherBuild) return -1; return 0; } int Version::CompareTimestamp(const Version& other) const { - if (m_timestamp == 0 || other.m_timestamp == 0) return 0; - if (m_timestamp > other.m_timestamp) return 1; - if (m_timestamp < other.m_timestamp) return -1; + const uint64_t ts = Timestamp(), oTs = other.Timestamp(); + if (ts == 0 || oTs == 0) return 0; + if (ts > oTs) return 1; + if (ts < oTs) return -1; return 0; } int Version::CompareComponents(const Version& other) const { - size_t minCount = std::min(m_versionComponents.size(), other.m_versionComponents.size()); + const auto comp = GetVersionComponents(); + const auto otherComp = other.GetVersionComponents(); + const size_t minCount = std::min(comp.size(), otherComp.size()); for(size_t i = 0; i < minCount; i++) { - if (m_versionComponents[i] > other.m_versionComponents[i]) return 1; - if (m_versionComponents[i] < other.m_versionComponents[i]) return -1; + if (comp[i] > otherComp[i]) return 1; + if (comp[i] < otherComp[i]) return -1; } - if (m_versionComponents.size() != other.m_versionComponents.size()) + if (comp.size() != otherComp.size()) { - for(size_t i = minCount; i < std::max(m_versionComponents.size(), other.m_versionComponents.size()); i++) + for(size_t i = minCount; i < std::max(comp.size(), otherComp.size()); i++) { if (GetComponent(i) > other.GetComponent(i)) return 1; if (GetComponent(i) < other.GetComponent(i)) return -1; diff --git a/openVulkanoCpp/Base/Version.hpp b/openVulkanoCpp/Base/Version.hpp index b631e5e..516b4a9 100644 --- a/openVulkanoCpp/Base/Version.hpp +++ b/openVulkanoCpp/Base/Version.hpp @@ -10,16 +10,199 @@ #include #include #include +#include namespace OpenVulkano { - class Version + struct VersionDataCompact + { + std::array m_versionComponents; + + VersionDataCompact(const uint32_t major, const uint32_t minor, const uint32_t patch, const uint32_t build) + : m_versionComponents({major, minor, patch, build}) + {} + + [[nodiscard]] uint32_t GetComponent(const size_t compId) const + { + if (m_versionComponents.size() < compId + 1) return 0u; + return m_versionComponents[compId]; + } + }; + + struct VersionDataExtendedData { std::vector m_versionComponents; std::vector m_tagComponents; uint64_t m_timestamp = 0, m_buildNumber = 0; + + VersionDataExtendedData() = default; + VersionDataExtendedData(const std::string_view& versionString, bool ignoreTags); + + [[nodiscard]] uint32_t GetComponent(const size_t compId) const + { + if (m_versionComponents.size() < compId + 1) return 0u; + return m_versionComponents[compId]; + } + + std::optional GetCompactVersion(const bool force = false) const + { + if (!force) + { + if (m_versionComponents.size() > 3 && m_buildNumber != 0) return {}; + if (m_versionComponents.size() > 4 || !m_tagComponents.empty()) return {}; + } + return VersionDataCompact(GetComponent(0), GetComponent(1), GetComponent(2), m_buildNumber ? m_buildNumber : GetComponent(3)); + } + }; + + struct VersionDataExtended + { + std::array m_leadComponents; + std::unique_ptr m_data; + + VersionDataExtended() : m_leadComponents({ UINT32_MAX, UINT32_MAX }), m_data(std::make_unique()) + {} + + VersionDataExtended(const VersionDataExtended& o) : m_leadComponents(o.m_leadComponents), m_data(std::make_unique(*o.m_data)) + {} + + VersionDataExtended(VersionDataExtended&& o) noexcept + : m_leadComponents(o.m_leadComponents), m_data(std::move(o.m_data)) + { + o.m_leadComponents = { 0, 0 }; + } + + VersionDataExtended(VersionDataExtendedData&& data) : + m_leadComponents({ UINT32_MAX, UINT32_MAX }), m_data(std::make_unique(std::move(data))) + {} + + VersionDataExtended& operator=(VersionDataExtended&& o) noexcept + { + m_leadComponents = std::move(o.m_leadComponents); + m_data = std::move(o.m_data); + o.m_data = nullptr; + o.m_leadComponents = { 0, 0 }; + return *this; + } + + VersionDataExtended& operator=(const VersionDataExtended& o) + { + m_leadComponents = o.m_leadComponents; + m_data = std::make_unique(*o.m_data); + return *this; + } + }; + + union VersionData + { + VersionDataCompact compact; + VersionDataExtended extended; + + VersionData() { memset(&this->compact, 0, sizeof(VersionDataCompact)); } + + VersionData(VersionData&& o) noexcept + { + if (o.IsExtended()) + { + new (&extended) VersionDataExtended(std::move(o.extended)); + } + else compact = o.compact; + } + + VersionData(const VersionData& o) + { + if (o.IsExtended()) new (&extended)VersionDataExtended(o.extended); + else compact = o.compact; + } + + VersionData(const VersionDataCompact& other) { new (&compact)VersionDataCompact(other); } + + VersionData(VersionDataCompact&& other) { new (&compact) VersionDataCompact(std::move(other)); } + + VersionData(const VersionDataExtended& other) + { + new (&extended)VersionDataExtended(other); + } + + VersionData(VersionDataExtended&& other) { new (&extended) VersionDataExtended(std::move(other)); } + + ~VersionData() + { + if (IsExtended()) + { + extended.~VersionDataExtended(); + } + } + + VersionData& operator =(const VersionDataCompact& other) + { + compact = other; + return *this; + } + + VersionData& operator =(VersionDataExtendedData&& other) + { + extended.m_leadComponents = { UINT32_MAX, UINT32_MAX }; + extended.m_data = std::make_unique(std::move(other)); + return *this; + } + + VersionData& operator =(VersionData&& other) noexcept + { + Clear(); + if (other.IsExtended()) + { + extended.m_leadComponents = { UINT32_MAX, UINT32_MAX }; + extended.m_data = std::move(other.extended.m_data); + } + else + { + compact = other.compact; + } + return *this; + } + + VersionData& operator =(const VersionData& other) + { + Clear(); + if (other.IsExtended()) + extended = other.extended; + else + compact = other.compact; + return *this; + } + + bool IsExtended() const + { + return compact.m_versionComponents[0] > INT32_MAX; + } + + uint64_t GetTimestamp() const + { + if (IsExtended()) return extended.m_data->m_timestamp; + return 0; + } + + private: + void Clear() + { + if (IsExtended()) + { + extended.~VersionDataExtended(); + } + memset(&compact, 0, sizeof(compact)); + } + }; + + class Version + { + VersionData m_data; std::string m_versionString; - bool m_preRelease = false; + + bool IsExtendedData() const + { + return m_data.compact.m_versionComponents[0] > INT32_MAX; + } public: Version() : Version(0, 0) {} @@ -34,10 +217,16 @@ namespace OpenVulkano explicit Version(double version); + Version(const Version& other) = default; + Version(Version&& other) = default; + Version& operator =(const Version& other) = default; + Version& operator=(Version&& other) = default; + [[nodiscard]] uint32_t GetComponent(const size_t compId) const { - if (m_versionComponents.size() < compId + 1) return 0u; - return m_versionComponents[compId]; + if (IsExtendedData()) + return m_data.extended.m_data->GetComponent(compId); + return m_data.compact.GetComponent(compId); } [[nodiscard]] uint32_t Major() const { return GetComponent(0); } @@ -46,13 +235,32 @@ namespace OpenVulkano [[nodiscard]] uint32_t Patch() const { return GetComponent(2); } - [[nodiscard]] uint64_t Build() const { return m_buildNumber; } + [[nodiscard]] uint64_t Build() const + { + if (IsExtendedData()) return m_data.extended.m_data->m_buildNumber; + return m_data.compact.m_versionComponents[3]; + } - [[nodiscard]] bool IsPreRelease() const { return m_preRelease; } + [[nodiscard]] uint64_t Timestamp() const + { + return m_data.GetTimestamp(); + } - [[nodiscard]] const std::vector& GetTags() const { return m_tagComponents; } + //[[nodiscard]] bool IsPreRelease() const { return m_preRelease; } - [[nodiscard]] const decltype(m_versionComponents)& GetVersionComponents() const { return m_versionComponents; } + [[nodiscard]] const std::vector& GetTags() const + { + static std::vector fallbackTags; + if (IsExtendedData()) + return m_data.extended.m_data->m_tagComponents; + return fallbackTags; + } + + [[nodiscard]] std::span GetVersionComponents() const + { + if (IsExtendedData()) return m_data.extended.m_data->m_versionComponents; + return m_data.compact.m_versionComponents; + } //region Conversion operators [[nodiscard]] explicit operator uint32_t() const { return (Major() << 20) | ((Minor() & 0x3FF) << 10) | (Patch() & 0x3FF); } diff --git a/tests/Base/VersionTest.cpp b/tests/Base/VersionTest.cpp index 686f9e8..2618f6b 100644 --- a/tests/Base/VersionTest.cpp +++ b/tests/Base/VersionTest.cpp @@ -559,4 +559,47 @@ TEST_CASE("testUnimportantVersionParts", "[Version]") REQUIRE(Version("1.0.0.3") == Version("1.0.0.3.0.0.0")); REQUIRE(Version("1.0.0.3") == Version("1.0.0.3.0.00.0")); REQUIRE(Version("1.0.0.3") == Version("1.00.0.3")); -} \ No newline at end of file +} + +TEST_CASE("testCopyConstructorAndAssignment", "[Version]") +{ + Version original("1.5.3"); + Version copyConstructed(original); + REQUIRE(copyConstructed == original); + REQUIRE(static_cast(copyConstructed) == static_cast(original)); + + Version copyAssigned("2.0"); + copyAssigned = original; + REQUIRE(copyAssigned == original); + REQUIRE(static_cast(copyAssigned) == static_cast(original)); + + Version extended("1.2.3-ALPHA-B99-T11"); + Version cpConstructedExtended(extended); + REQUIRE(cpConstructedExtended.Timestamp() == 11); + REQUIRE(cpConstructedExtended == extended); + + Version extended3 = extended; + REQUIRE(extended3.Timestamp() == 11); + REQUIRE(extended3 == extended); +} + +TEST_CASE("testMoveConstructorAndAssignment", "[Version]") +{ + Version original("3.1.4"); + Version movedConstructed(std::move(original)); + REQUIRE(static_cast(movedConstructed) == "3.1.4"); + + Version another("0.9.9"); + another = std::move(movedConstructed); + REQUIRE(static_cast(another) == "3.1.4"); + + Version extended("1.2.3-ALPHA-B99-T11"); + Version mvConstructedExtended(std::move(extended)); + REQUIRE(mvConstructedExtended.Timestamp() == 11); + REQUIRE(mvConstructedExtended != extended); + + Version extended3 = std::move(mvConstructedExtended); + REQUIRE(extended3.Timestamp() == 11); + REQUIRE(extended3 != extended); + REQUIRE(extended3 != mvConstructedExtended); +}