/usr/include/boost/hana/fwd
Edit: /usr/include/boost/hana/fwd/tuple.hpp (8554B)
/*!
@file
Forward declares `boost::hana::tuple`.
@copyright Louis Dionne 2013-2017
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_HANA_FWD_TUPLE_HPP
#define BOOST_HANA_FWD_TUPLE_HPP
#include
#include
#include
#include
#include
BOOST_HANA_NAMESPACE_BEGIN
//! @ingroup group-datatypes
//! General purpose index-based heterogeneous sequence with a fixed length.
//!
//! The tuple is the bread and butter for static metaprogramming.
//! Conceptually, it is like a `std::tuple`; it is a container able
//! of holding objects of different types and whose size is fixed at
//! compile-time. However, Hana's tuple provides much more functionality
//! than its `std` counterpart, and it is also much more efficient than
//! all standard library implementations tested so far.
//!
//! Tuples are index-based sequences. If you need an associative
//! sequence with a key-based access, then you should consider
//! `hana::map` or `hana::set` instead.
//!
//! @note
//! When you use a container, remember not to make assumptions about its
//! representation, unless the documentation gives you those guarantees.
//! More details [in the tutorial](@ref tutorial-containers-types).
//!
//!
//! Modeled concepts
//! ----------------
//! `Sequence`, and all the concepts it refines
//!
//!
//! Provided operators
//! ------------------
//! For convenience, the following operators are provided:
//! @code
//! xs == ys -> equal(xs, ys)
//! xs != ys -> not_equal(xs, ys)
//!
//! xs < ys -> less(xs, ys)
//! xs <= ys -> less_equal(xs, ys)
//! xs > ys -> greater(xs, ys)
//! xs >= ys -> greater_equal(xs, ys)
//!
//! xs | f -> chain(xs, f)
//!
//! xs[n] -> at(xs, n)
//! @endcode
//!
//!
//! Example
//! -------
//! @include example/tuple/tuple.cpp
#ifdef BOOST_HANA_DOXYGEN_INVOKED
template
struct tuple {
//! Default constructs the `tuple`. Only exists when all the elements
//! of the tuple are default constructible.
constexpr tuple();
//! Initialize each element of the tuple with the corresponding element
//! from `xn...`. Only exists when all the elements of the tuple are
//! copy-constructible.
//!
//! @note
//! Unlike the corresponding constructor for `std::tuple`, this
//! constructor is not explicit. This allows returning a tuple
//! from a function with the brace-initialization syntax.
constexpr tuple(Xn const& ...xn);
//! Initialize each element of the tuple by perfect-forwarding the
//! corresponding element in `yn...`. Only exists when all the
//! elements of the created tuple are constructible from the
//! corresponding perfect-forwarded value.
//!
//! @note
//! Unlike the corresponding constructor for `std::tuple`, this
//! constructor is not explicit. This allows returning a tuple
//! from a function with the brace-initialization syntax.
template
constexpr tuple(Yn&& ...yn);
//! Copy-initialize a tuple from another tuple. Only exists when all
//! the elements of the constructed tuple are copy-constructible from
//! the corresponding element in the source tuple.
template
constexpr tuple(tuple const& other);
//! Move-initialize a tuple from another tuple. Only exists when all
//! the elements of the constructed tuple are move-constructible from
//! the corresponding element in the source tuple.
template
constexpr tuple(tuple&& other);
//! Assign a tuple to another tuple. Only exists when all the elements
//! of the destination tuple are assignable from the corresponding
//! element in the source tuple.
template
constexpr tuple& operator=(tuple const& other);
//! Move-assign a tuple to another tuple. Only exists when all the
//! elements of the destination tuple are move-assignable from the
//! corresponding element in the source tuple.
template
constexpr tuple& operator=(tuple&& other);
//! Equivalent to `hana::chain`.
template
friend constexpr auto operator|(tuple, F);
//! Equivalent to `hana::equal`
template
friend constexpr auto operator==(X&& x, Y&& y);
//! Equivalent to `hana::not_equal`
template
friend constexpr auto operator!=(X&& x, Y&& y);
//! Equivalent to `hana::less`
template
friend constexpr auto operator<(X&& x, Y&& y);
//! Equivalent to `hana::greater`
template
friend constexpr auto operator>(X&& x, Y&& y);
//! Equivalent to `hana::less_equal`
template
friend constexpr auto operator<=(X&& x, Y&& y);
//! Equivalent to `hana::greater_equal`
template
friend constexpr auto operator>=(X&& x, Y&& y);
//! Equivalent to `hana::at`
template
constexpr decltype(auto) operator[](N&& n);
};
#else
template
struct tuple;
#endif
//! Tag representing `hana::tuple`s.
//! @related tuple
struct tuple_tag { };
#ifdef BOOST_HANA_DOXYGEN_INVOKED
//! Function object for creating a `tuple`.
//! @relates hana::tuple
//!
//! Given zero or more objects `xs...`, `make` returns a new tuple
//! containing those objects. The elements are held by value inside the
//! resulting tuple, and they are hence copied or moved in. This is
//! analogous to `std::make_tuple` for creating Hana tuples.
//!
//!
//! Example
//! -------
//! @include example/tuple/make.cpp
template <>
constexpr auto make = [](auto&& ...xs) {
return tuple...>{forwarded(xs)...};
};
#endif
//! Alias to `make`; provided for convenience.
//! @relates hana::tuple
constexpr auto make_tuple = make;
//! Equivalent to `to`; provided for convenience.
//! @relates hana::tuple
constexpr auto to_tuple = to;
//! Create a tuple specialized for holding `hana::type`s.
//! @relates hana::tuple
//!
//! This is functionally equivalent to `make(type_c...)`, except
//! that using `tuple_t` allows the library to perform some compile-time
//! optimizations. Also note that the type of the objects returned by
//! `tuple_t` and an equivalent call to `make` may differ.
//!
//!
//! Example
//! -------
//! @include example/tuple/tuple_t.cpp
#ifdef BOOST_HANA_DOXYGEN_INVOKED
template
constexpr implementation_defined tuple_t{};
#else
template
constexpr hana::tuple...> tuple_t{};
#endif
//! Create a tuple specialized for holding `hana::integral_constant`s.
//! @relates hana::tuple
//!
//! This is functionally equivalent to `make(integral_c...)`,
//! except that using `tuple_c` allows the library to perform some
//! compile-time optimizations. Also note that the type of the objects
//! returned by `tuple_c` and an equivalent call to `make` may differ.
//!
//!
//! Example
//! -------
//! @include example/tuple/tuple_c.cpp
#ifdef BOOST_HANA_DOXYGEN_INVOKED
template
constexpr implementation_defined tuple_c{};
#else
template
constexpr hana::tuple...> tuple_c{};
#endif
BOOST_HANA_NAMESPACE_END
#endif // !BOOST_HANA_FWD_TUPLE_HPP