archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-xp/Source/XPSP1/NT/sdktools/rasdiag/private/ncstlstr.h

1189 lines
29 KiB
Raw Permalink Blame History

//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1997.
//
// File: N C S T L S T R . H
//
// Contents: STL string class renamed so as to remove our dependance
// from msvcp50.dll.
//
// Notes:
//
// Author: shaunco 12 Apr 1998
//
//----------------------------------------------------------------------------
#pragma once
#ifndef _NCSTLSTR_H_
#define _NCSTLSTR_H_
#include <stliter.h>
#include <stlxutil.h>
#include <limits.h>
#include <wchar.h>
#include "ncdebug.h"
using namespace std;
//template<class _E,
//class _Tr = char_traits<_E>,
//class _A = allocator<_E> >
struct wchar_traits
{
typedef wchar_t _E;
typedef _E char_type; // for overloads
typedef wint_t int_type;
typedef mbstate_t state_type;
static void __cdecl assign(_E& _X, const _E& _Y)
{
_X = _Y;
}
static bool __cdecl eq(const _E& _X, const _E& _Y)
{
return (_X == _Y);
}
static bool __cdecl lt(const _E& _X, const _E& _Y)
{
return (_X < _Y);
}
static int __cdecl compare(const _E *_U, const _E *_V, size_t _N)
{
return (wmemcmp(_U, _V, _N));
}
static size_t __cdecl length(const _E *_U)
{
return (wcslen(_U));
}
static _E *__cdecl copy(_E *_U, const _E *_V, size_t _N)
{
return (wmemcpy(_U, _V, _N));
}
static const _E * __cdecl find(const _E *_U, size_t _N,
const _E& _C)
{
return ((const _E *)wmemchr(_U, _C, _N));
}
static _E * __cdecl move(_E *_U, const _E *_V, size_t _N)
{
return (wmemmove(_U, _V, _N));
}
static _E * __cdecl assign(_E *_U, size_t _N, const _E& _C)
{
return (wmemset(_U, _C, _N));
}
static _E __cdecl to_char_type(const int_type& _C)
{
return (_C);
}
static int_type __cdecl to_int_type(const _E& _C)
{
return (_C);
}
static bool __cdecl eq_int_type(const int_type& _X,
const int_type& _Y)
{
return (_X == _Y);
}
static int_type __cdecl eof()
{
return (WEOF);
}
static int_type __cdecl not_eof(const int_type& _C)
{
return (_C != eof() ? _C : !eof());
}
};
class CWideString
{
public:
typedef CWideString _Myt;
typedef wchar_traits _Tr;
typedef _Tr::_E _E;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _E* pointer;
typedef const _E* const_pointer;
typedef _E& reference;
typedef const _E& const_reference;
typedef _E value_type;
typedef pointer iterator;
typedef const_pointer const_iterator;
typedef reverse_iterator<const_iterator, value_type, const_reference,
const_pointer, difference_type>
const_reverse_iterator;
typedef reverse_iterator<iterator, value_type, reference, pointer,
difference_type>
reverse_iterator;
typedef const_iterator _It;
explicit CWideString()
{
_Tidy();
}
CWideString(const _Myt& _X)
{
_Tidy(), assign(_X, 0, npos);
}
CWideString(const _Myt& _X, size_type _P, size_type _M)
{
_Tidy(), assign(_X, _P, _M);
}
CWideString(const _E *_S, size_type _N)
{
_Tidy(), assign(_S, _N);
}
CWideString(const _E *_S)
{
_Tidy(), assign(_S);
}
CWideString(size_type _N, _E _C)
{
_Tidy(), assign(_N, _C);
}
CWideString(_It _F, _It _L)
{
_Tidy(); assign(_F, _L);
}
~CWideString()
{
_Tidy(true);
}
enum _Mref
{
_FROZEN = USHRT_MAX
};
enum _Npos
{
// -1 is not arbitrary. It is chosen because it works in math
// operations. npos is treated as size_type and is inolved in
// arithmetic.
//
npos = -1
};
_Myt& operator=(const _Myt& _X)
{
return (assign(_X));
}
_Myt& operator=(const _E *_S)
{
return (assign(_S));
}
_Myt& operator=(_E _C)
{
return (assign(1, _C));
}
_Myt& operator+=(const _Myt& _X)
{
return (append(_X));
}
_Myt& operator+=(const _E *_S)
{
return (append(_S));
}
_Myt& operator+=(_E _C)
{
return (append(1, _C));
}
_Myt& append(const _Myt& _X)
{
return (append(_X, 0, npos));
}
_Myt& append(const _Myt& _X, size_type _P, size_type _M)
{
AssertH (_X.size() >= _P);
//if (_X.size() < _P)
// _Xran();
size_type _N = _X.size() - _P;
if (_N < _M)
_M = _N;
AssertH ((_Len + _M < npos));
//if (npos - _Len <= _M)
// _Xlen();
if (0 < _M && _Grow(_N = _Len + _M))
{
_Tr::copy(_Ptr + _Len, &_X.c_str()[_P], _M);
_Eos(_N);
}
return (*this);
}
_Myt& append(const _E *_S, size_type _M)
{
AssertH ((_Len + _M < npos));
//if (npos - _Len <= _M)
// _Xlen();
size_type _N;
if (0 < _M && _Grow(_N = _Len + _M))
{
_Tr::copy(_Ptr + _Len, _S, _M);
_Eos(_N);
}
return (*this);
}
_Myt& append(const _E *_S)
{
return (append(_S, _Tr::length(_S)));
}
_Myt& append(size_type _M, _E _C)
{
AssertH ((_Len + _M < npos));
//if (npos - _Len <= _M)
// _Xlen();
size_type _N;
if (0 < _M && _Grow(_N = _Len + _M))
{
_Tr::assign(_Ptr + _Len, _M, _C);
_Eos(_N);
}
return (*this);
}
_Myt& append(_It _F, _It _L)
{
return (replace(end(), end(), _F, _L));
}
_Myt& assign(const _Myt& _X)
{
return (assign(_X, 0, npos));
}
_Myt& assign(const _Myt& _X, size_type _P, size_type _M)
{
AssertH (_X.size() >= _P);
//if (_X.size() < _P)
// _Xran();
size_type _N = _X.size() - _P;
if (_M < _N)
_N = _M;
if (this == &_X)
{
erase((size_type)(_P + _N)), erase(0, _P);
}
else if (0 < _N && _N == _X.size()
&& _Refcnt(_X.c_str()) < _FROZEN - 1)
{
_Tidy(true);
_Ptr = (_E *)_X.c_str();
_Len = _X.size();
_Res = _X.capacity();
++_Refcnt(_Ptr);
}
else if (_Grow(_N, true))
{
_Tr::copy(_Ptr, &_X.c_str()[_P], _N);
_Eos(_N);
}
return (*this);
}
_Myt& assign(const _E *_S, size_type _N)
{
if (_Grow(_N))
{
_Tr::copy(_Ptr, _S, _N);
_Eos(_N);
}
return (*this);
}
_Myt& assign(const _E *_S)
{
return (assign(_S, _Tr::length(_S)));
}
_Myt& assignSafe(const _E *_S)
{
return (_S) ? assign(_S, _Tr::length(_S)) : erase();
}
_Myt& assign(size_type _N, _E _C)
{
AssertH (npos != _N);
//if (_N == npos)
// _Xlen();
if (_Grow(_N))
{
_Tr::assign(_Ptr, _N, _C);
_Eos(_N);
}
return (*this);
}
_Myt& assign(_It _F, _It _L)
{
return (replace(begin(), end(), _F, _L));
}
_Myt& insert(size_type _P0, const _Myt& _X)
{
return (insert(_P0, _X, 0, npos));
}
_Myt& insert(size_type _P0, const _Myt& _X, size_type _P, size_type _M)
{
AssertH ((_Len >= _P0) && (_X.size() >= _P));
//if (_Len < _P0 || _X.size() < _P)
// _Xran();
size_type _N = _X.size() - _P;
if (_N < _M)
_M = _N;
AssertH ((_Len + _M < npos));
//if (npos - _Len <= _M)
// _Xlen();
if (0 < _M && _Grow(_N = _Len + _M))
{
_Tr::move(_Ptr + _P0 + _M, _Ptr + _P0, _Len - _P0);
_Tr::copy(_Ptr + _P0, &_X.c_str()[_P], _M);
_Eos(_N);
}
return (*this);
}
_Myt& insert(size_type _P0, const _E *_S, size_type _M)
{
AssertH (_Len >= _P0);
//if (_Len < _P0)
// _Xran();
AssertH ((_Len + _M < npos));
//if (npos - _Len <= _M)
// _Xlen();
size_type _N;
if (0 < _M && _Grow(_N = _Len + _M))
{
_Tr::move(_Ptr + _P0 + _M, _Ptr + _P0, _Len - _P0);
_Tr::copy(_Ptr + _P0, _S, _M);
_Eos(_N);
}
return (*this);
}
_Myt& insert(size_type _P0, const _E *_S)
{
return (insert(_P0, _S, _Tr::length(_S)));
}
_Myt& insert(size_type _P0, size_type _M, _E _C)
{
AssertH (_Len >= _P0);
//if (_Len < _P0)
// _Xran();
AssertH ((_Len + _M < npos));
//if (npos - _Len <= _M)
// _Xlen();
size_type _N;
if (0 < _M && _Grow(_N = _Len + _M))
{
_Tr::move(_Ptr + _P0 + _M, _Ptr + _P0, _Len - _P0);
_Tr::assign(_Ptr + _P0, _M, _C);
_Eos(_N);
}
return (*this);
}
iterator insert(iterator _P, _E _C)
{
size_type _P0 = _Pdif(_P, begin());
insert(_P0, 1, _C);
return (begin() + _P0);
}
void insert(iterator _P, size_type _M, _E _C)
{
size_type _P0 = _Pdif(_P, begin());
insert(_P0, _M, _C);
}
void insert(iterator _P, _It _F, _It _L)
{
replace(_P, _P, _F, _L);
}
_Myt& erase(size_type _P0 = 0, size_type _M = npos)
{
AssertH (_Len >= _P0);
//if (_Len < _P0)
// _Xran();
_Split();
if (_Len - _P0 < _M)
_M = _Len - _P0;
if (0 < _M)
{
_Tr::move(_Ptr + _P0, _Ptr + _P0 + _M,
_Len - _P0 - _M);
size_type _N = _Len - _M;
if (_Grow(_N))
_Eos(_N);
}
return (*this);
}
iterator erase(iterator _P)
{
size_t _M = _Pdif(_P, begin());
erase(_M, 1);
return (_Psum(_Ptr, _M));
}
iterator erase(iterator _F, iterator _L)
{
size_t _M = _Pdif(_F, begin());
erase(_M, _Pdif(_L, _F));
return (_Psum(_Ptr, _M));
}
_Myt& replace(size_type _P0, size_type _N0, const _Myt& _X)
{
return (replace(_P0, _N0, _X, 0, npos));
}
_Myt& replace(size_type _P0, size_type _N0, const _Myt& _X,
size_type _P, size_type _M)
{
AssertH ((_Len >= _P0) && (_X.size() >= _P));
//if (_Len < _P0 || _X.size() < _P)
// _Xran();
if (_Len - _P0 < _N0)
_N0 = _Len - _P0;
size_type _N = _X.size() - _P;
if (_N < _M)
_M = _N;
AssertH (npos - _M > _Len - _N0);
//if (npos - _M <= _Len - _N0)
// _Xlen();
_Split();
size_type _Nm = _Len - _N0 - _P0;
if (_M < _N0)
_Tr::move(_Ptr + _P0 + _M, _Ptr + _P0 + _N0, _Nm);
if ((0 < _M || 0 < _N0) && _Grow(_N = _Len + _M - _N0))
{
if (_N0 < _M)
_Tr::move(_Ptr + _P0 + _M, _Ptr + _P0 + _N0, _Nm);
_Tr::copy(_Ptr + _P0, &_X.c_str()[_P], _M);
_Eos(_N);
}
return (*this);
}
_Myt& replace(size_type _P0, size_type _N0, const _E *_S,
size_type _M)
{
AssertH (_Len >= _P0);
//if (_Len < _P0)
// _Xran();
if (_Len - _P0 < _N0)
_N0 = _Len - _P0;
AssertH (npos - _M > _Len - _N0);
//if (npos - _M <= _Len - _N0)
// _Xlen();
_Split();
size_type _Nm = _Len - _N0 - _P0;
if (_M < _N0)
_Tr::move(_Ptr + _P0 + _M, _Ptr + _P0 + _N0, _Nm);
size_type _N;
if ((0 < _M || 0 < _N0) && _Grow(_N = _Len + _M - _N0))
{
if (_N0 < _M)
_Tr::move(_Ptr + _P0 + _M, _Ptr + _P0 + _N0, _Nm);
_Tr::copy(_Ptr + _P0, _S, _M);
_Eos(_N);
}
return (*this);
}
_Myt& replace(size_type _P0, size_type _N0, const _E *_S)
{
return (replace(_P0, _N0, _S, _Tr::length(_S)));
}
_Myt& replace(size_type _P0, size_type _N0,
size_type _M, _E _C)
{
AssertH (_Len >= _P0);
//if (_Len < _P0)
// _Xran();
if (_Len - _P0 < _N0)
_N0 = _Len - _P0;
AssertH (npos - _M > _Len - _N0);
//if (npos - _M <= _Len - _N0)
// _Xlen();
_Split();
size_type _Nm = _Len - _N0 - _P0;
if (_M < _N0)
_Tr::move(_Ptr + _P0 + _M, _Ptr + _P0 + _N0, _Nm);
size_type _N;
if ((0 < _M || 0 < _N0) && _Grow(_N = _Len + _M - _N0))
{
if (_N0 < _M)
_Tr::move(_Ptr + _P0 + _M, _Ptr + _P0 + _N0,
_Nm);
_Tr::assign(_Ptr + _P0, _M, _C);
_Eos(_N);
}
return (*this);
}
_Myt& replace(iterator _F, iterator _L, const _Myt& _X)
{
return (replace(_Pdif(_F, begin()), _Pdif(_L, _F), _X));
}
_Myt& replace(iterator _F, iterator _L, const _E *_S,
size_type _M)
{
return (replace(_Pdif(_F, begin()), _Pdif(_L, _F), _S, _M));
}
_Myt& replace(iterator _F, iterator _L, const _E *_S)
{
return (replace(_Pdif(_F, begin()), _Pdif(_L, _F), _S));
}
_Myt& replace(iterator _F, iterator _L, size_type _M, _E _C)
{
return (replace(_Pdif(_F, begin()), _Pdif(_L, _F), _M, _C));
}
_Myt& replace(iterator _F1, iterator _L1,
_It _F2, _It _L2)
{
size_type _P0 = _Pdif(_F1, begin());
size_type _M = 0;
_Distance(_F2, _L2, _M);
replace(_P0, _Pdif(_L1, _F1), _M, _E(0));
for (_F1 = begin() + _P0; 0 < _M; ++_F1, ++_F2, --_M)
*_F1 = *_F2;
return (*this);
}
iterator begin()
{
_Freeze();
return (_Ptr);
}
const_iterator begin() const
{
return (_Ptr);
}
iterator end()
{
_Freeze();
return ((iterator)_Psum(_Ptr, _Len));
}
const_iterator end() const
{
return ((const_iterator)_Psum(_Ptr, _Len));
}
reverse_iterator rbegin()
{
return (reverse_iterator(end()));
}
const_reverse_iterator rbegin() const
{
return (const_reverse_iterator(end()));
}
reverse_iterator rend()
{
return (reverse_iterator(begin()));
}
const_reverse_iterator rend() const
{
return (const_reverse_iterator(begin()));
}
reference at(size_type _P0)
{
AssertH (_Len > _P0);
//if (_Len <= _P0)
// _Xran();
_Freeze();
return (_Ptr[_P0]);
}
const_reference at(size_type _P0) const
{
AssertH (_Len > _P0);
//if (_Len <= _P0)
// _Xran();
return (_Ptr[_P0]);
}
reference operator[](size_type _P0)
{
if (_Len < _P0 || _Ptr == 0)
return ((reference)*_Nullstr());
_Freeze();
return (_Ptr[_P0]);
}
const_reference operator[](size_type _P0) const
{
if (_Ptr == 0)
return (*_Nullstr());
else
return (_Ptr[_P0]);
}
const _E *c_str() const
{
return (_Ptr == 0 ? _Nullstr() : _Ptr);
}
const _E *data() const
{
return (c_str());
}
size_type length() const
{
return (_Len);
}
size_type size() const
{
return (_Len);
}
void resize(size_type _N, _E _C)
{
_N <= _Len ? erase(_N) : append(_N - _Len, _C);
}
void resize(size_type _N)
{
_N <= _Len ? erase(_N) : append(_N - _Len, _E(0));
}
size_type capacity() const
{
return (_Res);
}
void reserve(size_type _N = 0)
{
if (_Res < _N)
_Grow(_N);
}
bool empty() const
{
return (_Len == 0);
}
size_type copy(_E *_S, size_type _N, size_type _P0 = 0) const
{
AssertH (_Len >= _P0);
//if (_Len < _P0)
// _Xran();
if (_Len - _P0 < _N)
_N = _Len - _P0;
if (0 < _N)
_Tr::copy(_S, _Ptr + _P0, _N);
return (_N);
}
void swap(_Myt& _X)
{
std::swap(_Ptr, _X._Ptr);
std::swap(_Len, _X._Len);
std::swap(_Res, _X._Res);
}
void swap(_Myt& _X, _Myt& _Y)
{
_X.swap(_Y);
}
size_type find(const _Myt& _X, size_type _P = 0) const
{
return (find(_X.c_str(), _P, _X.size()));
}
size_type find(const _E *_S, size_type _P,
size_type _N) const
{
if (_N == 0 && _P <= _Len)
return (_P);
size_type _Nm;
if (_P < _Len && _N <= (_Nm = _Len - _P))
{
const _E *_U, *_V;
for (_Nm -= _N - 1, _V = _Ptr + _P;
(_U = _Tr::find(_V, _Nm, *_S)) != 0;
_Nm -= (size_type)(_U - _V + 1), _V = _U + 1)
if (_Tr::compare(_U, _S, _N) == 0)
return (_U - _Ptr);
}
return (npos);
}
size_type find(const _E *_S, size_type _P = 0) const
{
return (find(_S, _P, _Tr::length(_S)));
}
size_type find(_E _C, size_type _P = 0) const
{
return (find((const _E *)&_C, _P, 1));
}
size_type rfind(const _Myt& _X, size_type _P = npos) const
{
return (rfind(_X.c_str(), _P, _X.size()));
}
size_type rfind(const _E *_S, size_type _P,
size_type _N) const
{
if (_N == 0)
return (_P < _Len ? _P : _Len);
if (_N <= _Len)
for (const _E *_U = _Ptr +
+ (_P < _Len - _N ? _P : _Len - _N); ; --_U)
if (_Tr::eq(*_U, *_S)
&& _Tr::compare(_U, _S, _N) == 0)
return (_U - _Ptr);
else if (_U == _Ptr)
break;
return (npos);
}
size_type rfind(const _E *_S, size_type _P = npos) const
{
return (rfind(_S, _P, _Tr::length(_S)));
}
size_type rfind(_E _C, size_type _P = npos) const
{
return (rfind((const _E *)&_C, _P, 1));
}
size_type find_first_of(const _Myt& _X,
size_type _P = 0) const
{
return (find_first_of(_X.c_str(), _P, _X.size()));
}
size_type find_first_of(const _E *_S, size_type _P,
size_type _N) const
{
if (0 < _N && _P < _Len)
{
const _E *const _V = _Ptr + _Len;
for (const _E *_U = _Ptr + _P; _U < _V; ++_U)
if (_Tr::find(_S, _N, *_U) != 0)
return (_U - _Ptr);
}
return (npos);
}
size_type find_first_of(const _E *_S, size_type _P = 0) const
{
return (find_first_of(_S, _P, _Tr::length(_S)));
}
size_type find_first_of(_E _C, size_type _P = 0) const
{
return (find((const _E *)&_C, _P, 1));
}
size_type find_last_of(const _Myt& _X,
size_type _P = npos) const
{
return (find_last_of(_X.c_str(), _P, _X.size()));
}
size_type find_last_of(const _E *_S, size_type _P,
size_type _N) const
{
if (0 < _N && 0 < _Len)
for (const _E *_U = _Ptr
+ (_P < _Len ? _P : _Len - 1); ; --_U)
if (_Tr::find(_S, _N, *_U) != 0)
return (_U - _Ptr);
else if (_U == _Ptr)
break;
return (npos);
}
size_type find_last_of(const _E *_S,
size_type _P = npos) const
{
return (find_last_of(_S, _P, _Tr::length(_S)));
}
size_type find_last_of(_E _C, size_type _P = npos) const
{
return (rfind((const _E *)&_C, _P, 1));
}
size_type find_first_not_of(const _Myt& _X,
size_type _P = 0) const
{
return (find_first_not_of(_X.c_str(), _P,
_X.size()));
}
size_type find_first_not_of(const _E *_S, size_type _P,
size_type _N) const
{
if (_P < _Len)
{
const _E *const _V = _Ptr + _Len;
for (const _E *_U = _Ptr + _P; _U < _V; ++_U)
if (_Tr::find(_S, _N, *_U) == 0)
return (_U - _Ptr);
}
return (npos);
}
size_type find_first_not_of(const _E *_S,
size_type _P = 0) const
{
return (find_first_not_of(_S, _P, _Tr::length(_S)));
}
size_type find_first_not_of(_E _C, size_type _P = 0) const
{
return (find_first_not_of((const _E *)&_C, _P, 1));
}
size_type find_last_not_of(const _Myt& _X,
size_type _P = npos) const
{
return (find_last_not_of(_X.c_str(), _P, _X.size()));
}
size_type find_last_not_of(const _E *_S, size_type _P,
size_type _N) const
{
if (0 < _Len)
for (const _E *_U = _Ptr
+ (_P < _Len ? _P : _Len - 1); ; --_U)
if (_Tr::find(_S, _N, *_U) == 0)
return (_U - _Ptr);
else if (_U == _Ptr)
break;
return (npos);
}
size_type find_last_not_of(const _E *_S,
size_type _P = npos) const
{
return (find_last_not_of(_S, _P, _Tr::length(_S)));
}
size_type find_last_not_of(_E _C, size_type _P = npos) const
{
return (find_last_not_of((const _E *)&_C, _P, 1));
}
_Myt substr(size_type _P = 0, size_type _M = npos) const
{
return (_Myt(*this, _P, _M));
}
int compare(const _Myt& _X) const
{
return (compare(0, _Len, _X.c_str(), _X.size()));
}
int compare(size_type _P0, size_type _N0,
const _Myt& _X) const
{
return (compare(_P0, _N0, _X, 0, npos));
}
int compare(size_type _P0, size_type _N0, const _Myt& _X,
size_type _P, size_type _M) const
{
AssertH (_X.size() >= _P);
//if (_X.size() < _P)
// _Xran();
if (_X._Len - _P < _M)
_M = _X._Len - _P;
return (compare(_P0, _N0, _X.c_str() + _P, _M));
}
int compare(const _E *_S) const
{
return (compare(0, _Len, _S, _Tr::length(_S)));
}
int compare(size_type _P0, size_type _N0, const _E *_S) const
{
return (compare(_P0, _N0, _S, _Tr::length(_S)));
}
int compare(size_type _P0, size_type _N0, const _E *_S,
size_type _M) const
{
AssertH (_Len >= _P0);
//if (_Len < _P0)
// _Xran();
if (_Len - _P0 < _N0)
_N0 = _Len - _P0;
size_type _Ans = _Tr::compare(_Psum(_Ptr, _P0), _S,
_N0 < _M ? _N0 : _M);
return (_Ans != 0 ? _Ans : _N0 < _M ? -1
: _N0 == _M ? 0 : +1);
}
private:
enum
{
// the number of characters that, when multiplied by sizeof(_E) will
// still fit within the range of size_type. (We allocate two extra
// characters -- one for the refcount, the other for the terminator.)
//
_MAX_SIZE = (((unsigned int)(-1)) / sizeof(_E)) - 2,
// _MIN_SIZE seems to be an allocation granularity (in characters).
// Allocation requests are bit ORed with _MIN_SIZE.
//
_MIN_SIZE = 7,
//_MIN_SIZE = sizeof (_E) <= 32 ? 31 : 7
};
void _Copy(size_type _N)
{
//AssertSzH (_Len <= _N, "Can't allocate less than we need to copy");
size_type _Ns = _N | _MIN_SIZE;
if (_MAX_SIZE < _Ns)
_Ns = _N;
size_type _NewLen = (_Ns < _Len) ? _Ns : _Len;
_E *_S = (_E*) MemAllocRaiseException ((_Ns + 2) * sizeof(_E));
//_TRY_BEGIN
//_S = allocator.allocate(_Ns + 2, (void *)0);
//_CATCH_ALL
//_Ns = _N;
//_S = allocator.allocate(_Ns + 2, (void *)0);
//_CATCH_END
if (_Len)
{
_Tr::copy(_S + 1, _Ptr, _NewLen);
}
_Tidy(true);
_Ptr = _S + 1;
_Refcnt(_Ptr) = 0;
_Res = _Ns;
_Eos(_NewLen);
}
void _Eos(size_type _N)
{
_Tr::assign(_Ptr[_Len = _N], _E(0));
}
void _Freeze()
{
if (_Ptr != 0
&& _Refcnt(_Ptr) != 0 && _Refcnt(_Ptr) != _FROZEN)
_Grow(_Len);
if (_Ptr != 0)
_Refcnt(_Ptr) = _FROZEN;
}
bool _Grow(size_type _N, bool _Trim = false)
{
AssertH (_N < _MAX_SIZE);
//if (_MAX_SIZE < _N)
// _Xlen();
if (_Ptr != 0 && _Refcnt(_Ptr) != 0 && _Refcnt(_Ptr) != _FROZEN)
{
if (_N == 0)
{
--_Refcnt(_Ptr), _Tidy();
return (false);
}
else
{
_Copy(_N);
return (true);
}
}
else if (_N == 0)
{
if (_Trim)
{
_Tidy(true);
}
else if (_Ptr != 0)
{
_Eos(0);
}
return (false);
}
else
{
if (_Trim && (_N > _Res || _Res > _MIN_SIZE))
{
_Tidy(true);
_Copy(_N);
}
else if (!_Trim && (_N > _Res))
{
_Copy(_N);
}
return (true);
}
}
static const _E * __cdecl _Nullstr()
{
static const _E _C = _E(0);
return (&_C);
}
static size_type _Pdif(const_pointer _P2, const_pointer _P1)
{
return (_P2 == 0 ? 0 : _P2 - _P1);
}
static const_pointer _Psum(const_pointer _P, size_type _N)
{
return (_P == 0 ? 0 : _P + _N);
}
static pointer _Psum(pointer _P, size_type _N)
{
return (_P == 0 ? 0 : _P + _N);
}
unsigned short& _Refcnt(const _E *_U)
{
return (((unsigned short *)_U)[-1]);
}
void _Split()
{
if (_Ptr != 0 && _Refcnt(_Ptr) != 0 && _Refcnt(_Ptr) != _FROZEN)
{
_E *_Temp = _Ptr;
_Tidy(true);
assign(_Temp);
}
}
void _Tidy(bool _Built = false)
{
if (!_Built || _Ptr == 0)
{
;
}
else if (_Refcnt(_Ptr) == 0 || _Refcnt(_Ptr) == _FROZEN)
{
MemFree(_Ptr - 1);
//allocator.deallocate(_Ptr - 1, _Res + 2);
}
else
{
--_Refcnt(_Ptr);
}
_Ptr = 0, _Len = 0, _Res = 0;
}
_E *_Ptr;
size_type _Len, _Res;
};
inline
CWideString __cdecl operator+(
const CWideString& _L,
const CWideString& _R)
{return (CWideString(_L) += _R); }
inline
CWideString __cdecl operator+(
const CWideString::_E *_L,
const CWideString& _R)
{return (CWideString(_L) += _R); }
inline
CWideString __cdecl operator+(
const CWideString::_E _L,
const CWideString& _R)
{return (CWideString(1, _L) += _R); }
inline
CWideString __cdecl operator+(
const CWideString& _L,
const CWideString::_E *_R)
{return (CWideString(_L) += _R); }
inline
CWideString __cdecl operator+(
const CWideString& _L,
const CWideString::_E _R)
{return (CWideString(_L) += _R); }
inline
bool __cdecl operator==(
const CWideString& _L,
const CWideString& _R)
{return (_L.compare(_R) == 0); }
inline
bool __cdecl operator==(
const CWideString::_E * _L,
const CWideString& _R)
{return (_R.compare(_L) == 0); }
inline
bool __cdecl operator==(
const CWideString& _L,
const CWideString::_E *_R)
{return (_L.compare(_R) == 0); }
inline
bool __cdecl operator!=(
const CWideString& _L,
const CWideString& _R)
{return (!(_L == _R)); }
inline
bool __cdecl operator!=(
const CWideString::_E *_L,
const CWideString& _R)
{return (!(_L == _R)); }
inline
bool __cdecl operator!=(
const CWideString& _L,
const CWideString::_E *_R)
{return (!(_L == _R)); }
inline
bool __cdecl operator<(
const CWideString& _L,
const CWideString& _R)
{return (_L.compare(_R) < 0); }
inline
bool __cdecl operator<(
const CWideString::_E * _L,
const CWideString& _R)
{return (_R.compare(_L) > 0); }
inline
bool __cdecl operator<(
const CWideString& _L,
const CWideString::_E *_R)
{return (_L.compare(_R) < 0); }
inline
bool __cdecl operator>(
const CWideString& _L,
const CWideString& _R)
{return (_R < _L); }
inline
bool __cdecl operator>(
const CWideString::_E * _L,
const CWideString& _R)
{return (_R < _L); }
inline
bool __cdecl operator>(
const CWideString& _L,
const CWideString::_E *_R)
{return (_R < _L); }
inline
bool __cdecl operator<=(
const CWideString& _L,
const CWideString& _R)
{return (!(_R < _L)); }
inline
bool __cdecl operator<=(
const CWideString::_E * _L,
const CWideString& _R)
{return (!(_R < _L)); }
inline
bool __cdecl operator<=(
const CWideString& _L,
const CWideString::_E *_R)
{return (!(_R < _L)); }
inline
bool __cdecl operator>=(
const CWideString& _L,
const CWideString& _R)
{return (!(_L < _R)); }
inline
bool __cdecl operator>=(
const CWideString::_E * _L,
const CWideString& _R)
{return (!(_L < _R)); }
inline
bool __cdecl operator>=(
const CWideString& _L,
const CWideString::_E *_R)
{return (!(_L < _R)); }
#endif // _NCSTLSTR_H_