dependency_context.hpp concepts tuple type_traits utility serif/utils/dependencies/resource.hpp serif/utils/dependencies/detail/type_lists.hpp serif/utils/misc/concepts/concat.hpp src/compile_time_checks/serif/discretization/fields_meanfield.cpp src/compile_time_checks/serif/utils/dependencies/dependency_context.cpp src/include/serif/backend/mfem/discretization/resources.hpp src/include/serif/backend/mfem/discretization/term_coefficients.hpp src/include/serif/backend/mfem/geometry/deformation/inputs.hpp src/include/serif/operators/linearized_system_view.hpp src/include/serif/solver/normalization/configuration.hpp src/include/serif/utils/dependencies/dependencies.hpp src/include/serif/utils/dependencies/detail/schema.hpp src/include/serif/utils/serialize/model.hpp serif::utils::dependencies::DependencyContext serif::utils::dependencies::DependencyContextView< ParentT, KeyList< KeyTs... > > serif serif::utils serif::utils::dependencies serif::utils::dependencies::detail #pragmaonce #include<concepts> #include<tuple> #include<type_traits> #include<utility> #include"serif/utils/dependencies/resource.hpp" #include"serif/utils/dependencies/detail/type_lists.hpp" #include"serif/utils/misc/concepts/concat.hpp" namespaceserif::utils::dependencies{ template<typenameParentT,IsKeyListKeysT> requiresSatisfiesKeyList<typename ParentT::Bindings, KeysT> classDependencyContextView; template<IsResource...ResourceTs> requiresmisc::traits::all_unique_types_v<typenameResourceTs::Key...> classDependencyContext{ public: usingResources=types::TypeList<ResourceTs...>; usingKeys=KeyList<typenameResourceTs::Key...>; usingBindings=dependencies::Bindings<Binding<typename ResourceTs::Key, typename ResourceTs::Target>...>; usingResourceBindings=dependencies::Bindings<Binding<typename ResourceTs::Key, ResourceTs>...>; explicit(sizeof...(ResourceTs)!=0)DependencyContext(ResourceTs...resources):m_resources(std::move(resources)...){} template<typenameKeyT>requiresBindingsWithBinding<Bindings, KeyT> [[nodiscard]]constauto&get()const{ returnresource<KeyT>().get(); } template<typenameKeyT>requiresBindingsWithBinding<Bindings, KeyT> [[nodiscard]]constauto&resource()const{ constexprstd::size_tindex=detail::type_index<KeyT>(types::TypeList<typename ResourceTs::Key...>{}); returnstd::get<index>(m_resources); } template<IsKeyListKeysT>requiresSatisfiesKeyList<Bindings, KeysT> [[nodiscard]]autoselect(KeysT)const&{ returnDependencyContextView<DependencyContext, std::remove_cvref_t<KeysT>>(*this); } template<IsKeyListKeysT> autoselect(KeysT)const&&=delete; private: std::tuple<ResourceTs...>m_resources; }; template<typenameParentT,typename...KeyTs> requiresSatisfiesKeyList<typenameParentT::Bindings,KeyList<KeyTs...>> classDependencyContextView<ParentT,KeyList<KeyTs...>>{ public: usingKeys=KeyList<KeyTs...>; usingBindings=dependencies::Bindings<Binding<KeyTs, bound_type_t<typename ParentT::Bindings, KeyTs>>...>; usingResourceBindings=dependencies::Bindings<Binding<KeyTs, bound_type_t<typename ParentT::ResourceBindings, KeyTs>>...>; usingResources=types::TypeList<bound_type_t<typename ParentT::ResourceBindings, KeyTs>...>; explicitDependencyContextView(constParentT&parent):m_parent(parent){} DependencyContextView(constParentT&&)=delete; template<typenameKeyT>requiresBindingsWithBinding<Bindings, KeyT> [[nodiscard]]constauto&get()const{ returnm_parent.templateget<KeyT>(); } template<typenameKeyT>requiresBindingsWithBinding<Bindings, KeyT> [[nodiscard]]constauto&resource()const{ returnm_parent.templateresource<KeyT>(); } private: constParentT&m_parent; }; template<typenameT> inlineconstexprboolis_dependency_context_v=false; template<typename...Resources> inlineconstexprboolis_dependency_context_v<DependencyContext<Resources...>>=true; template<typenameParentT,typenameKeysT> inlineconstexprboolis_dependency_context_v<DependencyContextView<ParentT, KeysT>>=true; template<typenameT> conceptIsDependencyContext=is_dependency_context_v<std::remove_cvref_t<T>>; template<typename...Resources> requires(IsResource<Resources>&&...)&&misc::traits::all_unique_types_v<typename std::remove_cvref_t<Resources>::Key...> [[nodiscard]]automake_dependency_context(Resources&&...resources){ returnDependencyContext<std::remove_cvref_t<Resources>...>(std::forward<Resources>(resources)...); } namespacedetail{ template<typename...Resources> [[nodiscard]]constevalboolcombinable_resources(types::TypeList<Resources...>){ return(std::copy_constructible<Resources>&&...)&&misc::traits::all_unique_types_v<typenameResources::Key...>; } } template<IsDependencyContext...Contexts> requires(detail::combinable_resources(misc::concepts::ConcatT<typename Contexts::Resources...>{})) [[nodiscard]]autocombine_dependency_contexts(constContexts&...contexts){ constautoresources=[]<typename...Resources>(constauto&context,types::TypeList<Resources...>){ returnstd::tie(context.templateresource<typenameResources::Key>()...); }; returnstd::apply([](constauto&...entries){ returnmake_dependency_context(entries...); },std::tuple_cat(resources(contexts,typenameContexts::Resources{})...)); } }