Tuple.hpp

Go to the documentation of this file.

//
// Aurora C++ Library
// Copyright (c) 2012-2016 Jan Haller
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
//    claim that you wrote the original software. If you use this software
//    in a product, an acknowledgment in the product documentation would be
//    appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such, and must not be
//    misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//


#ifndef AURORA_TUPLE_HPP
#define AURORA_TUPLE_HPP

#include <Aurora/Config.hpp>
#include <Aurora/Meta/Templates.hpp>
#include <Aurora/Meta/Variadic.hpp>

#include <tuple>


namespace aurora
{
namespace detail
{

    // Metafunction to access tuple elements with dynamic index
    template <typename Tuple, typename Result, std::size_t N>
    struct TupleDynamic
    {
        static Result* get(Tuple& t, std::size_t i)
        {
            if (N-1 == i)
                return &std::get<N-1>(t);
            else
                return TupleDynamic<Tuple, Result, N-1>::get(t, i);
        }
    };

    template <typename Tuple, typename Result>
    struct TupleDynamic<Tuple, Result, 0u>
    {
        static Result* get(Tuple&, std::size_t)
        {
            return nullptr;
        }
    };


    // Metafunction to transform each element of a tuple and infer the return type
    template <typename SrcTuple, typename Transformer, std::size_t N>
    struct TupleTransform
    {
        static auto apply(const SrcTuple& src) -> AURORA_AUTO_RETURN
        (
            std::tuple_cat(
                TupleTransform<SrcTuple, Transformer, N-1>::apply(src),
                std::make_tuple(
                    Transformer::transform(std::get<N-1>(src))
                ))
        )
    };

    template <typename SrcTuple, typename Transformer>
    struct TupleTransform<SrcTuple, Transformer, 0u>
    {
        static std::tuple<> apply(const SrcTuple&)
        {
            return std::make_tuple();
        }
    };


} // namespace detail


template <typename Result, typename Tuple>
Result* dynamicGet(Tuple& t, std::size_t i)
{
    const std::size_t N = std::tuple_size<Tuple>::value;
    return detail::TupleDynamic<Tuple, Result, N>::get(t, i);
}

template <typename Transformer, typename SrcTuple>
auto tupleTransform(const SrcTuple& src) -> AURORA_AUTO_RETURN
(
    detail::TupleTransform<SrcTuple, Transformer, std::tuple_size<SrcTuple>::value>::apply(src)
)

template <typename Tuple>
auto tupleFront(Tuple&& t) -> AURORA_AUTO_RETURN
(
    std::get<0>(t)
)

template <typename Tuple>
auto tupleBack(Tuple&& t) -> AURORA_AUTO_RETURN
(
    std::get<std::tuple_size<typename std::remove_reference<Tuple>::type>::value - 1>(t)
)

template <typename T, typename... Us>
T& tupleGet(std::tuple<Us...>& tuple)
{
    return std::get<detail::IndexOfType<T, Us...>::value>(tuple);
}


} // namespace aurora

#endif // AURORA_TEMPLATES_HPP