/usr/include/CGAL/tuple.h is in libcgal-dev 4.7-4.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 | // Copyright (c) 2009 INRIA Sophia-Antipolis (France).
// All rights reserved.
//
// 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) : Sebastien Loriot, Sylvain Pion
#ifndef CGAL_TUPLE_H
#define CGAL_TUPLE_H
// A wrapper around C++0x, TR1 or Boost tuple<>.
// Together with the Is_in_tuple<> tool.
#include <CGAL/config.h>
// workaround issue in the tuple implementation of libc++
// by falling back onto boost's
#ifndef CGAL_CFG_NO_CPP0X_TUPLE
#include <cstddef>
#if defined( _LIBCPP_VERSION ) // check if libc++ is used
#define CGAL_CFG_NO_CPP0X_TUPLE
#endif
#endif
#ifndef CGAL_CFG_NO_CPP0X_TUPLE
# include <tuple>
#else
# include <boost/tuple/tuple.hpp>
# include <boost/tuple/tuple_comparison.hpp>
# include <utility>
#endif
namespace CGAL {
namespace cpp11 {
#ifndef CGAL_CFG_NO_CPP0X_TUPLE
using std::tuple;
using std::make_tuple;
using std::tie;
using std::get;
using std::tuple_size;
using std::tuple_element;
#else
using boost::tuple;
using boost::make_tuple;
using boost::tie;
using boost::get;
//tuple_size
template <class T>
struct tuple_size:public boost::tuples::length<T> {};
//tuple_element
template <int N,class T>
struct tuple_element: public boost::tuples::element<N,T>{};
#endif
#if defined(CGAL_CFG_NO_CPP0X_TUPLE)
// If not C++11 tuple, we need to add get<N>(std::pair).
////////////////////////////////////////////////////////////
// //
// Allow CGAL::cpp11::get<N>(std::pair), if N==0 or N==1. //
// //
// That is already in TR1 and C++11, but not in Boost. //
// //
////////////////////////////////////////////////////////////
template <std::size_t N, typename T1, typename T2>
struct pair_get;
template <typename T1, typename T2>
struct pair_get<0, T1, T2> {
static T1& get(std::pair<T1, T2>& pair) { return pair.first; }
static const T1& get(const std::pair<T1, T2>& pair) { return pair.first; }
}; // end specialization struct pair_get<0, T2, T2>
template <typename T1, typename T2>
struct pair_get<1, T1, T2> {
static T2& get(std::pair<T1, T2>& pair) { return pair.second; }
static const T2& get(const std::pair<T1, T2>& pair) { return pair.second; }
}; // end specialization struct pair_get<0, T2, T2>
template <std::size_t N, typename T1, typename T2>
inline typename boost::tuples::element<N, boost::tuple<T1, T2> >::type&
get(std::pair<T1, T2>& pair) {
return pair_get<N, T1, T2>::get(pair);
}
template <std::size_t N, typename T1, typename T2>
inline const typename boost::tuples::element<N, boost::tuple<T1, T2> >::type&
get(const std::pair<T1, T2>& pair) {
return pair_get<N, T1, T2>::get(pair);
}
#endif // end if not C++11 tuple
} // cpp11
namespace cpp0x = cpp11;
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
// Tool to test whether a type V is among the types of a tuple<...> = T.
template <typename V, typename T>
struct Is_in_tuple;
template <typename V, typename T0, typename... T>
struct Is_in_tuple <V, cpp11::tuple<T0, T...> >
{
static const bool value = Is_in_tuple<V, cpp11::tuple<T...> >::value;
};
template <typename V, typename... T>
struct Is_in_tuple <V, cpp11::tuple<V, T...> >
{
static const bool value = true;
};
template <typename V>
struct Is_in_tuple <V, cpp11::tuple<> >
{
static const bool value = false;
};
#else
// Non-variadic version
template <typename V,typename T>
struct Is_in_tuple;
template <typename V,typename T0,typename T1>
struct Is_in_tuple <V,cpp11::tuple<T0,T1> >
{
static const bool value = Is_in_tuple<V,cpp11::tuple<T1> >::value;
};
template <typename V, typename T0,typename T1,typename T2>
struct Is_in_tuple <V, cpp11::tuple<T0,T1,T2> >
{
static const bool value = Is_in_tuple<V,cpp11::tuple<T1,T2> >::value;
};
template <typename V, typename T0,typename T1,typename T2,typename T3>
struct Is_in_tuple <V, cpp11::tuple<T0,T1,T2,T3> >
{
static const bool value = Is_in_tuple<V,cpp11::tuple<T1,T2,T3> >::value;
};
template <typename V, typename T0,typename T1,typename T2,typename T3,typename T4>
struct Is_in_tuple <V, cpp11::tuple<T0,T1,T2,T3,T4> >
{
static const bool value = Is_in_tuple<V,cpp11::tuple<T1,T2,T3,T4> >::value;
};
template <typename V, typename T0,typename T1,typename T2,typename T3,typename T4,typename T5>
struct Is_in_tuple <V, cpp11::tuple<T0,T1,T2,T3,T4,T5> >
{
static const bool value = Is_in_tuple<V,cpp11::tuple<T1,T2,T3,T4,T5> >::value;
};
template <typename V, typename T0,typename T1,typename T2,typename T3,typename T4,typename T5,typename T6>
struct Is_in_tuple <V, cpp11::tuple<T0,T1,T2,T3,T4,T5,T6> >
{
static const bool value = Is_in_tuple<V,cpp11::tuple<T1,T2,T3,T4,T5,T6> >::value;
};
//Conclusions
template <typename V,typename T1>
struct Is_in_tuple <V,cpp11::tuple<T1> >
{
static const bool value = false;
};
template <typename V>
struct Is_in_tuple <V,cpp11::tuple<V> >
{
static const bool value = true;
};
template <typename V,typename T1>
struct Is_in_tuple <V,cpp11::tuple<V,T1> >
{
static const bool value = true;
};
template <typename V,typename T1,typename T2>
struct Is_in_tuple <V,cpp11::tuple<V,T1,T2> >
{
static const bool value = true;
};
template <typename V,typename T1,typename T2,typename T3>
struct Is_in_tuple <V,cpp11::tuple<V,T1,T2,T3> >
{
static const bool value = true;
};
template <typename V,typename T1,typename T2,typename T3,typename T4>
struct Is_in_tuple <V,cpp11::tuple<V,T1,T2,T3,T4> >
{
static const bool value = true;
};
template <typename V,typename T1,typename T2,typename T3,typename T4,typename T5>
struct Is_in_tuple <V,cpp11::tuple<V,T1,T2,T3,T4,T5> >
{
static const bool value = true;
};
template <typename V,typename T1,typename T2,typename T3,typename T4,typename T5,typename T6>
struct Is_in_tuple <V,cpp11::tuple<V,T1,T2,T3,T4,T5,T6> >
{
static const bool value = true;
};
#endif
} //namespace CGAL
#endif // CGAL_TUPLE_H
|