From 3c257dd01cc1a47825d4a94852e0ccd8b91fbe2a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Wed, 21 Apr 2021 14:14:34 +0200 Subject: [PATCH 01/12] allow non-copyable object for named parameters --- .../boost/graph/Named_function_parameters.h | 32 ++++++++++++------- 1 file changed, 21 insertions(+), 11 deletions(-) diff --git a/BGL/include/CGAL/boost/graph/Named_function_parameters.h b/BGL/include/CGAL/boost/graph/Named_function_parameters.h index c1858ac0198..c007da67960 100644 --- a/BGL/include/CGAL/boost/graph/Named_function_parameters.h +++ b/BGL/include/CGAL/boost/graph/Named_function_parameters.h @@ -16,6 +16,7 @@ #include #include +#include #define CGAL_BGL_NP_TEMPLATE_PARAMETERS T, typename Tag, typename Base #define CGAL_BGL_NP_CLASS CGAL::Named_function_parameters @@ -38,8 +39,9 @@ enum all_default_t { all_default }; template struct Named_params_impl : Base { - T v; // copy of the parameter - Named_params_impl(T v, const Base& b) + typename std::conditional::value, + T, std::reference_wrapper >::type v; // copy of the parameter if copyable + Named_params_impl(const T& v, const Base& b) : Base(b) , v(v) {} @@ -49,8 +51,9 @@ struct Named_params_impl : Base template struct Named_params_impl { - T v; // copy of the parameter - Named_params_impl(T v) + typename std::conditional::value, + T, std::reference_wrapper >::type v; // copy of the parameter if copyable + Named_params_impl(const T& v) : v(v) {} }; @@ -68,13 +71,15 @@ struct Get_param< Named_params_impl, Query_tag > template< typename T, typename Tag, typename Base> struct Get_param< Named_params_impl, Tag > { - typedef T type; + typedef typename std::conditional::value, + T, std::reference_wrapper >::type type; }; template< typename T, typename Tag> struct Get_param< Named_params_impl, Tag > { - typedef T type; + typedef typename std::conditional::value, + T, std::reference_wrapper >::type type; }; @@ -98,7 +103,9 @@ struct Lookup_named_param_def // helper function to extract the value from a named parameter pack given a query tag template -T get_parameter_impl(const Named_params_impl& np, Tag) +typename std::conditional::value, + T, std::reference_wrapper >::type +get_parameter_impl(const Named_params_impl& np, Tag) { return np.v; } @@ -110,7 +117,9 @@ Param_not_found get_parameter_impl(const Named_params_impl& } template< typename T, typename Tag> -T get_parameter_impl(const Named_params_impl& np, Tag) +typename std::conditional::value, + T, std::reference_wrapper >::type +get_parameter_impl(const Named_params_impl& np, Tag) { return np.v; }; @@ -133,8 +142,9 @@ struct Named_function_parameters typedef internal_np::Named_params_impl base; typedef Named_function_parameters self; - Named_function_parameters(T v = T()) : base(v) {} - Named_function_parameters(T v, const Base& b) : base(v, b) {} + 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) {} Named_function_parameters all_default() const @@ -178,7 +188,7 @@ inline no_parameters(Named_function_parameters) #define CGAL_add_named_parameter(X, Y, Z) \ template \ Named_function_parameters \ - Z(K const& p) \ + Z(const K& p) \ { \ typedef Named_function_parameters Params;\ return Params(p); \ From e38ab3b19ac4059f3dcb5c79d15194761cd6123e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Tue, 31 Aug 2021 16:43:57 +0200 Subject: [PATCH 02/12] remove useless test and add one about non-copyable --- BGL/test/BGL/test_cgal_bgl_named_params.cpp | 417 +------------------- 1 file changed, 19 insertions(+), 398 deletions(-) diff --git a/BGL/test/BGL/test_cgal_bgl_named_params.cpp b/BGL/test/BGL/test_cgal_bgl_named_params.cpp index 18cb646ff35..349f7b02302 100644 --- a/BGL/test/BGL/test_cgal_bgl_named_params.cpp +++ b/BGL/test/BGL/test_cgal_bgl_named_params.cpp @@ -11,6 +11,12 @@ struct A int v; }; +struct B +{ + B(){} + B(const B&) = delete; +}; + template void check_same_type(T) { @@ -20,416 +26,31 @@ void check_same_type(T) } template -void test(const NamedParameters& np) +void test_values_and_types(const NamedParameters& np) { using CGAL::parameters::get_parameter; - // Test values - - // Named parameters that we use in CGAL + // test values assert(get_parameter(np, CGAL::internal_np::vertex_index).v == 0); assert(get_parameter(np, CGAL::internal_np::visitor).v == 1); - assert(get_parameter(np, CGAL::internal_np::vertex_point).v == 2); - assert(get_parameter(np, CGAL::internal_np::halfedge_index).v == 3); - assert(get_parameter(np, CGAL::internal_np::edge_index).v == 4); - assert(get_parameter(np, CGAL::internal_np::face_index).v == 5); - assert(get_parameter(np, CGAL::internal_np::edge_is_constrained).v == 6); - assert(get_parameter(np, CGAL::internal_np::first_index).v == 7); - assert(get_parameter(np, CGAL::internal_np::number_of_iterations).v == 8); - - assert(get_parameter(np, CGAL::internal_np::METIS_options).v == 800000001); - assert(get_parameter(np, CGAL::internal_np::vertex_partition_id).v == 800000002); - assert(get_parameter(np, CGAL::internal_np::face_partition_id).v == 800000003); - - assert(get_parameter(np, CGAL::internal_np::vertex_to_vertex_output_iterator).v == 800000004); - assert(get_parameter(np, CGAL::internal_np::halfedge_to_halfedge_output_iterator).v == 800000005); - assert(get_parameter(np, CGAL::internal_np::face_to_face_output_iterator).v == 800000006); - - assert(get_parameter(np, CGAL::internal_np::vertex_to_vertex_map).v == 800000007); - assert(get_parameter(np, CGAL::internal_np::halfedge_to_halfedge_map).v == 800000008); - assert(get_parameter(np, CGAL::internal_np::face_to_face_map).v == 800000009); - - assert(get_parameter(np, CGAL::internal_np::implementation_tag).v == 800000010); - assert(get_parameter(np, CGAL::internal_np::prevent_unselection).v == 800000011); - - assert(get_parameter(np, CGAL::internal_np::stream_precision).v == 800000012); - - // Named parameters that we use in the package 'Mesh_3' - assert(get_parameter(np, CGAL::internal_np::vertex_feature_degree).v == 9); - - // Named parameters used in the package 'Polygon Mesh Processing' - assert(get_parameter(np, CGAL::internal_np::geom_traits).v == 10); - assert(get_parameter(np, CGAL::internal_np::vertex_incident_patches).v == 11); - assert(get_parameter(np, CGAL::internal_np::density_control_factor).v == 12); - assert(get_parameter(np, CGAL::internal_np::use_delaunay_triangulation).v == 13); - assert(get_parameter(np, CGAL::internal_np::use_2d_constrained_delaunay_triangulation).v == 4573); - assert(get_parameter(np, CGAL::internal_np::fairing_continuity).v == 14); - assert(get_parameter(np, CGAL::internal_np::sparse_linear_solver).v == 15); - assert(get_parameter(np, CGAL::internal_np::number_of_relaxation_steps).v == 16); - assert(get_parameter(np, CGAL::internal_np::protect_constraints).v == 17); - assert(get_parameter(np, CGAL::internal_np::relax_constraints).v == 18); - assert(get_parameter(np, CGAL::internal_np::collapse_constraints).v == 43); - assert(get_parameter(np, CGAL::internal_np::vertex_is_constrained).v == 19); - assert(get_parameter(np, CGAL::internal_np::face_patch).v == 20); - assert(get_parameter(np, CGAL::internal_np::random_uniform_sampling).v == 21); - assert(get_parameter(np, CGAL::internal_np::grid_sampling).v == 22); - assert(get_parameter(np, CGAL::internal_np::monte_carlo_sampling).v == 23); - assert(get_parameter(np, CGAL::internal_np::do_sample_edges).v == 24); - assert(get_parameter(np, CGAL::internal_np::do_sample_vertices).v == 25); - assert(get_parameter(np, CGAL::internal_np::do_sample_faces).v == 26); - assert(get_parameter(np, CGAL::internal_np::number_of_points_on_faces).v == 27); - assert(get_parameter(np, CGAL::internal_np::number_of_points_per_face).v == 28); - assert(get_parameter(np, CGAL::internal_np::grid_spacing).v == 29); - assert(get_parameter(np, CGAL::internal_np::number_of_points_per_edge).v == 30); - assert(get_parameter(np, CGAL::internal_np::number_of_points_on_edges).v == 31); - assert(get_parameter(np, CGAL::internal_np::nb_points_per_area_unit).v == 32); - assert(get_parameter(np, CGAL::internal_np::nb_points_per_distance_unit).v == 33); - assert(get_parameter(np, CGAL::internal_np::throw_on_self_intersection).v == 43); - assert(get_parameter(np, CGAL::internal_np::clip_volume).v == 44); - assert(get_parameter(np, CGAL::internal_np::use_compact_clipper).v == 45); - assert(get_parameter(np, CGAL::internal_np::erase_all_duplicates).v == 48); - assert(get_parameter(np, CGAL::internal_np::require_same_orientation).v == 49); - assert(get_parameter(np, CGAL::internal_np::use_bool_op_to_clip_surface).v == 50); - assert(get_parameter(np, CGAL::internal_np::face_size_map).v == 52); - assert(get_parameter(np, CGAL::internal_np::use_angle_smoothing).v == 53); - assert(get_parameter(np, CGAL::internal_np::use_area_smoothing).v == 54); - assert(get_parameter(np, CGAL::internal_np::use_Delaunay_flips).v == 55); - assert(get_parameter(np, CGAL::internal_np::use_safety_constraints).v == 56); - assert(get_parameter(np, CGAL::internal_np::area_threshold).v == 57); - assert(get_parameter(np, CGAL::internal_np::volume_threshold).v == 58); - assert(get_parameter(np, CGAL::internal_np::snapping_tolerance).v == 59); - assert(get_parameter(np, CGAL::internal_np::dry_run).v == 60); - assert(get_parameter(np, CGAL::internal_np::do_lock_mesh).v == 61); - assert(get_parameter(np, CGAL::internal_np::halfedges_keeper).v == 62); - assert(get_parameter(np, CGAL::internal_np::do_simplify_border).v == 64); - assert(get_parameter(np, CGAL::internal_np::do_not_modify).v == 65); - assert(get_parameter(np, CGAL::internal_np::allow_self_intersections).v == 66); - assert(get_parameter(np, CGAL::internal_np::polyhedral_envelope_epsilon).v == 67); - assert(get_parameter(np, CGAL::internal_np::maximum_number_of_faces).v == 78910); - assert(get_parameter(np, CGAL::internal_np::non_manifold_feature_map).v == 60); - assert(get_parameter(np, CGAL::internal_np::filter).v == 61); - assert(get_parameter(np, CGAL::internal_np::face_epsilon_map).v == 62); - assert(get_parameter(np, CGAL::internal_np::maximum_number).v == 68); - - // Named parameters that we use in the package 'Surface Mesh Simplification' - assert(get_parameter(np, CGAL::internal_np::get_cost_policy).v == 34); - assert(get_parameter(np, CGAL::internal_np::get_placement_policy).v == 35); - - // Named parameters that we use in the package 'Optimal_bounding_box' - assert(get_parameter(np, CGAL::internal_np::use_convex_hull).v == 63); - - // To-be-documented named parameters - assert(get_parameter(np, CGAL::internal_np::face_normal).v == 36); - assert(get_parameter(np, CGAL::internal_np::random_seed).v == 37); - assert(get_parameter(np, CGAL::internal_np::do_project).v == 38); - - // Internal named parameters - assert(get_parameter(np, CGAL::internal_np::weight_calculator).v == 39); - assert(get_parameter(np, CGAL::internal_np::preserve_genus).v == 40); - assert(get_parameter(np, CGAL::internal_np::verbosity_level).v == 41); - assert(get_parameter(np, CGAL::internal_np::use_binary_mode).v == 51); - assert(get_parameter(np, CGAL::internal_np::projection_functor).v == 42); - assert(get_parameter(np, CGAL::internal_np::apply_per_connected_component).v == 46); - assert(get_parameter(np, CGAL::internal_np::output_iterator).v == 47); - - // Test types - - // Named parameters that we use in CGAL + // test types check_same_type<0>(get_parameter(np, CGAL::internal_np::vertex_index)); check_same_type<1>(get_parameter(np, CGAL::internal_np::visitor)); - check_same_type<2>(get_parameter(np, CGAL::internal_np::vertex_point)); - check_same_type<3>(get_parameter(np, CGAL::internal_np::halfedge_index)); - check_same_type<4>(get_parameter(np, CGAL::internal_np::edge_index)); - check_same_type<5>(get_parameter(np, CGAL::internal_np::face_index)); +} - check_same_type<6>(get_parameter(np, CGAL::internal_np::edge_is_constrained)); - check_same_type<7>(get_parameter(np, CGAL::internal_np::first_index)); - check_same_type<8>(get_parameter(np, CGAL::internal_np::number_of_iterations)); - - check_same_type<800000001>(get_parameter(np, CGAL::internal_np::METIS_options)); - check_same_type<800000002>(get_parameter(np, CGAL::internal_np::vertex_partition_id)); - check_same_type<800000003>(get_parameter(np, CGAL::internal_np::face_partition_id)); - check_same_type<800000004>(get_parameter(np, CGAL::internal_np::vertex_to_vertex_output_iterator)); - check_same_type<800000005>(get_parameter(np, CGAL::internal_np::halfedge_to_halfedge_output_iterator)); - check_same_type<800000006>(get_parameter(np, CGAL::internal_np::face_to_face_output_iterator)); - check_same_type<800000007>(get_parameter(np, CGAL::internal_np::vertex_to_vertex_map)); - check_same_type<800000008>(get_parameter(np, CGAL::internal_np::halfedge_to_halfedge_map)); - check_same_type<800000009>(get_parameter(np, CGAL::internal_np::face_to_face_map)); - check_same_type<800000010>(get_parameter(np, CGAL::internal_np::implementation_tag)); - check_same_type<800000011>(get_parameter(np, CGAL::internal_np::prevent_unselection)); - check_same_type<800000012>(get_parameter(np, CGAL::internal_np::stream_precision)); - - // Named parameters that we use in the package 'Mesh_3' - check_same_type<9>(get_parameter(np, CGAL::internal_np::vertex_feature_degree)); - - // Named parameters used in the package 'Polygon Mesh Processing' - check_same_type<10>(get_parameter(np, CGAL::internal_np::geom_traits)); - check_same_type<11>(get_parameter(np, CGAL::internal_np::vertex_incident_patches)); - check_same_type<12>(get_parameter(np, CGAL::internal_np::density_control_factor)); - check_same_type<13>(get_parameter(np, CGAL::internal_np::use_delaunay_triangulation)); - check_same_type<4573>(get_parameter(np, CGAL::internal_np::use_2d_constrained_delaunay_triangulation)); - check_same_type<14>(get_parameter(np, CGAL::internal_np::fairing_continuity)); - check_same_type<15>(get_parameter(np, CGAL::internal_np::sparse_linear_solver)); - check_same_type<16>(get_parameter(np, CGAL::internal_np::number_of_relaxation_steps)); - check_same_type<17>(get_parameter(np, CGAL::internal_np::protect_constraints)); - check_same_type<18>(get_parameter(np, CGAL::internal_np::relax_constraints)); - check_same_type<43>(get_parameter(np, CGAL::internal_np::collapse_constraints)); - check_same_type<19>(get_parameter(np, CGAL::internal_np::vertex_is_constrained)); - check_same_type<20>(get_parameter(np, CGAL::internal_np::face_patch)); - check_same_type<21>(get_parameter(np, CGAL::internal_np::random_uniform_sampling)); - check_same_type<22>(get_parameter(np, CGAL::internal_np::grid_sampling)); - check_same_type<23>(get_parameter(np, CGAL::internal_np::monte_carlo_sampling)); - check_same_type<24>(get_parameter(np, CGAL::internal_np::do_sample_edges)); - check_same_type<25>(get_parameter(np, CGAL::internal_np::do_sample_vertices)); - check_same_type<26>(get_parameter(np, CGAL::internal_np::do_sample_faces)); - check_same_type<27>(get_parameter(np, CGAL::internal_np::number_of_points_on_faces)); - check_same_type<28>(get_parameter(np, CGAL::internal_np::number_of_points_per_face)); - check_same_type<29>(get_parameter(np, CGAL::internal_np::grid_spacing)); - check_same_type<30>(get_parameter(np, CGAL::internal_np::number_of_points_per_edge)); - check_same_type<31>(get_parameter(np, CGAL::internal_np::number_of_points_on_edges)); - check_same_type<32>(get_parameter(np, CGAL::internal_np::nb_points_per_area_unit)); - check_same_type<33>(get_parameter(np, CGAL::internal_np::nb_points_per_distance_unit)); - check_same_type<43>(get_parameter(np, CGAL::internal_np::throw_on_self_intersection)); - check_same_type<44>(get_parameter(np, CGAL::internal_np::clip_volume)); - check_same_type<45>(get_parameter(np, CGAL::internal_np::use_compact_clipper)); - check_same_type<48>(get_parameter(np, CGAL::internal_np::erase_all_duplicates)); - check_same_type<49>(get_parameter(np, CGAL::internal_np::require_same_orientation)); - check_same_type<50>(get_parameter(np, CGAL::internal_np::use_bool_op_to_clip_surface)); - check_same_type<52>(get_parameter(np, CGAL::internal_np::face_size_map)); - check_same_type<53>(get_parameter(np, CGAL::internal_np::use_angle_smoothing)); - check_same_type<54>(get_parameter(np, CGAL::internal_np::use_area_smoothing)); - check_same_type<55>(get_parameter(np, CGAL::internal_np::use_Delaunay_flips)); - check_same_type<56>(get_parameter(np, CGAL::internal_np::use_safety_constraints)); - check_same_type<65>(get_parameter(np, CGAL::internal_np::do_not_modify)); - check_same_type<66>(get_parameter(np, CGAL::internal_np::allow_self_intersections)); - check_same_type<67>(get_parameter(np, CGAL::internal_np::polyhedral_envelope_epsilon)); - - check_same_type<12340>(get_parameter(np, CGAL::internal_np::do_self_intersection_tests)); - check_same_type<12341>(get_parameter(np, CGAL::internal_np::do_orientation_tests)); - check_same_type<12342>(get_parameter(np, CGAL::internal_np::error_codes)); - check_same_type<12343>(get_parameter(np, CGAL::internal_np::volume_inclusions)); - check_same_type<12344>(get_parameter(np, CGAL::internal_np::face_connected_component_map)); - check_same_type<12345>(get_parameter(np, CGAL::internal_np::connected_component_id_to_volume_id)); - check_same_type<12346>(get_parameter(np, CGAL::internal_np::is_cc_outward_oriented)); - check_same_type<12347>(get_parameter(np, CGAL::internal_np::intersecting_volume_pairs_output_iterator)); - check_same_type<12348>(get_parameter(np, CGAL::internal_np::i_used_as_a_predicate)); - check_same_type<12349>(get_parameter(np, CGAL::internal_np::nesting_levels)); - check_same_type<12350>(get_parameter(np, CGAL::internal_np::i_used_for_volume_orientation)); - - check_same_type<57>(get_parameter(np, CGAL::internal_np::area_threshold)); - check_same_type<58>(get_parameter(np, CGAL::internal_np::volume_threshold)); - check_same_type<59>(get_parameter(np, CGAL::internal_np::snapping_tolerance)); - check_same_type<60>(get_parameter(np, CGAL::internal_np::dry_run)); - check_same_type<61>(get_parameter(np, CGAL::internal_np::do_lock_mesh)); - check_same_type<62>(get_parameter(np, CGAL::internal_np::halfedges_keeper)); - check_same_type<64>(get_parameter(np, CGAL::internal_np::do_simplify_border)); - check_same_type<78910>(get_parameter(np, CGAL::internal_np::maximum_number_of_faces)); - check_same_type<60>(get_parameter(np, CGAL::internal_np::non_manifold_feature_map)); - check_same_type<61>(get_parameter(np, CGAL::internal_np::filter)); - check_same_type<62>(get_parameter(np, CGAL::internal_np::face_epsilon_map)); - check_same_type<68>(get_parameter(np, CGAL::internal_np::maximum_number)); - - // Named parameters that we use in the package 'Surface Mesh Simplification' - check_same_type<34>(get_parameter(np, CGAL::internal_np::get_cost_policy)); - check_same_type<35>(get_parameter(np, CGAL::internal_np::get_placement_policy)); - - // Named parameters that we use in the package 'Optimal_bounding_box' - check_same_type<63>(get_parameter(np, CGAL::internal_np::use_convex_hull)); - - // To-be-documented named parameters - check_same_type<36>(get_parameter(np, CGAL::internal_np::face_normal)); - check_same_type<37>(get_parameter(np, CGAL::internal_np::random_seed)); - check_same_type<38>(get_parameter(np, CGAL::internal_np::do_project)); - check_same_type<456>(get_parameter(np, CGAL::internal_np::algorithm)); - - // Internal named parameters - check_same_type<39>(get_parameter(np, CGAL::internal_np::weight_calculator)); - check_same_type<40>(get_parameter(np, CGAL::internal_np::preserve_genus)); - check_same_type<41>(get_parameter(np, CGAL::internal_np::verbosity_level)); - check_same_type<51>(get_parameter(np, CGAL::internal_np::use_binary_mode)); - check_same_type<42>(get_parameter(np, CGAL::internal_np::projection_functor)); - check_same_type<46>(get_parameter(np, CGAL::internal_np::apply_per_connected_component)); - check_same_type<47>(get_parameter(np, CGAL::internal_np::output_iterator)); - - // Named parameters used in the package 'Point Set Processing' - check_same_type<9000>(get_parameter(np, CGAL::internal_np::point_map)); - check_same_type<9001>(get_parameter(np, CGAL::internal_np::query_point_map)); - check_same_type<9002>(get_parameter(np, CGAL::internal_np::normal_map)); - check_same_type<9003>(get_parameter(np, CGAL::internal_np::diagonalize_traits)); - check_same_type<9004>(get_parameter(np, CGAL::internal_np::svd_traits)); - check_same_type<9005>(get_parameter(np, CGAL::internal_np::callback)); - check_same_type<9006>(get_parameter(np, CGAL::internal_np::sharpness_angle)); - check_same_type<9007>(get_parameter(np, CGAL::internal_np::edge_sensitivity)); - check_same_type<9008>(get_parameter(np, CGAL::internal_np::neighbor_radius)); - check_same_type<9009>(get_parameter(np, CGAL::internal_np::number_of_output_points)); - check_same_type<9010>(get_parameter(np, CGAL::internal_np::size)); - check_same_type<9011>(get_parameter(np, CGAL::internal_np::maximum_variation)); - check_same_type<9012>(get_parameter(np, CGAL::internal_np::degree_fitting)); - check_same_type<9013>(get_parameter(np, CGAL::internal_np::degree_monge)); - check_same_type<9014>(get_parameter(np, CGAL::internal_np::threshold_percent)); - check_same_type<9015>(get_parameter(np, CGAL::internal_np::threshold_distance)); - check_same_type<9016>(get_parameter(np, CGAL::internal_np::attraction_factor)); - check_same_type<9017>(get_parameter(np, CGAL::internal_np::plane_map)); - check_same_type<9018>(get_parameter(np, CGAL::internal_np::plane_index_map)); - check_same_type<9019>(get_parameter(np, CGAL::internal_np::select_percentage)); - check_same_type<9020>(get_parameter(np, CGAL::internal_np::require_uniform_sampling)); - check_same_type<9021>(get_parameter(np, CGAL::internal_np::point_is_constrained)); - check_same_type<9022>(get_parameter(np, CGAL::internal_np::number_of_samples)); - check_same_type<9023>(get_parameter(np, CGAL::internal_np::accuracy)); - check_same_type<9024>(get_parameter(np, CGAL::internal_np::maximum_running_time)); - check_same_type<9025>(get_parameter(np, CGAL::internal_np::overlap)); - check_same_type<9026>(get_parameter(np, CGAL::internal_np::transformation)); - check_same_type<9027>(get_parameter(np, CGAL::internal_np::point_set_filters)); - check_same_type<9028>(get_parameter(np, CGAL::internal_np::matcher)); - check_same_type<9029>(get_parameter(np, CGAL::internal_np::outlier_filters)); - check_same_type<9030>(get_parameter(np, CGAL::internal_np::error_minimizer)); - check_same_type<9031>(get_parameter(np, CGAL::internal_np::transformation_checkers)); - check_same_type<9032>(get_parameter(np, CGAL::internal_np::inspector)); - check_same_type<9033>(get_parameter(np, CGAL::internal_np::logger)); - check_same_type<9034>(get_parameter(np, CGAL::internal_np::maximum_normal_deviation)); - check_same_type<9035>(get_parameter(np, CGAL::internal_np::scan_angle_map)); - check_same_type<9036>(get_parameter(np, CGAL::internal_np::scanline_id_map)); +template +void test_no_copyable(const NamedParameters&) +{ + typedef typename CGAL::internal_np::Get_param::type NP_type; + static_assert( boost::is_same > ::value ); } int main() { - test(CGAL::parameters::vertex_index_map(A<0>(0)) - .visitor(A<1>(1)) - .vertex_point_map(A<2>(2)) - .halfedge_index_map(A<3>(3)) - .edge_index_map(A<4>(4)) - .face_index_map(A<5>(5)) - .edge_is_constrained_map(A<6>(6)) - .first_index(A<7>(7)) - .number_of_iterations(A<8>(8)) - .METIS_options(A<800000001>(800000001)) - .vertex_partition_id_map(A<800000002>(800000002)) - .face_partition_id_map(A<800000003>(800000003)) - .vertex_to_vertex_output_iterator(A<800000004>(800000004)) - .halfedge_to_halfedge_output_iterator(A<800000005>(800000005)) - .face_to_face_output_iterator(A<800000006>(800000006)) - .vertex_to_vertex_map(A<800000007>(800000007)) - .halfedge_to_halfedge_map(A<800000008>(800000008)) - .face_to_face_map(A<800000009>(800000009)) - .implementation_tag(A<800000010>(800000010)) - .prevent_unselection(A<800000011>(800000011)) - .stream_precision(A<800000012>(800000012)) - .vertex_feature_degree_map(A<9>(9)) - .geom_traits(A<10>(10)) - .vertex_incident_patches_map(A<11>(11)) - .density_control_factor(A<12>(12)) - .use_delaunay_triangulation(A<13>(13)) - .use_2d_constrained_delaunay_triangulation(A<4573>(4573)) - .fairing_continuity(A<14>(14)) - .sparse_linear_solver(A<15>(15)) - .number_of_relaxation_steps(A<16>(16)) - .protect_constraints(A<17>(17)) - .relax_constraints(A<18>(18)) - .collapse_constraints(A<43>(43)) - .vertex_is_constrained_map(A<19>(19)) - .face_patch_map(A<20>(20)) - .use_random_uniform_sampling(A<21>(21)) - .use_grid_sampling(A<22>(22)) - .use_monte_carlo_sampling(A<23>(23)) - .do_sample_edges(A<24>(24)) - .do_sample_vertices(A<25>(25)) - .do_sample_faces(A<26>(26)) - .number_of_points_on_faces(A<27>(27)) - .number_of_points_per_face(A<28>(28)) - .grid_spacing(A<29>(29)) - .number_of_points_per_edge(A<30>(30)) - .number_of_points_on_edges(A<31>(31)) - .number_of_points_per_area_unit(A<32>(32)) - .number_of_points_per_distance_unit(A<33>(33)) - .get_cost(A<34>(34)) - .get_placement(A<35>(35)) - .face_normal_map(A<36>(36)) - .random_seed(A<37>(37)) - .do_project(A<38>(38)) - .algorithm(A<456>(456)) - .weight_calculator(A<39>(39)) - .preserve_genus(A<40>(40)) - .verbosity_level(A<41>(41)) - .projection_functor(A<42>(42)) - .throw_on_self_intersection(A<43>(43)) - .clip_volume(A<44>(44)) - .use_compact_clipper(A<45>(45)) - .non_manifold_feature_map(A<60>(60)) - .filter(A<61>(61)) - .face_epsilon_map(A<62>(62)) - .maximum_number(A<68>(68)) - .apply_per_connected_component(A<46>(46)) - .output_iterator(A<47>(47)) - .erase_all_duplicates(A<48>(48)) - .require_same_orientation(A<49>(49)) - .use_bool_op_to_clip_surface(A<50>(50)) - .use_binary_mode(A<51>(51)) - .face_size_map(A<52>(52)) - .use_angle_smoothing(A<53>(53)) - .use_area_smoothing(A<54>(54)) - .use_Delaunay_flips(A<55>(55)) - .use_safety_constraints(A<56>(56)) - .do_self_intersection_tests(A<12340>(12340)) - .do_orientation_tests(A<12341>(12341)) - .error_codes(A<12342>(12342)) - .volume_inclusions(A<12343>(12343)) - .face_connected_component_map(A<12344>(12344)) - .connected_component_id_to_volume_id(A<12345>(12345)) - .is_cc_outward_oriented(A<12346>(12346)) - .intersecting_volume_pairs_output_iterator(A<12347>(12347)) - .i_used_as_a_predicate(A<12348>(12348)) - .nesting_levels(A<12349>(12349)) - .i_used_for_volume_orientation(A<12350>(12350)) - .area_threshold(A<57>(57)) - .volume_threshold(A<58>(58)) - .snapping_tolerance(A<59>(59)) - .dry_run(A<60>(60)) - .do_lock_mesh(A<61>(61)) - .halfedges_keeper(A<62>(62)) - .use_convex_hull(A<63>(63)) - .do_simplify_border(A<64>(64)) - .do_not_modify(A<65>(65)) - .allow_self_intersections(A<66>(66)) - .polyhedral_envelope_epsilon(A<67>(67)) - .point_map(A<9000>(9000)) - .query_point_map(A<9001>(9001)) - .normal_map(A<9002>(9002)) - .diagonalize_traits(A<9003>(9003)) - .svd_traits(A<9004>(9004)) - .callback(A<9005>(9005)) - .sharpness_angle(A<9006>(9006)) - .edge_sensitivity(A<9007>(9007)) - .neighbor_radius(A<9008>(9008)) - .number_of_output_points(A<9009>(9009)) - .size(A<9010>(9010)) - .maximum_variation(A<9011>(9011)) - .degree_fitting(A<9012>(9012)) - .degree_monge(A<9013>(9013)) - .threshold_percent(A<9014>(9014)) - .threshold_distance(A<9015>(9015)) - .attraction_factor(A<9016>(9016)) - .plane_map(A<9017>(9017)) - .plane_index_map(A<9018>(9018)) - .select_percentage(A<9019>(9019)) - .require_uniform_sampling(A<9020>(9020)) - .point_is_constrained_map(A<9021>(9021)) - .number_of_samples(A<9022>(9022)) - .accuracy(A<9023>(9023)) - .maximum_running_time(A<9024>(9024)) - .overlap(A<9025>(9025)) - .transformation(A<9026>(9026)) - .point_set_filters(A<9027>(9027)) - .matcher(A<9028>(9028)) - .outlier_filters(A<9029>(9029)) - .error_minimizer(A<9030>(9030)) - .transformation_checkers(A<9031>(9031)) - .inspector(A<9032>(9032)) - .logger(A<9033>(9033)) - .maximum_normal_deviation(A<9034>(9034)) - .scan_angle_map(A<9035>(9035)) - .scanline_id_map(A<9036>(9036)) - .maximum_number_of_faces(A<78910>(78910)) - ); + test_values_and_types(CGAL::parameters::vertex_index_map(A<0>(0)).visitor(A<1>(1))); + + B b; + test_no_copyable(CGAL::parameters::visitor(b)); return EXIT_SUCCESS; } From aaa3947e4001487e5b2c0c0a14e8459a9c20d7bb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Wed, 1 Sep 2021 10:02:48 +0200 Subject: [PATCH 03/12] add a way to extract references from named parameters --- .../boost/graph/Named_function_parameters.h | 101 +++++++++++++++++- BGL/test/BGL/test_cgal_bgl_named_params.cpp | 48 +++++++-- 2 files changed, 139 insertions(+), 10 deletions(-) diff --git a/BGL/include/CGAL/boost/graph/Named_function_parameters.h b/BGL/include/CGAL/boost/graph/Named_function_parameters.h index c007da67960..b5bee02370d 100644 --- a/BGL/include/CGAL/boost/graph/Named_function_parameters.h +++ b/BGL/include/CGAL/boost/graph/Named_function_parameters.h @@ -66,6 +66,7 @@ template< typename T, typename Tag, typename Query_tag> struct Get_param< Named_params_impl, Query_tag > { typedef Param_not_found type; + typedef Param_not_found reference; }; template< typename T, typename Tag, typename Base> @@ -73,6 +74,8 @@ struct Get_param< Named_params_impl, Tag > { typedef typename std::conditional::value, T, std::reference_wrapper >::type type; + typedef typename std::conditional::value, + T&, const T&>::type reference; }; template< typename T, typename Tag> @@ -80,6 +83,22 @@ struct Get_param< Named_params_impl, Tag > { typedef typename std::conditional::value, T, std::reference_wrapper >::type type; + typedef typename std::conditional::value, + T&, const T&>::type reference; +}; + +template< typename T, typename Tag, typename Base> +struct Get_param< Named_params_impl, Tag, Base>, Tag > +{ + typedef std::reference_wrapper type; + typedef T& reference; +}; + +template< typename T, typename Tag> +struct Get_param< Named_params_impl, Tag, No_property>, Tag > +{ + typedef std::reference_wrapper type; + typedef T& reference; }; @@ -87,6 +106,7 @@ template< typename T, typename Tag, typename Base, typename Query_tag> struct Get_param< Named_params_impl, Query_tag> { typedef typename Get_param::type type; + typedef typename Get_param::reference reference; }; // helper to choose the default @@ -94,11 +114,17 @@ template struct Lookup_named_param_def { typedef typename internal_np::Get_param::type NP_type; + typedef typename internal_np::Get_param::reference NP_reference; typedef typename boost::mpl::if_< boost::is_same, D, NP_type>::type type; + + typedef typename boost::mpl::if_< + boost::is_same, + D&, NP_reference>::type + reference; }; // helper function to extract the value from a named parameter pack given a query tag @@ -132,6 +158,68 @@ get_parameter_impl(const Named_params_impl& np, Query_tag tag) return get_parameter_impl(static_cast(np), tag); } + +// helper for getting references +template +T& get_reference(T& t) +{ + return t; +} + +template +T& get_reference(const std::reference_wrapper& r) +{ + return r.get(); +} + +// helper function to extract the reference from a named parameter pack given a query tag +template +typename std::conditional::value, + T&, const T& >::type +get_parameter_reference_impl(Named_params_impl& np, Tag) +{ + return get_reference(np.v); +} + +template< typename T, typename Tag, typename Query_tag> +Param_not_found +get_parameter_reference_impl(Named_params_impl&, Query_tag) +{ + return Param_not_found(); +} + +template< typename T, typename Tag> +typename std::conditional::value, + T&, const T& >::type +get_parameter_reference_impl(Named_params_impl& np, Tag) +{ + return get_reference(np.v); +}; + +template +T& +get_parameter_reference_impl(Named_params_impl, Tag, Base>& np, Tag) +{ + return np.v.get(); +} + +template< typename T, typename Tag> +T& +get_parameter_reference_impl(Named_params_impl, Tag, No_property>& np, Tag) +{ + return np.v.get(); +}; + + +template +typename Get_param, Query_tag>::type +get_parameter_reference_impl(Named_params_impl& np, Query_tag tag) +{ + CGAL_static_assertion( (!boost::is_same::value) ); + return get_parameter_reference_impl(static_cast(np), tag); +} + + } // end of internal_np namespace @@ -204,15 +292,24 @@ get_parameter(const Named_function_parameters& np, Query_tag tag) return internal_np::get_parameter_impl(static_cast&>(np), tag); } +template +typename internal_np::Get_param, Query_tag>::reference +get_parameter_reference(const Named_function_parameters& np, Query_tag tag) +{ + return internal_np::get_parameter_reference_impl( + static_cast&>(const_cast&>(np)), + tag); +} + // Two parameters, non-trivial default value template -D choose_parameter(const internal_np::Param_not_found&, const D& d) +D& choose_parameter(const internal_np::Param_not_found&, D& d) { return d; } template -const T& choose_parameter(const T& t, const D&) +T& choose_parameter(T& t, D&) { return t; } diff --git a/BGL/test/BGL/test_cgal_bgl_named_params.cpp b/BGL/test/BGL/test_cgal_bgl_named_params.cpp index 349f7b02302..2abe9a28665 100644 --- a/BGL/test/BGL/test_cgal_bgl_named_params.cpp +++ b/BGL/test/BGL/test_cgal_bgl_named_params.cpp @@ -4,6 +4,9 @@ #include +namespace inp = CGAL::internal_np; +namespace params = CGAL::parameters; + template struct A { @@ -28,29 +31,58 @@ void check_same_type(T) template void test_values_and_types(const NamedParameters& np) { - using CGAL::parameters::get_parameter; + using params::get_parameter; // test values - assert(get_parameter(np, CGAL::internal_np::vertex_index).v == 0); - assert(get_parameter(np, CGAL::internal_np::visitor).v == 1); + assert(get_parameter(np, inp::vertex_index).v == 0); + assert(get_parameter(np, inp::visitor).v == 1); // test types - check_same_type<0>(get_parameter(np, CGAL::internal_np::vertex_index)); - check_same_type<1>(get_parameter(np, CGAL::internal_np::visitor)); + check_same_type<0>(get_parameter(np, inp::vertex_index)); + check_same_type<1>(get_parameter(np, inp::visitor)); } template void test_no_copyable(const NamedParameters&) { - typedef typename CGAL::internal_np::Get_param::type NP_type; + typedef typename inp::Get_param::type NP_type; static_assert( boost::is_same > ::value ); } +template +void test_references(const NamedParameters& np) +{ + typedef A<2> Default_type; + Default_type default_value(2); + + // std::reference_wrapper + typedef typename inp::Lookup_named_param_def::reference Visitor_reference_type; + static_assert(std::is_same::value); + Visitor_reference_type vis_ref = params::choose_parameter(params::get_parameter_reference(np, inp::visitor), default_value); + CGAL_USE(vis_ref); + + // non-copyable + typedef typename inp::Lookup_named_param_def::reference VPM_reference_type; + static_assert(std::is_same::value); + VPM_reference_type vpm_ref = params::choose_parameter(params::get_parameter_reference(np, inp::vertex_point), default_value); + CGAL_USE(vpm_ref); + + // passed by copy + typedef typename inp::Lookup_named_param_def::reference VIM_reference_type; + static_assert(std::is_same&, VIM_reference_type>::value); + VIM_reference_type vim_ref = params::choose_parameter(params::get_parameter_reference(np, inp::vertex_index), default_value); + CGAL_USE(vim_ref); +} + int main() { - test_values_and_types(CGAL::parameters::vertex_index_map(A<0>(0)).visitor(A<1>(1))); + test_values_and_types(params::vertex_index_map(A<0>(0)).visitor(A<1>(1))); B b; - test_no_copyable(CGAL::parameters::visitor(b)); + test_no_copyable(params::visitor(b)); + + test_references(params::visitor(std::ref(b)) + .vertex_point_map(b) + .vertex_index_map(A<0>(0))); return EXIT_SUCCESS; } From 0e730466ef27e449ef4c424341084f3e54b36d6f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Wed, 1 Sep 2021 10:13:15 +0200 Subject: [PATCH 04/12] forgot temporary default --- BGL/include/CGAL/boost/graph/Named_function_parameters.h | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/BGL/include/CGAL/boost/graph/Named_function_parameters.h b/BGL/include/CGAL/boost/graph/Named_function_parameters.h index b5bee02370d..f18f42fd94e 100644 --- a/BGL/include/CGAL/boost/graph/Named_function_parameters.h +++ b/BGL/include/CGAL/boost/graph/Named_function_parameters.h @@ -308,6 +308,12 @@ D& choose_parameter(const internal_np::Param_not_found&, D& d) return d; } +template +const D& choose_parameter(const internal_np::Param_not_found&, const D& d) +{ + return d; +} + template T& choose_parameter(T& t, D&) { From b4cbfc7b5c9686fa19d2dca34fa7455d175313cc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Wed, 1 Sep 2021 11:16:40 +0200 Subject: [PATCH 05/12] more tests and a bugfix --- .../boost/graph/Named_function_parameters.h | 3 +-- BGL/test/BGL/test_cgal_bgl_named_params.cpp | 17 ++++++++++++++++- 2 files changed, 17 insertions(+), 3 deletions(-) diff --git a/BGL/include/CGAL/boost/graph/Named_function_parameters.h b/BGL/include/CGAL/boost/graph/Named_function_parameters.h index f18f42fd94e..a9a9bd9b89b 100644 --- a/BGL/include/CGAL/boost/graph/Named_function_parameters.h +++ b/BGL/include/CGAL/boost/graph/Named_function_parameters.h @@ -210,9 +210,8 @@ get_parameter_reference_impl(Named_params_impl, Tag, N return np.v.get(); }; - template -typename Get_param, Query_tag>::type +typename Get_param, Query_tag>::reference get_parameter_reference_impl(Named_params_impl& np, Query_tag tag) { CGAL_static_assertion( (!boost::is_same::value) ); diff --git a/BGL/test/BGL/test_cgal_bgl_named_params.cpp b/BGL/test/BGL/test_cgal_bgl_named_params.cpp index 2abe9a28665..8a73d25df37 100644 --- a/BGL/test/BGL/test_cgal_bgl_named_params.cpp +++ b/BGL/test/BGL/test_cgal_bgl_named_params.cpp @@ -61,6 +61,12 @@ void test_references(const NamedParameters& np) Visitor_reference_type vis_ref = params::choose_parameter(params::get_parameter_reference(np, inp::visitor), default_value); CGAL_USE(vis_ref); + // std::reference_wrapper of const + typedef typename inp::Lookup_named_param_def::reference FIM_reference_type; + static_assert(std::is_same::value); + FIM_reference_type fim_ref = params::choose_parameter(params::get_parameter_reference(np, inp::face_index), default_value); + CGAL_USE(fim_ref); + // non-copyable typedef typename inp::Lookup_named_param_def::reference VPM_reference_type; static_assert(std::is_same::value); @@ -72,6 +78,12 @@ void test_references(const NamedParameters& np) static_assert(std::is_same&, VIM_reference_type>::value); VIM_reference_type vim_ref = params::choose_parameter(params::get_parameter_reference(np, inp::vertex_index), default_value); CGAL_USE(vim_ref); + + // default + typedef typename inp::Lookup_named_param_def::reference EIM_reference_type; + static_assert(std::is_same::value); + EIM_reference_type eim_ref = params::choose_parameter(params::get_parameter_reference(np, inp::edge_index), default_value); + assert(&eim_ref==&default_value); } int main() @@ -83,6 +95,9 @@ int main() test_references(params::visitor(std::ref(b)) .vertex_point_map(b) - .vertex_index_map(A<0>(0))); + .vertex_index_map(A<0>(0)) + .face_index_map(std::reference_wrapper(b)) + ); + return EXIT_SUCCESS; } From 4e7f1ced58b1773437983646d604671684e12d61 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Wed, 1 Sep 2021 11:44:25 +0200 Subject: [PATCH 06/12] readd missing function if D is a temporary --- BGL/include/CGAL/boost/graph/Named_function_parameters.h | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/BGL/include/CGAL/boost/graph/Named_function_parameters.h b/BGL/include/CGAL/boost/graph/Named_function_parameters.h index a9a9bd9b89b..40ab099181e 100644 --- a/BGL/include/CGAL/boost/graph/Named_function_parameters.h +++ b/BGL/include/CGAL/boost/graph/Named_function_parameters.h @@ -319,6 +319,12 @@ T& choose_parameter(T& t, D&) return t; } +template +const T& choose_parameter(const T& t, const D&) +{ + return t; +} + // single parameter so that we can avoid a default construction template D choose_parameter(const internal_np::Param_not_found&) From abddb30bd762a1bf3a7d26f3532908fbf908e6dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Thu, 2 Sep 2021 10:08:46 +0200 Subject: [PATCH 07/12] no ref to internal value of the parameter pack --- .../boost/graph/Named_function_parameters.h | 26 +++++++++---------- BGL/test/BGL/test_cgal_bgl_named_params.cpp | 2 +- 2 files changed, 14 insertions(+), 14 deletions(-) diff --git a/BGL/include/CGAL/boost/graph/Named_function_parameters.h b/BGL/include/CGAL/boost/graph/Named_function_parameters.h index 40ab099181e..acad6c9b93b 100644 --- a/BGL/include/CGAL/boost/graph/Named_function_parameters.h +++ b/BGL/include/CGAL/boost/graph/Named_function_parameters.h @@ -75,7 +75,7 @@ struct Get_param< Named_params_impl, Tag > typedef typename std::conditional::value, T, std::reference_wrapper >::type type; typedef typename std::conditional::value, - T&, const T&>::type reference; + T, const T&>::type reference; }; template< typename T, typename Tag> @@ -84,7 +84,7 @@ struct Get_param< Named_params_impl, Tag > typedef typename std::conditional::value, T, std::reference_wrapper >::type type; typedef typename std::conditional::value, - T&, const T&>::type reference; + T, const T&>::type reference; }; template< typename T, typename Tag, typename Base> @@ -161,7 +161,7 @@ get_parameter_impl(const Named_params_impl& np, Query_tag tag) // helper for getting references template -T& get_reference(T& t) +const T& get_reference(const T& t) { return t; } @@ -175,47 +175,47 @@ T& get_reference(const std::reference_wrapper& r) // helper function to extract the reference from a named parameter pack given a query tag template typename std::conditional::value, - T&, const T& >::type -get_parameter_reference_impl(Named_params_impl& np, Tag) + T, const T& >::type +get_parameter_reference_impl(const Named_params_impl& np, Tag) { return get_reference(np.v); } template< typename T, typename Tag, typename Query_tag> Param_not_found -get_parameter_reference_impl(Named_params_impl&, Query_tag) +get_parameter_reference_impl(const Named_params_impl&, Query_tag) { return Param_not_found(); } template< typename T, typename Tag> typename std::conditional::value, - T&, const T& >::type -get_parameter_reference_impl(Named_params_impl& np, Tag) + T, const T& >::type +get_parameter_reference_impl(const Named_params_impl& np, Tag) { return get_reference(np.v); }; template T& -get_parameter_reference_impl(Named_params_impl, Tag, Base>& np, Tag) +get_parameter_reference_impl(const Named_params_impl, Tag, Base>& np, Tag) { return np.v.get(); } template< typename T, typename Tag> T& -get_parameter_reference_impl(Named_params_impl, Tag, No_property>& np, Tag) +get_parameter_reference_impl(const Named_params_impl, Tag, No_property>& np, Tag) { return np.v.get(); }; template typename Get_param, Query_tag>::reference -get_parameter_reference_impl(Named_params_impl& np, Query_tag tag) +get_parameter_reference_impl(const Named_params_impl& np, Query_tag tag) { CGAL_static_assertion( (!boost::is_same::value) ); - return get_parameter_reference_impl(static_cast(np), tag); + return get_parameter_reference_impl(static_cast(np), tag); } @@ -296,7 +296,7 @@ typename internal_np::Get_param, Qu get_parameter_reference(const Named_function_parameters& np, Query_tag tag) { return internal_np::get_parameter_reference_impl( - static_cast&>(const_cast&>(np)), + static_cast&>(np), tag); } diff --git a/BGL/test/BGL/test_cgal_bgl_named_params.cpp b/BGL/test/BGL/test_cgal_bgl_named_params.cpp index 8a73d25df37..ab403c28000 100644 --- a/BGL/test/BGL/test_cgal_bgl_named_params.cpp +++ b/BGL/test/BGL/test_cgal_bgl_named_params.cpp @@ -75,7 +75,7 @@ void test_references(const NamedParameters& np) // passed by copy typedef typename inp::Lookup_named_param_def::reference VIM_reference_type; - static_assert(std::is_same&, VIM_reference_type>::value); + static_assert(std::is_same, VIM_reference_type>::value); VIM_reference_type vim_ref = params::choose_parameter(params::get_parameter_reference(np, inp::vertex_index), default_value); CGAL_USE(vim_ref); From 1eda841d320083d037eb90e1728e7df60328c8b0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Fri, 3 Sep 2021 11:03:22 +0200 Subject: [PATCH 08/12] workaround user taking ref to temporary If D is a temporary, it's lifetime extension is done when we go out of the scope of choose_parameter so the const D& returned is dangling --- BGL/include/CGAL/boost/graph/Named_function_parameters.h | 6 ++++++ BGL/test/BGL/test_cgal_bgl_named_params.cpp | 5 ++++- 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/BGL/include/CGAL/boost/graph/Named_function_parameters.h b/BGL/include/CGAL/boost/graph/Named_function_parameters.h index acad6c9b93b..4738b8e4db0 100644 --- a/BGL/include/CGAL/boost/graph/Named_function_parameters.h +++ b/BGL/include/CGAL/boost/graph/Named_function_parameters.h @@ -313,6 +313,12 @@ const D& choose_parameter(const internal_np::Param_not_found&, const D& d) return d; } +template +D choose_parameter(const internal_np::Param_not_found&, D&& d) +{ + return d; +} + template T& choose_parameter(T& t, D&) { diff --git a/BGL/test/BGL/test_cgal_bgl_named_params.cpp b/BGL/test/BGL/test_cgal_bgl_named_params.cpp index ab403c28000..c6af93cfee9 100644 --- a/BGL/test/BGL/test_cgal_bgl_named_params.cpp +++ b/BGL/test/BGL/test_cgal_bgl_named_params.cpp @@ -43,10 +43,13 @@ void test_values_and_types(const NamedParameters& np) } template -void test_no_copyable(const NamedParameters&) +void test_no_copyable(const NamedParameters& np) { typedef typename inp::Get_param::type NP_type; static_assert( boost::is_same > ::value ); + + const A<4>& a = params::choose_parameter(params::get_parameter_reference(np, inp::edge_index), A<4>(4)); + assert(a.v==4); } template From 646e6852dc663743c41d8f5d69595536ea3c1a88 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Tue, 7 Sep 2021 10:21:29 +0200 Subject: [PATCH 09/12] static_assert is a c++17 feature --- BGL/test/BGL/test_cgal_bgl_named_params.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/BGL/test/BGL/test_cgal_bgl_named_params.cpp b/BGL/test/BGL/test_cgal_bgl_named_params.cpp index c6af93cfee9..8e448b0b5d5 100644 --- a/BGL/test/BGL/test_cgal_bgl_named_params.cpp +++ b/BGL/test/BGL/test_cgal_bgl_named_params.cpp @@ -46,7 +46,7 @@ template void test_no_copyable(const NamedParameters& np) { typedef typename inp::Get_param::type NP_type; - static_assert( boost::is_same > ::value ); + CGAL_static_assertion( boost::is_same > ::value ); const A<4>& a = params::choose_parameter(params::get_parameter_reference(np, inp::edge_index), A<4>(4)); assert(a.v==4); @@ -60,31 +60,31 @@ void test_references(const NamedParameters& np) // std::reference_wrapper typedef typename inp::Lookup_named_param_def::reference Visitor_reference_type; - static_assert(std::is_same::value); + CGAL_static_assertion(std::is_same::value); Visitor_reference_type vis_ref = params::choose_parameter(params::get_parameter_reference(np, inp::visitor), default_value); CGAL_USE(vis_ref); // std::reference_wrapper of const typedef typename inp::Lookup_named_param_def::reference FIM_reference_type; - static_assert(std::is_same::value); + CGAL_static_assertion(std::is_same::value); FIM_reference_type fim_ref = params::choose_parameter(params::get_parameter_reference(np, inp::face_index), default_value); CGAL_USE(fim_ref); // non-copyable typedef typename inp::Lookup_named_param_def::reference VPM_reference_type; - static_assert(std::is_same::value); + CGAL_static_assertion(std::is_same::value); VPM_reference_type vpm_ref = params::choose_parameter(params::get_parameter_reference(np, inp::vertex_point), default_value); CGAL_USE(vpm_ref); // passed by copy typedef typename inp::Lookup_named_param_def::reference VIM_reference_type; - static_assert(std::is_same, VIM_reference_type>::value); + CGAL_static_assertion(std::is_same, VIM_reference_type>::value); VIM_reference_type vim_ref = params::choose_parameter(params::get_parameter_reference(np, inp::vertex_index), default_value); CGAL_USE(vim_ref); // default typedef typename inp::Lookup_named_param_def::reference EIM_reference_type; - static_assert(std::is_same::value); + CGAL_static_assertion(std::is_same::value); EIM_reference_type eim_ref = params::choose_parameter(params::get_parameter_reference(np, inp::edge_index), default_value); assert(&eim_ref==&default_value); } From b27fc8b4afdbfa270cf720420125d543d6bed8df Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Tue, 7 Sep 2021 11:46:54 +0200 Subject: [PATCH 10/12] add missing () --- BGL/test/BGL/test_cgal_bgl_named_params.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/BGL/test/BGL/test_cgal_bgl_named_params.cpp b/BGL/test/BGL/test_cgal_bgl_named_params.cpp index 8e448b0b5d5..b7322b049f2 100644 --- a/BGL/test/BGL/test_cgal_bgl_named_params.cpp +++ b/BGL/test/BGL/test_cgal_bgl_named_params.cpp @@ -46,7 +46,7 @@ template void test_no_copyable(const NamedParameters& np) { typedef typename inp::Get_param::type NP_type; - CGAL_static_assertion( boost::is_same > ::value ); + CGAL_static_assertion( (boost::is_same >::value) ); const A<4>& a = params::choose_parameter(params::get_parameter_reference(np, inp::edge_index), A<4>(4)); assert(a.v==4); @@ -60,31 +60,31 @@ void test_references(const NamedParameters& np) // std::reference_wrapper typedef typename inp::Lookup_named_param_def::reference Visitor_reference_type; - CGAL_static_assertion(std::is_same::value); + CGAL_static_assertion( (std::is_same::value) ); Visitor_reference_type vis_ref = params::choose_parameter(params::get_parameter_reference(np, inp::visitor), default_value); CGAL_USE(vis_ref); // std::reference_wrapper of const typedef typename inp::Lookup_named_param_def::reference FIM_reference_type; - CGAL_static_assertion(std::is_same::value); + CGAL_static_assertion( (std::is_same::value) ); FIM_reference_type fim_ref = params::choose_parameter(params::get_parameter_reference(np, inp::face_index), default_value); CGAL_USE(fim_ref); // non-copyable typedef typename inp::Lookup_named_param_def::reference VPM_reference_type; - CGAL_static_assertion(std::is_same::value); + CGAL_static_assertion( (std::is_same::value) ); VPM_reference_type vpm_ref = params::choose_parameter(params::get_parameter_reference(np, inp::vertex_point), default_value); CGAL_USE(vpm_ref); // passed by copy typedef typename inp::Lookup_named_param_def::reference VIM_reference_type; - CGAL_static_assertion(std::is_same, VIM_reference_type>::value); + CGAL_static_assertion( (std::is_same, VIM_reference_type>::value) ); VIM_reference_type vim_ref = params::choose_parameter(params::get_parameter_reference(np, inp::vertex_index), default_value); CGAL_USE(vim_ref); // default typedef typename inp::Lookup_named_param_def::reference EIM_reference_type; - CGAL_static_assertion(std::is_same::value); + CGAL_static_assertion(( std::is_same::value) ); EIM_reference_type eim_ref = params::choose_parameter(params::get_parameter_reference(np, inp::edge_index), default_value); assert(&eim_ref==&default_value); } From 64a602ba7c48f93ee9136b1849924f3f419ede76 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Tue, 7 Sep 2021 11:47:04 +0200 Subject: [PATCH 11/12] try to remove a warning with clang C++20 warning: local variable 'd' will be copied despite being returned by name [-Wreturn-std-move] return d; CGAL/boost/graph/Named_function_parameters.h:319:10: note: call 'std::move' explicitly to avoid copying return d; ^ std::move(d) --- BGL/include/CGAL/boost/graph/Named_function_parameters.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/BGL/include/CGAL/boost/graph/Named_function_parameters.h b/BGL/include/CGAL/boost/graph/Named_function_parameters.h index 4738b8e4db0..aba37d06399 100644 --- a/BGL/include/CGAL/boost/graph/Named_function_parameters.h +++ b/BGL/include/CGAL/boost/graph/Named_function_parameters.h @@ -316,7 +316,7 @@ const D& choose_parameter(const internal_np::Param_not_found&, const D& d) template D choose_parameter(const internal_np::Param_not_found&, D&& d) { - return d; + return std::move(d); } template From 2e07200e5f97cb08ed716ac049a55094864f007d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Tue, 7 Sep 2021 12:37:29 +0200 Subject: [PATCH 12/12] use forward instead of move --- BGL/include/CGAL/boost/graph/Named_function_parameters.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/BGL/include/CGAL/boost/graph/Named_function_parameters.h b/BGL/include/CGAL/boost/graph/Named_function_parameters.h index aba37d06399..0fe22798160 100644 --- a/BGL/include/CGAL/boost/graph/Named_function_parameters.h +++ b/BGL/include/CGAL/boost/graph/Named_function_parameters.h @@ -316,7 +316,7 @@ const D& choose_parameter(const internal_np::Param_not_found&, const D& d) template D choose_parameter(const internal_np::Param_not_found&, D&& d) { - return std::move(d); + return std::forward(d); } template