apply.hh

Go to the documentation of this file.

#ifndef UTOPIA_CORE_APPLY_HH
#define UTOPIA_CORE_APPLY_HH
 
#include <type_traits>
#include <vector>
 
#include "parallel.hh"
#include "state.hh"
#include "zip.hh"
 
 
namespace Utopia {
 
namespace impl {
template<class Container>
using entity_t = typename Container::value_type::element_type;
}
 
 
enum class Shuffle {
    on,
    off
};
 
 
template<typename State, typename Rule, typename... Args>
class rule_invoke_result
{
private:
  // Check if rule can be invoked
  static_assert(
    std::is_invocable_v<Rule,
                        typename std::remove_reference_t<Args>::reference...>,
    "Cannot invoke the Rule with the given container elements as arguments!"
    " Please check the rule signature!");
 
public:
    using type = std::invoke_result_t<
        Rule,
        typename std::remove_reference_t<Args>::reference...>;
 
private:
    // Check that rule returns type that can be converted to state
    static_assert(
        std::is_same_v<type, void> or std::is_convertible_v<type, State>,
        "Invoking the rule must return a type that can be converted to the "
        "Entity state type!");
};
 
 
template<typename State, typename Rule, typename... Args>
using rule_invoke_result_t =
    typename rule_invoke_result<State, Rule, Args...>::type;
 
 
template<typename State, typename Rule, typename... Args>
constexpr bool is_void_rule ()
{
    return std::is_same_v<void, rule_invoke_result_t<State, Rule, Args...>>;
}
 
 
template<class Tuple, std::size_t... I>
constexpr decltype(auto)
make_tuple_from_tuple_impl(Tuple&& t, std::index_sequence<I...>)
{
    return std::make_tuple(std::get<I>(std::forward<Tuple>(t))...);
}
 
 
template<class Tuple>
constexpr decltype(auto)
make_tuple_from_tuple(Tuple&& t)
{
    return make_tuple_from_tuple_impl(
        std::forward<Tuple>(t),
        std::make_index_sequence<
            std::tuple_size_v<std::remove_reference_t<Tuple>>>{});
}
 
// -- Manually-managed state updates ------------------------------------------
 
template<Update mode,
         class Rule,
         class ContTarget,
         class... ContArgs,
         typename std::enable_if_t<mode == Update::sync, int> = 0,
         typename std::enable_if_t<
                    impl::entity_t<ContTarget>::mode
                        == Update::manual, int> = 0>
void apply_rule(Rule&& rule,
                const ContTarget& cont_target,
                ContArgs&&... cont_args)
{
    apply_rule<mode>(
        Utopia::ExecPolicy::seq, rule, cont_target, cont_args...);
}
 
 
template<Update mode,
         class Rule,
         class ContTarget,
         class... ContArgs,
         typename std::enable_if_t<mode == Update::sync, int> = 0,
         typename std::enable_if_t<
                    impl::entity_t<ContTarget>::mode
                        == Update::manual, int> = 0>
void apply_rule(const Utopia::ExecPolicy policy,
                Rule&& rule,
                const ContTarget& cont_target,
                ContArgs&&... cont_args)
{
    using State = typename impl::entity_t<ContTarget>::State;
 
    // Make sure to call `invoke_result_type` at least for a conversion check
    static_assert(not is_void_rule<State, Rule, ContTarget, ContArgs...>(),
                  "Cannot apply void rules in a synchronous update!");
 
    // Initialize the state cache
    // NOTE: Copy one element to avoid requirement of default initialization
    std::vector<State> state_cache(cont_target.size(),
                                   cont_target.front()->state);
 
    // create the input zip iterators
    auto range = Itertools::zip(cont_target, cont_args...);
    using std::begin, std::end;
 
    // Apply the rule
    // NOTE: Capture by reference is fine because rule is a temporary
    std::transform(policy,
                   begin(range),
                   end(range),
                   begin(state_cache),
                   [&rule](auto&& args) {
                       return std::apply(rule,
                                         std::forward<decltype(args)>(args));
                   });
 
    // move the cache
    auto move_range = Itertools::zip(cont_target, state_cache);
    std::for_each(Utopia::ExecPolicy::par_unseq,
                  begin(move_range),
                  end(move_range),
                  [](auto&& tpl) {
                      std::get<0>(tpl)->state = std::move(std::get<1>(tpl));
                  });
}
 
template<Update mode,
         Shuffle shuffle = Shuffle::on,
         class Rule,
         class ContTarget,
         class... ContArgs,
         typename std::enable_if_t<mode == Update::async, int> = 0,
         typename std::enable_if_t<
                    impl::entity_t<ContTarget>::mode
                        == Update::manual, int> = 0,
         typename std::enable_if_t<shuffle == Shuffle::off, int> = 0>
void
apply_rule(Rule&& rule,
           const ContTarget& cont_target,
           ContArgs&&... cont_args)
{
    apply_rule<mode, shuffle>(
        Utopia::ExecPolicy::seq, rule, cont_target, cont_args...);
}
 
 
template<Update mode,
         Shuffle shuffle = Shuffle::on,
         class Rule,
         class ContTarget,
         class... ContArgs,
         typename std::enable_if_t<mode == Update::async, int> = 0,
         typename std::enable_if_t<
                    impl::entity_t<ContTarget>::mode
                        == Update::manual, int> = 0,
         typename std::enable_if_t<shuffle == Shuffle::off, int> = 0>
void
apply_rule(const Utopia::ExecPolicy policy,
           Rule&& rule,
           const ContTarget& cont_target,
           ContArgs&&... cont_args)
{
    // Create the input range zip iterators
    auto range = Itertools::zip(cont_target, cont_args...);
    using std::begin, std::end;
 
    // Apply the rule, distinguishing by return type of the rule
    using State = typename impl::entity_t<ContTarget>::State;
    if constexpr (is_void_rule<State, Rule, ContTarget, ContArgs...>()) {
        // Is a void-rule; no need to set the return value
        std::for_each(policy, begin(range), end(range), [&rule](auto&& args) {
            std::apply(rule,
                       std::forward<decltype(args)>(args));
        });
    }
    else {
        std::for_each(policy, begin(range), end(range), [&rule](auto&& args) {
            auto& cell = std::get<0>(args);
            cell->state = std::apply(rule,
                                    std::forward<decltype(args)>(args));
        });
    }
}
 
template<Update mode,
         Shuffle shuffle = Shuffle::on,
         class Rule,
         class ContTarget,
         class RNG,
         class... ContArgs,
         typename std::enable_if_t<mode == Update::async, int> = 0,
         typename std::enable_if_t<
                    impl::entity_t<ContTarget>::mode
                        == Update::manual, int> = 0,
         typename std::enable_if_t<shuffle == Shuffle::on, int> = 0>
void
apply_rule(Rule&& rule,
           const ContTarget& cont_target,
           RNG&& rng,
           ContArgs&&... cont_args)
{
    apply_rule<mode, shuffle>(
        Utopia::ExecPolicy::seq, rule, cont_target, rng, cont_args...);
}
 
 
template<Update mode,
         Shuffle shuffle = Shuffle::on,
         class Rule,
         class ContTarget,
         class RNG,
         class... ContArgs,
         typename std::enable_if_t<mode == Update::async, int> = 0,
         typename std::enable_if_t<
                    impl::entity_t<ContTarget>::mode
                        == Update::manual, int> = 0,
         typename std::enable_if_t<shuffle == Shuffle::on, int> = 0>
void
apply_rule(const Utopia::ExecPolicy policy,
           Rule&& rule,
           const ContTarget& cont_target,
           RNG&& rng,
           ContArgs&&... cont_args)
{
    // Create the input range zip iterators
    auto range = Itertools::zip(cont_target, cont_args...);
    using std::begin, std::end;
 
    // NOTE: std::shuffle requires the container elements to be swappable.
    //       This is not the case for tuples of T& so we need a container of
    //       tuples of std::reference_wrapper<T>. For this to work, we must
    //       propagate the const-ness of the container to the wrapper.
    //       When applying the rule, we must convert the reference wrappers back
    //       to regular references, which can be done with std::make_tuple.
    using Tuple = std::tuple<
        // 'ContTarget' is always const
        std::reference_wrapper<
            const typename std::remove_reference_t<ContTarget>::value_type>,
        // Universal references to 'ContArgs' *can* be const
        std::conditional_t<
            // Check if container is const
            std::is_const_v<std::remove_reference_t<ContArgs>>,
            // If true:
            std::reference_wrapper<
                const typename std::remove_reference_t<ContArgs>::value_type>,
            // If false:
            std::reference_wrapper<
                typename std::remove_reference_t<ContArgs>::value_type>>...>;
 
    // Create a container of tuples of arguments and shuffle it
    std::vector<Tuple> args_container(begin(range), end(range));
    std::shuffle(
        begin(args_container), end(args_container), std::forward<RNG>(rng));
 
    // Apply the rule, distinguishing by return type of the rule
    using State = typename impl::entity_t<ContTarget>::State;
    if constexpr(is_void_rule<State, Rule, ContTarget, ContArgs...>())
    {
        // Is a void-rule; no need to set the return value
        std::for_each(policy,
                      begin(args_container),
                      end(args_container),
                      [&rule](auto&& args) {
                          // NOTE: 'args' is tuple of reference_wrappers, and we
                          // want a tuple of regular references.
                          std::apply(rule,
                                     make_tuple_from_tuple(
                                       std::forward<decltype(args)>(args)));
                      });
    }
    else
    {
        std::for_each(policy,
                      begin(args_container),
                      end(args_container),
                      [&rule](auto&& args) {
                          // NOTE: 'args' is tuple of reference_wrappers, and we
                          //       want a tuple of regular references.
                          auto tpl = make_tuple_from_tuple(
                            std::forward<decltype(args)>(args));
                          auto& entity = std::get<0>(tpl);
                          // NOTE: Do not move 'tpl' as this invalidates ref
                          //       'entity'
                          entity->state = std::apply(rule, tpl);
                      });
    }
}
 
 
// -- Synchronous state updates -----------------------------------------------
 
template<
    class Rule,
    class Container,
    bool sync=impl::entity_t<Container>::is_sync()>
std::enable_if_t<sync, void>
    apply_rule(const Rule& rule, const Container& container)
{
    // Apply the rule, distinguishing by return type of the rule
    using ReturnType =
        std::invoke_result_t<Rule, typename Container::value_type>;
 
    if constexpr(std::is_same_v<ReturnType, void>) {
        std::for_each(
            std::begin(container), std::end(container),
            [&rule](const auto& entity){ rule(entity); }
        );
    }
    else {
        std::for_each(
            std::begin(container), std::end(container),
            [&rule](const auto& entity){ entity->state_new() = rule(entity); }
        );
    }
 
    // Let the entity update its state, moving it from the buffer state to the
    // actual state and potentially applying other updating operations
    std::for_each(
        std::begin(container), std::end(container),
        [](const auto& entity){ entity->update(); }
    );
}
 
 
// -- Asynchronous state updates ----------------------------------------------
 
template<
    bool shuffle=true,
    class Rule,
    class Container,
    bool sync=impl::entity_t<Container>::is_sync()>
std::enable_if_t<not sync && not shuffle, void>
    apply_rule(const Rule& rule, const Container& container)
{
    // Apply the rule, distinguishing by return type of the rule
    using ReturnType =
        std::invoke_result_t<Rule, typename Container::value_type>;
 
    if constexpr(std::is_same_v<ReturnType, void>) {
        std::for_each(
            std::begin(container), std::end(container),
            [&rule](const auto& entity){ rule(entity); }
        );
    }
    else {
        std::for_each(
            std::begin(container), std::end(container),
            [&rule](const auto& entity){ entity->state() = rule(entity); }
        );
    }
}
 
 
 
template<
    bool shuffle=true,
    class Rule,
    class Container,
    class RNG,
    bool sync=impl::entity_t<Container>::is_sync()>
std::enable_if_t<not sync && shuffle, void>
    apply_rule(const Rule& rule, const Container& container, RNG&& rng)
{
    std::remove_const_t<Container> container_shuffled(container);
    std::shuffle(std::begin(container_shuffled),
                 std::end(container_shuffled),
                 std::forward<RNG>(rng));
 
    // Apply the rule, distinguishing by return type of the rule
    using ReturnType =
        std::invoke_result_t<Rule, typename Container::value_type>;
 
    if constexpr(std::is_same_v<ReturnType, void>)
    {
        std::for_each(
            std::begin(container_shuffled), std::end(container_shuffled),
            [&rule](const auto& entity){ rule(entity); }
        );
    }
    else
    {
        std::for_each(
            std::begin(container_shuffled), std::end(container_shuffled),
            [&rule](const auto& entity){ entity->state() = rule(entity); }
        );
    }
}
 
} // namespace Utopia
 
#endif // UTOPIA_CORE_APPLY_HH