state_wrapper.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/state_traits.hpp>
#include <tuple>

namespace atria {
namespace xform {

struct no_tag {};

template <typename TagT   = no_tag,
          typename StateT = void,
          typename DataT  = void>
struct state_wrapper : std::tuple<StateT, DataT>
{
  using tag = TagT;
  using base_t = std::tuple<StateT, DataT>;

  state_wrapper(const state_wrapper&) = default;
  state_wrapper(state_wrapper&&) = default;
  state_wrapper& operator=(const state_wrapper&) = default;
  state_wrapper& operator=(state_wrapper&&) = default;

  template <typename T, typename U>
  state_wrapper(T&& st, U&& data)
    : base_t(std::forward<T>(st), std::forward<U>(data))
  {}
};

template <typename StateT, typename DecayedT = estd::decay_t<StateT> >
struct is_state_wrapper
  : std::false_type {};

template <typename _, typename T, typename S, typename D>
struct is_state_wrapper<_, state_wrapper<T, S, D> >
  : std::true_type {};

template <typename TagT=no_tag, typename StateT, typename DataT=TagT>
auto wrap_state(StateT&& next, DataT&& data=DataT{})
  -> state_wrapper<TagT,
                   estd::decay_t<StateT>,
                   estd::decay_t<DataT> >
{
  return state_wrapper<TagT, estd::decay_t<StateT>, estd::decay_t<DataT> > {
    std::forward<StateT>(next),
    std::forward<DataT>(data)
  };
}

template <typename TagT, typename T>
auto state_wrapper_complete(TagT, T&& s)
  -> ABL_DECLTYPE_RETURN(
    state_complete(state_unwrap(std::forward<T>(s))))


template <typename TagT, typename T>
auto state_wrapper_unwrap(TagT, T&& s)
  -> ABL_DECLTYPE_RETURN(
    std::get<0>(std::forward<T>(s)))

template <typename TagT, typename T>
auto state_wrapper_unwrap_all(TagT, T&& s)
  -> ABL_DECLTYPE_RETURN(
    state_unwrap_all(state_unwrap(std::forward<T>(s))))

  template <typename TagT, typename T, typename U>
  auto state_wrapper_rewrap(TagT, T&& s, U&& x)
  -> ABL_DECLTYPE_RETURN(
    wrap_state<TagT>(
      state_rewrap(state_unwrap(std::forward<T>(s)), x),
      state_wrapper_data(std::forward<T>(s))))

template <typename TagT, typename T, typename D>
auto state_wrapper_data(TagT tag, T&& s, D&&)
  -> ABL_DECLTYPE_RETURN(
    state_wrapper_data(tag, std::forward<T>(s)))

template <typename T>
auto state_wrapper_data(T&& s)
  -> ABL_DECLTYPE_RETURN(
    state_wrapper_data(typename estd::decay_t<T>::tag{}, std::forward<T>(s)))

template <typename TagT, typename T>
auto state_wrapper_data(TagT, T&& s)
  -> ABL_DECLTYPE_RETURN(
    std::get<1>(std::forward<T>(s)))


template <typename TagT, typename DataT>
bool state_wrapper_data_is_reduced(TagT, DataT&&)
{
  return false;
}

template <typename TagT, typename T>
bool state_wrapper_is_reduced(TagT tag, T&& s)
{
  return state_wrapper_data_is_reduced(
           tag, state_wrapper_data(tag, std::forward<T>(s)))
      || state_is_reduced(state_unwrap(std::forward<T>(s)));
}

template <typename TagT, typename StateT, typename DataT>
struct state_traits<state_wrapper<TagT, StateT, DataT> >
{
  template <typename T>
  static auto complete(T&& s)
    -> ABL_DECLTYPE_RETURN(
      state_wrapper_complete(TagT{}, std::forward<T>(s)))

  template <typename T>
  static auto is_reduced(T&& s)
    -> ABL_DECLTYPE_RETURN(
      state_wrapper_is_reduced(TagT{}, std::forward<T>(s)))

  template <typename T, typename D>
  static auto data(T&& s, D&& d)
    -> ABL_DECLTYPE_RETURN(
      state_wrapper_data(TagT{}, std::forward<T>(s), std::forward<D>(d)))

  template <typename T>
  static auto unwrap(T&& s)
    -> ABL_DECLTYPE_RETURN(
      state_wrapper_unwrap(TagT{}, std::forward<T>(s)))

  template <typename T>
  static auto unwrap_all(T&& s)
    -> ABL_DECLTYPE_RETURN(
      state_wrapper_unwrap_all(TagT{}, std::forward<T>(s)))

  template <typename T, typename U>
  static auto rewrap(T&& s, U&& x)
    -> ABL_DECLTYPE_RETURN(
      state_wrapper_rewrap(TagT{}, std::forward<T>(s), std::forward<U>(x)))
};

} // namespace xform
} // namespace atria