#include <tuple>
#include <utility>
#include <iostream>


class Aa {
    public:
        Aa(int a1_, int a2_): a1(a1_), a2(a2_) {}

        template<std::size_t N>
        decltype(auto) get() const {
            if constexpr (N == 0) return a1;
            else if constexpr (N == 1) return a2;
        }

    private:
        int a1;
        int a2;
};

class Bb {
    public:
        Bb(Aa a_, int b_): a(a_), b(b_) {}

        template<std::size_t N>
        decltype(auto) get() const {
            if constexpr (N == 0) return a;
            else if constexpr (N == 1) return b;
        }

    private:
        Aa a;
        int b;

};

namespace std {
    // Aa
    template<>
    struct tuple_size<Aa> : std::integral_constant<std::size_t, 2> {};

    template<std::size_t N>
    struct tuple_element<N, Aa> {
        using type = decltype(std::declval<Aa>().get<N>());
    };

    // Bb
    template<>
    struct tuple_size<Bb> : std::integral_constant<std::size_t, 2> {};

    template<std::size_t N>
    struct tuple_element<N, Bb> {
        using type = decltype(std::declval<Bb>().get<N>());
    };
}

// template <size_t N>
// using size = std::integral_constant<size_t, N>;

// template<typename T>
// void encode(T t) {
//     encode_impl<?std::tuple_size<T>?()>(T t, ?std::tuple_size<T>);
// }

// template<?>
// encode_impl(T t, ?) {
//    std::cout << "It works";
// }

template<typename T>
void encode(T const& t, std::ostream& os)
{
  encode_impl(t, os, std::make_index_sequence<std::tuple_size<T>>{ });
}

template<typename T, std::size_t... I>
void encode_impl(T const& t, std::ostream& os, std::index_sequence<I...> const)
{
  constexpr auto last = sizeof...(I) - 1;
  os << "{ ";
  [[maybe_unused]] int const temp[] =
    { ((os << (I != last ? ", " : " ") << t.template get<I>()), 0)... };
  os << "}" << std::endl;
}

int main () {
    auto a = Aa(1, 1);
    encode(a, std::cout);
    return 0;
}