abort_list_implementation.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file abort_list_implementation.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2018 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

#include <algorithm>
#include "Acts/Utilities/detail/MPL/type_collector.hpp"

namespace Acts {

namespace detail {

namespace {
template <bool has_result = true>
struct condition_caller {
  template <typename condition, typename result_t, typename propagator_state_t,
            typename stepper_t>
  static bool check(const condition& c, const result_t& r,
                    propagator_state_t& state, const stepper_t& stepper) {
    using action_type = action_type_t<condition>;
    using result_type = result_type_t<action_type>;

    return c(state, stepper, r.template get<result_type>());
  }
};

template <>
struct condition_caller<false> {
  template <typename condition, typename result_t, typename propagator_state_t,
            typename stepper_t>
  static bool check(const condition& c, const result_t& /*result*/,
                    propagator_state_t& state, const stepper_t& stepper) {
    return c(state, stepper);
  }
};
}  // end of anonymous namespace

template <typename... conditions>
struct abort_list_impl;

template <typename first, typename... others>
struct abort_list_impl<first, others...> {
  template <typename T, typename result_t, typename propagator_state_t,
            typename stepper_t>
  static bool check(const T& conditions_tuple, const result_t& result,
                    propagator_state_t& state, const stepper_t& stepper) {
    // get the right helper for calling the abort condition
    constexpr bool has_result = has_action_type_v<first>;
    using caller_type = condition_caller<has_result>;

    // get the cache abort condition
    const auto& this_condition = std::get<first>(conditions_tuple);

    // - check abort conditions recursively
    // - make use of short-circuit evaluation
    // -> skip remaining conditions if this abort condition evaluates to true
    bool abort = caller_type::check(this_condition, result, state, stepper) ||
                 abort_list_impl<others...>::check(conditions_tuple, result,
                                                   state, stepper);

    return abort;
  }
};

template <typename last>
struct abort_list_impl<last> {
  template <typename T, typename result_t, typename propagator_state_t,
            typename stepper_t>
  static bool check(const T& conditions_tuple, const result_t& result,
                    propagator_state_t& state, const stepper_t& stepper) {
    // get the right helper for calling the abort condition
    constexpr bool has_result = has_action_type_v<last>;
    const auto& this_condition = std::get<last>(conditions_tuple);

    return condition_caller<has_result>::check(this_condition, result, state,
                                               stepper);
  }
};

template <>
struct abort_list_impl<> {
  template <typename T, typename result_t, typename propagator_state_t,
            typename stepper_t>
  static bool check(const T& /*unused*/, const result_t& /*result*/,
                    propagator_state_t& /*state*/,
                    const stepper_t& /*unused*/) {
    return false;
  }
};

}  // namespace detail

}  // namespace Acts