mirror of https://github.com/CGAL/cgal
Merge pull request #5945 from sloriot/BGL-np_ref_for_non_copyable_parameters
Improvement for named parameters
This commit is contained in:
Sebastien Loriot
GitHub
commit
f9d20f42cc
|
|
@ -16,6 +16,7 @@
|
|||
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <type_traits>
|
||||
|
||||
#define CGAL_BGL_NP_TEMPLATE_PARAMETERS T, typename Tag, typename Base
|
||||
#define CGAL_BGL_NP_CLASS CGAL::Named_function_parameters<T,Tag,Base>
|
||||
|
|
@ -38,8 +39,9 @@ enum all_default_t { all_default };
|
|||
template <typename T, typename Tag, typename Base>
|
||||
struct Named_params_impl : Base
|
||||
{
|
||||
T v; // copy of the parameter
|
||||
Named_params_impl(T v, const Base& b)
|
||||
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)
|
||||
: Base(b)
|
||||
, v(v)
|
||||
{}
|
||||
|
|
@ -49,8 +51,9 @@ struct Named_params_impl : Base
|
|||
template <typename T, typename Tag>
|
||||
struct Named_params_impl<T, Tag, No_property>
|
||||
{
|
||||
T v; // copy of the parameter
|
||||
Named_params_impl(T v)
|
||||
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)
|
||||
: v(v)
|
||||
{}
|
||||
};
|
||||
|
|
@ -63,18 +66,39 @@ template< typename T, typename Tag, typename Query_tag>
|
|||
struct Get_param< Named_params_impl<T, Tag, No_property>, Query_tag >
|
||||
{
|
||||
typedef Param_not_found type;
|
||||
typedef Param_not_found reference;
|
||||
};
|
||||
|
||||
template< typename T, typename Tag, typename Base>
|
||||
struct Get_param< Named_params_impl<T, Tag, Base>, Tag >
|
||||
{
|
||||
typedef T type;
|
||||
typedef typename std::conditional<std::is_copy_constructible<T>::value,
|
||||
T, std::reference_wrapper<const T> >::type type;
|
||||
typedef typename std::conditional<std::is_copy_constructible<T>::value,
|
||||
T, const T&>::type reference;
|
||||
};
|
||||
|
||||
template< typename T, typename Tag>
|
||||
struct Get_param< Named_params_impl<T, Tag, No_property>, Tag >
|
||||
{
|
||||
typedef T type;
|
||||
typedef typename std::conditional<std::is_copy_constructible<T>::value,
|
||||
T, std::reference_wrapper<const T> >::type type;
|
||||
typedef typename std::conditional<std::is_copy_constructible<T>::value,
|
||||
T, const T&>::type reference;
|
||||
};
|
||||
|
||||
template< typename T, typename Tag, typename Base>
|
||||
struct Get_param< Named_params_impl<std::reference_wrapper<T>, Tag, Base>, Tag >
|
||||
{
|
||||
typedef std::reference_wrapper<T> type;
|
||||
typedef T& reference;
|
||||
};
|
||||
|
||||
template< typename T, typename Tag>
|
||||
struct Get_param< Named_params_impl<std::reference_wrapper<T>, Tag, No_property>, Tag >
|
||||
{
|
||||
typedef std::reference_wrapper<T> type;
|
||||
typedef T& reference;
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -82,6 +106,7 @@ template< typename T, typename Tag, typename Base, typename Query_tag>
|
|||
struct Get_param< Named_params_impl<T,Tag,Base>, Query_tag>
|
||||
{
|
||||
typedef typename Get_param<typename Base::base, Query_tag>::type type;
|
||||
typedef typename Get_param<typename Base::base, Query_tag>::reference reference;
|
||||
};
|
||||
|
||||
// helper to choose the default
|
||||
|
|
@ -89,16 +114,24 @@ template <typename Query_tag, typename NP, typename D>
|
|||
struct Lookup_named_param_def
|
||||
{
|
||||
typedef typename internal_np::Get_param<typename NP::base, Query_tag>::type NP_type;
|
||||
typedef typename internal_np::Get_param<typename NP::base, Query_tag>::reference NP_reference;
|
||||
|
||||
typedef typename boost::mpl::if_<
|
||||
boost::is_same<NP_type, internal_np::Param_not_found>,
|
||||
D, NP_type>::type
|
||||
type;
|
||||
|
||||
typedef typename boost::mpl::if_<
|
||||
boost::is_same<NP_reference, internal_np::Param_not_found>,
|
||||
D&, NP_reference>::type
|
||||
reference;
|
||||
};
|
||||
|
||||
// helper function to extract the value from a named parameter pack given a query tag
|
||||
template <typename T, typename Tag, typename Base>
|
||||
T get_parameter_impl(const Named_params_impl<T, Tag, Base>& np, Tag)
|
||||
typename std::conditional<std::is_copy_constructible<T>::value,
|
||||
T, std::reference_wrapper<const T> >::type
|
||||
get_parameter_impl(const Named_params_impl<T, Tag, Base>& np, Tag)
|
||||
{
|
||||
return np.v;
|
||||
}
|
||||
|
|
@ -110,7 +143,9 @@ Param_not_found get_parameter_impl(const Named_params_impl<T, Tag, No_property>&
|
|||
}
|
||||
|
||||
template< typename T, typename Tag>
|
||||
T get_parameter_impl(const Named_params_impl<T, Tag, No_property>& np, Tag)
|
||||
typename std::conditional<std::is_copy_constructible<T>::value,
|
||||
T, std::reference_wrapper<const T> >::type
|
||||
get_parameter_impl(const Named_params_impl<T, Tag, No_property>& np, Tag)
|
||||
{
|
||||
return np.v;
|
||||
};
|
||||
|
|
@ -123,6 +158,67 @@ get_parameter_impl(const Named_params_impl<T, Tag, Base>& np, Query_tag tag)
|
|||
return get_parameter_impl(static_cast<const typename Base::base&>(np), tag);
|
||||
}
|
||||
|
||||
|
||||
// helper for getting references
|
||||
template <class T>
|
||||
const T& get_reference(const T& t)
|
||||
{
|
||||
return t;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
T& get_reference(const std::reference_wrapper<T>& r)
|
||||
{
|
||||
return r.get();
|
||||
}
|
||||
|
||||
// helper function to extract the reference from a named parameter pack given a query tag
|
||||
template <typename T, typename Tag, typename Base>
|
||||
typename std::conditional<std::is_copy_constructible<T>::value,
|
||||
T, const T& >::type
|
||||
get_parameter_reference_impl(const Named_params_impl<T, Tag, Base>& np, Tag)
|
||||
{
|
||||
return get_reference(np.v);
|
||||
}
|
||||
|
||||
template< typename T, typename Tag, typename Query_tag>
|
||||
Param_not_found
|
||||
get_parameter_reference_impl(const Named_params_impl<T, Tag, No_property>&, Query_tag)
|
||||
{
|
||||
return Param_not_found();
|
||||
}
|
||||
|
||||
template< typename T, typename Tag>
|
||||
typename std::conditional<std::is_copy_constructible<T>::value,
|
||||
T, const T& >::type
|
||||
get_parameter_reference_impl(const Named_params_impl<T, Tag, No_property>& np, Tag)
|
||||
{
|
||||
return get_reference(np.v);
|
||||
};
|
||||
|
||||
template <typename T, typename Tag, typename Base>
|
||||
T&
|
||||
get_parameter_reference_impl(const Named_params_impl<std::reference_wrapper<T>, Tag, Base>& np, Tag)
|
||||
{
|
||||
return np.v.get();
|
||||
}
|
||||
|
||||
template< typename T, typename Tag>
|
||||
T&
|
||||
get_parameter_reference_impl(const Named_params_impl<std::reference_wrapper<T>, Tag, No_property>& np, Tag)
|
||||
{
|
||||
return np.v.get();
|
||||
};
|
||||
|
||||
template <typename T, typename Tag, typename Base, typename Query_tag>
|
||||
typename Get_param<Named_params_impl<T, Tag, Base>, Query_tag>::reference
|
||||
get_parameter_reference_impl(const Named_params_impl<T, Tag, Base>& np, Query_tag tag)
|
||||
{
|
||||
CGAL_static_assertion( (!boost::is_same<Query_tag, Tag>::value) );
|
||||
return get_parameter_reference_impl(static_cast<const typename Base::base&>(np), tag);
|
||||
}
|
||||
|
||||
|
||||
} // end of internal_np namespace
|
||||
|
||||
|
||||
|
|
@ -133,8 +229,9 @@ 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(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<bool, internal_np::all_default_t, self>
|
||||
all_default() const
|
||||
|
|
@ -178,7 +275,7 @@ inline no_parameters(Named_function_parameters<T,Tag,Base>)
|
|||
#define CGAL_add_named_parameter(X, Y, Z) \
|
||||
template <typename K> \
|
||||
Named_function_parameters<K, internal_np::X> \
|
||||
Z(K const& p) \
|
||||
Z(const K& p) \
|
||||
{ \
|
||||
typedef Named_function_parameters<K, internal_np::X> Params;\
|
||||
return Params(p); \
|
||||
|
|
@ -194,13 +291,40 @@ get_parameter(const Named_function_parameters<T, Tag, Base>& np, Query_tag tag)
|
|||
return internal_np::get_parameter_impl(static_cast<const internal_np::Named_params_impl<T, Tag, Base>&>(np), tag);
|
||||
}
|
||||
|
||||
template <typename T, typename Tag, typename Base, typename Query_tag>
|
||||
typename internal_np::Get_param<internal_np::Named_params_impl<T, Tag, Base>, Query_tag>::reference
|
||||
get_parameter_reference(const Named_function_parameters<T, Tag, Base>& np, Query_tag tag)
|
||||
{
|
||||
return internal_np::get_parameter_reference_impl(
|
||||
static_cast<const internal_np::Named_params_impl<T, Tag, Base>&>(np),
|
||||
tag);
|
||||
}
|
||||
|
||||
// Two parameters, non-trivial default value
|
||||
template <typename D>
|
||||
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 <typename D>
|
||||
const D& choose_parameter(const internal_np::Param_not_found&, const D& d)
|
||||
{
|
||||
return d;
|
||||
}
|
||||
|
||||
template <typename D>
|
||||
D choose_parameter(const internal_np::Param_not_found&, D&& d)
|
||||
{
|
||||
return std::forward<D>(d);
|
||||
}
|
||||
|
||||
template <typename T, typename D>
|
||||
T& choose_parameter(T& t, D&)
|
||||
{
|
||||
return t;
|
||||
}
|
||||
|
||||
template <typename T, typename D>
|
||||
const T& choose_parameter(const T& t, const D&)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -4,6 +4,9 @@
|
|||
|
||||
#include <cstdlib>
|
||||
|
||||
namespace inp = CGAL::internal_np;
|
||||
namespace params = CGAL::parameters;
|
||||
|
||||
template <int i>
|
||||
struct A
|
||||
{
|
||||
|
|
@ -11,6 +14,12 @@ struct A
|
|||
int v;
|
||||
};
|
||||
|
||||
struct B
|
||||
{
|
||||
B(){}
|
||||
B(const B&) = delete;
|
||||
};
|
||||
|
||||
template <int i, class T>
|
||||
void check_same_type(T)
|
||||
{
|
||||
|
|
@ -20,416 +29,78 @@ void check_same_type(T)
|
|||
}
|
||||
|
||||
template<class NamedParameters>
|
||||
void test(const NamedParameters& np)
|
||||
void test_values_and_types(const NamedParameters& np)
|
||||
{
|
||||
using CGAL::parameters::get_parameter;
|
||||
using params::get_parameter;
|
||||
|
||||
// Test values
|
||||
// test values
|
||||
assert(get_parameter(np, inp::vertex_index).v == 0);
|
||||
assert(get_parameter(np, inp::visitor).v == 1);
|
||||
|
||||
// Named parameters that we use in CGAL
|
||||
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);
|
||||
// test types
|
||||
check_same_type<0>(get_parameter(np, inp::vertex_index));
|
||||
check_same_type<1>(get_parameter(np, inp::visitor));
|
||||
}
|
||||
|
||||
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);
|
||||
template<class NamedParameters>
|
||||
void test_no_copyable(const NamedParameters& np)
|
||||
{
|
||||
typedef typename inp::Get_param<typename NamedParameters::base,inp::visitor_t>::type NP_type;
|
||||
CGAL_static_assertion( (boost::is_same<NP_type,std::reference_wrapper<const B> >::value) );
|
||||
|
||||
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);
|
||||
const A<4>& a = params::choose_parameter(params::get_parameter_reference(np, inp::edge_index), A<4>(4));
|
||||
assert(a.v==4);
|
||||
}
|
||||
|
||||
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);
|
||||
template <class NamedParameters>
|
||||
void test_references(const NamedParameters& np)
|
||||
{
|
||||
typedef A<2> Default_type;
|
||||
Default_type default_value(2);
|
||||
|
||||
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);
|
||||
// std::reference_wrapper
|
||||
typedef typename inp::Lookup_named_param_def<inp::visitor_t, NamedParameters, Default_type>::reference Visitor_reference_type;
|
||||
CGAL_static_assertion( (std::is_same<B&, Visitor_reference_type>::value) );
|
||||
Visitor_reference_type vis_ref = params::choose_parameter(params::get_parameter_reference(np, inp::visitor), default_value);
|
||||
CGAL_USE(vis_ref);
|
||||
|
||||
assert(get_parameter(np, CGAL::internal_np::implementation_tag).v == 800000010);
|
||||
assert(get_parameter(np, CGAL::internal_np::prevent_unselection).v == 800000011);
|
||||
// std::reference_wrapper of const
|
||||
typedef typename inp::Lookup_named_param_def<inp::face_index_t, NamedParameters, Default_type>::reference FIM_reference_type;
|
||||
CGAL_static_assertion( (std::is_same<const B&, FIM_reference_type>::value) );
|
||||
FIM_reference_type fim_ref = params::choose_parameter(params::get_parameter_reference(np, inp::face_index), default_value);
|
||||
CGAL_USE(fim_ref);
|
||||
|
||||
assert(get_parameter(np, CGAL::internal_np::stream_precision).v == 800000012);
|
||||
// non-copyable
|
||||
typedef typename inp::Lookup_named_param_def<inp::vertex_point_t, NamedParameters, Default_type>::reference VPM_reference_type;
|
||||
CGAL_static_assertion( (std::is_same<const B&, VPM_reference_type>::value) );
|
||||
VPM_reference_type vpm_ref = params::choose_parameter(params::get_parameter_reference(np, inp::vertex_point), default_value);
|
||||
CGAL_USE(vpm_ref);
|
||||
|
||||
// Named parameters that we use in the package 'Mesh_3'
|
||||
assert(get_parameter(np, CGAL::internal_np::vertex_feature_degree).v == 9);
|
||||
// passed by copy
|
||||
typedef typename inp::Lookup_named_param_def<inp::vertex_index_t, NamedParameters, Default_type>::reference VIM_reference_type;
|
||||
CGAL_static_assertion( (std::is_same<A<0>, 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);
|
||||
|
||||
// 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
|
||||
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));
|
||||
// default
|
||||
typedef typename inp::Lookup_named_param_def<inp::edge_index_t, NamedParameters, Default_type>::reference EIM_reference_type;
|
||||
CGAL_static_assertion(( std::is_same<Default_type&, EIM_reference_type>::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()
|
||||
{
|
||||
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(params::vertex_index_map(A<0>(0)).visitor(A<1>(1)));
|
||||
|
||||
B b;
|
||||
test_no_copyable(params::visitor(b));
|
||||
|
||||
test_references(params::visitor(std::ref(b))
|
||||
.vertex_point_map(b)
|
||||
.vertex_index_map(A<0>(0))
|
||||
.face_index_map(std::reference_wrapper<const B>(b))
|
||||
);
|
||||
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue