ichthyo/LUMIERA.clone
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

maximum munch

Browse source 
...feels like X-mas
This commit is contained in:
Fischlurch 2016-12-23 04:23:03 +01:00
parent 39060297ee
commit 1a4b6545a0
79 changed files with 281 additions and 280 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
src/common/advice/index.hpp
View file

@ -154,7 +154,8 @@ namespace advice {
struct Entry
: pair<Binding::Matcher, POA*>
, boost::equality_comparable<Entry, POA,
boost::equality_comparable<Entry> >
boost::equality_comparable<Entry>
>
{
explicit
Entry (POA& elm)

2
src/common/interfaceproxy.cpp
View file

@ -55,7 +55,7 @@ namespace facade {
class Holder;
template<class FA, class I>
class Holder<InstanceHandle<I,FA> >
class Holder<InstanceHandle<I,FA>>
: Accessor<FA>
, protected FA
{

2
src/common/query/defs-registry.hpp
View file

@ -141,7 +141,7 @@ namespace query {
struct Slot
: public TableEntry
{
typedef std::set<Record<TAR> > Registry;
typedef std::set<Record<TAR>> Registry;
Registry registry;
static size_t index; ///< where to find this Slot in every Table

2
src/gui/model/clip-track.cpp
View file

@ -49,7 +49,7 @@ namespace model {
return os.str();
}
lumiera::observable_list< shared_ptr<Clip> >&
lumiera::observable_list<shared_ptr<Clip>>&
ClipTrack::getClipList()
{
return clips;

4
src/gui/model/clip-track.hpp
View file

@ -55,12 +55,12 @@ namespace model {
/**
* Gets the list of clips associated with this track.
*/
lumiera::observable_list<shared_ptr<Clip> >&
lumiera::observable_list<shared_ptr<Clip>>&
getClipList(void);
private:
lumiera::observable_list<shared_ptr<Clip> > clips;
lumiera::observable_list<shared_ptr<Clip>> clips;
};

4
src/gui/model/parent-track.cpp
View file

@ -32,13 +32,13 @@ ParentTrack::ParentTrack()
{
}
const std::list<shared_ptr<Track> >&
const std::list<shared_ptr<Track>>&
ParentTrack::get_child_tracks() const
{
return tracks.get_list();
}
lumiera::observable_list<shared_ptr<Track> >&
lumiera::observable_list<shared_ptr<Track>>&
ParentTrack::get_child_track_list()
{
return tracks;

6
src/gui/model/parent-track.hpp
View file

@ -53,13 +53,13 @@ public:
/**
* Gets a read-only reference to the the list of child tracks.
*/
const std::list<shared_ptr<Track> >&
const std::list<shared_ptr<Track>>&
get_child_tracks() const;
/**
* Gets read-write access to the list of child tracks.
*/
lumiera::observable_list<shared_ptr<Track> >&
lumiera::observable_list<shared_ptr<Track>>&
get_child_track_list();
/**
@ -91,7 +91,7 @@ protected:
/**
* The internal list of child tracks of this parent.
*/
lumiera::observable_list<shared_ptr<Track> > tracks;
lumiera::observable_list<shared_ptr<Track>> tracks;
};
} // namespace model

10
src/gui/widget/timeline-widget.cpp
View file

@ -189,7 +189,7 @@ namespace widget {
return playbackPeriodDragReleasedSignal;
}
sigc::signal<void, shared_ptr<timeline::Track> >
sigc::signal<void, shared_ptr<timeline::Track>>
TimelineWidget::hovering_track_changed_signal() const
{
return hoveringTrackChangedSignal;
@ -368,7 +368,7 @@ namespace widget {
TimelineWidget::remove_orphaned_tracks()
{
std::map<shared_ptr<model::Track>,
shared_ptr<timeline::Track> >
shared_ptr<timeline::Track>>
orphan_track_map(trackMap);
// Remove all tracks which are still present in the sequence
@ -378,7 +378,7 @@ namespace widget {
// orphan_track_map now contains all the orphaned tracks
// Remove them
std::pair<shared_ptr<model::Track>, shared_ptr<timeline::Track> >
std::pair<shared_ptr<model::Track>, shared_ptr<timeline::Track>>
pair;
BOOST_FOREACH( pair, orphan_track_map )
{
@ -393,7 +393,7 @@ namespace widget {
TimelineWidget::search_orphaned_tracks_in_branch(
shared_ptr<model::Track> modelTrack,
std::map<shared_ptr<model::Track>,
shared_ptr<timeline::Track> > &orphan_track_map)
shared_ptr<timeline::Track>>& orphan_track_map)
{
REQUIRE(modelTrack);
@ -417,7 +417,7 @@ namespace widget {
REQUIRE(modelTrack != sequence()); // The sequence isn't
// really a track
std::map<shared_ptr<model::Track>, shared_ptr<timeline::Track> >::
std::map<shared_ptr<model::Track>, shared_ptr<timeline::Track>>::
const_iterator iterator = trackMap.find(modelTrack);
if (iterator == trackMap.end())
{

8
src/gui/widget/timeline-widget.hpp
View file

@ -127,8 +127,8 @@ namespace widget {
public:
/* ===== Signals ===== */
typedef sigc::signal<void, shared_ptr<timeline::TimelineState> > TimelineStateChangeSignal;
typedef sigc::signal<void, shared_ptr<timeline::Track> > HoveringTrackChangedSignal;
using TimelineStateChangeSignal = sigc::signal<void, shared_ptr<timeline::TimelineState>>;
using HoveringTrackChangedSignal = sigc::signal<void, shared_ptr<timeline::Track>>;
sigc::signal<void, lib::time::Time> mouse_hover_signal() const;
@ -202,7 +202,7 @@ namespace widget {
void
search_orphaned_tracks_in_branch (shared_ptr<model::Track> modelTrack,
std::map<shared_ptr<model::Track>,
shared_ptr<timeline::Track> > &orphan_track_map);
shared_ptr<timeline::Track>>& orphan_track_map);
/**
* Looks up a timeline UI track in trackMap that corresponds to a
@ -270,7 +270,7 @@ namespace widget {
* @deprecated for #955
*/
std::map<shared_ptr<model::Track>
,shared_ptr<timeline::Track> >
,shared_ptr<timeline::Track>>
trackMap;
shared_ptr<timeline::Track> hoveringTrack;

9
src/gui/widget/timeline/timeline-clip-track.cpp
View file

@ -68,7 +68,7 @@ namespace timeline {
cairo->stroke();
// Draw all clips
std::pair<shared_ptr<model::Clip>, shared_ptr<timeline::Clip> > pair;
std::pair<shared_ptr<model::Clip>, shared_ptr<timeline::Clip>> pair;
BOOST_FOREACH (pair, clipMap)
{
pair.second->draw(cairo, window);
@ -78,7 +78,7 @@ namespace timeline {
shared_ptr<timeline::Clip>
ClipTrack::getClipAt(Time position) const
{
std::pair<shared_ptr<model::Clip>, shared_ptr<timeline::Clip> >
std::pair<shared_ptr<model::Clip>, shared_ptr<timeline::Clip>>
pair;
BOOST_FOREACH (pair, clipMap)
{
@ -127,7 +127,8 @@ namespace timeline {
ClipTrack::removeOrphanedClips ()
{
std::map< shared_ptr<model::Clip>,
shared_ptr<timeline::Clip> >
shared_ptr<timeline::Clip>
>
orphanClipMap (clipMap);
// Remove all clips which are still present in the sequence
@ -137,7 +138,7 @@ namespace timeline {
// orphanClipMap now contains all the orphaned clips
// Remove them
std::pair< shared_ptr<model::Clip>, shared_ptr<timeline::Clip> >
std::pair<shared_ptr<model::Clip>, shared_ptr<timeline::Clip>>
pair;
BOOST_FOREACH (pair, orphanClipMap)
{

5
src/gui/window-manager.cpp
View file

@ -103,7 +103,7 @@ namespace gui {
REQUIRE(event);
REQUIRE(event->window);
list< shared_ptr<WorkspaceWindow> >::iterator iterator = windowList.begin();
list<shared_ptr<WorkspaceWindow>>::iterator iterator{windowList.begin()};
while (iterator != windowList.end())
{
@ -141,8 +141,7 @@ namespace gui {
{
bool enable = windowList.size() > 1;
list< shared_ptr<WorkspaceWindow> >::iterator iterator =
windowList.begin();
list<shared_ptr<WorkspaceWindow>>::iterator iterator{windowList.begin()};
while (iterator != windowList.end())
{

8
src/lib/element-tracker.hpp
View file

@ -90,11 +90,11 @@ namespace lib {
*/
template<typename ELM>
class ElementTracker
: public lib::RefArrayVector<P<ELM> >
: public lib::RefArrayVector<P<ELM>>
{
typedef std::vector<P<ELM> > _Vec;
typedef typename _Vec::iterator Iter;
typedef typename _Vec::const_iterator CIter;
using _Vec = std::vector<P<ELM>>;
using Iter = typename _Vec::iterator;
using CIter = typename _Vec::const_iterator;
public:
~ElementTracker()

2
src/lib/handle.hpp
View file

@ -68,7 +68,7 @@ namespace lib {
*/
template<class IMP>
class Handle
: public lib::BoolCheckable<Handle<IMP> >
: public lib::BoolCheckable<Handle<IMP>>
{
protected:
typedef std::shared_ptr<IMP> SmPtr;

4
src/lib/iter-adapter-ptr-deref.hpp
View file

@ -85,7 +85,7 @@ namespace lib {
*/
template<class IT>
class PtrDerefIter
: public lib::BoolCheckable<PtrDerefIter<IT> >
: public lib::BoolCheckable<PtrDerefIter<IT>>
{
IT i_; ///< nested source iterator
@ -230,7 +230,7 @@ namespace lib {
*/
template<class IT>
class AddressExposingIter
: public lib::BoolCheckable<AddressExposingIter<IT> >
: public lib::BoolCheckable<AddressExposingIter<IT>>
{
typedef typename IT::pointer _Ptr;

12
src/lib/iter-adapter-stl.hpp
View file

@ -55,7 +55,7 @@ namespace iter_stl {
*/
template<typename IT>
class DistinctIter
: public lib::BoolCheckable<DistinctIter<IT> >
: public lib::BoolCheckable<DistinctIter<IT>>
{
public:
typedef typename IT::value_type value_type;
@ -205,16 +205,16 @@ namespace iter_stl {
template<class IT, typename SEL>
struct _MapSubSelector
{
typedef WrappedStlIter< Wrapped_PickKey<IT> > PickKey;
typedef WrappedStlIter< Wrapped_PickVal<IT> > PickVal;
typedef WrappedStlIter< Wrapped_PickKey<IT>> PickKey;
typedef WrappedStlIter< Wrapped_PickVal<IT>> PickVal;
};
/** especially for const iterators we need to use \c const& and \c const* */
template<class IT, typename SEL>
struct _MapSubSelector<IT, SEL const&>
{
typedef WrappedStlIter< Wrapped_PickKey<IT> > PickKey; // Key is always const for maps
typedef WrappedStlIter< Wrapped_PickConstVal<IT> > PickVal;
typedef WrappedStlIter< Wrapped_PickKey<IT>> PickKey; // Key is always const for maps
typedef WrappedStlIter< Wrapped_PickConstVal<IT>> PickVal;
};
@ -415,7 +415,7 @@ namespace iter_stl {
*/
template<typename VAL>
class IterSnapshot
: public lib::BoolCheckable<IterSnapshot<VAL> >
: public lib::BoolCheckable<IterSnapshot<VAL>>
{
typedef std::vector<VAL> Sequence;

12
src/lib/iter-adapter.hpp
View file

@ -157,7 +157,7 @@ namespace lib {
*/
template<class POS, class CON>
class IterAdapter
: public lib::BoolCheckable<IterAdapter<POS,CON> >
: public lib::BoolCheckable<IterAdapter<POS,CON>>
{
CON source_;
mutable POS pos_;
@ -298,7 +298,7 @@ namespace lib {
*/
template<typename T, class ST =T>
class IterStateWrapper
: public lib::BoolCheckable<IterStateWrapper<T,ST> >
: public lib::BoolCheckable<IterStateWrapper<T,ST>>
{
ST core_;
@ -422,7 +422,7 @@ namespace lib {
*/
template<class IT>
class RangeIter
: public lib::BoolCheckable<RangeIter<IT> >
: public lib::BoolCheckable<RangeIter<IT>>
{
IT p_;
IT e_;
@ -648,7 +648,7 @@ namespace lib {
struct IterType;
template<template<class,class> class Iter, class TY, class CON>
struct IterType<Iter<TY,CON> >
struct IterType<Iter<TY,CON>>
{
typedef CON Container;
typedef TY ElemType;
@ -661,7 +661,7 @@ namespace lib {
};
template<class IT>
struct IterType<RangeIter<IT> >
struct IterType<RangeIter<IT>>
: IterType<IT>
{
template<class T2>
@ -677,7 +677,7 @@ namespace lib {
/** wrapper to declare exposed values const */
template<class IT>
class ConstIter
: public lib::BoolCheckable<ConstIter<IT> >
: public lib::BoolCheckable<ConstIter<IT>>
{
IT i_; ///< nested source iterator

8
src/lib/iter-explorer.hpp
View file

@ -450,7 +450,7 @@ namespace lib {
class ChainedIters;
template<class ITI>
class ChainedIters<ITI, typename enable_if< _is_iterator_of_iterators<ITI> >::type
class ChainedIters<ITI, typename enable_if< _is_iterator_of_iterators<ITI>>::type
>
: public IterStateWrapper<typename ITI::value_type::value_type
,ChainedIteratorImpl<ITI, typename ITI::value_type>
@ -471,7 +471,7 @@ namespace lib {
* of the given iterator is itself an iterator
*/
template<class SEQ>
class ChainedIters<SEQ, typename disable_if< _is_iterator_of_iterators<SEQ> >::type
class ChainedIters<SEQ, typename disable_if< _is_iterator_of_iterators<SEQ>>::type
>
: public IterStateWrapper<typename SEQ::value_type
,ChainedIteratorImpl<IterStack<SEQ>, SEQ>
@ -940,10 +940,10 @@ namespace lib {
/* ==== convenient builder free functions ==== */
template<class IT>
inline IterExplorer<iter_explorer::WrappedSequence<IT> >
inline IterExplorer<iter_explorer::WrappedSequence<IT>>
exploreIter (IT const& srcSeq)
{
return IterExplorer<iter_explorer::WrappedSequence<IT> > (srcSeq);
return IterExplorer<iter_explorer::WrappedSequence<IT>> (srcSeq);
}

4
src/lib/iter-stack.hpp
View file

@ -118,7 +118,7 @@ namespace lib {
*/
template<class TY>
struct IterStack
: IterStateWrapper<TY, IterDequeStorage<TY> >
: IterStateWrapper<TY, IterDequeStorage<TY>>
{
// using default create and copy operations
@ -165,7 +165,7 @@ namespace lib {
*/
template<class TY>
struct IterQueue
: IterStateWrapper<TY, IterDequeStorage<TY> >
: IterStateWrapper<TY, IterDequeStorage<TY>>
{
// using default create and copy operations

14
src/lib/itertools.hpp
View file

@ -147,7 +147,7 @@ namespace lib {
*/
template<class CORE>
class IterTool
: public lib::BoolCheckable<IterTool<CORE> >
: public lib::BoolCheckable<IterTool<CORE>>
{
protected: /* == iteration control == */
@ -315,7 +315,7 @@ namespace lib {
*/
template<class IT>
class FilterIter
: public IterTool<FilterCore<IT> >
: public IterTool<FilterCore<IT>>
{
typedef FilterCore<IT> _Filter;
typedef IterTool<_Filter> _Impl;
@ -609,7 +609,7 @@ namespace lib {
*/
template<class IT, class VAL>
class TransformIter
: public IterTool<TransformingCore<IT,VAL> >
: public IterTool<TransformingCore<IT,VAL>>
{
typedef TransformingCore<IT,VAL> _Trafo;
typedef IterTool<_Trafo> _IteratorImpl;
@ -636,19 +636,19 @@ namespace lib {
template<typename SIG>
struct _ProducedOutput
{
typedef typename FunctionSignature<function<SIG> >::Ret Type;
typedef typename FunctionSignature<function<SIG>>::Ret Type;
};
template<typename SIG>
struct _ProducedOutput<function<SIG> >
struct _ProducedOutput<function<SIG>>
{
typedef typename FunctionSignature<function<SIG> >::Ret Type;
typedef typename FunctionSignature<function<SIG>>::Ret Type;
};
template<typename FUN>
struct _ProducedOutput<FUN*>
{
typedef typename FunctionSignature<function<FUN> >::Ret Type;
typedef typename FunctionSignature<function<FUN>>::Ret Type;
};
}

6
src/lib/meta/configflags.hpp
View file

@ -105,7 +105,7 @@ namespace meta{
, uint f4
, uint IGN
>
struct ConfigSetFlag<Fl, Config<f1,f2,f3,f4,IGN> >
struct ConfigSetFlag<Fl, Config<f1,f2,f3,f4,IGN>>
{
typedef lib::meta::Config<Fl,f1,f2,f3,f4> Config;
};
@ -158,7 +158,7 @@ namespace meta{
struct FlagInfo;
template<uint ff, class FLAGS>
struct FlagInfo<Node<Flag<ff>, FLAGS> >
struct FlagInfo<Node<Flag<ff>, FLAGS>>
{
enum{ BITS = maxC< ff, FlagInfo<FLAGS>::BITS> ::VAL
, CODE = (1<<ff) | FlagInfo<FLAGS>::CODE
@ -181,7 +181,7 @@ namespace meta{
};
template<class CONF, class TAIL>
struct FlagInfo<Node<CONF, TAIL> >
struct FlagInfo<Node<CONF, TAIL>>
{
typedef typename CONF::Flags ThisFlags;
enum{

6
src/lib/meta/function-closure.hpp
View file

@ -476,10 +476,10 @@ namespace func{
template<typename SIG>
class TupleApplicator
{
typedef typename FunctionSignature< function<SIG> >::Args Args;
typedef typename FunctionSignature< function<SIG> >::Ret Ret;
using Args = typename FunctionSignature< function<SIG>>::Args;
using Ret = typename FunctionSignature< function<SIG>>::Ret;
typedef function<Ret()> BoundFunc;
using BoundFunc = function<Ret()>;
enum { ARG_CNT = count<typename Args::List>::value };

2
src/lib/meta/function-erasure.hpp
View file

@ -139,7 +139,7 @@ namespace meta{
function<SIG>&
getFun () const
{
return get<function<SIG> >();
return get<function<SIG>>();
}

44
src/lib/meta/function.hpp
View file

@ -226,33 +226,33 @@ namespace meta{
template<typename SIG>
struct _Fun
{
typedef typename FunctionSignature<function<SIG> >::Ret Ret;
typedef typename FunctionSignature<function<SIG> >::Args Args;
typedef SIG Sig;
typedef typename FunctionSignature<function<SIG>>::Ret Ret;
typedef typename FunctionSignature<function<SIG>>::Args Args;
typedef SIG Sig;
};
/** Specialisation for using a function pointer */
template<typename SIG>
struct _Fun<SIG*>
{
typedef typename FunctionSignature<function<SIG> >::Ret Ret;
typedef typename FunctionSignature<function<SIG> >::Args Args;
typedef SIG Sig;
typedef typename FunctionSignature<function<SIG>>::Ret Ret;
typedef typename FunctionSignature<function<SIG>>::Args Args;
typedef SIG Sig;
};
/** Specialisation when using a function reference */
template<typename SIG>
struct _Fun<SIG&>
{
typedef typename FunctionSignature<function<SIG> >::Ret Ret;
typedef typename FunctionSignature<function<SIG> >::Args Args;
typedef SIG Sig;
typedef typename FunctionSignature<function<SIG>>::Ret Ret;
typedef typename FunctionSignature<function<SIG>>::Args Args;
typedef SIG Sig;
};
/** Specialisation for passing a functor */
template<typename SIG>
struct _Fun<function<SIG> >
struct _Fun<function<SIG>>
{
typedef typename FunctionSignature<function<SIG> >::Ret Ret;
typedef typename FunctionSignature<function<SIG> >::Args Args;
typedef SIG Sig;
typedef typename FunctionSignature<function<SIG>>::Ret Ret;
typedef typename FunctionSignature<function<SIG>>::Args Args;
typedef SIG Sig;
};
/** Specialisations for member function pointers */
@ -407,7 +407,7 @@ namespace meta{
template< typename RET
, typename A1
>
struct FunctionTypedef<RET, Types<A1> >
struct FunctionTypedef<RET, Types<A1>>
{
typedef function<RET(A1)> Func;
typedef RET Sig(A1);
@ -418,7 +418,7 @@ namespace meta{
, typename A1
, typename A2
>
struct FunctionTypedef<RET, Types<A1,A2> >
struct FunctionTypedef<RET, Types<A1,A2>>
{
typedef function<RET(A1,A2)> Func;
typedef RET Sig(A1,A2);
@ -430,7 +430,7 @@ namespace meta{
, typename A2
, typename A3
>
struct FunctionTypedef<RET, Types<A1,A2,A3> >
struct FunctionTypedef<RET, Types<A1,A2,A3>>
{
typedef function<RET(A1,A2,A3)> Func;
typedef RET Sig(A1,A2,A3);
@ -443,7 +443,7 @@ namespace meta{
, typename A3
, typename A4
>
struct FunctionTypedef<RET, Types<A1,A2,A3,A4> >
struct FunctionTypedef<RET, Types<A1,A2,A3,A4>>
{
typedef function<RET(A1,A2,A3,A4)> Func;
typedef RET Sig(A1,A2,A3,A4);
@ -457,7 +457,7 @@ namespace meta{
, typename A4
, typename A5
>
struct FunctionTypedef<RET, Types<A1,A2,A3,A4,A5> >
struct FunctionTypedef<RET, Types<A1,A2,A3,A4,A5>>
{
typedef function<RET(A1,A2,A3,A4,A5)> Func;
typedef RET Sig(A1,A2,A3,A4,A5);
@ -472,7 +472,7 @@ namespace meta{
, typename A5
, typename A6
>
struct FunctionTypedef<RET, Types<A1,A2,A3,A4,A5,A6> >
struct FunctionTypedef<RET, Types<A1,A2,A3,A4,A5,A6>>
{
typedef function<RET(A1,A2,A3,A4,A5,A6)> Func;
typedef RET Sig(A1,A2,A3,A4,A5,A6);
@ -488,7 +488,7 @@ namespace meta{
, typename A6
, typename A7
>
struct FunctionTypedef<RET, Types<A1,A2,A3,A4,A5,A6,A7> >
struct FunctionTypedef<RET, Types<A1,A2,A3,A4,A5,A6,A7>>
{
typedef function<RET(A1,A2,A3,A4,A5,A6,A7)> Func;
typedef RET Sig(A1,A2,A3,A4,A5,A6,A7);
@ -505,7 +505,7 @@ namespace meta{
, typename A7
, typename A8
>
struct FunctionTypedef<RET, Types<A1,A2,A3,A4,A5,A6,A7,A8> >
struct FunctionTypedef<RET, Types<A1,A2,A3,A4,A5,A6,A7,A8>>
{
typedef function<RET(A1,A2,A3,A4,A5,A6,A7,A8)> Func;
typedef RET Sig(A1,A2,A3,A4,A5,A6,A7,A8);
@ -523,7 +523,7 @@ namespace meta{
, typename A8
, typename A9
>
struct FunctionTypedef<RET, Types<A1,A2,A3,A4,A5,A6,A7,A8,A9> >
struct FunctionTypedef<RET, Types<A1,A2,A3,A4,A5,A6,A7,A8,A9>>
{
typedef function<RET(A1,A2,A3,A4,A5,A6,A7,A8,A9)> Func;
typedef RET Sig(A1,A2,A3,A4,A5,A6,A7,A8,A9);

2
src/lib/meta/maybe-compare.hpp
View file

@ -53,7 +53,7 @@ namespace meta{
* we'll use our private hack, which at least detects equivalence
* in \em some cases... */
template<typename SIG>
struct Comparator<function<SIG> >
struct Comparator<function<SIG>>
{
static bool
equals (function<SIG> const& f1, function<SIG> const& f2)

4
src/lib/meta/trait-special.hpp
View file

@ -34,7 +34,7 @@ namespace lib {
namespace meta {
/** the tr1 hashtable(s) are notoriously difficult to handle
/** the std hashtable(s) are notoriously difficult to handle
* when it comes to detecting capabilities by metaprogramming,
* because the're built up from a generic baseclass and especially
* inherit their iterator-types as template specialisations.
@ -42,7 +42,7 @@ namespace meta {
* Thus we provide fixed diagnostics to bypass the traits check.
*/
template<typename KEY, typename VAL, typename HASH>
struct can_STL_ForEach<std::unordered_map<KEY,VAL,HASH> >
struct can_STL_ForEach<std::unordered_map<KEY,VAL,HASH>>
{
enum { value = true };
};

8
src/lib/meta/trait.hpp
View file

@ -145,7 +145,7 @@ namespace meta {
};
template<typename X>
struct Unwrap<boost::reference_wrapper<X> >
struct Unwrap<boost::reference_wrapper<X>>
{
typedef X Type;
@ -157,7 +157,7 @@ namespace meta {
};
template<typename X>
struct Unwrap<std::reference_wrapper<X> >
struct Unwrap<std::reference_wrapper<X>>
{
typedef X Type;
@ -169,7 +169,7 @@ namespace meta {
};
template<typename X>
struct Unwrap<std::shared_ptr<X> >
struct Unwrap<std::shared_ptr<X>>
{
typedef X Type;
@ -182,7 +182,7 @@ namespace meta {
};
template<typename X, class B>
struct Unwrap<P<X, B> >
struct Unwrap<P<X, B>>
{
typedef X Type;

12
src/lib/meta/typelist-manip.hpp
View file

@ -130,7 +130,7 @@ namespace meta {
struct Append<Node<TY,TYPES>, TAIL> { typedef Node<TY, typename Append<TYPES, TAIL>::List> List; };
template<class TY, class TYPES>
struct Append<NullType, Node<TY,TYPES> > { typedef Node<TY,TYPES> List; };
struct Append<NullType, Node<TY,TYPES>> { typedef Node<TY,TYPES> List; };
template<class TY, class TYPES>
struct Append<Node<TY,TYPES>, NullType> { typedef Node<TY,TYPES> List; };
@ -155,11 +155,11 @@ namespace meta {
struct SplitLast<NullType> { typedef NullType Type;
typedef NullType List; };
template<class TY>
struct SplitLast<Node<TY,NullType> > { typedef TY Type;
struct SplitLast<Node<TY,NullType>> { typedef TY Type;
typedef NullType List; };
template<class TY, class TYPES>
struct SplitLast<Node<TY,TYPES> > { typedef typename SplitLast<TYPES>::Type Type;
struct SplitLast<Node<TY,TYPES>> { typedef typename SplitLast<TYPES>::Type Type;
typedef typename Append< TY,
typename SplitLast<TYPES>::List
>::List
@ -211,7 +211,7 @@ namespace meta {
struct Dissect;
template<class T, class TYPES>
struct Dissect<Node<T,TYPES> >
struct Dissect<Node<T,TYPES>>
{
typedef Node<T,TYPES> List; ///< the complete list
typedef T Head; ///< first element
@ -253,7 +253,7 @@ namespace meta {
template< class T
, class TY, class TYPES
>
struct PrefixAll<T, Node<TY,TYPES> > { typedef Node< typename Append<T,TY>::List
struct PrefixAll<T, Node<TY,TYPES>> { typedef Node< typename Append<T,TY>::List
, typename PrefixAll<T,TYPES>::List
> List; };
@ -313,7 +313,7 @@ namespace meta {
template<class F>
struct FlagOnOff
{
typedef Node<F, Node<NullType,NullType> > List;
typedef Node<F, Node<NullType,NullType>> List;
};

8
src/lib/meta/typelist-util.hpp
View file

@ -65,7 +65,7 @@ namespace meta {
enum{ value = 0 };
};
template<class TY, class TYPES>
struct count<Node<TY,TYPES> >
struct count<Node<TY,TYPES>>
{
enum{ value = 1 + count<TYPES>::value };
};
@ -82,7 +82,7 @@ namespace meta {
static constexpr int value = 0;
};
template<class TY, class TYPES>
struct maxSize<Node<TY,TYPES> >
struct maxSize<Node<TY,TYPES>>
{
static constexpr size_t thisval = sizeof(TY);
static constexpr size_t nextval = maxSize<TYPES>::value;
@ -101,13 +101,13 @@ namespace meta {
};
template<typename TY, typename TYPES>
struct IsInList<TY, Node<TY,TYPES> >
struct IsInList<TY, Node<TY,TYPES>>
{
enum{ value = true };
};
template<typename TY, typename XX, typename TYPES>
struct IsInList<TY, Node<XX,TYPES> >
struct IsInList<TY, Node<XX,TYPES>>
{
enum{ value = IsInList<TY,TYPES>::value };
};

2
src/lib/observable-list.hpp
View file

@ -36,7 +36,7 @@ namespace lumiera
* An observable_list is an STL list with an inbuilt sigc++ signal that
* allows observers to be notified when changes are made to the list.
*/
template<class T, class Allocator = std::allocator<T> >
template<class T, class Allocator = std::allocator<T>>
class observable_list
{
public:

6
src/lib/opaque-holder.hpp
View file

@ -192,7 +192,7 @@ namespace lib {
///< how to access the contents via a common interface?
>
class InPlaceAnyHolder
: public BoolCheckable<InPlaceAnyHolder<siz, AccessPolicy> >
: public BoolCheckable<InPlaceAnyHolder<siz, AccessPolicy>>
{
typedef typename AccessPolicy::Base * BaseP;
@ -515,9 +515,9 @@ namespace lib {
, size_t siz = sizeof(BA)
>
class OpaqueHolder
: public InPlaceAnyHolder<siz, InPlaceAnyHolder_useCommonBase<BA> >
: public InPlaceAnyHolder<siz, InPlaceAnyHolder_useCommonBase<BA>>
{
typedef InPlaceAnyHolder<siz, InPlaceAnyHolder_useCommonBase<BA> > InPlaceHolder;
typedef InPlaceAnyHolder<siz, InPlaceAnyHolder_useCommonBase<BA>> InPlaceHolder;
public:
OpaqueHolder() : InPlaceHolder() {}

2
src/lib/optional-ref.hpp
View file

@ -53,7 +53,7 @@ namespace lib {
*/
template<typename T>
class OptionalRef
: public lib::BoolCheckable<OptionalRef<T> >
: public lib::BoolCheckable<OptionalRef<T>>
{
T* ref_;

2
src/lib/p.hpp
View file

@ -73,7 +73,7 @@ namespace lib {
* pointee causes an dynamic cast. Thus the pointee types
* need to support RTTI.
*/
template<class TAR, class BASE =shared_ptr<TAR> >
template<class TAR, class BASE =shared_ptr<TAR>>
class P
: public BASE
{

2
src/lib/scoped-holder-transfer.hpp
View file

@ -65,7 +65,7 @@ namespace lib {
* when the pointer isn'T \c NULL
*
*/
template<class TY, class PAR = std::allocator<TY> >
template<class TY, class PAR = std::allocator<TY>>
class Allocator_TransferNoncopyable
{
typedef Allocator_TransferNoncopyable<TY,PAR> _ThisType;

2
src/lib/sync.hpp
View file

@ -264,7 +264,7 @@ namespace lib {
template<class MTX>
class Condition
: public Mutex<Wrapped_Condition<MTX> >
: public Mutex<Wrapped_Condition<MTX>>
{
typedef Wrapped_Condition<MTX> Cond;

2
src/lib/test/depend-4test.hpp
View file

@ -74,7 +74,7 @@ namespace test{
template<class MOCK>
struct ServiceInterface<MOCK, typename enable_if< defines_ServiceInterface<MOCK> >::type>
struct ServiceInterface<MOCK, typename enable_if< defines_ServiceInterface<MOCK>>::type>
{
typedef typename MOCK::ServiceInterface Type;
};

2
src/lib/time/digxel.hpp
View file

@ -224,7 +224,7 @@ namespace time {
, class FMT = digxel::Formatter<NUM>
>
class Digxel
: public boost::totally_ordered<Digxel<NUM,FMT> >
: public boost::totally_ordered<Digxel<NUM,FMT>>
{
mutable
FMT buffer_;

2
src/lib/time/timevalue.hpp
View file

@ -79,7 +79,7 @@ namespace time {
*/
class TimeValue
: boost::totally_ordered<TimeValue,
boost::totally_ordered<TimeValue, gavl_time_t> >
boost::totally_ordered<TimeValue, gavl_time_t>>
{
protected:
/** the raw (internal) time value

4
src/lib/visitor-dispatcher.hpp
View file

@ -180,7 +180,7 @@ namespace visitor {
public:
static Depend<Dispatcher<TAR,TOOL> > instance;
static Depend<Dispatcher<TAR,TOOL>> instance;
inline ReturnType
forwardCall (TAR& target, TOOL& tool)
@ -208,7 +208,7 @@ namespace visitor {
/** storage for the dispatcher table(s) */
template<class TAR, class TOOL>
Depend<Dispatcher<TAR,TOOL> > Dispatcher<TAR,TOOL>::instance;
Depend<Dispatcher<TAR,TOOL>> Dispatcher<TAR,TOOL>::instance;

6
src/lib/wrapper.hpp
View file

@ -140,7 +140,7 @@ namespace wrapper {
*/
template<typename TY>
class ItemWrapper
: public BoolCheckable<ItemWrapper<TY> >
: public BoolCheckable<ItemWrapper<TY>>
{
typedef typename remove_const<TY>::type TY_unconst;
@ -347,8 +347,8 @@ namespace wrapper {
: public function<SIG>
, boost::noncopyable
{
typedef typename FunctionSignature<function<SIG> >::Ret Res;
typedef ItemWrapper<Res> ResWrapper;
using Res = typename FunctionSignature<function<SIG>>::Ret;
using ResWrapper = ItemWrapper<Res>;
ResWrapper lastResult_;

2
src/proc/asset.hpp
View file

@ -339,7 +339,7 @@ namespace asset {
struct is_pAsset : boost::false_type {};
template <class A>
struct is_pAsset<shared_ptr<A> >
struct is_pAsset<shared_ptr<A>>
: boost::is_base_of<Asset, A> {};

4
src/proc/control/argument-tuple-accept.hpp
View file

@ -596,8 +596,8 @@ namespace control {
template<typename SIG>
struct _Type
{
using Args = typename FunctionSignature< function<SIG> >::Args;
using Ret = typename FunctionSignature< function<SIG> >::Ret;
using Args = typename FunctionSignature< function<SIG>>::Args;
using Ret = typename FunctionSignature< function<SIG>>::Ret;
using Sig = SIG;
using ArgTuple = Tuple<Args>;
};

10
src/proc/control/command-def.hpp
View file

@ -98,8 +98,8 @@ namespace control {
namespace stage { ///< helpers for building up a command definition
typedef shared_ptr<CommandImpl> ImplInstance;
typedef function<Command&(ImplInstance const&)> Activation;
using ImplInstance = shared_ptr<CommandImpl>;
using Activation = function<Command&(ImplInstance const&)>;
@ -112,7 +112,7 @@ namespace control {
{
Command& prototype_;
typedef typename FunctionSignature< function<SIG> >::Args CmdArgs;
typedef typename FunctionSignature< function<SIG>>::Args CmdArgs;
CompletedDefinition (Command& definedCommand)
: prototype_(definedCommand)
@ -244,11 +244,11 @@ namespace control {
template<typename SIG2>
typename BuildUndoDefType<UndoSignature<SIG2> >::Type
typename BuildUndoDefType<UndoSignature<SIG2>>::Type
captureUndo (SIG2& how_to_capture_UndoState)
{
typedef typename UndoSignature<SIG2>::CaptureSig UndoCapSig;
typedef typename BuildUndoDefType<UndoSignature<SIG2> >::Type SpecificUndoDefinition;
typedef typename BuildUndoDefType<UndoSignature<SIG2>>::Type SpecificUndoDefinition;
function<UndoCapSig> captureOperation (how_to_capture_UndoState);
return SpecificUndoDefinition (callback_, operation_, captureOperation);

2
src/proc/control/command-op-closure.hpp
View file

@ -153,7 +153,7 @@ namespace control {
template<typename SIG>
class OpClosure
{
using Args = typename FunctionSignature< function<SIG> >::Args;
using Args = typename FunctionSignature< function<SIG>>::Args;
using Builder = BuildTupleAccessor<ParamAccessor, Args>;
using ParamStorageTuple =typename Builder::Product;

2
src/proc/control/command-registry.hpp
View file

@ -120,7 +120,7 @@ namespace control {
, noncopyable
{
// using a hashtable to implement the index
typedef unordered_map<Symbol, Command, hash<Symbol> > CmdIndex;
typedef unordered_map<Symbol, Command, hash<Symbol>> CmdIndex;
typedef map< const Command*, Symbol, order_by_impl> ReverseIndex;
TypedAllocationManager allocator_;

6
src/proc/control/command-signature.hpp
View file

@ -78,7 +78,7 @@ namespace control {
template<typename SIG, typename MEM>
class CommandSignature
{
typedef typename FunctionSignature< function<SIG> >::Args Args;
typedef typename FunctionSignature< function<SIG>>::Args Args;
typedef typename Args::List ArgList;
typedef typename Append<ArgList, MEM>::List ExtendedArglist;
@ -113,8 +113,8 @@ namespace control {
class UndoSignature
{
// preparation: dissect the function signature into arguments and result
typedef typename FunctionSignature< function<SIG> >::Args Args;
typedef typename FunctionSignature< function<SIG> >::Ret Ret;
typedef typename FunctionSignature< function<SIG>>::Args Args;
typedef typename FunctionSignature< function<SIG>>::Ret Ret;
/** Case1: defining the Undo-Capture function */
template<typename RET, typename ARG>

6
src/proc/engine/nodeoperation.hpp
View file

@ -283,7 +283,7 @@ namespace config {
template<class CONF>
struct SelectBuffProvider { typedef AllocBufferFromParent Type; };
template<uint PROC_ign, uint INPLA_ign>
struct SelectBuffProvider< Config<CACHING, PROC_ign, INPLA_ign> > { typedef AllocBufferFromCache Type; };
struct SelectBuffProvider< Config<CACHING, PROC_ign, INPLA_ign>> { typedef AllocBufferFromCache Type; };
template<class Config>
@ -291,7 +291,7 @@ namespace config {
template<uint INPLACE_ign>
struct Strategy< Config<CACHING,PROCESS,INPLACE_ign> >
struct Strategy< Config<CACHING,PROCESS,INPLACE_ign>>
: QueryCache<
AllocBufferTable<
PullInput<
@ -303,7 +303,7 @@ namespace config {
{ };
template<uint INPLACE_ign>
struct Strategy< Config<PROCESS,INPLACE_ign> >
struct Strategy< Config<PROCESS,INPLACE_ign>>
: AllocBufferTable<
PullInput<
AllocOutput<

2
src/proc/engine/nodewiring-config.hpp
View file

@ -153,7 +153,7 @@ namespace config {
void
visit (IxID code)
{
PFunc pFactory (new FactoryHolder<Factory<CONF> > (ctor_param_));
PFunc pFactory (new FactoryHolder<Factory<CONF>> (ctor_param_));
factories_[code] = pFactory;
}

2
src/proc/mobject/placement-ref.hpp
View file

@ -98,7 +98,7 @@ namespace proc {
*/
template<class MX =MObject>
class PlacementRef
: public lib::BoolCheckable<PlacementRef<MX> >
: public lib::BoolCheckable<PlacementRef<MX>>
{
typedef Placement<MX> PlacementMX;
typedef Placement<MObject>::ID _ID;

2
src/proc/mobject/session/fork.hpp
View file

@ -90,7 +90,7 @@ namespace session { //////////////////////////////////////////////////////TI
public:
/** Child tracks in a tree structure */
// vector<Placement<Track> > subTracks; ///////////TODO: it should really work with PlacementRefs! this here is just a decoy!!!!!!!
// vector<Placement<Track>> subTracks; ///////////TODO: it should really work with PlacementRefs! this here is just a decoy!!!!!!!
/////////////////////////////////////////////////////////TICKET #513
bool isSameID (string const&);

16
src/proc/mobject/session/placement-index-query-resolver.cpp
View file

@ -275,7 +275,7 @@ namespace session {
QueryID
whenQueryingFor()
{
QueryID qID(Goal::DISCOVERY, getResultTypeID<Placement<MO> >());
QueryID qID(Goal::DISCOVERY, getResultTypeID<Placement<MO>>());
return qID;
}
@ -326,15 +326,15 @@ namespace session {
PlacementIndexQueryResolver::canHandleQuery(QID qID) const
{
return qID.kind == Goal::DISCOVERY
&&( qID.type == getResultTypeID<Placement<MObject> >()
||qID.type == getResultTypeID<Placement<Clip> >()
||qID.type == getResultTypeID<Placement<Effect> >()
&&( qID.type == getResultTypeID<Placement<MObject>>()
||qID.type == getResultTypeID<Placement<Clip>>()
||qID.type == getResultTypeID<Placement<Effect>>()
/////////////////////////////////////////////////////////////////TICKET #414
||qID.type == getResultTypeID<Placement<mobject::test::DummyMO > >()
||qID.type == getResultTypeID<Placement<mobject::test::TestSubMO1 > >()
||qID.type == getResultTypeID<Placement<mobject::test::TestSubMO2 > >()
||qID.type == getResultTypeID<Placement<mobject::test::TestSubMO21> >()
||qID.type == getResultTypeID<Placement<mobject::test::DummyMO >>()
||qID.type == getResultTypeID<Placement<mobject::test::TestSubMO1 >>()
||qID.type == getResultTypeID<Placement<mobject::test::TestSubMO2 >>()
||qID.type == getResultTypeID<Placement<mobject::test::TestSubMO21>>()
/////////////////////////////////////////////////////////////////TICKET #532
);
}

2
src/proc/mobject/session/placement-index.hpp
View file

@ -157,7 +157,7 @@ namespace session {
/// @note just ignoring the second (parent) type encoded into Placement
template<typename MO, typename BMO>
struct BuildID<Placement<MO,BMO> >
struct BuildID<Placement<MO,BMO>>
{
typedef PlacementMO::Id<MO> Type;
typedef MO Target;

6
src/proc/mobject/session/scope-query.hpp
View file

@ -72,9 +72,9 @@ namespace session {
*/
template<class MO>
class DiscoveryQuery
: public Query<Placement<MO> >
: public Query<Placement<MO>>
{
typedef Query<Placement<MO> > _Query;
typedef Query<Placement<MO>> _Query;
public:
@ -145,7 +145,7 @@ namespace session {
: public DiscoveryQuery<MO>
{
typedef DiscoveryQuery<MO> _Parent;
typedef Query<Placement<MO> > _Query;
typedef Query<Placement<MO>> _Query;
PlacementMO::ID startPoint_;

14
tests/basics/time/digxel-configurations-test.cpp
View file

@ -60,13 +60,13 @@ namespace test{
virtual void
run (Arg)
{
verifyConfiguration<Digxel<int> > (123);
verifyConfiguration<Digxel<double> > (123.4567);
verifyConfiguration<SexaDigit > (42);
verifyConfiguration<SexaDigit > (-5);
verifyConfiguration<HexaDigit > (0xc);
verifyConfiguration<HexaDigit > (0x6f);
verifyConfiguration<CountVal > (-1234567890);
verifyConfiguration<Digxel<int> > (123);
verifyConfiguration<Digxel<double>> (123.4567);
verifyConfiguration<SexaDigit > (42);
verifyConfiguration<SexaDigit > (-5);
verifyConfiguration<HexaDigit > (0xc);
verifyConfiguration<HexaDigit > (0x6f);
verifyConfiguration<CountVal > (-1234567890);
verifySignum();
}

6
tests/core/proc/asset/testasset.cpp
View file

@ -79,7 +79,7 @@ namespace test {
* within AssetManager by the Asset base class ctor
*/
template<class A>
lib::P<TestAsset<A> >
lib::P<TestAsset<A>>
TestAsset<A>::ptrFromThis ()
{
return static_pointer_cast<TestAsset<A>,Asset>
@ -111,8 +111,8 @@ namespace test {
template TestAsset<Asset>::TestAsset (PAsset& pRef);
template TestAsset<Unknown>::TestAsset (PAsset& pRef);
template lib::P<TestAsset<Asset> > TestAsset<Asset>::ptrFromThis ();
template lib::P<TestAsset<Unknown> > TestAsset<Unknown>::ptrFromThis ();
template lib::P<TestAsset<Asset>> TestAsset<Asset>::ptrFromThis ();
template lib::P<TestAsset<Unknown>> TestAsset<Unknown>::ptrFromThis ();

2
tests/core/proc/asset/testasset.hpp
View file

@ -53,7 +53,7 @@ namespace test {
static void deleter (TestAsset<A>* aa) { delete aa; }
public:
typedef lib::P<TestAsset<A> > PA;
using PA = lib::P<TestAsset<A>>;
static PA create () { return (new TestAsset<A> )->ptrFromThis(); }
static PA create (PAsset& pRef) { return (new TestAsset<A> (pRef))->ptrFromThis(); }

4
tests/core/proc/control/argument-tuple-accept-test.cpp
View file

@ -54,8 +54,8 @@ namespace test {
template<typename SIG>
struct _Tup
{
typedef typename FunctionSignature< function<SIG> >::Args Args;
typedef typename FunctionSignature< function<SIG> >::Ret Ret;
typedef typename FunctionSignature< function<SIG>>::Args Args;
typedef typename FunctionSignature< function<SIG>>::Ret Ret;
typedef Tuple<Args> Ty;
};

2
tests/core/proc/control/command-mutation-test.cpp
View file

@ -108,7 +108,7 @@ namespace test {
VERIFY_ERROR (UNBOUND_ARGUMENTS, functor(nullClosure) );
// now create a real closure....
Tuple<Types<int> > param = std::make_tuple (23);
Tuple<Types<int>> param = std::make_tuple (23);
SimpleClosure<void(int)> closed_over{param};
CmdClosure& closure (closed_over);

2
tests/core/proc/control/command-registry-test.cpp
View file

@ -211,7 +211,7 @@ namespace test {
CHECK (!pImpl->canExec());
typedef Types<int> ArgType;
TypedArguments<Tuple<ArgType> > arg (Tuple<ArgType>(98765));
TypedArguments<Tuple<ArgType>> arg{Tuple<ArgType>(98765)};
pImpl->setArguments(arg);
CHECK (pImpl->canExec());

2
tests/core/proc/control/handling-pattern-basics-test.cpp
View file

@ -179,7 +179,7 @@ namespace test {
typedef Types<int> ArgType;
const int ARGU (1 + rand() % 1000);
Tuple<ArgType> tuple(ARGU);
TypedArguments<Tuple<ArgType> > arg(tuple);
TypedArguments<Tuple<ArgType>> arg(tuple);
com->setArguments(arg);
CHECK (com->canExec());

4
tests/core/proc/engine/testframe.cpp
View file

@ -90,9 +90,9 @@ namespace test {
*/
template<uint CHA, uint FRA>
struct TestFrameTable
: vector<vector<TestFrame> >
: vector<vector<TestFrame>>
{
typedef vector<vector<TestFrame> > VECT;
typedef vector<vector<TestFrame>> VECT;
TestFrameTable()
: VECT(CHA)

16
tests/core/proc/mobject/session/defs-registry-impl-test.cpp
View file

@ -79,10 +79,10 @@ namespace test {
string Dummy<I>::name = _Fmt("Dummy<%2i>") % I;
template<int I>
inline P<Dummy<I> >
inline P<Dummy<I>>
fabricate()
{
return P<Dummy<I> >(new Dummy<I>);
return P<Dummy<I>>(new Dummy<I>);
}
}//(End)Test helpers
@ -104,14 +104,14 @@ namespace test {
{
scoped_ptr<DefsRegistry> reg_;
typedef P<Dummy<13> > Obj;
typedef P<Dummy<23> > Pra;
typedef P<Dummy<13>> Obj;
typedef P<Dummy<23>> Pra;
typedef Query<Dummy<13> > Q13;
typedef Query<Dummy<23> > Q23;
typedef Query<Dummy<13>> Q13;
typedef Query<Dummy<23>> Q23;
typedef DefsRegistry::Iter<Dummy<13> > Iter13;
typedef DefsRegistry::Iter<Dummy<23> > Iter23;
typedef DefsRegistry::Iter<Dummy<13>> Iter13;
typedef DefsRegistry::Iter<Dummy<23>> Iter23;
// some test objects...

18
tests/library/allocation-cluster-test.cpp
View file

@ -98,7 +98,7 @@ namespace test {
void
place_object (AllocationCluster& clu, uint id)
{
clu.create<Dummy<i> > (id);
clu.create<Dummy<i>> (id);
}
typedef void (Invoker)(AllocationCluster&, uint);
@ -170,10 +170,10 @@ namespace test {
AllocationCluster clu;
char c1(123), c2(56), c3(3), c4(4), c5(5);
Dummy<44>& ref1 = clu.create<Dummy<44> > ();
Dummy<37>& ref2 = clu.create<Dummy<37> > (c1);
Dummy<37>& ref3 = clu.create<Dummy<37> > (c2);
Dummy<1234>& rX = clu.create<Dummy<1234> > (c3,c4,c5);
Dummy<44>& ref1 = clu.create<Dummy<44>> ();
Dummy<37>& ref2 = clu.create<Dummy<37>> (c1);
Dummy<37>& ref3 = clu.create<Dummy<37>> (c2);
Dummy<1234>& rX = clu.create<Dummy<1234>> (c3,c4,c5);
CHECK (&ref1);
CHECK (&ref2);
@ -189,9 +189,9 @@ namespace test {
// all created object's dtors will be invoked.
CHECK (4 == clu.size());
CHECK (1 == clu.count<Dummy<44> >());
CHECK (2 == clu.count<Dummy<37> >());
CHECK (1 == clu.count<Dummy<1234> >());
CHECK (1 == clu.count<Dummy<44>>());
CHECK (2 == clu.count<Dummy<37>>());
CHECK (1 == clu.count<Dummy<1234>>());
}
@ -221,7 +221,7 @@ namespace test {
{
char i1 = truncChar(i);
char i2 = truncChar(rand() % 5);
clu.create<Dummy<1> > (i1,i2);
clu.create<Dummy<1>> (i1,i2);
}
catch (char id)
{

16
tests/library/custom-shared-ptr-test.cpp
View file

@ -141,7 +141,7 @@ namespace test{
CHECK (0 == pX.use_count());
CHECK (4 == pX2.use_count());
P<X, P<X> > pXX (pX2); // a different type, but compatible pointers
P<X, P<X>> pXX (pX2); // a different type, but compatible pointers
pX2 = pX;
CHECK (!pX2);
CHECK (0 == pX2.use_count());
@ -194,13 +194,13 @@ namespace test{
void
check_type_relations ()
{
P<X> pX; // Base: shared_ptr<X>
P<XX> pX1; // Base: shared_ptr<XX>
P<XX,P<X> > pX2; // Base: P<X>
P<XX,shared_ptr<X> > pX3; // Base: shared_ptr<X>
P<XX,shared_ptr<long> > pLo;// Base: shared_ptr<long> (rather nonsense, but well...)
P<X,string> pLoL; // Base: std::string
P<string> pLoLoL; // Base: shared_ptr<string>
P<X> pX; // Base: shared_ptr<X>
P<XX> pX1; // Base: shared_ptr<XX>
P<XX,P<X>> pX2; // Base: P<X>
P<XX,shared_ptr<X>> pX3; // Base: shared_ptr<X>
P<XX,shared_ptr<long>> pLo;// Base: shared_ptr<long> (rather nonsense, but well...)
P<X,string> pLoL; // Base: std::string
P<string> pLoLoL; // Base: shared_ptr<string>
CHECK (INSTANCEOF (shared_ptr<X>, &pX));

2
tests/library/del-stash-test.cpp
View file

@ -130,7 +130,7 @@ namespace test{
killer.manage (p);
killer.manage (r);
killer.manage<Probe<9> > (v);
killer.manage<Probe<9>> (v);
CHECK (3 == killer.size());

12
tests/library/linked-elements-test.cpp
View file

@ -416,15 +416,15 @@ namespace test{
ListCustomAllocated elements(allocator);
elements.pushNew<Num<1> > (2);
elements.pushNew<Num<3> > (4,5);
elements.pushNew<Num<6> > (7,8,9);
elements.pushNew<Num<1>> (2);
elements.pushNew<Num<3>> (4,5);
elements.pushNew<Num<6>> (7,8,9);
CHECK (sum(9) == Dummy::checksum());
CHECK (3 == allocator.size());
CHECK (1 == allocator.count<Num<1> >());
CHECK (1 == allocator.count<Num<3> >());
CHECK (1 == allocator.count<Num<6> >());
CHECK (1 == allocator.count<Num<1>>());
CHECK (1 == allocator.count<Num<3>>());
CHECK (1 == allocator.count<Num<6>>());
CHECK (3 == elements.size());
CHECK (1+2 == elements[2].getVal());

4
tests/library/meta/config-flags-test.cpp
View file

@ -102,7 +102,7 @@ namespace test {
template<> struct Maybe<Conf3> : Indeed { enum{ CODE = 30 }; };
template<uint Fl>
struct Maybe<Config<TWO,Fl> >
struct Maybe<Config<TWO,Fl>>
{
typedef Yes_t is_defined;
@ -170,7 +170,7 @@ cout << "__________________________\n" \
CHECK (1==sizeof(flags1)); // pure marker-type without content
CHECK (1==sizeof(flags2));
typedef DefineConfigByFlags<Node<Flag<ONE>,NullType> >::Config SimpleConfig_defined_by_Typelist;
typedef DefineConfigByFlags<Node<Flag<ONE>,NullType>>::Config SimpleConfig_defined_by_Typelist;
DISPLAY (SimpleConfig_defined_by_Typelist);
typedef DefineConfigByFlags<AllFlags>::Config AnotherConfig_defined_by_Typelist;

44
tests/library/meta/function-closure-test.cpp
View file

@ -142,8 +142,8 @@ namespace test {
check_signatureTypeManip ()
{
typedef int someFunc(Num<5>,Num<9>);
typedef FunctionSignature<function<someFunc> >::Ret RetType; // should be int
typedef FunctionSignature<function<someFunc> >::Args Args;
typedef FunctionSignature<function<someFunc>>::Ret RetType; // should be int
typedef FunctionSignature<function<someFunc>>::Args Args;
DISPLAY (Args);
typedef Prepend<Num<1>, Args>::Seq NewArgs; // manipulate the argument type(s)
@ -162,10 +162,10 @@ namespace test {
{
cout << "\t:\n\t: ---Apply---\n";
Tuple<Types<> > tup0 ;
Tuple<Types<int> > tup1 (11);
Tuple<Types<int,int> > tup2 (11,12);
Tuple<Types<int,int,int> > tup3 (11,12,13);
Tuple<Types<>> tup0 ;
Tuple<Types<int>> tup1 (11);
Tuple<Types<int,int>> tup2 (11,12);
Tuple<Types<int,int,int>> tup3 (11,12,13);
DUMPVAL (tup0);
DUMPVAL (tup1);
DUMPVAL (tup2);
@ -192,10 +192,10 @@ namespace test {
void
check_applyFunc ()
{
Tuple<Types<> > tup0 ;
Tuple<Types<int> > tup1 (11);
Tuple<Types<int,int> > tup2 (11,12);
Tuple<Types<int,int,int> > tup3 (11,12,13);
Tuple<Types<>> tup0 ;
Tuple<Types<int>> tup1 (11);
Tuple<Types<int,int>> tup2 (11,12);
Tuple<Types<int,int,int>> tup3 (11,12,13);
function<int()> functor0 (fun0);
function<int(int)> functor1 (fun1);
function<int(int,int)> functor2 (fun2);
@ -224,10 +224,10 @@ namespace test {
{
cout << "\t:\n\t: ---Bind----\n";
Tuple<Types<> > tup0 ;
Tuple<Types<int> > tup1 (11);
Tuple<Types<int,int> > tup2 (11,12);
Tuple<Types<int,int,int> > tup3 (11,12,13);
Tuple<Types<>> tup0 ;
Tuple<Types<int>> tup1 (11);
Tuple<Types<int,int>> tup2 (11,12);
Tuple<Types<int,int,int>> tup3 (11,12,13);
typedef function<int()> BoundFun;
@ -257,10 +257,10 @@ namespace test {
void
check_bindFunc ()
{
Tuple<Types<> > tup0 ;
Tuple<Types<int> > tup1 (11);
Tuple<Types<int,int> > tup2 (11,12);
Tuple<Types<int,int,int> > tup3 (11,12,13);
Tuple<Types<>> tup0 ;
Tuple<Types<int>> tup1 (11);
Tuple<Types<int,int>> tup2 (11,12);
Tuple<Types<int,int,int>> tup3 (11,12,13);
function<int()> unbound_functor0 (fun0);
function<int(int)> unbound_functor1 (fun1);
function<int(int,int)> unbound_functor2 (fun2);
@ -294,10 +294,10 @@ namespace test {
void
build_closure ()
{
Tuple<Types<> > tup0 ;
Tuple<Types<int> > tup1 (11);
Tuple<Types<int,int> > tup2 (11,12);
Tuple<Types<int,int,int> > tup3 (11,12,13);
Tuple<Types<>> tup0 ;
Tuple<Types<int>> tup1 (11);
Tuple<Types<int,int>> tup2 (11,12);
Tuple<Types<int,int,int>> tup3 (11,12,13);
FunctionClosure<int()> clo0 (fun0,tup0);
FunctionClosure<int(int)> clo1 (fun1,tup1);

6
tests/library/meta/function-composition-test.cpp
View file

@ -217,7 +217,7 @@ namespace test {
// Version3: let the PApply-template do the work for us--- //
typedef Types<Num<1> > ArgTypes; // now package just the argument(s) to be applied into a tuple
typedef Types<Num<1>> ArgTypes; // now package just the argument(s) to be applied into a tuple
Tuple<ArgTypes> args_to_bind (Num<1>(18));
fun_23 = PApply<Sig123, ArgTypes>::bindFront (f , args_to_bind);
@ -280,7 +280,7 @@ namespace test {
// covering the general case of partial function closure:
typedef Num<5> Sig54321(Num<5>, Num<4>, Num<3>, Num<2>, Num<1>); // Signature of the 5-argument function
typedef Num<5> Sig54 (Num<5>, Num<4>); // ...closing the last 3 arguments should yield this 2-argument function
typedef Types<Num<3>,Num<2>,Num<1> > Args2Close; // Tuple type to hold the 3 argument values used for the closure
typedef Types<Num<3>,Num<2>,Num<1>> Args2Close; // Tuple type to hold the 3 argument values used for the closure
// Close the trailing 3 arguments of the 5-argument function...
function<Sig54> fun_54 = PApply<Sig54321, Args2Close>::bindBack(fun15<5,4,3,2,1>,
@ -343,7 +343,7 @@ namespace test {
Sig15& f = fun15<1,2,3,4,5>;
SigA5& f5 = fun11<5>;
Tuple<Types<char> > argT(55);
Tuple<Types<char>> argT(55);
function<SigR1> f_bound_1 = BindToArgument<Sig15,char,0>::reduced (f, argT);
function<SigR2> f_bound_2 = BindToArgument<Sig15,char,1>::reduced (f, argT);

2
tests/library/meta/generator-test.cpp
View file

@ -131,7 +131,7 @@ namespace test {
me_can_has_more_numberz.eat (b2);
me_can_has_more_numberz.eat (b5);
TakeIt<Block<13> >& subInterface = me_can_has_more_numberz;
TakeIt<Block<13>>& subInterface = me_can_has_more_numberz;
subInterface.eat (b13);
me_can_has_more_numberz.eat();

6
tests/library/meta/tuple-helper-test.cpp
View file

@ -55,11 +55,11 @@ namespace test {
typedef Types< Num<1>
, Num<3>
, Num<5>
> Types1;
> Types1;
typedef Types< Num<2>
, Num<4>
> Types2;
typedef Types< Num<7> > Types3;
> Types2;
typedef Types< Num<7>> Types3;

6
tests/library/meta/typelist-diagnostics.hpp
View file

@ -88,9 +88,9 @@ namespace meta {
/** helper for generating test lists */
template<class X> struct CountDown { typedef NullType List; };
template<> struct CountDown<Num<0> > { typedef Node<Num<0>, NullType> List; };
template<int I> struct CountDown<Num<I> > { typedef Node<Num<I>, typename CountDown<Num<I-1> >::List> List; };
template<class X> struct CountDown { typedef NullType List; };
template<> struct CountDown<Num<0>> { typedef Node<Num<0>, NullType> List; };
template<int I> struct CountDown<Num<I>> { typedef Node<Num<I>, typename CountDown<Num<I-1>>::List> List; };

30
tests/library/meta/typelist-manip-test.cpp
View file

@ -153,13 +153,13 @@ namespace test {
typedef Append<NullType, NullType> Append1;
DISPLAY (Append1);
typedef Append<Num<11>,Num<22> > Append2;
typedef Append<Num<11>,Num<22>> Append2;
DISPLAY (Append2);
typedef Append<Num<111>,NullType> Append3;
DISPLAY (Append3);
typedef Append<NullType,Num<222> > Append4;
typedef Append<NullType,Num<222>> Append4;
DISPLAY (Append4);
typedef Append<List1,NullType> Append5;
@ -171,7 +171,7 @@ namespace test {
typedef Append<Num<111>,List2> Append7;
DISPLAY (Append7);
typedef Append<List1,Num<222> > Append8;
typedef Append<List1,Num<222>> Append8;
DISPLAY (Append8);
typedef Append<List1,List2> Append9;
@ -182,7 +182,7 @@ namespace test {
void
check_splice ()
{
typedef Types<Num<9>,Num<8> >::List OLi;
typedef Types<Num<9>,Num<8>>::List OLi;
// will "paste" the list OLi "on top" of another Typelist...
typedef Splice<NullType, NullType> Overl01;
@ -225,7 +225,7 @@ namespace test {
DISPLAY (Overl13);
typedef Types<Num<99> >::List OLi2;
typedef Types<Num<99>>::List OLi2;
typedef Splice<List1, OLi2, 0>::Front Front1;
typedef Splice<List1, OLi2, 1>::Front Front2;
typedef Splice<List1, OLi2, 5>::Front Front3;
@ -293,8 +293,8 @@ namespace test {
template<class X> struct AddConst2 { typedef X Type; };
template<int I> struct AddConst2<Num<I> > { typedef Num<I+2> Type; };
template<class X> struct AddConst2 { typedef X Type; };
template<int I> struct AddConst2<Num<I>> { typedef Num<I+2> Type; };
void
check_apply ()
@ -304,8 +304,8 @@ namespace test {
}
template<class X> struct IsEven { enum {value = false }; };
template<int I> struct IsEven<Num<I> > { enum {value = (0 == I % 2) }; };
template<class X> struct IsEven { enum {value = false }; };
template<int I> struct IsEven<Num<I>> { enum {value = (0 == I % 2) }; };
void
check_filter ()
@ -318,13 +318,13 @@ namespace test {
void
check_prefix ()
{
typedef PrefixAll<Num<11>,Num<22> > Prefix1;
typedef PrefixAll<Num<11>,Num<22>> Prefix1;
DISPLAY (Prefix1);
typedef PrefixAll<Num<101>,List1> Prefix2;
typedef PrefixAll<Num<101>,List1> Prefix2;
DISPLAY (Prefix2);
typedef PrefixAll<NullType,List1> Prefix3;
typedef PrefixAll<NullType,List1> Prefix3;
DISPLAY (Prefix3);
typedef Types<List1::List,Num<0>,List2::List>::List List_of_Lists;
@ -345,8 +345,8 @@ namespace test {
typedef Distribute<Num<11>, List1> Dist1;
DISPLAY (Dist1);
typedef Types<Num<11>,Num<22>,Num<33> >::List Prefixes;
typedef Distribute<Prefixes, Num<0> > Dist2;
typedef Types<Num<11>,Num<22>,Num<33>>::List Prefixes;
typedef Distribute<Prefixes, Num<0>> Dist2;
DISPLAY (Dist2);
typedef Distribute<Prefixes, List1> Dist3;
@ -360,7 +360,7 @@ namespace test {
void
check_combine()
{
typedef CountDown<Num<11> > Down;
typedef CountDown<Num<11>> Down;
DISPLAY (Down);
typedef Combine<List1::List, CountDown> Combi;

10
tests/library/multifact-singleton-test.cpp
View file

@ -78,10 +78,10 @@ namespace test{
TestFactory theFact;
// Configure the products to be fabricated....
TestFactory::Singleton<Implementation<ONE> > holder1 (theFact,ONE);
TestFactory::Singleton<Implementation<TWO> > holder2 (theFact,TWO);
TestFactory::Singleton<Implementation<THR> > holder3 (theFact,THR);
TestFactory::Singleton<Implementation<FOU> > holder4 (theFact,FOU);
TestFactory::Singleton<Implementation<ONE>> holder1{theFact,ONE};
TestFactory::Singleton<Implementation<TWO>> holder2{theFact,TWO};
TestFactory::Singleton<Implementation<THR>> holder3{theFact,THR};
TestFactory::Singleton<Implementation<FOU>> holder4{theFact,FOU};
}
@ -124,7 +124,7 @@ namespace test{
CHECK (isnil (anotherFact));
VERIFY_ERROR (INVALID, anotherFact(ONE) );
TestFactory::Singleton<Implementation<ONE> > anotherSingletonHolder (anotherFact,ONE);
TestFactory::Singleton<Implementation<ONE>> anotherSingletonHolder (anotherFact,ONE);
Interface & o3 = anotherFact(ONE);
CHECK (isSameObject(o2,o3));
}

6
tests/library/opaque-unchecked-buffer-test.cpp
View file

@ -137,7 +137,7 @@ namespace test{
_checksum = 0;
_create_count = 0;
{
typedef InPlaceBuffer<Base, sizeof(DD<42>), DD<0> > Buffer;
typedef InPlaceBuffer<Base, sizeof(DD<42>), DD<0>> Buffer;
Buffer buff;
CHECK (sizeof(buff) <= sizeof(DD<42>) + _ALIGN_);
@ -145,10 +145,10 @@ namespace test{
CHECK (0 == _checksum);
buff->confess(); // one default object of type DD<0> has been created
buff.create<DD<5> > ();
buff.create<DD<5>>();
buff->confess();
buff.create<DD<9> > ("I'm fine");
buff.create<DD<9>> ("I'm fine");
buff->confess();
VERIFY_ERROR( FATAL, buff.create<Killer> () );

10
tests/library/polymorphic-value-test.cpp
View file

@ -194,11 +194,11 @@ namespace test{
createOpaqueValues ()
{
TestList list;
list.push_back (PolyVal::build<Imp<1> > () );
list.push_back (PolyVal::build<Imp<11> > () );
list.push_back (PolyVal::build<Imp<111> >() );
list.push_back (PolyVal::build<Imp<23> > () );
list.push_back (PolyVal::build<Imp<5> > () );
list.push_back (PolyVal::build<Imp<1>> () );
list.push_back (PolyVal::build<Imp<11>> () );
list.push_back (PolyVal::build<Imp<111>>() );
list.push_back (PolyVal::build<Imp<23>> () );
list.push_back (PolyVal::build<Imp<5>> () );
return list;
} //note: copy

16
tests/library/simple-allocator-test.cpp
View file

@ -106,10 +106,10 @@ namespace test{
typedef DummyObj<23> * PD23;
CHECK (sizeof(DummyObj<1>) != sizeof(DummyObj<23>));
PD1 pD11 = allocator.create<DummyObj<1> >();
PD1 pD12 = allocator.create<DummyObj<1> >();
PD23 pD21 = allocator.create<DummyObj<23> >();
PD23 pD22 = allocator.create<DummyObj<23> >();
PD1 pD11 = allocator.create<DummyObj<1>>();
PD1 pD12 = allocator.create<DummyObj<1>>();
PD23 pD21 = allocator.create<DummyObj<23>>();
PD23 pD22 = allocator.create<DummyObj<23>>();
PS pS11 = allocator.create<string> ("Lumiera");
PS pS12 = allocator.create<string> ("the paradox");
@ -138,8 +138,8 @@ namespace test{
CHECK (*pS11 == "Lumiera");
CHECK (*pS12 == "the paradox");
PD23 pDxx = allocator.create<DummyObj<23> > (*pD21);
PS pSxx = allocator.create<string> (*pS12);
PD23 pDxx = allocator.create<DummyObj<23>> (*pD21);
PS pSxx = allocator.create<string> (*pS12);
CHECK (*pS12 == *pSxx);
CHECK (!isSameObject (*pS12, *pSxx));
@ -153,8 +153,8 @@ namespace test{
allocator.destroy (pDxx);
allocator.destroy (pSxx);
CHECK (0 == allocator.numSlots<DummyObj<1> >());
CHECK (0 == allocator.numSlots<DummyObj<23> >());
CHECK (0 == allocator.numSlots<DummyObj<1>>());
CHECK (0 == allocator.numSlots<DummyObj<23>>());
CHECK (0 == allocator.numSlots<string>());
CHECK (0 == checksum_);
}

2
tests/library/sub-id-test.cpp
View file

@ -142,7 +142,7 @@ namespace test{
template<class KEY>
struct HashTable
: std::unordered_map<KEY, string, hash<KEY> >
: std::unordered_map<KEY, string, hash<KEY>>
{
void
add (KEY key)

2
tests/library/symbol-hashtable-test.cpp
View file

@ -54,7 +54,7 @@ namespace test{
}
typedef std::unordered_map< Symbol, string, hash<Symbol> > HTable;
typedef std::unordered_map< Symbol, string, hash<Symbol>> HTable;
/*********************************************************//**

12
tests/library/typed-allocation-manager-test.cpp
View file

@ -90,15 +90,15 @@ namespace test{
TypedAllocationManager allocator;
typedef shared_ptr<DummyObj<1> > PD1;
typedef shared_ptr<DummyObj<22> > PD22;
typedef shared_ptr<DummyObj<1>> PD1;
typedef shared_ptr<DummyObj<22>> PD22;
CHECK (sizeof(DummyObj<1>) != sizeof(DummyObj<22>));
{
PD1 pD11 = allocator.create<DummyObj<1> >();
PD1 pD12 = allocator.create<DummyObj<1> >();
PD22 pD21 = allocator.create<DummyObj<22> >();
PD22 pD22 = allocator.create<DummyObj<22> >();
PD22 pD21 = allocator.create<DummyObj<22>>();
PD22 pD22 = allocator.create<DummyObj<22>>();
CHECK (pD11);
CHECK (pD12);
CHECK (pD21);
@ -121,13 +121,13 @@ namespace test{
CHECK (isSameObject (*pD21, *pD2x));
CHECK (2 == allocator.numSlots<DummyObj<1> >());
CHECK (2 == allocator.numSlots<DummyObj<22> >());
CHECK (2 == allocator.numSlots<DummyObj<22>>());
CHECK (0 == allocator.numSlots<long>()); // query just some unrelated type...
}
CHECK (0 == allocator.numSlots<DummyObj<1> >());
CHECK (0 == allocator.numSlots<DummyObj<22> >());
CHECK (0 == allocator.numSlots<DummyObj<22>>());
CHECK (0 == checksum_);
}
};