EIC code displayed by LXR master/​include/​boost/​hana/​fwd/​tuple.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-12-15 09:53:05

 /*!
 @file
 Forward declares `boost::hana::tuple`.
 
 Copyright Louis Dionne 2013-2022
 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 <boost/hana/config.hpp>
 #include <boost/hana/fwd/core/make.hpp>
 #include <boost/hana/fwd/core/to.hpp>
 #include <boost/hana/fwd/integral_constant.hpp>
 #include <boost/hana/fwd/type.hpp>
 
 
 namespace boost { namespace hana {
     //! @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 <typename ...Xn>
     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 <typename ...Yn>
         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 <typename ...Yn>
         constexpr tuple(tuple<Yn...> 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 <typename ...Yn>
         constexpr tuple(tuple<Yn...>&& 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 <typename ...Yn>
         constexpr tuple& operator=(tuple<Yn...> 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 <typename ...Yn>
         constexpr tuple& operator=(tuple<Yn...>&& other);
 
         //! Equivalent to `hana::chain`.
         template <typename ...T, typename F>
         friend constexpr auto operator|(tuple<T...>, F);
 
         //! Equivalent to `hana::equal`
         template <typename X, typename Y>
         friend constexpr auto operator==(X&& x, Y&& y);
 
         //! Equivalent to `hana::not_equal`
         template <typename X, typename Y>
         friend constexpr auto operator!=(X&& x, Y&& y);
 
         //! Equivalent to `hana::less`
         template <typename X, typename Y>
         friend constexpr auto operator<(X&& x, Y&& y);
 
         //! Equivalent to `hana::greater`
         template <typename X, typename Y>
         friend constexpr auto operator>(X&& x, Y&& y);
 
         //! Equivalent to `hana::less_equal`
         template <typename X, typename Y>
         friend constexpr auto operator<=(X&& x, Y&& y);
 
         //! Equivalent to `hana::greater_equal`
         template <typename X, typename Y>
         friend constexpr auto operator>=(X&& x, Y&& y);
 
         //! Equivalent to `hana::at`
         template <typename N>
         constexpr decltype(auto) operator[](N&& n);
     };
 #else
     template <typename ...Xn>
     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<tuple_tag>` 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<tuple_tag> = [](auto&& ...xs) {
         return tuple<std::decay_t<decltype(xs)>...>{forwarded(xs)...};
     };
 #endif
 
     //! Alias to `make<tuple_tag>`; provided for convenience.
     //! @relates hana::tuple
     BOOST_HANA_INLINE_VARIABLE constexpr auto make_tuple = make<tuple_tag>;
 
     //! Equivalent to `to<tuple_tag>`; provided for convenience.
     //! @relates hana::tuple
     BOOST_HANA_INLINE_VARIABLE constexpr auto to_tuple = to<tuple_tag>;
 
     //! Create a tuple specialized for holding `hana::type`s.
     //! @relates hana::tuple
     //!
     //! This is functionally equivalent to `make<tuple_tag>(type_c<T>...)`, 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<tuple_tag>` may differ.
     //!
     //!
     //! Example
     //! -------
     //! @include example/tuple/tuple_t.cpp
 #ifdef BOOST_HANA_DOXYGEN_INVOKED
     template <typename ...T>
     constexpr implementation_defined tuple_t{};
 #else
     template <typename ...T>
     BOOST_HANA_INLINE_VARIABLE constexpr hana::tuple<hana::type<T>...> tuple_t{};
 #endif
 
     //! Create a tuple specialized for holding `hana::integral_constant`s.
     //! @relates hana::tuple
     //!
     //! This is functionally equivalent to `make<tuple_tag>(integral_c<T, v>...)`,
     //! 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<tuple_tag>` may differ.
     //!
     //!
     //! Example
     //! -------
     //! @include example/tuple/tuple_c.cpp
 #ifdef BOOST_HANA_DOXYGEN_INVOKED
     template <typename T, T ...v>
     constexpr implementation_defined tuple_c{};
 #else
     template <typename T, T ...v>
     BOOST_HANA_INLINE_VARIABLE constexpr hana::tuple<hana::integral_constant<T, v>...> tuple_c{};
 #endif
 }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_TUPLE_HPP

This page was automatically generated by the 2.3.7 LXR engine. The LXR team