binding.cpp array cstddef utility serif/utils/dependencies/binding.hpp src/compile_time_checks/serif/utils/dependencies/binding.cpp serif/utils/dependencies/binding.hpp serif/utils/misc/std_helper/cleaning.hpp serif/utils/misc/traits/type_uniqueness.hpp array cstddef type_traits utility #include<array> #include<cstddef> #include<utility> #include"serif/utils/dependencies/binding.hpp" namespace{ namespacedependencies=serif::utils::dependencies; structFirstKey{}; structSecondKey{}; structMissingKey{}; structUnrelatedBinding{ usingKey=FirstKey; usingTarget=int; }; usingEmpty=dependencies::Bindings<>; usingCollection=dependencies::Bindings<dependencies::Binding<FirstKey,int>,dependencies::Binding<SecondKey,double>>; usingRepeatedTargets=dependencies::Bindings<dependencies::Binding<FirstKey,int>,dependencies::Binding<SecondKey,int>>; usingDuplicateKeys=dependencies::Bindings<dependencies::Binding<FirstKey,int>,dependencies::Binding<FirstKey,double>>; usingQualifiedKeys=dependencies::Bindings< dependencies::Binding<constFirstKey,int>, dependencies::Binding<FirstKey&,double> >; usingQualifiedTarget=dependencies::Bindings<dependencies::Binding<FirstKey,constint&>>; template<typenameBindingsT,typenameKeyT> conceptHasBoundType=requires{ typenamedependencies::bound_type_t<BindingsT,KeyT>; }; template<typenameBindingsT,typenameKeyT> conceptHasBoundTypeMember=requires{ typenamedependencies::BoundType<BindingsT,KeyT>::target_type; }; static_assert(dependencies::IsBinding<dependencies::Binding<FirstKey,int>>); static_assert(!dependencies::IsBinding<UnrelatedBinding>); static_assert(!dependencies::IsBinding<int>); static_assert(dependencies::IsBindings<Empty>); static_assert(dependencies::IsBindings<Collection>); static_assert(dependencies::IsBindings<RepeatedTargets>); static_assert(!dependencies::IsBindings<DuplicateKeys>); static_assert(!dependencies::IsBindings<int>); static_assert(dependencies::HasBinding<Collection,FirstKey>::value); static_assert(dependencies::has_binding_v<Collection,SecondKey>); static_assert(!dependencies::has_binding_v<Collection,MissingKey>); static_assert(!dependencies::has_binding_v<Empty,FirstKey>); static_assert(std::is_same_v<dependencies::bound_type_t<Collection,FirstKey>,int>); static_assert(std::is_same_v<dependencies::bound_type_t<Collection,SecondKey>,double>); static_assert(std::is_same_v<dependencies::bound_type_t<RepeatedTargets,SecondKey>,int>); static_assert(std::is_same_v<dependencies::bound_type_t<QualifiedTarget,FirstKey>,constint&>); //EverypubliclookupacceptsthequalifiedcollectiontypesrecognizedbyIsBindings. static_assert(dependencies::IsBindings<constvolatileCollection&>); static_assert(dependencies::HasBinding<constCollection&,FirstKey>::value); static_assert(dependencies::has_binding_v<constvolatileCollection&,FirstKey>); static_assert(dependencies::BindingsWithBinding<Collection&&,FirstKey>); static_assert(std::is_same_v<dependencies::BoundType<constCollection&,FirstKey>::target_type,int>); static_assert(std::is_same_v<dependencies::bound_type_t<constvolatileCollection&,SecondKey>,double>); //Qualifiedkeysaredistinctassociations;queriesmustagreewiththeirexactstoredtypes. static_assert(dependencies::IsBindings<QualifiedKeys>); static_assert(dependencies::has_binding_v<QualifiedKeys,constFirstKey>); static_assert(dependencies::BindingsWithBinding<QualifiedKeys,constFirstKey>); static_assert(dependencies::BindingsWithBinding<QualifiedKeys,FirstKey&>); static_assert(!dependencies::has_binding_v<QualifiedKeys,FirstKey>); static_assert(!dependencies::BindingsWithBinding<QualifiedKeys,FirstKey>); static_assert(std::is_same_v<dependencies::bound_type_t<QualifiedKeys,constFirstKey>,int>); static_assert(std::is_same_v<dependencies::bound_type_t<QualifiedKeys,FirstKey&>,double>); //Missingkeysandinvalidcollectionsmustfailtheserequirementswithoutahardcompilererror. static_assert(HasBoundType<Collection, FirstKey>); static_assert(HasBoundTypeMember<Collection, SecondKey>); static_assert(!HasBoundType<Collection, MissingKey>); static_assert(!HasBoundTypeMember<Collection, MissingKey>); static_assert(!HasBoundType<Empty, FirstKey>); static_assert(!HasBoundTypeMember<Empty, FirstKey>); static_assert(!HasBoundType<QualifiedKeys, FirstKey>); static_assert(!HasBoundType<DuplicateKeys, FirstKey>); static_assert(!HasBoundTypeMember<DuplicateKeys, FirstKey>); static_assert(!dependencies::BindingsWithBinding<DuplicateKeys,FirstKey>); static_assert(!dependencies::BindingsWithBinding<int,FirstKey>); static_assert(!HasBoundType<int, FirstKey>); static_assert(!HasBoundTypeMember<int, FirstKey>); template<std::size_tIndex> structIndexedKey{}; template<std::size_tIndex> structIndexedTarget{ IndexedTarget()=delete; }; template<std::size_t...Indices> constevalboolevery_binding_resolves(std::index_sequence<Indices...>){ usingLargeCollection=dependencies::Bindings<dependencies::Binding<IndexedKey<Indices>,IndexedTarget<Indices>>...>; constexprstd::array<bool,sizeof...(Indices)>resolved{ std::is_same_v<dependencies::bound_type_t<LargeCollection,IndexedKey<Indices>>,IndexedTarget<Indices>>...}; for(constboolcorrect:resolved){ if(!correct){returnfalse;} } return!dependencies::has_binding_v<LargeCollection,MissingKey>; } static_assert(every_binding_resolves(std::make_index_sequence<300>{})); template<typename...Types> conceptCanMakeBindings=requires{typenamedependencies::Bindings<Types...>;}; static_assert(CanMakeBindings<>); static_assert(CanMakeBindings<dependencies::Binding<FirstKey, int>>); static_assert(!CanMakeBindings<int, dependencies::Binding<FirstKey, int>>); static_assert(!CanMakeBindings<dependencies::Binding<FirstKey, int>,int>); static_assert(!CanMakeBindings<UnrelatedBinding>); }