1   
//
1   
//
2   
// Copyright (c) 2016-2019 Damian Jarek (damian dot jarek93 at gmail dot com)
2   
// Copyright (c) 2016-2019 Damian Jarek (damian dot jarek93 at gmail dot com)
3   
// Copyright (c) 2022 Vinnie Falco (vinnie dot falco at gmail dot com)
3   
// Copyright (c) 2022 Vinnie Falco (vinnie dot falco at gmail dot com)
4   
//
4   
//
5   
// Distributed under the Boost Software License, Version 1.0. (See accompanying
5   
// Distributed under the Boost Software License, Version 1.0. (See accompanying
6   
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6   
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7   
//
7   
//
8   
// Official repository: https://github.com/boostorg/beast
8   
// Official repository: https://github.com/boostorg/beast
9   
//
9   
//
10  
10  
11   
#ifndef BOOST_URL_GRAMMAR_DETAIL_TUPLE_HPP
11   
#ifndef BOOST_URL_GRAMMAR_DETAIL_TUPLE_HPP
12   
#define BOOST_URL_GRAMMAR_DETAIL_TUPLE_HPP
12   
#define BOOST_URL_GRAMMAR_DETAIL_TUPLE_HPP
13  
13  
14   
#include <boost/url/detail/config.hpp>
14   
#include <boost/url/detail/config.hpp>
15   
#include <boost/url/error_types.hpp>
15   
#include <boost/url/error_types.hpp>
16   
#include <boost/core/empty_value.hpp>
16   
#include <boost/core/empty_value.hpp>
17   
#include <boost/mp11/algorithm.hpp>
17   
#include <boost/mp11/algorithm.hpp>
18   
#include <boost/mp11/function.hpp>
18   
#include <boost/mp11/function.hpp>
19   
#include <boost/mp11/integer_sequence.hpp>
19   
#include <boost/mp11/integer_sequence.hpp>
20   
#include <boost/type_traits/remove_cv.hpp>
20   
#include <boost/type_traits/remove_cv.hpp>
21   
#include <boost/type_traits/copy_cv.hpp>
21   
#include <boost/type_traits/copy_cv.hpp>
22   
#include <cstdlib>
22   
#include <cstdlib>
23   
#include <utility>
23   
#include <utility>
24  
24  
25   
#ifndef BOOST_URL_TUPLE_EBO
25   
#ifndef BOOST_URL_TUPLE_EBO
26   
// VFALCO No idea what causes it or how to fix it
26   
// VFALCO No idea what causes it or how to fix it
27   
// https://devblogs.microsoft.com/cppblog/optimizing-the-layout-of-empty-base-classes-in-vs2015-update-2-3/
27   
// https://devblogs.microsoft.com/cppblog/optimizing-the-layout-of-empty-base-classes-in-vs2015-update-2-3/
28   
#ifdef BOOST_MSVC
28   
#ifdef BOOST_MSVC
29   
#define BOOST_URL_TUPLE_EBO 0
29   
#define BOOST_URL_TUPLE_EBO 0
30   
#else
30   
#else
31   
#define BOOST_URL_TUPLE_EBO 1
31   
#define BOOST_URL_TUPLE_EBO 1
32   
#endif
32   
#endif
33   
#endif
33   
#endif
34  
34  
35   
namespace boost {
35   
namespace boost {
36   
namespace urls {
36   
namespace urls {
37   
namespace grammar {
37   
namespace grammar {
38   
namespace detail {
38   
namespace detail {
39  
39  
40   
#if BOOST_URL_TUPLE_EBO
40   
#if BOOST_URL_TUPLE_EBO
41   
template<std::size_t I, class T>
41   
template<std::size_t I, class T>
42   
struct tuple_element_impl
42   
struct tuple_element_impl
43   
    : empty_value<T>
43   
    : empty_value<T>
44   
{
44   
{
45   
    constexpr
45   
    constexpr
46   
    tuple_element_impl(T const& t)
46   
    tuple_element_impl(T const& t)
47   
        : empty_value<T>(
47   
        : empty_value<T>(
48   
            empty_init, t)
48   
            empty_init, t)
49   
    {
49   
    {
50   
    }
50   
    }
51  
51  
52   
    constexpr
52   
    constexpr
53   
    tuple_element_impl(T&& t)
53   
    tuple_element_impl(T&& t)
54   
        : empty_value<T>(
54   
        : empty_value<T>(
55   
            empty_init,
55   
            empty_init,
56   
                std::move(t))
56   
                std::move(t))
57   
    {
57   
    {
58   
    }
58   
    }
59   
};
59   
};
60   
#else
60   
#else
61   
template<std::size_t I, class T>
61   
template<std::size_t I, class T>
62   
struct tuple_element_impl
62   
struct tuple_element_impl
63   
{
63   
{
64   
    T t_;
64   
    T t_;
65  
65  
66   
    constexpr
66   
    constexpr
67   
    tuple_element_impl(T const& t)
67   
    tuple_element_impl(T const& t)
68   
        : t_(t)
68   
        : t_(t)
69   
    {
69   
    {
70   
    }
70   
    }
71  
71  
72   
    constexpr
72   
    constexpr
73   
    tuple_element_impl(T&& t)
73   
    tuple_element_impl(T&& t)
74   
        : t_(std::move(t))
74   
        : t_(std::move(t))
75   
    {
75   
    {
76   
    }
76   
    }
77  
77  
78   
    constexpr
78   
    constexpr
79   
    T&
79   
    T&
80   
    get() noexcept
80   
    get() noexcept
81   
    {
81   
    {
82   
        return t_;
82   
        return t_;
83   
    }
83   
    }
84  
84  
85   
    constexpr
85   
    constexpr
86   
    T const&
86   
    T const&
87   
    get() const noexcept
87   
    get() const noexcept
88   
    {
88   
    {
89   
        return t_;
89   
        return t_;
90   
    }
90   
    }
91   
};
91   
};
92   
#endif
92   
#endif
93  
93  
94   
template<std::size_t I, class T>
94   
template<std::size_t I, class T>
95   
struct tuple_element_impl<I, T&>
95   
struct tuple_element_impl<I, T&>
96   
{
96   
{
97   
    T& t;
97   
    T& t;
98  
98  
99   
    constexpr
99   
    constexpr
100   
    tuple_element_impl(T& t_)
100   
    tuple_element_impl(T& t_)
101   
        : t(t_)
101   
        : t(t_)
102   
    {
102   
    {
103   
    }
103   
    }
104  
104  
105   
    T&
105   
    T&
106   
    get() const noexcept
106   
    get() const noexcept
107   
    {
107   
    {
108   
        return t;
108   
        return t;
109   
    }
109   
    }
110   
};
110   
};
111  
111  
112   
template<class... Ts>
112   
template<class... Ts>
113   
struct tuple_impl;
113   
struct tuple_impl;
114  
114  
115   
template<class... Ts, std::size_t... Is>
115   
template<class... Ts, std::size_t... Is>
116   
struct tuple_impl<
116   
struct tuple_impl<
117   
    mp11::index_sequence<Is...>, Ts...>
117   
    mp11::index_sequence<Is...>, Ts...>
118   
  : tuple_element_impl<Is, Ts>...
118   
  : tuple_element_impl<Is, Ts>...
119   
{
119   
{
120   
    template<class... Us>
120   
    template<class... Us>
121   
    constexpr
121   
    constexpr
122   
    explicit
122   
    explicit
123   
    tuple_impl(Us&&... us)
123   
    tuple_impl(Us&&... us)
124   
        : tuple_element_impl<Is, Ts>(
124   
        : tuple_element_impl<Is, Ts>(
125   
            std::forward<Us>(us))...
125   
            std::forward<Us>(us))...
126   
    {
126   
    {
127   
    }
127   
    }
128   
};
128   
};
129  
129  
130   
template<class... Ts>
130   
template<class... Ts>
131   
struct tuple
131   
struct tuple
132   
    : tuple_impl<
132   
    : tuple_impl<
133   
        mp11::index_sequence_for<Ts...>, Ts...>
133   
        mp11::index_sequence_for<Ts...>, Ts...>
134   
{
134   
{
135   
    template<class... Us,
135   
    template<class... Us,
136   
        typename std::enable_if<
136   
        typename std::enable_if<
137   
            mp11::mp_bool<
137   
            mp11::mp_bool<
138   
                mp11::mp_all<std::is_constructible<
138   
                mp11::mp_all<std::is_constructible<
139   
                    Ts, Us>...>::value &&
139   
                    Ts, Us>...>::value &&
140   
                ! mp11::mp_all<std::is_convertible<
140   
                ! mp11::mp_all<std::is_convertible<
141   
                    Us, Ts>...>::value>::value,
141   
                    Us, Ts>...>::value>::value,
142   
            int>::type = 0
142   
            int>::type = 0
143   
    >
143   
    >
144   
    constexpr
144   
    constexpr
145   
    explicit
145   
    explicit
146   
    tuple(Us&&... us) noexcept
146   
    tuple(Us&&... us) noexcept
147   
      : tuple_impl<mp11::index_sequence_for<
147   
      : tuple_impl<mp11::index_sequence_for<
148   
            Ts...>, Ts...>{std::forward<Us>(us)...}
148   
            Ts...>, Ts...>{std::forward<Us>(us)...}
149   
    {
149   
    {
150   
    }
150   
    }
151  
151  
152   
    template<class... Us,
152   
    template<class... Us,
153   
        typename std::enable_if<
153   
        typename std::enable_if<
154   
            mp11::mp_all<std::is_convertible<
154   
            mp11::mp_all<std::is_convertible<
155   
                Us, Ts>...>::value,
155   
                Us, Ts>...>::value,
156   
            int>::type = 0
156   
            int>::type = 0
157   
    >
157   
    >
158   
    constexpr
158   
    constexpr
159   
    tuple(Us&&... us) noexcept
159   
    tuple(Us&&... us) noexcept
160   
      : tuple_impl<mp11::index_sequence_for<
160   
      : tuple_impl<mp11::index_sequence_for<
161   
            Ts...>, Ts...>{std::forward<Us>(us)...}
161   
            Ts...>, Ts...>{std::forward<Us>(us)...}
162   
    {
162   
    {
163   
    }
163   
    }
164   
};
164   
};
165  
165  
166   
//------------------------------------------------
166   
//------------------------------------------------
167  
167  
168   
template<std::size_t I, class T>
168   
template<std::size_t I, class T>
169   
constexpr
169   
constexpr
170   
T&
170   
T&
171   
get(tuple_element_impl<I, T>& te)
171   
get(tuple_element_impl<I, T>& te)
172   
{
172   
{
173   
    return te.get();
173   
    return te.get();
174   
}
174   
}
175  
175  
176   
template<std::size_t I, class T>
176   
template<std::size_t I, class T>
177   
constexpr
177   
constexpr
178   
T const&
178   
T const&
179   
get(tuple_element_impl<I, T> const& te)
179   
get(tuple_element_impl<I, T> const& te)
180   
{
180   
{
181   
    return te.get();
181   
    return te.get();
182   
}
182   
}
183  
183  
184   
template<std::size_t I, class T>
184   
template<std::size_t I, class T>
185   
constexpr
185   
constexpr
186   
T&&
186   
T&&
187   
get(tuple_element_impl<I, T>&& te)
187   
get(tuple_element_impl<I, T>&& te)
188   
{
188   
{
189   
    return std::move(te.get());
189   
    return std::move(te.get());
190   
}
190   
}
191  
191  
192   
template<std::size_t I, class T>
192   
template<std::size_t I, class T>
193   
constexpr
193   
constexpr
194   
T&
194   
T&
195   
get(tuple_element_impl<I, T&>&& te)
195   
get(tuple_element_impl<I, T&>&& te)
196   
{
196   
{
197   
    return te.get();
197   
    return te.get();
198   
}
198   
}
199  
199  
200   
template<std::size_t I, class T>
200   
template<std::size_t I, class T>
201   
using tuple_element =
201   
using tuple_element =
202   
    typename boost::copy_cv<
202   
    typename boost::copy_cv<
203   
        mp11::mp_at_c<typename
203   
        mp11::mp_at_c<typename
204   
            remove_cv<T>::type,
204   
            remove_cv<T>::type,
205   
            I>, T>::type;
205   
            I>, T>::type;
206  
206  
207   
} // detail
207   
} // detail
208   
} // grammar
208   
} // grammar
209   
} // urls
209   
} // urls
210   
} // boost
210   
} // boost
211  
211  
212   
#endif
212   
#endif