Compile time check on named parameters passed to a function

Convex_hull_3/include/CGAL/convex_hull_3.h

@@ -1064,6 +1064,8 @@ void convex_hull_3(const VertexListGraph& g,
                    PolygonMesh& pm,
                    const NamedParameters& np = parameters::default_values())
 {
+  CGAL_CHECK_AUTHORIZED_NAMED_PARAMETERS(np, vertex_point_t);
+
   using CGAL::parameters::choose_parameter;
   using CGAL::parameters::get_parameter;
 

Kinetic_space_partition/include/CGAL/Kinetic_space_partition_3.h

@@ -279,7 +279,10 @@ class Kinetic_space_partition_3 {
     m_parameters(
       parameters::choose_parameter(parameters::get_parameter(np, internal_np::verbose), false),
       parameters::choose_parameter(parameters::get_parameter(np, internal_np::debug), false)), // use true here to export all steps
-    m_input2regularized() {}
+    m_input2regularized()
+  {
+    CGAL_CHECK_AUTHORIZED_NAMED_PARAMETERS(np, verbose_t, debug_t);
+  }
 
   /*!
   \brief constructs a kinetic space partition object and initializes it.
@@ -355,7 +358,11 @@ class Kinetic_space_partition_3 {
     m_parameters(
       parameters::choose_parameter(parameters::get_parameter(np, internal_np::verbose), false),
       parameters::choose_parameter(parameters::get_parameter(np, internal_np::debug), false)), // use true here to export all steps
-    m_input2regularized() {
+    m_input2regularized()
+  {
+    CGAL_CHECK_AUTHORIZED_NAMED_PARAMETERS(np, point_t, debug_t, verbose_t, reorient_bbox_t,
+                                           bbox_dilation_ratio_t, max_octree_depth_t, max_octree_node_size_t);
+
     insert(points, polygons, np);
     initialize(np);
   }
@@ -393,7 +400,9 @@ class Kinetic_space_partition_3 {
   void insert(
     const PointRange& points,
     const PolygonRange& polygons,
-    const NamedParameters& np = CGAL::parameters::default_values()) {
+    const NamedParameters& np = CGAL::parameters::default_values())
+  {
+    CGAL_CHECK_AUTHORIZED_NAMED_PARAMETERS(np, point_t);
 
     using NP_helper = Point_set_processing_3_np_helper<PointRange, NamedParameters>;
     using PointMap = typename NP_helper::Point_map;
@@ -480,7 +489,10 @@ class Kinetic_space_partition_3 {
   template<
     typename NamedParameters = parameters::Default_named_parameters>
   void initialize(
-    const NamedParameters& np = CGAL::parameters::default_values()) {
+    const NamedParameters& np = CGAL::parameters::default_values())
+  {
+    CGAL_CHECK_AUTHORIZED_NAMED_PARAMETERS(np, reorient_bbox_t, bbox_dilation_ratio_t, max_octree_depth_t, max_octree_node_size_t);
+
     Timer timer;
     m_parameters.bbox_dilation_ratio = parameters::choose_parameter(
       parameters::get_parameter(np, internal_np::bbox_dilation_ratio), FT(11) / FT(10));

Kinetic_surface_reconstruction/include/CGAL/Kinetic_surface_reconstruction_3.h

@@ -91,7 +91,10 @@ class Kinetic_surface_reconstruction_3 {
   */
   template<typename NamedParameters = parameters::Default_named_parameters>
   Kinetic_surface_reconstruction_3(Point_range& points,
-    const NamedParameters& np = CGAL::parameters::default_values()) : m_points(points), m_ground_polygon_index(-1), m_kinetic_partition(np) {
+    const NamedParameters& np = CGAL::parameters::default_values()) : m_points(points), m_ground_polygon_index(-1), m_kinetic_partition(np)
+  {
+    CGAL_CHECK_AUTHORIZED_NAMED_PARAMETERS(np, point_t);
+
     m_verbose = parameters::choose_parameter(parameters::get_parameter(np, internal_np::verbose), false);
     m_debug = parameters::choose_parameter(parameters::get_parameter(np, internal_np::debug), false);
 
@@ -178,7 +181,14 @@ class Kinetic_surface_reconstruction_3 {
 
   */
   template<typename CGAL_NP_TEMPLATE_PARAMETERS>
-  std::size_t detect_planar_shapes(const CGAL_NP_CLASS& np = parameters::default_values()) {
+  std::size_t detect_planar_shapes(const CGAL_NP_CLASS& np = parameters::default_values())
+  {
+    CGAL_CHECK_AUTHORIZED_NAMED_PARAMETERS(np, point_t, normal_t, k_neighbors_t, maximum_distance_t, maximum_angle_t,
+                                               minimum_region_size_t, angle_tolerance_t, maximum_offset_t,
+                                               regularize_parallelism_t, regularize_orthogonality_t, regularize_coplanarity_t,
+                                               regularize_axis_symmetry_t, symmetry_direction_t);
+
+
     m_verbose = parameters::choose_parameter(parameters::get_parameter(np, internal_np::verbose), m_verbose);
     m_debug = parameters::choose_parameter(parameters::get_parameter(np, internal_np::debug), m_debug);
 
@@ -319,7 +329,13 @@ class Kinetic_surface_reconstruction_3 {
 
   */
   template<typename CGAL_NP_TEMPLATE_PARAMETERS>
-  void detection_and_partition(std::size_t k, const CGAL_NP_CLASS& np = parameters::default_values()) {
+  void detection_and_partition(std::size_t k, const CGAL_NP_CLASS& np = parameters::default_values())
+  {
+    CGAL_CHECK_AUTHORIZED_NAMED_PARAMETERS(np, point_t, normal_t, k_neighbors_t, maximum_distance_t, maximum_angle_t,
+                                               minimum_region_size_t, angle_tolerance_t, maximum_offset_t, regularize_parallelism_t,
+                                               regularize_orthogonality_t, regularize_coplanarity_t, regularize_axis_symmetry_t,
+                                               symmetry_direction_t, reorient_bbox_t, bbox_dilation_ratio_t);
+
     detect_planar_shapes(np);
     initialize_partition(np);
     partition(k);
@@ -373,7 +389,10 @@ class Kinetic_surface_reconstruction_3 {
     \pre shape detection performed
   */
   template<typename CGAL_NP_TEMPLATE_PARAMETERS>
-  void initialize_partition(const CGAL_NP_CLASS& np = parameters::default_values()) {
+  void initialize_partition(const CGAL_NP_CLASS& np = parameters::default_values())
+  {
+    CGAL_CHECK_AUTHORIZED_NAMED_PARAMETERS(np, reorient_bbox_t, bbox_dilation_ratio_t);
+
     m_kinetic_partition.initialize(np);
   }
 

STL_Extension/include/CGAL/Named_function_parameters.h

@@ -67,7 +67,7 @@ struct Named_params_impl : Base
 {
   typename std::conditional<std::is_copy_constructible<T>::value,
                             T, std::reference_wrapper<const T> >::type v; // copy of the parameter if copyable
-  Named_params_impl(const T& v, const Base& b)
+  constexpr Named_params_impl(const T& v, const Base& b)
     : Base(b)
     , v(v)
   {}
@@ -79,7 +79,7 @@ struct Named_params_impl<T, Tag, No_property>
 {
   typename std::conditional<std::is_copy_constructible<T>::value,
                             T, std::reference_wrapper<const T> >::type v; // copy of the parameter if copyable
-  Named_params_impl(const T& v)
+  constexpr Named_params_impl(const T& v)
     : v(v)
   {}
 };
@@ -256,7 +256,7 @@ namespace parameters{
 typedef Named_function_parameters<bool, internal_np::all_default_t>  Default_named_parameters;
 
 Default_named_parameters
-inline default_values();
+inline constexpr default_values();
 
 // function to extract a parameter
 template <typename T, typename Tag, typename Base, typename Query_tag>
@@ -339,14 +339,15 @@ struct Named_function_parameters
   typedef internal_np::Named_params_impl<T, Tag, Base> base;
   typedef Named_function_parameters<T, Tag, Base> self;
 
-  Named_function_parameters() : base(T()) {}
-  Named_function_parameters(const T& v) : base(v) {}
-  Named_function_parameters(const T& v, const Base& b) : base(v, b) {}
+  constexpr Named_function_parameters() : base(T()) {}
+  constexpr Named_function_parameters(const T& v) : base(v) {}
+  constexpr Named_function_parameters(const T& v, const Base& b) : base(v, b) {}
 
 // create the functions for new named parameters and the one imported boost
 // used to concatenate several parameters
 #define CGAL_add_named_parameter(X, Y, Z)                             \
   template<typename K>                                                \
+  constexpr                                                           \
   Named_function_parameters<K, internal_np::X, self>                  \
   Z(const K& k) const                                                 \
   {                                                                   \
@@ -355,14 +356,15 @@ struct Named_function_parameters
   }
 #define CGAL_add_named_parameter_with_compatibility(X, Y, Z)          \
   template<typename K>                                                \
-  Named_function_parameters<K, internal_np::X, self>                  \
+  constexpr Named_function_parameters<K, internal_np::X, self>                  \
   Z(const K& k) const                                                 \
   {                                                                   \
     typedef Named_function_parameters<K, internal_np::X, self> Params;\
     return Params(k, *this);                                          \
   }
 #define CGAL_add_named_parameter_with_compatibility_cref_only(X, Y, Z) \
   template<typename K>                                                \
+  constexpr                                                           \
   Named_function_parameters<std::reference_wrapper<const K>,          \
                             internal_np::X, self>                     \
   Z(const K& k) const                                                 \
@@ -373,6 +375,7 @@ struct Named_function_parameters
   }
 #define CGAL_add_named_parameter_with_compatibility_ref_only(X, Y, Z) \
   template<typename K>                                                \
+  constexpr                                                           \
   Named_function_parameters<std::reference_wrapper<K>,                \
                             internal_np::X, self>                     \
   Z(K& k) const                                                       \
@@ -383,6 +386,7 @@ struct Named_function_parameters
   }
 #define CGAL_add_extra_named_parameter_with_compatibility(X, Y, Z)    \
   template<typename K>                                                \
+  constexpr                                                           \
   Named_function_parameters<K, internal_np::X, self>                  \
   Z(const K& k) const                                                 \
   {                                                                   \
@@ -406,13 +410,15 @@ struct Named_function_parameters
 #undef CGAL_NP_BUILD
 
   template <typename OT, typename OTag>
+  constexpr
   Named_function_parameters<OT, OTag, self>
   combine(const Named_function_parameters<OT,OTag>& np) const
   {
     return Named_function_parameters<OT, OTag, self>(np.v,*this);
   }
 
   template <typename OT, typename OTag, typename ... NPS>
+  constexpr
   auto
   combine(const Named_function_parameters<OT,OTag>& np, const NPS& ... nps) const
   {
@@ -426,14 +432,14 @@ struct Named_function_parameters
 namespace parameters {
 
 Default_named_parameters
-inline default_values()
+inline constexpr default_values()
 {
   return Default_named_parameters();
 }
 
 #ifndef CGAL_NO_DEPRECATED_CODE
 Default_named_parameters
-inline all_default()
+inline constexpr all_default()
 {
   return Default_named_parameters();
 }
@@ -443,6 +449,7 @@ template <class Tag, bool ref_only = false, bool ref_is_const = false>
 struct Boost_parameter_compatibility_wrapper
 {
   template <typename K>
+  constexpr
   Named_function_parameters<K, Tag>
   operator()(const K& p) const
   {
@@ -452,6 +459,7 @@ struct Boost_parameter_compatibility_wrapper
 
   template <typename K>
   Named_function_parameters<K, Tag>
+  constexpr
   operator=(const K& p) const
   {
     typedef Named_function_parameters<K, Tag> Params;
@@ -502,7 +510,7 @@ struct Boost_parameter_compatibility_wrapper<Tag, true, false>
 // define free functions and Boost_parameter_compatibility_wrapper for named parameters
 #define CGAL_add_named_parameter(X, Y, Z)        \
   template <typename K>                        \
-  Named_function_parameters<K, internal_np::X>                  \
+  constexpr Named_function_parameters<K, internal_np::X>                  \
   Z(const K& p)                                \
   {                                            \
     typedef Named_function_parameters<K, internal_np::X> Params;\
@@ -549,8 +557,84 @@ struct is_default_parameter
   typedef CGAL::Boolean_tag<value> type;
 };
 
+
+// code used to make sure all options passed are used by a function
+namespace authorized_parameters_impl
+{
+
+template <class ... Tag>
+struct Tag_wrapper{};
+
+template <class Tag>
+constexpr
+bool is_tag_present(Tag_wrapper<Tag>, Tag)
+{
+  return true;
+}
+
+template <class TagAllowed, class Tag>
+constexpr
+bool is_tag_present(Tag_wrapper<TagAllowed>, Tag)
+{
+  return false;
+}
+
+template <class TagAllowed, class ... TagsAllowed, class Tag, class = std::enable_if_t<sizeof...(TagsAllowed) >= 1>>
+constexpr
+bool is_tag_present(Tag_wrapper<TagAllowed, TagsAllowed...>, Tag)
+{
+  if (std::is_same_v<TagAllowed, Tag>)
+    return true;
+  else
+    return is_tag_present(Tag_wrapper<TagsAllowed...>(), Tag());
+}
+
+template <class ... TagsAllowed, class T, class Tag>
+constexpr
+bool authorized_options_rec(const Named_function_parameters<T, Tag>&)
+{
+  if constexpr (std::is_same_v<Tag, internal_np::do_not_check_allowed_np_t>)
+    return true;
+  return is_tag_present(Tag_wrapper<TagsAllowed...>(), Tag());
+}
+
+template <class ... TagsAllowed, class T, class Tag, class Base>
+constexpr
+bool authorized_options_rec(const Named_function_parameters<T, Tag, Base>& np)
+{
+  if constexpr (std::is_same_v<Tag, internal_np::do_not_check_allowed_np_t>)
+    return true;
+  if (is_tag_present(Tag_wrapper<TagsAllowed...>(), Tag()))
+    return authorized_options_rec<TagsAllowed...>(static_cast<const Base&>(np));
+  return false;
+}
+
+}// impl namespace
+
+template <class ... TagsAllowed, class Named_function_parameters>
+constexpr
+bool authorized_options(const Named_function_parameters& np)
+{
+#ifndef CGAL_DISABLE_NAMED_FUNCTION_PARAMETERS_CHECKS
+  return authorized_parameters_impl::authorized_options_rec
+    <internal_np::all_default_t, TagsAllowed...>(np);
+#else
+  return true;
+#endif
+}
+
 } // end of parameters namespace
 
+#ifdef CGAL_NDEBUG
+#define CGAL_CHECK_AUTHORIZED_NAMED_PARAMETERS(np, ...)
+#else
+#define CGAL_CHECK_AUTHORIZED_NAMED_PARAMETERS(np, ...) \
+{ \
+using namespace ::CGAL::internal_np; \
+static_assert(::CGAL::parameters::authorized_options<__VA_ARGS__>(np)); \
+}
+#endif
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 namespace Polygon_mesh_processing {
 

STL_Extension/include/CGAL/STL_Extension/internal/parameters_interface.h

@@ -182,6 +182,7 @@ CGAL_add_named_parameter(use_smoothing_t, use_smoothing, use_smoothing)
 //internal
 CGAL_add_named_parameter(weight_calculator_t, weight_calculator, weight_calculator)
 CGAL_add_named_parameter(use_bool_op_to_clip_surface_t, use_bool_op_to_clip_surface, use_bool_op_to_clip_surface)
+CGAL_add_named_parameter(do_not_check_allowed_np_t, do_not_check_allowed_np, do_not_check_allowed_np)
 
 // List of named parameters used in the Point Set Processing package
 CGAL_add_named_parameter(query_point_t, query_point_map, query_point_map)

STL_Extension/test/STL_Extension/test_cgal_named_params.cpp

@@ -89,6 +89,38 @@ void test_references(const NamedParameters& np)
   assert(&eim_ref==&default_value);
 }
 
+void test_authorized_options()
+{
+  auto np_ok1 = CGAL::parameters::vertex_point_map(0).edge_index_map(2).face_index_map(3);
+  auto np_ok2 = CGAL::parameters::face_index_map(3).vertex_point_map(0).edge_index_map(4);
+  constexpr auto np_ko = CGAL::parameters::face_index_map(3).vertex_point_map(0).edge_index_map(4).halfedge_index_map(4);
+  auto np_permissive = np_ko.do_not_check_allowed_np(true);
+  auto np_default = CGAL::parameters::default_values();
+
+
+  static_assert(CGAL::parameters::authorized_options<CGAL::internal_np::vertex_point_t,
+                                                     CGAL::internal_np::edge_index_t,
+                                                     CGAL::internal_np::face_index_t>(np_default));
+  static_assert(CGAL::parameters::authorized_options<CGAL::internal_np::vertex_point_t,
+                                                     CGAL::internal_np::edge_index_t,
+                                                     CGAL::internal_np::face_index_t>(np_ok1));
+  static_assert(CGAL::parameters::authorized_options<CGAL::internal_np::vertex_point_t,
+                                                     CGAL::internal_np::edge_index_t,
+                                                     CGAL::internal_np::face_index_t>(np_ok2));
+  static_assert(!CGAL::parameters::authorized_options<CGAL::internal_np::vertex_point_t,
+                                                      CGAL::internal_np::edge_index_t,
+                                                      CGAL::internal_np::face_index_t>(np_ko));
+  static_assert(CGAL::parameters::authorized_options<CGAL::internal_np::vertex_point_t,
+                                                     CGAL::internal_np::edge_index_t,
+                                                     CGAL::internal_np::face_index_t>(np_permissive));
+  static_assert(CGAL::parameters::authorized_options<CGAL::internal_np::vertex_point_t,
+                                                     CGAL::internal_np::edge_index_t,
+                                                     CGAL::internal_np::face_index_t>(np_ko.do_not_check_allowed_np(true)));
+
+  CGAL_CHECK_AUTHORIZED_NAMED_PARAMETERS(np_ok1, vertex_point_t, edge_index_t, face_index_t);
+  CGAL_CHECK_AUTHORIZED_NAMED_PARAMETERS(np_ok2, vertex_point_t, edge_index_t, face_index_t);
+}
+
 int main()
 {
   test_values_and_types(params::vertex_index_map(A<0>(0)).visitor(A<1>(1)));
@@ -111,5 +143,7 @@ int main()
   static_assert(std::is_same<decltype(d2),CGAL::parameters::Default_named_parameters>::value);
 #endif
 
+  test_authorized_options();
+
   return EXIT_SUCCESS;
 }