diff options
Diffstat (limited to 'include/gudhi_patches/CGAL/NewKernel_d/Wrapper/Cartesian_wrap.h')
| -rw-r--r-- | include/gudhi_patches/CGAL/NewKernel_d/Wrapper/Cartesian_wrap.h | 305 |
1 files changed, 0 insertions, 305 deletions
diff --git a/include/gudhi_patches/CGAL/NewKernel_d/Wrapper/Cartesian_wrap.h b/include/gudhi_patches/CGAL/NewKernel_d/Wrapper/Cartesian_wrap.h deleted file mode 100644 index 44e9aa96..00000000 --- a/include/gudhi_patches/CGAL/NewKernel_d/Wrapper/Cartesian_wrap.h +++ /dev/null @@ -1,305 +0,0 @@ -// Copyright (c) 2014 -// INRIA Saclay-Ile de France (France) -// -// This file is part of CGAL (www.cgal.org); you can redistribute it and/or -// modify it under the terms of the GNU Lesser General Public License as -// published by the Free Software Foundation; either version 3 of the License, -// or (at your option) any later version. -// -// Licensees holding a valid commercial license may use this file in -// accordance with the commercial license agreement provided with the software. -// -// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE -// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. -// -// $URL$ -// $Id$ -// -// Author(s) : Marc Glisse - -#ifndef CGAL_KERNEL_D_CARTESIAN_WRAP_H -#define CGAL_KERNEL_D_CARTESIAN_WRAP_H - -#include <CGAL/basic.h> -#include <CGAL/is_iterator.h> - -#if defined(BOOST_MSVC) -# pragma warning(push) -# pragma warning(disable:4003) // not enough actual parameters for macro 'BOOST_PP_EXPAND_I' - // http://lists.boost.org/boost-users/2014/11/83291.php -#endif -#include <CGAL/NewKernel_d/Wrapper/Point_d.h> -#include <CGAL/NewKernel_d/Wrapper/Vector_d.h> -#include <CGAL/NewKernel_d/Wrapper/Segment_d.h> -#include <CGAL/NewKernel_d/Wrapper/Sphere_d.h> -#include <CGAL/NewKernel_d/Wrapper/Hyperplane_d.h> -#include <CGAL/NewKernel_d/Wrapper/Weighted_point_d.h> - -#include <CGAL/NewKernel_d/Wrapper/Ref_count_obj.h> - -#include <boost/mpl/or.hpp> -#include <boost/mpl/contains.hpp> -#include <boost/mpl/vector.hpp> - -//TODO: do we want to store the kernel ref in the Object wrappers? It would allow for additions and operator[] and things like that to work, but objects would still need to be created by functors. - -namespace CGAL { -namespace internal { -BOOST_MPL_HAS_XXX_TRAIT_DEF(Is_wrapper) -template<class T,bool=has_Is_wrapper<T>::value> struct Is_wrapper { - enum { value=false }; - typedef Tag_false type; -}; -template<class T> struct Is_wrapper<T,true> { - typedef typename T::Is_wrapper type; - enum { value=type::value }; -}; - -template<class T,bool=is_iterator_type<T,std::input_iterator_tag>::value> struct Is_wrapper_iterator { - enum { value=false }; - typedef Tag_false type; -}; -template<class T> struct Is_wrapper_iterator<T,true> : - Is_wrapper<typename std::iterator_traits<typename CGAL::decay<T>::type>::value_type> -{ }; - -struct Forward_rep { -//TODO: make a good C++0X version with perfect forwarding -//#ifdef CGAL_CXX11 -//template <class T,class=typename std::enable_if<!Is_wrapper<typename std::decay<T>::type>::value&&!Is_wrapper_iterator<typename std::decay<T>::type>::value>::type> -//T&& operator()(typename std::remove_reference<T>::type&& t) const {return static_cast<T&&>(t);}; -//template <class T,class=typename std::enable_if<!Is_wrapper<typename std::decay<T>::type>::value&&!Is_wrapper_iterator<typename std::decay<T>::type>::value>::type> -//T&& operator()(typename std::remove_reference<T>::type& t) const {return static_cast<T&&>(t);}; -// -//template <class T,class=typename std::enable_if<Is_wrapper<typename std::decay<T>::type>::value>::type> -//typename Type_copy_cvref<T,typename std::decay<T>::type::Rep>::type&& -//operator()(T&& t) const { -// return static_cast<typename Type_copy_cvref<T,typename std::decay<T>::type::Rep>::type&&>(t.rep()); -//}; -// -//template <class T,class=typename std::enable_if<Is_wrapper_iterator<typename std::decay<T>::type>::value>::type> -//transforming_iterator<Forward_rep,typename std::decay<T>::type> -//operator()(T&& t) const { -// return make_transforming_iterator(std::forward<T>(t),Forward_rep()); -//}; -//#else -template <class T,bool=Is_wrapper<T>::value,bool=Is_wrapper_iterator<T>::value> struct result_; -template <class T> struct result_<T,false,false>{typedef T const& type;}; -template <class T> struct result_<T,true,false>{typedef typename decay<T>::type::Rep const& type;}; -template <class T> struct result_<T,false,true>{typedef transforming_iterator<Forward_rep,typename decay<T>::type> type;}; -template<class> struct result; -template<class T> struct result<Forward_rep(T)> : result_<T> {}; - -template <class T> typename boost::disable_if<boost::mpl::or_<Is_wrapper<T>,Is_wrapper_iterator<T> >,T>::type const& operator()(T const& t) const {return t;} -template <class T> typename boost::disable_if<boost::mpl::or_<Is_wrapper<T>,Is_wrapper_iterator<T> >,T>::type& operator()(T& t) const {return t;} - -template <class T> typename T::Rep const& operator()(T const& t, typename boost::enable_if<Is_wrapper<T> >::type* = 0) const {return t.rep();} - -template <class T> transforming_iterator<Forward_rep,typename boost::enable_if<Is_wrapper_iterator<T>,T>::type> operator()(T const& t) const {return make_transforming_iterator(t,Forward_rep());} -//#endif -}; -} - -template <class B, class K, class T, bool = Provides_type<B, T>::value> -struct Map_wrapping_type : Get_type<B, T> {}; -#define CGAL_REGISTER_OBJECT_WRAPPER(X) \ - template <class B, class K> \ - struct Map_wrapping_type <B, K, X##_tag, true> { \ - typedef Wrap::X##_d<K> type; \ - } -CGAL_REGISTER_OBJECT_WRAPPER(Point); -CGAL_REGISTER_OBJECT_WRAPPER(Vector); -CGAL_REGISTER_OBJECT_WRAPPER(Segment); -CGAL_REGISTER_OBJECT_WRAPPER(Sphere); -CGAL_REGISTER_OBJECT_WRAPPER(Hyperplane); -CGAL_REGISTER_OBJECT_WRAPPER(Weighted_point); -#undef CGAL_REGISTER_OBJECT_WRAPPER - -// Note: this tends to be an all or nothing thing currently, wrapping -// only some types breaks, probably because we don't check whether the -// return type is indeed wrapped. -template < typename Base_ , typename Derived_ = Default > -struct Cartesian_wrap : public Base_ -{ - CGAL_CONSTEXPR Cartesian_wrap(){} - CGAL_CONSTEXPR Cartesian_wrap(int d):Base_(d){} - typedef Base_ Kernel_base; - typedef Cartesian_wrap Self; - // TODO: pass the 2 types Self and Derived to the wrappers, they can use Self for most purposes and Derived only for Kernel_traits' typedef R. - typedef typename Default::Get<Derived_, Self>::type Derived; - // FIXME: The list doesn't belong here. - typedef boost::mpl::vector<Point_tag,Segment_tag,Sphere_tag,Vector_tag,Hyperplane_tag> Wrapped_list; - - template <class T> - struct Type : Map_wrapping_type<Base_, Derived, T> {}; - - //Translate the arguments - template <class T, class D = void, - class=typename Get_functor_category<Derived,T>::type, - bool=Provides_functor<Kernel_base, T>::value, - bool=boost::mpl::contains<Wrapped_list,typename map_result_tag<T>::type>::type::value> - struct Functor { - typedef typename Get_functor<Kernel_base, T>::type B; - struct type { - B b; - type(){} - type(Self const&k):b(k){} - typedef typename B::result_type result_type; -#ifdef CGAL_CXX11 - template<class...U> result_type operator()(U&&...u)const{ - return b(internal::Forward_rep()(u)...); - } -#else -#define CGAL_VAR(Z,N,_) internal::Forward_rep()(u##N) -#define CGAL_CODE(Z,N,_) template<BOOST_PP_ENUM_PARAMS(N,class U)> result_type \ - operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,U,const&u))const{ \ - return b(BOOST_PP_ENUM(N,CGAL_VAR,)); \ - } - BOOST_PP_REPEAT_FROM_TO(1,11,CGAL_CODE,_) -#undef CGAL_CODE -#undef CGAL_VAR -// In case the last argument needs to be non-const. Fragile... -#define CGAL_VAR(Z,N,_) internal::Forward_rep()(u##N) -#define CGAL_CODE(Z,N,_) template<BOOST_PP_ENUM_PARAMS(N,class U),class V> result_type \ - operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,U,const&u),V&v)const{ \ - return b(BOOST_PP_ENUM(N,CGAL_VAR,),internal::Forward_rep()(v)); \ - } - BOOST_PP_REPEAT_FROM_TO(1,8,CGAL_CODE,_) -#undef CGAL_CODE -#undef CGAL_VAR -#endif - }; - }; - - // Preserve the difference between Null_functor and nothing. - template <class T, class D, class C, bool b> - struct Functor <T, D, C, false, b> - : Get_functor <Kernel_base, T> {}; - - //Translate both the arguments and the result - //TODO: Check Is_wrapper instead of relying on map_result_tag? - template<class T,class D> struct Functor<T,D,Construct_tag,true,true> { - typedef typename Get_functor<Kernel_base, T>::type B; - struct type { - B b; - type(){} - type(Self const&k):b(k){} - typedef typename map_result_tag<T>::type result_tag; - // FIXME: Self or Derived? - typedef typename Get_type<Self,result_tag>::type result_type; -#ifdef CGAL_CXX11 - template<class...U> result_type operator()(U&&...u)const{ - return result_type(Eval_functor(),b,internal::Forward_rep()(u)...); - } -#else -#define CGAL_VAR(Z,N,_) internal::Forward_rep()(u##N) -#define CGAL_CODE(Z,N,_) template<BOOST_PP_ENUM_PARAMS(N,class U)> result_type \ - operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,U,const&u))const{ \ - return result_type(Eval_functor(),b,BOOST_PP_ENUM(N,CGAL_VAR,)); \ - } - BOOST_PP_REPEAT_FROM_TO(1,11,CGAL_CODE,_) -#undef CGAL_CODE -#undef CGAL_VAR -#endif - }; - }; - -}; - -template < typename Base_ > -struct Cartesian_refcount : public Base_ -{ - CGAL_CONSTEXPR Cartesian_refcount(){} - CGAL_CONSTEXPR Cartesian_refcount(int d):Base_(d){} - typedef Base_ Kernel_base; - typedef Cartesian_refcount Self; - - // FIXME: Use object_list, or a list passed as argument, or anything - // automatic. - template <class T, class=void> struct Type : Get_type<Base_, T> {}; -#define CGAL_Kernel_obj(X,Y) \ - template <class D> struct Type<X##_tag, D> { typedef Ref_count_obj<Cartesian_refcount, X##_tag> type; }; - - CGAL_Kernel_obj(Point,point) - CGAL_Kernel_obj(Vector,vector) -#undef CGAL_Kernel_obj - - template<class T> struct Dispatch { - //typedef typename map_functor_type<T>::type f_t; - typedef typename map_result_tag<T>::type r_t; - enum { - is_nul = boost::is_same<typename Get_functor<Kernel_base, T>::type,Null_functor>::value, - ret_rcobj = boost::is_same<r_t,Point_tag>::value || boost::is_same<r_t,Vector_tag>::value - }; - }; - - //Translate the arguments - template<class T,class D=void,bool=Dispatch<T>::is_nul,bool=Dispatch<T>::ret_rcobj> struct Functor { - typedef typename Get_functor<Kernel_base, T>::type B; - struct type { - B b; - type(){} - type(Self const&k):b(k){} - typedef typename B::result_type result_type; -#ifdef CGAL_CXX11 - template<class...U> result_type operator()(U&&...u)const{ - return b(internal::Forward_rep()(u)...); - } -#else - result_type operator()()const{ - return b(); - } -#define CGAL_VAR(Z,N,_) internal::Forward_rep()(u##N) -#define CGAL_CODE(Z,N,_) template<BOOST_PP_ENUM_PARAMS(N,class U)> result_type \ - operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,U,const&u))const{ \ - return b(BOOST_PP_ENUM(N,CGAL_VAR,)); \ - } - BOOST_PP_REPEAT_FROM_TO(1,11,CGAL_CODE,_) -#undef CGAL_CODE -#undef CGAL_VAR -#endif - }; - }; - - //Translate both the arguments and the result - template<class T,class D,bool b> struct Functor<T,D,true,b> { - typedef Null_functor type; - }; - - template<class T,class D> struct Functor<T,D,false,true> { - typedef typename Get_functor<Kernel_base, T>::type B; - struct type { - B b; - type(){} - type(Self const&k):b(k){} - typedef typename map_result_tag<T>::type result_tag; - typedef typename Get_type<Self,result_tag>::type result_type; -#ifdef CGAL_CXX11 - template<class...U> result_type operator()(U&&...u)const{ - return result_type(Eval_functor(),b,internal::Forward_rep()(u)...); - } -#else - result_type operator()()const{ - return result_type(Eval_functor(),b); - } -#define CGAL_VAR(Z,N,_) internal::Forward_rep()(u##N) -#define CGAL_CODE(Z,N,_) template<BOOST_PP_ENUM_PARAMS(N,class U)> result_type \ - operator()(BOOST_PP_ENUM_BINARY_PARAMS(N,U,const&u))const{ \ - return result_type(Eval_functor(),b,BOOST_PP_ENUM(N,CGAL_VAR,)); \ - } - BOOST_PP_REPEAT_FROM_TO(1,11,CGAL_CODE,_) -#undef CGAL_CODE -#undef CGAL_VAR -#endif - }; - }; - -}; - -} //namespace CGAL - -#if defined(BOOST_MSVC) -# pragma warning(pop) -#endif - -#endif // CGAL_KERNEL_D_CARTESIAN_WRAP_H |