replace tabs with 4 spaces
git-svn-id: svn://svn.code.sf.net/p/loki-lib/code/trunk@680 7ec92016-0320-0410-acc4-a06ded1c099a
This commit is contained in:
syntheticpp
parent
963152efd4
commit
30f4e933c1
14 changed files with 298 additions and 283 deletions
|
|
@ -35,21 +35,21 @@ namespace Loki
|
|||
/// Is the default smart pointer of Pimpl.
|
||||
//////////////////////////////////////////
|
||||
|
||||
template<class T>
|
||||
struct ConstPropPtr
|
||||
template<class T>
|
||||
struct ConstPropPtr
|
||||
{
|
||||
explicit ConstPropPtr(T* p) : ptr_(p) {}
|
||||
explicit ConstPropPtr(T* p) : ptr_(p) {}
|
||||
~ConstPropPtr() { delete ptr_; ptr_ = 0; }
|
||||
T* operator->() { return ptr_; }
|
||||
T& operator*() { return *ptr_; }
|
||||
const T* operator->() const { return ptr_; }
|
||||
const T& operator*() const { return *ptr_; }
|
||||
T* operator->() { return ptr_; }
|
||||
T& operator*() { return *ptr_; }
|
||||
const T* operator->() const { return ptr_; }
|
||||
const T& operator*() const { return *ptr_; }
|
||||
|
||||
private:
|
||||
ConstPropPtr();
|
||||
ConstPropPtr(const ConstPropPtr&);
|
||||
ConstPropPtr& operator=(const ConstPropPtr&);
|
||||
T* ptr_;
|
||||
private:
|
||||
ConstPropPtr();
|
||||
ConstPropPtr(const ConstPropPtr&);
|
||||
ConstPropPtr& operator=(const ConstPropPtr&);
|
||||
T* ptr_;
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -66,18 +66,18 @@ namespace Loki
|
|||
/// see test/Pimpl
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
template
|
||||
template
|
||||
<
|
||||
class T,
|
||||
typename Pointer = ConstPropPtr<T>
|
||||
class T,
|
||||
typename Pointer = ConstPropPtr<T>
|
||||
>
|
||||
class Pimpl
|
||||
{
|
||||
public:
|
||||
|
||||
typedef T Impl;
|
||||
typedef T Impl;
|
||||
|
||||
Pimpl() : ptr_(new T)
|
||||
Pimpl() : ptr_(new T)
|
||||
{}
|
||||
|
||||
~Pimpl()
|
||||
|
|
@ -89,11 +89,11 @@ namespace Loki
|
|||
// destructor of the class hosting the pimpl:
|
||||
// - implement the destructor of the class
|
||||
// - 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->();
|
||||
}
|
||||
|
|
@ -113,26 +113,26 @@ namespace Loki
|
|||
return ptr_.operator*();
|
||||
}
|
||||
|
||||
Pointer& wrapped()
|
||||
Pointer& wrapped()
|
||||
{
|
||||
return ptr_;
|
||||
return ptr_;
|
||||
}
|
||||
|
||||
const Pointer& wrapped() const
|
||||
const Pointer& wrapped() const
|
||||
{
|
||||
return ptr_;
|
||||
return ptr_;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
Pimpl(const Pimpl&);
|
||||
Pimpl(const Pimpl&);
|
||||
Pimpl& operator=(const Pimpl&);
|
||||
|
||||
Pointer ptr_;
|
||||
Pointer ptr_;
|
||||
};
|
||||
|
||||
|
||||
template<class T, typename Pointer = ConstPropPtr<T> >
|
||||
template<class T, typename Pointer = ConstPropPtr<T> >
|
||||
struct PimplOwner
|
||||
{
|
||||
Pimpl<T,Pointer> LOKI_INHERITED_PIMPL_NAME;
|
||||
|
|
@ -163,7 +163,7 @@ namespace Loki
|
|||
template<class T, template<class> class Ptr = ConstPropPtr>
|
||||
struct PimplT
|
||||
{
|
||||
typedef T Impl;
|
||||
typedef T Impl;
|
||||
|
||||
// declare pimpl
|
||||
typedef Pimpl<ImplT<T>, Ptr<ImplT<T> > > Type;
|
||||
|
|
@ -173,20 +173,20 @@ namespace Loki
|
|||
};
|
||||
|
||||
|
||||
template<class T, class UsedPimpl = typename PimplT<T>::Type >
|
||||
template<class T, class UsedPimpl = typename PimplT<T>::Type >
|
||||
struct RimplT
|
||||
{
|
||||
typedef typename UsedPimpl::Impl & Type;
|
||||
typedef typename UsedPimpl::Impl & Type;
|
||||
|
||||
class Owner
|
||||
{
|
||||
UsedPimpl pimpl;
|
||||
UsedPimpl pimpl;
|
||||
|
||||
public:
|
||||
Owner() : LOKI_INHERITED_RIMPL_NAME(*pimpl)
|
||||
public:
|
||||
Owner() : LOKI_INHERITED_RIMPL_NAME(*pimpl)
|
||||
{}
|
||||
|
||||
Type LOKI_INHERITED_RIMPL_NAME;
|
||||
Type LOKI_INHERITED_RIMPL_NAME;
|
||||
};
|
||||
|
||||
};
|
||||
|
|
@ -196,6 +196,9 @@ namespace Loki
|
|||
#endif
|
||||
|
||||
// $Log$
|
||||
// Revision 1.21 2006/06/19 12:39:08 syntheticpp
|
||||
// replace tabs with 4 spaces
|
||||
//
|
||||
// Revision 1.20 2006/03/27 15:33:24 syntheticpp
|
||||
// fix spelling
|
||||
//
|
||||
|
|
|
|||
|
|
@ -32,38 +32,38 @@ namespace Loki
|
|||
/// \ingroup RegisterGroup
|
||||
/// Must be specialized be the user
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
template<class t> bool RegisterFunction();
|
||||
template<class t> bool RegisterFunction();
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// \ingroup RegisterGroup
|
||||
/// Must be specialized be the user
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
template<class t> bool UnRegisterFunction();
|
||||
template<class t> bool UnRegisterFunction();
|
||||
|
||||
namespace Private
|
||||
namespace Private
|
||||
{
|
||||
template<class T>
|
||||
struct RegisterOnCreate
|
||||
template<class T>
|
||||
struct RegisterOnCreate
|
||||
{
|
||||
RegisterOnCreate() { RegisterFunction<T>(); }
|
||||
RegisterOnCreate() { RegisterFunction<T>(); }
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct UnRegisterOnDelete
|
||||
template<class T>
|
||||
struct UnRegisterOnDelete
|
||||
{
|
||||
~UnRegisterOnDelete() { UnRegisterFunction<T>(); }
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct RegisterOnCreateElement
|
||||
template<class T>
|
||||
struct RegisterOnCreateElement
|
||||
{
|
||||
RegisterOnCreate<T> registerObj;
|
||||
RegisterOnCreate<T> registerObj;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct UnRegisterOnDeleteElement
|
||||
template<class T>
|
||||
struct UnRegisterOnDeleteElement
|
||||
{
|
||||
UnRegisterOnDelete<T> unregisterObj;
|
||||
UnRegisterOnDelete<T> unregisterObj;
|
||||
};
|
||||
}
|
||||
|
||||
|
|
@ -77,8 +77,8 @@ namespace Loki
|
|||
/// see test/Register
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
template<typename ElementList>
|
||||
struct RegisterOnCreateSet
|
||||
template<typename ElementList>
|
||||
struct RegisterOnCreateSet
|
||||
: GenScatterHierarchy<ElementList, Private::RegisterOnCreateElement>
|
||||
{};
|
||||
|
||||
|
|
@ -91,8 +91,8 @@ namespace Loki
|
|||
/// \par Usage
|
||||
/// see test/Register
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
template<typename ElementList>
|
||||
struct UnRegisterOnDeleteSet
|
||||
template<typename ElementList>
|
||||
struct UnRegisterOnDeleteSet
|
||||
: GenScatterHierarchy<ElementList, Private::UnRegisterOnDeleteElement>
|
||||
{};
|
||||
|
||||
|
|
@ -109,11 +109,11 @@ namespace Loki
|
|||
|
||||
#define LOKI_CHECK_CLASS_IN_LIST( CLASS , LIST ) \
|
||||
\
|
||||
struct Loki_##CLASS##LIST_OK{typedef int class_##CLASS##_is_not_in_##LIST;};\
|
||||
typedef Loki::Select<Loki::TL::IndexOf<LIST, CLASS>::value == -1, \
|
||||
CLASS,Loki_##CLASS##LIST_OK >::Result IsInList##CLASS##LIST; \
|
||||
typedef IsInList##CLASS##LIST::class_##CLASS##_is_not_in_##LIST \
|
||||
isInListTest##CLASS##LIST;
|
||||
struct Loki_##CLASS##LIST_OK{typedef int class_##CLASS##_is_not_in_##LIST;};\
|
||||
typedef Loki::Select<Loki::TL::IndexOf<LIST, CLASS>::value == -1, \
|
||||
CLASS,Loki_##CLASS##LIST_OK >::Result IsInList##CLASS##LIST; \
|
||||
typedef IsInList##CLASS##LIST::class_##CLASS##_is_not_in_##LIST \
|
||||
isInListTest##CLASS##LIST;
|
||||
|
||||
} // namespace Loki
|
||||
|
||||
|
|
|
|||
|
|
@ -50,11 +50,11 @@ namespace Loki
|
|||
// Crude writing method: writes straight to the file, unbuffered
|
||||
// Must be combined with a buffer to work properly (and efficiently)
|
||||
LOKI_EXPORT
|
||||
void write(std::FILE* f, const char* from, const char* to);
|
||||
void write(std::FILE* f, const char* from, const char* to);
|
||||
|
||||
|
||||
// Write to a string
|
||||
LOKI_EXPORT
|
||||
LOKI_EXPORT
|
||||
void write(std::string& s, const char* from, const char* to);
|
||||
|
||||
// Write to a fixed-size buffer
|
||||
|
|
@ -532,22 +532,22 @@ namespace Loki
|
|||
LOKI_SAFEFORMAT_SIGNED_LONG result_;
|
||||
};
|
||||
|
||||
LOKI_EXPORT
|
||||
LOKI_EXPORT
|
||||
PrintfState<std::FILE*, char> Printf(const char* format);
|
||||
|
||||
LOKI_EXPORT
|
||||
LOKI_EXPORT
|
||||
PrintfState<std::FILE*, char> Printf(const std::string format);
|
||||
|
||||
LOKI_EXPORT
|
||||
LOKI_EXPORT
|
||||
PrintfState<std::FILE*, char> FPrintf(FILE* f, const char* format);
|
||||
|
||||
LOKI_EXPORT
|
||||
LOKI_EXPORT
|
||||
PrintfState<std::FILE*, char> FPrintf(FILE* f, const std::string& format);
|
||||
|
||||
LOKI_EXPORT
|
||||
LOKI_EXPORT
|
||||
PrintfState<std::string&, char> SPrintf(std::string& s, const char* format);
|
||||
|
||||
LOKI_EXPORT
|
||||
LOKI_EXPORT
|
||||
PrintfState<std::string&, char> SPrintf(std::string& s, const std::string& format);
|
||||
|
||||
template <class T, class Char>
|
||||
|
|
@ -573,6 +573,9 @@ namespace Loki
|
|||
#endif //SAFEFORMAT_H_
|
||||
|
||||
// $Log$
|
||||
// Revision 1.25 2006/06/19 12:39:08 syntheticpp
|
||||
// replace tabs with 4 spaces
|
||||
//
|
||||
// Revision 1.24 2006/02/28 11:13:20 syntheticpp
|
||||
// add export specifier
|
||||
//
|
||||
|
|
|
|||
|
|
@ -872,12 +872,12 @@ namespace Loki
|
|||
|
||||
#define LOKI_SINGLETON_INSTANCE_DEFINITION(SHOLDER) \
|
||||
namespace Loki \
|
||||
{ \
|
||||
template<> \
|
||||
SHOLDER::ObjectType& Singleton<SHOLDER::ObjectType>::Instance() \
|
||||
{ \
|
||||
{ \
|
||||
template<> \
|
||||
SHOLDER::ObjectType& Singleton<SHOLDER::ObjectType>::Instance() \
|
||||
{ \
|
||||
return SHOLDER::Instance(); \
|
||||
} \
|
||||
} \
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -897,6 +897,9 @@ namespace Loki \
|
|||
#endif // SINGLETON_INC_
|
||||
|
||||
// $Log$
|
||||
// Revision 1.31 2006/06/19 12:39:08 syntheticpp
|
||||
// replace tabs with 4 spaces
|
||||
//
|
||||
// Revision 1.30 2006/05/20 10:23:07 syntheticpp
|
||||
// add warnings in the documentation about the special lifetime when using SmallObjects
|
||||
//
|
||||
|
|
|
|||
|
|
@ -218,7 +218,7 @@ namespace Loki
|
|||
std::size_t maxSmallObjectSize = LOKI_MAX_SMALL_OBJECT_SIZE,
|
||||
std::size_t objectAlignSize = LOKI_DEFAULT_OBJECT_ALIGNMENT,
|
||||
template <class> class LifetimePolicy = LOKI_DEFAULT_SMALLOBJ_LIFETIME,
|
||||
class MutexPolicy = LOKI_DEFAULT_MUTEX
|
||||
class MutexPolicy = LOKI_DEFAULT_MUTEX
|
||||
>
|
||||
class AllocatorSingleton : public SmallObjAllocator
|
||||
{
|
||||
|
|
@ -283,7 +283,7 @@ namespace Loki
|
|||
std::size_t MSOS,
|
||||
std::size_t OAS,
|
||||
template <class> class LP,
|
||||
class MX
|
||||
class MX
|
||||
>
|
||||
void AllocatorSingleton< TM, CS, MSOS, OAS, LP, MX >::ClearExtraMemory( void )
|
||||
{
|
||||
|
|
@ -299,7 +299,7 @@ namespace Loki
|
|||
std::size_t MSOS,
|
||||
std::size_t OAS,
|
||||
template <class> class LP,
|
||||
class MX
|
||||
class MX
|
||||
>
|
||||
bool AllocatorSingleton< TM, CS, MSOS, OAS, LP, MX >::IsCorrupted( void )
|
||||
{
|
||||
|
|
@ -327,7 +327,7 @@ namespace Loki
|
|||
std::size_t MSOS,
|
||||
std::size_t OAS,
|
||||
template <class> class LP,
|
||||
class MX
|
||||
class MX
|
||||
>
|
||||
inline unsigned int GetLongevity(
|
||||
AllocatorSingleton< TM, CS, MSOS, OAS, LP, MX > * )
|
||||
|
|
@ -421,7 +421,7 @@ namespace Loki
|
|||
std::size_t maxSmallObjectSize,
|
||||
std::size_t objectAlignSize,
|
||||
template <class> class LifetimePolicy,
|
||||
class MutexPolicy
|
||||
class MutexPolicy
|
||||
>
|
||||
class SmallObjectBase
|
||||
{
|
||||
|
|
@ -578,7 +578,7 @@ namespace Loki
|
|||
std::size_t maxSmallObjectSize = LOKI_MAX_SMALL_OBJECT_SIZE,
|
||||
std::size_t objectAlignSize = LOKI_DEFAULT_OBJECT_ALIGNMENT,
|
||||
template <class> class LifetimePolicy = LOKI_DEFAULT_SMALLOBJ_LIFETIME,
|
||||
class MutexPolicy = LOKI_DEFAULT_MUTEX
|
||||
class MutexPolicy = LOKI_DEFAULT_MUTEX
|
||||
>
|
||||
class SmallObject : public SmallObjectBase< ThreadingModel, chunkSize,
|
||||
maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
|
||||
|
|
@ -614,7 +614,7 @@ namespace Loki
|
|||
std::size_t maxSmallObjectSize = LOKI_MAX_SMALL_OBJECT_SIZE,
|
||||
std::size_t objectAlignSize = LOKI_DEFAULT_OBJECT_ALIGNMENT,
|
||||
template <class> class LifetimePolicy = LOKI_DEFAULT_SMALLOBJ_LIFETIME,
|
||||
class MutexPolicy = LOKI_DEFAULT_MUTEX
|
||||
class MutexPolicy = LOKI_DEFAULT_MUTEX
|
||||
>
|
||||
class SmallValueObject : public SmallObjectBase< ThreadingModel, chunkSize,
|
||||
maxSmallObjectSize, objectAlignSize, LifetimePolicy, MutexPolicy >
|
||||
|
|
@ -634,6 +634,9 @@ namespace Loki
|
|||
// Nov. 26, 2004: re-implemented by Rich Sposato.
|
||||
//
|
||||
// $Log$
|
||||
// Revision 1.30 2006/06/19 12:39:08 syntheticpp
|
||||
// replace tabs with 4 spaces
|
||||
//
|
||||
// Revision 1.29 2006/03/08 17:07:11 syntheticpp
|
||||
// replace tabs with 4 spaces in all files
|
||||
//
|
||||
|
|
|
|||
|
|
@ -884,7 +884,7 @@ namespace Loki
|
|||
class ConversionPolicy = DisallowConversion,
|
||||
template <class> class CheckingPolicy = AssertCheck,
|
||||
template <class> class StoragePolicy = DefaultSPStorage,
|
||||
template<class> class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS
|
||||
template<class> class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS
|
||||
>
|
||||
struct SmartPtrDef
|
||||
{
|
||||
|
|
@ -895,7 +895,7 @@ namespace Loki
|
|||
ConversionPolicy,
|
||||
CheckingPolicy,
|
||||
StoragePolicy,
|
||||
ConstnessPolicy
|
||||
ConstnessPolicy
|
||||
>
|
||||
type;
|
||||
};
|
||||
|
|
@ -1525,6 +1525,9 @@ namespace std
|
|||
|
||||
|
||||
// $Log$
|
||||
// Revision 1.32 2006/06/19 12:39:08 syntheticpp
|
||||
// replace tabs with 4 spaces
|
||||
//
|
||||
// Revision 1.31 2006/05/30 14:30:19 syntheticpp
|
||||
// add warning about mt bug
|
||||
//
|
||||
|
|
|
|||
|
|
@ -122,7 +122,7 @@ public:
|
|||
typedef typename A::pointer iterator;
|
||||
typedef typename A::const_pointer const_iterator;
|
||||
|
||||
AllocatorStringStorage()
|
||||
AllocatorStringStorage()
|
||||
: A(), pData_(0)
|
||||
{
|
||||
}
|
||||
|
|
@ -231,12 +231,12 @@ public:
|
|||
swap(newStr);
|
||||
}
|
||||
|
||||
template <class ForwardIterator>
|
||||
void append(ForwardIterator b, ForwardIterator e)
|
||||
template <class ForwardIterator>
|
||||
void append(ForwardIterator b, ForwardIterator e)
|
||||
{
|
||||
const size_type
|
||||
sz = std::distance(b, e),
|
||||
neededCapacity = size() + sz;
|
||||
const size_type
|
||||
sz = std::distance(b, e),
|
||||
neededCapacity = size() + sz;
|
||||
|
||||
if (capacity() < neededCapacity)
|
||||
{
|
||||
|
|
@ -245,7 +245,7 @@ public:
|
|||
assert(!(le(begin(), &*b) && le(&*b, end())));
|
||||
reserve(neededCapacity);
|
||||
}
|
||||
std::copy(b, e, end());
|
||||
std::copy(b, e, end());
|
||||
pData_->pEnd_ += sz;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -90,7 +90,7 @@ public:
|
|||
typedef typename Storage::const_iterator const_iterator;
|
||||
typedef typename Storage::allocator_type allocator_type;
|
||||
typedef typename allocator_type::size_type size_type;
|
||||
typedef typename Storage::reference reference;
|
||||
typedef typename Storage::reference reference;
|
||||
|
||||
private:
|
||||
union
|
||||
|
|
|
|||
|
|
@ -17,14 +17,14 @@
|
|||
|
||||
namespace flex_string_details
|
||||
{
|
||||
template <class InIt, class OutIt>
|
||||
OutIt copy_n(InIt b, typename std::iterator_traits<InIt>::difference_type n, OutIt d)
|
||||
template <class InIt, class OutIt>
|
||||
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;
|
||||
}
|
||||
return d;
|
||||
return d;
|
||||
}
|
||||
|
||||
template <class Pod, class T>
|
||||
|
|
|
|||
|
|
@ -170,7 +170,7 @@ class flex_string : private Storage
|
|||
struct Invariant
|
||||
{
|
||||
#ifndef NDEBUG
|
||||
Invariant(const flex_string& s) : s_(s)
|
||||
Invariant(const flex_string& s) : s_(s)
|
||||
{
|
||||
assert(s_.Sane());
|
||||
}
|
||||
|
|
@ -181,9 +181,9 @@ class flex_string : private Storage
|
|||
private:
|
||||
const flex_string& s_;
|
||||
#else
|
||||
Invariant(const flex_string&) {}
|
||||
Invariant(const flex_string&) {}
|
||||
#endif
|
||||
Invariant& operator=(const Invariant&);
|
||||
Invariant& operator=(const Invariant&);
|
||||
};
|
||||
|
||||
public:
|
||||
|
|
@ -217,9 +217,9 @@ public:
|
|||
private:
|
||||
static size_type Min(size_type lhs, size_type rhs)
|
||||
{ return lhs < rhs ? lhs : rhs; }
|
||||
static size_type Max(size_type lhs, size_type rhs)
|
||||
static size_type Max(size_type lhs, size_type 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; }
|
||||
|
||||
public:
|
||||
|
|
@ -364,7 +364,7 @@ public:
|
|||
|
||||
flex_string& operator+=(const value_type c)
|
||||
{
|
||||
push_back(c);
|
||||
push_back(c);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
|
@ -376,20 +376,20 @@ public:
|
|||
{
|
||||
const size_type sz = str.size();
|
||||
Enforce(pos <= sz, static_cast<std::out_of_range*>(0), "");
|
||||
Procust(n, sz - pos);
|
||||
Procust(n, sz - pos);
|
||||
return append(str.data() + pos, n);
|
||||
}
|
||||
|
||||
flex_string& append(const value_type* s, const size_type n)
|
||||
{
|
||||
Invariant checker(*this);
|
||||
Invariant checker(*this);
|
||||
(void) checker;
|
||||
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();
|
||||
Storage::reserve(size() + n);
|
||||
s = &*begin() + offset;
|
||||
const size_type offset = s - &*begin();
|
||||
Storage::reserve(size() + n);
|
||||
s = &*begin() + offset;
|
||||
}
|
||||
Storage::append(s, s + n);
|
||||
return *this;
|
||||
|
|
@ -407,7 +407,7 @@ public:
|
|||
template<class InputIterator>
|
||||
flex_string& append(InputIterator first, InputIterator last)
|
||||
{
|
||||
insert(end(), first, last);
|
||||
insert(end(), first, last);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
|
@ -418,7 +418,7 @@ public:
|
|||
{
|
||||
reserve(cap << 1u);
|
||||
}
|
||||
Storage::append(&c, &c + 1);
|
||||
Storage::append(&c, &c + 1);
|
||||
}
|
||||
|
||||
flex_string& assign(const flex_string& str)
|
||||
|
|
@ -430,25 +430,25 @@ public:
|
|||
flex_string& assign(const flex_string& str, const size_type pos,
|
||||
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), "");
|
||||
Procust(n, sz - pos);
|
||||
Procust(n, sz - pos);
|
||||
return assign(str.data() + pos, n);
|
||||
}
|
||||
|
||||
flex_string& assign(const value_type* s, const size_type n)
|
||||
{
|
||||
Invariant checker(*this);
|
||||
Invariant checker(*this);
|
||||
(void) checker;
|
||||
if (size() >= n)
|
||||
{
|
||||
std::copy(s, s + n, begin());
|
||||
std::copy(s, s + n, begin());
|
||||
resize(n);
|
||||
}
|
||||
else
|
||||
{
|
||||
const value_type *const s2 = s + size();
|
||||
std::copy(s, s2, begin());
|
||||
const value_type *const s2 = s + size();
|
||||
std::copy(s, s2, begin());
|
||||
append(s2, n - size());
|
||||
}
|
||||
return *this;
|
||||
|
|
@ -468,15 +468,15 @@ public:
|
|||
size_type pos2, size_type n)
|
||||
{
|
||||
Enforce(pos2 <= str.length(), static_cast<std::out_of_range*>(0), "");
|
||||
Procust(n, str.length() - pos2);
|
||||
return insert(pos1, str.data() + pos2, n);
|
||||
Procust(n, str.length() - pos2);
|
||||
return insert(pos1, str.data() + pos2, n);
|
||||
}
|
||||
|
||||
flex_string& insert(size_type pos, const value_type* s, size_type n)
|
||||
{
|
||||
Enforce(pos <= length(), static_cast<std::out_of_range*>(0), "");
|
||||
insert(begin() + pos, s, s + n);
|
||||
return *this;
|
||||
insert(begin() + pos, s, s + n);
|
||||
return *this;
|
||||
}
|
||||
|
||||
flex_string& insert(size_type pos, const value_type* s)
|
||||
|
|
@ -485,13 +485,13 @@ public:
|
|||
flex_string& insert(size_type pos, size_type n, value_type c)
|
||||
{
|
||||
Enforce(pos <= length(), static_cast<std::out_of_range*>(0), "");
|
||||
insert(begin() + pos, n, c);
|
||||
return *this;
|
||||
insert(begin() + pos, n, c);
|
||||
return *this;
|
||||
}
|
||||
|
||||
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);
|
||||
return begin() + pos;
|
||||
}
|
||||
|
|
@ -502,122 +502,122 @@ private:
|
|||
flex_string& InsertImplDiscr(iterator p,
|
||||
size_type n, value_type c, Selector<1>)
|
||||
{
|
||||
Invariant checker(*this);
|
||||
Invariant checker(*this);
|
||||
(void) checker;
|
||||
assert(p >= begin() && p <= end());
|
||||
if (capacity() - size() < n)
|
||||
assert(p >= begin() && p <= end());
|
||||
if (capacity() - size() < n)
|
||||
{
|
||||
const size_type sz = p - begin();
|
||||
reserve(size() + n);
|
||||
p = begin() + sz;
|
||||
const size_type sz = p - begin();
|
||||
reserve(size() + n);
|
||||
p = begin() + sz;
|
||||
}
|
||||
const iterator oldEnd = end();
|
||||
const iterator oldEnd = end();
|
||||
//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(
|
||||
// reverse_iterator(oldEnd - n),
|
||||
// reverse_iterator(p),
|
||||
// reverse_iterator(oldEnd));
|
||||
flex_string_details::pod_move(&*p, &*oldEnd - n, &*p + n);
|
||||
std::fill(p, p + n, c);
|
||||
// reverse_iterator(oldEnd - n),
|
||||
// reverse_iterator(p),
|
||||
// reverse_iterator(oldEnd));
|
||||
flex_string_details::pod_move(&*p, &*oldEnd - n, &*p + n);
|
||||
std::fill(p, p + n, c);
|
||||
}
|
||||
else
|
||||
else
|
||||
{
|
||||
append(n - (end() - p), c);
|
||||
append(p, oldEnd);
|
||||
std::fill(p, oldEnd, c);
|
||||
append(n - (end() - p), c);
|
||||
append(p, oldEnd);
|
||||
std::fill(p, oldEnd, c);
|
||||
}
|
||||
return *this;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<class InputIterator>
|
||||
flex_string& InsertImplDiscr(iterator i,
|
||||
InputIterator b, InputIterator e, Selector<0>)
|
||||
{
|
||||
InsertImpl(i, b, e,
|
||||
typename std::iterator_traits<InputIterator>::iterator_category());
|
||||
InsertImpl(i, b, e,
|
||||
typename std::iterator_traits<InputIterator>::iterator_category());
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class FwdIterator>
|
||||
template <class FwdIterator>
|
||||
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;
|
||||
const size_type pos = i - begin();
|
||||
const typename std::iterator_traits<FwdIterator>::difference_type n2 =
|
||||
std::distance(s1, s2);
|
||||
assert(n2 >= 0);
|
||||
const size_type pos = i - begin();
|
||||
const typename std::iterator_traits<FwdIterator>::difference_type n2 =
|
||||
std::distance(s1, s2);
|
||||
assert(n2 >= 0);
|
||||
using namespace flex_string_details;
|
||||
assert(pos <= size());
|
||||
|
||||
const typename std::iterator_traits<FwdIterator>::difference_type maxn2 =
|
||||
capacity() - size();
|
||||
const typename std::iterator_traits<FwdIterator>::difference_type maxn2 =
|
||||
capacity() - size();
|
||||
if (maxn2 < n2)
|
||||
{
|
||||
// realloc the string
|
||||
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())));
|
||||
reserve(size() + n2);
|
||||
i = begin() + pos;
|
||||
i = begin() + pos;
|
||||
}
|
||||
if (pos + n2 <= size())
|
||||
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);
|
||||
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);
|
||||
std::copy(reverse_iterator(tailBegin), reverse_iterator(i),
|
||||
reverse_iterator(tailBegin + n2));
|
||||
std::copy(s1, s2, i);
|
||||
}
|
||||
else
|
||||
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);
|
||||
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,
|
||||
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)
|
||||
{
|
||||
temp.push_back(*b);
|
||||
temp.push_back(*b);
|
||||
}
|
||||
temp.append(i2, end());
|
||||
swap(temp);
|
||||
temp.append(i2, end());
|
||||
swap(temp);
|
||||
}
|
||||
|
||||
public:
|
||||
template <class ItOrLength, class ItOrChar>
|
||||
void insert(iterator p, ItOrLength first_or_n, ItOrChar last_or_c)
|
||||
{
|
||||
Selector<std::numeric_limits<ItOrLength>::is_specialized> sel;
|
||||
InsertImplDiscr(p, first_or_n, last_or_c, sel);
|
||||
Selector<std::numeric_limits<ItOrLength>::is_specialized> sel;
|
||||
InsertImplDiscr(p, first_or_n, last_or_c, sel);
|
||||
}
|
||||
|
||||
flex_string& erase(size_type pos = 0, size_type n = npos)
|
||||
{
|
||||
Invariant checker(*this);
|
||||
Invariant checker(*this);
|
||||
(void) checker;
|
||||
Enforce(pos <= length(), static_cast<std::out_of_range*>(0), "");
|
||||
Procust(n, length() - pos);
|
||||
std::copy(begin() + pos + n, end(), begin() + pos);
|
||||
resize(length() - n);
|
||||
Procust(n, length() - pos);
|
||||
std::copy(begin() + pos + n, end(), begin() + pos);
|
||||
resize(length() - n);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
|
@ -653,28 +653,28 @@ public:
|
|||
// Replaces at most n1 chars of *this, starting with pos,
|
||||
// with at most n2 chars of str.
|
||||
// str must have at least n2 chars.
|
||||
flex_string& replace(const size_type pos, size_type n1,
|
||||
const value_type* s1, const size_type n2)
|
||||
flex_string& replace(const size_type pos, size_type n1,
|
||||
const value_type* s1, const size_type n2)
|
||||
{
|
||||
Invariant checker(*this);
|
||||
Invariant checker(*this);
|
||||
(void) checker;
|
||||
Enforce(pos <= size(), (std::out_of_range*)0, "");
|
||||
Procust(n1, size() - pos);
|
||||
const iterator b = begin() + pos;
|
||||
return replace(b, b + n1, s1, s1 + n2);
|
||||
const iterator b = begin() + pos;
|
||||
return replace(b, b + n1, s1, s1 + n2);
|
||||
using namespace flex_string_details;
|
||||
const int delta = int(n2 - n1);
|
||||
static const std::less_equal<const value_type*> le;
|
||||
const bool aliased = le(&*begin(), s1) && le(s1, &*end());
|
||||
|
||||
// From here on we're dealing with an aliased replace
|
||||
if (delta <= 0)
|
||||
if (delta <= 0)
|
||||
{
|
||||
// simple case, we're shrinking
|
||||
pod_move(s1, s1 + n2, &*begin() + pos);
|
||||
pod_move(&*begin() + pos + n1, &*end(), &*begin() + pos + n1 + delta);
|
||||
resize(size() + delta);
|
||||
return *this;
|
||||
return *this;
|
||||
}
|
||||
|
||||
// From here on we deal with aliased growth
|
||||
|
|
@ -739,14 +739,14 @@ public:
|
|||
// str must have at least n2 chars.
|
||||
template <class StrOrLength, class NumOrChar>
|
||||
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;
|
||||
Enforce(pos <= size(), static_cast<std::out_of_range*>(0), "");
|
||||
Procust(n1, length() - pos);
|
||||
const iterator b = begin() + pos;
|
||||
return replace(b, b + n1, s_or_n2, n_or_c);
|
||||
Enforce(pos <= size(), static_cast<std::out_of_range*>(0), "");
|
||||
Procust(n1, length() - pos);
|
||||
const iterator b = begin() + pos;
|
||||
return replace(b, b + n1, s_or_n2, n_or_c);
|
||||
}
|
||||
|
||||
flex_string& replace(iterator i1, iterator i2, const flex_string& str)
|
||||
|
|
@ -759,87 +759,87 @@ private:
|
|||
flex_string& ReplaceImplDiscr(iterator i1, iterator i2,
|
||||
const value_type* s, size_type n, Selector<2>)
|
||||
{
|
||||
assert(i1 <= i2);
|
||||
assert(begin() <= i1 && i1 <= end());
|
||||
assert(begin() <= i2 && i2 <= end());
|
||||
return replace(i1, i2, s, s + n);
|
||||
assert(i1 <= i2);
|
||||
assert(begin() <= i1 && i1 <= end());
|
||||
assert(begin() <= i2 && i2 <= end());
|
||||
return replace(i1, i2, s, s + n);
|
||||
}
|
||||
|
||||
flex_string& ReplaceImplDiscr(iterator i1, iterator i2,
|
||||
size_type n2, value_type c, Selector<1>)
|
||||
{
|
||||
const size_type n1 = i2 - i1;
|
||||
if (n1 > n2)
|
||||
const size_type n1 = i2 - i1;
|
||||
if (n1 > n2)
|
||||
{
|
||||
std::fill(i1, i1 + n2, c);
|
||||
erase(i1 + n2, i2);
|
||||
std::fill(i1, i1 + n2, c);
|
||||
erase(i1 + n2, i2);
|
||||
}
|
||||
else
|
||||
else
|
||||
{
|
||||
std::fill(i1, i2, c);
|
||||
insert(i2, n2 - n1, c);
|
||||
std::fill(i1, i2, c);
|
||||
insert(i2, n2 - n1, c);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class InputIterator>
|
||||
flex_string& ReplaceImplDiscr(iterator i1, iterator i2,
|
||||
template <class InputIterator>
|
||||
flex_string& ReplaceImplDiscr(iterator i1, iterator i2,
|
||||
InputIterator b, InputIterator e, Selector<0>)
|
||||
{
|
||||
ReplaceImpl(i1, i2, b, e,
|
||||
typename std::iterator_traits<InputIterator>::iterator_category());
|
||||
ReplaceImpl(i1, i2, b, e,
|
||||
typename std::iterator_traits<InputIterator>::iterator_category());
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class FwdIterator>
|
||||
template <class FwdIterator>
|
||||
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;
|
||||
const typename std::iterator_traits<iterator>::difference_type n1 =
|
||||
i2 - i1;
|
||||
assert(n1 >= 0);
|
||||
const typename std::iterator_traits<FwdIterator>::difference_type n2 =
|
||||
std::distance(s1, s2);
|
||||
assert(n2 >= 0);
|
||||
const typename std::iterator_traits<iterator>::difference_type n1 =
|
||||
i2 - i1;
|
||||
assert(n1 >= 0);
|
||||
const typename std::iterator_traits<FwdIterator>::difference_type n2 =
|
||||
std::distance(s1, s2);
|
||||
assert(n2 >= 0);
|
||||
|
||||
// Handle aliased replace
|
||||
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());
|
||||
if (aliased /* && capacity() < size() - n1 + n2 */)
|
||||
if (aliased /* && capacity() < size() - n1 + n2 */)
|
||||
{
|
||||
// Aliased replace, copy to new string
|
||||
flex_string temp;
|
||||
temp.reserve(size() - n1 + n2);
|
||||
temp.append(begin(), i1).append(s1, s2).append(i2, end());
|
||||
swap(temp);
|
||||
return;
|
||||
flex_string temp;
|
||||
temp.reserve(size() - n1 + n2);
|
||||
temp.append(begin(), i1).append(s1, s2).append(i2, end());
|
||||
swap(temp);
|
||||
return;
|
||||
}
|
||||
|
||||
if (n1 > n2)
|
||||
if (n1 > n2)
|
||||
{
|
||||
// shrinks
|
||||
std::copy(s1, s2, i1);
|
||||
erase(i1 + n2, i2);
|
||||
std::copy(s1, s2, i1);
|
||||
erase(i1 + n2, i2);
|
||||
}
|
||||
else
|
||||
else
|
||||
{
|
||||
// grows
|
||||
flex_string_details::copy_n(s1, n1, i1);
|
||||
std::advance(s1, n1);
|
||||
insert(i2, s1, s2);
|
||||
flex_string_details::copy_n(s1, n1, i1);
|
||||
std::advance(s1, n1);
|
||||
insert(i2, s1, s2);
|
||||
}
|
||||
}
|
||||
|
||||
template <class InputIterator>
|
||||
template <class InputIterator>
|
||||
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);
|
||||
temp.append(b, e).append(i2, end());
|
||||
swap(temp);
|
||||
flex_string temp(begin(), i1);
|
||||
temp.append(b, e).append(i2, end());
|
||||
swap(temp);
|
||||
}
|
||||
|
||||
public:
|
||||
|
|
@ -847,11 +847,11 @@ public:
|
|||
flex_string& replace(iterator i1, iterator i2,
|
||||
T1 first_or_n_or_s, T2 last_or_c_or_n)
|
||||
{
|
||||
const bool
|
||||
num1 = std::numeric_limits<T1>::is_specialized,
|
||||
num2 = std::numeric_limits<T2>::is_specialized;
|
||||
const bool
|
||||
num1 = std::numeric_limits<T1>::is_specialized,
|
||||
num2 = std::numeric_limits<T2>::is_specialized;
|
||||
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
|
||||
|
|
@ -1055,7 +1055,7 @@ public:
|
|||
int compare(const flex_string& str) const
|
||||
{
|
||||
// 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,
|
||||
|
|
@ -1069,20 +1069,20 @@ public:
|
|||
int compare(size_type pos1, size_type n1,
|
||||
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,
|
||||
const value_type* s, size_type n2) const
|
||||
{
|
||||
Enforce(pos1 <= size(), static_cast<std::out_of_range*>(0), "");
|
||||
Procust(n1, size() - pos1);
|
||||
const int r = traits_type::compare(data(), s, Min(n1, n2));
|
||||
return
|
||||
r != 0 ? r :
|
||||
n1 > n2 ? 1 :
|
||||
n1 < n2 ? -1 :
|
||||
0;
|
||||
Procust(n1, size() - pos1);
|
||||
const int r = traits_type::compare(data(), s, Min(n1, n2));
|
||||
return
|
||||
r != 0 ? r :
|
||||
n1 > n2 ? 1 :
|
||||
n1 < n2 ? -1 :
|
||||
0;
|
||||
}
|
||||
|
||||
int compare(size_type pos1, size_type n1,
|
||||
|
|
@ -1095,7 +1095,7 @@ public:
|
|||
|
||||
int compare(const value_type* s) const
|
||||
{
|
||||
return traits_type::compare(data(), s, Max(length(),traits_type::length(s)));
|
||||
return traits_type::compare(data(), s, Max(length(),traits_type::length(s)));
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -1257,7 +1257,7 @@ std::basic_istream<typename flex_string<E, T, A, S>::value_type,
|
|||
typename flex_string<E, T, A, S>::traits_type>&
|
||||
operator>>(
|
||||
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);
|
||||
|
||||
template <typename E, class T, class A, class S>
|
||||
|
|
@ -1265,7 +1265,7 @@ std::basic_ostream<typename flex_string<E, T, A, S>::value_type,
|
|||
typename flex_string<E, T, A, S>::traits_type>&
|
||||
operator<<(
|
||||
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)
|
||||
{ return os << str.c_str(); }
|
||||
|
||||
|
|
|
|||
|
|
@ -120,7 +120,7 @@ public:
|
|||
typedef E* iterator;
|
||||
typedef const E* const_iterator;
|
||||
typedef A allocator_type;
|
||||
typedef typename A::reference reference;
|
||||
typedef typename A::reference reference;
|
||||
|
||||
|
||||
SimpleStringStorage(const SimpleStringStorage& rhs)
|
||||
|
|
@ -219,14 +219,14 @@ public:
|
|||
template <class InputIterator>
|
||||
void append(InputIterator b, InputIterator e)
|
||||
{
|
||||
const size_type
|
||||
sz = std::distance(b, e),
|
||||
neededCapacity = size() + sz;
|
||||
const size_type
|
||||
sz = std::distance(b, e),
|
||||
neededCapacity = size() + sz;
|
||||
if (capacity() < neededCapacity)
|
||||
{
|
||||
static std::less_equal<const E*> le;
|
||||
static std::less_equal<const E*> le;
|
||||
(void) le;
|
||||
assert(!(le(begin(), &*b) && le(&*b, end()))); // no aliasing
|
||||
assert(!(le(begin(), &*b) && le(&*b, end()))); // no aliasing
|
||||
reserve(neededCapacity);
|
||||
}
|
||||
std::copy(b, e, end());
|
||||
|
|
@ -272,8 +272,8 @@ template <typename E, class A>
|
|||
const typename SimpleStringStorage<E, A>::Data
|
||||
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() }
|
||||
//};
|
||||
|
||||
|
|
|
|||
|
|
@ -86,10 +86,10 @@ public:
|
|||
typedef const value_type* const_iterator;
|
||||
typedef typename Storage::allocator_type allocator_type;
|
||||
typedef typename allocator_type::size_type size_type;
|
||||
typedef typename Storage::reference reference;
|
||||
typedef typename Storage::reference reference;
|
||||
|
||||
private:
|
||||
enum { temp1 = threshold * sizeof(value_type) > sizeof(Storage)
|
||||
enum { temp1 = threshold * sizeof(value_type) > sizeof(Storage)
|
||||
? threshold * sizeof(value_type)
|
||||
: sizeof(Storage) };
|
||||
|
||||
|
|
@ -128,7 +128,7 @@ private:
|
|||
}
|
||||
|
||||
public:
|
||||
SmallStringOpt(const SmallStringOpt& s)
|
||||
SmallStringOpt(const SmallStringOpt& s)
|
||||
{
|
||||
if (s.Small())
|
||||
{
|
||||
|
|
@ -260,14 +260,14 @@ public:
|
|||
else
|
||||
{
|
||||
// append to a small string
|
||||
const size_type
|
||||
sz = std::distance(b, e),
|
||||
neededCapacity = maxSmallString - buf_[maxSmallString] + sz;
|
||||
const size_type
|
||||
sz = std::distance(b, e),
|
||||
neededCapacity = maxSmallString - buf_[maxSmallString] + sz;
|
||||
|
||||
if (maxSmallString < neededCapacity)
|
||||
{
|
||||
// need to change storage strategy
|
||||
allocator_type alloc;
|
||||
allocator_type alloc;
|
||||
Storage temp(alloc);
|
||||
temp.reserve(neededCapacity);
|
||||
temp.append(buf_, buf_ + maxSmallString - buf_[maxSmallString]);
|
||||
|
|
@ -278,7 +278,7 @@ public:
|
|||
}
|
||||
else
|
||||
{
|
||||
std::copy(b, e, buf_ + maxSmallString - buf_[maxSmallString]);
|
||||
std::copy(b, e, buf_ + maxSmallString - buf_[maxSmallString]);
|
||||
buf_[maxSmallString] = buf_[maxSmallString] - value_type(sz);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -83,7 +83,7 @@ public: // protected:
|
|||
typedef typename base::const_iterator const_iterator;
|
||||
typedef A allocator_type;
|
||||
typedef typename A::size_type size_type;
|
||||
typedef typename A::reference reference;
|
||||
typedef typename A::reference reference;
|
||||
|
||||
VectorStringStorage(const VectorStringStorage& s) : base(s)
|
||||
{ }
|
||||
|
|
@ -137,32 +137,32 @@ public: // protected:
|
|||
|
||||
void reserve(size_type res_arg)
|
||||
{
|
||||
assert(res_arg < max_size());
|
||||
assert(res_arg < max_size());
|
||||
base::reserve(res_arg + 1);
|
||||
}
|
||||
|
||||
template <class ForwardIterator>
|
||||
void append(ForwardIterator b, ForwardIterator e)
|
||||
{
|
||||
const typename std::iterator_traits<ForwardIterator>::difference_type
|
||||
sz = std::distance(b, e);
|
||||
assert(sz >= 0);
|
||||
if (sz == 0) return;
|
||||
base::reserve(base::size() + sz);
|
||||
const value_type & v = *b;
|
||||
struct OnBlockExit
|
||||
const typename std::iterator_traits<ForwardIterator>::difference_type
|
||||
sz = std::distance(b, e);
|
||||
assert(sz >= 0);
|
||||
if (sz == 0) return;
|
||||
base::reserve(base::size() + sz);
|
||||
const value_type & v = *b;
|
||||
struct OnBlockExit
|
||||
{
|
||||
VectorStringStorage * that;
|
||||
VectorStringStorage * that;
|
||||
~OnBlockExit()
|
||||
{
|
||||
that->base::push_back(value_type());
|
||||
that->base::push_back(value_type());
|
||||
}
|
||||
} onBlockExit = { this };
|
||||
(void) onBlockExit;
|
||||
assert(!base::empty());
|
||||
assert(base::back() == value_type());
|
||||
base::back() = v;
|
||||
base::insert(base::end(), ++b, e);
|
||||
assert(!base::empty());
|
||||
assert(base::back() == value_type());
|
||||
base::back() = v;
|
||||
base::insert(base::end(), ++b, e);
|
||||
}
|
||||
|
||||
void resize(size_type n, E c)
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
namespace yasli_nstd
|
||||
{
|
||||
template <class T>
|
||||
class fill_iterator_base
|
||||
class fill_iterator_base
|
||||
: public std::iterator<
|
||||
std::random_access_iterator_tag,
|
||||
T,
|
||||
|
|
@ -18,7 +18,7 @@ namespace yasli_nstd
|
|||
};
|
||||
|
||||
template <class T>
|
||||
class fill_iterator_base<T&>
|
||||
class fill_iterator_base<T&>
|
||||
: public std::iterator<
|
||||
std::random_access_iterator_tag,
|
||||
T,
|
||||
|
|
@ -50,7 +50,7 @@ namespace yasli_nstd
|
|||
}
|
||||
|
||||
template<class U>
|
||||
fill_iterator(const fill_iterator<U>& rhs)
|
||||
fill_iterator(const fill_iterator<U>& rhs)
|
||||
: value_(rhs.value_), count_(rhs.count_)
|
||||
{
|
||||
}
|
||||
|
|
@ -140,7 +140,7 @@ namespace yasli_nstd
|
|||
template <class T>
|
||||
inline bool operator!=(
|
||||
const fill_iterator<T>& lhs,
|
||||
const fill_iterator<T>& rhs)
|
||||
const fill_iterator<T>& rhs)
|
||||
{ // test for fill_iterator inequality
|
||||
return !(lhs == rhs);
|
||||
}
|
||||
|
|
@ -148,7 +148,7 @@ namespace yasli_nstd
|
|||
template <class T>
|
||||
inline bool operator<(
|
||||
const fill_iterator<T>& lhs,
|
||||
const fill_iterator<T>& rhs)
|
||||
const fill_iterator<T>& rhs)
|
||||
{
|
||||
return lhs.count_ < rhs.count_;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue