outer_join.hpp

Go to the documentation of this file.

 
 
#ifndef UTIL_META_OUTER_JOIN_HPP_
#define UTIL_META_OUTER_JOIN_HPP_
 
#include "Traits.hpp"
#include "contains.hpp"
 
namespace util::meta
{
    template <typename Rights, bool IsInner, typename Left, typename... OuterLefts>
    struct _left_outer_join {
        using type = Traits<>;
    };
 
    template <typename... Rights, bool IsInner, typename Left, typename... OuterLefts>
    struct _left_outer_join<Traits<Rights...>, IsInner, Left, OuterLefts...> {
        template <typename... LeftsUntreated>
        struct result {
            // clang-format off
                using type = std::conditional_t<
                    IsInner,
                    Traits<OuterLefts...>,
                    Traits<OuterLefts..., Left>
                >;
            // clang-format on
        };
 
        template <typename NextLeft, typename... LeftsUntreated>
        struct result<NextLeft, LeftsUntreated...> {
            // clang-format off
                using type = std::conditional_t<
                    IsInner, 
                    typename _left_outer_join<
                        Traits<Rights...>,                          // Rights
                        util::meta::contains<NextLeft, Rights...>,  // IsInner
                        NextLeft,                                   // Left
                        OuterLefts...                               // OuterLefts
                    >::template result<LeftsUntreated...>::type,
                    typename _left_outer_join<
                        Traits<Rights...>,                          // Rights
                        util::meta::contains<NextLeft, Rights...>,  // IsInner
                        NextLeft,                                   // Left
                        OuterLefts..., Left                         // OuterLefts
                    >::template result<LeftsUntreated...>::type
                >;
            // clang-format on
        };
    };
 
    template <typename, typename>
    struct left_outer_join {
        using type = Traits<>;
    };
 
    template <typename Left, typename... Lefts, typename... Rights>
    struct left_outer_join<Traits<Left, Lefts...>, Traits<Rights...>> {
        // clang-format off
        using type = typename
            _left_outer_join<
                Traits<Rights...>,              // Rights
                contains<Left, Rights...>,      // IsInner
                Left                            // Left
            >::template result<Lefts...>::type;
        // clang-format on
    };
 
    template <typename... Lefts, typename... Rights>
    struct left_outer_join<std::tuple<Lefts...>, std::tuple<Rights...>> {
        using type = typename left_outer_join<Traits<Lefts...>, Traits<Rights...>>::type;
    };
 
    template <typename Lefts, typename Rights>
    using left_outer_join_t = typename left_outer_join<Lefts, Rights>::type;
 
    template <typename Lefts, typename Rights>
    using right_outer_join = left_outer_join<Rights, Lefts>;
 
    template <typename Lefts, typename Rights>
    using right_outer_join_t = typename right_outer_join<Lefts, Rights>::type;
} // namespace util::meta
 
#endif /* !UTIL_META_OUTER_JOIN_HPP_ */