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
|
// Copyright (c) 2014
// INRIA Saclay-Ile de France (France)
//
// This file is part of CGAL (www.cgal.org)
//
// $URL: https://github.com/CGAL/cgal/blob/v6.1.1/NewKernel_d/include/CGAL/NewKernel_d/Vector/vector.h $
// $Id: include/CGAL/NewKernel_d/Vector/vector.h 08b27d3db14 $
// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial
//
// Author(s) : Marc Glisse
#ifndef CGAL_VECTOR_VECTOR_H
#define CGAL_VECTOR_VECTOR_H
#include <boost/type_traits/is_arithmetic.hpp>
#include <CGAL/Dimension.h>
#include <CGAL/NewKernel_d/utils.h>
#include <vector>
#include <boost/preprocessor/repetition.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
namespace CGAL {
//Derive from a class that doesn't depend on Dim, or still use Dim for checking?
template<class NT_,class Dim_,class Max_dim_=Dim_> struct Vector_vector {
typedef NT_ NT;
typedef Dim_ Dimension;
typedef Max_dim_ Max_dimension;
typedef std::vector<NT> Vector;
template< class D2, class D3=D2 >
struct Rebind_dimension {
typedef Vector_vector< NT, D2, D3 > Other;
};
template<class> struct Property : std::false_type {};
struct Construct_vector {
struct Dimension {
Vector operator()(int d) const {
return Vector(d);
}
};
struct Iterator {
template<typename Iter>
Vector operator()(int CGAL_assertion_code(d),Iter const& f,Iter const& e) const {
CGAL_assertion(d==std::distance(f,e));
return Vector(f,e);
}
};
// unneeded thanks to Iterator_and_last?
#if 0
struct Iterator_add_one {
template<typename Iter>
Vector operator()(int CGAL_assertion_code(d),Iter const& f,Iter const& e) const {
CGAL_assertion(d==std::distance(f,e)+1);
Vector a;
a.reserve(d+1);
a.insert(a.end(),f,e);
a.push_back(1);
return a;
}
};
#endif
struct Iterator_and_last {
template<typename Iter,typename T>
Vector operator()(int d,Iter const& f,Iter const& e,T&& t) const {
CGAL_assertion(d==std::distance(f,e)+1);
Vector a;
a.reserve(d+1);
a.insert(a.end(),f,e);
a.push_back(std::forward<T>(t));
return a;
}
};
// useless, use a transform_iterator?
#if 0
struct Iterator_and_last_divide {
template<typename Iter,typename T>
Vector operator()(int d,Iter f,Iter const& e,T const&t) const {
CGAL_assertion(d==std::distance(f,e)+1);
Vector a;
a.reserve(d+1);
for(;f!=e;++f){
a.push_back(*f/t);
}
return a;
}
};
#endif
struct Values {
template<class...U>
Vector operator()(U&&...u) const {
//TODO: check the right number of {}, g++ accepts one and two
Vector a={forward_safe<NT,U>(u)...};
return a;
}
};
struct Values_divide {
template<class H,class...U>
Vector operator()(H const&h,U&&...u) const {
//TODO: do we want to cast at some point?
//e.g. to avoid 1/2 in integers
// ==> use Rational_traits<NT>().make_rational(x,y) ?
Vector a={Rational_traits<NT>().make_rational(std::forward<U>(u),h)...};
return a;
}
};
};
typedef typename Vector::const_iterator Vector_const_iterator;
static Vector_const_iterator vector_begin(Vector const&a){
return a.begin();
}
static Vector_const_iterator vector_end(Vector const&a){
return a.end();
}
static int size_of_vector(Vector const&a){
return (int)a.size();
}
};
}
#endif
|
