FM / util

/usr/include/boost/geometry/util

Name	Size	Mode	Actions
add_const_if_c.hpp	1677	0644	edit dl rm
bare_type.hpp	1330	0644	edit dl rm
calculation_type.hpp	4873	0644	edit dl rm
closure_as_bool.hpp	1080	0644	edit dl rm
combine_if.hpp	2927	0644	edit dl rm
compress_variant.hpp	3098	0644	edit dl rm
condition.hpp	1346	0644	edit dl rm
coordinate_cast.hpp	1530	0644	edit dl rm
for_each_coordinate.hpp	2627	0644	edit dl rm
has_infinite_coordinate.hpp	1376	0644	edit dl rm
has_nan_coordinate.hpp	2375	0644	edit dl rm
has_non_finite_coordinate.hpp	1405	0644	edit dl rm
is_inverse_spheroidal_coordinates.hpp	1553	0644	edit dl rm
math.hpp	21972	0644	edit dl rm
normalize_spheroidal_box_coordinates.hpp	7317	0644	edit dl rm
normalize_spheroidal_coordinates.hpp	14416	0644	edit dl rm
order_as_direction.hpp	1211	0644	edit dl rm
parameter_type_of.hpp	2156	0644	edit dl rm
promote_floating_point.hpp	1356	0644	edit dl rm
promote_integral.hpp	9775	0644	edit dl rm
range.hpp	12445	0644	edit dl rm
rational.hpp	4580	0644	edit dl rm
select_calculation_type.hpp	2532	0644	edit dl rm
select_coordinate_type.hpp	2003	0644	edit dl rm
select_most_precise.hpp	5459	0644	edit dl rm
select_sequence_element.hpp	2052	0644	edit dl rm
series_expansion.hpp	25670	0644	edit dl rm
transform_variant.hpp	2735	0644	edit dl rm
tuples.hpp	8819	0644	edit dl rm

Edit: /usr/include/boost/geometry/util/tuples.hpp (8819B)

#ifndef BOOST_GEOMETRY_UTIL_TUPLES_HPP
#define BOOST_GEOMETRY_UTIL_TUPLES_HPP

#include <boost/geometry/core/config.hpp>

#include <boost/mpl/if.hpp>
#include <boost/mpl/not.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/is_same.hpp>

#include <utility>

#ifdef BOOST_GEOMETRY_CXX11_TUPLE

#include <tuple>

#endif // BOOST_GEOMETRY_CXX11_TUPLE

namespace boost { namespace geometry { namespace tuples {

using boost::tuples::null_type;

template <int I, typename Tuple>
struct element
 : boost::tuples::element<I, Tuple>
{};

template <typename Tuple>
struct size
 : boost::tuples::length<Tuple>
{};

template <int I, typename HT, typename TT>
inline typename boost::tuples::access_traits
 <
 typename boost::tuples::element<I, boost::tuples::cons<HT, TT> >::type
 >::non_const_type
get(boost::tuples::cons<HT, TT> & tup)
{
 return boost::tuples::get(tup);
}

template <int I, typename HT, typename TT>
inline typename boost::tuples::access_traits
 <
 typename boost::tuples::element<I, boost::tuples::cons<HT, TT> >::type
 >::const_type
get(boost::tuples::cons<HT, TT> const& tup)
{
 return boost::tuples::get(tup);
}

template <int I, typename F, typename S>
struct element<I, std::pair<F, S> >
{};

template <typename F, typename S>
struct element<0, std::pair<F, S> >
{
 typedef F type;
};

template <typename F, typename S>
struct element<1, std::pair<F, S> >
{
 typedef S type;
};

template <typename F, typename S>
struct size<std::pair<F, S> >
 : boost::integral_constant<int, 2>
{};

template <int I, typename Pair>
struct get_pair;

template <typename F, typename S>
struct get_pair<0, std::pair<F, S> >
{
 typedef F type;

static inline F& apply(std::pair<F, S> & p)
 {
 return p.first;
 }

static inline F const& apply(std::pair<F, S> const& p)
 {
 return p.first;
 }
};

template <typename F, typename S>
struct get_pair<1, std::pair<F, S> >
{
 typedef S type;

static inline S& apply(std::pair<F, S> & p)
 {
 return p.second;
 }

static inline S const& apply(std::pair<F, S> const& p)
 {
 return p.second;
 }
};

template <int I, typename F, typename S>
inline typename get_pair<I, std::pair<F, S> >::type&
get(std::pair<F, S> & p)
{
 return get_pair<I, std::pair<F, S> >::apply(p);
}

template <int I, typename F, typename S>
inline typename get_pair<I, std::pair<F, S> >::type const&
get(std::pair<F, S> const& p)
{
 return get_pair<I, std::pair<F, S> >::apply(p);
}

#ifdef BOOST_GEOMETRY_CXX11_TUPLE

template <int I, typename ...Ts>
struct element<I, std::tuple<Ts...> >
 : std::tuple_element<I, std::tuple<Ts...> >
{};

template <typename ...Ts>
struct size<std::tuple<Ts...> >
 : std::tuple_size<std::tuple<Ts...> >
{};

template <int I, typename ...Ts>
inline typename std::tuple_element<I, std::tuple<Ts...> >::type&
get(std::tuple<Ts...> & tup)
{
 return std::get(tup);
}

template <int I, typename ...Ts>
inline typename std::tuple_element<I, std::tuple<Ts...> >::type const&
get(std::tuple<Ts...> const& tup)
{
 return std::get(tup);
}

#endif // BOOST_GEOMETRY_CXX11_TUPLE

// find_index_if
// Searches for the index of an element for which UnaryPredicate returns true
// If such element is not found the result is N

template
<
 typename Tuple,
 template <typename> class UnaryPred,
 int I = 0,
 int N = size<Tuple>::value
>
struct find_index_if
 : boost::mpl::if_c
 <
 UnaryPred<typename element<I, Tuple>::type>::value,
 boost::integral_constant<int, I>,
 typename find_index_if<Tuple, UnaryPred, I+1, N>::type
 >::type
{};

template
<
 typename Tuple,
 template <typename> class UnaryPred,
 int N
>
struct find_index_if<Tuple, UnaryPred, N, N>
 : boost::integral_constant<int, N>
{};

// find_if
// Searches for an element for which UnaryPredicate returns true
// If such element is not found the result is boost::tuples::null_type

template
<
 typename Tuple,
 template <typename> class UnaryPred,
 int I = 0,
 int N = size<Tuple>::value
>
struct find_if
 : boost::mpl::if_c
 <
 UnaryPred<typename element<I, Tuple>::type>::value,
 element<I, Tuple>,
 find_if<Tuple, UnaryPred, I+1, N>
 >::type
{};

template
<
 typename Tuple,
 template <typename> class UnaryPred,
 int N
>
struct find_if<Tuple, UnaryPred, N, N>
{
 typedef boost::tuples::null_type type;
};

// is_found
// Returns true if a type T (the result of find_if) was found.

template <typename T>
struct is_found
 : boost::mpl::not_<boost::is_same<T, boost::tuples::null_type> >
{};

// is_not_found
// Returns true if a type T (the result of find_if) was not found.

template <typename T>
struct is_not_found
 : boost::is_same<T, boost::tuples::null_type>
{};

// exists_if
// Returns true if search for element meeting UnaryPred can be found.

template <typename Tuple, template <typename> class UnaryPred>
struct exists_if
 : is_found<typename find_if<Tuple, UnaryPred>::type>
{};

// push_back
// A utility used to create a type/object of a Tuple containing
//   all types/objects stored in another Tuple plus additional one.

template <typename Tuple,
 typename T,
 size_t I = 0,
 size_t N = size<Tuple>::value>
struct push_back_bt
{
 typedef
 boost::tuples::cons<
 typename element<I, Tuple>::type,
 typename push_back_bt<Tuple, T, I+1, N>::type
 > type;

static type apply(Tuple const& tup, T const& t)
 {
 return
 type(
 geometry::tuples::get(tup),
 push_back_bt<Tuple, T, I+1, N>::apply(tup, t)
 );
 }
};

template <typename Tuple, typename T, size_t N>
struct push_back_bt<Tuple, T, N, N>
{
 typedef boost::tuples::cons<T, boost::tuples::null_type> type;

static type apply(Tuple const&, T const& t)
    {
        return type(t, boost::tuples::null_type());
    }
};

template <typename Tuple, typename T>
struct push_back
 : push_back_bt<Tuple, T>
{};

template <typename F, typename S, typename T>
struct push_back<std::pair<F, S>, T>
{
#ifdef BOOST_GEOMETRY_CXX11_TUPLE
 typedef std::tuple<F, S, T> type;
#else
 typedef boost::tuple<F, S, T> type;
#endif // BOOST_GEOMETRY_CXX11_TUPLE

static type apply(std::pair<F, S> const& p, T const& t)
 {
 return type(p.first, p.second, t);
 }

#ifdef BOOST_GEOMETRY_CXX11_TUPLE
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)

static type apply(std::pair<F, S> && p, T const& t)
 {
 return type(std::move(p.first), std::move(p.second), t);
 }

static type apply(std::pair<F, S> && p, T && t)
 {
 return type(std::move(p.first), std::move(p.second), std::move(t));
 }

#endif
#endif // BOOST_GEOMETRY_CXX11_TUPLE

};

#ifdef BOOST_GEOMETRY_CXX11_TUPLE

// NOTE: In C++14 std::integer_sequence and std::make_integer_sequence could be used

template <int... Is>
struct int_sequence {};

template <int N, int ...Is>
struct make_int_sequence
{
 typedef typename make_int_sequence<N - 1, N - 1, Is...>::type type;
};

template <int ...Is>
struct make_int_sequence<0, Is...>
{
 typedef int_sequence<Is...> type;
};

template <typename Is, typename Tuple, typename T>
struct push_back_st;

template <int ...Is, typename ...Ts, typename T>
struct push_back_st<int_sequence<Is...>, std::tuple<Ts...>, T>
{
 typedef std::tuple<Ts..., T> type;

static type apply(std::tuple<Ts...> const& tup, T const& t)
 {
 return type(std::get<Is>(tup)..., t);
 }

#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)

static type apply(std::tuple<Ts...> && tup, T const& t)
 {
 return type(std::move(std::get<Is>(tup))..., t);
 }

static type apply(std::tuple<Ts...> && tup, T && t)
 {
 return type(std::move(std::get<Is>(tup))..., std::move(t));
 }

#endif
};

template <typename ...Ts, typename T>
struct push_back<std::tuple<Ts...>, T>
 : push_back_st
 <
 typename make_int_sequence<sizeof...(Ts)>::type,
 std::tuple<Ts...>,
 T
 >
{};

#endif // BOOST_GEOMETRY_CXX11_TUPLE

}}} // namespace boost::geometry::tuples

#endif // BOOST_GEOMETRY_UTIL_TUPLES_HPP

// Boost.Geometry Index // // Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland. // // This file was modified by Oracle on 2019, 2020. // Modifications copyright (c) 2019-2020 Oracle and/or its affiliates. // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle // // Use, modification and distribution is subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_GEOMETRY_UTIL_TUPLES_HPP #define BOOST_GEOMETRY_UTIL_TUPLES_HPP #include #include #include #include #include #include #include #ifdef BOOST_GEOMETRY_CXX11_TUPLE #include #endif // BOOST_GEOMETRY_CXX11_TUPLE namespace boost { namespace geometry { namespace tuples { using boost::tuples::null_type; template struct element : boost::tuples::element {}; template struct size : boost::tuples::length {}; template inline typename boost::tuples::access_traits < typename boost::tuples::element >::type >::non_const_type get(boost::tuples::cons & tup) { return boost::tuples::get(tup); } template inline typename boost::tuples::access_traits < typename boost::tuples::element >::type >::const_type get(boost::tuples::cons const& tup) { return boost::tuples::get(tup); } template struct element > {}; template struct element<0, std::pair > { typedef F type; }; template struct element<1, std::pair > { typedef S type; }; template struct size > : boost::integral_constant {}; template struct get_pair; template struct get_pair<0, std::pair > { typedef F type; static inline F& apply(std::pair & p) { return p.first; } static inline F const& apply(std::pair const& p) { return p.first; } }; template struct get_pair<1, std::pair > { typedef S type; static inline S& apply(std::pair & p) { return p.second; } static inline S const& apply(std::pair const& p) { return p.second; } }; template inline typename get_pair >::type& get(std::pair & p) { return get_pair >::apply(p); } template inline typename get_pair >::type const& get(std::pair const& p) { return get_pair >::apply(p); } #ifdef BOOST_GEOMETRY_CXX11_TUPLE template struct element > : std::tuple_element > {}; template struct size > : std::tuple_size > {}; template inline typename std::tuple_element >::type& get(std::tuple & tup) { return std::get(tup); } template inline typename std::tuple_element >::type const& get(std::tuple const& tup) { return std::get(tup); } #endif // BOOST_GEOMETRY_CXX11_TUPLE // find_index_if // Searches for the index of an element for which UnaryPredicate returns true // If such element is not found the result is N template < typename Tuple, template class UnaryPred, int I = 0, int N = size::value > struct find_index_if : boost::mpl::if_c < UnaryPred::type>::value, boost::integral_constant, typename find_index_if::type >::type {}; template < typename Tuple, template class UnaryPred, int N > struct find_index_if : boost::integral_constant {}; // find_if // Searches for an element for which UnaryPredicate returns true // If such element is not found the result is boost::tuples::null_type template < typename Tuple, template class UnaryPred, int I = 0, int N = size::value > struct find_if : boost::mpl::if_c < UnaryPred::type>::value, element, find_if >::type {}; template < typename Tuple, template class UnaryPred, int N > struct find_if { typedef boost::tuples::null_type type; }; // is_found // Returns true if a type T (the result of find_if) was found. template struct is_found : boost::mpl::not_ > {}; // is_not_found // Returns true if a type T (the result of find_if) was not found. template struct is_not_found : boost::is_same {}; // exists_if // Returns true if search for element meeting UnaryPred can be found. template class UnaryPred> struct exists_if : is_found::type> {}; // push_back // A utility used to create a type/object of a Tuple containing // all types/objects stored in another Tuple plus additional one. template ::value> struct push_back_bt { typedef boost::tuples::cons< typename element::type, typename push_back_bt::type > type; static type apply(Tuple const& tup, T const& t) { return type( geometry::tuples::get(tup), push_back_bt::apply(tup, t) ); } }; template struct push_back_bt { typedef boost::tuples::cons type; static type apply(Tuple const&, T const& t) { return type(t, boost::tuples::null_type()); } }; template struct push_back : push_back_bt {}; template struct push_back, T> { #ifdef BOOST_GEOMETRY_CXX11_TUPLE typedef std::tuple type; #else typedef boost::tuple type; #endif // BOOST_GEOMETRY_CXX11_TUPLE static type apply(std::pair const& p, T const& t) { return type(p.first, p.second, t); } #ifdef BOOST_GEOMETRY_CXX11_TUPLE #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) static type apply(std::pair && p, T const& t) { return type(std::move(p.first), std::move(p.second), t); } static type apply(std::pair && p, T && t) { return type(std::move(p.first), std::move(p.second), std::move(t)); } #endif #endif // BOOST_GEOMETRY_CXX11_TUPLE }; #ifdef BOOST_GEOMETRY_CXX11_TUPLE // NOTE: In C++14 std::integer_sequence and std::make_integer_sequence could be used template struct int_sequence {}; template struct make_int_sequence { typedef typename make_int_sequence::type type; }; template struct make_int_sequence<0, Is...> { typedef int_sequence type; }; template struct push_back_st; template struct push_back_st, std::tuple, T> { typedef std::tuple type; static type apply(std::tuple const& tup, T const& t) { return type(std::get(tup)..., t); } #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) static type apply(std::tuple && tup, T const& t) { return type(std::move(std::get(tup))..., t); } static type apply(std::tuple && tup, T && t) { return type(std::move(std::get(tup))..., std::move(t)); } #endif }; template struct push_back, T> : push_back_st < typename make_int_sequence::type, std::tuple, T > {}; #endif // BOOST_GEOMETRY_CXX11_TUPLE }}} // namespace boost::geometry::tuples #endif // BOOST_GEOMETRY_UTIL_TUPLES_HPP