reductor.hpp

Go to the documentation of this file.

//
// Copyright (C) 2014, 2015 Ableton AG, Berlin. All rights reserved.
//
// 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/or sell 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 <atria/xform/skip.hpp>
#include <atria/xform/state_traits.hpp>
#include <atria/estd/type_traits.hpp>

namespace atria {
namespace xform {

template <typename ReducingFnT,
          typename StateT,
          typename... InputTs>
struct reductor_fn_base
{
  using reducing_fn_type = ReducingFnT;
  using state_type = StateT;
  using complete_type = estd::decay_t<
    decltype(state_complete(std::declval<state_type>()))>;

  reductor_fn_base() = delete;

  explicit operator bool() const
    { return !state_is_reduced(state_); }

  complete_type complete() const&
  { return state_complete(state_); }

  complete_type complete() &&
  { return state_complete(std::move(state_)); }

  complete_type current() const&
  { return state_unwrap_all(state_); }

  complete_type current() &&
  { return state_unwrap_all(std::move(state_)); }

  template <typename T>
  void current(T&& x)
  { state_ = state_rewrap(std::move(state_), std::forward<T>(x)); }

  template <typename... InputTs2>
  reductor_fn_base& operator() (InputTs2&& ...ins) &
  {
    auto next = step_(std::move(state_), std::forward<InputTs2>(ins)...);
    state_ = std::move(next);
    return *this;
  }

  template <typename... InputTs2>
  reductor_fn_base operator() (InputTs2&& ...ins) const&
  {
    auto copied = *this;
    copied(std::forward<InputTs2>(ins)...);
    return copied;
  }

  template <typename... InputTs2>
  reductor_fn_base&& operator() (InputTs2&& ...ins) &&
  {
    return std::move((*this)(std::forward<InputTs2>(ins)...));
  }

protected:
  template <typename ReducingFnT2,
            typename StateT2>
  reductor_fn_base(ReducingFnT2&& step,
                   StateT2&& state)
    : step_(std::forward<ReducingFnT2>(step))
    , state_(std::forward<StateT2>(state))
  {}

private:
  reducing_fn_type step_;
  state_type state_;
};

template <typename ReducingFnT,
          typename InitialStateT,
          typename... InputTs>
struct reductor_fn : reductor_fn_base<
  ReducingFnT,
  estd::result_of_t<ReducingFnT(InitialStateT, InputTs...)>,
  InputTs...>
{
  using base_t = reductor_fn_base<
    ReducingFnT,
    estd::result_of_t<ReducingFnT(InitialStateT, InputTs...)>,
    InputTs...>;

  template <typename ReducingFnT2,
            typename InitialStateT2,
            typename... InputTs2>
  reductor_fn(ReducingFnT2&& step,
              InitialStateT2&& state,
              InputTs2&& ...ins)
    : base_t(std::forward<ReducingFnT2>(step),
             step(std::forward<InitialStateT2>(state),
                  std::forward<InputTs2>(ins)...))
  {}
};

template <typename ReducingFnT, typename InitialStateT, typename... InputTs>
auto reductor(ReducingFnT&& step, InitialStateT&& state, InputTs&& ...ins)
  -> reductor_fn<estd::decay_t<ReducingFnT>,
                 estd::decay_t<InitialStateT>,
                 estd::decay_t<InputTs>... >
{
  return {
    std::forward<ReducingFnT>(step),
    std::forward<InitialStateT>(state),
    std::forward<InputTs>(ins)...
  };
}

namespace detail {

template <typename ReducingFnT>
struct caller
{
  ReducingFnT step;

  template <typename... Args>
  auto operator() (Args&& ...args)
  -> ABL_DECLTYPE_RETURN(
    call(step, std::forward<Args>(args)...))
};

} // namespace detail

template <typename ReducingFnT,
          typename InitialStateT,
          typename... InputTs>
struct empty_reductor_fn : reductor_fn_base<
  detail::caller<estd::decay_t<ReducingFnT>>,
  estd::decay_t<skip_result_t<ReducingFnT, InitialStateT, InputTs...> >,
  InputTs...>
{
  using base_t = reductor_fn_base<
    detail::caller<estd::decay_t<ReducingFnT> >,
    estd::decay_t<skip_result_t<ReducingFnT, InitialStateT, InputTs...> >,
    InputTs...>;

  template <typename ReducingFnT2,
            typename InitialStateT2,
            typename... InputTs2>
  empty_reductor_fn(ReducingFnT2&& step,
                    InitialStateT2&& state)
    : base_t(detail::caller<estd::decay_t<ReducingFnT>> {
               std::forward<ReducingFnT2>(step) },
             typename base_t::state_type {
               std::forward<InitialStateT2>(state) })
  {}
};

template <typename ReducingFnT,
          typename InitialStateT,
          typename... InputTs>
struct empty_reductor_fn<ReducingFnT, InitialStateT, meta::pack<InputTs...> >
  : empty_reductor_fn<ReducingFnT, InitialStateT, InputTs...>
{
  using empty_reductor_fn<ReducingFnT, InitialStateT, InputTs...>::empty_reductor_fn;
};

template <typename... InputTs, typename ReducingFnT, typename InitialStateT>
auto empty_reductor(ReducingFnT&& step, InitialStateT&& state)
  -> empty_reductor_fn<estd::decay_t<ReducingFnT>,
                       estd::decay_t<InitialStateT>,
                       estd::decay_t<InputTs>... >
{
  return {
    std::forward<ReducingFnT>(step),
    std::forward<InitialStateT>(state)
  };
}

} // namespace xform
} // namespace atria