Tuple.hh

Go to the documentation of this file.

//  MIT License
//  Copyright (c) 2020 Jonathan R. Madsen
//  Permission is hereby granted, free of charge, to any person obtaining a copy
//  of this software and associated documentation files (the "Software"), to deal
//  in the Software without restriction, including without limitation the rights
//  to use, copy, modify, merge, publish, distribute, sublicense, and
//  copies of the Software, and to permit persons to whom the Software is
//  furnished to do so, subject to the following conditions:
//  The above copyright notice and this permission notice shall be included in
//  all copies or substantial portions of the Software.
//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
//  SOFTWARE.
 
#pragma once
 
#include <cstring>
#include <functional>
#include <tuple>
#include <type_traits>
 
namespace PTL
{
template <typename Tp, typename Up>
struct SmallerThanT
{
    static constexpr bool value = sizeof(Tp) < sizeof(Up);
};
 
//======================================================================================//
 
// CTValue == compile-time value
//
// useful to work with sequences of compile-time values, such as the bounds of a
// multidimensional array or indices into another typelist.
 
template <typename Tp, Tp Value>
struct CTValue
{
    static constexpr Tp value = Value;
};
 
//======================================================================================//
 
template <std::size_t Height, typename Tp,
          bool = std::is_class<Tp>::value && !std::is_final<Tp>::value>
class TupleElt;
 
//--------------------------------------------------------------------------------------//
//  specialization that does not satisfy is_class<> and not is_final<>
//
template <std::size_t Height, typename Tp>
class TupleElt<Height, Tp, false>
{
    Tp value;
 
public:
    TupleElt() = default;
 
    template <typename Up>
    TupleElt(Up&& other)
    : value(std::forward<Up>(other))
    {}
 
    Tp&       get() { return value; }
    Tp const& get() const { return value; }
};
 
//--------------------------------------------------------------------------------------//
//  specialization that does satisfy is_class<> and not is_final<>
//
template <std::size_t Height, typename Tp>
class TupleElt<Height, Tp, true> : private Tp
{
public:
    TupleElt() = default;
 
    template <typename Up>
    explicit TupleElt(Up&& other)
    : Tp(std::forward<Up>(other))
    {}
 
    Tp&       get() { return *this; }
    const Tp& get() const { return *this; }
};
 
//======================================================================================//
 
template <unsigned H, typename T>
T&
get_height(TupleElt<H, T>& te)
{
    return te.get();
}
 
//======================================================================================//
 
template <typename... Types>
class Tuple;
 
//--------------------------------------------------------------------------------------//
 
// recursive case:
template <typename Head, typename... Tail>
class Tuple<Head, Tail...>
: private TupleElt<sizeof...(Tail), Head>
, private Tuple<Tail...>
{
    template <unsigned I, typename... Elements>
    friend auto get(Tuple<Elements...>& t)
        -> decltype(get_height<sizeof...(Elements) - I - 1>(t));
 
public:
    Head&           head() { return static_cast<HeadElt*>(this)->get(); }
    const Head&     head() const { return static_cast<HeadElt const*>(this)->get(); }
    Tuple<Tail...>& tail() { return *this; }
    const Tuple<Tail...>& tail() const { return *this; }
 
private:
    using HeadElt = TupleElt<sizeof...(Tail), Head>;
};
 
//--------------------------------------------------------------------------------------//
// basis case:
template <>
class Tuple<>
{
    // no storage required
};
 
//--------------------------------------------------------------------------------------//
 
template <unsigned I, typename... Elements>
auto
get(Tuple<Elements...>& t) -> decltype(get_height<sizeof...(Elements) - I - 1>(t))
{
    return get_height<sizeof...(Elements) - I - 1>(t);
}
 
template <typename... Tp>
using TypeList = Tuple<Tp...>;
 
//======================================================================================//
 
template <typename List>
class IsEmpty
{
public:
    static constexpr bool value = false;
};
 
template <>
class IsEmpty<Tuple<>>
{
public:
    static constexpr bool value = true;
};
 
template <typename List, typename NewElement>
class PushBackT;
 
template <typename... Elements, typename NewElement>
class PushBackT<Tuple<Elements...>, NewElement>
{
public:
    using Type = Tuple<Elements..., NewElement>;
};
 
template <typename List, typename NewElement>
using PushBack = typename PushBackT<List, NewElement>::Type;
 
template <typename List>
class PopFrontT;
 
template <typename Head, typename... Tail>
class PopFrontT<std::tuple<Head, Tail...>>
{
public:
    using Type = std::tuple<Tail...>;
};
 
template <typename List>
using PopFront = typename PopFrontT<List>::Type;
 
template <typename List, typename Element>
class PushFrontT;
 
template <typename... Types, typename Element>
class PushFrontT<std::tuple<Types...>, Element>
{
public:
    using Type = std::tuple<Element, Types...>;
};
 
template <typename List, typename NewElement>
using PushFront = typename PushFrontT<List, NewElement>::Type;
 
template <typename... Types, typename V>
PushFront<std::tuple<Types...>, V>
pushFront(std::tuple<Types...> const& tuple, V const& value)
{
    return PushFront<std::tuple<Types...>, V>(value, tuple);
}
 
template <typename T, T... Values>
struct Valuelist
{};
 
template <typename... Types>
struct Front;
 
template <typename FrontT, typename... Types>
struct Front<FrontT, Types...>
{
    using Type = FrontT;
};
 
template <typename... Types>
struct Back;
 
template <typename BackT, typename... Types>
struct Back<Types..., BackT>
{                        // ERROR: pack expansion not at the end of
    using Type = BackT;  //       template argument list
};
 
//======================================================================================//
 
template <typename List, template <typename T> class MetaFun,
          bool Empty = IsEmpty<List>::value>
class TransformT;
 
// recursive case:
template <typename List, template <typename T> class MetaFun>
class TransformT<List, MetaFun, false>
: public PushFrontT<typename TransformT<PopFront<List>, MetaFun>::Type,
                    typename MetaFun<Front<List>>::Type>
{};
 
// basis case:
template <typename List, template <typename T> class MetaFun>
class TransformT<List, MetaFun, true>
{
public:
    using Type = List;
};
 
template <typename List, template <typename T> class MetaFun>
using Transform = typename TransformT<List, MetaFun>::Type;
 
template <typename... Elements, template <typename T> class MetaFun>
class TransformT<Tuple<Elements...>, MetaFun, false>
{
public:
    using Type = Tuple<typename MetaFun<Elements>::Type...>;
};
 
template <size_t N>
struct ForwardTupleAsArgs
{
    template <typename Func, typename Head, typename... Tail>
    static inline auto forward(Func&& func, Head&& head, Tail&&... tail)
        -> decltype(ForwardTupleAsArgs<N - 1>::forward(
            std::forward<Func>(func), std::forward<Head>(head),
            std::get<N - 1>(std::forward<Head>(head)), std::forward<Tail>(tail)...))
    {
        return ForwardTupleAsArgs<N - 1>::forward(
            std::forward<Func>(func), std::forward<Head>(head),
            std::get<N - 1>(std::forward<Head>(head)), std::forward<Tail>(tail)...);
    }
};
 
//======================================================================================//
 
template <>
struct ForwardTupleAsArgs<0>
{
    template <typename Func, typename Head, typename... Tail>
    static inline auto forward(Func&& func, Head&&, Tail&&... tail)
        -> decltype(std::forward<Func>(func)(std::forward<Tail>(tail)...))
    {
        return std::forward<Func>(func)(std::forward<Tail>(tail)...);
    }
};
 
//======================================================================================//
 
template <size_t N>
struct ForEachTupleArg
{
    template <typename Func, typename Head>
    static inline auto apply(Func&& func, Head&& head)
    {
        std::forward<Func>(func)(std::forward<Head>(head));
    }
 
    template <typename Func, typename Head, typename... Tail>
    static inline void apply(Func&& func, Head&& head, Tail&&... tail)
    {
        std::forward<Func>(func)(std::forward<Head>(head));
        ForEachTupleArg<N - 1>::apply(std::forward<Func>(func),
                                      std::forward<Tail>(tail)...);
    }
};
 
//======================================================================================//
 
template <typename Func, typename Tuple>
void
for_each_tuple_arg(Func&& func, Tuple&& _tuple)
{
    ForEachTupleArg<std::tuple_size<Tuple>::value>::apply(
        std::forward<Func>(func), std::forward<std::tuple>(_tuple));
}
 
//======================================================================================//
 
template <typename Func, typename Tuple, std::size_t Head>
inline auto
InvokeSequence_impl(const Func& func, const Tuple& data)
{
    func(std::get<Head>(data));
}
 
//======================================================================================//
 
template <typename Func, typename Tuple, std::size_t Head, std::size_t... Tail>
inline auto
InvokeSequence_impl(const Func& func, const Tuple& data)
{
    func(std::get<Head>(data));
    InvokeSequence_impl<Func, Tuple, Tail...>(func, data);
}
 
//======================================================================================//
 
template <typename Func, typename Tuple, std::size_t N = std::tuple_size<Tuple>::value,
          typename Indices = std::make_index_sequence<N>>
inline auto
InvokeSequence(const Func& func, const Tuple& data)
{
    return InvokeSequence_impl(func, data);
}
 
//======================================================================================//
 
// Convert array into a tuple
template <typename Container, std::size_t... N>
inline auto
ContainerToTuple_impl(const Container& tasks, std::index_sequence<N...>)
{
    return std::make_tuple(tasks[N]...);
}
 
//======================================================================================//
 
template <std::size_t N, typename Container,
          typename Indices = std::make_index_sequence<N>>
inline auto
ContainerToTuple(const Container& tasks)
{
    return ContainerToTuple_impl(tasks, Indices{});
}
 
//======================================================================================//
 
template <typename... Args>
struct tuple_subset
{
    static std::tuple<> get(const std::tuple<>&) { return std::tuple<>{}; }
 
    template <typename... SubArgs>
    static std::tuple<SubArgs...> get(const std::tuple<Args...>& t)
    {
        return std::tuple<SubArgs...>{ std::get<SubArgs>(t)... };
    }
};
 
template <typename Head>
inline void
tuple_transform(const std::function<void(const Head&)>& pred,
                const std::tuple<Head>&                 data)
{
    pred(std::get<0>(data));
}
 
template <typename Head, typename... Tail>
inline void
tuple_transform(const std::function<void(const Head&)>& pred,
                const std::tuple<Head, Tail...>&        data)
{
    pred(std::get<0>(data));
    auto subset = tuple_subset<Head, Tail...>::template get<Tail...>(data);
    tuple_transform<Tail...>(pred, std::forward<decltype(subset)>(subset));
}
 
template <typename Head, typename... Tail>
struct transform_tuple
{
    using Function = std::function<void(Head)>;
    template <typename TupleType>
    static void apply(const Function& func, const TupleType& t)
    {
        func(std::get<0>(t));
        PopFront<TupleType> nt = std::tuple<Tail...>{ std::get<Tail>(t)... };
        transform_tuple<Tail...>::apply(func, nt);
    }
};
 
template <typename Head>
struct transform_tuple<Head>
{
    using Function = std::function<void(Head)>;
    template <typename TupleType>
    static void apply(const Function& func, const TupleType& t)
    {
        func(std::get<0>(t));
    }
};
 
//======================================================================================//
 
template <typename Func, typename... Elements, unsigned... Indices>
auto
applyImpl(Func func, std::tuple<Elements...> const& t, Valuelist<unsigned, Indices...>)
    -> decltype(func(std::get<Indices>(t)...))
{
    return func(std::get<Indices>(t)...);
}
 
template <typename Func, typename... Elements, unsigned N = sizeof...(Elements)>
auto
apply(Func func, std::tuple<Elements...> const& t)
    -> decltype(applyImpl(func, t, std::make_index_sequence<N>()))
{
    return applyImpl(func, t, std::make_index_sequence<N>());
}
 
}  // namespace PTL