From 5b70ab40f4f57b68737d6d328a2c21119cd5adf5 Mon Sep 17 00:00:00 2001 From: Anton Alkin Date: Sun, 4 Jul 2021 16:21:06 +0200 Subject: [PATCH 1/2] add unsigned int types to Variant --- Framework/Core/include/Framework/Variant.h | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/Framework/Core/include/Framework/Variant.h b/Framework/Core/include/Framework/Variant.h index df76219ffa052..50332d0c48f58 100644 --- a/Framework/Core/include/Framework/Variant.h +++ b/Framework/Core/include/Framework/Variant.h @@ -28,6 +28,10 @@ namespace o2::framework enum class VariantType : int { Int = 0, Int64, + UInt8, + UInt16, + UInt32, + UInt64, Float, Double, String, @@ -76,6 +80,11 @@ struct variant_trait : std::integral_constant DECLARE_VARIANT_TRAIT(int, Int); DECLARE_VARIANT_TRAIT(long int, Int64); DECLARE_VARIANT_TRAIT(long long int, Int64); +DECLARE_VARIANT_TRAIT(uint8_t, UInt8); +DECLARE_VARIANT_TRAIT(uint16_t, UInt16); +DECLARE_VARIANT_TRAIT(uint32_t, UInt32); +DECLARE_VARIANT_TRAIT(uint64_t, UInt64); + DECLARE_VARIANT_TRAIT(float, Float); DECLARE_VARIANT_TRAIT(double, Double); DECLARE_VARIANT_TRAIT(bool, Bool); @@ -152,6 +161,10 @@ struct variant_type { DECLARE_VARIANT_TYPE(int, Int); DECLARE_VARIANT_TYPE(int64_t, Int64); +DECLARE_VARIANT_TYPE(uint8_t, UInt8); +DECLARE_VARIANT_TYPE(uint16_t, UInt16); +DECLARE_VARIANT_TYPE(uint32_t, UInt32); +DECLARE_VARIANT_TYPE(uint64_t, UInt64); DECLARE_VARIANT_TYPE(float, Float); DECLARE_VARIANT_TYPE(double, Double); DECLARE_VARIANT_TYPE(const char*, String); @@ -236,7 +249,8 @@ struct variant_helper { /// Variant for configuration parameter storage. Owns stored data. class Variant { - using storage_t = std::aligned_union<8, int, int64_t, const char*, float, double, bool, + using storage_t = std::aligned_union<8, int, int64_t, uint8_t, uint16_t, uint32_t, uint64_t, + const char*, float, double, bool, int*, float*, double*, bool*, Array2D, Array2D, Array2D, LabeledArray, LabeledArray, LabeledArray>::type; From 4387f5ccef0a9efb2dea806843b2c78aaa25b8b1 Mon Sep 17 00:00:00 2001 From: Anton Alkin Date: Mon, 5 Jul 2021 08:24:47 +0200 Subject: [PATCH 2/2] add handling and tests for uints --- .../include/Framework/ConfigParamRegistry.h | 25 +++++++++---- .../include/Framework/ConfigParamsHelper.h | 15 ++------ Framework/Core/include/Framework/Variant.h | 32 ++++++++++++++--- Framework/Core/src/BoostOptionsRetriever.cxx | 12 +++++++ Framework/Core/src/ConfigParamsHelper.cxx | 12 +++++++ Framework/Core/src/PropertyTreeHelpers.cxx | 36 +++++++++++++++++++ Framework/Core/src/Variant.cxx | 16 +++++++-- .../Core/src/WorkflowSerializationHelpers.cxx | 12 +++++++ .../Core/test/test_BoostOptionsRetriever.cxx | 12 +++++++ .../Core/test/test_ConfigParamRegistry.cxx | 16 +++++++++ Framework/Core/test/test_ConfigParamStore.cxx | 20 +++++++++++ .../src/FrameworkGUIDeviceInspector.cxx | 15 ++++++++ 12 files changed, 197 insertions(+), 26 deletions(-) diff --git a/Framework/Core/include/Framework/ConfigParamRegistry.h b/Framework/Core/include/Framework/ConfigParamRegistry.h index 0f0aa10166bfd..f7bf011abaf00 100644 --- a/Framework/Core/include/Framework/ConfigParamRegistry.h +++ b/Framework/Core/include/Framework/ConfigParamRegistry.h @@ -21,6 +21,24 @@ #include #include +namespace +{ +template +constexpr auto isSimpleType() +{ + return std::is_same_v || + std::is_same_v || + std::is_same_v || + std::is_same_v || + std::is_same_v || + std::is_same_v || + std::is_same_v || + std::is_same_v || + std::is_same_v || + std::is_same_v; +} +} // namespace + namespace o2::framework { class ConfigParamStore; @@ -54,12 +72,7 @@ class ConfigParamRegistry { assert(mStore.get()); try { - if constexpr (std::is_same_v || - std::is_same_v || - std::is_same_v || - std::is_same_v || - std::is_same_v || - std::is_same_v) { + if constexpr (isSimpleType()) { return mStore->store().get(key); } else if constexpr (std::is_same_v) { return mStore->store().get(key); diff --git a/Framework/Core/include/Framework/ConfigParamsHelper.h b/Framework/Core/include/Framework/ConfigParamsHelper.h index d0179777932f2..4dc974549a2bb 100644 --- a/Framework/Core/include/Framework/ConfigParamsHelper.h +++ b/Framework/Core/include/Framework/ConfigParamsHelper.h @@ -105,11 +105,7 @@ struct ConfigParamsHelper { const char* name = spec.name.c_str(); const char* help = spec.help.c_str(); - if constexpr (V == VariantType::Int || - V == VariantType::Int64 || - V == VariantType::Float || - V == VariantType::Double || - V == VariantType::Bool) { + if constexpr (isSimpleVariant()) { using Type = typename variant_type::type; using BoostType = typename std::conditional::type; auto value = boost::program_options::value(); @@ -120,14 +116,7 @@ struct ConfigParamsHelper { value = value->zero_tokens(); } options.add_options()(name, value, help); - } else if constexpr (V == VariantType::ArrayInt || - V == VariantType::ArrayFloat || - V == VariantType::ArrayDouble || - V == VariantType::ArrayBool || - V == VariantType::ArrayString || - V == VariantType::Array2DInt || - V == VariantType::Array2DFloat || - V == VariantType::Array2DDouble) { + } else if constexpr (isArray() || isArray2D()) { auto value = boost::program_options::value(); value = value->default_value(spec.defaultValue.asString()); if constexpr (V != VariantType::String) { diff --git a/Framework/Core/include/Framework/Variant.h b/Framework/Core/include/Framework/Variant.h index 50332d0c48f58..dd03aa8a6521f 100644 --- a/Framework/Core/include/Framework/Variant.h +++ b/Framework/Core/include/Framework/Variant.h @@ -53,19 +53,41 @@ enum class VariantType : int { Int = 0, template constexpr auto isArray() { - return (V == VariantType::ArrayBool || V == VariantType::ArrayDouble || V == VariantType::ArrayFloat || V == VariantType::ArrayInt || V == VariantType::ArrayString); + return (V == VariantType::ArrayBool || + V == VariantType::ArrayDouble || + V == VariantType::ArrayFloat || + V == VariantType::ArrayInt || + V == VariantType::ArrayString); } template constexpr auto isArray2D() { - return (V == VariantType::Array2DInt || V == VariantType::Array2DFloat || V == VariantType::Array2DDouble); + return (V == VariantType::Array2DInt || + V == VariantType::Array2DFloat || + V == VariantType::Array2DDouble); } template constexpr auto isLabeledArray() { - return (V == VariantType::LabeledArrayInt || V == VariantType::LabeledArrayFloat || V == VariantType::LabeledArrayDouble); + return (V == VariantType::LabeledArrayInt || + V == VariantType::LabeledArrayFloat || + V == VariantType::LabeledArrayDouble); +} + +template +constexpr auto isSimpleVariant() +{ + return (V == VariantType::Int) || + (V == VariantType::Int64) || + (V == VariantType::UInt8) || + (V == VariantType::UInt16) || + (V == VariantType::UInt32) || + (V == VariantType::UInt64) || + (V == VariantType::Float) || + (V == VariantType::Double) || + (V == VariantType::Bool); } template @@ -285,10 +307,10 @@ class Variant } Variant(const Variant& other); - Variant(Variant&& other); + Variant(Variant&& other) noexcept; ~Variant(); Variant& operator=(const Variant& other); - Variant& operator=(Variant&& other); + Variant& operator=(Variant&& other) noexcept; template T get() const diff --git a/Framework/Core/src/BoostOptionsRetriever.cxx b/Framework/Core/src/BoostOptionsRetriever.cxx index ae9183e16400c..63b8c07fbb946 100644 --- a/Framework/Core/src/BoostOptionsRetriever.cxx +++ b/Framework/Core/src/BoostOptionsRetriever.cxx @@ -50,6 +50,18 @@ void BoostOptionsRetriever::update(std::vector const& specs, case VariantType::Int: options = options(name, bpo::value()->default_value(spec.defaultValue.get()), help); break; + case VariantType::UInt8: + options = options(name, bpo::value()->default_value(spec.defaultValue.get()), help); + break; + case VariantType::UInt16: + options = options(name, bpo::value()->default_value(spec.defaultValue.get()), help); + break; + case VariantType::UInt32: + options = options(name, bpo::value()->default_value(spec.defaultValue.get()), help); + break; + case VariantType::UInt64: + options = options(name, bpo::value()->default_value(spec.defaultValue.get()), help); + break; case VariantType::Int64: options = options(name, bpo::value()->default_value(spec.defaultValue.get()), help); break; diff --git a/Framework/Core/src/ConfigParamsHelper.cxx b/Framework/Core/src/ConfigParamsHelper.cxx index 169433dfa53d3..b52d44a294a97 100644 --- a/Framework/Core/src/ConfigParamsHelper.cxx +++ b/Framework/Core/src/ConfigParamsHelper.cxx @@ -44,6 +44,18 @@ void ConfigParamsHelper::populateBoostProgramOptions( case VariantType::Int64: addConfigSpecOption(spec, options); break; + case VariantType::UInt8: + addConfigSpecOption(spec, options); + break; + case VariantType::UInt16: + addConfigSpecOption(spec, options); + break; + case VariantType::UInt32: + addConfigSpecOption(spec, options); + break; + case VariantType::UInt64: + addConfigSpecOption(spec, options); + break; case VariantType::Float: addConfigSpecOption(spec, options); break; diff --git a/Framework/Core/src/PropertyTreeHelpers.cxx b/Framework/Core/src/PropertyTreeHelpers.cxx index ba9a7f01c25b0..dbbfc0a97a93f 100644 --- a/Framework/Core/src/PropertyTreeHelpers.cxx +++ b/Framework/Core/src/PropertyTreeHelpers.cxx @@ -36,6 +36,18 @@ void PropertyTreeHelpers::populateDefaults(std::vector const& s case VariantType::Int: pt.put(key, spec.defaultValue.get()); break; + case VariantType::UInt8: + pt.put(key, spec.defaultValue.get()); + break; + case VariantType::UInt16: + pt.put(key, spec.defaultValue.get()); + break; + case VariantType::UInt32: + pt.put(key, spec.defaultValue.get()); + break; + case VariantType::UInt64: + pt.put(key, spec.defaultValue.get()); + break; case VariantType::Int64: pt.put(key, spec.defaultValue.get()); break; @@ -116,6 +128,18 @@ void PropertyTreeHelpers::populate(std::vector const& schema, case VariantType::Int: pt.put(key, vmap[key].as()); break; + case VariantType::UInt8: + pt.put(key, vmap[key].as()); + break; + case VariantType::UInt16: + pt.put(key, vmap[key].as()); + break; + case VariantType::UInt32: + pt.put(key, vmap[key].as()); + break; + case VariantType::UInt64: + pt.put(key, vmap[key].as()); + break; case VariantType::Int64: pt.put(key, vmap[key].as()); break; @@ -209,6 +233,18 @@ void PropertyTreeHelpers::populate(std::vector const& schema, case VariantType::Int: pt.put(key, (*it).get_value()); break; + case VariantType::UInt8: + pt.put(key, (*it).get_value()); + break; + case VariantType::UInt16: + pt.put(key, (*it).get_value()); + break; + case VariantType::UInt32: + pt.put(key, (*it).get_value()); + break; + case VariantType::UInt64: + pt.put(key, (*it).get_value()); + break; case VariantType::Int64: pt.put(key, (*it).get_value()); break; diff --git a/Framework/Core/src/Variant.cxx b/Framework/Core/src/Variant.cxx index ad9a6461f9fd0..41c46e98629cb 100644 --- a/Framework/Core/src/Variant.cxx +++ b/Framework/Core/src/Variant.cxx @@ -56,6 +56,18 @@ std::ostream& operator<<(std::ostream& oss, Variant const& val) case VariantType::Int: oss << val.get(); break; + case VariantType::UInt8: + oss << val.get(); + break; + case VariantType::UInt16: + oss << val.get(); + break; + case VariantType::UInt32: + oss << val.get(); + break; + case VariantType::UInt64: + oss << val.get(); + break; case VariantType::Int64: oss << val.get(); break; @@ -146,7 +158,7 @@ Variant::Variant(const Variant& other) : mType(other.mType) } } -Variant::Variant(Variant&& other) : mType(other.mType) +Variant::Variant(Variant&& other) noexcept : mType(other.mType) { mStore = other.mStore; mSize = other.mSize; @@ -222,7 +234,7 @@ Variant& Variant::operator=(const Variant& other) } } -Variant& Variant::operator=(Variant&& other) +Variant& Variant::operator=(Variant&& other) noexcept { mSize = other.mSize; mType = other.mType; diff --git a/Framework/Core/src/WorkflowSerializationHelpers.cxx b/Framework/Core/src/WorkflowSerializationHelpers.cxx index eb2ce9aafc3ec..fc4d0765a20ed 100644 --- a/Framework/Core/src/WorkflowSerializationHelpers.cxx +++ b/Framework/Core/src/WorkflowSerializationHelpers.cxx @@ -319,6 +319,18 @@ struct WorkflowImporter : public rapidjson::BaseReaderHandler, case VariantType::Int: opt = std::make_unique(optionName, optionType, std::stoi(optionDefault, nullptr), HelpString{optionHelp}, optionKind); break; + case VariantType::UInt8: + opt = std::make_unique(optionName, optionType, static_cast(std::stoul(optionDefault, nullptr)), HelpString{optionHelp}, optionKind); + break; + case VariantType::UInt16: + opt = std::make_unique(optionName, optionType, static_cast(std::stoul(optionDefault, nullptr)), HelpString{optionHelp}, optionKind); + break; + case VariantType::UInt32: + opt = std::make_unique(optionName, optionType, static_cast(std::stoul(optionDefault, nullptr)), HelpString{optionHelp}, optionKind); + break; + case VariantType::UInt64: + opt = std::make_unique(optionName, optionType, std::stoul(optionDefault, nullptr), HelpString{optionHelp}, optionKind); + break; case VariantType::Int64: opt = std::make_unique(optionName, optionType, std::stol(optionDefault, nullptr), HelpString{optionHelp}, optionKind); break; diff --git a/Framework/Core/test/test_BoostOptionsRetriever.cxx b/Framework/Core/test/test_BoostOptionsRetriever.cxx index 6da8b2d871a78..812e184a54354 100644 --- a/Framework/Core/test/test_BoostOptionsRetriever.cxx +++ b/Framework/Core/test/test_BoostOptionsRetriever.cxx @@ -29,6 +29,10 @@ BOOST_AUTO_TEST_CASE(TrivialBoostOptionsRetrieverTest) auto specs = std::vector{ {"someInt", VariantType::Int, 2, {"some int option"}}, + {"someUInt8", VariantType::UInt8, static_cast(2u), {"some uint8 option"}}, + {"someUInt16", VariantType::UInt16, static_cast(2u), {"some uint16 option"}}, + {"someUInt32", VariantType::UInt32, 2u, {"some uint32 option"}}, + {"someUInt64", VariantType::UInt64, static_cast(2ul), {"some uint64 option"}}, {"someInt64", VariantType::Int64, 4ll, {"some int64 option"}}, {"someBool", VariantType::Bool, false, {"some bool option"}}, {"someFloat", VariantType::Float, 2.0f, {"some float option"}}, @@ -38,6 +42,10 @@ BOOST_AUTO_TEST_CASE(TrivialBoostOptionsRetrieverTest) "test", "--someBool", "--someInt", "1", + "--someUInt8", "1", + "--someUInt16", "1", + "--someUInt32", "1", + "--someUInt64", "1", "--someInt64", "50000000000000", "--someFloat", "0.5", "--someDouble", "0.5", @@ -50,6 +58,10 @@ BOOST_AUTO_TEST_CASE(TrivialBoostOptionsRetrieverTest) bpo::store(parse_command_line(sizeof(args) / sizeof(char*), args, opts), vm); bpo::notify(vm); BOOST_CHECK(vm["someInt"].as() == 1); + BOOST_CHECK(vm["someUInt8"].as() == '1'); + BOOST_CHECK(vm["someUInt16"].as() == 1); + BOOST_CHECK(vm["someUInt32"].as() == 1); + BOOST_CHECK(vm["someUInt64"].as() == 1); BOOST_CHECK(vm["someInt64"].as() == 50000000000000ll); BOOST_CHECK(vm["someBool"].as() == true); BOOST_CHECK(vm["someString"].as() == "foobar"); diff --git a/Framework/Core/test/test_ConfigParamRegistry.cxx b/Framework/Core/test/test_ConfigParamRegistry.cxx index 61ffa2c8edd5f..5f00986529344 100644 --- a/Framework/Core/test/test_ConfigParamRegistry.cxx +++ b/Framework/Core/test/test_ConfigParamRegistry.cxx @@ -41,6 +41,10 @@ BOOST_AUTO_TEST_CASE(TestConfigParamRegistry) ("aFloat", bpo::value()->default_value(10.f)) // ("aDouble", bpo::value()->default_value(20.)) // ("anInt", bpo::value()->default_value(1)) // + ("anUInt8", bpo::value()->default_value(1)) // + ("anUInt16", bpo::value()->default_value(1)) // + ("anUInt32", bpo::value()->default_value(1)) // + ("anUInt64", bpo::value()->default_value(1)) // ("anInt64", bpo::value()->default_value(1ll)) // ("aBoolean", bpo::value()->zero_tokens()->default_value(false)) // ("aString,s", bpo::value()->default_value("something")) // @@ -52,6 +56,10 @@ BOOST_AUTO_TEST_CASE(TestConfigParamRegistry) options->ParseAll({"cmd", "--aFloat", "1.0", "--aDouble", "2.0", "--anInt", "10", + "--anUInt8", "2", + "--anUInt16", "10", + "--anUInt32", "10", + "--anUInt64", "10", "--anInt64", "50000000000000", "--aBoolean", "-s", "somethingelse", @@ -60,6 +68,10 @@ BOOST_AUTO_TEST_CASE(TestConfigParamRegistry) true); std::vector specs{ ConfigParamSpec{"anInt", VariantType::Int, 1, {"an int option"}}, + ConfigParamSpec{"anUInt8", VariantType::UInt8, static_cast(1u), {"an uint8 option"}}, + ConfigParamSpec{"anUInt16", VariantType::UInt16, static_cast(1u), {"an uint16 option"}}, + ConfigParamSpec{"anUInt32", VariantType::UInt32, 1u, {"an uint32 option"}}, + ConfigParamSpec{"anUInt64", VariantType::UInt64, static_cast(1ul), {"an uint64 option"}}, ConfigParamSpec{"anInt64", VariantType::Int64, 1ll, {"an int64_t option"}}, ConfigParamSpec{"aFloat", VariantType::Float, 2.0f, {"a float option"}}, ConfigParamSpec{"aDouble", VariantType::Double, 3., {"a double option"}}, @@ -82,6 +94,10 @@ BOOST_AUTO_TEST_CASE(TestConfigParamRegistry) BOOST_CHECK_EQUAL(registry.get("aFloat"), 1.0); BOOST_CHECK_EQUAL(registry.get("aDouble"), 2.0); BOOST_CHECK_EQUAL(registry.get("anInt"), 10); + BOOST_CHECK_EQUAL(registry.get("anUInt8"), '2'); + BOOST_CHECK_EQUAL(registry.get("anUInt16"), 10); + BOOST_CHECK_EQUAL(registry.get("anUInt32"), 10); + BOOST_CHECK_EQUAL(registry.get("anUInt64"), 10); BOOST_CHECK_EQUAL(registry.get("anInt64"), 50000000000000ll); BOOST_CHECK_EQUAL(registry.get("aBoolean"), true); BOOST_CHECK_EQUAL(registry.get("aString"), "somethingelse"); diff --git a/Framework/Core/test/test_ConfigParamStore.cxx b/Framework/Core/test/test_ConfigParamStore.cxx index fa51ed35caae6..df56fdf8a0e18 100644 --- a/Framework/Core/test/test_ConfigParamStore.cxx +++ b/Framework/Core/test/test_ConfigParamStore.cxx @@ -31,6 +31,10 @@ BOOST_AUTO_TEST_CASE(TestConfigParamStore) ("aFloat", bpo::value()->default_value(10.f)) // ("aDouble", bpo::value()->default_value(20.)) // ("anInt", bpo::value()->default_value(1)) // + ("anUInt8", bpo::value()->default_value(1)) // + ("anUInt16", bpo::value()->default_value(1)) // + ("anUInt32", bpo::value()->default_value(1)) // + ("anUInt64", bpo::value()->default_value(1)) // ("anInt64", bpo::value()->default_value(1ll)) // ("aBoolean", bpo::value()->zero_tokens()->default_value(false)) // ("aString,s", bpo::value()->default_value("something")) // @@ -42,6 +46,10 @@ BOOST_AUTO_TEST_CASE(TestConfigParamStore) options->ParseAll({"cmd", "--aFloat", "1.0", "--aDouble", "2.0", "--anInt", "10", + "--anUInt8", "2", + "--anUInt16", "10", + "--anUInt32", "10", + "--anUInt64", "10", "--anInt64", "50000000000000", "--aBoolean", "-s", "somethingelse", @@ -50,6 +58,10 @@ BOOST_AUTO_TEST_CASE(TestConfigParamStore) true); std::vector specs{ ConfigParamSpec{"anInt", VariantType::Int, 1, {"an int option"}}, + ConfigParamSpec{"anUInt8", VariantType::UInt8, static_cast(1u), {"an int option"}}, + ConfigParamSpec{"anUInt16", VariantType::UInt16, static_cast(1u), {"an int option"}}, + ConfigParamSpec{"anUInt32", VariantType::UInt32, 1u, {"an int option"}}, + ConfigParamSpec{"anUInt64", VariantType::UInt64, static_cast(1ul), {"an int option"}}, ConfigParamSpec{"anInt64", VariantType::Int64, 1ll, {"an int64_t option"}}, ConfigParamSpec{"aFloat", VariantType::Float, 2.0f, {"a float option"}}, ConfigParamSpec{"aDouble", VariantType::Double, 3., {"a double option"}}, @@ -71,6 +83,10 @@ BOOST_AUTO_TEST_CASE(TestConfigParamStore) BOOST_CHECK_EQUAL(store.store().get("aFloat"), 1.0); BOOST_CHECK_EQUAL(store.store().get("aDouble"), 2.0); BOOST_CHECK_EQUAL(store.store().get("anInt"), 10); + BOOST_CHECK_EQUAL(store.store().get("anUInt8"), '2'); + BOOST_CHECK_EQUAL(store.store().get("anUInt16"), 10); + BOOST_CHECK_EQUAL(store.store().get("anUInt32"), 10); + BOOST_CHECK_EQUAL(store.store().get("anUInt64"), 10); BOOST_CHECK_EQUAL(store.store().get("anInt64"), 50000000000000ll); BOOST_CHECK_EQUAL(store.store().get("aBoolean"), true); BOOST_CHECK_EQUAL(store.store().get("aString"), "somethingelse"); @@ -87,6 +103,10 @@ BOOST_AUTO_TEST_CASE(TestConfigParamStore) BOOST_CHECK_EQUAL(store.provenance("aFloat"), "fairmq"); BOOST_CHECK_EQUAL(store.provenance("aDouble"), "fairmq"); BOOST_CHECK_EQUAL(store.provenance("anInt"), "fairmq"); + BOOST_CHECK_EQUAL(store.provenance("anUInt8"), "fairmq"); + BOOST_CHECK_EQUAL(store.provenance("anUInt16"), "fairmq"); + BOOST_CHECK_EQUAL(store.provenance("anUInt32"), "fairmq"); + BOOST_CHECK_EQUAL(store.provenance("anUInt64"), "fairmq"); BOOST_CHECK_EQUAL(store.provenance("anInt64"), "fairmq"); BOOST_CHECK_EQUAL(store.provenance("aBoolean"), "fairmq"); BOOST_CHECK_EQUAL(store.provenance("aString"), "fairmq"); diff --git a/Framework/GUISupport/src/FrameworkGUIDeviceInspector.cxx b/Framework/GUISupport/src/FrameworkGUIDeviceInspector.cxx index cc74f3d9f3855..8630dc2cbb178 100644 --- a/Framework/GUISupport/src/FrameworkGUIDeviceInspector.cxx +++ b/Framework/GUISupport/src/FrameworkGUIDeviceInspector.cxx @@ -122,6 +122,21 @@ void optionsTable(const char* label, std::vector const& options case VariantType::Int: ImGui::Text("%d (default)", option.defaultValue.get()); break; + case VariantType::Int64: + ImGui::Text("%lld (default)", option.defaultValue.get()); + break; + case VariantType::UInt8: + ImGui::Text("%d (default)", option.defaultValue.get()); + break; + case VariantType::UInt16: + ImGui::Text("%d (default)", option.defaultValue.get()); + break; + case VariantType::UInt32: + ImGui::Text("%d (default)", option.defaultValue.get()); + break; + case VariantType::UInt64: + ImGui::Text("%lld (default)", option.defaultValue.get()); + break; case VariantType::Float: ImGui::Text("%f (default)", option.defaultValue.get()); break;