update boost

linx64/include/boost/geometry/util/tuples.hpp

@@ -0,0 +1,389 @@
+// 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 <tuple>
+#include <type_traits>
+#include <utility>
+
+#include <boost/geometry/core/config.hpp>
+
+#include <boost/tuple/tuple.hpp>
+
+namespace boost { namespace geometry { namespace tuples
+{
+
+template <typename T>
+struct is_tuple
+    : std::integral_constant<bool, false>
+{};
+
+template <typename ...Ts>
+struct is_tuple<std::tuple<Ts...>>
+    : std::integral_constant<bool, true>
+{};
+
+template <typename F, typename S>
+struct is_tuple<std::pair<F, S>>
+    : std::integral_constant<bool, true>
+{};
+
+template <typename ...Ts>
+struct is_tuple<boost::tuples::tuple<Ts...>>
+    : std::integral_constant<bool, true>
+{};
+
+template <typename HT, typename TT>
+struct is_tuple<boost::tuples::cons<HT, TT>>
+    : std::integral_constant<bool, true>
+{};
+
+
+template <std::size_t I, typename Tuple>
+struct element;
+
+template <std::size_t I, typename ...Ts>
+struct element<I, std::tuple<Ts...>>
+    : std::tuple_element<I, std::tuple<Ts...>>
+{};
+
+template <std::size_t I, typename HT, typename TT>
+struct element<I, std::pair<HT, TT>>
+    : std::tuple_element<I, std::pair<HT, TT>>
+{};
+
+template <std::size_t I, typename ...Ts>
+struct element<I, boost::tuples::tuple<Ts...>>
+{
+    typedef typename boost::tuples::element
+        <
+            I, boost::tuples::tuple<Ts...>
+        >::type type;
+};
+
+template <std::size_t I, typename HT, typename TT>
+struct element<I, boost::tuples::cons<HT, TT>>
+{
+    typedef typename boost::tuples::element
+        <
+            I, boost::tuples::cons<HT, TT>
+        >::type type;
+};
+
+
+template <typename Tuple>
+struct size;
+
+template <typename ...Ts>
+struct size<std::tuple<Ts...>>
+    : std::tuple_size<std::tuple<Ts...>>
+{};
+
+template <typename HT, typename TT>
+struct size<std::pair<HT, TT>>
+    : std::tuple_size<std::pair<HT, TT>>
+{};
+
+template <typename ...Ts>
+struct size<boost::tuples::tuple<Ts...>>
+    : std::integral_constant
+        <
+            std::size_t,
+            boost::tuples::length<boost::tuples::tuple<Ts...>>::value
+        >
+{};
+
+template <typename HT, typename TT>
+struct size<boost::tuples::cons<HT, TT>>
+    : std::integral_constant
+        <
+            std::size_t,
+            boost::tuples::length<boost::tuples::cons<HT, TT>>::value
+        >
+{};
+
+
+template <std::size_t I, typename ...Ts>
+constexpr inline typename std::tuple_element<I, std::tuple<Ts...>>::type&
+get(std::tuple<Ts...> & t)
+{
+    return std::get<I>(t);
+}
+
+template <std::size_t I, typename ...Ts>
+constexpr inline typename std::tuple_element<I, std::tuple<Ts...>>::type const&
+get(std::tuple<Ts...> const& t)
+{
+    return std::get<I>(t);
+}
+
+template <std::size_t I, typename HT, typename TT>
+constexpr inline typename std::tuple_element<I, std::pair<HT, TT>>::type&
+get(std::pair<HT, TT> & t)
+{
+    return std::get<I>(t);
+}
+
+template <std::size_t I, typename HT, typename TT>
+constexpr inline typename std::tuple_element<I, std::pair<HT, TT>>::type const&
+get(std::pair<HT, TT> const& t)
+{
+    return std::get<I>(t);
+}
+
+template <std::size_t I, typename ...Ts>
+inline typename boost::tuples::access_traits
+    <
+        typename boost::tuples::element<I, boost::tuples::tuple<Ts...>>::type
+    >::non_const_type
+get(boost::tuples::tuple<Ts...> & t)
+{
+    return boost::tuples::get<I>(t);
+}
+
+template <std::size_t I, typename ...Ts>
+inline typename boost::tuples::access_traits
+    <
+        typename boost::tuples::element<I, boost::tuples::tuple<Ts...>>::type
+    >::const_type
+get(boost::tuples::tuple<Ts...> const& t)
+{
+    return boost::tuples::get<I>(t);
+}
+
+
+template <std::size_t 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<I>(tup);
+}
+
+template <std::size_t 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<I>(tup);
+}
+
+
+
+// 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,
+    std::size_t I = 0,
+    std::size_t N = size<Tuple>::value
+>
+struct find_index_if
+    : std::conditional_t
+        <
+            UnaryPred<typename element<I, Tuple>::type>::value,
+            std::integral_constant<std::size_t, I>,
+            typename find_index_if<Tuple, UnaryPred, I+1, N>::type
+        >
+{};
+
+template
+<
+    typename Tuple,
+    template <typename> class UnaryPred,
+    std::size_t N
+>
+struct find_index_if<Tuple, UnaryPred, N, N>
+    : std::integral_constant<std::size_t, N>
+{};
+
+
+// find_if
+// Searches for an element for which UnaryPredicate returns true
+// If such element is not found the result is detail::null_type
+
+namespace detail
+{
+
+struct null_type {};
+
+} // detail
+
+template
+<
+    typename Tuple,
+    template <typename> class UnaryPred,
+    std::size_t I = 0,
+    std::size_t N = size<Tuple>::value
+>
+struct find_if
+    : std::conditional_t
+        <
+            UnaryPred<typename element<I, Tuple>::type>::value,
+            element<I, Tuple>,
+            find_if<Tuple, UnaryPred, I+1, N>
+        >
+{};
+
+template
+<
+    typename Tuple,
+    template <typename> class UnaryPred,
+    std::size_t N
+>
+struct find_if<Tuple, UnaryPred, N, N>
+{
+    typedef detail::null_type type;
+};
+
+
+// is_found
+// Returns true if a type T (the result of find_if) was found.
+
+template <typename T>
+struct is_found
+    : std::integral_constant
+        <
+            bool,
+            ! std::is_same<T, detail::null_type>::value
+        >
+{};
+
+
+// is_not_found
+// Returns true if a type T (the result of find_if) was not found.
+
+template <typename T>
+struct is_not_found
+    : std::is_same<T, detail::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,
+          std::size_t I = 0,
+          std::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<I>(tup),
+            push_back_bt<Tuple, T, I+1, N>::apply(tup, t)
+        );
+    }
+};
+
+template <typename Tuple, typename T, std::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>
+{
+    typedef std::tuple<F, S, T> type;
+
+    static type apply(std::pair<F, S> const& p, T const& t)
+    {
+        return type(p.first, p.second, t);
+    }
+
+    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));
+    }
+};
+
+template <typename Is, typename Tuple, typename T>
+struct push_back_st;
+
+template <std::size_t ...Is, typename ...Ts, typename T>
+struct push_back_st<std::index_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);
+    }
+
+    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));
+    }
+};
+
+template <typename ...Ts, typename T>
+struct push_back<std::tuple<Ts...>, T>
+    : push_back_st
+        <
+            std::make_index_sequence<sizeof...(Ts)>,
+            std::tuple<Ts...>,
+            T
+        >
+{};
+
+
+}}} // namespace boost::geometry::tuples
+
+#endif // BOOST_GEOMETRY_UTIL_TUPLES_HPP