split domain getter

Author: mwestphal

cmake/f3dOptions.cmake

@@ -76,7 +76,8 @@ function (f3d_generate_options)
   list(JOIN _options_is_optional ";\n  else " _options_is_optional)
   list(JOIN _options_reset ";\n  else " _options_reset)
   list(JOIN _options_has_domain ";\n  else " _options_has_domain)
-  list(JOIN _options_get_domain ";\n  else " _options_get_domain)
+  list(JOIN _options_get_enum_domain ";\n  else " _options_get_enum_domain)
+  list(JOIN _options_get_range_domain ";\n  else " _options_get_range_domain)
   list(JOIN _options_increase ";\n  else " _options_increase)
   list(JOIN _options_cycle ";\n  else " _options_cycle)
 
@@ -261,7 +262,8 @@ function(_parse_json_option _top_json)
          # Add range domain to struct and methods
          string(APPEND _options_domains_struct "${_option_indent}    domain_range_t<${_option_domain_type}> ${_member_name} = ${_range_value_initialize};\n")
          list(APPEND _options_has_domain "if (name == \"${_option_name}\") return options_tools::hasDomain(style, options::domain_style::RANGE)")
-         list(APPEND _options_get_domain "if (name == \"${_option_name}\") return options_tools::getDomain(opt.domains.${_option_name})")
+         list(APPEND _options_get_enum_domain "if (name == \"${_option_name}\") throw options::incompatible_exception(\"Trying to get domain \" + std::string(\"${_option_name}\") + \" with incompatible option\")")
+         list(APPEND _options_get_range_domain "if (name == \"${_option_name}\") return options_tools::getRangeDomain(opt.domains.${_option_name})")
          list(APPEND _options_increase "if (name == \"${_option_name}\") options_tools::increase(opt.${_option_name}, opt.domains.${_option_name}, up)")
          list(APPEND _options_cycle "if (name == \"${_option_name}\") throw options::incompatible_exception(\"Trying to increase \" + std::string(\"${_option_name}\") + \" with incompatible option\")")
 
@@ -284,14 +286,16 @@ function(_parse_json_option _top_json)
            # Add enum domain to struct and methods
            string(APPEND _options_domains_struct "${_option_indent}    domain_enum_t<${_option_domain_type}> ${_member_name} = ${_enum_value_initialize};\n")
            list(APPEND _options_has_domain "if (name == \"${_option_name}\") return options_tools::hasDomain(style, options::domain_style::ENUM)")
-           list(APPEND _options_get_domain "if (name == \"${_option_name}\") return options_tools::getDomain(opt.domains.${_option_name})")
+           list(APPEND _options_get_range_domain "if (name == \"${_option_name}\") throw options::incompatible_exception(\"Trying to get domain \" + std::string(\"${_option_name}\") + \" with incompatible option\")")
+           list(APPEND _options_get_enum_domain "if (name == \"${_option_name}\") return options_tools::getEnumDomain(opt.domains.${_option_name})")
            list(APPEND _options_increase "if (name == \"${_option_name}\") throw options::incompatible_exception(\"Trying to cycle \" + std::string(\"${_option_name}\") + \" with incompatible option\")")
            list(APPEND _options_cycle "if (name == \"${_option_name}\") options_tools::cycle(opt.${_option_name}, opt.domains.${_option_name})")
 
          # No domain
          else()
            list(APPEND _options_has_domain "if (name == \"${_option_name}\") return false")
-           list(APPEND _options_get_domain "if (name == \"${_option_name}\") throw options::incompatible_exception(\"Trying to get domain \" + std::string(\"${_option_name}\") + \" with incompatible option\")")
+           list(APPEND _options_get_range_domain "if (name == \"${_option_name}\") throw options::incompatible_exception(\"Trying to get domain \" + std::string(\"${_option_name}\") + \" with incompatible option\")")
+           list(APPEND _options_get_enum_domain "if (name == \"${_option_name}\") throw options::incompatible_exception(\"Trying to get domain \" + std::string(\"${_option_name}\") + \" with incompatible option\")")
            list(APPEND _options_increase "if (name == \"${_option_name}\") throw options::incompatible_exception(\"Trying to cycle \" + std::string(\"${_option_name}\") + \" with incompatible option\")")
            list(APPEND _options_cycle "if (name == \"${_option_name}\") throw options::incompatible_exception(\"Trying to increase \" + std::string(\"${_option_name}\") + \" with incompatible option\")")
          endif()
@@ -324,7 +328,8 @@ function(_parse_json_option _top_json)
   set(_options_is_optional ${_options_is_optional} PARENT_SCOPE)
   set(_options_reset ${_options_reset} PARENT_SCOPE)
   set(_options_has_domain ${_options_has_domain} PARENT_SCOPE)
-  set(_options_get_domain ${_options_get_domain} PARENT_SCOPE)
+  set(_options_get_range_domain ${_options_get_range_domain} PARENT_SCOPE)
+  set(_options_get_enum_domain ${_options_get_enum_domain} PARENT_SCOPE)
   set(_options_increase ${_options_increase} PARENT_SCOPE)
   set(_options_cycle ${_options_cycle} PARENT_SCOPE)
 endfunction()

library/private/options_generated.h.in

@@ -138,12 +138,24 @@ bool hasDomain(std::string_view name, f3d::options::domain_style& style)
 
 //----------------------------------------------------------------------------
 /**
- * Generated method, see `options::getDomain`
+ * Generated method, see `options::getEnumDomain`
  */
-std::vector<std::string> getDomain(const f3d::options& opt, std::string_view name)
+std::vector<std::string> getEnumDomain(const f3d::options& opt, std::string_view name)
 {
   // clang-format off
-  ${_options_get_domain};
+  ${_options_get_enum_domain};
+  // clang-format on
+  else throw options::inexistent_exception("Option " + std::string(name) + " does not exist");
+}
+
+//----------------------------------------------------------------------------
+/**
+ * Generated method, see `options::getRangeDomain`
+ */
+std::pair<std::array<std::string, 2>, std::string> getRangeDomain(const f3d::options& opt, std::string_view name)
+{
+  // clang-format off
+  ${_options_get_range_domain};
   // clang-format on
   else throw options::inexistent_exception("Option " + std::string(name) + " does not exist");
 }

library/private/options_tools.h

@@ -901,12 +901,24 @@ bool hasDomain(f3d::options::domain_style& styleVar, const f3d::options::domain_
  * Get provided domain_range as a string vector
  */
 template<typename T>
-std::vector<std::string> getDomain(const f3d::options::domain_range_t<T>& domain)
+std::pair<std::array<std::string, 2>, std::string> getRangeDomain(const f3d::options::domain_range_t<T>& domain)
 {
-  std::vector<std::string> ret;
-  ret.emplace_back(format(domain.range[0]));
-  ret.emplace_back(format(domain.range[1]));
-  ret.emplace_back(format(domain.increment));
+  std::pair<std::array<std::string, 2>, std::string> ret;
+  ret.first[0] = std::move(format(domain.range[0]));
+  ret.first[1] = std::move(format(domain.range[1]));
+  ret.second = std::move(format(domain.increment));
+  return ret;
+}
+
+//----------------------------------------------------------------------------
+/**
+ * Get provided domain_range<std::string> as a string vector
+ */
+std::pair<std::array<std::string, 2>, std::string> getRangeDomain(const f3d::options::domain_range_t<std::string>& domain)
+{
+  std::pair<std::array<std::string, 2>, std::string> ret;
+  ret.first = domain.range;
+  ret.second = domain.increment;
   return ret;
 }
 
@@ -915,7 +927,7 @@ std::vector<std::string> getDomain(const f3d::options::domain_range_t<T>& domain
  * Get provided domain_enum as a string vector
  */
 template<typename T>
-std::vector<std::string> getDomain(const f3d::options::domain_enum_t<T>& domain)
+std::vector<std::string> getEnumDomain(const f3d::options::domain_enum_t<T>& domain)
 {
   std::vector<std::string> ret;
   std::ranges::transform(
@@ -927,7 +939,7 @@ std::vector<std::string> getDomain(const f3d::options::domain_enum_t<T>& domain)
 /**
  * Get provided domain_enum<std::string> enumeration
  */
-std::vector<std::string> getDomain(const f3d::options::domain_enum_t<std::string>& domain)
+std::vector<std::string> getEnumDomain(const f3d::options::domain_enum_t<std::string>& domain)
 {
   return domain.enumeration;
 }

library/public/options.h.in

@@ -166,13 +166,20 @@ public:
   [[nodiscard]] bool hasDomain(std::string_view name, domain_style& style) const;
 
   /**
-   * Return a string vector version of the domain of provided option.
-   * For a range domain, [0] and [1] are min and max respectively, [2] is the increment.
-   * For a enum domain, the enumeration is provided as is.
-   * Throw options::incompatible_exception if option has no domain.
+   * Return a the min, max and increment of the range domain of provided option.
+   * Provided as a pair containing the min/max as an array and the increment.
+   * Throw options::incompatible_exception if option doesn't have a range domain.
    * Throws an options::inexistent_exception if option does not exist.
    */
-  [[nodiscard]] std::vector<std::string> getDomain(std::string_view name) const;
+  [[nodiscard]] std::pair<std::array<std::string, 2>, std::string> getRangeDomain(std::string_view name) const;
+
+  /**
+   * Return a the enumeration of the enum domain of provided option.
+   * The enumeration is provided as is in string form.
+   * Throw options::incompatible_exception if option doesn't have an enumeration domain.
+   * Throws an options::inexistent_exception if option does not exist.
+   */
+  [[nodiscard]] std::vector<std::string> getEnumDomain(std::string_view name) const;
 
   /**
    * Increase an option value if it has a range domain, else throws

library/src/interactor_impl.cxx

@@ -831,7 +831,7 @@ interactor& interactor_impl::initCommands()
           style == f3d::options::domain_style::ENUM)
         {
           // recover the enumeration
-          std::vector<std::string> enumeration = this->Internals->Options.getDomain(args[0]);
+          std::vector<std::string> enumeration = this->Internals->Options.getEnumDomain(args[0]);
 
           // Transform potential values into found option
           std::ranges::transform(enumeration, std::back_inserter(candidates),
@@ -857,7 +857,7 @@ interactor& interactor_impl::initCommands()
         style == f3d::options::domain_style::ENUM)
       {
         // recover the enumeration
-        std::vector<std::string> enumeration = this->Internals->Options.getDomain(args[0]);
+        std::vector<std::string> enumeration = this->Internals->Options.getEnumDomain(args[0]);
 
         // Complete the option value if possible
         return complNames(args, enumeration, 1);

library/src/options.cxx

@@ -195,9 +195,15 @@ bool options::hasDomain(std::string_view name, domain_style& style) const
 }
 
 //----------------------------------------------------------------------------
-std::vector<std::string> options::getDomain(std::string_view name) const
+std::pair<std::array<std::string, 2>, std::string> options::getRangeDomain(std::string_view name) const
 {
-  return options_generated::getDomain(*this, name);
+  return options_generated::getRangeDomain(*this, name);
+}
+
+//----------------------------------------------------------------------------
+std::vector<std::string> options::getEnumDomain(std::string_view name) const
+{
+  return options_generated::getEnumDomain(*this, name);
 }
 
 //----------------------------------------------------------------------------

library/testing/TestSDKOptionsDomains.cxx

@@ -18,14 +18,22 @@ int TestSDKOptionsDomains([[maybe_unused]] int argc, [[maybe_unused]] char* argv
   test.expect<f3d::options::inexistent_exception>(
     "hasDomain inexistent", [&]() { std::ignore = opt.hasDomain("inexistent", style); });
 
-  // Test getDomain
-  test("getDomain range", opt.getDomain("scene.animation.speed_factor"), { "0", "2", "0.1" });
-  test("getDomain enum", opt.getDomain("render.effect.blending.mode"),
+  // Test getRangeDomain
+  std::pair<std::array<std::string, 2>, std::string> rangeDomain = opt.getRangeDomain("scene.animation.speed_factor");
+  test("getRangeDomain range", rangeDomain.first, {"0", "2"});
+  test("getRangeDomain increment", rangeDomain.second, std::string("0.1"));
+  test.expect<f3d::options::incompatible_exception>(
+    "getRangeDomain incompatible", [&]() { std::ignore = opt.getRangeDomain("model.scivis.cells"); });
+  test.expect<f3d::options::inexistent_exception>(
+    "getRangeDomain inexistent", [&]() { std::ignore = opt.getRangeDomain("inexistent"); });
+
+  // Test getEnumDomain
+  test("getEnumDomain", opt.getEnumDomain("render.effect.blending.mode"),
     { "none", "ddp", "sort", "sort_cpu", "stochastic" });
   test.expect<f3d::options::incompatible_exception>(
-    "getDomain incompatible", [&]() { std::ignore = opt.getDomain("model.scivis.cells"); });
+    "getEnumDomain incompatible", [&]() { std::ignore = opt.getEnumDomain("model.scivis.cells"); });
   test.expect<f3d::options::inexistent_exception>(
-    "getDomain inexistent", [&]() { std::ignore = opt.getDomain("inexistent"); });
+    "getEnumDomain inexistent", [&]() { std::ignore = opt.getEnumDomain("inexistent"); });
 
   // Test increase/decrease
 
@@ -110,25 +118,64 @@ int TestSDKOptionsDomains([[maybe_unused]] int argc, [[maybe_unused]] char* argv
   // render.effect.blending.mode: tested above
   // scene.animation.speed_factor: tested above
   // render.raytracing.samples: tested above
-  test("interactor.style domain", opt.getDomain("interactor.style"), {"default", "trackball", "2d"});
-  test("model.color.opacity domain", opt.getDomain("model.color.opacity"), {"0", "1", "0.05"});
-  test("model.material.base_ior domain", opt.getDomain("model.material.base_ior"), {"0", "1", "0.05"});
-  test("model.material.metallic domain", opt.getDomain("model.material.metallic"), {"0", "1", "0.05"});
-  test("model.material.roughness domain", opt.getDomain("model.material.roughness"), {"0", "1", "0.05"});
-  test("model.normal.scale domain", opt.getDomain("model.normal.scale"), {"0", "1", "0.05"});
-  test("model.normal_glyphs.scale domain", opt.getDomain("model.normal_glyphs.scale"), {"0", "10", "0.1"});
-  test("model.point_sprites.size domain", opt.getDomain("model.point_sprites.size"), {"1", "100", "1"});
-  test("model.point_sprites.type domain", opt.getDomain("model.point_sprites.type"), {"none", "sphere", "gaussian", "circle", "stddev", "bound","cross"});
-  test("model.scivis.discretization domain", opt.getDomain("model.scivis.discretization"), {"1", "1024", "5"});
-  test("render.backface_type domain", opt.getDomain("render.backface_type"), {"visible", "hidden"});
-  test("render.background.blur.coc domain", opt.getDomain("render.background.blur.coc"), {"0", "100", "5"});
-  test("render.effect.antialiasing.mode domain", opt.getDomain("render.effect.antialiasing.mode"), {"none", "fxaa", "ssaa", "taa"});
-  test("render.light.intensity domain", opt.getDomain("render.light.intensity"), {"0", "5", "0.02"});
-  test("render.line_width domain", opt.getDomain("render.line_width"), {"0", "10", "0.1"});
-  test("render.point_size domain", opt.getDomain("render.point_size"), {"0", "10", "0.1"});
-  test("scene.camera.index domain", opt.getDomain("scene.camera.index"), {});
-  test("ui.backdrop.opacity domain", opt.getDomain("ui.backdrop.opacity"), {"0", "1", "0.05"});
-  test("ui.scale domain", opt.getDomain("ui.scale"), {"0", "10", "0.1"});
+
+  rangeDomain = opt.getRangeDomain("model.color.opacity");
+  test("model.color.opacity range", rangeDomain.first, {"0", "1"});
+  test("model.color.opacity increment", rangeDomain.second, std::string("0.05"));
+
+  rangeDomain = opt.getRangeDomain("model.material.base_ior");
+  test("model.material.base_ior range", rangeDomain.first, {"0", "1"});
+  test("model.material.base_ior increment", rangeDomain.second, std::string("0.05"));
+
+  rangeDomain = opt.getRangeDomain("model.material.metallic");
+  test("model.material.metallic range", rangeDomain.first, {"0", "1"});
+  test("model.material.metallic increment", rangeDomain.second, std::string("0.05"));
+
+  rangeDomain = opt.getRangeDomain("model.material.roughness");
+  test("model.material.roughness range", rangeDomain.first, {"0", "1"});
+  test("model.material.roughness increment", rangeDomain.second, std::string("0.05"));
+
+  rangeDomain = opt.getRangeDomain("model.normal.scale");
+  test("model.normal.scale range", rangeDomain.first, {"0", "1"});
+  test("model.normal.scale increment", rangeDomain.second, std::string("0.05"));
+
+  rangeDomain = opt.getRangeDomain("model.normal_glyphs.scale");
+  test("model.normal_glyphs.scale range", rangeDomain.first, {"0", "10"});
+  test("model.normal_glyphs.scale increment", rangeDomain.second, std::string("0.1"));
+
+  rangeDomain = opt.getRangeDomain("model.scivis.discretization");
+  test("model.scivis.discretization range", rangeDomain.first, {"1", "1024"});
+  test("model.scivis.discretization increment", rangeDomain.second, std::string("5"));
+
+  rangeDomain = opt.getRangeDomain("render.background.blur.coc");
+  test("render.background.blur.coc range", rangeDomain.first, {"0", "100"});
+  test("render.background.blur.coc increment", rangeDomain.second, std::string("5"));
+
+  rangeDomain = opt.getRangeDomain("render.light.intensity");
+  test("render.light.intensity range", rangeDomain.first, {"0", "5"});
+  test("render.light.intensity increment", rangeDomain.second, std::string("0.02"));
+
+  rangeDomain = opt.getRangeDomain("render.line_width");
+  test("render.line_width range", rangeDomain.first, {"0", "10"});
+  test("render.line_width increment", rangeDomain.second, std::string("0.1"));
+
+  rangeDomain = opt.getRangeDomain("render.point_size");
+  test("render.point_size range", rangeDomain.first, {"0", "10"});
+  test("render.point_size increment", rangeDomain.second, std::string("0.1"));
+
+  rangeDomain = opt.getRangeDomain("ui.backdrop.opacity");
+  test("ui.backdrop.opacity range", rangeDomain.first, {"0", "1"});
+  test("ui.backdrop.opacity increment", rangeDomain.second, std::string("0.05"));
+
+  rangeDomain = opt.getRangeDomain("ui.scale");
+  test("ui.scale range", rangeDomain.first, {"0", "10"});
+  test("ui.scale increment", rangeDomain.second, std::string("0.1"));
+
+  test("interactor.style enum", opt.getEnumDomain("interactor.style"), {"default", "trackball", "2d"});
+  test("model.point_sprites.type enum", opt.getEnumDomain("model.point_sprites.type"), {"none", "sphere", "gaussian", "circle", "stddev", "bound","cross"});
+  test("render.backface_type enum", opt.getEnumDomain("render.backface_type"), {"visible", "hidden"});
+  test("render.effect.antialiasing.mode enum", opt.getEnumDomain("render.effect.antialiasing.mode"), {"none", "fxaa", "ssaa", "taa"});
+  test("scene.camera.index enum", opt.getEnumDomain("scene.camera.index"), {});
   // clang-format on
 
   return test.result();