Acts/Propagator/ActorConcepts.hpp

0001 // This file is part of the ACTS project.
0002 //
0003 // Copyright (C) 2016 CERN for the benefit of the ACTS project
0004 //
0005 // This Source Code Form is subject to the terms of the Mozilla Public
0006 // License, v. 2.0. If a copy of the MPL was not distributed with this
0007 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
0008
0009 #pragma once
0010
0011 #include "Acts/Utilities/Result.hpp"
0012
0013 #include <concepts>
0014 #include <type_traits>
0015 #include <utility>
0016
0017 namespace Acts {
0018
0019 template <typename actor_t>
0020 concept ActorHasResult = requires { typename actor_t::result_type; };
0021
0022 template <typename actor_t>
0023 struct ActorHasResultStruct {
0024   static constexpr bool value = ActorHasResult<actor_t>;
0025 };
0026
0027 template <typename actor_t, typename propagator_state_t, typename stepper_t,
0028           typename navigator_t, typename... Args>
0029 concept ActorHasActWithoutResult = requires(
0030     const actor_t& a, propagator_state_t& state, const stepper_t& stepper,
0031     const navigator_t& navigator, Args&&... args) {
0032   {
0033     a.act(state, stepper, navigator, std::forward<Args>(args)...)
0034   } -> std::same_as<Result<void>>;
0035 };
0036
0037 template <typename actor_t, typename propagator_state_t, typename stepper_t,
0038           typename navigator_t, typename... Args>
0039 concept ActorHasActWithResult =
0040     ActorHasResult<actor_t> &&
0041     requires(const actor_t& a, propagator_state_t& state,
0042              const stepper_t& stepper, const navigator_t& navigator,
0043              typename actor_t::result_type& result, Args&&... args) {
0044       {
0045         a.act(state, stepper, navigator, result, std::forward<Args>(args)...)
0046       } -> std::same_as<Result<void>>;
0047     };
0048
0049 template <typename actor_t, typename propagator_state_t, typename stepper_t,
0050           typename navigator_t, typename... Args>
0051 concept ActorHasOldVoidInterface =
0052     // Check without result parameter (for actors without result_type)
0053     requires(const actor_t& a, propagator_state_t& state,
0054              const stepper_t& stepper, const navigator_t& navigator,
0055              Args&&... args) {
0056       {
0057         a.act(state, stepper, navigator, std::forward<Args>(args)...)
0058       } -> std::same_as<void>;
0059     } ||
0060     // Check with result parameter (for actors with result_type)
0061     (ActorHasResult<actor_t> &&
0062      requires(const actor_t& a, propagator_state_t& state,
0063               const stepper_t& stepper, const navigator_t& navigator,
0064               typename actor_t::result_type& result, Args&&... args) {
0065        {
0066          a.act(state, stepper, navigator, result, std::forward<Args>(args)...)
0067        } -> std::same_as<void>;
0068      });
0069
0070 template <typename actor_t, typename propagator_state_t, typename stepper_t,
0071           typename navigator_t, typename... Args>
0072 concept ActorHasAct =
0073     ActorHasActWithoutResult<actor_t, propagator_state_t, stepper_t,
0074                              navigator_t, Args...> ||
0075     ActorHasActWithResult<actor_t, propagator_state_t, stepper_t, navigator_t,
0076                           Args...>;
0077
0078 template <typename actor_t, typename propagator_state_t, typename stepper_t,
0079           typename navigator_t, typename... Args>
0080 concept ActorHasAbortWithoutResult = requires(
0081     const actor_t& a, propagator_state_t& state, const stepper_t& stepper,
0082     const navigator_t& navigator, Args&&... args) {
0083   {
0084     a.checkAbort(state, stepper, navigator, std::forward<Args>(args)...)
0085   } -> std::same_as<bool>;
0086 };
0087
0088 template <typename actor_t, typename propagator_state_t, typename stepper_t,
0089           typename navigator_t, typename... Args>
0090 concept ActorHasAbortWithResult =
0091     ActorHasResult<actor_t> &&
0092     requires(const actor_t& a, propagator_state_t& state,
0093              const stepper_t& stepper, const navigator_t& navigator,
0094              typename actor_t::result_type& result, Args&&... args) {
0095       {
0096         a.checkAbort(state, stepper, navigator, result,
0097                      std::forward<Args>(args)...)
0098       } -> std::same_as<bool>;
0099     };
0100
0101 template <typename actor_t, typename propagator_state_t, typename stepper_t,
0102           typename navigator_t, typename... Args>
0103 concept ActorHasAbort =
0104     ActorHasAbortWithoutResult<actor_t, propagator_state_t, stepper_t,
0105                                navigator_t, Args...> ||
0106     ActorHasAbortWithResult<actor_t, propagator_state_t, stepper_t, navigator_t,
0107                             Args...>;
0108
0109 template <typename actor_t, typename propagator_state_t, typename stepper_t,
0110           typename navigator_t, typename... Args>
0111 concept Actor = (ActorHasAct<actor_t, propagator_state_t, stepper_t,
0112                              navigator_t, Args...> ||
0113                  ActorHasAbort<actor_t, propagator_state_t, stepper_t,
0114                                navigator_t, Args...>) &&
0115                 !ActorHasOldVoidInterface<actor_t, propagator_state_t,
0116                                           stepper_t, navigator_t, Args...>;
0117
0118 }  // namespace Acts