diff --git a/src/common/advice/index.hpp b/src/common/advice/index.hpp index 10f4323c6..6e4d3339b 100644 --- a/src/common/advice/index.hpp +++ b/src/common/advice/index.hpp @@ -171,8 +171,8 @@ namespace advice { }; - typedef vector EntryList; - typedef typename EntryList::iterator EIter; + using EntryList = vector; + using EIter = EntryList::iterator; struct Cluster @@ -249,7 +249,7 @@ namespace advice { POA* find_latest_solution (POA& requestElm) { - typedef typename EntryList::reverse_iterator RIter; + using RIter = EntryList::reverse_iterator; Binding::Matcher pattern (requestElm.getMatcher()); for (RIter ii=this->elms_.rbegin(); ii!=this->elms_.rend(); @@ -514,8 +514,8 @@ namespace advice { bool Index::isValid() const { - typedef typename RTable::const_iterator RTIter; - typedef typename PTable::const_iterator PTIter; + using RTIter = RTable::const_iterator; + using PTIter = PTable::const_iterator; try { for (PTIter ii =provisionEntries_.begin(); diff --git a/src/common/instancehandle.hpp b/src/common/instancehandle.hpp index 906357539..a067d9c00 100644 --- a/src/common/instancehandle.hpp +++ b/src/common/instancehandle.hpp @@ -112,7 +112,7 @@ namespace lumiera { /** The ServiceHandle automatically creates and manages the Proxy instance */ template - using ServiceHandle = typename lib::DependInject::template ServiceInstance>>; + using ServiceHandle = lib::DependInject::template ServiceInstance>>; /** diff --git a/src/common/query.hpp b/src/common/query.hpp index 1adba1ad9..62be08cab 100644 --- a/src/common/query.hpp +++ b/src/common/query.hpp @@ -538,7 +538,7 @@ namespace lumiera { template - inline typename Query::Builder + inline Query::Builder Query::build (Kind queryType) { return Builder(defineQueryTypeID (queryType)); @@ -546,7 +546,7 @@ namespace lumiera { template - inline typename Query::Builder + inline Query::Builder Query::rebuild() const { return Builder(this->id_, getQueryDefinition()); diff --git a/src/common/query/defs-registry.hpp b/src/common/query/defs-registry.hpp index be56a11d2..e258e918c 100644 --- a/src/common/query/defs-registry.hpp +++ b/src/common/query/defs-registry.hpp @@ -78,7 +78,7 @@ namespace query { /** we maintain an independent defaults registry * for every participating kind of object. */ - typedef std::vector< P > Table; + using Table = std::vector< P >; /** @@ -132,7 +132,7 @@ namespace query { struct Slot : public TableEntry { - typedef std::set> Registry; + using Registry = std::set>; Registry registry; static size_t index; ///< where to find this Slot in every Table @@ -194,7 +194,7 @@ namespace query { class Iter { friend class DefsRegistry; - typedef typename Slot::Registry::iterator II; + using II = Slot::Registry::iterator; II p,i,e; P next, ptr; @@ -251,12 +251,12 @@ namespace query { { P dummy; Record entry (query, dummy); - typedef typename Slot::Registry Registry; + using Registry = Slot::Registry; Registry& registry = Slot::access(table_); // try to get a possible direct match (same query) - typename Registry::iterator pos = registry.find (entry); - typename Registry::iterator end = registry.end(); + auto pos = registry.find (entry); + auto end = registry.end(); if (pos==end) return Iter (registry.begin(), end); // just enumerate contents @@ -277,8 +277,8 @@ namespace query { put (P const& obj, Query const& query) { Record entry (query, obj); - typedef typename Slot::Registry Registry; - typedef typename Registry::iterator RIter; + using Registry = Slot::Registry; + using RIter = Registry::iterator; Registry& registry = Slot::access(table_); RIter pos = registry.lower_bound (entry); @@ -306,8 +306,8 @@ namespace query { bool forget (P const& obj) { - typedef typename Slot::Registry Registry; - typedef typename Record::Search SearchFunc; + using Registry = Slot::Registry; + using SearchFunc = Record::Search; Registry& registry = Slot::access(table_); return util::remove_if(registry, SearchFunc (obj)); diff --git a/src/common/query/query-resolver.hpp b/src/common/query/query-resolver.hpp index 94554427a..564aa3da0 100644 --- a/src/common/query/query-resolver.hpp +++ b/src/common/query/query-resolver.hpp @@ -137,7 +137,7 @@ namespace lumiera { template - inline typename Query::iterator + inline Query::iterator Query::resolveBy (QueryResolver const& resolver) const { PReso resultSet = resolver.issue (*this); @@ -150,7 +150,7 @@ namespace lumiera { /** notational convenience shortcut, * synonymous to Query::resolveBy() */ template - inline typename Query::iterator + inline Query::iterator Query::operator() (QueryResolver const& resolver) const { return resolveBy (resolver); diff --git a/src/lib/allocation-cluster.hpp b/src/lib/allocation-cluster.hpp index 067935909..ca54f5674 100644 --- a/src/lib/allocation-cluster.hpp +++ b/src/lib/allocation-cluster.hpp @@ -347,14 +347,14 @@ namespace lib { struct SetupSeveral { template - using Adapter = typename AllocationCluster::template Allocator; + using Adapter = AllocationCluster::template Allocator; template struct Policy : AllocationPolicy { using Base = AllocationPolicy; - using Bucket = typename Base::Bucket; + using Bucket = Base::Bucket; /** @warning allocation size is severely limited in AllocationCluster. */ size_t static constexpr ALLOC_LIMIT = AllocationCluster::max_size(); diff --git a/src/lib/allocator-handle.hpp b/src/lib/allocator-handle.hpp index 6914dbe3b..d7c0477f3 100644 --- a/src/lib/allocator-handle.hpp +++ b/src/lib/allocator-handle.hpp @@ -89,7 +89,7 @@ namespace lib { { using Allo = ALO; using AlloT = std::allocator_traits; - using BaseType = typename Allo::value_type; + using BaseType = Allo::value_type; Allo& baseAllocator() { return *this; } @@ -97,7 +97,7 @@ namespace lib { auto adaptAllocator() { - using XAllo = typename AlloT::template rebind_alloc; + using XAllo = AlloT::template rebind_alloc; if constexpr (std::is_constructible_v) return XAllo{baseAllocator()}; else @@ -105,8 +105,8 @@ namespace lib { } template - typename ALOT::pointer - construct (typename ALOT::allocator_type& allo, ARGS&& ...args) + ALOT::pointer + construct (ALOT::allocator_type& allo, ARGS&& ...args) { auto loc = ALOT::allocate (allo, 1); try { ALOT::construct (allo, loc, std::forward(args)...); } @@ -120,7 +120,7 @@ namespace lib { template void - destroy (typename ALOT::allocator_type& allo, typename ALOT::pointer elm) + destroy (ALOT::allocator_type& allo, ALOT::pointer elm) { ALOT::destroy (allo, elm); ALOT::deallocate (allo, elm, 1); @@ -167,7 +167,7 @@ namespace lib { } else { - using XAlloT = typename AlloT::template rebind_traits; + using XAlloT = AlloT::template rebind_traits; auto xAllo = adaptAllocator(); return construct (xAllo, std::forward(args)...); } @@ -184,7 +184,7 @@ namespace lib { } else { - using XAlloT = typename AlloT::template rebind_traits; + using XAlloT = AlloT::template rebind_traits; auto xAllo = adaptAllocator(); destroy (xAllo, elm); } diff --git a/src/lib/depend-inject.hpp b/src/lib/depend-inject.hpp index 72bf9f068..6a3edebd6 100644 --- a/src/lib/depend-inject.hpp +++ b/src/lib/depend-inject.hpp @@ -148,8 +148,8 @@ namespace lib { class DependInject : util::NoInstance { - using Factory = typename Depend::Factory; - using Lock = typename Depend::Lock; + using Factory = Depend::Factory; + using Lock = Depend::Lock; public: /** configure dependency-injection for type SRV to build a subclass singleton. @@ -178,8 +178,8 @@ namespace lib { static void useSingleton (FUN&& ctor) { - using Sub = typename SubclassFactoryType::Subclass; - using Fun = typename SubclassFactoryType::Functor; + using Sub = SubclassFactoryType::Subclass; + using Fun = SubclassFactoryType::Functor; __assert_compatible(); installFactory (forward (ctor)); @@ -372,9 +372,9 @@ namespace lib { static_assert (meta::_Fun(), "Need a Lambda or Function object to create a heap allocated instance"); - using Functor = typename meta::_Fun::Functor; // suitable type to store for later invocation - using ResultVal = typename meta::_Fun::Ret; - using Subclass = typename meta::Strip::TypePlain; + using Functor = meta::_Fun::Functor; // suitable type to store for later invocation + using ResultVal = meta::_Fun::Ret; + using Subclass = meta::Strip::TypePlain; static_assert (std::is_pointer::value, "Function must yield a pointer to a heap allocated instance"); diff --git a/src/lib/diff/diff-language.hpp b/src/lib/diff/diff-language.hpp index 9f2f51aba..18b3cd7f0 100644 --- a/src/lib/diff/diff-language.hpp +++ b/src/lib/diff/diff-language.hpp @@ -106,7 +106,7 @@ namespace diff{ struct InterpreterScheme ///< base case is to expect typedef I::Val { using Interpreter = I; - using Val = typename I::Val; + using Val = I::Val; using Handler = HandlerFun; }; @@ -188,12 +188,12 @@ namespace diff{ struct DiffStepBuilder { using Scheme = InterpreterScheme; - using Handler = typename Scheme::Handler; - using Val = typename Scheme::Val; + using Handler = Scheme::Handler; + using Val = Scheme::Val; using Lang = DiffLanguage; - using Step = typename Lang::DiffStep; - using Verb = typename Lang::DiffVerb; + using Step = Lang::DiffStep; + using Verb = Lang::DiffVerb; Handler handler; Literal id; @@ -239,7 +239,7 @@ namespace diff{ * @warning use for internal state marking only -- * invoking this token produces undefined behaviour */ template - const typename DiffLanguage::DiffStep DiffLanguage::NIL = DiffStep(DiffVerb(), E()); + const DiffLanguage::DiffStep DiffLanguage::NIL = DiffStep(DiffVerb(), E()); diff --git a/src/lib/diff/gen-node.hpp b/src/lib/diff/gen-node.hpp index 2957d6047..a52691b21 100644 --- a/src/lib/diff/gen-node.hpp +++ b/src/lib/diff/gen-node.hpp @@ -119,7 +119,7 @@ namespace diff{ struct RecordSetup { using Storage = std::vector; - using ElmIter = typename Storage::const_iterator; + using ElmIter = Storage::const_iterator; /** using const reference data access * relevant for handling large subtrees */ @@ -516,7 +516,7 @@ namespace diff{ using No = lib::meta::No_t; template - static Yes check(typename variant::CanBuildFrom::Type*); + static Yes check(variant::CanBuildFrom::Type*); template static No check(...); diff --git a/src/lib/diff/index-table.hpp b/src/lib/diff/index-table.hpp index cd729ed14..a775989a3 100644 --- a/src/lib/diff/index-table.hpp +++ b/src/lib/diff/index-table.hpp @@ -69,8 +69,8 @@ namespace diff{ /* === forwarded sequence access === */ - using iterator = typename std::vector::iterator; - using const_iterator = typename std::vector::const_iterator; + using iterator = std::vector::iterator; + using const_iterator = std::vector::const_iterator; iterator begin() { return data_.begin(); } iterator end() { return data_.end(); } diff --git a/src/lib/diff/list-diff-application.hpp b/src/lib/diff/list-diff-application.hpp index 38d64bbf2..3775a6a27 100644 --- a/src/lib/diff/list-diff-application.hpp +++ b/src/lib/diff/list-diff-application.hpp @@ -64,7 +64,7 @@ namespace diff{ : public ListDiffInterpreter { using Vec = vector; - using Iter = typename Vec::iterator; + using Iter = Vec::iterator; Vec orig_; Vec& seq_; diff --git a/src/lib/diff/list-diff-detector.hpp b/src/lib/diff/list-diff-detector.hpp index 3c2b12d1a..29def1e9f 100644 --- a/src/lib/diff/list-diff-detector.hpp +++ b/src/lib/diff/list-diff-detector.hpp @@ -78,14 +78,14 @@ namespace diff{ class DiffDetector : util::NonCopyable { - using Val = typename SEQ::value_type; + using Val = SEQ::value_type; using Idx = IndexTable; Idx refIdx_; SEQ const& currentData_; - using DiffStep = typename ListDiffLanguage::DiffStep; + using DiffStep = ListDiffLanguage::DiffStep; /** @internal state frame for diff detection and generation. */ class DiffFrame; diff --git a/src/lib/diff/record.hpp b/src/lib/diff/record.hpp index 31c274d80..89c9f7637 100644 --- a/src/lib/diff/record.hpp +++ b/src/lib/diff/record.hpp @@ -140,9 +140,9 @@ namespace diff{ template class Record { - using Storage = typename RecordSetup::Storage; - using ElmIter = typename RecordSetup::ElmIter; - using Access = typename RecordSetup::Access; + using Storage = RecordSetup::Storage; + using ElmIter = RecordSetup::ElmIter; + using Access = RecordSetup::Access; string type_; @@ -307,7 +307,7 @@ namespace diff{ /* ==== Exposing scope and contents for iteration ====== */ using iterator = IterAdapter; - using scopeIter = typename iter_stl::_SeqT::Range; + using scopeIter = iter_stl::_SeqT::Range; using keyIter = TransformIter; using valIter = TransformIter; @@ -595,10 +595,10 @@ namespace diff{ * @see tree-diff-application.hpp */ template - inline typename Record::Mutator& + inline Record::Mutator& mutateInPlace (Record& record_to_mutate) { - return reinterpret_cast::Mutator &> (record_to_mutate); + return reinterpret_cast::Mutator &> (record_to_mutate); } @@ -713,8 +713,8 @@ namespace diff{ struct RecordSetup { using Storage = std::vector; - using ElmIter = typename Storage::const_iterator; - using Access = string; ///< data access by value copy + using ElmIter = Storage::const_iterator; + using Access = string; ///< data access by value copy }; diff --git a/src/lib/diff/test-mutation-target.hpp b/src/lib/diff/test-mutation-target.hpp index e1e545f80..713fe23b6 100644 --- a/src/lib/diff/test-mutation-target.hpp +++ b/src/lib/diff/test-mutation-target.hpp @@ -195,8 +195,8 @@ namespace diff{ public: - using iterator = typename iter_stl::_SeqT::Range; - using const_iterator = typename iter_stl::_SeqT::Range; + using iterator = iter_stl::_SeqT::Range; + using const_iterator = iter_stl::_SeqT::Range; const_iterator begin() const { return eachElm(content_); } const_iterator end() const { return const_iterator(); } diff --git a/src/lib/diff/tree-diff-application.hpp b/src/lib/diff/tree-diff-application.hpp index be8ad9ea1..48e7ebf9a 100644 --- a/src/lib/diff/tree-diff-application.hpp +++ b/src/lib/diff/tree-diff-application.hpp @@ -364,7 +364,7 @@ namespace diff{ void initDiffApplication() { - using Target = typename TreeDiffTraits::Ret; + using Target = TreeDiffTraits::Ret; Target target = mutatorBinding (subject_); buildMutator(target)->init(); diff --git a/src/lib/diff/tree-diff-traits.hpp b/src/lib/diff/tree-diff-traits.hpp index d755f4d23..7f584ed76 100644 --- a/src/lib/diff/tree-diff-traits.hpp +++ b/src/lib/diff/tree-diff-traits.hpp @@ -200,10 +200,10 @@ namespace diff{ * the return value in local scope as long as necessary */ template - typename TreeDiffTraits::Ret + TreeDiffTraits::Ret mutatorBinding (TAR& subject) { - using Wrapper = typename TreeDiffTraits::Ret; + using Wrapper = TreeDiffTraits::Ret; return Wrapper(subject); } diff --git a/src/lib/diff/tree-mutator-attribute-binding.hpp b/src/lib/diff/tree-mutator-attribute-binding.hpp index 81babe431..75ff024c1 100644 --- a/src/lib/diff/tree-mutator-attribute-binding.hpp +++ b/src/lib/diff/tree-mutator-attribute-binding.hpp @@ -236,9 +236,9 @@ namespace diff{ class ChangeOperation : public AttributeBindingBase { - using CloArgs = typename lib::meta::_Fun::Args; - using ValueType = typename lib::meta::Pick::Type; - using ID = idi::EntryID; + using CloArgs = lib::meta::_Fun::Args; + using ValueType = lib::meta::Pick::Type; + using ID = idi::EntryID; CLO setter_; diff --git a/src/lib/diff/tree-mutator-collection-binding.hpp b/src/lib/diff/tree-mutator-collection-binding.hpp index 2f5bfad36..bdb24b15a 100644 --- a/src/lib/diff/tree-mutator-collection-binding.hpp +++ b/src/lib/diff/tree-mutator-collection-binding.hpp @@ -121,8 +121,8 @@ namespace diff{ struct ContainerTraits > { using Vec = _AsVector; - using Elm = typename Vec::value_type; - using Itr = typename Vec::iterator; + using Elm = Vec::value_type; + using Itr = Vec::iterator; static Itr recentElmRawIter (Vec& vec) @@ -141,8 +141,8 @@ namespace diff{ struct ContainerTraits > { using Map = _AsMap; - using Key = typename Map::key_type; - using Val = typename Map::mapped_type; + using Key = Map::key_type; + using Val = Map::mapped_type; using Elm = std::pair; /** heuristic for `std::map`: lookup via reverse iterator. @@ -188,12 +188,12 @@ namespace diff{ struct CollectionBinding : util::MoveOnly { - using Coll = typename Strip::TypeReferred; - using Elm = typename Coll::value_type; + using Coll = Strip::TypeReferred; + using Elm = Coll::value_type; using Trait = ContainerTraits; - using iterator = typename lib::iter_stl::_SeqT::Range; - using const_iterator = typename lib::iter_stl::_SeqT::Range; + using iterator = lib::iter_stl::_SeqT::Range; + using const_iterator = lib::iter_stl::_SeqT::Range; ASSERT_VALID_SIGNATURE (MAT, bool(GenNode const& spec, Elm const& elm)) @@ -306,7 +306,7 @@ namespace diff{ class ChildCollectionMutator : public PAR { - using Iter = typename BIN::iterator; + using Iter = BIN::iterator; BIN binding_; Iter pos_; @@ -582,7 +582,7 @@ namespace diff{ inline auto createCollectionBindingBuilder (COLL& coll, MAT m, CTR c, SEL s, ASS a, MUT u) { - using Coll = typename Strip::TypeReferred; + using Coll = Strip::TypeReferred; return CollectionBindingBuilder {coll, m,c,s,a,u}; } @@ -738,7 +738,7 @@ namespace diff{ inline auto collection (COLL& coll) { - using Elm = typename COLL::value_type; + using Elm = COLL::value_type; return _DefaultBinding::attachTo(coll); } diff --git a/src/lib/element-tracker.hpp b/src/lib/element-tracker.hpp index 7be833951..aa30b64ad 100644 --- a/src/lib/element-tracker.hpp +++ b/src/lib/element-tracker.hpp @@ -82,8 +82,8 @@ namespace lib { : public std::vector> { using _Vec = std::vector>; - using Iter = typename _Vec::iterator; - using CIter = typename _Vec::const_iterator; + using Iter = _Vec::iterator; + using CIter = _Vec::const_iterator; public: ~ElementTracker() @@ -226,7 +226,7 @@ namespace lib { /** storage for the functor to link an AutoRegistered entity * to the corresponding registration service */ template - typename AutoRegistered::RegistryLink AutoRegistered::getRegistry; + AutoRegistered::RegistryLink AutoRegistered::getRegistry; diff --git a/src/lib/format-obj.hpp b/src/lib/format-obj.hpp index dc5f98aa4..85f65a2b1 100644 --- a/src/lib/format-obj.hpp +++ b/src/lib/format-obj.hpp @@ -190,7 +190,7 @@ namespace util { inline std::string toString (TY const& val) noexcept { - using PlainVal = typename lib::meta::Strip::TypeReferred; + using PlainVal = lib::meta::Strip::TypeReferred; return StringConv::invoke (val); } diff --git a/src/lib/format-util.hpp b/src/lib/format-util.hpp index f3b0a5cca..01e7c8616 100644 --- a/src/lib/format-util.hpp +++ b/src/lib/format-util.hpp @@ -133,7 +133,7 @@ namespace util { inline auto stringify (IT&& src) { - using Val = typename lib::meta::ValueTypeBinding::value_type; + using Val = lib::meta::ValueTypeBinding::value_type; return lib::transformIterator(forward(src), util::toString); } @@ -144,7 +144,7 @@ namespace util { template struct _RangeIter { - using StlIter = typename CON::const_iterator; + using StlIter = CON::const_iterator; lib::RangeIter iter; @@ -193,7 +193,7 @@ namespace util { inline string join (COLL&& coll, string const& delim =", ") { - using Coll = typename lib::meta::Strip::TypePlain; + using Coll = lib::meta::Strip::TypePlain; _RangeIter range(std::forward(coll)); // copies when CON is reference auto strings = stringify (std::move (range.iter)); diff --git a/src/lib/hetero-data.hpp b/src/lib/hetero-data.hpp index 7d20cb746..900a24874 100644 --- a/src/lib/hetero-data.hpp +++ b/src/lib/hetero-data.hpp @@ -183,7 +183,7 @@ namespace lib { /** access type to reside in the given slot of the _complete chain_ */ template - using Elm_t = typename PickType::type; + using Elm_t = PickType::type; /** access data elements within _complete chain_ by index pos */ @@ -272,10 +272,10 @@ namespace lib { } template - using ChainExtent = typename ChainType::template Chain; + using ChainExtent = ChainType::template Chain; template - using Accessor = typename ChainType::template Accessor<_Self::size()+slot>; + using Accessor = ChainType::template Accessor<_Self::size()+slot>; template using AccessorFor = Accessor()>; @@ -310,7 +310,7 @@ namespace lib { using _FrontBlock = HeteroData, meta::Nil>>; public: - using NewFrame = typename _FrontBlock::Frame; + using NewFrame = _FrontBlock::Frame; using ChainType = _FrontBlock; using _FrontBlock::_FrontBlock; @@ -434,7 +434,7 @@ namespace std { // Specialisation to support C++ »Tuple Protocol« and structur template struct tuple_element > { - using type = typename lib::HeteroData::template Elm_t; + using type = lib::HeteroData::template Elm_t; }; template struct tuple_element > diff --git a/src/lib/index-iter.hpp b/src/lib/index-iter.hpp index 532560cac..b8bb7915f 100644 --- a/src/lib/index-iter.hpp +++ b/src/lib/index-iter.hpp @@ -50,8 +50,8 @@ namespace lib { using ResVal = decltype(data_->operator[](0)); - using value_type = typename meta::RefTraits::Value; - using reference = typename meta::RefTraits::Reference; + using value_type = meta::RefTraits::Value; + using reference = meta::RefTraits::Reference; bool checkPoint() const @@ -113,7 +113,7 @@ namespace lib { : public iter::IndexAccessCore::IterWrapper { using _Cor = iter::IndexAccessCore; - using _Par = typename _Cor::IterWrapper; + using _Par = _Cor::IterWrapper; public: IndexIter() = default; diff --git a/src/lib/iter-adapter-ptr-deref.hpp b/src/lib/iter-adapter-ptr-deref.hpp index be0f42113..3458efe80 100644 --- a/src/lib/iter-adapter-ptr-deref.hpp +++ b/src/lib/iter-adapter-ptr-deref.hpp @@ -60,10 +60,10 @@ namespace lib { public: /** this iterator adapter is meant to wrap an iterator yielding pointer values */ - using pointer = typename meta::ValueTypeBinding::value_type; + using pointer = meta::ValueTypeBinding::value_type; static_assert(std::is_pointer_v); - using value_type = typename std::remove_pointer_t; + using value_type = std::remove_pointer_t; using reference = value_type&; @@ -72,10 +72,10 @@ namespace lib { // the purpose of the following typedefs is to support building a correct "const iterator" - using ValueTypeBase = typename std::remove_const_t; // value_type without const + using ValueTypeBase = std::remove_const_t; // value_type without const - using WrappedIterType = typename IterType::template SimilarIter< ValueTypeBase* * >::Type; - using WrappedConstIterType = typename IterType::template SimilarIter::Type; + using WrappedIterType = IterType::template SimilarIter< ValueTypeBase* * >::Type; + using WrappedConstIterType = IterType::template SimilarIter::Type; using IterType = PtrDerefIter; using ConstIterType = PtrDerefIter; @@ -220,7 +220,7 @@ namespace lib { template class AddressExposingIter { - using _Ptr = typename IT::pointer; + using _Ptr = IT::pointer; IT i_; ///< nested source iterator @@ -238,9 +238,9 @@ namespace lib { public: - using pointer = typename IT::pointer const*; - using reference = typename IT::pointer const&; - using value_type = typename IT::pointer const ; + using pointer = IT::pointer const*; + using reference = IT::pointer const&; + using value_type = IT::pointer const ; ENABLE_USE_IN_STD_RANGE_FOR_LOOPS (AddressExposingIter); diff --git a/src/lib/iter-adapter-stl.hpp b/src/lib/iter-adapter-stl.hpp index e67cc9f2f..96f68cf7c 100644 --- a/src/lib/iter-adapter-stl.hpp +++ b/src/lib/iter-adapter-stl.hpp @@ -49,9 +49,9 @@ namespace iter_stl { class DistinctIter { public: - using value_type = typename IT::value_type; - using reference = typename IT::reference; - using pointer = typename IT::pointer; + using value_type = IT::value_type; + using reference = IT::reference; + using pointer = IT::pointer; private: IT i_; @@ -96,9 +96,9 @@ namespace iter_stl { template struct WrappedStlIter : DEF { - using Iter = typename DEF::Iter; - using reference = typename DEF::reference; - using pointer = typename DEF::pointer; + using Iter = DEF::Iter; + using reference = DEF::reference; + using pointer = DEF::pointer; WrappedStlIter() : i_() { } @@ -127,9 +127,9 @@ namespace iter_stl { struct Wrapped_Identity { using Iter = IT; - using value_type = typename IT::value_type; - using reference = typename IT::reference; - using pointer = typename IT::pointer; + using value_type = IT::value_type; + using reference = IT::reference; + using pointer = IT::pointer; static Iter get (Iter& it) { return & (*it); } }; @@ -142,7 +142,7 @@ namespace iter_stl { struct Wrapped_PickKey { using Iter = IT; - using value_type = typename IT::value_type::first_type; + using value_type = IT::value_type::first_type; using reference = value_type &; using pointer = value_type *; @@ -157,7 +157,7 @@ namespace iter_stl { struct Wrapped_PickVal { using Iter = IT; - using value_type = typename IT::value_type::second_type; + using value_type = IT::value_type::second_type; using reference = value_type &; using pointer = value_type *; @@ -168,7 +168,7 @@ namespace iter_stl { struct Wrapped_PickConstVal { using Iter = IT; - using value_type = const typename IT::value_type::second_type; + using value_type = const IT::value_type::second_type; using reference = const value_type &; using pointer = const value_type *; @@ -185,17 +185,17 @@ namespace iter_stl { template struct _MapTypeSelector { - using Key = typename MAP::value_type::first_type; - using Val = typename MAP::value_type::second_type; - using Itr = typename MAP::iterator; + using Key = MAP::value_type::first_type; + using Val = MAP::value_type::second_type; + using Itr = MAP::iterator; }; template struct _MapTypeSelector { - using Key = typename MAP::value_type::first_type; - using Val = typename MAP::value_type::second_type const; - using Itr = typename MAP::const_iterator; + using Key = MAP::value_type::first_type; + using Val = MAP::value_type::second_type const; + using Itr = MAP::const_iterator; }; /** helper to access the parts of the pair values correctly...*/ @@ -219,13 +219,13 @@ namespace iter_stl { template struct _MapT { - using KeyType = typename _MapTypeSelector::Key; - using ValType = typename _MapTypeSelector::Val; - using EntryIter = typename _MapTypeSelector::Itr; + using KeyType = _MapTypeSelector::Key; + using ValType = _MapTypeSelector::Val; + using EntryIter = _MapTypeSelector::Itr; - using DetectConst = typename EntryIter::reference; - using PickKeyIter = typename _MapSubSelector::PickKey; - using PickValIter = typename _MapSubSelector::PickVal; + using DetectConst = EntryIter::reference; + using PickKeyIter = _MapSubSelector::PickKey; + using PickValIter = _MapSubSelector::PickVal; using KeyIter = RangeIter; using ValIter = RangeIter; @@ -239,12 +239,12 @@ namespace iter_stl { { using EntryIter = IT; - using KeyType = typename EntryIter::value_type::first_type; - using ValType = typename EntryIter::value_type::second_type; + using KeyType = EntryIter::value_type::first_type; + using ValType = EntryIter::value_type::second_type; - using DetectConst = typename EntryIter::reference; - using PickKeyIter = typename _MapSubSelector::PickKey; - using PickValIter = typename _MapSubSelector::PickVal; + using DetectConst = EntryIter::reference; + using PickKeyIter = _MapSubSelector::PickKey; + using PickValIter = _MapSubSelector::PickVal; using KeyIter = RangeIter; using ValIter = RangeIter; @@ -257,7 +257,7 @@ namespace iter_stl { template struct _SeqT { - using Iter = typename SEQ::iterator; + using Iter = SEQ::iterator; using Range = RangeIter; using DistinctVals = DistinctIter; using Addrs = AddressExposingIter; @@ -266,7 +266,7 @@ namespace iter_stl { template struct _SeqT { - using Iter = typename SEQ::const_iterator; + using Iter = SEQ::const_iterator; using Range = RangeIter; using DistinctVals = DistinctIter; using Addrs = AddressExposingIter; @@ -281,10 +281,10 @@ namespace iter_stl { * to yield each Element from a STL container */ template - inline typename _SeqT::Range + inline _SeqT::Range eachElm (CON& coll) { - using Range = typename _SeqT::Range; + using Range = _SeqT::Range; return Range (coll.begin(), coll.end()); } @@ -293,10 +293,10 @@ namespace iter_stl { * exposing the address of each Element within a STL */ template - inline typename _SeqT::Addrs + inline _SeqT::Addrs eachAddress (CON& coll) { - using Addresses = typename _SeqT::Addrs; + using Addresses = _SeqT::Addrs; return Addresses (eachElm (coll)); } @@ -305,11 +305,11 @@ namespace iter_stl { * each key of a map/multimap */ template - inline typename _MapT::KeyIter + inline _MapT::KeyIter eachKey (MAP& map) { - using Range = typename _MapT::KeyIter; - using PickKey = typename _MapT::PickKeyIter; + using Range = _MapT::KeyIter; + using PickKey = _MapT::PickKeyIter; return Range (PickKey (map.begin()), PickKey (map.end())); } @@ -319,11 +319,11 @@ namespace iter_stl { * from a given range of (key,value) pairs */ template - inline typename _MapIterT::KeyIter + inline _MapIterT::KeyIter eachKey (IT const& begin, IT const& end) { - using Range = typename _MapIterT::KeyIter; - using PickKey = typename _MapIterT::PickKeyIter; + using Range = _MapIterT::KeyIter; + using PickKey = _MapIterT::PickKeyIter; return Range (PickKey (begin), PickKey (end)); } @@ -333,11 +333,11 @@ namespace iter_stl { * each value within a map/multimap */ template - inline typename _MapT::ValIter + inline _MapT::ValIter eachVal (MAP& map) { - using Range = typename _MapT::ValIter; - using PickVal = typename _MapT::PickValIter; + using Range = _MapT::ValIter; + using PickVal = _MapT::PickValIter; return Range (PickVal (map.begin()), PickVal (map.end())); } @@ -347,11 +347,11 @@ namespace iter_stl { * from a given range of (key,value) pairs */ template - inline typename _MapIterT::ValIter + inline _MapIterT::ValIter eachVal (IT const& begin, IT const& end) { - using Range = typename _MapIterT::ValIter; - using PickVal = typename _MapIterT::PickValIter; + using Range = _MapIterT::ValIter; + using PickVal = _MapIterT::PickValIter; return Range (PickVal (begin), PickVal (end)); } @@ -361,11 +361,11 @@ namespace iter_stl { * any repetitions in the given sequence. */ template - inline typename _SeqT::DistinctVals + inline _SeqT::DistinctVals eachDistinct (SEQ& seq) { - using Range = typename _SeqT::Range; - using DistinctValues = typename _SeqT::DistinctVals; + using Range = _SeqT::Range; + using DistinctValues = _SeqT::DistinctVals; return DistinctValues (Range (seq.begin(), seq.end())); } @@ -376,7 +376,7 @@ namespace iter_stl { * @warning full scan of all keys, dropping repetitions */ template - inline typename _MapT::DistinctKeys + inline _MapT::DistinctKeys eachDistinctKey (MAP& map) { return typename _MapT::DistinctKeys (eachKey (map)); @@ -388,12 +388,12 @@ namespace iter_stl { * @warning full scan of all keys, dropping repetitions */ template - inline typename _MapT::ValIter + inline _MapT::ValIter eachValForKey (MMAP& multimap, KEY key) { - using Pos = typename _MapT::EntryIter; - using Range = typename _MapT::ValIter; - using PickVal = typename _MapT::PickValIter; + using Pos = _MapT::EntryIter; + using Range = _MapT::ValIter; + using PickVal = _MapT::PickValIter; std::pair valRange = multimap.equal_range (key); diff --git a/src/lib/iter-adapter.hpp b/src/lib/iter-adapter.hpp index fe5c3248d..453f51f87 100644 --- a/src/lib/iter-adapter.hpp +++ b/src/lib/iter-adapter.hpp @@ -212,9 +212,9 @@ namespace lib { using _ValTrait = meta::ValueTypeBinding>; public: - using value_type = typename _ValTrait::value_type; - using reference = typename _ValTrait::reference; - using pointer = typename _ValTrait::pointer; + using value_type = _ValTrait::value_type; + using reference = _ValTrait::reference; + using pointer = _ValTrait::pointer; IterAdapter (CON src, POS const& startpos) @@ -302,7 +302,7 @@ namespace lib { protected: - using ConRef = typename meta::RefTraits::Reference; + using ConRef = meta::RefTraits::Reference; /** allow derived classes to access backing container */ ConRef source() { return source_; } @@ -376,9 +376,9 @@ namespace lib { ST core_; public: - using value_type = typename meta::RefTraits::Value; - using reference = typename meta::RefTraits::Reference; - using pointer = typename meta::RefTraits::Pointer; + using value_type = meta::RefTraits::Value; + using reference = meta::RefTraits::Reference; + using pointer = meta::RefTraits::Pointer; IterStateWrapper (ST&& initialState) : core_(std::forward(initialState)) @@ -519,7 +519,7 @@ namespace lib { return bool(srcIter()); } - typename IT::reference + IT::reference yield() const { return *srcIter(); @@ -614,7 +614,7 @@ namespace lib { class ContainerCore : public CON { - using Iter = typename CON::iterator; + using Iter = CON::iterator; Iter p_; @@ -694,9 +694,9 @@ namespace lib { public: using YieldRes = iter::CoreYield; - using value_type = typename meta::RefTraits::Value; - using reference = typename meta::RefTraits::Reference; - using pointer = typename meta::RefTraits::Pointer; + using value_type = meta::RefTraits::Value; + using reference = meta::RefTraits::Reference; + using pointer = meta::RefTraits::Pointer; /** by default, pass anything down for initialisation of the core. @@ -803,11 +803,11 @@ namespace lib { using _ValTrait = meta::ValueTypeBinding>; public: - using pointer = typename _ValTrait::pointer; - using reference = typename _ValTrait::reference; + using pointer = _ValTrait::pointer; + using reference = _ValTrait::reference; /// @note special twist, since a STL const_iterator would yield a non-const `value_type` - using value_type = typename std::remove_reference::type; + using value_type = std::remove_reference::type; RangeIter (IT const& start, IT const& end) @@ -1052,7 +1052,7 @@ namespace lib { template struct SimilarIter ///< rebind to rewritten Iterator wrapped into RangeIter { - using WrappedIter = typename IterType::template SimilarIter::Type; + using WrappedIter = IterType::template SimilarIter::Type; using Type = RangeIter; }; }; @@ -1067,9 +1067,9 @@ namespace lib { public: - using value_type = const typename IT::value_type; - using pointer = const typename IT::pointer ; - using reference = const typename IT::reference ; + using value_type = const IT::value_type; + using pointer = const IT::pointer ; + using reference = const IT::reference ; ConstIter (IT srcIter) : i_(srcIter) diff --git a/src/lib/iter-chain-search.hpp b/src/lib/iter-chain-search.hpp index 3e3d5ce94..dc7d18ba8 100644 --- a/src/lib/iter-chain-search.hpp +++ b/src/lib/iter-chain-search.hpp @@ -150,11 +150,11 @@ namespace iter { : public _IterChainSetup::Pipeline { using _Trait = _IterChainSetup; - using _Base = typename _Trait::Pipeline; + using _Base = _Trait::Pipeline; - using Value = typename _Base::value_type; - using Filter = typename _Trait::Filter; - using Step = typename _Trait::StepFunctor; + using Value = _Base::value_type; + using Filter = _Trait::Filter; + using Step = _Trait::StepFunctor; /** Storage for a sequence of filter configuration functors */ std::vector stepChain_; diff --git a/src/lib/iter-cursor.hpp b/src/lib/iter-cursor.hpp index e2e713b72..532ab5279 100644 --- a/src/lib/iter-cursor.hpp +++ b/src/lib/iter-cursor.hpp @@ -56,9 +56,9 @@ namespace lib { public: - using pointer = typename meta::ValueTypeBinding::pointer; - using reference = typename meta::ValueTypeBinding::reference; - using value_type = typename std::remove_reference::type; ///< @note will be const for const iterators (while const_iterator::value_type isn't) + using pointer = meta::ValueTypeBinding::pointer; + using reference = meta::ValueTypeBinding::reference; + using value_type = std::remove_reference::type; ///< @note will be const for const iterators (while const_iterator::value_type isn't) CursorGear() diff --git a/src/lib/iter-explorer.hpp b/src/lib/iter-explorer.hpp index 66defe34d..ba50bb54c 100644 --- a/src/lib/iter-explorer.hpp +++ b/src/lib/iter-explorer.hpp @@ -133,9 +133,9 @@ namespace lib { namespace iter_explorer { // basic iterator wrappers... template - using iterator = typename meta::Strip::TypeReferred::iterator; + using iterator = meta::Strip::TypeReferred::iterator; template - using const_iterator = typename meta::Strip::TypeReferred::const_iterator; + using const_iterator = meta::Strip::TypeReferred::const_iterator; /** * Adapt STL compliant container. @@ -190,7 +190,7 @@ namespace lib { class IterSourceIter : public ISO::iterator { - using Iterator = typename ISO::iterator; + using Iterator = ISO::iterator; public: IterSourceIter() =default; @@ -273,8 +273,8 @@ namespace lib { template struct _DecoratorTraits>> { - using SrcRaw = typename lib::meta::Strip::Type; - using SrcVal = typename meta::RefTraits>::Value; + using SrcRaw = lib::meta::Strip::Type; + using SrcVal = meta::RefTraits>::Value; using SrcIter = lib::IterableDecorator>; }; @@ -282,7 +282,7 @@ namespace lib { struct _DecoratorTraits>> { using SrcIter = remove_reference_t; - using SrcVal = typename SrcIter::value_type; + using SrcVal = SrcIter::value_type; }; template @@ -291,14 +291,14 @@ namespace lib { static_assert (not std::is_rvalue_reference::value, "container needs to exist elsewhere during the lifetime of the iteration"); using SrcIter = iter_explorer::StlRange; - using SrcVal = typename SrcIter::value_type; + using SrcVal = SrcIter::value_type; }; template struct _DecoratorTraits, ISO>>> { using SrcIter = iter_explorer::IterSourceIter; - using SrcVal = typename ISO::value_type; + using SrcVal = ISO::value_type; }; template @@ -324,7 +324,7 @@ namespace lib { template struct _ExpanderTraits { - using ResIter = typename _DecoratorTraits::SrcIter; + using ResIter = _DecoratorTraits::SrcIter; using SrcYield = iter::Yield; using ResYield = iter::Yield; using _CommonT = meta::CommonResultYield; @@ -336,10 +336,10 @@ namespace lib { static_assert (is_const_v == is_const_v, "source and expanded types differ in const-ness"); - using YieldRes = typename _CommonT::ResType; - using value_type = typename _CommonT::value_type; - using reference = typename _CommonT::reference; - using pointer = typename _CommonT::pointer; + using YieldRes = _CommonT::ResType; + using value_type = _CommonT::value_type; + using reference = _CommonT::reference; + using pointer = _CommonT::pointer; }; }//(End) IterExplorer traits @@ -389,22 +389,22 @@ namespace lib { template struct FunDetector { - using Sig = typename _Fun::Sig; + using Sig = _Fun::Sig; }; /** handle a generic lambda, accepting a reference to the `SRC` iterator */ template struct FunDetector> > { - using Arg = typename std::add_lvalue_reference::type; + using Arg = std::add_lvalue_reference::type; using Ret = decltype(std::declval() (std::declval())); using Sig = Ret(Arg); }; - using Sig = typename FunDetector::Sig; - using Arg = typename _Fun::Args::List::Head; // assuming function with a single argument - using Res = typename _Fun::Ret; + using Sig = FunDetector::Sig; + using Arg = _Fun::Args::List::Head; // assuming function with a single argument + using Res = _Fun::Ret; static_assert (meta::is_UnaryFun()); @@ -442,7 +442,7 @@ namespace lib { , is_base_of, remove_reference_t> > >> { - using Source = typename IT::Source; + using Source = IT::Source; static auto wrap (function rawFun) ///< extract the (abstracted) IterSource @@ -466,7 +466,7 @@ namespace lib { inline void static_assert_isPredicate() { - using Res = typename _FunTraits::Res; + using Res = _FunTraits::Res; static_assert(std::is_constructible::value, "Functor must be a predicate"); } @@ -477,8 +477,8 @@ namespace lib { template struct _ReduceTraits { - using Result = typename iter_explorer::_FunTraits::Res; - using ResVal = typename lib::meta::RefTraits::Value; + using Result = iter_explorer::_FunTraits::Res; + using ResVal = lib::meta::RefTraits::Value; }; @@ -557,7 +557,7 @@ namespace lib { static_assert(can_IterForEach::value, "Lumiera Iterator required as source"); using _Trait = _ExpanderTraits; - using ResIter = typename _Trait::ResIter; + using ResIter = _Trait::ResIter; using RootExpandFunctor = function; using ChldExpandFunctor = function; @@ -621,10 +621,10 @@ namespace lib { public: /* === Iteration control API for IterableDecorator === */ /** @note result type bindings based on a common type of source and expanded result */ - using YieldRes = typename _Trait::YieldRes; - using value_type = typename _Trait::value_type; - using reference = typename _Trait::reference; - using pointer = typename _Trait::pointer; + using YieldRes = _Trait::YieldRes; + using value_type = _Trait::value_type; + using reference = _Trait::reference; + using pointer = _Trait::pointer; bool @@ -791,9 +791,9 @@ namespace lib { TransformedItem treated_; public: - using value_type = typename meta::ValueTypeBinding::value_type; - using reference = typename meta::ValueTypeBinding::reference; - using pointer = typename meta::ValueTypeBinding::pointer; + using value_type = meta::ValueTypeBinding::value_type; + using reference = meta::ValueTypeBinding::reference; + using pointer = meta::ValueTypeBinding::pointer; template @@ -896,7 +896,7 @@ namespace lib { protected: using Group = std::array; - using Iter = typename Group::iterator; + using Iter = Group::iterator; struct Buffer : lib::UninitialisedStorage { @@ -1028,7 +1028,7 @@ namespace lib { static_assert(can_IterForEach::value, "Lumiera Iterator required as source"); protected: - using SrcValue = typename meta::ValueTypeBinding::value_type; + using SrcValue = meta::ValueTypeBinding::value_type; using Grouping = function; using Aggregator = function; @@ -1038,9 +1038,9 @@ namespace lib { Aggregator aggregate_; public: - using value_type = typename meta::RefTraits::Value; - using reference = typename meta::RefTraits::Reference; - using pointer = typename meta::RefTraits::Pointer; + using value_type = meta::RefTraits::Value; + using reference = meta::RefTraits::Reference; + using pointer = meta::RefTraits::Pointer; GroupAggregator() =default; // inherited default copy operations @@ -1152,7 +1152,7 @@ namespace lib { return bool(srcIter()); } - typename SRC::reference + SRC::reference yield() const { return *srcIter(); @@ -1446,7 +1446,7 @@ namespace lib { , public ChildExpandableSource { using Parent = WrappedLumieraIter; - using Val = typename SRC::value_type; ///////////////////////////////////TICKET #1125 : get rid of Val + using Val = SRC::value_type; ///////////////////////////////////TICKET #1125 : get rid of Val ~PackagedIterExplorerSource() { } public: @@ -1583,9 +1583,9 @@ namespace lib { public: - using value_type = typename meta::ValueTypeBinding::value_type; - using reference = typename meta::ValueTypeBinding::reference; - using pointer = typename meta::ValueTypeBinding::pointer; + using value_type = meta::ValueTypeBinding::value_type; + using reference = meta::ValueTypeBinding::reference; + using pointer = meta::ValueTypeBinding::pointer; using TAG_IterExplorer_Src = SRC; ///< @internal for \ref _PipelineDetector @@ -1640,10 +1640,10 @@ namespace lib { auto expand (FUN&& expandFunctor) { - using ExpandedChildren = typename iter_explorer::_FunTraits::Res; + using ExpandedChildren = iter_explorer::_FunTraits::Res; using ResCore = iter_explorer::Expander; - using ResIter = typename _DecoratorTraits::SrcIter; + using ResIter = _DecoratorTraits::SrcIter; return IterExplorer (ResCore {move(*this), forward(expandFunctor)}); } @@ -1664,7 +1664,7 @@ namespace lib { expandAll() { using ResCore = iter_explorer::AutoExpander; - using ResIter = typename _DecoratorTraits::SrcIter; + using ResIter = _DecoratorTraits::SrcIter; return IterExplorer (ResCore {move(*this)}); } @@ -1692,7 +1692,7 @@ namespace lib { expandOnIteration() { using ResCore = iter_explorer::ScheduledExpander; - using ResIter = typename _DecoratorTraits::SrcIter; + using ResIter = _DecoratorTraits::SrcIter; return IterExplorer (ResCore {move(*this)}); } @@ -1712,10 +1712,10 @@ namespace lib { auto transform (FUN&& transformFunctor) { - using Product = typename iter_explorer::_FunTraits::Res; + using Product = iter_explorer::_FunTraits::Res; using ResCore = iter_explorer::Transformer; - using ResIter = typename _DecoratorTraits::SrcIter; + using ResIter = _DecoratorTraits::SrcIter; return IterExplorer (ResCore {move(*this), forward(transformFunctor)}); } @@ -1733,9 +1733,9 @@ namespace lib { auto grouped() { - using Value = typename meta::ValueTypeBinding::value_type; + using Value = meta::ValueTypeBinding::value_type; using ResCore = iter_explorer::Grouping; - using ResIter = typename _DecoratorTraits::SrcIter; + using ResIter = _DecoratorTraits::SrcIter; return IterExplorer (ResCore {move(*this)}); } @@ -1756,14 +1756,14 @@ namespace lib { auto groupedBy (FGRP&& groupFun, FAGG&& aggFun) { - using GroupVal = typename iter_explorer::_FunTraits::Res; + using GroupVal = iter_explorer::_FunTraits::Res; static_assert (meta::is_BinaryFun()); - using ArgType1 = typename _Fun::Args::List::Head; - using Aggregate = typename meta::RefTraits::Value; + using ArgType1 = _Fun::Args::List::Head; + using Aggregate = meta::RefTraits::Value; using ResCore = iter_explorer::GroupAggregator; - using ResIter = typename _DecoratorTraits::SrcIter; + using ResIter = _DecoratorTraits::SrcIter; return IterExplorer (ResCore {move(*this) ,forward (groupFun) @@ -1775,7 +1775,7 @@ namespace lib { auto groupedBy (FGRP&& groupFun) { - using Value = typename meta::ValueTypeBinding::value_type; + using Value = meta::ValueTypeBinding::value_type; return groupedBy (forward (groupFun) ,[](Value& agg, Value const& val){ agg += val; } ); @@ -1792,7 +1792,7 @@ namespace lib { iter_explorer::static_assert_isPredicate(); using ResCore = iter_explorer::StopTrigger; - using ResIter = typename _DecoratorTraits::SrcIter; + using ResIter = _DecoratorTraits::SrcIter; return IterExplorer (ResCore {move(*this), forward(whileCond)}); } @@ -1808,8 +1808,8 @@ namespace lib { iter_explorer::static_assert_isPredicate(); using ResCore = iter_explorer::StopTrigger; - using ResIter = typename _DecoratorTraits::SrcIter; - using ArgType = typename iter_explorer::_FunTraits::Arg; + using ResIter = _DecoratorTraits::SrcIter; + using ArgType = iter_explorer::_FunTraits::Arg; return IterExplorer (ResCore { move(*this) ,[whileCond = forward(untilCond)](ArgType val) @@ -1833,7 +1833,7 @@ namespace lib { iter_explorer::static_assert_isPredicate(); using ResCore = iter_explorer::Filter; - using ResIter = typename _DecoratorTraits::SrcIter; + using ResIter = _DecoratorTraits::SrcIter; return IterExplorer (ResCore {move(*this), forward(filterPredicate)}); } @@ -1863,7 +1863,7 @@ namespace lib { iter_explorer::static_assert_isPredicate(); using ResCore = iter_explorer::MutableFilter; - using ResIter = typename _DecoratorTraits::SrcIter; + using ResIter = _DecoratorTraits::SrcIter; return IterExplorer (ResCore {move(*this), forward(filterPredicate)}); } @@ -1893,7 +1893,7 @@ namespace lib { processingLayer() { using ResCore = LAY; - using ResIter = typename _DecoratorTraits::SrcIter; + using ResIter = _DecoratorTraits::SrcIter; return IterExplorer (ResCore {move(*this)}); } @@ -1904,7 +1904,7 @@ namespace lib { auto asPtr() { - using Val = typename meta::ValueTypeBinding::value_type; + using Val = meta::ValueTypeBinding::value_type; static_assert (not std::is_pointer_v); return IterExplorer::transform ([](Val& ref){ return &ref; }); } @@ -1913,7 +1913,7 @@ namespace lib { auto derefPtr() { - using Ptr = typename meta::ValueTypeBinding::value_type; + using Ptr = meta::ValueTypeBinding::value_type; return IterExplorer::transform ([](Ptr ptr){ return *ptr; }); } @@ -1925,9 +1925,9 @@ namespace lib { auto deduplicate() { - using Value = typename meta::ValueTypeBinding::value_type; + using Value = meta::ValueTypeBinding::value_type; using ResCore = ContainerCore>; - using ResIter = typename _DecoratorTraits::SrcIter; + using ResIter = _DecoratorTraits::SrcIter; SET buffer; for (auto& val : *this) buffer.emplace (val); @@ -2106,7 +2106,7 @@ namespace lib { template // used when actually a CheckedCore was attached struct _UnstripAdapter > { - using RawIter = typename COR::TAG_CheckedCore_Raw; + using RawIter = COR::TAG_CheckedCore_Raw; }; @@ -2123,8 +2123,8 @@ namespace lib { template struct _PipelineDetector > { - using _SrcIT = typename SRC::TAG_IterExplorer_Src; - using RawIter = typename _UnstripAdapter<_SrcIT>::RawIter; + using _SrcIT = SRC::TAG_IterExplorer_Src; + using RawIter = _UnstripAdapter<_SrcIT>::RawIter; }; }//(End)internal adapter logic @@ -2188,9 +2188,9 @@ namespace lib { inline auto explore (IT&& srcSeq) { - using RawIter = typename _PipelineDetector::RawIter; // possibly strip an underlying IterExplorer - using SrcIter = typename _DecoratorTraits::SrcIter; // then decide how to adapt the source / iterator - using Base = typename _BaseDetector::BaseAdapter; // detect if a BaseAdapter exists or must be added + using RawIter = _PipelineDetector::RawIter; // possibly strip an underlying IterExplorer + using SrcIter = _DecoratorTraits::SrcIter; // then decide how to adapt the source / iterator + using Base = _BaseDetector::BaseAdapter; // detect if a BaseAdapter exists or must be added return IterExplorer (std::forward (srcSeq)); } diff --git a/src/lib/iter-source.hpp b/src/lib/iter-source.hpp index fa915d514..8a157a336 100644 --- a/src/lib/iter-source.hpp +++ b/src/lib/iter-source.hpp @@ -206,7 +206,7 @@ namespace lib { /** storage for the empty data-source constant */ template - typename IterSource::iterator IterSource::EMPTY_SOURCE = iterator(); + IterSource::iterator IterSource::EMPTY_SOURCE = iterator(); @@ -226,7 +226,7 @@ namespace lib { IT src_; protected: - using Pos = typename ISO::Pos; + using Pos = ISO::Pos; Pos ////////////////////////////////////////////////////TICKET #1125 : this API should use three control functions, similar to IterStateWrapper firstResult () @@ -276,55 +276,55 @@ namespace lib { template struct _SeqT { - using Val = typename CON::iterator::value_type; - using Iter = typename IterSource::iterator; + using Val = CON::iterator::value_type; + using Iter = IterSource::iterator; }; template struct _RangeT { - using Val = typename IT::value_type; - using Iter = typename IterSource::iterator; + using Val = IT::value_type; + using Iter = IterSource::iterator; }; template struct _MapT { - using Key = typename MAP::key_type; - using Val = typename MAP::value_type::second_type; - using KeyIter = typename IterSource::iterator; - using ValIter = typename IterSource::iterator; + using Key = MAP::key_type; + using Val = MAP::value_type::second_type; + using KeyIter = IterSource::iterator; + using ValIter = IterSource::iterator; }; template struct _IterT { - using Src = typename std::remove_reference::type; - using Val = typename Src::value_type; - using Iter = typename IterSource::iterator; + using Src = std::remove_reference::type; + using Val = Src::value_type; + using Iter = IterSource::iterator; }; template struct _TransformIterT { - using Src = typename std::remove_reference::type; - using ResVal = typename lib::meta::_Fun::Ret; + using Src = std::remove_reference::type; + using ResVal = lib::meta::_Fun::Ret; using TransIter = TransformIter; - using Iter = typename IterSource::iterator; + using Iter = IterSource::iterator; }; template struct _PairIterT { - using Src = typename std::remove_reference::type; - using PairType = typename Src::value_type; - using ValType = typename PairType::second_type; - using ConstKeyType = typename PairType::first_type; + using Src = std::remove_reference::type; + using PairType = Src::value_type; + using ValType = PairType::second_type; + using ConstKeyType = PairType::first_type; // since we're returning the keys always by value, // we can strip the const added by the STL map types - using KeyType = typename std::remove_const::type; + using KeyType = std::remove_const::type; using KeyIter = TransformIter; using ValIter = TransformIter; @@ -335,14 +335,14 @@ namespace lib { template - typename _PairIterT::KeyIter + _PairIterT::KeyIter takePairFirst (IT&& source) { return transformIterator(forward(source), _PairIterT::takeFirst ); } template - typename _PairIterT::ValIter + _PairIterT::ValIter takePairSecond (IT&& source) { return transformIterator(forward(source), _PairIterT::takeSecond ); @@ -356,11 +356,11 @@ namespace lib { * exposing just a IterSource based frontend. */ template - typename _IterT::Iter + _IterT::Iter wrapIter (IT&& source) { - using Src = typename _IterT::Src; - using Val = typename _IterT::Val; + using Src = _IterT::Src; + using Val = _IterT::Val; return IterSource::build (new WrappedLumieraIter (forward(source))); } @@ -376,7 +376,7 @@ namespace lib { singleVal (VAL&& something) { using Src = decltype(singleValIterator (forward(something))); - using Val = typename _IterT::Val; + using Val = _IterT::Val; return IterSource::build (new WrappedLumieraIter{singleValIterator (forward(something))}); } @@ -392,11 +392,11 @@ namespace lib { * function call for every fetched element. */ template - typename _TransformIterT::Iter + _TransformIterT::Iter transform (IT&& source, FUN processingFunc) { - using ValType = typename _TransformIterT::ResVal; - using TransIT = typename _TransformIterT::TransIter; + using ValType = _TransformIterT::ResVal; + using TransIT = _TransformIterT::TransIter; return IterSource::build ( new WrappedLumieraIter ( @@ -408,7 +408,7 @@ namespace lib { * all the keys of the given Map or Hashtable */ template - typename _MapT::KeyIter + _MapT::KeyIter eachMapKey (MAP& map) { using Range = RangeIter; @@ -422,7 +422,7 @@ namespace lib { * all the values of the given Map or Hashtable */ template - typename _MapT::ValIter + _MapT::ValIter eachMapVal (MAP& map) { using Range = RangeIter; @@ -438,7 +438,7 @@ namespace lib { * the distinct keys */ template - typename _MapT::KeyIter + _MapT::KeyIter eachDistinctKey (MAP& map) { using Range = RangeIter; @@ -453,10 +453,10 @@ namespace lib { * @note obviously in case of a Map we'll get at most one result. */ template - typename _MapT::ValIter + _MapT::ValIter eachValForKey (MAP& map, typename _MapT::Key key) { - using Pos = typename MAP::iterator; + using Pos = MAP::iterator; using Range = RangeIter; std::pair valuesForKey = map.equal_range(key); @@ -472,10 +472,10 @@ namespace lib { * starting with \c begin and excluding \c end . */ template - typename _SeqT::Iter + _SeqT::Iter eachEntry (CON& container) { - using ValType = typename _SeqT::Val; + using ValType = _SeqT::Val; using Range = RangeIter; Range contents (container.begin(), container.end()); @@ -487,10 +487,10 @@ namespace lib { * defined by a classical Iterator range. */ template - typename _RangeT::Iter + _RangeT::Iter eachEntry (IT const& begin, IT const& end) { - using ValType = typename _RangeT::Val; + using ValType = _RangeT::Val; using Range = RangeIter; Range contents (begin, end); diff --git a/src/lib/itertools.hpp b/src/lib/itertools.hpp index 2d2144c90..b4eb78320 100644 --- a/src/lib/itertools.hpp +++ b/src/lib/itertools.hpp @@ -137,9 +137,9 @@ namespace lib { return bool(source_); } - using pointer = typename IT::pointer; - using reference = typename IT::reference; - using value_type = typename IT::value_type; + using pointer = IT::pointer; + using reference = IT::reference; + using value_type = IT::value_type; }; @@ -186,9 +186,9 @@ namespace lib { public: - using pointer = typename CORE::pointer; - using reference = typename CORE::reference; - using value_type = typename CORE::value_type; + using pointer = CORE::pointer; + using reference = CORE::reference; + using value_type = CORE::value_type; IterTool (CORE&& setup) @@ -341,7 +341,7 @@ namespace lib { typedef IterTool<_Filter> _Impl; public: - static bool acceptAll(typename _Filter::Val) { return true; } + static bool acceptAll(_Filter::Val) { return true; } FilterIter () @@ -378,7 +378,7 @@ namespace lib { inline auto filterIterator (IT&& src, PRED filterPredicate) { - using SrcIT = typename std::remove_reference::type; + using SrcIT = std::remove_reference::type; return FilterIter{forward(src), filterPredicate}; } @@ -411,7 +411,7 @@ namespace lib { : public FilterIter { using _Filter = FilterCore; - using Val = typename _Filter::Val; + using Val = _Filter::Val; void reEvaluate() @@ -739,9 +739,9 @@ namespace lib { return bool(source_); } - using pointer = typename ValueTypeBinding::pointer; - using reference = typename ValueTypeBinding::reference; - using value_type = typename ValueTypeBinding::value_type; + using pointer = ValueTypeBinding::pointer; + using reference = ValueTypeBinding::reference; + using value_type = ValueTypeBinding::value_type; }; @@ -787,7 +787,7 @@ namespace lib { inline auto transformIterator (IT const& src, FUN processingFunc) { - using OutVal = typename lib::meta::_Fun::Ret; + using OutVal = lib::meta::_Fun::Ret; return TransformIter{src,processingFunc}; } @@ -795,8 +795,8 @@ namespace lib { inline auto transformIterator (IT&& src, FUN processingFunc) { - using SrcIT = typename std::remove_reference::type; - using OutVal = typename lib::meta::_Fun::Ret; + using SrcIT = std::remove_reference::type; + using OutVal = lib::meta::_Fun::Ret; return TransformIter{forward(src), processingFunc}; } @@ -815,10 +815,10 @@ namespace lib { template - inline typename IT::value_type + inline IT::value_type pull_last (IT iter) { - using Val = typename IT::value_type; + using Val = IT::value_type; using Item = wrapper::ItemWrapper; Item lastElm; @@ -845,7 +845,7 @@ namespace lib { inline auto filterRepetitions (IT const& source) { - using Val = typename meta::ValueTypeBinding::value_type; + using Val = meta::ValueTypeBinding::value_type; return filterIterator (source, SkipRepetition()); } @@ -853,7 +853,7 @@ namespace lib { inline auto filterRepetitions (IT&& source) { - using Val = typename meta::ValueTypeBinding::value_type; + using Val = meta::ValueTypeBinding::value_type; return filterIterator (forward(source), SkipRepetition() ); } diff --git a/src/lib/lazy-init.hpp b/src/lib/lazy-init.hpp index f474e081e..b04d09b2a 100644 --- a/src/lib/lazy-init.hpp +++ b/src/lib/lazy-init.hpp @@ -179,7 +179,7 @@ namespace lib { generateTrap (DEL* delegate) { static_assert (_Fun(), "Delegate must be function-like"); - using Ret = typename _Fun::Ret; + using Ret = _Fun::Ret; static_assert (_Fun(), "Result from invoking delegate must also be function-like"); static_assert (has_Sig(), "Result from delegate must expose target signature"); diff --git a/src/lib/linked-elements.hpp b/src/lib/linked-elements.hpp index bbc5c7e87..dbba6f767 100644 --- a/src/lib/linked-elements.hpp +++ b/src/lib/linked-elements.hpp @@ -184,7 +184,7 @@ namespace lib { * discarding of node elements */ explicit - LinkedElements (typename ALO::CustomAllocator allo) + LinkedElements (ALO::CustomAllocator allo) : ALO{allo} , head_{nullptr} { } diff --git a/src/lib/meta/duck-detector.hpp b/src/lib/meta/duck-detector.hpp index 0ce0efbcd..301279d4c 100644 --- a/src/lib/meta/duck-detector.hpp +++ b/src/lib/meta/duck-detector.hpp @@ -114,7 +114,7 @@ { \ \ template \ - static Yes_t check(typename X::_TYPE_ *); \ + static Yes_t check(X::_TYPE_ *); \ template \ static No_t check(...); \ \ @@ -183,30 +183,30 @@ * and return type. Yet a non-function member will not trigger this detector. * @note this check will fail if there are overloads or similar ambiguity */ -#define META_DETECT_FUNCTION_NAME(_FUN_NAME_) \ - template \ - class HasFunName_##_FUN_NAME_ \ - { \ - template \ - struct Probe; \ - template \ - struct Probe \ - { \ - using Match = void; \ - }; \ - template \ - struct Probe \ - { \ - using Match = void; \ - }; \ - \ - template \ - static Yes_t check(typename Probe::Match * ); \ - template \ - static No_t check(...); \ - \ - public: \ - static const bool value = (sizeof(Yes_t)==sizeof(check(0))); \ +#define META_DETECT_FUNCTION_NAME(_FUN_NAME_) \ + template \ + class HasFunName_##_FUN_NAME_ \ + { \ + template \ + struct Probe; \ + template \ + struct Probe \ + { \ + using Match = void; \ + }; \ + template \ + struct Probe \ + { \ + using Match = void; \ + }; \ + \ + template \ + static Yes_t check(Probe::Match * ); \ + template \ + static No_t check(...); \ + \ + public: \ + static const bool value = (sizeof(Yes_t)==sizeof(check(0))); \ }; @@ -216,22 +216,22 @@ * @remarks the presence of overloads is irrelevant, since we explicitly * from an invocation to that function (within `decltype`) */ -#define META_DETECT_FUNCTION_ARGLESS(_FUN_) \ - template \ - class HasArglessFun_##_FUN_ \ - { \ - template \ + class HasArglessFun_##_FUN_ \ + { \ + template()._FUN_())>\ - struct Probe \ - { }; \ - \ - template \ - static Yes_t check(Probe * ); \ - template \ - static No_t check(...); \ - \ - public: \ - static const bool value = (sizeof(Yes_t)==sizeof(check(0))); \ + struct Probe \ + { }; \ + \ + template \ + static Yes_t check(Probe * ); \ + template \ + static No_t check(...); \ + \ + public: \ + static const bool value = (sizeof(Yes_t)==sizeof(check(0))); \ }; @@ -245,22 +245,22 @@ * type checks, the extension point is assumed to be supported. * @warning beware of implicit type conversions */ -#define META_DETECT_EXTENSION_POINT(_FUN_) \ - template \ - class HasExtensionPoint_##_FUN_ \ - { \ - template \ + class HasExtensionPoint_##_FUN_ \ + { \ + template()))>\ - struct Probe \ - { }; \ - \ - template \ - static Yes_t check(Probe * ); \ - template \ - static No_t check(...); \ - \ - public: \ - static const bool value = (sizeof(Yes_t)==sizeof(check(0))); \ + struct Probe \ + { }; \ + \ + template \ + static Yes_t check(Probe * ); \ + template \ + static No_t check(...); \ + \ + public: \ + static const bool value = (sizeof(Yes_t)==sizeof(check(0))); \ }; diff --git a/src/lib/meta/function-closure.hpp b/src/lib/meta/function-closure.hpp index 356ed8010..9aa26f7f9 100644 --- a/src/lib/meta/function-closure.hpp +++ b/src/lib/meta/function-closure.hpp @@ -96,7 +96,7 @@ namespace func{ template struct PlaceholderTuple, i> { - using TailPlaceholders = typename PlaceholderTuple::List; + using TailPlaceholders = PlaceholderTuple::List; using List = Node<_Placeholder, TailPlaceholders>; }; @@ -136,7 +136,7 @@ namespace func{ struct PartiallyInitTuple { template - using DestType = typename std::tuple_element_t; + using DestType = std::tuple_element_t; /** @@ -257,8 +257,8 @@ namespace func{ buildInvokableWrapper (FUN&& fun) { static_assert (is_Typelist::value); - using ArgTypes = typename TYPES::Seq; - using Builder = typename lib::meta::RebindVariadic::Type; + using ArgTypes = TYPES::Seq; + using Builder = lib::meta::RebindVariadic::Type; return Builder::buildWrapper (forward (fun)); } @@ -290,11 +290,11 @@ namespace func{ template class PApply { - using Args = typename _Fun::Args; - using Ret = typename _Fun::Ret; - using ArgsList = typename Args::List; - using ValList = typename VAL::List; - using ValTypes = typename Types::Seq; // reconstruct a type-seq from a type-list + using Args = _Fun::Args; + using Ret = _Fun::Ret; + using ArgsList = Args::List; + using ValList = VAL::List; + using ValTypes = Types::Seq; // reconstruct a type-seq from a type-list enum { ARG_CNT = count() , VAL_CNT = count() @@ -303,34 +303,34 @@ namespace func{ // create list of the *remaining* arguments, after applying the ValList - using LeftReduced = typename Splice::Back; - using RightReduced = typename Splice::Front; + using LeftReduced = Splice::Back; + using RightReduced = Splice::Front; - using ArgsL = typename Types::Seq; - using ArgsR = typename Types::Seq; + using ArgsL = Types::Seq; + using ArgsR = Types::Seq; // build a list, where each of the *remaining* arguments is replaced by a placeholder marker - using TrailingPlaceholders = typename func::PlaceholderTuple::List; - using LeadingPlaceholders = typename func::PlaceholderTuple::List; + using TrailingPlaceholders = func::PlaceholderTuple::List; + using LeadingPlaceholders = func::PlaceholderTuple::List; // ... and splice these placeholders on top of the original argument type list, // thus retaining the types to be closed, but setting a placeholder for each remaining argument - using LeftReplaced = typename Splice::List; - using RightReplaced = typename Splice::List; + using LeftReplaced = Splice::List; + using RightReplaced = Splice::List; - using LeftReplacedTypes = typename Types::Seq; - using RightReplacedTypes = typename Types::Seq; + using LeftReplacedTypes = Types::Seq; + using RightReplacedTypes = Types::Seq; // create a "builder" helper, which accepts exactly the value tuple elements // and puts them at the right location, while default-constructing the remaining // (=placeholder)-arguments. Using this builder helper, we can finally set up // the argument tuples (Left/RightReplacedArgs) used for the std::bind call template - using IdxSelectorL = typename PartiallyInitTuple::template IndexMapper; + using IdxSelectorL = PartiallyInitTuple::template IndexMapper; template - using IdxSelectorR = typename PartiallyInitTuple::template IndexMapper; + using IdxSelectorR = PartiallyInitTuple::template IndexMapper; using BuildL = TupleConstructor; using BuildR = TupleConstructor; @@ -404,31 +404,31 @@ namespace func{ template class BindToArgument { - using Args = typename _Fun::Args; - using Ret = typename _Fun::Ret; - using ArgsList = typename Args::List; - using ValList = typename Types::List; + using Args = _Fun::Args; + using Ret = _Fun::Ret; + using ArgsList = Args::List; + using ValList = Types::List; enum { ARG_CNT = count() }; - using RemainingFront = typename Splice::Front; - using RemainingBack = typename Splice::Back; - using PlaceholdersBefore = typename func::PlaceholderTuple::List; - using PlaceholdersBehind = typename func::PlaceholderTuple::List; + using RemainingFront = Splice::Front; + using RemainingBack = Splice::Back; + using PlaceholdersBefore = func::PlaceholderTuple::List; + using PlaceholdersBehind = func::PlaceholderTuple::List; using PreparedArgsRaw = typename Append::List // splice in the value tuple ,PlaceholdersBehind // arguments behind the splice: passed-through >::List; using PreparedArgs = Prefix; - using ReducedArgs = typename Append::List; + using ReducedArgs = Append::List; - using PreparedArgTypes = typename Types::Seq; - using RemainingArgs = typename Types::Seq; + using PreparedArgTypes = Types::Seq; + using RemainingArgs = Types::Seq; template - using IdxSelector = typename PartiallyInitTuple::template IndexMapper; + using IdxSelector = PartiallyInitTuple::template IndexMapper; using BuildPreparedArgs = TupleConstructor; @@ -461,10 +461,10 @@ namespace func{ template struct _Chain { - using Ret = typename _Fun::Ret; - using Args = typename _Fun::Args; + using Ret = _Fun::Ret; + using Args = _Fun::Args; - using FunType = typename BuildFunType::Fun; + using FunType = BuildFunType::Fun; static auto adaptedFunType() { return FunType{}; } diff --git a/src/lib/meta/function.hpp b/src/lib/meta/function.hpp index 90f303c67..e5ffd4a5a 100644 --- a/src/lib/meta/function.hpp +++ b/src/lib/meta/function.hpp @@ -250,7 +250,7 @@ namespace meta{ /** abbreviation for referring to a function's return type */ template - using _FunRet = typename _Fun::Ret; + using _FunRet = _Fun::Ret; namespace { template @@ -259,14 +259,14 @@ namespace meta{ static_assert(_Fun() , "something funktion-like required"); static_assert(_Fun::ARITY == 1 , "function with exactly one argument required"); - using Sig = typename _Fun::Sig; - using Arg = typename _Fun::Args::List::Head; + using Sig = _Fun::Sig; + using Arg = _Fun::Args::List::Head; }; } /** abbreviation for referring to a function's single Argument type */ template - using _FunArg = typename _DetectSingleArgFunction::Arg; + using _FunArg = _DetectSingleArgFunction::Arg; diff --git a/src/lib/meta/trait.hpp b/src/lib/meta/trait.hpp index 733cfdaf6..7ab1ff8a6 100644 --- a/src/lib/meta/trait.hpp +++ b/src/lib/meta/trait.hpp @@ -236,7 +236,7 @@ namespace meta { * reference to an anonymous temporary. */ template - typename Unwrap::Type& + Unwrap::Type& unwrap (X const& wrapped) { return Unwrap::extract(wrapped); @@ -258,7 +258,7 @@ namespace meta { using TypePointee = remove_pointer_t; using TypePlain = remove_cv_t; - using Type = typename Unwrap::Type; + using Type = Unwrap::Type; }; @@ -509,7 +509,7 @@ namespace meta { template class can_IterForEach { - using Type = typename Strip::Type; + using Type = Strip::Type; META_DETECT_NESTED(value_type); META_DETECT_OPERATOR_DEREF(); @@ -533,7 +533,7 @@ namespace meta { template class is_StateCore { - using Type = typename Strip::Type; + using Type = Strip::Type; META_DETECT_FUNCTION_ARGLESS(checkPoint); META_DETECT_FUNCTION_ARGLESS(iterNext); @@ -554,7 +554,7 @@ namespace meta { template class can_STL_ForEach { - using Type = typename Strip::Type; + using Type = Strip::Type; struct is_iterable { @@ -618,7 +618,7 @@ namespace meta { template class can_STL_backIteration { - using Type = typename Strip::Type; + using Type = Strip::Type; struct is_backIterable { diff --git a/src/lib/meta/tuple-closure.hpp b/src/lib/meta/tuple-closure.hpp index 9400a1e9d..35b551c0f 100644 --- a/src/lib/meta/tuple-closure.hpp +++ b/src/lib/meta/tuple-closure.hpp @@ -133,8 +133,8 @@ namespace meta{ static auto wrapBuilder (CLO closureFun) ///< need to provide the remaining arguments as a tuple { - using RemainingArgs = typename _Fun::Args; - using RemainingParams = typename lib::meta::RebindVariadic::Type; + using RemainingArgs = _Fun::Args; + using RemainingParams = lib::meta::RebindVariadic::Type; struct Wrap { @@ -186,13 +186,13 @@ namespace meta{ template struct _Adapt { - using NFold = typename Repeat::Seq; - using Array = typename RebindVariadic::Type; + using NFold = Repeat::Seq; + using Array = RebindVariadic::Type; static_assert(N,"attempt to partially close empty array"); }; template - using _AdaptArray_t = typename _Adapt::Array; + using _AdaptArray_t = _Adapt::Array; } /** @note adding seamless conversion and compount-init */ diff --git a/src/lib/meta/tuple-helper.hpp b/src/lib/meta/tuple-helper.hpp index 6e9af9711..3e14aa4cb 100644 --- a/src/lib/meta/tuple-helper.hpp +++ b/src/lib/meta/tuple-helper.hpp @@ -179,17 +179,17 @@ namespace meta { struct _InvokeMetafunTup { using Tupl = std::decay_t; - using Elms = typename ElmTypes::Seq; - using Args = typename Prepend::Seq; - using Type = typename RebindVariadic::Type; + using Elms = ElmTypes::Seq; + using Args = Prepend::Seq; + using Type = RebindVariadic::Type; }; template class META, class FUN, class TUP> struct _InvokeMetafunTup { using Tupl = std::decay_t; - using Elms = typename ElmTypes::Apply; - using Args = typename Prepend::Seq; - using Type = typename RebindVariadic::Type; + using Elms = typename ElmTypes::template Apply; + using Args = Prepend::Seq; + using Type = RebindVariadic::Type; }; template @@ -282,20 +282,20 @@ namespace meta { static constexpr size_t SIZ = std::tuple_size_v; using Idx = std::make_index_sequence; - using Seq = typename Extract::ElmTypes; - using Tup = typename RebindVariadic::Type; + using Seq = Extract::ElmTypes; + using Tup = RebindVariadic::Type; template class META> - using Apply = typename ElmTypes::template Apply; + using Apply = ElmTypes::template Apply; template class O> - using Rebind = typename RebindVariadic::Type; + using Rebind = RebindVariadic::Type; template class PRED> - using AndAll = typename ElmTypes>::template Rebind; + using AndAll = ElmTypes>::template Rebind; template class PRED> - using OrAll = typename ElmTypes>::template Rebind; + using OrAll = ElmTypes>::template Rebind; }; @@ -318,8 +318,8 @@ namespace meta { template struct BuildTupleType> { - using Seq = typename Types>::Seq; - using Type = typename BuildTupleType::Type; + using Seq = Types>::Seq; + using Type = BuildTupleType::Type; }; template<> @@ -339,7 +339,7 @@ namespace meta { * over clever re-use of existing types. */ template - using Tuple = typename BuildTupleType::Type; + using Tuple = BuildTupleType::Type; using std::tuple_size; @@ -351,14 +351,14 @@ namespace meta { template struct RebindTupleTypes { - using Seq = typename Types::Seq; - using List = typename Seq::List; + using Seq = Types::Seq; + using List = Seq::List; }; template struct RebindTupleTypes> { - using Seq = typename Types::Seq; - using List = typename Seq::List; + using Seq = Types::Seq; + using List = Seq::List; }; @@ -396,7 +396,7 @@ namespace meta { : Tuple { /** meta-sequence to drive instantiation of the ElmMapper */ - using SequenceIterator = typename BuildIdxIter::Ascending; + using SequenceIterator = BuildIdxIter::Ascending; template static auto @@ -436,7 +436,7 @@ namespace meta { template - using ExtractArg = typename ElementExtractor::template Access; + using ExtractArg = ElementExtractor::template Access; /** @@ -489,10 +489,10 @@ namespace meta { class BuildTupleAccessor { // prepare recursion... - using Head = typename Split::Head; - using Tail = typename Split::Tail; + using Head = Split::Head; + using Tail = Split::Tail; using NextBuilder = BuildTupleAccessor<_X_, Tail,TUP, i+1>; - using NextAccessor = typename NextBuilder::Product; + using NextAccessor = NextBuilder::Product; public: /** type of the product created by this template. @@ -575,7 +575,7 @@ namespace meta { dump (std::tuple const& tuple) { using BuildAccessor = BuildTupleAccessor>; - using Displayer = typename BuildAccessor::Product ; + using Displayer = BuildAccessor::Product ; return static_cast (tuple) .dump(); diff --git a/src/lib/meta/tuple-record-init.hpp b/src/lib/meta/tuple-record-init.hpp index 6ac6e7247..597e38cc9 100644 --- a/src/lib/meta/tuple-record-init.hpp +++ b/src/lib/meta/tuple-record-init.hpp @@ -107,7 +107,7 @@ namespace meta { > { }; - using SupportedSourceTypes = typename Filter::List; + using SupportedSourceTypes = Filter::List; @@ -193,7 +193,7 @@ namespace meta { struct ElementExtractor> { template - using TargetType = typename Pick, i>::Type; + using TargetType = Pick, i>::Type; template diff --git a/src/lib/meta/typelist-manip.hpp b/src/lib/meta/typelist-manip.hpp index 7d0e7a81b..15bc0ae4c 100644 --- a/src/lib/meta/typelist-manip.hpp +++ b/src/lib/meta/typelist-manip.hpp @@ -74,7 +74,7 @@ namespace meta { template struct Pick, i> { - using Type = typename Pick::Type; + using Type = Pick::Type; }; @@ -111,11 +111,11 @@ namespace meta { template< class TY, class TYPES , template class _P_ > - struct Filter,_P_> { using List = typename CondNode< _P_::value - , TY - , typename Filter::List - >::Next - ; }; + struct Filter,_P_> { using List = CondNode< _P_::value + , TY + , typename Filter::List + >::Next + ; }; /** append (concatenate) lists-of-types */ @@ -157,11 +157,11 @@ namespace meta { using List = Nil; }; template - struct PickLast> { using Type = typename PickLast::Type; - using List = typename Append< TY - , typename PickLast::List - >::List - ; }; + struct PickLast> { using Type = PickLast::Type; + using List = Append< TY + , typename PickLast::List + >::List + ; }; @@ -203,11 +203,11 @@ namespace meta { /** extract prefix of given length */ template - using Prefix = typename Splice::Front; + using Prefix = Splice::Front; /** extract suffix starting at given pos */ template - using Suffix = typename Splice::Back; + using Suffix = Splice::Back; @@ -222,13 +222,13 @@ namespace meta { template struct Dissect> { - using List = Node; ///< the complete list - using Head = T; ///< first element - using First = Node; ///< a list containing the first element - using Tail = TYPES; ///< remainder of the list starting with the second elm. - using Prefix = typename PickLast::List; ///< all of the list, up to but excluding the last element - using End = typename PickLast::Type; ///< the last element - using Last = Node; ///< a list containing the last element + using List = Node; ///< the complete list + using Head = T; ///< first element + using First = Node; ///< a list containing the first element + using Tail = TYPES; ///< remainder of the list starting with the second elm. + using Prefix = PickLast::List; ///< all of the list, up to but excluding the last element + using End = PickLast::Type; ///< the last element + using Last = Node; ///< a list containing the last element }; template<> @@ -276,7 +276,7 @@ namespace meta { * sources, i.e. the Cartesian product. */ template - struct Distribute { using List = typename PrefixAll::List; }; + struct Distribute { using List = PrefixAll::List; }; template struct Distribute { using List = Nil; }; @@ -284,10 +284,10 @@ namespace meta { template< class TY, class TYPES , class TAIL > - struct Distribute,TAIL> { using List = typename Append< typename PrefixAll::List - , typename Distribute::List - >::List - ; }; + struct Distribute,TAIL> { using List = Append< typename PrefixAll::List + , typename Distribute::List + >::List + ; }; @@ -306,17 +306,17 @@ namespace meta { */ template< class X , template class _ENUM_> - struct Combine { using List = typename Distribute< typename _ENUM_::List - , NilNode - >::List; }; + struct Combine { using List = Distribute< typename _ENUM_::List + , NilNode + >::List; }; template< template class _ENUM_> struct Combine { using List = NilNode; }; template< class TY, class TYPES , template class _ENUM_> - struct Combine,_ENUM_> { using List = typename Distribute< typename _ENUM_::List - , typename Combine::List - >::List; }; + struct Combine,_ENUM_> { using List = Distribute< typename _ENUM_::List + , typename Combine::List + >::List; }; /** enumeration generator for the Combine metafunction, * yielding an "on" and "off" case; the latter is @@ -334,7 +334,7 @@ namespace meta { template struct CombineFlags { - using List = typename Combine::List; + using List = Combine::List; }; diff --git a/src/lib/meta/typeseq-util.hpp b/src/lib/meta/typeseq-util.hpp index 5f3f0b0e0..67f6e5909 100644 --- a/src/lib/meta/typeseq-util.hpp +++ b/src/lib/meta/typeseq-util.hpp @@ -94,7 +94,7 @@ namespace meta { struct Prepend> { using Seq = Types; - using List = typename Types::List; + using List = Types::List; }; @@ -108,9 +108,9 @@ namespace meta { struct Types< Node > { using List = Node; - using Seq = typename Prepend< H - , typename Types::Seq - >::Seq; + using Seq = Prepend< H + , typename Types::Seq + >::Seq; }; template<> struct Types @@ -135,7 +135,7 @@ namespace meta { template struct Split > { - using List = typename Types::List; + using List = Types::List; using Head = T1; using First = Types; @@ -143,11 +143,11 @@ namespace meta { // for finding the end we need the help of typelist-util.hpp - using PrefixList = typename PickLast::List; - using TailList = typename Tail::List; + using PrefixList = PickLast::List; + using TailList = Tail::List; - using Prefix = typename Types::Seq; - using End = typename PickLast::Type; + using Prefix = Types::Seq; + using End = PickLast::Type; using Last = Types; }; @@ -180,17 +180,17 @@ namespace meta { template class Shifted { - using Tail = typename Split::Tail; + using Tail = Split::Tail; public: - using Type = typename Shifted::Type; - using Head = typename Split::Head; + using Type = Shifted::Type; + using Head = Split::Head; }; template struct Shifted { using Type = TYPES; - using Head = typename Split::Head; ///< @warning may be Nil in case of an empty list + using Head = Split::Head; ///< @warning may be Nil in case of an empty list }; @@ -202,7 +202,7 @@ namespace meta { template struct Pick, i> { - using Type = typename Shifted, i>::Head; + using Type = Shifted, i>::Head; }; @@ -214,8 +214,8 @@ namespace meta { template struct Repeat { - using Rem = typename Repeat::Seq; - using Seq = typename Prepend::Seq; + using Rem = Repeat::Seq; + using Seq = Prepend::Seq; }; template diff --git a/src/lib/meta/util.hpp b/src/lib/meta/util.hpp index f3e06a138..fce8b979c 100644 --- a/src/lib/meta/util.hpp +++ b/src/lib/meta/util.hpp @@ -84,10 +84,10 @@ namespace meta { * @see [std::enable_if](http://en.cppreference.com/w/cpp/types/enable_if) */ template - using enable_if = typename enable_if_c::type; + using enable_if = enable_if_c::type; template - using disable_if = typename enable_if_c::type; + using disable_if = enable_if_c::type; @@ -114,9 +114,9 @@ namespace meta { class _DetectNested_TypeResult { template - static Yes_t check(typename ZZ::type *); + static Yes_t check(ZZ::type *); template - static Yes_t check(typename X::Type *); + static Yes_t check(X::Type *); template static No_t check(...); @@ -145,7 +145,7 @@ namespace meta { } /** helper to extract the first argument from a variadic arg pack, if any */ template - using extractFirst_t = typename _ExtractFirst::Type; + using extractFirst_t = _ExtractFirst::Type; @@ -204,7 +204,7 @@ namespace meta { class is_Typelist { template - static Yes_t check(typename X::List *); + static Yes_t check(X::List *); template static No_t check(...); @@ -492,7 +492,7 @@ namespace util { inline std::string showSmartPtr (SP const& smPtr, std::string label = "smP") { - using TargetType = typename SP::element_type; + using TargetType = SP::element_type; return smPtr? label+"("+showAdr(smPtr.get()) + ") ↗" + StringConv::invoke(*smPtr) : BOTTOM_INDICATOR + " «" + typeStr(smPtr) + "»"; diff --git a/src/lib/meta/value-type-binding.hpp b/src/lib/meta/value-type-binding.hpp index 446609757..c816db729 100644 --- a/src/lib/meta/value-type-binding.hpp +++ b/src/lib/meta/value-type-binding.hpp @@ -107,20 +107,20 @@ namespace meta { template struct ValueTypeBinding { - using value_type = typename RefTraits::Value; - using reference = typename RefTraits::Reference; - using pointer = typename RefTraits::Pointer; + using value_type = RefTraits::Value; + using reference = RefTraits::Reference; + using pointer = RefTraits::Pointer; }; /** specialisation for classes providing STL style type binding definitions */ template struct ValueTypeBinding> > { - using _SrcType = typename RefTraits::Value; + using _SrcType = RefTraits::Value; - using value_type = typename _SrcType::value_type; - using reference = typename _SrcType::reference; - using pointer = typename _SrcType::pointer; + using value_type = _SrcType::value_type; + using reference = _SrcType::reference; + using pointer = _SrcType::pointer; }; @@ -159,9 +159,9 @@ namespace meta { >; using ResType = _ValRef; - using value_type = typename RefTraits::Value; - using reference = typename RefTraits::Reference; - using pointer = typename RefTraits::Pointer; + using value_type = RefTraits::Value; + using reference = RefTraits::Reference; + using pointer = RefTraits::Pointer; }; diff --git a/src/lib/meta/variadic-helper.hpp b/src/lib/meta/variadic-helper.hpp index 501352dd6..dcfcad5cf 100644 --- a/src/lib/meta/variadic-helper.hpp +++ b/src/lib/meta/variadic-helper.hpp @@ -70,20 +70,20 @@ namespace meta { template struct BuildIndexSeq { - using Ascending = typename BuildIndexSeq::Ascending::template AppendElm; - using Descending = typename BuildIndexSeq::Descending::template PrependElm; + using Ascending = BuildIndexSeq::Ascending::template AppendElm; + using Descending = BuildIndexSeq::Descending::template PrependElm; template - using OffsetBy = typename BuildIndexSeq::template OffsetBy::template AppendElm; + using OffsetBy = BuildIndexSeq::template OffsetBy::template AppendElm; template - using FilledWith = typename BuildIndexSeq::template FilledWith::template AppendElm; + using FilledWith = BuildIndexSeq::template FilledWith::template AppendElm; template - using First = typename BuildIndexSeq::Ascending; + using First = BuildIndexSeq::Ascending; template - using After = typename BuildIndexSeq< (n>c)? n-c : 0>::template OffsetBy; + using After = BuildIndexSeq< (n>c)? n-c : 0>::template OffsetBy; }; template<> @@ -118,20 +118,20 @@ namespace meta { enum {SIZ = sizeof...(TYPES) }; using Builder = BuildIndexSeq; - using Ascending = typename Builder::Ascending; - using Descending = typename Builder::Descending; + using Ascending = Builder::Ascending; + using Descending = Builder::Descending; template - using OffsetBy = typename Builder::template OffsetBy; + using OffsetBy = Builder::template OffsetBy; template - using FilledWith = typename Builder::template FilledWith; + using FilledWith = Builder::template FilledWith; template - using First = typename Builder::template First; + using First = Builder::template First; template - using After = typename Builder::template After; + using After = Builder::template After; }; /** build an index number sequence from a type sequence */ @@ -193,13 +193,13 @@ namespace meta { using Apply = Types...>; template class O> - using Rebind = typename lib::meta::RebindVariadic::Type; + using Rebind = lib::meta::RebindVariadic::Type; template class PRED> - using AndAll = typename ElmTypes>::template Rebind; + using AndAll = ElmTypes>::template Rebind; template class PRED> - using OrAll = typename ElmTypes>::template Rebind; + using OrAll = ElmTypes>::template Rebind; }; // Note: a further specialisation for any »tuple-like« is defined in tuple-helper.hpp diff --git a/src/lib/meta/variadic-rebind.hpp b/src/lib/meta/variadic-rebind.hpp index 19b30ce9a..755704b77 100644 --- a/src/lib/meta/variadic-rebind.hpp +++ b/src/lib/meta/variadic-rebind.hpp @@ -34,13 +34,13 @@ ** template ** struct MyModel ** { - ** using SubSeq = typename _Vari::Prefix; + ** using SubSeq = _Vari::Prefix; ** ** // adapt a predecessor sequence ** MyModel (SubSeq&& subModel); ** ** - ** using Tuple = typename RebindVariadic::Type; + ** using Tuple = RebindVariadic::Type; ** } ** \endcode ** @see param-weaving-pattern.hpp "usage example" @@ -138,15 +138,15 @@ namespace meta { template class L, typename X, typename...XS> struct _Vari { - using Penult = typename _Vari::Penult; - using Ultima = typename _Vari::Ultima; + using Penult = _Vari::Penult; + using Ultima = _Vari::Ultima; - using _Tail_Pre_ = typename _Vari::Prefix; - using _Tail_Rev_ = typename _Vari::Revers; + using _Tail_Pre_ = _Vari::Prefix; + using _Tail_Rev_ = _Vari::Revers; using Remain = L; - using Prefix = typename _Vari::Prepend; - using Revers = typename _Vari::Prepend; + using Prefix = _Vari::Prepend; + using Revers = _Vari::Prepend; }; }} // namespace lib::meta diff --git a/src/lib/multifact.hpp b/src/lib/multifact.hpp index 5f9b292d6..1877d65ef 100644 --- a/src/lib/multifact.hpp +++ b/src/lib/multifact.hpp @@ -103,7 +103,7 @@ namespace lib { template struct BuildRefcountPtr { - using RawType = typename std::remove_pointer::type; + using RawType = std::remove_pointer::type; using BareType = RawType *; using ResultType = std::shared_ptr; @@ -210,8 +210,8 @@ namespace lib { struct FabConfig { using WrapFunctor = Wrapper; - using BareProduct = typename WrapFunctor::BareType; - using WrappedProduct = typename WrapFunctor::ResultType; + using BareProduct = WrapFunctor::BareType; + using WrappedProduct = WrapFunctor::ResultType; typedef BareProduct SIG_Fab(void); @@ -228,8 +228,8 @@ namespace lib { struct FabConfig { using WrapFunctor = Wrapper; - using BareProduct = typename WrapFunctor::BareType; - using WrappedProduct = typename WrapFunctor::ResultType; + using BareProduct = WrapFunctor::BareType; + using WrappedProduct = WrapFunctor::ResultType; typedef BareProduct SIG_Fab(ARGS...); @@ -259,14 +259,14 @@ namespace lib { : public FabConfig::WrapFunctor { using _Conf = FabConfig; - using SIG_Fab = typename _Conf::SIG_Fab; + using SIG_Fab = _Conf::SIG_Fab; using _Fab = Fab; _Fab funcTable_; protected: - using Creator = typename _Fab::FactoryFunc; + using Creator = _Fab::FactoryFunc; Creator& selectProducer (ID const& id) @@ -276,7 +276,7 @@ namespace lib { public: - using Product = typename _Conf::WrappedProduct; + using Product = _Conf::WrappedProduct; /** * Core operation of the factory: diff --git a/src/lib/opaque-holder.hpp b/src/lib/opaque-holder.hpp index ba7e539aa..f6ea4d0aa 100644 --- a/src/lib/opaque-holder.hpp +++ b/src/lib/opaque-holder.hpp @@ -200,7 +200,7 @@ namespace lib { > class InPlaceAnyHolder { - using BaseP = typename AccessPolicy::Base *; + using BaseP = AccessPolicy::Base *; /** Inner capsule managing the contained object (interface) */ struct Buffer diff --git a/src/lib/parse.hpp b/src/lib/parse.hpp index 2c6e06529..b3f821d32 100644 --- a/src/lib/parse.hpp +++ b/src/lib/parse.hpp @@ -203,7 +203,7 @@ namespace util { using PFun = FUN; PFun parse; - using Result = typename _Fun::Ret::Result; + using Result = _Fun::Ret::Result; Connex (FUN pFun) : parse{pFun} @@ -281,7 +281,7 @@ namespace util { inline auto buildConnex (Syntax const& anchor) { - using Con = typename Syntax::Connex; + using Con = Syntax::Connex; return Con{anchor}; } @@ -336,9 +336,9 @@ namespace util { inline auto adaptConnex (CON&& connex, BIND&& modelBinding) { - using RX = typename CON::Result; + using RX = CON::Result; using Arg = std::add_rvalue_reference_t; - using AdaptedRes = typename _ProbeFunReturn::Ret; + using AdaptedRes = _ProbeFunReturn::Ret; return Connex{[origConnex = forward(connex) ,binding = forward(modelBinding) ] @@ -357,7 +357,7 @@ namespace util { inline auto toStringConnex (CON&& connex, uint part) { - using Result = typename CON::Result; + using Result = CON::Result; return Connex([baseConnex = forward(connex) ,part ] @@ -442,9 +442,9 @@ namespace util { /* === Builder functions to mark which side of the combinator to pick === */ - using SubSeq = typename _Vari::Prefix; ///< a nested sub-model to extend - using Penult = typename _Vari::Penult; ///< plain value expected for left-branch - using Ultima = typename _Vari::Ultima; ///< plain value expected for right-branch + using SubSeq = _Vari::Prefix; ///< a nested sub-model to extend + using Penult = _Vari::Penult; ///< plain value expected for left-branch + using Ultima = _Vari::Ultima; ///< plain value expected for right-branch static AltModel mark_left (SubSeq&& leftCases) @@ -524,9 +524,9 @@ namespace util { inline auto sequenceConnex (C1&& connex1, C2&& connex2) { - using R1 = typename decay_t::Result; - using R2 = typename decay_t::Result; - using ProductResult = typename _Join::Result; + using R1 = decay_t::Result; + using R2 = decay_t::Result; + using ProductResult = _Join::Result; using ProductEval = Eval; return Connex{[conL = forward(connex1) ,conR = forward(connex2) @@ -558,9 +558,9 @@ namespace util { inline auto branchedConnex (C1&& connex1, C2&& connex2) { - using R1 = typename decay_t::Result; - using R2 = typename decay_t::Result; - using SumResult = typename _Join::Result; + using R1 = decay_t::Result; + using R2 = decay_t::Result; + using SumResult = _Join::Result; using SumEval = Eval; return Connex{[conL = forward(connex1) ,conR = forward(connex2) @@ -595,7 +595,7 @@ namespace util { ,C1&& delimConnex ,C2&& bodyConnex) { - using Res = typename decay_t::Result; + using Res = decay_t::Result; using IterResult = IterModel; using IterEval = Eval; return Connex{[sep = forward(delimConnex) @@ -636,7 +636,7 @@ namespace util { inline auto optionalConnex (CNX&& connex) { - using Res = typename decay_t::Result; + using Res = decay_t::Result; using OptResult = optional; using OptEval = Eval; return Connex{[body = forward(connex) @@ -661,7 +661,7 @@ namespace util { ,C3&& bodyConnex ,bool isOptional) { - using Res = typename decay_t::Result; + using Res = decay_t::Result; return Connex{[opening = forward(openingConnex) ,closing = forward(closingConnex) ,body = forward(bodyConnex) @@ -704,12 +704,12 @@ namespace util { class Parser : public CON { - using PFun = typename CON::PFun; + using PFun = CON::PFun; static_assert (_Fun(), "Connex must define a parse-function"); public: using Connex = CON; - using Result = typename CON::Result; + using Result = CON::Result; static_assert (has_Sig(StrView)>() ,"Signature of the parse-function not suitable"); @@ -785,8 +785,8 @@ namespace util { PAR parse_; public: - using Connex = typename PAR::Connex; - using Result = typename PAR::Result; + using Connex = PAR::Connex; + using Result = PAR::Result; Syntax() : parse_{Nil()} @@ -826,7 +826,7 @@ namespace util { Syntax& operator= (Syntax refSyntax) { - using ConX = typename PX::Connex; + using ConX = PX::Connex; ConX& refConnex = refSyntax; parse_.parse = move(refConnex.parse); return *this; diff --git a/src/lib/path-array.hpp b/src/lib/path-array.hpp index 2d13f54ea..de3623c5a 100644 --- a/src/lib/path-array.hpp +++ b/src/lib/path-array.hpp @@ -259,8 +259,8 @@ namespace lib { template struct Split { - using Prefix = typename meta::BuildIndexSeq::Ascending; - using Rest = typename meta::BuildIdxIter::template After; + using Prefix = meta::BuildIndexSeq::Ascending; + using Rest = meta::BuildIdxIter::template After; }; public: @@ -560,8 +560,8 @@ namespace lib { { if (l.size() != r.size()) return false; - typename PathArray::iterator lp = l.begin(); - typename PathArray::iterator rp = r.begin(); + auto lp = l.begin(); + auto rp = r.begin(); while (lp and rp) { if (*lp != *rp) return false; diff --git a/src/lib/polymorphic-value.hpp b/src/lib/polymorphic-value.hpp index 54fa1057c..d9ff8787f 100644 --- a/src/lib/polymorphic-value.hpp +++ b/src/lib/polymorphic-value.hpp @@ -366,8 +366,8 @@ namespace lib { { private: typedef polyvalue::Trait _Traits; - typedef typename _Traits::CopyAPI _CopyHandlingAdapter; - typedef typename _Traits::Assignment _AssignmentPolicy; /////////////////TICKET #1197 : confusingly indirect decision logic + typedef _Traits::CopyAPI _CopyHandlingAdapter; + typedef _Traits::Assignment _AssignmentPolicy; /////////////////TICKET #1197 : confusingly indirect decision logic enum{ siz = storage + _Traits::ADMIN_OVERHEAD }; diff --git a/src/lib/random-draw.hpp b/src/lib/random-draw.hpp index 5b263dcd3..442a6c845 100644 --- a/src/lib/random-draw.hpp +++ b/src/lib/random-draw.hpp @@ -175,11 +175,11 @@ namespace lib { : public LazyInit { using Lazy = LazyInit; - using Disabled = typename Lazy::MarkDisabled; + using Disabled = Lazy::MarkDisabled; - using Sig = typename _Fun::Sig; - using Fun = function; - using Tar = typename _Fun::Ret; + using Sig = _Fun::Sig; + using Fun = function; + using Tar = _Fun::Ret; Tar maxResult_{Tar::maxVal()}; ///< maximum result val actually to produce < max Tar minResult_{Tar::minVal()}; ///< minimum result val actually to produce > min @@ -363,16 +363,16 @@ namespace lib { using _Fun = lib::meta::_Fun; static_assert (_Fun(), "Need something function-like."); - using Sig = typename _Fun::Sig; - using Args = typename _Fun::Args; - using BaseIn = typename lib::meta::_Fun::Args; + using Sig = _Fun::Sig; + using Args = _Fun::Args; + using BaseIn = lib::meta::_Fun::Args; if constexpr (std::is_same_v) // function accepts same arguments as this RandomDraw return forward (fun); // pass-through directly else {// attempt to find a custom adaptor via Policy template - using Adaptor = typename POL::template Adaptor; + using Adaptor = POL::template Adaptor; return Adaptor::build (forward (fun)); } } @@ -392,7 +392,7 @@ namespace lib { { static_assert (lib::meta::_Fun(), "Need something function-like."); - using Res = typename lib::meta::_Fun::Ret; + using Res = lib::meta::_Fun::Ret; using lib::meta::func::chained; using lib::meta::_FunRet; diff --git a/src/lib/random.hpp b/src/lib/random.hpp index 241a6ddfc..44ce7abe9 100644 --- a/src/lib/random.hpp +++ b/src/lib/random.hpp @@ -280,7 +280,7 @@ namespace lib { public: using GEN::GEN; - typename GEN::result_type + GEN::result_type operator()() { if constexpr (GEN::max() < std::numeric_limits::max()) diff --git a/src/lib/scoped-collection.hpp b/src/lib/scoped-collection.hpp index a35143744..8d4d9d82d 100644 --- a/src/lib/scoped-collection.hpp +++ b/src/lib/scoped-collection.hpp @@ -428,7 +428,7 @@ namespace lib { { public: void - operator() (typename ScopedCollection::ElementHolder& storage) + operator() (ScopedCollection::ElementHolder& storage) { storage.template create(); } @@ -440,7 +440,7 @@ namespace lib { { public: void - operator() (typename ScopedCollection::ElementHolder& storage) + operator() (ScopedCollection::ElementHolder& storage) { storage.template create(); } @@ -461,7 +461,7 @@ namespace lib { { IT iter_; - using ElementType = typename meta::ValueTypeBinding::value_type; + using ElementType = meta::ValueTypeBinding::value_type; public: PullFrom (IT source) @@ -469,7 +469,7 @@ namespace lib { { } void - operator() (typename ScopedCollection::ElementHolder& storage) + operator() (ScopedCollection::ElementHolder& storage) { storage.template create (*iter_); ++iter_; diff --git a/src/lib/scoped-ptrvect.hpp b/src/lib/scoped-ptrvect.hpp index 5dd87678d..81fdfe76c 100644 --- a/src/lib/scoped-ptrvect.hpp +++ b/src/lib/scoped-ptrvect.hpp @@ -68,13 +68,13 @@ namespace lib { : util::MoveAssign { using _Vec = std::vector; - using VIter = typename _Vec::iterator; + using VIter = _Vec::iterator; using RIter = RangeIter; using IterType = PtrDerefIter; - using ConstIterType = typename IterType::ConstIterType; - using RcIter = typename IterType::WrappedConstIterType; + using ConstIterType = IterType::ConstIterType; + using RcIter = IterType::WrappedConstIterType; _Vec vec_; diff --git a/src/lib/several-builder.hpp b/src/lib/several-builder.hpp index d282ca256..9bc5f6795 100644 --- a/src/lib/several-builder.hpp +++ b/src/lib/several-builder.hpp @@ -185,7 +185,7 @@ namespace lib { using Bucket = ArrayBucket; template - using XAlloT = typename AlloT::template rebind_traits>; + using XAlloT = AlloT::template rebind_traits>; Allo& baseAllocator() { return *this; } @@ -193,7 +193,7 @@ namespace lib { auto adaptAllocator() { - using XAllo = typename XAlloT::allocator_type; + using XAllo = XAlloT::allocator_type; if constexpr (std::is_constructible_v) return XAllo{baseAllocator()}; else @@ -401,7 +401,7 @@ namespace lib { using Policy = POL; using Bucket = several::ArrayBucket; - using Deleter = typename Bucket::Deleter; + using Deleter = Bucket::Deleter; public: SeveralBuilder() = default; @@ -477,7 +477,7 @@ namespace lib { SeveralBuilder&& appendAll (std::initializer_list ili) { - using Val = typename meta::Strip::TypeReferred; + using Val = meta::Strip::TypeReferred; for (Val const& x : ili) emplaceNewElm (x); return move(*this); @@ -507,7 +507,7 @@ namespace lib { SeveralBuilder&& emplace (ARGS&& ...args) { - using Val = typename meta::Strip::TypeReferred; + using Val = meta::Strip::TypeReferred; emplaceNewElm (forward (args)...); return move(*this); } @@ -549,7 +549,7 @@ namespace lib { void emplaceCopy (IT& dataSrc) { - using Val = typename IT::value_type; + using Val = IT::value_type; emplaceNewElm (*dataSrc); } @@ -557,7 +557,7 @@ namespace lib { void emplaceMove (IT& dataSrc) { - using Val = typename IT::value_type; + using Val = IT::value_type; emplaceNewElm (move (*dataSrc)); } @@ -737,9 +737,9 @@ namespace lib { Deleter selectDestructor() { - using IVal = typename lib::meta::Strip::TypeReferred; - using EVal = typename lib::meta::Strip::TypeReferred; - using TVal = typename lib::meta::Strip::TypeReferred; + using IVal = lib::meta::Strip::TypeReferred; + using EVal = lib::meta::Strip::TypeReferred; + using TVal = lib::meta::Strip::TypeReferred; typename Policy::Fac& factory(*this); @@ -783,8 +783,8 @@ namespace lib { void probeMoveCapability() { - using TVal = typename lib::meta::Strip::TypeReferred; - using EVal = typename lib::meta::Strip::TypeReferred; + using TVal = lib::meta::Strip::TypeReferred; + using EVal = lib::meta::Strip::TypeReferred; if (not (is_same_v or is_trivially_copyable_v)) lock_move = true; @@ -793,7 +793,7 @@ namespace lib { bool canWildMove() { - using EVal = typename lib::meta::Strip::TypeReferred; + using EVal = lib::meta::Strip::TypeReferred; return is_trivially_copyable_v and not lock_move; } diff --git a/src/lib/several.hpp b/src/lib/several.hpp index f517168d2..52e3a1645 100644 --- a/src/lib/several.hpp +++ b/src/lib/several.hpp @@ -227,8 +227,8 @@ namespace lib { friend auto begin (Several const& svl) { return svl.begin();} friend auto end (Several const& svl) { return svl.end(); } - using value_type = typename meta::RefTraits::Value; - using reference = typename meta::RefTraits::Reference; + using value_type = meta::RefTraits::Value; + using reference = meta::RefTraits::Reference; using const_reference = value_type const&; diff --git a/src/lib/stat/data.hpp b/src/lib/stat/data.hpp index 8c9ce6f2d..75af73e08 100644 --- a/src/lib/stat/data.hpp +++ b/src/lib/stat/data.hpp @@ -456,7 +456,7 @@ namespace stat{ % csv.getParsedFieldCnt() % columnCnt % line}; } - using Value = typename std::remove_reference::type::ValueType; + using Value = std::remove_reference::type::ValueType; col.get() = parseAs(*csv); ++csv; }); diff --git a/src/lib/sync-classlock.hpp b/src/lib/sync-classlock.hpp index a44153238..bfad118c9 100644 --- a/src/lib/sync-classlock.hpp +++ b/src/lib/sync-classlock.hpp @@ -55,8 +55,8 @@ namespace lib { class ClassLock : public Sync::Lock { - using Lock = typename Sync::Lock; - using Monitor = typename sync::Monitor; + using Lock = Sync::Lock; + using Monitor = sync::Monitor; struct PerClassMonitor : Monitor {}; diff --git a/src/lib/test/microbenchmark-adaptor.hpp b/src/lib/test/microbenchmark-adaptor.hpp index fa265ef57..d795c99ab 100644 --- a/src/lib/test/microbenchmark-adaptor.hpp +++ b/src/lib/test/microbenchmark-adaptor.hpp @@ -151,7 +151,7 @@ namespace microbenchmark { static_assert (lib::meta::_Fun(), "Need something function-like."); static_assert (lib::meta::_Fun::ARITY <=1, "Function with zero or one argument required."); - using Sig = typename lib::meta::_Fun::Sig; + using Sig = lib::meta::_Fun::Sig; return Adaptor::wrap (std::forward (fun)); } diff --git a/src/lib/test/test-helper.hpp b/src/lib/test/test-helper.hpp index faeeab38f..4f3a73515 100644 --- a/src/lib/test/test-helper.hpp +++ b/src/lib/test/test-helper.hpp @@ -257,7 +257,7 @@ namespace test{ showType() { using Case = TypeDiagnostics; - using Type = typename Case::Type; + using Type = Case::Type; return Case::prefix + meta::humanReadableTypeID (typeid(Type).name()) diff --git a/src/lib/text-template.hpp b/src/lib/text-template.hpp index 6fa19255b..7d28ba42b 100644 --- a/src/lib/text-template.hpp +++ b/src/lib/text-template.hpp @@ -372,10 +372,10 @@ namespace lib { class InstanceCore { using ActionIter = IndexIter; - using DataCtxIter = typename SRC::Iter; + using DataCtxIter = SRC::Iter; using NestedCtx = std::pair; using CtxStack = std::stack>; - using Value = typename SRC::Value; + using Value = SRC::Value; SRC dataSrc_; ActionIter actionIter_; @@ -826,7 +826,7 @@ namespace lib { /** Instantiate next Action token and expose its rendering */ template - inline typename SRC::Value + inline SRC::Value TextTemplate::InstanceCore::instantiateNext() { return actionIter_? actionIter_->instantiate(*this) @@ -840,7 +840,7 @@ namespace lib { * @return the rendering produced by the selected next Action token */ template - inline typename SRC::Value + inline SRC::Value TextTemplate::InstanceCore::reInstatiate (Idx nextCode) { if (nextCode == Idx(-1)) @@ -852,7 +852,7 @@ namespace lib { /** retrieve a data value from the data source for the indiated key */ template - inline typename SRC::Value + inline SRC::Value TextTemplate::InstanceCore::getContent (string key) { static Value nil{}; diff --git a/src/lib/thread.hpp b/src/lib/thread.hpp index 6ec2223db..1e57b01f1 100644 --- a/src/lib/thread.hpp +++ b/src/lib/thread.hpp @@ -523,13 +523,13 @@ namespace lib { static_assert(1 == _Fun::ARITY); static_assert(1 >= _Fun::ARITY); // argument type expected by the hooks down in the policy class - using Arg = typename _Fun::Args::List::Head; + using Arg = _Fun::Args::List::Head; // distinguish if user provided functor takes zero or one argument if constexpr (0 == _Fun::ARITY) return [hook = forward(hook)](Arg){ hook(); }; else { // instance type expected by the user-provided hook - using Target = typename _Fun::Args::List::Head; + using Target = _Fun::Args::List::Head; return [hook = forward(hook)] (Arg& threadWrapper) { // build a two-step cast path from the low-level wrapper to user type @@ -764,7 +764,7 @@ namespace lib { inline void launchDetached (string const& threadID, INVO&& ...args) { - using Launch = typename TAR::Launch; + using Launch = TAR::Launch; launchDetached (Launch{forward (args)...} .threadID (threadID)); } @@ -774,7 +774,7 @@ namespace lib { inline void launchDetached (string const& threadID, void (TAR::*memFun) (ARGS...), ARGS ...args) { - using Launch = typename TAR::Launch; + using Launch = TAR::Launch; launchDetached (Launch{std::move (memFun) ,lib::meta::InstancePlaceholder{} ,forward (args)... diff --git a/src/lib/time/control-impl.hpp b/src/lib/time/control-impl.hpp index bd61fc4cd..99d7fd91f 100644 --- a/src/lib/time/control-impl.hpp +++ b/src/lib/time/control-impl.hpp @@ -151,7 +151,7 @@ namespace mutation { TI operator() (TI const& changedVal) const { - typedef typename ListenerList::const_iterator Iter; + using Iter = ListenerList::const_iterator; Iter p = listeners_.begin(); Iter e = listeners_.end(); diff --git a/src/lib/time/formats.hpp b/src/lib/time/formats.hpp index 1c5ce0e7f..b5e2f5ca5 100644 --- a/src/lib/time/formats.hpp +++ b/src/lib/time/formats.hpp @@ -217,7 +217,7 @@ namespace time { static Supported formats() { - typedef typename TY::List SupportedFormats; + using SupportedFormats = TY::List; return Supported().define(SupportedFormats()); } diff --git a/src/lib/time/timequant.hpp b/src/lib/time/timequant.hpp index 1bddcc267..314610e0d 100644 --- a/src/lib/time/timequant.hpp +++ b/src/lib/time/timequant.hpp @@ -101,7 +101,7 @@ namespace time { bool supports() const; ///< does our implicit time grid support building that timecode format? template - typename format::Traits::TimeCode + format::Traits::TimeCode formatAs() const; ///< create new time code instance, then #castInto template @@ -133,10 +133,10 @@ namespace time { template - inline typename format::Traits::TimeCode + inline format::Traits::TimeCode QuTime::formatAs() const { - using TC = typename format::Traits::TimeCode; + using TC = format::Traits::TimeCode; return TC(*this); } @@ -154,7 +154,7 @@ namespace time { inline void QuTime::castInto (TC& timecode) const { - using Format = typename TC::Format; + using Format = TC::Format; REQUIRE (supports()); Format::rebuild (timecode, *quantiser_, TimeValue(*this)); diff --git a/src/lib/util-coll.hpp b/src/lib/util-coll.hpp index d17cea7da..06d819994 100644 --- a/src/lib/util-coll.hpp +++ b/src/lib/util-coll.hpp @@ -54,7 +54,7 @@ namespace util { template struct treat_as_STL_Container { - typedef typename lib::meta::Unwrap::Type TaT; + typedef lib::meta::Unwrap::Type TaT; enum{ value = lib::meta::can_STL_ForEach::value &&!lib::meta::can_IterForEach::value @@ -71,7 +71,7 @@ namespace util { template struct can_direct_access_Last { - typedef typename lib::meta::Unwrap::Type TaT; + typedef lib::meta::Unwrap::Type TaT; enum{ value = lib::meta::can_STL_backIteration::value }; @@ -159,7 +159,7 @@ namespace util { inline auto max (IT&& elms) { - using Val = typename std::remove_reference_t::value_type; + using Val = std::remove_reference_t::value_type; Val res = std::numeric_limits::min(); for (auto const& elm : std::forward (elms)) if (elm > res) @@ -171,7 +171,7 @@ namespace util { inline auto max (CON const& elms) { - using Val = typename std::remove_reference_t::value_type; + using Val = std::remove_reference_t::value_type; Val res = std::numeric_limits::min(); for (auto const& elm : elms) if (elm > res) @@ -184,7 +184,7 @@ namespace util { inline auto min (IT&& elms) { - using Val = typename std::remove_reference_t::value_type; + using Val = std::remove_reference_t::value_type; Val res = std::numeric_limits::max(); for (auto const& elm : std::forward (elms)) if (elm < res) @@ -196,7 +196,7 @@ namespace util { inline auto min (CON const& elms) { - using Val = typename std::remove_reference_t::value_type; + using Val = std::remove_reference_t::value_type; Val res = std::numeric_limits::max(); for (auto const& elm : elms) if (elm < res) diff --git a/src/lib/util.hpp b/src/lib/util.hpp index 1c63cf0b9..f834299a8 100644 --- a/src/lib/util.hpp +++ b/src/lib/util.hpp @@ -271,7 +271,7 @@ namespace util { /** fetch value from a Map, or return a default if not found */ template - inline typename MAP::mapped_type + inline MAP::mapped_type getValue_or_default (MAP& map, typename MAP::key_type const& key , typename MAP::mapped_type defaultVal) { @@ -288,7 +288,7 @@ namespace util { * @see lib::NullValue */ template - inline typename MAP::mapped_type const & + inline MAP::mapped_type const & access_or_default (MAP& map, typename MAP::key_type const& key , typename MAP::mapped_type const& refDefault) { @@ -302,7 +302,7 @@ namespace util { /** shortcut for removing all copies of an Element * in any sequential collection */ template - inline typename SEQ::iterator + inline SEQ::iterator removeall (SEQ& coll, typename SEQ::value_type const& val) { typename SEQ::iterator collEnd = coll.end(); @@ -318,7 +318,7 @@ namespace util { template bool remove_if (SET& set, FUN test) { - typedef typename SET::iterator Itor; + using Itor = SET::iterator; bool found = false; Itor end = set.end(); Itor begin = set.begin(); diff --git a/src/lib/variant.hpp b/src/lib/variant.hpp index 0351c205b..1561e7e83 100644 --- a/src/lib/variant.hpp +++ b/src/lib/variant.hpp @@ -221,9 +221,9 @@ namespace lib { }; template - using VisitorFunc = typename variant::VFunc::template VisitorInterface; + using VisitorFunc = variant::VFunc::template VisitorInterface; template - using VisitorConstFunc = typename variant::VFunc::template VisitorInterface>; + using VisitorConstFunc = variant::VFunc::template VisitorInterface>; /** * to be implemented by the client for visitation @@ -443,7 +443,7 @@ namespace lib { Variant() { - using DefaultType = typename TYPES::List::Head; + using DefaultType = TYPES::List::Head; new(storage_) Buff (DefaultType()); } @@ -453,7 +453,7 @@ namespace lib { { static_assert (variant::CanBuildFrom(), "No type in Typelist can be built from the given argument"); - using StorageType = typename variant::CanBuildFrom::Type; + using StorageType = variant::CanBuildFrom::Type; new(storage_) Buff (forward(x)); } @@ -477,7 +477,7 @@ namespace lib { Variant& operator= (X x) { - using RawType = typename std::remove_reference::type; + using RawType = std::remove_reference::type; static_assert (meta::isInList(), "Type error: the given variant could never hold the required type"); static_assert (std::is_copy_assignable::value, "target type does not support assignment"); diff --git a/src/lib/verb-visitor.hpp b/src/lib/verb-visitor.hpp index 7e4a4c6f9..1efe6950f 100644 --- a/src/lib/verb-visitor.hpp +++ b/src/lib/verb-visitor.hpp @@ -133,13 +133,13 @@ namespace lib { using Args = std::tuple; /** meta-sequence to pick argument values from the storage tuple */ - using SequenceIterator = typename meta::BuildIdxIter::Ascending; + using SequenceIterator = meta::BuildIdxIter::Ascending; /** Storage for the argument tuple */ Args args_; template - VerbHolder (typename Verb::Handler handlerRef, Literal verbID, PARS&&... args) + VerbHolder (Verb::Handler handlerRef, Literal verbID, PARS&&... args) : Verb{handlerRef, verbID} , args_{std::forward (args)...} { } @@ -203,7 +203,7 @@ namespace lib { }; template - using PayloadType = typename HandlerTypeDetector::Payload *; + using PayloadType = HandlerTypeDetector::Payload *; public: diff --git a/src/lib/visitor-dispatcher.hpp b/src/lib/visitor-dispatcher.hpp index fe846b548..1ef54ff70 100644 --- a/src/lib/visitor-dispatcher.hpp +++ b/src/lib/visitor-dispatcher.hpp @@ -108,7 +108,7 @@ namespace visitor { template class Dispatcher { - using ReturnType = typename TOOL::ReturnType; + using ReturnType = TOOL::ReturnType; /** generator for Trampoline functions, * used to dispatch calls down to the diff --git a/src/lib/visitor.hpp b/src/lib/visitor.hpp index 33c87bb2d..b8a950e31 100644 --- a/src/lib/visitor.hpp +++ b/src/lib/visitor.hpp @@ -152,7 +152,7 @@ namespace visitor { : public Applicable { - using ToolBase = typename BASE::ToolBase; + using ToolBase = BASE::ToolBase; protected: virtual ~Applicable () {} @@ -188,7 +188,7 @@ namespace visitor { class Visitable { public: - using ReturnType = typename TOOL::ReturnType; + using ReturnType = TOOL::ReturnType; /** to be defined by the DEFINE_PROCESSABLE_BY macro * in all classes wanting to be treated by some tool */ @@ -199,7 +199,7 @@ namespace visitor { virtual ~Visitable () { }; /// @note may differ from TOOL - using ToolBase = typename TOOL::ToolBase; + using ToolBase = TOOL::ToolBase; /** @internal used by the #DEFINE_PROCESSABLE_BY macro. * Dispatches to the actual operation on the diff --git a/src/lib/wrapper-function-result.hpp b/src/lib/wrapper-function-result.hpp index a5fd1da50..7fe2644a1 100644 --- a/src/lib/wrapper-function-result.hpp +++ b/src/lib/wrapper-function-result.hpp @@ -53,7 +53,7 @@ namespace wrapper { : public function , util::NonCopyable { - using Res = typename _Fun::Ret; + using Res = _Fun::Ret; using ResWrapper = ItemWrapper; ResWrapper lastResult_; diff --git a/src/stage/interact/view-spec-dsl.hpp b/src/stage/interact/view-spec-dsl.hpp index 63330f57c..4c360b6a3 100644 --- a/src/stage/interact/view-spec-dsl.hpp +++ b/src/stage/interact/view-spec-dsl.hpp @@ -210,10 +210,10 @@ namespace interact { using lib::meta::Types; using lib::meta::func::PApply; - using Ret = typename _Fun::Ret; - using Args = typename _Fun::Args; - using Arg1 = typename Split::Head; - using FurtherArgs = typename Split::Tail; + using Ret = _Fun::Ret; + using Args = _Fun::Args; + using Arg1 = Split::Head; + using FurtherArgs = Split::Tail; static_assert (std::is_convertible::value, "Allocator function must accept UICoordinates (where to create/locate) as first argument"); diff --git a/src/stage/model/element-access.hpp b/src/stage/model/element-access.hpp index d9548c3e4..0864fc9dc 100644 --- a/src/stage/model/element-access.hpp +++ b/src/stage/model/element-access.hpp @@ -129,7 +129,7 @@ namespace model { template // note the "backward" use. We pick that base interface using canUpcast = std::is_convertible; // into which our desired result type can be upcast, because // we know the then following dynamic_cast (downcast) can succeed - using Base = typename RawResult::FirstMatching::Type; + using Base = RawResult::FirstMatching::Type; virtual void handle (Base& pb) override diff --git a/src/steam/control/argument-tuple-accept.hpp b/src/steam/control/argument-tuple-accept.hpp index d8e4b6580..e57988adc 100644 --- a/src/steam/control/argument-tuple-accept.hpp +++ b/src/steam/control/argument-tuple-accept.hpp @@ -141,8 +141,8 @@ namespace control { template struct _Type { - using Args = typename _Fun::Args; - using Ret = typename _Fun::Ret; + using Args = _Fun::Args; + using Ret = _Fun::Ret; using Sig = SIG; using ArgTuple = Tuple; }; @@ -150,9 +150,9 @@ namespace control { template struct _Type > { - using Args = typename Types::Seq; + using Args = Types::Seq; using Ret = void; - using Sig = typename BuildFunType::Sig; + using Sig = BuildFunType::Sig; using ArgTuple = std::tuple; }; diff --git a/src/steam/control/command-def.hpp b/src/steam/control/command-def.hpp index c1166f797..0260af1bd 100644 --- a/src/steam/control/command-def.hpp +++ b/src/steam/control/command-def.hpp @@ -98,7 +98,7 @@ namespace control { { Command& prototype_; - using CmdArgs = typename _Fun::Args; + using CmdArgs = _Fun::Args; CompletedDefinition (Command& definedCommand) : prototype_(definedCommand) @@ -109,7 +109,7 @@ namespace control { } - typedef HandlingPattern::ID PattID; + using PattID = HandlingPattern::ID; /** allow for defining the default execution pattern, * which is used by Command::operator() */ @@ -159,15 +159,15 @@ namespace control { template struct UndoDefinition { - typedef CommandSignature CmdType; - typedef typename CmdType::OperateSig CommandOperationSig; - typedef typename CmdType::UndoOp_Sig UndoOperationSig; - typedef typename CmdType::CaptureSig UndoCaptureSig; - typedef typename CmdType::CmdArgs CmdArgs; + using CmdType = CommandSignature; + using CommandOperationSig = CmdType::OperateSig; + using UndoOperationSig = CmdType::UndoOp_Sig; + using UndoCaptureSig = CmdType::CaptureSig; + using CmdArgs = CmdType::CmdArgs; - typedef function OperFunc; - typedef function UndoFunc; - typedef function CaptFunc; + using OperFunc = function; + using UndoFunc = function; + using CaptFunc = function; Activation activatePrototype_; OperFunc operFunctor_; @@ -233,9 +233,9 @@ namespace control { auto captureUndo (FUN2 how_to_capture_UndoState) { - using Sig2 = typename _Fun::Sig; - using UndoCapSig = typename UndoSignature::CaptureSig; - using SpecificUndoDefinition = typename BuildUndoDefType>::Type; + using Sig2 = _Fun::Sig; + using UndoCapSig = UndoSignature::CaptureSig; + using SpecificUndoDefinition = BuildUndoDefType>::Type; function captureOperation (how_to_capture_UndoState); return SpecificUndoDefinition (callback_, operation_, captureOperation); @@ -287,7 +287,7 @@ namespace control { auto operation (FUN operation_to_define) { - using Sig = typename _Fun::Sig; + using Sig = _Fun::Sig; function opera1 (operation_to_define); Activation callback_when_defined = bind (&CommandDef::activate, this, _1); diff --git a/src/steam/control/command-impl.hpp b/src/steam/control/command-impl.hpp index 02ec7ab9d..097aa2c87 100644 --- a/src/steam/control/command-impl.hpp +++ b/src/steam/control/command-impl.hpp @@ -79,13 +79,13 @@ namespace control { template struct _Type { - typedef typename ARG::SIG_op SIG_op; - typedef typename ARG::SIG_cap SIG_cap; - typedef typename ARG::SIG_undo SIG_undo; + using SIG_op = ARG::SIG_op; + using SIG_cap = ARG::SIG_cap; + using SIG_undo = ARG::SIG_undo; - typedef function Func_op; - typedef function Func_cap; - typedef function Func_undo; + using Func_op = function; + using Func_cap = function; + using Func_undo = function; }; #define _TY(_ID_) typename _Type::_ID_ @@ -185,7 +185,7 @@ namespace control { - typedef HandlingPattern::ID PattID; + using PattID = HandlingPattern::ID; PattID getDefaultHandlingPattern() const diff --git a/src/steam/control/command-op-closure.hpp b/src/steam/control/command-op-closure.hpp index f5bc4b857..fb8e676ca 100644 --- a/src/steam/control/command-op-closure.hpp +++ b/src/steam/control/command-op-closure.hpp @@ -126,10 +126,10 @@ namespace control { template class OpClosure { - using Args = typename _Fun::Args; + using Args = _Fun::Args; using Builder = BuildTupleAccessor; - using ParamStorageTuple = typename Builder::Product; + using ParamStorageTuple = Builder::Product; ParamStorageTuple params_; bool activated_; diff --git a/src/steam/control/command-registry.hpp b/src/steam/control/command-registry.hpp index 407d43e98..10723d0f2 100644 --- a/src/steam/control/command-registry.hpp +++ b/src/steam/control/command-registry.hpp @@ -111,8 +111,8 @@ namespace control { , util::NonCopyable { // using a hashtable to implement the index - typedef unordered_map> CmdIndex; - typedef map< const Command*, Symbol, order_by_impl> ReverseIndex; + using CmdIndex = unordered_map>; + using ReverseIndex = map< const Command*, Symbol, order_by_impl>; TypedAllocationManager allocator_; CmdIndex index_; @@ -236,8 +236,8 @@ namespace control { // derive the storage type necessary // to hold the command arguments and UNDO memento - typedef typename UndoSignature::Memento Mem; - typedef StorageHolder Arguments; + using Mem = UndoSignature::Memento; + using Arguments = StorageHolder; shared_ptr pArg (allocator_.create()); diff --git a/src/steam/control/command-signature.hpp b/src/steam/control/command-signature.hpp index b3cd3a180..d2f590426 100644 --- a/src/steam/control/command-signature.hpp +++ b/src/steam/control/command-signature.hpp @@ -74,15 +74,15 @@ namespace control { template class CommandSignature { - using Args = typename _Fun::Args; - using ArgList = typename Args::List; - using ExtendedArglist = typename Append::List; - using ExtendedArgs = typename Types::Seq; + using Args = _Fun::Args; + using ArgList = Args::List; + using ExtendedArglist = Append::List; + using ExtendedArgs = Types::Seq; public: - using OperateSig = typename BuildFunType::Sig; - using CaptureSig = typename BuildFunType::Sig; - using UndoOp_Sig = typename BuildFunType::Sig; + using OperateSig = BuildFunType::Sig; + using CaptureSig = BuildFunType::Sig; + using UndoOp_Sig = BuildFunType::Sig; using CmdArgs = Args; using Memento = MEM; }; @@ -108,8 +108,8 @@ namespace control { class UndoSignature { // preparation: dissect the function signature into arguments and result - using Args = typename _Fun::Args; - using Ret = typename _Fun::Ret; + using Args = _Fun::Args; + using Ret = _Fun::Ret; /** Case1: defining the Undo-Capture function */ template @@ -117,33 +117,33 @@ namespace control { { using Memento = RET; - using ExtendedArglist = typename Append::List; - using ExtendedArgs = typename Types::Seq; + using ExtendedArglist = Append::List; + using ExtendedArgs = Types::Seq; - using OperateSig = typename BuildFunType::Sig; - using CaptureSig = typename BuildFunType::Sig; - using UndoOp_Sig = typename BuildFunType::Sig; + using OperateSig = BuildFunType::Sig; + using CaptureSig = BuildFunType::Sig; + using UndoOp_Sig = BuildFunType::Sig; }; /** Case2: defining the actual Undo function */ template struct Case { - using Args = typename ARG::List; + using Args = ARG::List; - using Memento = typename PickLast::Type; - using OperationArglist = typename PickLast::List; - using OperationArgs = typename Types::Seq; + using Memento = PickLast::Type; + using OperationArglist = PickLast::List; + using OperationArgs = Types::Seq; - using OperateSig = typename BuildFunType::Sig; - using CaptureSig = typename BuildFunType::Sig; - using UndoOp_Sig = typename BuildFunType::Sig; + using OperateSig = BuildFunType::Sig; + using CaptureSig = BuildFunType::Sig; + using UndoOp_Sig = BuildFunType::Sig; }; public: - using CaptureSig = typename Case::CaptureSig; - using UndoOp_Sig = typename Case::UndoOp_Sig; - using OperateSig = typename Case::OperateSig; - using Memento = typename Case::Memento; + using CaptureSig = Case::CaptureSig; + using UndoOp_Sig = Case::UndoOp_Sig; + using OperateSig = Case::OperateSig; + using Memento = Case::Memento; }; diff --git a/src/steam/control/command-simple-closure.hpp b/src/steam/control/command-simple-closure.hpp index e0aab096a..5ebd56085 100644 --- a/src/steam/control/command-simple-closure.hpp +++ b/src/steam/control/command-simple-closure.hpp @@ -71,8 +71,8 @@ namespace control { using ArgHolder = OpClosure; using ArgumentBuff = InPlaceBuffer; - using ArgTuple = typename ArgHolder::ArgTuple; - using Args = typename lib::meta::RebindTupleTypes::Seq; // std::tuple to Types + using ArgTuple = ArgHolder::ArgTuple; + using Args = lib::meta::RebindTupleTypes::Seq; // std::tuple to Types /* ====== in-place argument storage ====== */ diff --git a/src/steam/control/command-storage-holder.hpp b/src/steam/control/command-storage-holder.hpp index 882a682d6..dbb0b8d0b 100644 --- a/src/steam/control/command-storage-holder.hpp +++ b/src/steam/control/command-storage-holder.hpp @@ -77,8 +77,8 @@ namespace control { using ArgumentBuff = InPlaceBuffer; using MementoBuff = InPlaceBuffer; - using ArgTuple = typename ArgHolder::ArgTuple; - using Args = typename lib::meta::RebindTupleTypes::Seq; // std::tuple to Types + using ArgTuple = ArgHolder::ArgTuple; + using Args = lib::meta::RebindTupleTypes::Seq; // std::tuple to Types /* ====== in-place storage buffers ====== */ @@ -215,9 +215,9 @@ namespace control { } - typedef typename CommandSignature::OperateSig SIG_op; - typedef typename CommandSignature::CaptureSig SIG_cap; - typedef typename CommandSignature::UndoOp_Sig SIG_undo; + using SIG_op = CommandSignature::OperateSig; + using SIG_cap = CommandSignature::CaptureSig; + using SIG_undo = CommandSignature::UndoOp_Sig; /** create a new memento storage wiring, discarding existing memento state. * @note any bound undo/capture functions based on the previously held MementoTie diff --git a/src/steam/control/handling-patterns.hpp b/src/steam/control/handling-patterns.hpp index f0cbc264f..1b9762756 100644 --- a/src/steam/control/handling-patterns.hpp +++ b/src/steam/control/handling-patterns.hpp @@ -56,7 +56,7 @@ namespace control { class BasicHandlingPattern : public HandlingPattern { - bool isValid() const { return true; } + bool isValid() const override { return true; } void performExec (CommandImpl& command) const override diff --git a/src/steam/control/memento-tie.hpp b/src/steam/control/memento-tie.hpp index 24e74e8cb..0c5fc7272 100644 --- a/src/steam/control/memento-tie.hpp +++ b/src/steam/control/memento-tie.hpp @@ -76,8 +76,8 @@ namespace control { template class MementoTie { - typedef typename CommandSignature::CaptureSig SIG_cap; - typedef typename CommandSignature::UndoOp_Sig SIG_undo; + using SIG_cap = CommandSignature::CaptureSig; + using SIG_undo = CommandSignature::UndoOp_Sig; ItemWrapper memento_; ///< storage holding the captured state for undo diff --git a/src/steam/engine/feed-manifold.hpp b/src/steam/engine/feed-manifold.hpp index 97cf3f0ad..f91ba8f44 100644 --- a/src/steam/engine/feed-manifold.hpp +++ b/src/steam/engine/feed-manifold.hpp @@ -157,13 +157,13 @@ namespace engine { static_assert(0 < _Fun::ARITY , "function with at least one argument expected"); static_assert(3 >= _Fun::ARITY , "function with up to three arguments accepted"); - using Sig = typename _Fun::Sig; + using Sig = _Fun::Sig; template - using _Arg = typename lib::meta::Pick::Args, i>::Type; + using _Arg = lib::meta::Pick::Args, i>::Type; template class COND> - using AllElements = typename ElmTypes<_Arg>::template AndAll; + using AllElements = ElmTypes<_Arg>::template AndAll; template static constexpr bool nonEmpty = ElmTypes<_Arg>::SIZ; @@ -205,9 +205,9 @@ namespace engine { using SigI = _Arg<_Case::SLOT_I>; using SigO = _Arg<_Case::SLOT_O>; using SigP = _Arg< 0>; - using ArgI = typename ElmTypes::Seq; - using ArgO = typename ElmTypes::Seq; - using ArgP = typename ElmTypes::Seq; + using ArgI = ElmTypes::Seq; + using ArgO = ElmTypes::Seq; + using ArgP = ElmTypes::Seq; // Metaprogramming helper for Buffer types (sans pointer) using ElmsI = ElmTypes::template Apply>; @@ -252,7 +252,7 @@ namespace engine { using Param = conditional_t>; template - using Res = typename _Fun::Ret; + using Res = _Fun::Ret; template using SigP = add_pointer_t::Sig>; @@ -335,7 +335,7 @@ namespace engine { using Param = conditional_t>; using ArgI = conditional_t>; - using ArgO = typename _Trait::SigO; + using ArgO = _Trait::SigO; /** FeedManifold building block: hold parameter data */ @@ -368,7 +368,7 @@ namespace engine { }; template - using enable_if_hasParam = typename lib::meta::enable_if_c<_ProcFun::hasParam()>::type; + using enable_if_hasParam = lib::meta::enable_if_c<_ProcFun::hasParam()>::type; template using NotProvided = Tagged; @@ -445,14 +445,14 @@ namespace engine { { using _T = _ProcFun; using _S = _StorageSetup; - using _F = typename _S::Storage; + using _F = _S::Storage; /** pass-through constructor */ using _S::Storage::Storage; - using ArgI = typename _S::ArgI; - using ArgO = typename _S::ArgO; - using Param = typename _S::Param; + using ArgI = _S::ArgI; + using ArgO = _S::ArgO; + using Param = _S::Param; enum{ FAN_I = _S::FAN_I , FAN_O = _S::FAN_O , FAN_P = _S::FAN_P @@ -480,8 +480,8 @@ namespace engine { return arg; } - using TupI = typename _T::ElmsI::Tup; - using TupO = typename _T::ElmsO::Tup; + using TupI = _T::ElmsI::Tup; + using TupO = _T::ElmsO::Tup; void @@ -560,13 +560,13 @@ namespace engine { , FAN_O = Feed::FAN_O , FAN_P = Feed::FAN_P }; - using ElmsI = typename _Proc::ElmsI; - using ElmsO = typename _Proc::ElmsO; + using ElmsI = _Proc::ElmsI; + using ElmsO = _Proc::ElmsO; using ElmsP = conditional_t<_Trait::hasParam(), typename _Proc::ArgP, Types<>>; - using Param = typename _Proc::SigP; ///////////////////////////////////////////////////////////////////OOO qualify? + using Param = _Proc::SigP; template class META> - using OutTypesApply = typename ElmsO::template Apply; + using OutTypesApply = ElmsO::template Apply; /** setup with processing-functor only */ @@ -680,8 +680,8 @@ namespace engine { static_assert (isSuitableParamAdaptor(), "Given functor's output not suitable " "for adapting the proc-functor's 1st argument"); using SigP = lib::meta::_FunArg; - using SigI = typename _Proc::SigI; - using SigO = typename _Proc::SigO; + using SigI = _Proc::SigI; + using SigO = _Proc::SigO; if constexpr (_Proc::hasInput()) { return [procFun = move(procFun_) diff --git a/src/steam/engine/media-weaving-pattern.hpp b/src/steam/engine/media-weaving-pattern.hpp index 839d8d499..0e2d6f799 100644 --- a/src/steam/engine/media-weaving-pattern.hpp +++ b/src/steam/engine/media-weaving-pattern.hpp @@ -177,7 +177,7 @@ namespace engine { struct MediaWeavingPattern : util::NonCopyable { - using Feed = typename INVO::Feed; + using Feed = INVO::Feed; static_assert (_verify_usable_as_InvocationAdapter()); diff --git a/src/steam/engine/node-builder.hpp b/src/steam/engine/node-builder.hpp index bdbd31144..2aeaa290b 100644 --- a/src/steam/engine/node-builder.hpp +++ b/src/steam/engine/node-builder.hpp @@ -432,8 +432,8 @@ namespace engine { auto attachParamFun (PFX paramFunctor) { - using AdaptedWeavingBuilder = typename WAB::template Adapted; - using AdaptedPortBuilder = PortBuilder; + using AdaptedWeavingBuilder = WAB::template Adapted; + using AdaptedPortBuilder = PortBuilder; // return AdaptedPortBuilder{move(*this) ,weavingBuilder_.adaptParam (move (paramFunctor)) @@ -490,7 +490,7 @@ namespace engine { auto adaptParam (ADA&& paramAdaptor) { - using DecoratedPrototype = typename WAB::template Decorated; + using DecoratedPrototype = WAB::template Decorated; using AdaptedPortBuilder = PortBuilder; // return AdaptedPortBuilder{move(*this) @@ -598,7 +598,7 @@ namespace engine { auto PortBuilderRoot::invoke (StrView portSpec, FUN fun) { - using Prototype = typename FeedManifold::Prototype; + using Prototype = FeedManifold::Prototype; using WeavingBuilder_FUN = WeavingBuilder; return PortBuilder{move(*this), move(fun), portSpec}; } @@ -621,7 +621,7 @@ namespace engine { { using _Par = PortBuilderRoot; - using BlockBuilder = typename SPEC::BlockBuilder; + using BlockBuilder = SPEC::BlockBuilder; using PostProcessor = function; BlockBuilder blockBuilder_; diff --git a/src/steam/engine/param-weaving-pattern.hpp b/src/steam/engine/param-weaving-pattern.hpp index 90fc72119..44196df92 100644 --- a/src/steam/engine/param-weaving-pattern.hpp +++ b/src/steam/engine/param-weaving-pattern.hpp @@ -141,7 +141,7 @@ namespace engine { { using Functors = tuple; - using ResTypes = typename ElmTypes::template Apply; + using ResTypes = ElmTypes::template Apply; using ParamTup = Tuple; Functors functors_; @@ -185,7 +185,7 @@ namespace engine { * @remark HeteroData defines a nested struct `Chain`, and with the help of `RebindVariadic`, * the type sequence from the ParamTup can be used to instantiate this chain constructor. */ - using ChainCons = typename lib::meta::RebindVariadic::Type; + using ChainCons = lib::meta::RebindVariadic::Type; /** a (static) getter functor able to work on the full extended HeteroData-Chain @@ -196,7 +196,7 @@ namespace engine { static auto& getParamVal (TurnoutSystem& turnoutSys) { - using StorageAccessor = typename ChainCons::template Accessor; + using StorageAccessor = ChainCons::template Accessor; return turnoutSys.retrieveData (StorageAccessor()); } }; @@ -221,7 +221,7 @@ namespace engine { public: /** invoke all parameter-functors and _drop off_ the result into a »chain-block« (non-copyable) */ - typename ChainCons::NewFrame + ChainCons::NewFrame buildParamDataBlock (TurnoutSystem& turnoutSys) { return std::apply ([&](auto&&... paramFun) @@ -284,9 +284,9 @@ namespace engine { struct ParamWeavingPattern : util::MoveOnly { - using Functors = typename SPEC::Functors; - using DataBlock = typename SPEC::ChainCons::NewFrame; - using BlockBuilder = typename SPEC::BlockBuilder; + using Functors = SPEC::Functors; + using DataBlock = SPEC::ChainCons::NewFrame; + using BlockBuilder = SPEC::BlockBuilder; using PostProcessor = function; BlockBuilder blockBuilder_; diff --git a/src/steam/engine/turnout.hpp b/src/steam/engine/turnout.hpp index 243b9645c..567ba8377 100644 --- a/src/steam/engine/turnout.hpp +++ b/src/steam/engine/turnout.hpp @@ -91,7 +91,7 @@ namespace engine { constexpr bool _verify_usable_as_WeavingPattern() { - using Feed = typename PAT::Feed; + using Feed = PAT::Feed; ASSERT_MEMBER_FUNCTOR (&PAT::mount, Feed(TurnoutSystem&)); ASSERT_MEMBER_FUNCTOR (&PAT::pull, void(Feed&, TurnoutSystem&)); ASSERT_MEMBER_FUNCTOR (&PAT::shed, void(Feed&, TurnoutSystem&, OptionalBuff)); @@ -117,7 +117,7 @@ namespace engine { { static_assert (_verify_usable_as_WeavingPattern()); - using Feed = typename PAT::Feed; + using Feed = PAT::Feed; public: template diff --git a/src/steam/engine/weaving-pattern-builder.hpp b/src/steam/engine/weaving-pattern-builder.hpp index c15017f86..b99a09a16 100644 --- a/src/steam/engine/weaving-pattern-builder.hpp +++ b/src/steam/engine/weaving-pattern-builder.hpp @@ -292,7 +292,7 @@ namespace engine { /** type builder for FeedPrototype adapted to another parameter-fun */ template - using AdaptedPrototype = typename PROT::template Adapted; + using AdaptedPrototype = PROT::template Adapted; template using Adapted = WeavingBuilder>; @@ -317,7 +317,7 @@ namespace engine { /** type builder for FeedPrototype with remoulded parameter input */ template - using DecoratedPrototype = typename PROT::template Decorated; + using DecoratedPrototype = PROT::template Decorated; template using Decorated = WeavingBuilder>; @@ -447,8 +447,8 @@ namespace engine { } }; - using OutTypesDescriptors = typename PROT::template OutTypesApply; - using OutDescriptorTup = lib::meta::Tuple; + using OutTypesDescriptors = PROT::template OutTypesApply; + using OutDescriptorTup = lib::meta::Tuple; /** A tuple of BufferDescriptor instances for all output buffer types */ static constexpr OutDescriptorTup outDescriptors{}; diff --git a/src/steam/fixture/segmentation.cpp b/src/steam/fixture/segmentation.cpp index eacc7889f..400d9f8ff 100644 --- a/src/steam/fixture/segmentation.cpp +++ b/src/steam/fixture/segmentation.cpp @@ -68,7 +68,7 @@ namespace fixture { Segmentation::splitSplice (OptTime start, OptTime after, engine::ExitNodes&& modelLink) { ASSERT (!start or !after or start != after); - using Iter = typename list::iterator; + using Iter = list::iterator; auto getStart = [](Iter elm) -> Time { return elm->start(); }; auto getAfter = [](Iter elm) -> Time { return elm->after(); }; diff --git a/src/steam/mobject/output-mapping.hpp b/src/steam/mobject/output-mapping.hpp index cc82aec47..7e53cb440 100644 --- a/src/steam/mobject/output-mapping.hpp +++ b/src/steam/mobject/output-mapping.hpp @@ -81,7 +81,7 @@ namespace mobject { using Rebinder = Rebind; public: - using Target = typename Rebinder::Res; + using Target = Rebinder::Res; }; }//(End) type rebinding helper @@ -130,7 +130,7 @@ namespace mobject { std::map table_; public: - using Target = typename Setup::Target; + using Target = Setup::Target; // using default ctor and copy operations @@ -317,7 +317,7 @@ namespace mobject { * stored. Thus the yielded Resolver should be checked, if in doubt. */ template - inline typename OutputMapping::Resolver + inline OutputMapping::Resolver OutputMapping::operator[] (PId sourcePipeID) { if (not contains (sourcePipeID)) @@ -333,7 +333,7 @@ namespace mobject { /** similar to the standard map-style access, but accepts * a source pipe object instead of just a pipe-ID */ template - inline typename OutputMapping::Resolver + inline OutputMapping::Resolver OutputMapping::operator[] (PPipe const& pipe) { REQUIRE (pipe); @@ -372,7 +372,7 @@ namespace mobject { * if in doubt. */ template - inline typename OutputMapping::Resolver + inline OutputMapping::Resolver OutputMapping::operator[] (Query query4pipe) { HashVal hash4query = _mapping::slot (query4pipe); diff --git a/src/steam/mobject/placement.hpp b/src/steam/mobject/placement.hpp index f7bdd4545..c335bc295 100644 --- a/src/steam/mobject/placement.hpp +++ b/src/steam/mobject/placement.hpp @@ -116,11 +116,11 @@ namespace mobject { , public HashIndexed, lib::hash::LuidH > { protected: - typedef HashIndexed, lib::hash::LuidH> HashInd; - typedef shared_ptr _SmartPtr; + using HashInd = HashIndexed, lib::hash::LuidH>; + using _SmartPtr = shared_ptr; typedef void (*Deleter)(MObject*); - typedef lib::time::Time Time; - typedef asset::shared_ptr Pipe; ////TICKET #109 : get rid of this + using Time = lib::time::Time; + using Pipe = asset::shared_ptr; ////TICKET #109 : get rid of this @@ -232,10 +232,10 @@ namespace mobject { : public Placement { protected: - typedef Placement _Parent; - typedef typename _Parent::template Id const& _Id; - typedef typename _Parent::Deleter Deleter; - typedef typename _Parent::_SmartPtr _SmartPtr; + using _Parent = Placement; + using _Id = _Parent::template Id const&; + using Deleter = _Parent::Deleter; + using _SmartPtr = _Parent::_SmartPtr; Placement (MO & mo, Deleter killer) @@ -262,8 +262,8 @@ namespace mobject { /** @todo cleanup uses of ref-to-placement. See Ticket #115 */ - typedef Placement PlacementMO; - typedef Placement PMO; + using PlacementMO = Placement; + using PMO = Placement; diff --git a/src/steam/mobject/session/element-query.hpp b/src/steam/mobject/session/element-query.hpp index 307866739..18141ac4f 100644 --- a/src/steam/mobject/session/element-query.hpp +++ b/src/steam/mobject/session/element-query.hpp @@ -50,25 +50,25 @@ namespace session { template struct _PickRes const&)> > { - typedef MO Type; - typedef MORef Result; - typedef typename ScopeQuery::iterator Iterator; + using Type = MO; + using Result = MORef; + using Iterator = ScopeQuery::iterator; }; template struct _PickRes const&)> { - typedef MO Type; - typedef MORef Result; - typedef typename ScopeQuery::iterator Iterator; + using Type = MO; + using Result = MORef; + using Iterator = ScopeQuery::iterator; }; template struct _PickRes const&)> { - typedef MO Type; - typedef MORef Result; - typedef typename ScopeQuery::iterator Iterator; + using Type = MO; + using Result = MORef; + using Iterator = ScopeQuery::iterator; }; } @@ -106,11 +106,11 @@ namespace session { * compiler error "no suitable function pick(.....)" */ template - typename _PickRes::Result + _PickRes::Result pick (PRED const& searchPredicate) { - typedef typename _PickRes::Result ResultRef; - typedef typename _PickRes::Iterator Iterator; + using ResultRef = _PickRes::Result; + using Iterator = _PickRes::Iterator; Iterator iter (pickAllSuitable ( SessionServiceExploreScope::getScopeRoot() , searchPredicate diff --git a/src/steam/mobject/session/placement-index.hpp b/src/steam/mobject/session/placement-index.hpp index 366bb1f70..282cb4c51 100644 --- a/src/steam/mobject/session/placement-index.hpp +++ b/src/steam/mobject/session/placement-index.hpp @@ -226,7 +226,7 @@ namespace session { bool remove (ID); template - typename BuildID::Type insert (PLA const&, ID); + BuildID::Type insert (PLA const&, ID); @@ -318,10 +318,10 @@ namespace session { * @todo is this API used in application code? or just used in tests? */ template - typename BuildID::Type + BuildID::Type PlacementIndex::insert (PLA const& newObj, ID targetScope) { - typedef typename BuildID::Target TargetMO; + using TargetMO = BuildID::Target; PlacementMO const& genericPlacement(newObj); return find (insert (genericPlacement, targetScope)) diff --git a/src/steam/mobject/session/query-focus.hpp b/src/steam/mobject/session/query-focus.hpp index 96bf4d2ef..f19de1aa5 100644 --- a/src/steam/mobject/session/query-focus.hpp +++ b/src/steam/mobject/session/query-focus.hpp @@ -119,11 +119,11 @@ namespace session { template - typename ScopeQuery::iterator + ScopeQuery::iterator query() const; template - typename ScopeQuery::iterator + ScopeQuery::iterator explore() const; lib::IterSource::iterator @@ -175,7 +175,7 @@ namespace session { * within \em current focus. Resolution is * delegated to the \em current session */ template - inline typename ScopeQuery::iterator + inline ScopeQuery::iterator QueryFocus::query() const { return ScopeLocator::instance().query (*this); @@ -186,7 +186,7 @@ namespace session { * as immediate Child within \em current focus. * Resolution through \em current session */ template - inline typename ScopeQuery::iterator + inline ScopeQuery::iterator QueryFocus::explore() const { return ScopeLocator::instance().explore (*this); diff --git a/src/steam/mobject/session/query/fake-configrules.cpp b/src/steam/mobject/session/query/fake-configrules.cpp index 4ac69655d..48ad184ff 100644 --- a/src/steam/mobject/session/query/fake-configrules.cpp +++ b/src/steam/mobject/session/query/fake-configrules.cpp @@ -78,7 +78,7 @@ namespace session { template AnyPair entry_Struct(Literal caps) { - using Ptr = typename WrapReturn::Wrapper; + using Ptr = WrapReturn::Wrapper; string capabilities (caps); Query query (capabilities); diff --git a/src/steam/mobject/session/query/fake-configrules.hpp b/src/steam/mobject/session/query/fake-configrules.hpp index 28025f226..3e75238a3 100644 --- a/src/steam/mobject/session/query/fake-configrules.hpp +++ b/src/steam/mobject/session/query/fake-configrules.hpp @@ -174,7 +174,7 @@ namespace session { template class LookupPreconfigured : public BASE { - typedef typename WrapReturn::Wrapper Ret; + using Ret = WrapReturn::Wrapper; /** (dummy) implementation of the QueryHandler interface */ virtual bool diff --git a/src/steam/mobject/session/scope-locator.hpp b/src/steam/mobject/session/scope-locator.hpp index 032d65067..1f13dd265 100644 --- a/src/steam/mobject/session/scope-locator.hpp +++ b/src/steam/mobject/session/scope-locator.hpp @@ -65,15 +65,15 @@ namespace session { ScopePath& pushPath(); template - typename ScopeQuery::iterator + ScopeQuery::iterator explore (Scope const&); template - typename ScopeQuery::iterator + ScopeQuery::iterator query (Scope const&); template - typename ScopeQuery::iterator + ScopeQuery::iterator getRawPath (Scope const&); ScopeQuery::iterator @@ -103,7 +103,7 @@ namespace session { * to enumerate the contents (children) of the given scope */ template - inline typename ScopeQuery::iterator + inline ScopeQuery::iterator ScopeLocator::explore (Scope const& scope) { return ScopeQuery (scope.getTop(), CHILDREN).resolveBy (theResolver()); @@ -114,7 +114,7 @@ namespace session { * to discover depth-first any object within this scope */ template - inline typename ScopeQuery::iterator + inline ScopeQuery::iterator ScopeLocator::query (Scope const& scope) { return ScopeQuery (scope.getTop(), CONTENTS).resolveBy (theResolver()); @@ -131,7 +131,7 @@ namespace session { * to be "dead ends" */ template - inline typename ScopeQuery::iterator + inline ScopeQuery::iterator ScopeLocator::getRawPath (Scope const& scope) { return ScopeQuery (scope.getTop(), PATH).resolveBy (theResolver()); diff --git a/src/steam/mobject/session/scope-query.hpp b/src/steam/mobject/session/scope-query.hpp index b0aff8eb9..84b45ee5d 100644 --- a/src/steam/mobject/session/scope-query.hpp +++ b/src/steam/mobject/session/scope-query.hpp @@ -65,13 +65,12 @@ namespace session { class DiscoveryQuery : public Query> { - typedef Query> _Query; + using _Query = Query>; public: - typedef typename _Query::iterator iterator; - - typedef function ContentFilter; + using iterator = _Query::iterator; + using ContentFilter = function; ContentFilter @@ -135,16 +134,16 @@ namespace session { class ScopeQuery : public DiscoveryQuery { - typedef DiscoveryQuery _Parent; - typedef Query> _Query; + using _Parent = DiscoveryQuery ; + using _Query = Query>; PlacementMO::ID startPoint_; ScopeQueryKind to_discover_; public: - typedef typename _Parent::iterator iterator; - typedef typename _Parent::ContentFilter ContentFilter; + using iterator = _Parent::iterator ; + using ContentFilter = _Parent::ContentFilter; ScopeQuery (PlacementMO const& scope, diff --git a/src/steam/mobject/session/specific-contents-query.hpp b/src/steam/mobject/session/specific-contents-query.hpp index fbe336ee6..b521103e7 100644 --- a/src/steam/mobject/session/specific-contents-query.hpp +++ b/src/steam/mobject/session/specific-contents-query.hpp @@ -54,11 +54,9 @@ namespace session { class SpecificContentsQuery : public ContentsQuery { - typedef typename ContentsQuery::ContentFilter ContentFilter; - - typedef Placement const& TypedPlacement; - - typedef function SpecialPredicate; + using ContentFilter = ContentsQuery::ContentFilter; + using TypedPlacement = Placement const&; + using SpecialPredicate = function; /** * Filter functor, built on top of a predicate, @@ -120,25 +118,25 @@ namespace session { template struct _PickResult const&)> > { - typedef MO Type; - typedef SpecificContentsQuery FilterQuery; - typedef typename ScopeQuery::iterator Iterator; + using Type = MO; + using FilterQuery = SpecificContentsQuery; + using Iterator = ScopeQuery::iterator; }; template struct _PickResult const&)> { - typedef MO Type; - typedef SpecificContentsQuery FilterQuery; - typedef typename ScopeQuery::iterator Iterator; + using Type = MO; + using FilterQuery = SpecificContentsQuery; + using Iterator = ScopeQuery::iterator; }; template struct _PickResult const&)> { - typedef MO Type; - typedef SpecificContentsQuery FilterQuery; - typedef typename ScopeQuery::iterator Iterator; + using Type = MO; + using FilterQuery = SpecificContentsQuery; + using Iterator = ScopeQuery::iterator; }; } @@ -150,10 +148,10 @@ namespace session { * based on the predicate given as parameter */ template - inline typename _PickResult::FilterQuery + inline _PickResult::FilterQuery pickAllSuitable(PlacementMO const& scope, FUNC predicate) { - typedef typename _PickResult::FilterQuery Query; + using Query = _PickResult::FilterQuery; return Query(scope, predicate); } @@ -164,10 +162,10 @@ namespace session { * defined through the parameter of the predicate */ template - inline typename _PickResult::Iterator + inline _PickResult::Iterator pickAllSuitable(PlacementMO const& scope, FUNC predicate, QueryResolver const& resolver) { - typedef typename _PickResult::FilterQuery Query; + using Query = _PickResult::FilterQuery; return Query(scope, predicate ).resolveBy(resolver); } diff --git a/src/steam/play/output-slot-connection.hpp b/src/steam/play/output-slot-connection.hpp index f20e7db7a..932962882 100644 --- a/src/steam/play/output-slot-connection.hpp +++ b/src/steam/play/output-slot-connection.hpp @@ -197,7 +197,7 @@ namespace play { connections_.populate_by (&ConnectionManager::buildConnection, this); } - typedef typename Connections::ElementHolder& ConnectionStorage; + using ConnectionStorage = Connections::ElementHolder&; /** factory function to build the actual * connection handling objects per channel */ diff --git a/src/vault/gear/block-flow.hpp b/src/vault/gear/block-flow.hpp index 503a97435..464c8313a 100644 --- a/src/vault/gear/block-flow.hpp +++ b/src/vault/gear/block-flow.hpp @@ -224,8 +224,8 @@ namespace gear { class Epoch : public ALO::Extent { - using RawIter = typename ALO::iterator; - using SIZ = typename ALO::Extent::SIZ; + using RawIter = ALO::iterator; + using SIZ = ALO::Extent::SIZ; /// @warning will be faked, never constructed Epoch() = delete; @@ -347,8 +347,8 @@ namespace gear { public: using Allocator = mem::ExtentFamily; using Strategy = blockFlow::Strategy; - using RawIter = typename Allocator::iterator; - using Extent = typename Allocator::Extent; + using RawIter = Allocator::iterator; + using Extent = Allocator::Extent; using Epoch = blockFlow::Epoch; using Strategy::config; @@ -723,7 +723,7 @@ namespace gear { template class FlowDiagnostic { - using Epoch = typename BlockFlow::Epoch; + using Epoch = BlockFlow::Epoch; BlockFlow& flow_; diff --git a/tests/basics/visitingtool-concept.cpp b/tests/basics/visitingtool-concept.cpp index dce080f24..67c4922ff 100644 --- a/tests/basics/visitingtool-concept.cpp +++ b/tests/basics/visitingtool-concept.cpp @@ -114,8 +114,8 @@ namespace lumiera { class Tool { public: - typedef RET ReturnType; - typedef Tool ToolBase; ///< for templating the Tag and Dispatcher + using ReturnType = RET; + using ToolBase = Tool; ///< for templating the Tag and Dispatcher virtual ~Tool() { }; ///< use RTTI for all visiting tools @@ -130,7 +130,7 @@ namespace lumiera { class ToolType : public BASE { - typedef typename BASE::ToolBase ToolBase; + using ToolBase = BASE::ToolBase; public: virtual Tag @@ -152,7 +152,7 @@ namespace lumiera { template class Dispatcher { - typedef typename TOOL::ReturnType ReturnType; + using ReturnType = TOOL::ReturnType; /** generator for Trampoline functions, * used to dispatch calls down to the @@ -254,8 +254,8 @@ namespace lumiera { template > class Applicable { - typedef typename BASE::ReturnType Ret; - typedef typename BASE::ToolBase ToolBase; + using Ret = BASE::ReturnType; + using ToolBase = BASE::ToolBase; protected: Applicable() @@ -288,8 +288,8 @@ namespace lumiera { virtual ~Visitable() { }; /// @note may differ from TOOL - typedef typename TOOL::ToolBase ToolBase; - typedef typename TOOL::ReturnType ReturnType; + using ToolBase = TOOL::ToolBase; + using ReturnType = TOOL::ReturnType; /** @internal used by the DEFINE_PROCESSABLE_BY macro. * Dispatches to the actual operation on the @@ -327,7 +327,7 @@ namespace lumiera { namespace test { - typedef Tool VisitingTool; + using VisitingTool = Tool; class HomoSapiens : public Visitable<> { diff --git a/tests/core/steam/control/argument-tuple-accept-test.cpp b/tests/core/steam/control/argument-tuple-accept-test.cpp index d7236fe73..8fb0fb5fd 100644 --- a/tests/core/steam/control/argument-tuple-accept-test.cpp +++ b/tests/core/steam/control/argument-tuple-accept-test.cpp @@ -49,8 +49,8 @@ namespace test { template struct _Tup { - using Args = typename _Fun::Args; - using Ret = typename _Fun::Ret; + using Args = _Fun::Args; + using Ret = _Fun::Ret; using Ty = Tuple; }; @@ -62,8 +62,8 @@ namespace test { , typename _Tup::Ty // base class to inherit from > { - using ATuple = typename _Tup::Ty; - using RetType = typename _Tup::Ret; + using ATuple = _Tup::Ty; + using RetType = _Tup::Ret; public: diff --git a/tests/core/steam/mobject/session/query-resolver-test.cpp b/tests/core/steam/mobject/session/query-resolver-test.cpp index 98c194eb8..aa007135e 100644 --- a/tests/core/steam/mobject/session/query-resolver-test.cpp +++ b/tests/core/steam/mobject/session/query-resolver-test.cpp @@ -86,7 +86,7 @@ namespace test{ { DummySolutions solutions_; - typedef typename Query::Cursor Cursor; + using Cursor = Query::Cursor; Result prepareResolution() diff --git a/tests/core/steam/mobject/session/scope-query-test.cpp b/tests/core/steam/mobject/session/scope-query-test.cpp index cadb8b948..7ddd871c6 100644 --- a/tests/core/steam/mobject/session/scope-query-test.cpp +++ b/tests/core/steam/mobject/session/scope-query-test.cpp @@ -126,7 +126,7 @@ namespace test { } template - static typename ScopeQuery::iterator + static ScopeQuery::iterator issue (ScopeQuery const& query) { return query.resolveBy(SessionServiceExploreScope::getResolver()); diff --git a/tests/library/meta/function-erasure-test.cpp b/tests/library/meta/function-erasure-test.cpp index a84222ca2..4fc447fa7 100644 --- a/tests/library/meta/function-erasure-test.cpp +++ b/tests/library/meta/function-erasure-test.cpp @@ -201,7 +201,7 @@ namespace test { detect_unboundFunctor (HOL h1, HOL h2, HOL h3) { // fabricate a suitable, unbound functor to wrap... - typedef typename BuildEmptyFunctor::Type NoFunc; + using NoFunc = BuildEmptyFunctor::Type; NoFunc noFunction = NoFunc(); // wrap this (actually empty) functor into the holder type diff --git a/tests/library/meta/tuple-diagnostics.hpp b/tests/library/meta/tuple-diagnostics.hpp index 4f7ab8b00..fccd13ef0 100644 --- a/tests/library/meta/tuple-diagnostics.hpp +++ b/tests/library/meta/tuple-diagnostics.hpp @@ -70,7 +70,7 @@ namespace test { inline string showType () { - using TypeList = typename RebindTupleTypes::List; + using TypeList = RebindTupleTypes::List; using DumpPrinter = InstantiateChained; return "TUPLE" diff --git a/tests/library/meta/typelist-diagnostics.hpp b/tests/library/meta/typelist-diagnostics.hpp index 7873824fd..9c5edef7e 100644 --- a/tests/library/meta/typelist-diagnostics.hpp +++ b/tests/library/meta/typelist-diagnostics.hpp @@ -167,7 +167,7 @@ namespace meta { { static string show() { - typedef typename Config::Flags FlagList; + using FlagList = Config::Flags; return string("\n\t+-Conf-[") + printSublist()+"]" + BASE::show(); } @@ -184,7 +184,7 @@ namespace meta { string > showType () { - using TypeList = typename TYPES::List; + using TypeList = TYPES::List; return printSublist(); } diff --git a/tests/library/meta/typelist-test.cpp b/tests/library/meta/typelist-test.cpp index 834c34775..792fde6b3 100644 --- a/tests/library/meta/typelist-test.cpp +++ b/tests/library/meta/typelist-test.cpp @@ -48,7 +48,7 @@ namespace test { , Block<2> , Block<1> >; - using ListOfTypes = typename SequenceOfTypes::List; + using ListOfTypes = SequenceOfTypes::List; template diff --git a/tests/library/meta/variadic-argument-picker-test.cpp b/tests/library/meta/variadic-argument-picker-test.cpp index 178850de8..db531926a 100644 --- a/tests/library/meta/variadic-argument-picker-test.cpp +++ b/tests/library/meta/variadic-argument-picker-test.cpp @@ -243,9 +243,9 @@ namespace test { cout << fun (n0,n1,n2,n3) << endl; - using Backwards = typename BuildIndexSeq<4>::Descending; // 3,2,1,0 - using Back2 = typename BuildIndexSeq<2>::Descending; // 1,0 - using After2 = typename BuildIndexSeq<4>::After<2>; // 2,3 + using Backwards = BuildIndexSeq<4>::Descending; // 3,2,1,0 + using Back2 = BuildIndexSeq<2>::Descending; // 1,0 + using After2 = BuildIndexSeq<4>::After<2>; // 2,3 cout << call_with_reversed_arguments (Backwards(), n0,n1,n2,n3) <; - using Iter = typename SegL::iterator; + using Iter = SegL::iterator; /** * Perform the »SplitSplice« Algorithm to splice a new Segment diff --git a/tests/library/sync-locking-test.cpp b/tests/library/sync-locking-test.cpp index f5ddbfcd8..76f019d82 100644 --- a/tests/library/sync-locking-test.cpp +++ b/tests/library/sync-locking-test.cpp @@ -48,7 +48,7 @@ namespace test{ size_t hot_sum_{0}; size_t control_sum_{0}; - using Lock = typename Sync::Lock; + using Lock = Sync::Lock; public: bool diff --git a/tests/library/util-collection-test.cpp b/tests/library/util-collection-test.cpp index 4dfc2f4b2..fe93541fa 100644 --- a/tests/library/util-collection-test.cpp +++ b/tests/library/util-collection-test.cpp @@ -115,7 +115,7 @@ namespace test { COL empty; - using Val = typename COL::value_type; + using Val = COL::value_type; CHECK (max (empty) == std::numeric_limits::min()); CHECK (min (empty) == std::numeric_limits::max()); diff --git a/tests/stage/gen-node-location-query.hpp b/tests/stage/gen-node-location-query.hpp index 422269e02..679da0c05 100644 --- a/tests/stage/gen-node-location-query.hpp +++ b/tests/stage/gen-node-location-query.hpp @@ -252,7 +252,7 @@ namespace interact { // Literal currentChild_ = Symbol::BOTTOM; - using Pos = typename PAR::Pos; + using Pos = PAR::Pos; virtual Pos firstResult () override diff --git a/tests/vault/gear/activity-detector.hpp b/tests/vault/gear/activity-detector.hpp index 49f77e4cf..cad30087f 100644 --- a/tests/vault/gear/activity-detector.hpp +++ b/tests/vault/gear/activity-detector.hpp @@ -292,11 +292,11 @@ namespace test { template struct _DiagnosticFun { - using Ret = typename lib::meta::_Fun::Ret; - using Args = typename lib::meta::_Fun::Args; - using SigTypes = typename lib::meta::Prepend::Seq; + using Ret = lib::meta::_Fun::Ret; + using Args = lib::meta::_Fun::Args; + using SigTypes = lib::meta::Prepend::Seq; - using Type = typename RebindVariadic::Type; + using Type = RebindVariadic::Type; }; using Logger = _DiagnosticFun::Type; @@ -308,7 +308,7 @@ namespace test { class MockJobFunctor : public NopJobFunctor { - using MockOp = typename _DiagnosticFun::Type; + using MockOp = _DiagnosticFun::Type; MockOp mockOperation_; @@ -510,7 +510,7 @@ namespace test { auto buildDiagnosticFun (string id) { - using Functor = typename _DiagnosticFun::Type; + using Functor = _DiagnosticFun::Type; return Functor{id, eventLog_, invocationSeq_}; } diff --git a/tests/vault/gear/stress-test-rig.hpp b/tests/vault/gear/stress-test-rig.hpp index 6bb995967..c6c002623 100644 --- a/tests/vault/gear/stress-test-rig.hpp +++ b/tests/vault/gear/stress-test-rig.hpp @@ -176,7 +176,7 @@ namespace test { { public: using TestLoad = TestChainLoad; - using TestSetup = typename TestLoad::ScheduleCtx; + using TestSetup = TestLoad::ScheduleCtx; /***********************************************************************//** @@ -268,8 +268,8 @@ namespace test { class BreakingPoint : public CONF { - using TestLoad = typename CONF::TestLoad; - using TestSetup = typename TestLoad::ScheduleCtx; + using TestLoad = CONF::TestLoad; + using TestSetup = TestLoad::ScheduleCtx; struct Res { @@ -484,12 +484,12 @@ namespace test { class ParameterRange : public CONF { - using TestLoad = typename CONF::TestLoad; - using TestSetup = typename TestLoad::ScheduleCtx; + using TestLoad = CONF::TestLoad; + using TestSetup = TestLoad::ScheduleCtx; // Type binding for data evaluation - using Param = typename CONF::Param; - using Table = typename CONF::Table; + using Param = CONF::Param; + using Table = CONF::Table; void diff --git a/tests/vault/gear/test-chain-load.hpp b/tests/vault/gear/test-chain-load.hpp index 90baef6da..9b49e98ab 100644 --- a/tests/vault/gear/test-chain-load.hpp +++ b/tests/vault/gear/test-chain-load.hpp @@ -255,9 +255,9 @@ namespace test { struct Node : util::MoveOnly { - using _Arr = std::array; - using Iter = typename _Arr::iterator; - using CIter = typename _Arr::const_iterator; + using _Arr = std::array; + using Iter = _Arr::iterator; + using CIter = _Arr::const_iterator; /** Table with connections to other Node records */ struct Tab : _Arr @@ -364,7 +364,7 @@ namespace test { using Rule = lib::RandomDraw; private: - using NodeTab = typename Node::Tab; + using NodeTab = Node::Tab; using NodeIT = lib::RangeIter; std::unique_ptr nodes_; @@ -1579,7 +1579,7 @@ namespace test { class RandomChainCalcFunctor : public ChainFunctor { - using Node = typename TestChainLoad::Node; + using Node = TestChainLoad::Node; using Watch = lib::IncidenceCount; Node* startNode_; @@ -1627,7 +1627,7 @@ namespace test { class RandomChainPlanFunctor : public ChainFunctor { - using Node = typename TestChainLoad::Node; + using Node = TestChainLoad::Node; function scheduleCalcJob_; function markDependency_; @@ -2179,7 +2179,7 @@ namespace test { * @note clears hashes and re-propagates seed in the node graph beforehand. */ template - typename TestChainLoad::ScheduleCtx + TestChainLoad::ScheduleCtx TestChainLoad::setupSchedule (Scheduler& scheduler) { clearNodeHashes(); diff --git a/wiki/thinkPad.ichthyo.mm b/wiki/thinkPad.ichthyo.mm index 7d75eae0b..5c53df286 100644 --- a/wiki/thinkPad.ichthyo.mm +++ b/wiki/thinkPad.ichthyo.mm @@ -167591,6 +167591,27 @@ Since then others have made contributions, see the log for the history. + + + + +

+ viele typename und template -Qualifier werden überflüssig +

+ + + + + + + + + + + + + + @@ -169457,8 +169478,8 @@ Since then others have made contributions, see the log for the history. - - + + @@ -169472,13 +169493,65 @@ Since then others have made contributions, see the log for the history. - - + + + + +

+ Einige lasse ich bewußt offen, weil es sich um Code handelt, der mit dem nächsten »Vertical Slice« komplett überarbeitet wird +

+
    +
  • + diverse Warnings zu Vergleichs-Operatoren über Assets und MObjects, im Besonderen mit dem speziellen Smart-Ptr lumiera::P (den will ich loswerden) +
    • +
  • + Warnungen zur pessimisation durch std::move im Return. Das betrifft vor allem die View-Spec-DSL im GUI, und dort ist die Warnung sogar fehlgeleitet (d.h. der Code würde brechen, wenn man das std::move entfernt); deutet das als Hinweis auf ein Design-Problem, das aber derzeit nicht auf der Agenda steht +
    • +
+ + + - - + + + + + + + + + + + +

+ tatsächlich hat GCC das bereits im Vorgriff, im C++17 Modus teilweise unterstützt, und ich habe beonnen, es zu nutzen +

+ + + + + + + +

+ Nach Sprachstandard können die allermeisten "typename" und "template" Qualifier wegfallen; notfalls mithilfe einer weiteren, dazwischengeschalteten Typedef.... +

+ + + + + + + +

+ Diese redundanten typename und template -Qualifier sind einer der Hauptgründe, warum Metaprogramming-Code in C++ so schwer lesbar ist... +

+ + + +