1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
// 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_LAZY_CARTESIAN_H
#define CGAL_KERNEL_D_LAZY_CARTESIAN_H
#include <CGAL/basic.h>
#include <CGAL/algorithm.h>
#include <CGAL/Lazy.h>
#include <CGAL/Default.h>
#include <CGAL/NewKernel_d/Filtered_predicate2.h>
#include <CGAL/iterator_from_indices.h>
#include <CGAL/NewKernel_d/Define_kernel_types.h>
namespace CGAL {
template<class K,class T>
struct Nth_iterator_element : private Store_kernel<K> {
Nth_iterator_element(){}
Nth_iterator_element(K const&k):Store_kernel<K>(k){}
typedef typename Get_type<K, typename iterator_tag_traits<T>::value_tag>::type result_type;
template<class U> result_type operator()(CGAL_FORWARDABLE(U) u, int i) const {
typename Get_functor<K, Construct_ttag<T> >::type ci(this->kernel());
return *cpp0x::next(ci(CGAL_FORWARD(U,u),Begin_tag()),i);
}
};
//typedef typename Functor<typename iterator_tag_traits<T>::nth_element>::type nth_elem;
template<class K, class T, bool = iterator_tag_traits<T>::has_nth_element>
struct Select_nth_element_functor {
typedef Nth_iterator_element<K, T> type;
};
template<class K, class T>
struct Select_nth_element_functor <K, T, true> :
Get_functor<K, typename iterator_tag_traits<T>::nth_element> {};
namespace internal {
template<class A,class B,class C,bool/*is_NT=false*/>
struct Lazy_construction_maybe_nt {
typedef Lazy_construction<A,B,C> type;
};
template<class A,class B,class C>
struct Lazy_construction_maybe_nt<A,B,C,true> {
typedef Lazy_construction_nt<A,B,C> type;
};
}
template <class EK_, class AK_, class E2A_, class Kernel_>
struct Lazy_cartesian_types
{
typedef typename typeset_intersection<
typename AK_::Object_list,
typename EK_::Object_list
>::type Object_list;
typedef typename typeset_intersection<
typename AK_::Iterator_list,
typename EK_::Iterator_list
>::type Iterator_list;
template <class T,class=typename Get_type_category<Kernel_,T>::type> struct Type {};
template <class T> struct Type<T,Object_tag> {
typedef Lazy<
typename Get_type<AK_,T>::type,
typename Get_type<EK_,T>::type,
typename Get_type<EK_, FT_tag>::type,
E2A_> type;
};
template <class T> struct Type<T,Number_tag> {
typedef CGAL::Lazy_exact_nt<typename Get_type<EK_,T>::type> type;
};
template <class T> struct Iterator {
typedef typename iterator_tag_traits<T>::value_tag Vt;
typedef typename Type<Vt>::type V;
typedef typename Select_nth_element_functor<AK_,T>::type AF;
typedef typename Select_nth_element_functor<EK_,T>::type EF;
typedef typename internal::Lazy_construction_maybe_nt<
Kernel_, AF, EF, is_NT_tag<Vt>::value
>::type nth_elem;
typedef Iterator_from_indices<
const typename Type<typename iterator_tag_traits<T>::container>::type,
const V, V, nth_elem
> type;
};
};
template <class EK_, class AK_, class E2A_/*, class Kernel_=Default*/>
struct Lazy_cartesian : Dimension_base<typename EK_::Default_ambient_dimension>,
Lazy_cartesian_types<EK_,AK_,E2A_,Lazy_cartesian<EK_,AK_,E2A_> >
{
//CGAL_CONSTEXPR Lazy_cartesian(){}
//CGAL_CONSTEXPR Lazy_cartesian(int d):Base_(d){}
//TODO: Do we want to store an AK and an EK? Or just references?
//FIXME: references would be better I guess.
//TODO: In any case, make sure that we don't end up storing this kernel for
//nothing (it is not empty but references empty kernels or something)
AK_ ak; EK_ ek;
AK_ const& approximate_kernel()const{return ak;}
EK_ const& exact_kernel()const{return ek;}
typedef Lazy_cartesian Self;
typedef Lazy_cartesian_types<EK_,AK_,E2A_,Self> Base;
//typedef typename Default::Get<Kernel_,Self>::type Kernel;
typedef Self Kernel;
typedef AK_ Approximate_kernel;
typedef EK_ Exact_kernel;
typedef E2A_ E2A;
typedef Approx_converter<Kernel, Approximate_kernel> C2A;
typedef Exact_converter<Kernel, Exact_kernel> C2E;
typedef typename Exact_kernel::Rep_tag Rep_tag;
typedef typename Exact_kernel::Kernel_tag Kernel_tag;
typedef typename Exact_kernel::Default_ambient_dimension Default_ambient_dimension;
typedef typename Exact_kernel::Max_ambient_dimension Max_ambient_dimension;
//typedef typename Exact_kernel::Flat_orientation Flat_orientation;
// Check that Approximate_kernel agrees with all that...
template<class T,class D=void,class=typename Get_functor_category<Lazy_cartesian,T,D>::type> struct Functor {
typedef Null_functor type;
};
//FIXME: what do we do with D here?
template<class T,class D> struct Functor<T,D,Predicate_tag> {
typedef typename Get_functor<Approximate_kernel, T>::type FA;
typedef typename Get_functor<Exact_kernel, T>::type FE;
typedef Filtered_predicate2<FE,FA,C2E,C2A> type;
};
template<class T,class D> struct Functor<T,D,Compute_tag> {
typedef typename Get_functor<Approximate_kernel, T>::type FA;
typedef typename Get_functor<Exact_kernel, T>::type FE;
typedef Lazy_construction_nt<Kernel,FA,FE> type;
};
template<class T,class D> struct Functor<T,D,Construct_tag> {
typedef typename Get_functor<Approximate_kernel, T>::type FA;
typedef typename Get_functor<Exact_kernel, T>::type FE;
typedef Lazy_construction<Kernel,FA,FE> type;
};
//typedef typename Iterator<Point_cartesian_const_iterator_tag>::type Point_cartesian_const_iterator;
//typedef typename Iterator<Vector_cartesian_const_iterator_tag>::type Vector_cartesian_const_iterator;
template<class U>
struct Construct_iter : private Store_kernel<Kernel> {
Construct_iter(){}
Construct_iter(Kernel const&k):Store_kernel<Kernel>(k){}
//FIXME: pass the kernel to the functor in the iterator
typedef U result_type;
template<class T>
result_type operator()(T const& t,Begin_tag)const{
return result_type(t,0,this->kernel());
}
template<class T>
result_type operator()(T const& t,End_tag)const{
return result_type(t,Self().dimension(),this->kernel());
}
};
template<class T,class D> struct Functor<T,D,Construct_iterator_tag> {
typedef Construct_iter<typename Base::template Iterator<typename map_result_tag<T>::type>::type> type;
};
//TODO: what about other functors of the Misc category?
// for Point_dimension, we should apply it to the approximate point
// for printing, we should??? just not do printing this way?
};
} //namespace CGAL
#endif // CGAL_KERNEL_D_LAZY_CARTESIAN_H
|
