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 /// Helper struct exposing ActorHasResult as a boolean.
0023 template <typename actor_t>
0024 struct ActorHasResultStruct {
0025   /// Whether the actor has a result type
0026   static constexpr bool value = ActorHasResult<actor_t>;
0027 };
0028
0029 template <typename actor_t, typename propagator_state_t, typename stepper_t,
0030           typename navigator_t, typename... Args>
0031 concept ActorHasActWithoutResult = requires(
0032     const actor_t& a, propagator_state_t& state, const stepper_t& stepper,
0033     const navigator_t& navigator, Args&&... args) {
0034   {
0035     a.act(state, stepper, navigator, std::forward<Args>(args)...)
0036   } -> std::same_as<Result<void>>;
0037 };
0038
0039 template <typename actor_t, typename propagator_state_t, typename stepper_t,
0040           typename navigator_t, typename... Args>
0041 concept ActorHasActWithResult =
0042     ActorHasResult<actor_t> &&
0043     requires(const actor_t& a, propagator_state_t& state,
0044              const stepper_t& stepper, const navigator_t& navigator,
0045              typename actor_t::result_type& result, Args&&... args) {
0046       {
0047         a.act(state, stepper, navigator, result, std::forward<Args>(args)...)
0048       } -> std::same_as<Result<void>>;
0049     };
0050
0051 template <typename actor_t, typename propagator_state_t, typename stepper_t,
0052           typename navigator_t, typename... Args>
0053 concept ActorHasOldVoidInterface =
0054     // Check without result parameter (for actors without result_type)
0055     requires(const actor_t& a, propagator_state_t& state,
0056              const stepper_t& stepper, const navigator_t& navigator,
0057              Args&&... args) {
0058       {
0059         a.act(state, stepper, navigator, std::forward<Args>(args)...)
0060       } -> std::same_as<void>;
0061     } ||
0062     // Check with result parameter (for actors with result_type)
0063     (ActorHasResult<actor_t> &&
0064      requires(const actor_t& a, propagator_state_t& state,
0065               const stepper_t& stepper, const navigator_t& navigator,
0066               typename actor_t::result_type& result, Args&&... args) {
0067        {
0068          a.act(state, stepper, navigator, result, std::forward<Args>(args)...)
0069        } -> std::same_as<void>;
0070      });
0071
0072 template <typename actor_t, typename propagator_state_t, typename stepper_t,
0073           typename navigator_t, typename... Args>
0074 concept ActorHasAct =
0075     ActorHasActWithoutResult<actor_t, propagator_state_t, stepper_t,
0076                              navigator_t, Args...> ||
0077     ActorHasActWithResult<actor_t, propagator_state_t, stepper_t, navigator_t,
0078                           Args...>;
0079
0080 template <typename actor_t, typename propagator_state_t, typename stepper_t,
0081           typename navigator_t, typename... Args>
0082 concept ActorHasAbortWithoutResult = requires(
0083     const actor_t& a, propagator_state_t& state, const stepper_t& stepper,
0084     const navigator_t& navigator, Args&&... args) {
0085   {
0086     a.checkAbort(state, stepper, navigator, std::forward<Args>(args)...)
0087   } -> std::same_as<bool>;
0088 };
0089
0090 template <typename actor_t, typename propagator_state_t, typename stepper_t,
0091           typename navigator_t, typename... Args>
0092 concept ActorHasAbortWithResult =
0093     ActorHasResult<actor_t> &&
0094     requires(const actor_t& a, propagator_state_t& state,
0095              const stepper_t& stepper, const navigator_t& navigator,
0096              typename actor_t::result_type& result, Args&&... args) {
0097       {
0098         a.checkAbort(state, stepper, navigator, result,
0099                      std::forward<Args>(args)...)
0100       } -> std::same_as<bool>;
0101     };
0102
0103 template <typename actor_t, typename propagator_state_t, typename stepper_t,
0104           typename navigator_t, typename... Args>
0105 concept ActorHasAbort =
0106     ActorHasAbortWithoutResult<actor_t, propagator_state_t, stepper_t,
0107                                navigator_t, Args...> ||
0108     ActorHasAbortWithResult<actor_t, propagator_state_t, stepper_t, navigator_t,
0109                             Args...>;
0110
0111 template <typename actor_t, typename propagator_state_t, typename stepper_t,
0112           typename navigator_t, typename... Args>
0113 concept Actor = (ActorHasAct<actor_t, propagator_state_t, stepper_t,
0114                              navigator_t, Args...> ||
0115                  ActorHasAbort<actor_t, propagator_state_t, stepper_t,
0116                                navigator_t, Args...>) &&
0117                 !ActorHasOldVoidInterface<actor_t, propagator_state_t,
0118                                           stepper_t, navigator_t, Args...>;
0119
0120 }  // namespace Acts