cpp-json/include/json/binder/json_direct_get_binder.hpp

//
//  json_direct_tuple_binder.hpp
//  json
//
//  Created by Sam Jaffe on 2/26/17.
//

#pragma once

#include "json_binder.hpp"
#include "json_direct_binder.hpp"
#include "json_tuple_binder.hpp"

#include <array>
#include <tuple>

namespace json { namespace binder {
  template <typename T, std::size_t I>
  class get_binder : public binder_impl<T> {
    // Maybe a reference type
    using ith_type = decltype(std::get<I>(std::declval<T>()));
  public:
    using value_type = typename std::remove_reference<ith_type>::type;
    
    get_binder() : impl(value_binder<value_type>()) {}
    
    get_binder(binder<value_type> val_binder)
    : impl(std::move(val_binder)) {}
    
    get_binder(binder_impl<value_type> const & val_binder)
    : impl(val_binder) {}
    
    virtual binder_impl<T>* clone() const override {
      return new get_binder(*this);
    }
    
    virtual void parse(T& object, char const*& data,
                       parser::options opts) const override {
      impl.parse(std::get<I>(object), data, opts);
    }
    
    virtual void write(T const& val, std::ostream & data) const override {
      impl.write(std::get<I>(val), data);
    }
  private:
    binder<value_type> impl;
  };
  
#if __cpluscplus >= 201402L
  namespace detail {
    template <typename TupleOut, typename TupleIn, std::size_t... Indexes>
    tuple_binder<TupleOut> make_tuple_binder(TupleIn && binds,
                                             std::index_sequence<Indexes...>) {
      tuple_binder<TupleOut> binder;
      using swallow = int[];
      (void) swallow{
        0,
        (void(binder(get_binder<TupleOut, Indexes>(std::get<Indexes>(binds)))),
         0)...
      };
      return binder;
    }
    
    template <typename TupleOut, typename T, std::size_t... Indexes>
    tuple_binder<TupleOut> make_array_binder(binder<T> && binds,
                                             std::index_sequence<Indexes...>) {
      tuple_binder<TupleOut> binder;
      using swallow = int[];
      (void) swallow{
        0,
        (void(binder(get_binder<TupleOut, Indexes>(binds))), 0)...
      };
      return binder;
    }
  }
  
  template <typename... Ts>
  tuple_binder<std::tuple<Ts...>> make_tuple_binder(binder<Ts> &&... binds) {
    return detail::make_tuple_binder<std::tuple<Ts...>>
    (std::make_tuple(binds...),
     std::make_index_sequence<sizeof...(Ts)>());
  }

  template <typename... Ts>
  tuple_binder<std::tuple<Ts...>> make_tuple_binder(binder_impl<Ts> &&... binds) {
    return detail::make_tuple_binder<std::tuple<Ts...>>
    (std::make_tuple(binder<Ts>(binds)...),
     std::make_index_sequence<sizeof...(Ts)>());
  }
  
  template <typename... Ts>
  tuple_binder<std::tuple<Ts...>> make_default_tuple_binder() {
    return detail::make_tuple_binder<std::tuple<Ts...>>
    (std::make_tuple(binder<Ts>(value_binder<Ts>())...),
     std::make_index_sequence<sizeof...(Ts)>());
  }
  
  template <typename T, std::size_t N>
  tuple_binder<std::array<T, N>> make_array_binder(binder<T> && binds) {
    return detail::make_array_binder<std::array<T, N>>
    (binds, std::make_index_sequence<N>());
  }
  
  template <typename T, std::size_t N>
  tuple_binder<std::array<T, N>> make_array_binder(binder_impl<T> const & binds
                                                   = value_binder<T>()) {
    return detail::make_array_binder<std::array<T, N>>
    (binder<T>(binds), std::make_index_sequence<N>());
  }
#else
  namespace detail {
    template <std::size_t> struct tuple_binder_helper;
    
    template <>
    struct tuple_binder_helper<0> {
      template <typename BindOut>
      tuple_binder<BindOut> & operator()(tuple_binder<BindOut> & bind) const {
        return bind;
      }
    };
    
    template <std::size_t N>
    struct tuple_binder_helper {
      template <typename BindOut, typename BindIn, typename... Ts>
      tuple_binder<BindOut> & operator()(tuple_binder<BindOut> & bind,
                                         BindIn && ith,
                                         Ts &&... binders) const {
        constexpr auto get_index = std::tuple_size<BindOut>::value-N;
        using get_binder_t = get_binder<BindOut, get_index>;
        return tuple_binder_helper<N-1>()
        (bind(get_binder_t(std::forward<BindIn>(ith))),
         std::forward<Ts>(binders)...);
      }
    };
    
    template <std::size_t> struct array_binder_helper;
    
    template <>
    struct array_binder_helper<1> {
      template <typename BindOut, typename BindIn>
      tuple_binder<BindOut> & operator()(tuple_binder<BindOut> & bind,
                                         BindIn &&) const {
        return bind;
      }
    };
    
    template <std::size_t N>
    struct array_binder_helper {
      template <typename BindOut, typename BindIn>
      tuple_binder<BindOut> & operator()(tuple_binder<BindOut> & bind,
                                         BindIn && ith) const {
        return array_binder_helper<N-1>()(bind(get_binder<BindOut, N-1>(ith)),
                                          std::forward<BindIn>(ith));
      }
    };
  }
  
  template <typename... Ts>
  tuple_binder<std::tuple<Ts...>> make_tuple_binder(binder<Ts> &&... binds) {
    tuple_binder<std::tuple<Ts...>> binder;
    return detail::tuple_binder_helper<sizeof...(Ts)>()
    (binder, std::forward<Ts>(binds)...);
  }
  
  template <typename... Ts>
  tuple_binder<std::tuple<Ts...>> make_tuple_binder(binder_impl<Ts> &&... binds) {
    tuple_binder<std::tuple<Ts...>> binder;
    return detail::tuple_binder_helper<sizeof...(Ts)>()
    (binder, json::binder::binder<Ts>(binds)...);
  }
  
  template <typename... Ts>
  tuple_binder<std::tuple<Ts...>> make_default_tuple_binder() {
    tuple_binder<std::tuple<Ts...>> binder;
    return detail::tuple_binder_helper<sizeof...(Ts)>()
    (binder, json::binder::binder<Ts>(value_binder<Ts>())...);
  }
  
  template <typename T, std::size_t N>
  tuple_binder<std::array<T, N>> make_array_binder(binder<T> && binds) {
    tuple_binder<std::array<T, N>> binder;
    return detail::array_binder_helper<N>(binder, binds);
  }
  
  template <typename T, std::size_t N>
  tuple_binder<std::array<T, N>> make_array_binder(binder_impl<T> const & binds
                                                   = value_binder<T>()) {
    tuple_binder<std::array<T, N>> binder;
    return detail::array_binder_helper<N>(binder,
                                          json::binder::binder<T>(binds));
  }
#endif
} }