King_DuckZ/Loki
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

replace tabs with 4 spaces in all files

Browse source 
git-svn-id: svn://svn.code.sf.net/p/loki-lib/code/trunk@600 7ec92016-0320-0410-acc4-a06ded1c099a
This commit is contained in:
syntheticpp 2006-03-08 17:07:20 +00:00
parent 5b77cc6de3
commit d72b2ff1b3
22 changed files with 554 additions and 545 deletions
Download patch file Download diff file Expand all files Collapse all files

4
include/loki/LokiExport.h
View file

@ -40,8 +40,8 @@
#if (defined(LOKI_MAKE_DLL) && defined(LOKI_DLL)) || \ #if (defined(LOKI_MAKE_DLL) && defined(LOKI_DLL)) || \
(defined(LOKI_MAKE_DLL) && defined(LOKI_STATIC)) || \ (defined(LOKI_MAKE_DLL) && defined(LOKI_STATIC)) || \
(defined(LOKI_DLL) && defined(LOKI_STATIC)) (defined(LOKI_DLL) && defined(LOKI_STATIC))
#error export macro error: you could not build AND use the library #error export macro error: you could not build AND use the library
#endif #endif

157
include/loki/Pimpl.h
View file

@ -27,73 +27,73 @@
namespace Loki namespace Loki
{ {
////////////////////////////////////////// //////////////////////////////////////////
/// \class ConstPropPtr /// \class ConstPropPtr
/// ///
/// \ingroup PimplGroup /// \ingroup PimplGroup
/// Simple const propagating smart pointer /// Simple const propagating smart pointer
/// Is the default smart pointer of Pimpl. /// Is the default smart pointer of Pimpl.
////////////////////////////////////////// //////////////////////////////////////////
template<class T> template<class T>
struct ConstPropPtr struct ConstPropPtr
{ {
explicit ConstPropPtr(T* p) : ptr_(p) {} explicit ConstPropPtr(T* p) : ptr_(p) {}
~ConstPropPtr() { delete ptr_; ptr_ = 0; } ~ConstPropPtr() { delete ptr_; ptr_ = 0; }
T* operator->() { return ptr_; } T* operator->() { return ptr_; }
T& operator*() { return *ptr_; } T& operator*() { return *ptr_; }
const T* operator->() const { return ptr_; } const T* operator->() const { return ptr_; }
const T& operator*() const { return *ptr_; } const T& operator*() const { return *ptr_; }
private: private:
ConstPropPtr(); ConstPropPtr();
ConstPropPtr(const ConstPropPtr&); ConstPropPtr(const ConstPropPtr&);
ConstPropPtr& operator=(const ConstPropPtr&); ConstPropPtr& operator=(const ConstPropPtr&);
T* ptr_; T* ptr_;
}; };
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/// \class Pimpl /// \class Pimpl
/// ///
/// \ingroup PimplGroup /// \ingroup PimplGroup
/// ///
/// Implements the Pimpl idiom. It's a wrapper for a smart pointer which /// Implements the Pimpl idiom. It's a wrapper for a smart pointer which
/// automatically creates and deletes the implementation object and adds /// automatically creates and deletes the implementation object and adds
/// const propagation to the smart pointer. /// const propagation to the smart pointer.
/// ///
/// \par Usage /// \par Usage
/// see test/Pimpl /// see test/Pimpl
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
template template
< <
class T, class T,
typename Pointer = ConstPropPtr<T> typename Pointer = ConstPropPtr<T>
> >
class Pimpl class Pimpl
{ {
public: public:
typedef T Impl; typedef T Impl;
Pimpl() : ptr_(new T) Pimpl() : ptr_(new T)
{} {}
~Pimpl() ~Pimpl()
{ {
// Don't compile with incomplete type // Don't compile with incomplete type
// //
// If compilation brakes here make sure // If compilation brakes here make sure
// the compiler does not auto-generate the // the compiler does not auto-generate the
// destructor of the class hosting the pimpl: // destructor of the class hosting the pimpl:
// - implement the destructor of the class // - implement the destructor of the class
// - don't inline the destructor // - don't inline the destructor
typedef char T_must_be_defined[sizeof(T) ? 1 : -1 ]; typedef char T_must_be_defined[sizeof(T) ? 1 : -1 ];
} }
T* operator->() T* operator->()
{ {
return ptr_.operator->(); return ptr_.operator->();
} }
@ -113,22 +113,22 @@ namespace Loki
return ptr_.operator*(); return ptr_.operator*();
} }
Pointer& wrapped() Pointer& wrapped()
{ {
return ptr_; return ptr_;
} }
const Pointer& wrapped() const const Pointer& wrapped() const
{ {
return ptr_; return ptr_;
} }
private: private:
Pimpl(const Pimpl&); Pimpl(const Pimpl&);
Pimpl& operator=(const Pimpl&); Pimpl& operator=(const Pimpl&);
Pointer ptr_; Pointer ptr_;
}; };
@ -139,55 +139,55 @@ namespace Loki
}; };
////////////////////////////////////////// //////////////////////////////////////////
/// \class ImplT /// \class ImplT
/// ///
/// \ingroup PimplGroup /// \ingroup PimplGroup
/// Convenience template for the /// Convenience template for the
/// implementations which PimplT points to. /// implementations which PimplT points to.
////////////////////////////////////////// //////////////////////////////////////////
template<class T> template<class T>
struct ImplT; struct ImplT;
////////////////////////////////////////// //////////////////////////////////////////
/// \class PImplT /// \class PImplT
/// ///
/// \ingroup PimplGroup /// \ingroup PimplGroup
/// Convenience template which uses ImplT /// Convenience template which uses ImplT
/// as implementation structure /// as implementation structure
////////////////////////////////////////// //////////////////////////////////////////
template<class T, template<class> class Ptr = ConstPropPtr> template<class T, template<class> class Ptr = ConstPropPtr>
struct PimplT struct PimplT
{ {
typedef T Impl; typedef T Impl;
// declare pimpl // declare pimpl
typedef Pimpl<ImplT<T>, Ptr<ImplT<T> > > Type; typedef Pimpl<ImplT<T>, Ptr<ImplT<T> > > Type;
// inherit pimpl // inherit pimpl
typedef PimplOwner<ImplT<T>, Ptr<ImplT<T> > > Owner; typedef PimplOwner<ImplT<T>, Ptr<ImplT<T> > > Owner;
}; };
template<class T, class UsedPimpl = typename PimplT<T>::Type > template<class T, class UsedPimpl = typename PimplT<T>::Type >
struct RimplT struct RimplT
{ {
typedef typename UsedPimpl::Impl & Type; typedef typename UsedPimpl::Impl & Type;
class Owner class Owner
{ {
UsedPimpl pimpl; UsedPimpl pimpl;
public: public:
Owner() : LOKI_INHERITED_RIMPL_NAME(*pimpl) Owner() : LOKI_INHERITED_RIMPL_NAME(*pimpl)
{} {}
Type LOKI_INHERITED_RIMPL_NAME; Type LOKI_INHERITED_RIMPL_NAME;
}; };
}; };
@ -196,6 +196,9 @@ namespace Loki
#endif #endif
// $Log$ // $Log$
// Revision 1.19 2006/03/08 17:07:11 syntheticpp
// replace tabs with 4 spaces in all files
//
// Revision 1.18 2006/03/08 16:39:27 syntheticpp // Revision 1.18 2006/03/08 16:39:27 syntheticpp
// add documenation // add documenation
// //

2
include/loki/RefToValue.h
View file

@ -49,7 +49,7 @@ namespace Loki
}; };
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/// \function ByRef /// \function ByRef
/// ///
/// \ingroup ExceptionGroup /// \ingroup ExceptionGroup

144
include/loki/Register.h
View file

@ -22,98 +22,98 @@
namespace Loki namespace Loki
{ {
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// //
// Helper classes/functions for RegisterByCreateSet // Helper classes/functions for RegisterByCreateSet
// //
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/// \ingroup Register /// \ingroup Register
/// Must be specialized be the user /// Must be specialized be the user
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
template<class t> bool RegisterFunction(); template<class t> bool RegisterFunction();
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/// \ingroup Register /// \ingroup Register
/// Must be specialized be the user /// Must be specialized be the user
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
template<class t> bool UnRegisterFunction(); template<class t> bool UnRegisterFunction();
namespace Private namespace Private
{ {
template<class T> template<class T>
struct RegisterOnCreate struct RegisterOnCreate
{ {
RegisterOnCreate() { RegisterFunction<T>(); } RegisterOnCreate() { RegisterFunction<T>(); }
}; };
template<class T> template<class T>
struct UnRegisterOnDelete struct UnRegisterOnDelete
{ {
~UnRegisterOnDelete() { UnRegisterFunction<T>(); } ~UnRegisterOnDelete() { UnRegisterFunction<T>(); }
}; };
template<class T> template<class T>
struct RegisterOnCreateElement struct RegisterOnCreateElement
{ {
RegisterOnCreate<T> registerObj; RegisterOnCreate<T> registerObj;
}; };
template<class T> template<class T>
struct UnRegisterOnDeleteElement struct UnRegisterOnDeleteElement
{ {
UnRegisterOnDelete<T> unregisterObj; UnRegisterOnDelete<T> unregisterObj;
}; };
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/// \class RegisterOnCreateSet /// \class RegisterOnCreateSet
/// ///
/// \ingroup Register /// \ingroup Register
/// Implements a generic register class which registers classes of a typelist /// Implements a generic register class which registers classes of a typelist
/// ///
/// \par Usage /// \par Usage
/// see test/Register /// see test/Register
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
template<typename ElementList> template<typename ElementList>
struct RegisterOnCreateSet struct RegisterOnCreateSet
: GenScatterHierarchy<ElementList, Private::RegisterOnCreateElement> : GenScatterHierarchy<ElementList, Private::RegisterOnCreateElement>
{}; {};
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/// \class UnRegisterOnDeleteSet /// \class UnRegisterOnDeleteSet
/// ///
/// \ingroup Register /// \ingroup Register
/// Implements a generic register class which unregisters classes of a typelist /// Implements a generic register class which unregisters classes of a typelist
/// ///
/// \par Usage /// \par Usage
/// see test/Register /// see test/Register
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
template<typename ElementList> template<typename ElementList>
struct UnRegisterOnDeleteSet struct UnRegisterOnDeleteSet
: GenScatterHierarchy<ElementList, Private::UnRegisterOnDeleteElement> : GenScatterHierarchy<ElementList, Private::UnRegisterOnDeleteElement>
{}; {};
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/// \def LOKI_CHECK_CLASS_IN_LIST( CLASS , LIST ) /// \def LOKI_CHECK_CLASS_IN_LIST( CLASS , LIST )
/// ///
/// \ingroup Register /// \ingroup Register
/// Check if CLASS is in the typelist LIST. /// Check if CLASS is in the typelist LIST.
/// ///
/// \par Usage /// \par Usage
/// see test/Register /// see test/Register
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#define LOKI_CHECK_CLASS_IN_LIST( CLASS , LIST ) \ #define LOKI_CHECK_CLASS_IN_LIST( CLASS , LIST ) \
\ \
struct Loki_##CLASS##LIST_OK{typedef int class_##CLASS##_is_not_in_##LIST;};\ struct Loki_##CLASS##LIST_OK{typedef int class_##CLASS##_is_not_in_##LIST;};\
typedef Loki::Select<Loki::TL::IndexOf<LIST, CLASS>::value == -1, \ typedef Loki::Select<Loki::TL::IndexOf<LIST, CLASS>::value == -1, \
CLASS,Loki_##CLASS##LIST_OK >::Result IsInList##CLASS##LIST; \ CLASS,Loki_##CLASS##LIST_OK >::Result IsInList##CLASS##LIST; \
typedef IsInList##CLASS##LIST::class_##CLASS##_is_not_in_##LIST \ typedef IsInList##CLASS##LIST::class_##CLASS##_is_not_in_##LIST \
isInListTest##CLASS##LIST; isInListTest##CLASS##LIST;
} // namespace Loki } // namespace Loki

17
include/loki/SmallObj.h
View file

@ -218,7 +218,7 @@ namespace Loki
std::size_t maxSmallObjectSize = LOKI_MAX_SMALL_OBJECT_SIZE, std::size_t maxSmallObjectSize = LOKI_MAX_SMALL_OBJECT_SIZE,
std::size_t objectAlignSize = LOKI_DEFAULT_OBJECT_ALIGNMENT, std::size_t objectAlignSize = LOKI_DEFAULT_OBJECT_ALIGNMENT,
template <class> class LifetimePolicy = LOKI_DEFAULT_SMALLOBJ_LIFETIME, template <class> class LifetimePolicy = LOKI_DEFAULT_SMALLOBJ_LIFETIME,
class MutexPolicy = LOKI_DEFAULT_MUTEX class MutexPolicy = LOKI_DEFAULT_MUTEX
> >
class AllocatorSingleton : public SmallObjAllocator class AllocatorSingleton : public SmallObjAllocator
{ {
@ -283,7 +283,7 @@ namespace Loki
std::size_t MSOS, std::size_t MSOS,
std::size_t OAS, std::size_t OAS,
template <class> class LP, template <class> class LP,
class MX class MX
> >
void AllocatorSingleton< TM, CS, MSOS, OAS, LP, MX >::ClearExtraMemory( void ) void AllocatorSingleton< TM, CS, MSOS, OAS, LP, MX >::ClearExtraMemory( void )
{ {
@ -299,7 +299,7 @@ namespace Loki
std::size_t MSOS, std::size_t MSOS,
std::size_t OAS, std::size_t OAS,
template <class> class LP, template <class> class LP,
class MX class MX
> >
bool AllocatorSingleton< TM, CS, MSOS, OAS, LP, MX >::IsCorrupted( void ) bool AllocatorSingleton< TM, CS, MSOS, OAS, LP, MX >::IsCorrupted( void )
{ {
@ -327,7 +327,7 @@ namespace Loki
std::size_t MSOS, std::size_t MSOS,
std::size_t OAS, std::size_t OAS,
template <class> class LP, template <class> class LP,
class MX class MX
> >
inline unsigned int GetLongevity( inline unsigned int GetLongevity(
AllocatorSingleton< TM, CS, MSOS, OAS, LP, MX > * ) AllocatorSingleton< TM, CS, MSOS, OAS, LP, MX > * )
@ -421,7 +421,7 @@ namespace Loki
std::size_t maxSmallObjectSize, std::size_t maxSmallObjectSize,
std::size_t objectAlignSize, std::size_t objectAlignSize,
template <class> class LifetimePolicy, template <class> class LifetimePolicy,
class MutexPolicy class MutexPolicy
> >
class SmallObjectBase class SmallObjectBase
{ {
@ -578,7 +578,7 @@ namespace Loki
std::size_t maxSmallObjectSize = LOKI_MAX_SMALL_OBJECT_SIZE, std::size_t maxSmallObjectSize = LOKI_MAX_SMALL_OBJECT_SIZE,
std::size_t objectAlignSize = LOKI_DEFAULT_OBJECT_ALIGNMENT, std::size_t objectAlignSize = LOKI_DEFAULT_OBJECT_ALIGNMENT,
template <class> class LifetimePolicy = LOKI_DEFAULT_SMALLOBJ_LIFETIME, template <class> class LifetimePolicy = LOKI_DEFAULT_SMALLOBJ_LIFETIME,
class MutexPolicy = LOKI_DEFAULT_MUTEX class MutexPolicy = LOKI_DEFAULT_MUTEX
> >
class SmallObject : public SmallObjectBase< ThreadingModel, chunkSize, class SmallObject : public SmallObjectBase< ThreadingModel, chunkSize,
maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
@ -614,7 +614,7 @@ namespace Loki
std::size_t maxSmallObjectSize = LOKI_MAX_SMALL_OBJECT_SIZE, std::size_t maxSmallObjectSize = LOKI_MAX_SMALL_OBJECT_SIZE,
std::size_t objectAlignSize = LOKI_DEFAULT_OBJECT_ALIGNMENT, std::size_t objectAlignSize = LOKI_DEFAULT_OBJECT_ALIGNMENT,
template <class> class LifetimePolicy = LOKI_DEFAULT_SMALLOBJ_LIFETIME, template <class> class LifetimePolicy = LOKI_DEFAULT_SMALLOBJ_LIFETIME,
class MutexPolicy = LOKI_DEFAULT_MUTEX class MutexPolicy = LOKI_DEFAULT_MUTEX
> >
class SmallValueObject : public SmallObjectBase< ThreadingModel, chunkSize, class SmallValueObject : public SmallObjectBase< ThreadingModel, chunkSize,
maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy > maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
@ -634,6 +634,9 @@ namespace Loki
// Nov. 26, 2004: re-implemented by Rich Sposato. // Nov. 26, 2004: re-implemented by Rich Sposato.
// //
// $Log$ // $Log$
// Revision 1.29 2006/03/08 17:07:11 syntheticpp
// replace tabs with 4 spaces in all files
//
// Revision 1.28 2006/02/27 19:59:20 syntheticpp // Revision 1.28 2006/02/27 19:59:20 syntheticpp
// add support of loki.dll // add support of loki.dll
// //

7
include/loki/SmartPtr.h
View file

@ -793,7 +793,7 @@ namespace Loki
class ConversionPolicy = DisallowConversion, class ConversionPolicy = DisallowConversion,
template <class> class CheckingPolicy = AssertCheck, template <class> class CheckingPolicy = AssertCheck,
template <class> class StoragePolicy = DefaultSPStorage, template <class> class StoragePolicy = DefaultSPStorage,
template<class> class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS template<class> class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS
> >
struct SmartPtrDef struct SmartPtrDef
{ {
@ -804,7 +804,7 @@ namespace Loki
ConversionPolicy, ConversionPolicy,
CheckingPolicy, CheckingPolicy,
StoragePolicy, StoragePolicy,
ConstnessPolicy ConstnessPolicy
> >
type; type;
}; };
@ -1362,6 +1362,9 @@ namespace std
#endif // SMARTPTR_INC_ #endif // SMARTPTR_INC_
// $Log$ // $Log$
// Revision 1.24 2006/03/08 17:07:11 syntheticpp
// replace tabs with 4 spaces in all files
//
// Revision 1.23 2006/02/28 16:55:56 syntheticpp // Revision 1.23 2006/02/28 16:55:56 syntheticpp
// undo disabling checking, remove warnings, many thanks to Sam Miller // undo disabling checking, remove warnings, many thanks to Sam Miller
// //

8
include/loki/flex/allocatorstringstorage.h
View file

@ -234,9 +234,9 @@ public:
template <class ForwardIterator> template <class ForwardIterator>
void append(ForwardIterator b, ForwardIterator e) void append(ForwardIterator b, ForwardIterator e)
{ {
const size_type const size_type
sz = std::distance(b, e), sz = std::distance(b, e),
neededCapacity = size() + sz; neededCapacity = size() + sz;
if (capacity() < neededCapacity) if (capacity() < neededCapacity)
{ {
@ -245,7 +245,7 @@ public:
assert(!(le(begin(), &*b) && le(&*b, end()))); assert(!(le(begin(), &*b) && le(&*b, end())));
reserve(neededCapacity); reserve(neededCapacity);
} }
std::copy(b, e, end()); std::copy(b, e, end());
pData_->pEnd_ += sz; pData_->pEnd_ += sz;
} }

14
include/loki/flex/flex_string_details.h
View file

@ -19,13 +19,13 @@ namespace flex_string_details
{ {
template <class InIt, class OutIt> template <class InIt, class OutIt>
OutIt copy_n(InIt b, typename std::iterator_traits<InIt>::difference_type n, OutIt d) OutIt copy_n(InIt b, typename std::iterator_traits<InIt>::difference_type n, OutIt d)
{ {
for (; n != 0; --n, ++b, ++d) for (; n != 0; --n, ++b, ++d)
{ {
*d = *b; *d = *b;
} }
return d; return d;
} }
template <class Pod, class T> template <class Pod, class T>
inline void pod_fill(Pod* b, Pod* e, T c) inline void pod_fill(Pod* b, Pod* e, T c)

444
include/loki/flex/flex_string_shell.h
View file

@ -170,7 +170,7 @@ class flex_string : private Storage
struct Invariant struct Invariant
{ {
#ifndef NDEBUG #ifndef NDEBUG
Invariant(const flex_string& s) : s_(s) Invariant(const flex_string& s) : s_(s)
{ {
assert(s_.Sane()); assert(s_.Sane());
} }
@ -181,7 +181,7 @@ class flex_string : private Storage
private: private:
const flex_string& s_; const flex_string& s_;
#else #else
Invariant(const flex_string&) {} Invariant(const flex_string&) {}
#endif #endif
Invariant& operator=(const Invariant&); Invariant& operator=(const Invariant&);
}; };
@ -218,7 +218,7 @@ private:
static size_type Min(size_type lhs, size_type rhs) static size_type Min(size_type lhs, size_type rhs)
{ return lhs < rhs ? lhs : rhs; } { return lhs < rhs ? lhs : rhs; }
static void Procust(size_type& n, size_type nmax) static void Procust(size_type& n, size_type nmax)
{ if (n > nmax) n = nmax; } { if (n > nmax) n = nmax; }
public: public:
// 21.3.1 construct/copy/destroy // 21.3.1 construct/copy/destroy
@ -362,7 +362,7 @@ public:
flex_string& operator+=(const value_type c) flex_string& operator+=(const value_type c)
{ {
push_back(c); push_back(c);
return *this; return *this;
} }
@ -374,21 +374,21 @@ public:
{ {
const size_type sz = str.size(); const size_type sz = str.size();
Enforce(pos <= sz, static_cast<std::out_of_range*>(0), ""); Enforce(pos <= sz, static_cast<std::out_of_range*>(0), "");
Procust(n, sz - pos); Procust(n, sz - pos);
return append(str.data() + pos, n); return append(str.data() + pos, n);
} }
flex_string& append(const value_type* s, const size_type n) flex_string& append(const value_type* s, const size_type n)
{ {
Invariant checker(*this); Invariant checker(*this);
(void) checker; (void) checker;
static std::less_equal<const value_type*> le; static std::less_equal<const value_type*> le;
if (le(&*begin(), s) && le(s, &*end())) // aliasing if (le(&*begin(), s) && le(s, &*end())) // aliasing
{ {
const size_type offset = s - &*begin(); const size_type offset = s - &*begin();
Storage::reserve(size() + n); Storage::reserve(size() + n);
s = &*begin() + offset; s = &*begin() + offset;
} }
Storage::append(s, s + n); Storage::append(s, s + n);
return *this; return *this;
} }
@ -405,7 +405,7 @@ public:
template<class InputIterator> template<class InputIterator>
flex_string& append(InputIterator first, InputIterator last) flex_string& append(InputIterator first, InputIterator last)
{ {
insert(end(), first, last); insert(end(), first, last);
return *this; return *this;
} }
@ -416,7 +416,7 @@ public:
{ {
reserve(cap << 1u); reserve(cap << 1u);
} }
Storage::append(&c, &c + 1); Storage::append(&c, &c + 1);
} }
flex_string& assign(const flex_string& str) flex_string& assign(const flex_string& str)
@ -428,25 +428,25 @@ public:
flex_string& assign(const flex_string& str, const size_type pos, flex_string& assign(const flex_string& str, const size_type pos,
size_type n) size_type n)
{ {
const size_type sz = str.size(); const size_type sz = str.size();
Enforce(pos <= sz, static_cast<std::out_of_range*>(0), ""); Enforce(pos <= sz, static_cast<std::out_of_range*>(0), "");
Procust(n, sz - pos); Procust(n, sz - pos);
return assign(str.data() + pos, n); return assign(str.data() + pos, n);
} }
flex_string& assign(const value_type* s, const size_type n) flex_string& assign(const value_type* s, const size_type n)
{ {
Invariant checker(*this); Invariant checker(*this);
(void) checker; (void) checker;
if (size() >= n) if (size() >= n)
{ {
std::copy(s, s + n, begin()); std::copy(s, s + n, begin());
resize(n); resize(n);
} }
else else
{ {
const value_type *const s2 = s + size(); const value_type *const s2 = s + size();
std::copy(s, s2, begin()); std::copy(s, s2, begin());
append(s2, n - size()); append(s2, n - size());
} }
return *this; return *this;
@ -466,16 +466,16 @@ public:
size_type pos2, size_type n) size_type pos2, size_type n)
{ {
Enforce(pos2 <= str.length(), static_cast<std::out_of_range*>(0), ""); Enforce(pos2 <= str.length(), static_cast<std::out_of_range*>(0), "");
Procust(n, str.length() - pos2); Procust(n, str.length() - pos2);
return insert(pos1, str.data() + pos2, n); return insert(pos1, str.data() + pos2, n);
} }
flex_string& insert(size_type pos, const value_type* s, size_type n) flex_string& insert(size_type pos, const value_type* s, size_type n)
{ {
Enforce(pos <= length(), static_cast<std::out_of_range*>(0), ""); Enforce(pos <= length(), static_cast<std::out_of_range*>(0), "");
insert(begin() + pos, s, s + n); insert(begin() + pos, s, s + n);
return *this; return *this;
} }
flex_string& insert(size_type pos, const value_type* s) flex_string& insert(size_type pos, const value_type* s)
{ return insert(pos, s, traits_type::length(s)); } { return insert(pos, s, traits_type::length(s)); }
@ -483,13 +483,13 @@ public:
flex_string& insert(size_type pos, size_type n, value_type c) flex_string& insert(size_type pos, size_type n, value_type c)
{ {
Enforce(pos <= length(), static_cast<std::out_of_range*>(0), ""); Enforce(pos <= length(), static_cast<std::out_of_range*>(0), "");
insert(begin() + pos, n, c); insert(begin() + pos, n, c);
return *this; return *this;
} }
iterator insert(const iterator p, const value_type c) iterator insert(const iterator p, const value_type c)
{ {
const size_type pos = p - begin(); const size_type pos = p - begin();
insert(p, 1, c); insert(p, 1, c);
return begin() + pos; return begin() + pos;
} }
@ -500,122 +500,122 @@ private:
flex_string& InsertImplDiscr(iterator p, flex_string& InsertImplDiscr(iterator p,
size_type n, value_type c, Selector<1>) size_type n, value_type c, Selector<1>)
{ {
Invariant checker(*this); Invariant checker(*this);
(void) checker; (void) checker;
assert(p >= begin() && p <= end()); assert(p >= begin() && p <= end());
if (capacity() - size() < n) if (capacity() - size() < n)
{ {
const size_type sz = p - begin(); const size_type sz = p - begin();
reserve(size() + n); reserve(size() + n);
p = begin() + sz; p = begin() + sz;
} }
const iterator oldEnd = end(); const iterator oldEnd = end();
//if (p + n < oldEnd) // replaced because of crash (pk) //if (p + n < oldEnd) // replaced because of crash (pk)
if( n < size_type(oldEnd - p)) if( n < size_type(oldEnd - p))
{ {
append(oldEnd - n, oldEnd); append(oldEnd - n, oldEnd);
//std::copy( //std::copy(
// reverse_iterator(oldEnd - n), // reverse_iterator(oldEnd - n),
// reverse_iterator(p), // reverse_iterator(p),
// reverse_iterator(oldEnd)); // reverse_iterator(oldEnd));
flex_string_details::pod_move(&*p, &*oldEnd - n, &*p + n); flex_string_details::pod_move(&*p, &*oldEnd - n, &*p + n);
std::fill(p, p + n, c); std::fill(p, p + n, c);
} }
else else
{ {
append(n - (end() - p), c); append(n - (end() - p), c);
append(p, oldEnd); append(p, oldEnd);
std::fill(p, oldEnd, c); std::fill(p, oldEnd, c);
} }
return *this; return *this;
} }
template<class InputIterator> template<class InputIterator>
flex_string& InsertImplDiscr(iterator i, flex_string& InsertImplDiscr(iterator i,
InputIterator b, InputIterator e, Selector<0>) InputIterator b, InputIterator e, Selector<0>)
{ {
InsertImpl(i, b, e, InsertImpl(i, b, e,
typename std::iterator_traits<InputIterator>::iterator_category()); typename std::iterator_traits<InputIterator>::iterator_category());
return *this; return *this;
} }
template <class FwdIterator> template <class FwdIterator>
void InsertImpl(iterator i, void InsertImpl(iterator i,
FwdIterator s1, FwdIterator s2, std::forward_iterator_tag) FwdIterator s1, FwdIterator s2, std::forward_iterator_tag)
{ {
Invariant checker(*this); Invariant checker(*this);
(void) checker; (void) checker;
const size_type pos = i - begin(); const size_type pos = i - begin();
const typename std::iterator_traits<FwdIterator>::difference_type n2 = const typename std::iterator_traits<FwdIterator>::difference_type n2 =
std::distance(s1, s2); std::distance(s1, s2);
assert(n2 >= 0); assert(n2 >= 0);
using namespace flex_string_details; using namespace flex_string_details;
assert(pos <= size()); assert(pos <= size());
const typename std::iterator_traits<FwdIterator>::difference_type maxn2 = const typename std::iterator_traits<FwdIterator>::difference_type maxn2 =
capacity() - size(); capacity() - size();
if (maxn2 < n2) if (maxn2 < n2)
{ {
// realloc the string // realloc the string
static const std::less_equal<const value_type*> le = static const std::less_equal<const value_type*> le =
std::less_equal<const value_type*>(); std::less_equal<const value_type*>();
assert(!(le(&*begin(), &*s1) && le(&*s1, &*end()))); assert(!(le(&*begin(), &*s1) && le(&*s1, &*end())));
reserve(size() + n2); reserve(size() + n2);
i = begin() + pos; i = begin() + pos;
}
if (pos + n2 <= size())
{
//const iterator oldEnd = end();
//Storage::append(oldEnd - n2, n2);
//std::copy(i, oldEnd - n2, i + n2);
const iterator tailBegin = end() - n2;
Storage::append(tailBegin, tailBegin + n2);
//std::copy(i, tailBegin, i + n2);
std::copy(reverse_iterator(tailBegin), reverse_iterator(i),
reverse_iterator(tailBegin + n2));
std::copy(s1, s2, i);
}
else
{
FwdIterator t = s1;
const size_type old_size = size();
std::advance(t, old_size - pos);
assert(std::distance(t, s2) >= 0);
Storage::append(t, s2);
Storage::append(data() + pos, data() + old_size);
std::copy(s1, t, i);
} }
if (pos + n2 <= size())
{
//const iterator oldEnd = end();
//Storage::append(oldEnd - n2, n2);
//std::copy(i, oldEnd - n2, i + n2);
const iterator tailBegin = end() - n2;
Storage::append(tailBegin, tailBegin + n2);
//std::copy(i, tailBegin, i + n2);
std::copy(reverse_iterator(tailBegin), reverse_iterator(i),
reverse_iterator(tailBegin + n2));
std::copy(s1, s2, i);
}
else
{
FwdIterator t = s1;
const size_type old_size = size();
std::advance(t, old_size - pos);
assert(std::distance(t, s2) >= 0);
Storage::append(t, s2);
Storage::append(data() + pos, data() + old_size);
std::copy(s1, t, i);
}
} }
template <class InputIterator> template <class InputIterator>
void InsertImpl(iterator i1, iterator i2, void InsertImpl(iterator i1, iterator i2,
InputIterator b, InputIterator e, std::input_iterator_tag) InputIterator b, InputIterator e, std::input_iterator_tag)
{ {
flex_string temp(begin(), i1); flex_string temp(begin(), i1);
for (; b != e; ++b) for (; b != e; ++b)
{ {
temp.push_back(*b); temp.push_back(*b);
} }
temp.append(i2, end()); temp.append(i2, end());
swap(temp); swap(temp);
} }
public: public:
template <class ItOrLength, class ItOrChar> template <class ItOrLength, class ItOrChar>
void insert(iterator p, ItOrLength first_or_n, ItOrChar last_or_c) void insert(iterator p, ItOrLength first_or_n, ItOrChar last_or_c)
{ {
Selector<std::numeric_limits<ItOrLength>::is_specialized> sel; Selector<std::numeric_limits<ItOrLength>::is_specialized> sel;
InsertImplDiscr(p, first_or_n, last_or_c, sel); InsertImplDiscr(p, first_or_n, last_or_c, sel);
} }
flex_string& erase(size_type pos = 0, size_type n = npos) flex_string& erase(size_type pos = 0, size_type n = npos)
{ {
Invariant checker(*this); Invariant checker(*this);
(void) checker; (void) checker;
Enforce(pos <= length(), static_cast<std::out_of_range*>(0), ""); Enforce(pos <= length(), static_cast<std::out_of_range*>(0), "");
Procust(n, length() - pos); Procust(n, length() - pos);
std::copy(begin() + pos + n, end(), begin() + pos); std::copy(begin() + pos + n, end(), begin() + pos);
resize(length() - n); resize(length() - n);
return *this; return *this;
} }
@ -633,12 +633,12 @@ public:
return begin() + pos; return begin() + pos;
} }
// Replaces at most n1 chars of *this, starting with pos1 with the content of str // Replaces at most n1 chars of *this, starting with pos1 with the content of str
flex_string& replace(size_type pos1, size_type n1, const flex_string& str) flex_string& replace(size_type pos1, size_type n1, const flex_string& str)
{ return replace(pos1, n1, str.data(), str.size()); } { return replace(pos1, n1, str.data(), str.size()); }
// Replaces at most n1 chars of *this, starting with pos1, // Replaces at most n1 chars of *this, starting with pos1,
// with at most n2 chars of str starting with pos2 // with at most n2 chars of str starting with pos2
flex_string& replace(size_type pos1, size_type n1, const flex_string& str, flex_string& replace(size_type pos1, size_type n1, const flex_string& str,
size_type pos2, size_type n2) size_type pos2, size_type n2)
{ {
@ -648,34 +648,34 @@ public:
} }
/* /*
// Replaces at most n1 chars of *this, starting with pos, // Replaces at most n1 chars of *this, starting with pos,
// with at most n2 chars of str. // with at most n2 chars of str.
// str must have at least n2 chars. // str must have at least n2 chars.
flex_string& replace(const size_type pos, size_type n1, flex_string& replace(const size_type pos, size_type n1,
const value_type* s1, const size_type n2) const value_type* s1, const size_type n2)
{ {
Invariant checker(*this); Invariant checker(*this);
(void) checker; (void) checker;
Enforce(pos <= size(), (std::out_of_range*)0, ""); Enforce(pos <= size(), (std::out_of_range*)0, "");
Procust(n1, size() - pos); Procust(n1, size() - pos);
const iterator b = begin() + pos; const iterator b = begin() + pos;
return replace(b, b + n1, s1, s1 + n2); return replace(b, b + n1, s1, s1 + n2);
using namespace flex_string_details; using namespace flex_string_details;
const int delta = int(n2 - n1); const int delta = int(n2 - n1);
static const std::less_equal<const value_type*> le; static const std::less_equal<const value_type*> le;
const bool aliased = le(&*begin(), s1) && le(s1, &*end()); const bool aliased = le(&*begin(), s1) && le(s1, &*end());
// From here on we're dealing with an aliased replace // From here on we're dealing with an aliased replace
if (delta <= 0) if (delta <= 0)
{ {
// simple case, we're shrinking // simple case, we're shrinking
pod_move(s1, s1 + n2, &*begin() + pos); pod_move(s1, s1 + n2, &*begin() + pos);
pod_move(&*begin() + pos + n1, &*end(), &*begin() + pos + n1 + delta); pod_move(&*begin() + pos + n1, &*end(), &*begin() + pos + n1 + delta);
resize(size() + delta); resize(size() + delta);
return *this; return *this;
} }
// From here on we deal with aliased growth // From here on we deal with aliased growth
if (capacity() < size() + delta) if (capacity() < size() + delta)
{ {
// realloc the string // realloc the string
@ -726,25 +726,25 @@ public:
} }
*/ */
// Replaces at most n1 chars of *this, starting with pos, with chars from s // Replaces at most n1 chars of *this, starting with pos, with chars from s
flex_string& replace(size_type pos, size_type n1, const value_type* s) flex_string& replace(size_type pos, size_type n1, const value_type* s)
{ return replace(pos, n1, s, traits_type::length(s)); } { return replace(pos, n1, s, traits_type::length(s)); }
// Replaces at most n1 chars of *this, starting with pos, with n2 occurences of c // Replaces at most n1 chars of *this, starting with pos, with n2 occurences of c
// consolidated with // consolidated with
// Replaces at most n1 chars of *this, starting with pos, // Replaces at most n1 chars of *this, starting with pos,
// with at most n2 chars of str. // with at most n2 chars of str.
// str must have at least n2 chars. // str must have at least n2 chars.
template <class StrOrLength, class NumOrChar> template <class StrOrLength, class NumOrChar>
flex_string& replace(size_type pos, size_type n1, flex_string& replace(size_type pos, size_type n1,
StrOrLength s_or_n2, NumOrChar n_or_c) StrOrLength s_or_n2, NumOrChar n_or_c)
{ {
Invariant checker(*this); Invariant checker(*this);
(void) checker; (void) checker;
Enforce(pos <= size(), static_cast<std::out_of_range*>(0), ""); Enforce(pos <= size(), static_cast<std::out_of_range*>(0), "");
Procust(n1, length() - pos); Procust(n1, length() - pos);
const iterator b = begin() + pos; const iterator b = begin() + pos;
return replace(b, b + n1, s_or_n2, n_or_c); return replace(b, b + n1, s_or_n2, n_or_c);
} }
flex_string& replace(iterator i1, iterator i2, const flex_string& str) flex_string& replace(iterator i1, iterator i2, const flex_string& str)
@ -757,26 +757,26 @@ private:
flex_string& ReplaceImplDiscr(iterator i1, iterator i2, flex_string& ReplaceImplDiscr(iterator i1, iterator i2,
const value_type* s, size_type n, Selector<2>) const value_type* s, size_type n, Selector<2>)
{ {
assert(i1 <= i2); assert(i1 <= i2);
assert(begin() <= i1 && i1 <= end()); assert(begin() <= i1 && i1 <= end());
assert(begin() <= i2 && i2 <= end()); assert(begin() <= i2 && i2 <= end());
return replace(i1, i2, s, s + n); return replace(i1, i2, s, s + n);
} }
flex_string& ReplaceImplDiscr(iterator i1, iterator i2, flex_string& ReplaceImplDiscr(iterator i1, iterator i2,
size_type n2, value_type c, Selector<1>) size_type n2, value_type c, Selector<1>)
{ {
const size_type n1 = i2 - i1; const size_type n1 = i2 - i1;
if (n1 > n2) if (n1 > n2)
{ {
std::fill(i1, i1 + n2, c); std::fill(i1, i1 + n2, c);
erase(i1 + n2, i2); erase(i1 + n2, i2);
} }
else else
{ {
std::fill(i1, i2, c); std::fill(i1, i2, c);
insert(i2, n2 - n1, c); insert(i2, n2 - n1, c);
} }
return *this; return *this;
} }
@ -784,60 +784,60 @@ private:
flex_string& ReplaceImplDiscr(iterator i1, iterator i2, flex_string& ReplaceImplDiscr(iterator i1, iterator i2,
InputIterator b, InputIterator e, Selector<0>) InputIterator b, InputIterator e, Selector<0>)
{ {
ReplaceImpl(i1, i2, b, e, ReplaceImpl(i1, i2, b, e,
typename std::iterator_traits<InputIterator>::iterator_category()); typename std::iterator_traits<InputIterator>::iterator_category());
return *this; return *this;
} }
template <class FwdIterator> template <class FwdIterator>
void ReplaceImpl(iterator i1, iterator i2, void ReplaceImpl(iterator i1, iterator i2,
FwdIterator s1, FwdIterator s2, std::forward_iterator_tag) FwdIterator s1, FwdIterator s2, std::forward_iterator_tag)
{ {
Invariant checker(*this); Invariant checker(*this);
(void) checker; (void) checker;
const typename std::iterator_traits<iterator>::difference_type n1 = const typename std::iterator_traits<iterator>::difference_type n1 =
i2 - i1; i2 - i1;
assert(n1 >= 0); assert(n1 >= 0);
const typename std::iterator_traits<FwdIterator>::difference_type n2 = const typename std::iterator_traits<FwdIterator>::difference_type n2 =
std::distance(s1, s2); std::distance(s1, s2);
assert(n2 >= 0); assert(n2 >= 0);
// Handle aliased replace // Handle aliased replace
static const std::less_equal<const value_type*> le = static const std::less_equal<const value_type*> le =
std::less_equal<const value_type*>(); std::less_equal<const value_type*>();
const bool aliased = le(&*begin(), &*s1) && le(&*s1, &*end()); const bool aliased = le(&*begin(), &*s1) && le(&*s1, &*end());
if (aliased /* && capacity() < size() - n1 + n2 */) if (aliased /* && capacity() < size() - n1 + n2 */)
{ {
// Aliased replace, copy to new string // Aliased replace, copy to new string
flex_string temp; flex_string temp;
temp.reserve(size() - n1 + n2); temp.reserve(size() - n1 + n2);
temp.append(begin(), i1).append(s1, s2).append(i2, end()); temp.append(begin(), i1).append(s1, s2).append(i2, end());
swap(temp); swap(temp);
return; return;
} }
if (n1 > n2) if (n1 > n2)
{ {
// shrinks // shrinks
std::copy(s1, s2, i1); std::copy(s1, s2, i1);
erase(i1 + n2, i2); erase(i1 + n2, i2);
} }
else else
{ {
// grows // grows
flex_string_details::copy_n(s1, n1, i1); flex_string_details::copy_n(s1, n1, i1);
std::advance(s1, n1); std::advance(s1, n1);
insert(i2, s1, s2); insert(i2, s1, s2);
} }
} }
template <class InputIterator> template <class InputIterator>
void ReplaceImpl(iterator i1, iterator i2, void ReplaceImpl(iterator i1, iterator i2,
InputIterator b, InputIterator e, std::input_iterator_tag) InputIterator b, InputIterator e, std::input_iterator_tag)
{ {
flex_string temp(begin(), i1); flex_string temp(begin(), i1);
temp.append(b, e).append(i2, end()); temp.append(b, e).append(i2, end());
swap(temp); swap(temp);
} }
public: public:
@ -845,11 +845,11 @@ public:
flex_string& replace(iterator i1, iterator i2, flex_string& replace(iterator i1, iterator i2,
T1 first_or_n_or_s, T2 last_or_c_or_n) T1 first_or_n_or_s, T2 last_or_c_or_n)
{ {
const bool const bool
num1 = std::numeric_limits<T1>::is_specialized, num1 = std::numeric_limits<T1>::is_specialized,
num2 = std::numeric_limits<T2>::is_specialized; num2 = std::numeric_limits<T2>::is_specialized;
return ReplaceImplDiscr(i1, i2, first_or_n_or_s, last_or_c_or_n, return ReplaceImplDiscr(i1, i2, first_or_n_or_s, last_or_c_or_n,
Selector<num1 ? (num2 ? 1 : -1) : (num2 ? 2 : 0)>()); Selector<num1 ? (num2 ? 1 : -1) : (num2 ? 2 : 0)>());
} }
size_type copy(value_type* s, size_type n, size_type pos = 0) const size_type copy(value_type* s, size_type n, size_type pos = 0) const
@ -1051,36 +1051,36 @@ public:
} }
int compare(const flex_string& str) const int compare(const flex_string& str) const
{ {
// FIX due to Goncalo N M de Carvalho July 18, 2005 // FIX due to Goncalo N M de Carvalho July 18, 2005
return compare(0, size(), str); return compare(0, size(), str);
} }
int compare(size_type pos1, size_type n1, int compare(size_type pos1, size_type n1,
const flex_string& str) const const flex_string& str) const
{ return compare(pos1, n1, str.data(), str.size()); } { return compare(pos1, n1, str.data(), str.size()); }
// FIX to compare: added the TC // FIX to compare: added the TC
// (http://www.comeaucomputing.com/iso/lwg-defects.html number 5) // (http://www.comeaucomputing.com/iso/lwg-defects.html number 5)
// Thanks to Caleb Epstein for the fix // Thanks to Caleb Epstein for the fix
int compare(size_type pos1, size_type n1, int compare(size_type pos1, size_type n1,
const value_type* s) const const value_type* s) const
{ {
return compare(pos1, n1, s, traits_type::length(s)); return compare(pos1, n1, s, traits_type::length(s));
} }
int compare(size_type pos1, size_type n1, int compare(size_type pos1, size_type n1,
const value_type* s, size_type n2) const const value_type* s, size_type n2) const
{ {
Enforce(pos1 <= size(), static_cast<std::out_of_range*>(0), ""); Enforce(pos1 <= size(), static_cast<std::out_of_range*>(0), "");
Procust(n1, size() - pos1); Procust(n1, size() - pos1);
const int r = traits_type::compare(data(), s, Min(n1, n2)); const int r = traits_type::compare(data(), s, Min(n1, n2));
return return
r != 0 ? r : r != 0 ? r :
n1 > n2 ? 1 : n1 > n2 ? 1 :
n1 < n2 ? -1 : n1 < n2 ? -1 :
0; 0;
} }
int compare(size_type pos1, size_type n1, int compare(size_type pos1, size_type n1,
@ -1092,9 +1092,9 @@ public:
} }
int compare(const value_type* s) const int compare(const value_type* s) const
{ {
return traits_type::compare(data(), s, traits_type::length(s)); return traits_type::compare(data(), s, traits_type::length(s));
} }
}; };
// non-member functions // non-member functions
@ -1255,7 +1255,7 @@ std::basic_istream<typename flex_string<E, T, A, S>::value_type,
typename flex_string<E, T, A, S>::traits_type>& typename flex_string<E, T, A, S>::traits_type>&
operator>>( operator>>(
std::basic_istream<typename flex_string<E, T, A, S>::value_type, std::basic_istream<typename flex_string<E, T, A, S>::value_type,
typename flex_string<E, T, A, S>::traits_type>& is, typename flex_string<E, T, A, S>::traits_type>& is,
flex_string<E, T, A, S>& str); flex_string<E, T, A, S>& str);
template <typename E, class T, class A, class S> template <typename E, class T, class A, class S>
@ -1263,7 +1263,7 @@ std::basic_ostream<typename flex_string<E, T, A, S>::value_type,
typename flex_string<E, T, A, S>::traits_type>& typename flex_string<E, T, A, S>::traits_type>&
operator<<( operator<<(
std::basic_ostream<typename flex_string<E, T, A, S>::value_type, std::basic_ostream<typename flex_string<E, T, A, S>::value_type,
typename flex_string<E, T, A, S>::traits_type>& os, typename flex_string<E, T, A, S>::traits_type>& os,
const flex_string<E, T, A, S>& str) const flex_string<E, T, A, S>& str)
{ return os << str.c_str(); } { return os << str.c_str(); }

14
include/loki/flex/simplestringstorage.h
View file

@ -219,14 +219,14 @@ public:
template <class InputIterator> template <class InputIterator>
void append(InputIterator b, InputIterator e) void append(InputIterator b, InputIterator e)
{ {
const size_type const size_type
sz = std::distance(b, e), sz = std::distance(b, e),
neededCapacity = size() + sz; neededCapacity = size() + sz;
if (capacity() < neededCapacity) if (capacity() < neededCapacity)
{ {
static std::less_equal<const E*> le; static std::less_equal<const E*> le;
(void) le; (void) le;
assert(!(le(begin(), &*b) && le(&*b, end()))); // no aliasing assert(!(le(begin(), &*b) && le(&*b, end()))); // no aliasing
reserve(neededCapacity); reserve(neededCapacity);
} }
std::copy(b, e, end()); std::copy(b, e, end());
@ -274,7 +274,7 @@ SimpleStringStorage<E, A>::emptyString_;
//{ //{
// const_cast<E*>(SimpleStringStorage<E, A>::emptyString_.buffer_), // const_cast<E*>(SimpleStringStorage<E, A>::emptyString_.buffer_),
// const_cast<E*>(SimpleStringStorage<E, A>::emptyString_.buffer_), // const_cast<E*>(SimpleStringStorage<E, A>::emptyString_.buffer_),
// { E() } // { E() }
//}; //};

12
include/loki/flex/smallstringopt.h
View file

@ -97,7 +97,7 @@ private:
public: public:
enum { maxSmallString = enum { maxSmallString =
(temp2 + sizeof(value_type) - 1) / sizeof(value_type) }; (temp2 + sizeof(value_type) - 1) / sizeof(value_type) };
private: private:
enum { magic = maxSmallString + 1 }; enum { magic = maxSmallString + 1 };
@ -260,14 +260,14 @@ public:
else else
{ {
// append to a small string // append to a small string
const size_type const size_type
sz = std::distance(b, e), sz = std::distance(b, e),
neededCapacity = maxSmallString - buf_[maxSmallString] + sz; neededCapacity = maxSmallString - buf_[maxSmallString] + sz;
if (maxSmallString < neededCapacity) if (maxSmallString < neededCapacity)
{ {
// need to change storage strategy // need to change storage strategy
allocator_type alloc; allocator_type alloc;
Storage temp(alloc); Storage temp(alloc);
temp.reserve(neededCapacity); temp.reserve(neededCapacity);
temp.append(buf_, buf_ + maxSmallString - buf_[maxSmallString]); temp.append(buf_, buf_ + maxSmallString - buf_[maxSmallString]);
@ -278,7 +278,7 @@ public:
} }
else else
{ {
std::copy(b, e, buf_ + maxSmallString - buf_[maxSmallString]); std::copy(b, e, buf_ + maxSmallString - buf_[maxSmallString]);
buf_[maxSmallString] = buf_[maxSmallString] - value_type(sz); buf_[maxSmallString] = buf_[maxSmallString] - value_type(sz);
} }
} }

40
include/loki/flex/vectorstringstorage.h
View file

@ -137,32 +137,32 @@ public: // protected:
void reserve(size_type res_arg) void reserve(size_type res_arg)
{ {
assert(res_arg < max_size()); assert(res_arg < max_size());
base::reserve(res_arg + 1); base::reserve(res_arg + 1);
} }
template <class ForwardIterator> template <class ForwardIterator>
void append(ForwardIterator b, ForwardIterator e) void append(ForwardIterator b, ForwardIterator e)
{ {
const typename std::iterator_traits<ForwardIterator>::difference_type const typename std::iterator_traits<ForwardIterator>::difference_type
sz = std::distance(b, e); sz = std::distance(b, e);
assert(sz >= 0); assert(sz >= 0);
if (sz == 0) return; if (sz == 0) return;
base::reserve(base::size() + sz); base::reserve(base::size() + sz);
const value_type & v = *b; const value_type & v = *b;
struct OnBlockExit struct OnBlockExit
{ {
VectorStringStorage * that; VectorStringStorage * that;
~OnBlockExit() ~OnBlockExit()
{ {
that->base::push_back(value_type()); that->base::push_back(value_type());
} }
} onBlockExit = { this }; } onBlockExit = { this };
(void) onBlockExit; (void) onBlockExit;
assert(!base::empty()); assert(!base::empty());
assert(base::back() == value_type()); assert(base::back() == value_type());
base::back() = v; base::back() = v;
base::insert(base::end(), ++b, e); base::insert(base::end(), ++b, e);
} }
void resize(size_type n, E c) void resize(size_type n, E c)

166
include/loki/yasli/yasli_fill_iterator.h
View file

@ -10,10 +10,10 @@ namespace yasli_nstd
class fill_iterator_base class fill_iterator_base
: public std::iterator< : public std::iterator<
std::random_access_iterator_tag, std::random_access_iterator_tag,
T, T,
ptrdiff_t, ptrdiff_t,
T*, T*,
T&> T&>
{ {
}; };
@ -21,112 +21,112 @@ namespace yasli_nstd
class fill_iterator_base<T&> class fill_iterator_base<T&>
: public std::iterator< : public std::iterator<
std::random_access_iterator_tag, std::random_access_iterator_tag,
T, T,
ptrdiff_t, ptrdiff_t,
T*, T*,
T&> T&>
{ {
}; };
template <class T> template <class T>
class fill_iterator : public fill_iterator_base<T> class fill_iterator : public fill_iterator_base<T>
{ {
T value_; T value_;
/*difference_type*/ ptrdiff_t count_;////////////////////////////////// /*difference_type*/ ptrdiff_t count_;//////////////////////////////////
public: public:
typedef std::ptrdiff_t difference_type; typedef std::ptrdiff_t difference_type;
typedef typename fill_iterator_base<T>::pointer pointer; typedef typename fill_iterator_base<T>::pointer pointer;
typedef typename fill_iterator_base<T>::reference reference; typedef typename fill_iterator_base<T>::reference reference;
//typedef iterator_type; //typedef iterator_type;
fill_iterator() fill_iterator()
{
}
explicit fill_iterator(reference value, difference_type count = 0)
: value_(value), count_(count)
{
}
template<class U>
fill_iterator(const fill_iterator<U>& rhs)
: value_(rhs.value_), count_(rhs.count_)
{
}
reference operator*() const
{
return value_;
}
pointer operator->() const
{ {
return &**this; }
}
fill_iterator& operator++() explicit fill_iterator(reference value, difference_type count = 0)
{ : value_(value), count_(count)
{
}
template<class U>
fill_iterator(const fill_iterator<U>& rhs)
: value_(rhs.value_), count_(rhs.count_)
{
}
reference operator*() const
{
return value_;
}
pointer operator->() const
{
return &**this;
}
fill_iterator& operator++()
{
++count_; ++count_;
return *this; return *this;
} }
fill_iterator operator++(int) fill_iterator operator++(int)
{ {
fill_iterator it(*this); fill_iterator it(*this);
++*this; ++*this;
return it; return it;
} }
fill_iterator& operator--() fill_iterator& operator--()
{
--count_;
return *this;
}
fill_iterator operator--(int)
{ {
fill_iterator it(*this); --count_;
--*this; return *this;
return it;
} }
fill_iterator& operator+=(difference_type d) fill_iterator operator--(int)
{ {
count_ += d; fill_iterator it(*this);
return *this; --*this;
} return it;
}
fill_iterator operator+(difference_type d) const fill_iterator& operator+=(difference_type d)
{ {
return fill_iterator(*this) += d; count_ += d;
} return *this;
}
fill_iterator& operator-=(difference_type d) fill_iterator operator+(difference_type d) const
{ {
count_ -= d; return fill_iterator(*this) += d;
return *this; }
}
fill_iterator operator-(difference_type d) const fill_iterator& operator-=(difference_type d)
{ {
return fill_iterator(*this) -= d; count_ -= d;
} return *this;
}
fill_iterator operator-(difference_type d) const
{
return fill_iterator(*this) -= d;
}
difference_type operator-(const fill_iterator<T>& rhs) const difference_type operator-(const fill_iterator<T>& rhs) const
{ {
return count_ - rhs.count_; return count_ - rhs.count_;
} }
reference operator[](difference_type) const reference operator[](difference_type) const
{ {
return **this; return **this;
} }
template <class T2> template <class T2>
bool operator==(const fill_iterator<T2>& rhs) const bool operator==(const fill_iterator<T2>& rhs) const
{ {
return count_ == rhs.count_; return count_ == rhs.count_;
} }
}; };
@ -134,21 +134,21 @@ namespace yasli_nstd
template <class T, class D> template <class T, class D>
inline fill_iterator<T> operator+(D lhs, const fill_iterator<T>& rhs) inline fill_iterator<T> operator+(D lhs, const fill_iterator<T>& rhs)
{ {
return rhs + lhs; return rhs + lhs;
} }
template <class T> template <class T>
inline bool operator!=( inline bool operator!=(
const fill_iterator<T>& lhs, const fill_iterator<T>& lhs,
const fill_iterator<T>& rhs) const fill_iterator<T>& rhs)
{ // test for fill_iterator inequality { // test for fill_iterator inequality
return !(lhs == rhs); return !(lhs == rhs);
} }
template <class T> template <class T>
inline bool operator<( inline bool operator<(
const fill_iterator<T>& lhs, const fill_iterator<T>& lhs,
const fill_iterator<T>& rhs) const fill_iterator<T>& rhs)
{ {
return lhs.count_ < rhs.count_; return lhs.count_ < rhs.count_;
} }
@ -156,7 +156,7 @@ namespace yasli_nstd
template <class T> template <class T>
inline bool operator>( inline bool operator>(
const fill_iterator<T>& lhs, const fill_iterator<T>& lhs,
const fill_iterator<T>& rhs) const fill_iterator<T>& rhs)
{ {
return rhs < lhs; return rhs < lhs;
} }
@ -164,7 +164,7 @@ namespace yasli_nstd
template <class T> template <class T>
inline bool operator<=( inline bool operator<=(
const fill_iterator<T>& lhs, const fill_iterator<T>& lhs,
const fill_iterator<T>& rhs) const fill_iterator<T>& rhs)
{ {
return !(rhs < lhs); return !(rhs < lhs);
} }

4
include/loki/yasli/yasli_vector.h
View file

@ -316,13 +316,13 @@ namespace yasli {
} }
const_reference at(size_type n) const const_reference at(size_type n) const
{ {
// Fix by Joseph Canedo // Fix by Joseph Canedo
if (n >= size()) throw std::range_error("vector<>::at"); if (n >= size()) throw std::range_error("vector<>::at");
return ebo_.beg_[n]; return ebo_.beg_[n];
} }
reference at(size_type n) reference at(size_type n)
{ {
// Fix by Joseph Canedo // Fix by Joseph Canedo
if (n >= size()) throw std::range_error("vector<>::at"); if (n >= size()) throw std::range_error("vector<>::at");
return ebo_.beg_[n]; return ebo_.beg_[n];
} }

4
test/Pimpl/type.h
View file

@ -102,7 +102,7 @@ typedef std::auto_ptr<ImplT<E> > StdAutoPtr;
// Pimpl // Pimpl
typedef Pimpl<ImplT<E> > Pimpl1; typedef Pimpl<ImplT<E> > Pimpl1;
typedef Pimpl<ImplT<E>, CPropPtr> Pimpl2; typedef Pimpl<ImplT<E>, CPropPtr> Pimpl2;
typedef Pimpl<ImplT<E>, LokiPtr> Pimpl3; typedef Pimpl<ImplT<E>, LokiPtr> Pimpl3;
typedef Pimpl<ImplT<E>, BoostPtr> Pimpl4; typedef Pimpl<ImplT<E>, BoostPtr> Pimpl4;
@ -117,7 +117,7 @@ struct P5 {Pimpl5 d; P5();void f();void f()const;};
// PimplOwner // PimplOwner
typedef PimplOwner<ImplT<E> > PimplOwner1; typedef PimplOwner<ImplT<E> > PimplOwner1;
typedef PimplOwner<ImplT<E>, CPropPtr> PimplOwner2; typedef PimplOwner<ImplT<E>, CPropPtr> PimplOwner2;
typedef PimplOwner<ImplT<E>, LokiPtr> PimplOwner3; typedef PimplOwner<ImplT<E>, LokiPtr> PimplOwner3;
typedef PimplOwner<ImplT<E>, BoostPtr> PimplOwner4; typedef PimplOwner<ImplT<E>, BoostPtr> PimplOwner4;

18
test/Pimpl/type2.h
View file

@ -26,7 +26,7 @@ class A2
{ {
public: public:
A2(); A2();
~A2(); ~A2();
void foo(); void foo();
private: private:
@ -42,7 +42,7 @@ class B2 : private PimplT<B2>::Owner
{ {
public: public:
B2(); B2();
~B2(); ~B2();
void foo(); void foo();
}; };
@ -56,7 +56,7 @@ class C2
{ {
public: public:
C2(); C2();
~C2(); ~C2();
void foo(); void foo();
private: private:
@ -73,7 +73,7 @@ class D2 : private RimplT<D2>::Owner
{ {
public: public:
D2(); D2();
~D2(); ~D2();
void foo(); void foo();
}; };
@ -94,7 +94,7 @@ class Incomplete2
{ {
public: public:
Incomplete2(); Incomplete2();
~Incomplete2(); ~Incomplete2();
void foo(); void foo();
private: private:
PimplT<Incomplete2>::Type d; PimplT<Incomplete2>::Type d;
@ -108,10 +108,10 @@ class Incomplete3
{ {
public: public:
Incomplete3(); Incomplete3();
~Incomplete3() ~Incomplete3()
{ {
// inline destructor // inline destructor
} }
void foo(); void foo();
private: private:
PimplT<Incomplete3>::Type d; PimplT<Incomplete3>::Type d;

32
test/Register/foo.cpp
View file

@ -37,24 +37,24 @@ Base* createBoo(){ return new Boo; }
namespace Loki namespace Loki
{ {
template<> bool RegisterFunction<Foo>() template<> bool RegisterFunction<Foo>()
{ {
std::cout << "RegisterFunction<Foo>\n"; std::cout << "RegisterFunction<Foo>\n";
return registerClass("Foo", &createFoo); return registerClass("Foo", &createFoo);
} }
template<> bool RegisterFunction<Boo>() template<> bool RegisterFunction<Boo>()
{ {
std::cout << "RegisterFunction<Boo>\n"; std::cout << "RegisterFunction<Boo>\n";
return registerClass("Boo", &createBoo); return registerClass("Boo", &createBoo);
} }
template<> bool UnRegisterFunction<Foo>() template<> bool UnRegisterFunction<Foo>()
{ {
std::cout << "UnRegisterFunction<Foo>\n"; std::cout << "UnRegisterFunction<Foo>\n";
return true; return true;
} }
template<> bool UnRegisterFunction<Boo>() template<> bool UnRegisterFunction<Boo>()
{ {
std::cout << "UnRegisterFunction<Boo>\n"; std::cout << "UnRegisterFunction<Boo>\n";
return true; return true;
} }
} }

4
test/SingletonDll/foo_export.h
View file

@ -15,8 +15,8 @@
#include <loki/LokiExport.h> #include <loki/LokiExport.h>
#if (defined(FOO_MAKE_DLL) && defined(FOO_DLL)) || \ #if (defined(FOO_MAKE_DLL) && defined(FOO_DLL)) || \
(defined(FOO_MAKE_DLL) && defined(FOO_STATIC)) || \ (defined(FOO_MAKE_DLL) && defined(FOO_STATIC)) || \
(defined(FOO_DLL) && defined(FOO_STATIC)) (defined(FOO_DLL) && defined(FOO_STATIC))
#error export macro error: you could not build AND use the library #error export macro error: you could not build AND use the library
#endif #endif

4
test/SingletonDll/singletondll_export.h
View file

@ -15,8 +15,8 @@
#include <loki/LokiExport.h> #include <loki/LokiExport.h>
#if (defined(SINGLETONDLL_MAKE_DLL) && defined(SINGLETONDLL_DLL)) || \ #if (defined(SINGLETONDLL_MAKE_DLL) && defined(SINGLETONDLL_DLL)) || \
(defined(SINGLETONDLL_MAKE_DLL) && defined(SINGLETONDLL_STATIC)) || \ (defined(SINGLETONDLL_MAKE_DLL) && defined(SINGLETONDLL_STATIC)) || \
(defined(SINGLETONDLL_DLL) && defined(SINGLETONDLL_STATIC)) (defined(SINGLETONDLL_DLL) && defined(SINGLETONDLL_STATIC))
#error export macro error: you could not build AND use the library #error export macro error: you could not build AND use the library
#endif #endif