MichaelAgarkov/CodeBlocksPortable
MichaelAgarkov/CodeBlocksPortable
Archived
1
1
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity
This repository has been archived on 2024-12-16. You can view files and clone it, but cannot push or open issues or pull requests.
CodeBlocksPortable/Borland/BCC55/Include/string.stl

1747 lines
64 KiB
Plaintext
Raw Normal View History

My portable distribution of Code::Blocks
2024-07-04 16:52:56 +00:00
#ifndef __STRING_STL
#define __STRING_STL
#pragma option push -b -a8 -pc -Vx- -Ve- -w-inl -w-aus -w-sig
// -*- C++ -*-
/***************************************************************************
*
* string - Declarations for the Standard Library string classes
*
***************************************************************************
*
* Copyright (c) 1994-1999 Rogue Wave Software, Inc. All Rights Reserved.
*
* This computer software is owned by Rogue Wave Software, Inc. and is
* protected by U.S. copyright laws and other laws and by international
* treaties. This computer software is furnished by Rogue Wave Software,
* Inc. pursuant to a written license agreement and may be used, copied,
* transmitted, and stored only in accordance with the terms of such
* license and with the inclusion of the above copyright notice. This
* computer software or any other copies thereof may not be provided or
* otherwise made available to any other person.
*
* U.S. Government Restricted Rights. This computer software is provided
* with Restricted Rights. Use, duplication, or disclosure by the
* Government is subject to restrictions as set forth in subparagraph (c)
* (1) (ii) of The Rights in Technical Data and Computer Software clause
* at DFARS 252.227-7013 or subparagraphs (c) (1) and (2) of the
* Commercial Computer Software <20> Restricted Rights at 48 CFR 52.227-19,
* as applicable. Manufacturer is Rogue Wave Software, Inc., 5500
* Flatiron Parkway, Boulder, Colorado 80301 USA.
*
**************************************************************************/
#ifndef __STD_STRING
#define __STD_STRING
#include <stdcomp.h>
#include <rw/rwstderr.h>
#ifndef _RWSTD_NO_NEW_HEADER
#include <cstring>
#include <cctype>
#else
#include <string.h>
#include <ctype.h>
#endif
#ifdef _HPACC_
#include <wchar.h>
#else
#ifndef _RWSTD_NO_WIDE_CHAR
#ifndef _RWSTD_NO_NEW_HEADER
#include <cwchar>
#include <cwctype>
#else
#ifndef _RWSTD_NO_WCHAR_H
#include <wchar.h>
#endif
#ifndef _RWSTD_NO_WCTYPE_H
# include <wctype.h>
#endif
#endif
#endif
#endif
#ifndef _RW_STD_IOSTREAM
#include <iostream.h>
#endif
#include <rw/string_ref>
#ifndef _RWSTD_NO_NAMESPACE
namespace __rwstd {
#endif
//
// Global error message declarations
//
#ifdef _RWSTD_LOCALIZED_ERRORS
extern const unsigned int _RWSTDExport __rwse_InvalidSizeParam;
extern const unsigned int _RWSTDExport __rwse_PosBeyondEndOfString;
extern const unsigned int _RWSTDExport __rwse_ResultLenInvalid;
extern const unsigned int _RWSTDExport __rwse_StringIndexOutOfRange;
extern const unsigned int _RWSTDExport __rwse_UnexpectedNullPtr;
#else
extern const char _RWSTDExportFunc(*) __rwse_InvalidSizeParam;
extern const char _RWSTDExportFunc(*) __rwse_PosBeyondEndOfString;
extern const char _RWSTDExportFunc(*) __rwse_ResultLenInvalid;
extern const char _RWSTDExportFunc(*) __rwse_StringIndexOutOfRange;
extern const char _RWSTDExportFunc(*) __rwse_UnexpectedNullPtr;
#endif
#ifdef _RWSTD_NO_STATIC_DEF3
extern unsigned long _RWSTDExport __nullref[];
extern bool _RWSTDExport __nullref_initialized;
#endif
#ifndef _RWSTD_NO_NAMESPACE
} namespace std {
#endif
template <class charT, class traits , class Allocator >
class _RWSTDExportTemplate basic_string
{
public:
//
// Implementation types (see rw/string_ref)
//
// __string_ref_type is the type of the string reference that holds
// the data for a basic_string. Defining _RWSTD_NO_STRING_REF_COUNT
// gets you a basic_string that does not use reference counting at all.
//
#ifndef _RWSTD_NO_STRING_REF_COUNT
typedef __RWSTD::__string_ref<charT,traits,Allocator> __string_ref_type;
#else
typedef __RWSTD::__string_noref<charT,traits,Allocator> __string_ref_type;
#endif
//
// __rep_type is the base class of __string_ref_type. This type
// defines the representation of the reference class.
//
typedef _TYPENAME __string_ref_type::__string_ref_rep_type __rep_type;
//
// __null_ref_type is the type of the null reference. Every empty
// string holds a reference to the same null reference object in order
// to keep the size of an empty string at sizeof(char*) -- assuming
// your compiler can handle the empty base optimization.
//
typedef __RWSTD::__null_string_ref_rep<charT,traits,Allocator,__rep_type> __null_ref_type;
//
// types
//
typedef traits traits_type;
typedef _TYPENAME traits::char_type value_type;
typedef Allocator allocator_type;
private:
#ifdef _RWSTD_ALLOCATOR
typedef Allocator __value_alloc_type;
typedef _TYPENAME Allocator::template rebind<__string_ref_type>::other __ref_alloc_type;
#else
typedef allocator_interface<Allocator,charT> __value_alloc_type;
typedef allocator_interface<Allocator,__string_ref_type> __ref_alloc_type;
#endif
public:
#ifndef _RWSTD_NO_COMPLICATED_TYPEDEF
typedef _TYPENAME _RWSTD_ALLOC_SIZE_TYPE size_type;
typedef _TYPENAME _RWSTD_ALLOC_DIFF_TYPE difference_type;
typedef _TYPENAME __value_alloc_type::reference reference;
typedef _TYPENAME __value_alloc_type::const_reference const_reference;
typedef _TYPENAME __value_alloc_type::pointer pointer;
typedef _TYPENAME __value_alloc_type::const_pointer const_pointer;
typedef _TYPENAME __value_alloc_type::pointer iterator;
typedef _TYPENAME __value_alloc_type::const_pointer const_iterator;
#else
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef charT& reference;
typedef const charT& const_reference;
typedef charT* pointer;
typedef const charT* const_pointer;
typedef charT* iterator;
typedef const charT* const_iterator;
#endif //_RWSTD_NO_COMPLICATED_TYPEDEF
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
typedef _RW_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef _RW_STD::reverse_iterator<iterator> reverse_iterator;
#else
typedef _RW_STD::reverse_iterator<const_iterator,
random_access_iterator_tag, value_type,
const_reference, const_pointer, difference_type>
const_reverse_iterator;
typedef _RW_STD::reverse_iterator<iterator,
random_access_iterator_tag, value_type,
reference, pointer, difference_type>
reverse_iterator;
#endif
#ifdef _RWSTD_MSC22_STATIC_INIT_BUG
#define npos (size_type)-1
#else
static const size_type npos;
#endif
inline _EXPLICIT basic_string (const Allocator& _RWSTD_DEFAULT_ARG(Allocator()));
#ifdef _RWSTD_NO_DEFAULT_TEMPLATE_ARGS
inline basic_string (void);
#endif
inline basic_string (const basic_string<charT, traits, Allocator>&);
basic_string (const basic_string<charT, traits, Allocator>&,
size_type, size_type _RWSTD_DEFAULT_ARG(npos),
const Allocator& _RWSTD_DEFAULT_ARG(Allocator()));
basic_string (const charT*, size_type,
const Allocator& _RWSTD_DEFAULT_ARG(Allocator()));
basic_string (const charT*, const Allocator& _RWSTD_DEFAULT_ARG(Allocator()));
#ifdef _RWSTD_NO_DEFAULT_TEMPLATE_ARGS
basic_string (const charT*, size_type);
basic_string (const charT*);
basic_string (size_type n, charT c) : __data_((charT*)0,Allocator())
{ __initn(n,c); }
#endif
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
template <class InputIterator>
basic_string (InputIterator, InputIterator, const Allocator& _RWSTD_DEFAULT_ARG(Allocator()));
basic_string (int n, charT c, const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
: __data_((charT*)0,alloc)
{ __initn(n,c); }
basic_string (unsigned int n, charT c, const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
: __data_((charT*)0,alloc)
{ __initn(n,c); }
basic_string (long n, charT c, const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
: __data_((charT*)0,alloc)
{ __initn(n,c); }
basic_string (unsigned long n, charT c, const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
: __data_((charT*)0,alloc)
{ __initn(n,c); }
basic_string (short n, charT c, const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
: __data_((charT*)0,alloc)
{ __initn(n,c); }
basic_string (unsigned short n, charT c, const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
: __data_((charT*)0,alloc)
{ __initn(n,c); }
basic_string (char n, charT c, const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
: __data_((charT*)0,alloc)
{ __initn(n,c); }
basic_string (unsigned char n, charT c, const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
: __data_((charT*)0,alloc)
{ __initn(n,c); }
#ifndef _RWSTD_NO_OVERLOAD_WCHAR
basic_string (wchar_t n, charT c, const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
: __data_((charT*)0,alloc)
{ __initn(n,c); }
#endif
#ifndef _RWSTD_NO_BOOL
basic_string (bool n, charT c, const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
: __data_((charT*)0,alloc)
{ __initn(n,c); }
#endif
#else
basic_string (size_type n, charT c, const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
: __data_((charT*)0,alloc)
{ __initn(n,c); }
#endif // _RWSTD_NO_MEMBER_TEMPLATES
basic_string (const charT*, const charT*, const Allocator& _RWSTD_DEFAULT_ARG(Allocator()));
#ifdef _RWSTD_NO_DEFAULT_TEMPLATE_ARGS
basic_string (const charT*, const charT*);
#endif
~basic_string ()
{
__unLink();
}
basic_string<charT, traits, Allocator>& operator= (const basic_string<charT, traits, Allocator>&);
basic_string<charT, traits, Allocator>& operator= (const charT*);
inline basic_string<charT, traits, Allocator>& operator= (charT);
//
// iterators
//
iterator begin ()
{ __cow(); __pref()->__setRefCount(0); return __data_.data(); }
const_iterator begin () const
{ return __data_.data(); }
iterator end ()
{ __cow(); __pref()->__setRefCount(0); return __data_.data()+length(); }
const_iterator end () const
{ return __data_.data()+length(); }
reverse_iterator rbegin ()
{ reverse_iterator tmp(end()); return tmp; }
const_reverse_iterator rbegin () const
{ const_reverse_iterator tmp(end()); return tmp; }
reverse_iterator rend ()
{ reverse_iterator tmp(begin()); return tmp; }
const_reverse_iterator rend () const
{ const_reverse_iterator tmp(begin()); return tmp; }
//
// capacity
//
size_type size () const { return length(); }
inline size_type length () const;
size_type max_size () const
{
return npos - sizeof(__rep_type)-2;
}
inline void resize (size_type, charT);
void resize (size_type n)
{
resize(n,__eos());
}
inline size_type capacity () const;
inline void reserve (size_type=0);
void clear () { erase(); }
bool empty () const { return length() == 0; }
//
// element access
//
inline const_reference operator[] (size_type) const;
inline reference operator[] (size_type);
inline const_reference at (size_type) const;
inline reference at (size_type);
//
// modifiers
//
inline basic_string<charT, traits, Allocator>& operator+= (const basic_string<charT, traits, Allocator>&);
inline basic_string<charT, traits, Allocator>& operator+= (const charT*);
inline basic_string<charT, traits, Allocator>& operator+= (charT);
basic_string<charT, traits, Allocator>& append (
const basic_string<charT, traits, Allocator>&);
basic_string<charT, traits, Allocator>& append (
const basic_string<charT, traits, Allocator>&,
size_type,
size_type);
inline basic_string<charT, traits, Allocator>& append (const charT*, size_type);
inline basic_string<charT, traits, Allocator>& append (const charT*);
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
template<class InputIterator>
inline basic_string<charT, traits, Allocator>& append (InputIterator,
InputIterator);
basic_string<charT, traits, Allocator>& append (int n, charT c)
{ return replace(length(),0,n,c); }
basic_string<charT, traits, Allocator>& append (unsigned int n, charT c)
{ return replace(length(),0,n,c); }
basic_string<charT, traits, Allocator>& append (long n, charT c)
{ return replace(length(),0,n,c); }
basic_string<charT, traits, Allocator>& append (unsigned long n, charT c)
{ return replace(length(),0,n,c); }
basic_string<charT, traits, Allocator>& append (short n, charT c)
{ return replace(length(),0,n,c); }
basic_string<charT, traits, Allocator>& append (unsigned short n, charT c)
{ return replace(length(),0,n,c); }
basic_string<charT, traits, Allocator>& append (char n, charT c)
{ return replace(length(),0,n,c); }
basic_string<charT, traits, Allocator>& append (unsigned char n, charT c)
{ return replace(length(),0,n,c); }
#ifndef _RWSTD_NO_OVERLOAD_WCHAR
basic_string<charT, traits, Allocator>& append (wchar_t n, charT c)
{ return replace(length(),0,n,c); }
#endif
#ifndef _RWSTD_NO_BOOL
basic_string<charT, traits, Allocator>& append (bool n, charT c)
{ return replace(length(),0,n,c); }
#endif
#else
inline basic_string<charT, traits, Allocator>& append (const charT*,
const charT*);
inline basic_string<charT, traits, Allocator>& append (size_type, charT);
#endif // _RWSTD_NO_MEMBER_TEMPLATES
inline void push_back(const charT);
basic_string<charT, traits, Allocator>& assign (
const basic_string<charT, traits, Allocator>&);
basic_string<charT, traits, Allocator>& assign (
const basic_string<charT, traits, Allocator>&,
size_type,
size_type);
inline basic_string<charT, traits, Allocator>& assign (const charT*, size_type);
inline basic_string<charT, traits, Allocator>& assign (const charT*);
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
template<class InputIterator>
inline basic_string<charT, traits, Allocator>& assign (InputIterator,
InputIterator);
basic_string<charT, traits, Allocator>& assign (int n, charT c)
{ return replace(0,length(),n,c); }
basic_string<charT, traits, Allocator>& assign (unsigned int n, charT c)
{ return replace(0,length(),n,c); }
basic_string<charT, traits, Allocator>& assign (long n, charT c)
{ return replace(0,length(),n,c); }
basic_string<charT, traits, Allocator>& assign (unsigned long n, charT c)
{ return replace(0,length(),n,c); }
basic_string<charT, traits, Allocator>& assign (short n, charT c)
{ return replace(0,length(),n,c); }
basic_string<charT, traits, Allocator>& assign (unsigned short n, charT c)
{ return replace(0,length(),n,c); }
basic_string<charT, traits, Allocator>& assign (char n, charT c)
{ return replace(0,length(),n,c); }
basic_string<charT, traits, Allocator>& assign (unsigned char n, charT c)
{ return replace(0,length(),n,c); }
#ifndef _RWSTD_NO_OVERLOAD_WCHAR
basic_string<charT, traits, Allocator>& assign (wchar_t n, charT c)
{ return replace(0,length(),n,c); }
#endif
#ifndef _RWSTD_NO_BOOL
basic_string<charT, traits, Allocator>& assign (bool n, charT c)
{ return replace(0,length(),n,c); }
#endif
#else
inline basic_string<charT, traits, Allocator>& assign (const charT*,
const charT*);
inline basic_string<charT, traits, Allocator>& assign (size_type, charT);
#endif // _RWSTD_NO_MEMBER_TEMPLATES
basic_string<charT, traits, Allocator>& insert (size_type,
const basic_string<charT, traits, Allocator>&);
basic_string<charT, traits, Allocator>& insert (
size_type,
const basic_string<charT, traits, Allocator>&,
size_type,
size_type);
inline basic_string<charT, traits, Allocator>& insert (
size_type,
const charT*,
size_type);
inline basic_string<charT, traits, Allocator>& insert (size_type, const charT*);
iterator insert (iterator pos, charT c)
{
iterator tmp = __replace_aux(pos-begin(), 0, basic_string<charT, traits, Allocator>(1,c));
__pref()->__setRefCount(0);
return tmp;
}
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
template<class InputIterator>
inline void insert (iterator, InputIterator, InputIterator);
void insert (iterator p, int n, charT c)
{ replace(p-begin(),0,n,c); }
void insert (iterator p, unsigned int n, charT c)
{ replace(p-begin(),0,n,c); }
void insert (iterator p, long n, charT c)
{ replace(p-begin(),0,n,c); }
void insert (iterator p, unsigned long n, charT c)
{ replace(p-begin(),0,n,c); }
void insert (iterator p, short n, charT c)
{ replace(p-begin(),0,n,c); }
void insert (iterator p, unsigned short n, charT c)
{ replace(p-begin(),0,n,c); }
void insert (iterator p, char n, charT c)
{ replace(p-begin(),0,n,c); }
void insert (iterator p, unsigned char n, charT c)
{ replace(p-begin(),0,n,c); }
basic_string<charT, traits, Allocator>& insert (size_type pos,int n,charT c)
{ return replace(pos,0,n,c); }
basic_string<charT, traits, Allocator>& insert (size_type pos,unsigned int n,charT c)
{ return replace(pos,0,n,c); }
basic_string<charT, traits, Allocator>& insert (size_type pos,long n,charT c)
{ return replace(pos,0,n,c); }
basic_string<charT, traits, Allocator>& insert (size_type pos,unsigned long n,charT c)
{ return replace(pos,0,n,c); }
basic_string<charT, traits, Allocator>& insert (size_type pos,short n,charT c)
{ return replace(pos,0,n,c); }
basic_string<charT, traits, Allocator>& insert (size_type pos,unsigned short n,charT c)
{ return replace(pos,0,n,c); }
basic_string<charT, traits, Allocator>& insert (size_type pos,char n,charT c)
{ return replace(pos,0,n,c); }
basic_string<charT, traits, Allocator>& insert (size_type pos,unsigned char n,charT c)
{ return replace(pos,0,n,c); }
#ifndef _RWSTD_NO_OVERLOAD_WCHAR
void insert (iterator p, wchar_t n, charT c)
{ replace(p-begin(),0,n,c); }
basic_string<charT, traits, Allocator>& insert (size_type pos,wchar_t n,charT c)
{ return replace(pos,0,n,c); }
#endif
#ifndef _RWSTD_NO_BOOL
void insert (iterator p, bool n, charT c)
{ replace(p-begin(),0,n,c);}
basic_string<charT, traits, Allocator>& insert (size_type pos,bool n,charT c)
{ return replace(pos,0,n,c); }
#endif
#else
inline void insert (iterator, const charT*, const charT*);
inline basic_string<charT, traits, Allocator>& insert (size_type,size_type,charT);
inline void insert (iterator, size_type, charT);
#endif // _RWSTD_NO_MEMBER_TEMPLATES
inline basic_string<charT, traits, Allocator>& erase (size_type = 0,
size_type = npos);
iterator erase (iterator it)
{
iterator ret = replace(it - begin(),1,(const charT *)NULL,0,0,0);
__pref()->__setRefCount(0);
return ret;
}
iterator erase (iterator first, iterator last)
{
iterator ret = replace(first - begin(),last-first,(const charT *)NULL,0,0,0);
__pref()->__setRefCount(0);
return ret;
}
private:
//
// Used for effiency
//
_TYPENAME
basic_string<charT, traits, Allocator>::iterator replace (size_type,
size_type,
const charT*,
size_type,
size_type,
size_type);
_TYPENAME
basic_string<charT, traits, Allocator>::iterator __replace_aux (
size_type,
size_type,
const basic_string<charT, traits, Allocator>&,
size_type =0,
size_type =npos);
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
template<class InputIterator>
basic_string<charT, traits, Allocator>& __replace_aux (
iterator first1,
iterator last1,
InputIterator first2,
InputIterator last2);
#endif
public:
inline basic_string<charT, traits, Allocator>& replace (size_type,
size_type,
const basic_string<charT, traits, Allocator>&);
inline basic_string<charT, traits, Allocator>& replace (size_type,
size_type,
const basic_string<charT, traits, Allocator>&,
size_type,
size_type);
inline basic_string<charT, traits, Allocator>& replace (size_type,
size_type,
const charT*,
size_type);
inline basic_string<charT, traits, Allocator>& replace (size_type,
size_type,
const charT*);
basic_string<charT, traits, Allocator>& replace (size_type,
size_type,
size_type,
charT);
inline basic_string<charT, traits, Allocator>& replace (iterator,
iterator,
const basic_string<charT, traits, Allocator>&);
inline basic_string<charT, traits, Allocator>& replace (iterator,
iterator,
const charT*,
size_type);
inline basic_string<charT, traits, Allocator>& replace (iterator,
iterator,
const charT*);
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
template<class InputIterator>
basic_string<charT, traits, Allocator>& replace (iterator, iterator,
InputIterator,
InputIterator);
basic_string<charT, traits, Allocator>& replace (iterator first,
iterator last,
int n,
charT c)
{ return replace(first-begin(),last-first,n,c); }
basic_string<charT, traits, Allocator>& replace (iterator first,
iterator last,
unsigned int n,
charT c)
{ return replace(first-begin(),last-first,n,c); }
basic_string<charT, traits, Allocator>& replace (iterator first,
iterator last,
long n,
charT c)
{ return replace(first-begin(),last-first,n,c); }
basic_string<charT, traits, Allocator>& replace (iterator first,
iterator last,
unsigned long n,
charT c)
{ return replace(first-begin(),last-first,n,c); }
basic_string<charT, traits, Allocator>& replace (iterator first,
iterator last,
short n,
charT c)
{ return replace(first-begin(),last-first,n,c); }
basic_string<charT, traits, Allocator>& replace (iterator first,
iterator last,
unsigned short n,
charT c)
{ return replace(first-begin(),last-first,n,c); }
basic_string<charT, traits, Allocator>& replace (iterator first,
iterator last,
char n,
charT c)
{ return replace(first-begin(),last-first,n,c); }
basic_string<charT, traits, Allocator>& replace (iterator first,
iterator last,
unsigned char n,
charT c)
{ return replace(first-begin(),last-first,n,c); }
#ifndef _RWSTD_NO_OVERLOAD_WCHAR
basic_string<charT, traits, Allocator>& replace (iterator first,
iterator last,
wchar_t n,
charT c)
{ return replace(first-begin(),last-first,n,c); }
#endif
#ifndef _RWSTD_NO_BOOL
basic_string<charT, traits, Allocator>& replace (iterator first,
iterator last,
bool n,
charT c)
{ return replace(first-begin(),last-first,n,c); }
#endif
#else
inline basic_string<charT, traits, Allocator>& replace (iterator, iterator,
const charT*,
const charT*);
inline basic_string<charT, traits, Allocator>& replace (iterator,
iterator,
size_type,
charT);
#endif // _RWSTD_NO_MEMBER_TEMPLATES
size_type copy (charT*, size_type, size_type = 0) const;
basic_string<charT, traits, Allocator> copy () const; // Returns deep copy
void swap(basic_string<charT, traits, Allocator>& s)
{
charT * temp = __data_.data(); __data_ = s.__data_.data(); s.__data_ = temp;
}
//
// string operations
//
inline const charT* c_str () const;
inline const charT* data () const;
allocator_type get_allocator() const
{
return (allocator_type)__data_;
}
inline size_type find (const basic_string<charT, traits, Allocator>&,
size_type = 0) const;
size_type find (const charT*, size_type, size_type) const;
inline size_type find (const charT*, size_type = 0) const;
inline size_type find (charT, size_type = 0) const;
inline size_type rfind (const basic_string<charT, traits, Allocator>&,
size_type = npos) const;
size_type rfind (const charT*, size_type, size_type) const;
inline size_type rfind (const charT*, size_type = npos) const;
inline size_type rfind (charT, size_type = npos) const;
inline size_type find_first_of (const basic_string<charT, traits, Allocator>&,
size_type = 0) const;
size_type find_first_of (const charT*, size_type, size_type) const;
inline size_type find_first_of (const charT*, size_type = 0) const;
inline size_type find_first_of (charT, size_type = 0) const;
inline size_type find_last_of (const basic_string<charT, traits, Allocator>&,
size_type = npos) const;
size_type find_last_of (const charT*, size_type, size_type) const;
inline size_type find_last_of (const charT*, size_type = npos) const;
inline size_type find_last_of (charT, size_type = npos) const;
inline size_type find_first_not_of (const basic_string<charT, traits, Allocator>&,
size_type = 0) const;
size_type find_first_not_of (const charT*, size_type ,
size_type) const;
inline size_type find_first_not_of (const charT*, size_type = 0) const;
inline size_type find_first_not_of (charT, size_type = 0) const;
inline size_type find_last_not_of (const basic_string<charT, traits, Allocator>&,
size_type = npos) const;
size_type find_last_not_of (const charT*, size_type, size_type) const;
inline size_type find_last_not_of (const charT*, size_type = npos) const;
inline size_type find_last_not_of (charT, size_type = npos) const;
basic_string<charT, traits, Allocator> substr (size_type = 0,
size_type = npos) const;
inline int compare(const basic_string<charT, traits, Allocator>&) const;
int compare(size_type, size_type,
const basic_string<charT, traits, Allocator>&) const;
int compare(size_type, size_type,
const basic_string<charT, traits, Allocator>&,
size_type, size_type) const;
inline int compare (const charT*) const;
int compare (size_type, size_type, const charT*, size_type) const;
inline int compare (size_type, size_type, const charT*) const;
protected:
size_type __getCapac () const { return __pref()->__getCapac(); }
void __clobber (size_type); // Remove old contents
void __cow () // Do copy on write as necessary
{
if (__pref()->__references() > 1)
__clone();
}
void __cow (size_type nc) // Do copy on write w/ new capacity
{
if (__pref()->__references() > 1 || __getCapac() < nc)
__clone(nc);
}
private:
void __initn(size_type, charT);
static charT __eos () { return (charT)0; }
//
// Make a distinct copy of self
//
void __clone ();
//
// Make a distinct copy w/ new capacity nc
//
void __clone (size_type nc);
__string_ref_type * __pref () const
{
#ifdef _RWSTD_SUNPRO_ANACHRONISM
return (__string_ref_type*)__data_.data() - 1;
#else
return _RWSTD_STATIC_CAST(__string_ref_type*,
((_RWSTD_REINTERPRET_CAST(__string_ref_type*,__data_.data())) - 1));
#endif
}
//
// Disconnect from ref, maybe delete it.
//
inline void __unLink ();
#ifndef _RWSTD_NO_NAMESPACE
friend class __RWSTD::__string_ref<charT,traits,Allocator>;
#else
friend class __string_ref<charT,traits,Allocator>;
#endif
//
// Null string ref
//
#ifndef _RWSTD_NO_STATIC_DEF3
static const __null_ref_type __nullref;
#endif
static __string_ref_type * __getNullRep ()
{
#ifndef _RWSTD_NO_STATIC_DEF3
# ifdef _RWSTD_NO_STATIC_CAST
return (__string_ref_type *)&__nullref;
# else
return reinterpret_cast<__string_ref_type *>
(const_cast<__null_ref_type *>(&__nullref));
# endif // _RWSTD_NO_STATIC_CAST
#else
if (!__RWSTD::__nullref_initialized)
{
new (&__RWSTD::__nullref) __null_ref_type();
__RWSTD::__nullref_initialized = 1;
}
return (__string_ref_type *) &__RWSTD::__nullref[0];
#endif // _RWSTD_NO_STATIC_DEF3
}
__string_ref_type * __getRep (size_type capac, size_type nchar);
__RWSTD::__rw_basis<charT*,allocator_type> __data_;
};
//
// Standard Type Definitions
//
typedef basic_string<char, char_traits<char>, allocator<char> >
string;
#ifndef _RWSTD_NO_WIDE_CHAR
typedef basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >
wstring;
#endif
//
// The following has to go after the declaration of the string
// classes because of cross references.
//
#ifndef _RWSTD_NO_NAMESPACE
}
#endif
#ifdef _RW_STD_EXCEPT
#include <stdexcept>
#endif
#if defined(_RWSTD_NO_DESTROY_BUILTIN) || defined(_RWSTD_NO_DESTROY_NONBUILTIN)
#ifndef _RWSTD_NO_NAMESPACE
namespace __rwstd {
#endif
//
// Specializations for STL destroy
//
inline void __destroy (string**) {;}
inline void __destroy (string***) {;}
inline void __destroy (string****) {;}
#ifndef _RWSTD_NO_WIDE_CHAR
inline void __destroy (wstring**) {;}
inline void __destroy (wstring***) {;}
inline void __destroy (wstring****) {;}
#endif
#ifndef _RWSTD_NO_NAMESPACE
}
#endif
#endif // _RWSTD_NO_DESTROY_BUILTIN || _RWSTD_NO_DESTROY_NONBUILTIN
#ifndef _RWSTD_NO_NAMESPACE
namespace std {
#endif
//
// Inline member functions for class basic_string
//
template <class charT, class traits , class Allocator >
inline void basic_string<charT, traits, Allocator>::__unLink()
{
if (!__data_.data())
return;
if (__pref()->__references() == 0 || __pref()->__removeReference() == 0)
{
__ref_alloc_type(__data_).destroy(__pref());
__value_alloc_type(__data_).
deallocate(_RWSTD_REINTERPRET_CAST(charT*,__pref()),length());
__data_ = (charT*)0;
}
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator>
::basic_string (const Allocator& alloc) : __data_((charT*)0,alloc)
{
__data_ = __getNullRep()->data();
__getNullRep()->__addReference();
}
#ifdef _RWSTD_NO_DEFAULT_TEMPLATE_ARGS
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator>
::basic_string (void) : __data_((charT*)0,Allocator())
{
__data_ = __getNullRep()->data();
__getNullRep()->__addReference();
}
#endif
template <class charT, class traits , class Allocator >
inline
basic_string<charT, traits, Allocator>
::basic_string (const basic_string<charT, traits, Allocator> & s)
: __data_((charT*)0,Allocator())
{
if ( s.__pref()->__references() > 0 )
{
__data_ = s.__data_.data();
__pref()->__addReference();
}
else
{
size_type n = s.length();
__data_ = __getRep(n, n)->data();
traits::copy(__data_.data(), s.c_str(), n);
}
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> &
basic_string<charT, traits, Allocator>::operator= (charT c)
{
replace(0,length(),1,c);
return *this;
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> &
basic_string<charT, traits, Allocator>::operator+= (const basic_string<charT, traits, Allocator>& s)
{
return append(s);
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> &
basic_string<charT, traits, Allocator>::operator+= (const charT* s)
{
return append(s);
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> &
basic_string<charT, traits, Allocator>::operator+= (charT c)
{
return append((size_type) 1, c);
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> &
basic_string<charT, traits, Allocator>::append (const charT* s, size_type n)
{
replace(size(),0,s,n,0,n);
return *this;
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> &
basic_string<charT, traits, Allocator>::append (const charT* s)
{
replace(size(),0,s);
return *this;
}
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
template<class charT, class traits , class Allocator >
template<class InputIterator>
inline basic_string<charT, traits, Allocator>&
basic_string<charT, traits, Allocator>::append (InputIterator first,
InputIterator last )
{
replace(end(),end(),first,last);
return *this;
}
#else
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator>&
basic_string<charT, traits, Allocator>::append (const charT* first,
const charT* last)
{
replace(size(),0,first,last-first,0,last-first);
return *this;
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> &
basic_string<charT, traits, Allocator>::append (size_type n, charT c)
{
replace(length(),0,n,c);
return *this;
}
#endif // _RWSTD_NO_MEMBER_TEMPLATES
template <class charT, class traits , class Allocator >
void basic_string<charT, traits, Allocator>::push_back(const charT c)
{
replace(size(),0,1,c);
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> &
basic_string<charT, traits, Allocator>::assign (const charT* s, size_type n)
{
replace(0, length(), s, n, 0, n);
return *this;
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> &
basic_string<charT, traits, Allocator>::assign (const charT* s)
{
size_type len = traits::length(s);
replace(0, length(), s, len, 0, len);
return *this;
}
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
template<class charT, class traits , class Allocator >
template<class InputIterator>
inline basic_string<charT, traits, Allocator>&
basic_string<charT, traits, Allocator>::assign (InputIterator first,
InputIterator last)
{
replace(begin(),end(),first,last);
return *this;
}
#else
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator>&
basic_string<charT, traits, Allocator>::assign (const charT* first,
const charT* last)
{
replace(0,length(),first,last-first,0,last-first);
return *this;
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> &
basic_string<charT, traits, Allocator>::assign (size_type n, charT c)
{
return replace(0,length(),n,c);
}
#endif // _RWSTD_NO_MEMBER_TEMPLATES
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> &
basic_string<charT, traits, Allocator>::insert (size_type pos,
const charT* s,
size_type n)
{
replace(pos, 0, s, n, 0, n);
return *this;
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> &
basic_string<charT, traits, Allocator>::insert (size_type pos, const charT* s)
{
size_type len = traits::length(s);
replace(pos, 0, s, len, 0, len);
return *this;
}
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
template<class charT, class traits , class Allocator >
template<class InputIterator>
inline void
basic_string<charT, traits, Allocator>::insert (
iterator p,
InputIterator first,
InputIterator last)
{
replace(p,p,first,last);
}
#else
template <class charT, class traits , class Allocator >
inline void
basic_string<charT, traits, Allocator>::insert (
iterator p,
const charT* first,
const charT* last)
{
replace(p-begin(),0,first,last-first,0,last-first);
}
template <class charT, class traits , class Allocator >
inline void
basic_string<charT, traits, Allocator>::insert (
iterator p,
size_type n,
charT c)
{
replace(p-begin(),0,n,c);
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> &
basic_string<charT, traits, Allocator>::insert(size_type pos,
size_type n,
charT c)
{
return replace(pos,0,n,c);
}
#endif // _RWSTD_NO_MEMBER_TEMPLATES
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> &
basic_string<charT, traits, Allocator>::erase (size_type pos, size_type n)
{
_RWSTD_THROW(pos > length(), out_of_range,
__RWSTD::except_msg_string(__RWSTD::__rwse_StringIndexOutOfRange,
"basic_string::erase(size_t,size_t)", pos,length()).msgstr());
size_type len = length() - pos;
charT tmp[1];
*tmp = 0;
return replace(pos,n < len ? n : len, tmp,0);
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> &
basic_string<charT, traits, Allocator>::replace (size_type pos1,
size_type n1,
const basic_string<charT, traits, Allocator> & str,
size_type pos2,
size_type n2)
{
replace(pos1, n1, str.data(), str.length(), pos2, n2);
return *this;
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> &
basic_string<charT, traits, Allocator>::replace (
size_type pos1,
size_type n1,
const basic_string<charT, traits, Allocator> & str)
{
replace(pos1, n1, str.data(), str.length(),0,str.length());
return *this;
}
template <class charT, class traits , class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::iterator
basic_string<charT, traits, Allocator>::__replace_aux (size_type pos1,
size_type n1,
const basic_string<charT, traits, Allocator> & str,
size_type pos2,
size_type n2)
{
return replace(pos1, n1, str.data(), str.length(), pos2, n2);
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> &
basic_string<charT, traits, Allocator>::replace (size_type pos,
size_type n1,
const charT* s,
size_type n2)
{
replace(pos, n1, s, n2, 0, n2);
return *this;
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> &
basic_string<charT, traits, Allocator>::replace (size_type pos,
size_type n1,
const charT* s)
{
size_type len = traits::length(s);
replace(pos, n1, s, len, 0, len);
return *this;
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator>&
basic_string<charT, traits, Allocator>::replace (
iterator first,
iterator last,
const basic_string<charT, traits, Allocator>& str)
{
return replace(first - begin(), last - first, str);
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator>&
basic_string<charT, traits, Allocator>::replace (
iterator first,
iterator last,
const charT* s,
size_type n)
{
replace(first-begin(),last-first,s,n,0,n);
return *this;
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator>&
basic_string<charT, traits, Allocator>::replace (
iterator first,
iterator last,
const charT* s)
{
size_type len = traits::length(s);
replace(first-begin(),last-first,s,len,0,len);
return *this;
}
#ifdef _RWSTD_NO_MEMBER_TEMPLATES
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator>&
basic_string<charT, traits, Allocator>::replace (
iterator first1,
iterator last1,
const charT* first2,
const charT* last2)
{
replace(first1-begin(),last1-first1,first2,last2-first2,0,last2-first2);
return *this;
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator>&
basic_string<charT, traits, Allocator>::replace (
iterator first,
iterator last,
size_type n,
charT c)
{
return replace(first-begin(),last-first,n,c);
}
#endif
template <class charT, class traits , class Allocator >
inline _TYPENAME basic_string<charT, traits,Allocator>::const_reference
basic_string<charT, traits, Allocator>::operator[] (size_type pos) const
{
#ifdef _RWSTD_BOUNDS_CHECKING
_RWSTD_THROW(pos > size(), out_of_range,
__RWSTD::except_msg_string(__RWSTD::__rwse_PosBeyondEndOfString,
"basic_string::operator[](size_t) const", pos,size()).msgstr());
#endif
return __data_.data()[pos];
}
template <class charT, class traits , class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::reference
basic_string<charT, traits, Allocator>::operator[] (size_type pos)
{
#ifdef _RWSTD_BOUNDS_CHECKING
_RWSTD_THROW(pos >= size(), out_of_range,
__RWSTD::except_msg_string(__RWSTD::__rwse_PosBeyondEndOfString,
"basic_string::operator[](size_t)", pos,size()).msgstr());
#endif
__cow();
__pref()->__setRefCount(0);
return __data_.data()[pos];
}
template <class charT, class traits , class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::const_reference
basic_string<charT, traits, Allocator>::at (size_type pos) const
{
_RWSTD_THROW(pos >= size(), out_of_range,
__RWSTD::except_msg_string(__RWSTD::__rwse_PosBeyondEndOfString,
"basic_string::at(size_t) const", pos,size()).msgstr());
return __data_.data()[pos];
}
template <class charT, class traits , class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::reference
basic_string<charT, traits, Allocator>::at (size_type pos)
{
_RWSTD_THROW(pos >= size(), out_of_range,
__RWSTD::except_msg_string(__RWSTD::__rwse_PosBeyondEndOfString,
"basic_string::at(size_t)", pos,size()).msgstr());
__cow();
__pref()->__setRefCount(0);
return __data_.data()[pos];
}
template <class charT, class traits , class Allocator >
inline const charT* basic_string<charT, traits, Allocator>::c_str () const
{
return __data_.data();
}
template <class charT, class traits , class Allocator >
inline const charT* basic_string<charT, traits, Allocator>::data () const
{
return __data_.data();
}
template <class charT, class traits , class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::size_type
basic_string<charT, traits, Allocator>::length () const
{
return __pref()->__nchars_;
}
template <class charT, class traits , class Allocator >
inline void
basic_string<charT, traits, Allocator>::resize (size_type n, charT c)
{
_RWSTD_THROW(n > max_size(), length_error,
__RWSTD::except_msg_string(__RWSTD::__rwse_InvalidSizeParam,
"basic_string( const charT*,size_type,const Allocator&)",n,npos).msgstr());
if (n < length())
erase(n,length()-n);
else
replace(length(),0,n-length(),c);
__pref()->__setRefCount(1);
}
template <class charT, class traits , class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::size_type
basic_string<charT, traits, Allocator>::capacity () const
{
return __getCapac();
}
template <class charT, class traits , class Allocator >
inline void basic_string<charT, traits, Allocator>::reserve(size_type res_arg)
{
_RWSTD_THROW(res_arg > max_size(), length_error,
__RWSTD::except_msg_string(__RWSTD::__rwse_InvalidSizeParam,
"basic_string::reserve(size_t)",res_arg,max_size()).msgstr());
if (res_arg > __getCapac()) __clone(res_arg);
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator>
basic_string<charT, traits, Allocator>::copy () const
{
basic_string<charT, traits, Allocator> temp(*this); // Make referenced copy
temp.__clone(); // Make a distinct copy
return temp;
}
template <class charT, class traits, class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::size_type
basic_string<charT, traits, Allocator>::find (
const basic_string<charT, traits, Allocator>& str,
size_type pos) const
{
return find(str.c_str(),pos,str.length());
}
template <class charT, class traits , class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::size_type
basic_string<charT, traits, Allocator>::find (const charT* s,
size_type pos) const
{
_RWSTD_THROW(s == 0, logic_error,
__RWSTD::except_msg_string(__RWSTD::__rwse_UnexpectedNullPtr,
"basic_string::find(const char*,size_t) const").msgstr());
if (pos > length())
return npos;
const charT* p = __RWSTD::rw_traits<charT,traits>::find(__data_.data()+pos,s);
return p ? p - __data_.data() : npos;
}
template <class charT, class traits , class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::size_type
basic_string<charT, traits, Allocator>::find (charT c, size_type pos) const
{
if (pos > length())
return npos;
const charT* p = traits::find(__data_.data()+pos,length()-pos,c);
return p ? p - __data_.data() : npos;
}
template <class charT, class traits, class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::size_type
basic_string<charT, traits, Allocator>::rfind (
const basic_string<charT, traits, Allocator>& str,
size_type pos) const
{
return rfind(str.c_str(), pos, str.length());
}
template <class charT, class traits , class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::size_type
basic_string<charT, traits, Allocator>::rfind (const charT* s, size_type pos)
const
{
size_type len = traits::length(s);
return rfind(s, pos,len);
}
template <class charT, class traits , class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::size_type
basic_string<charT, traits, Allocator>::rfind (charT c, size_type pos) const
{
if (pos > length())
pos = length();
const charT* p = __RWSTD::rw_traits<charT,traits>::rfind(__data_.data(),c,pos);
return p ? p - __data_.data() : npos;
}
template <class charT, class traits, class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::size_type
basic_string<charT, traits, Allocator>::find_first_of (
const basic_string<charT, traits, Allocator>& str,
size_type pos) const
{
return find_first_of(str.c_str(),pos,str.length());
}
template <class charT, class traits , class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::size_type
basic_string<charT, traits, Allocator>::find_first_of (const charT* s,
size_type pos) const
{
_RWSTD_THROW(s == 0, logic_error,
__RWSTD::except_msg_string(__RWSTD::__rwse_UnexpectedNullPtr,
"basic_string::find_first_of(char*,size_t) const").msgstr());
if (pos > length())
return npos;
size_type i = __RWSTD::rw_traits<charT,traits>::find_first_of(__data_.data()+pos,s) + pos;
return i >= length() ? npos : i;
}
template <class charT, class traits , class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::size_type
basic_string<charT, traits, Allocator>::find_first_of (charT c, size_type pos) const
{
return find(c, pos);
}
template <class charT, class traits, class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::size_type
basic_string<charT, traits, Allocator>::find_last_of (
const basic_string<charT, traits, Allocator>& str,
size_type pos) const
{
return find_last_of(str.c_str(), pos,str.length());
}
template <class charT, class traits , class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::size_type
basic_string<charT, traits, Allocator>::find_last_of (const charT* s,
size_type pos) const
{
size_type len = traits::length(s);
return find_last_of(s, pos,len);
}
template <class charT, class traits , class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::size_type
basic_string<charT, traits, Allocator>::find_last_of (charT c, size_type pos)
const
{
return rfind(c,pos);
}
template <class charT, class traits, class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::size_type
basic_string<charT, traits, Allocator>::find_first_not_of (
const basic_string<charT, traits, Allocator>& str,
size_type pos) const
{
return find_first_not_of(str.c_str(), pos, str.length());
}
template <class charT, class traits , class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::size_type
basic_string<charT, traits, Allocator>::find_first_not_of (const charT* s,
size_type pos) const
{
_RWSTD_THROW(s == 0, logic_error,
__RWSTD::except_msg_string(__RWSTD::__rwse_UnexpectedNullPtr,
"basic_string::find_first_not_of(char*,size_t) const").msgstr());
if (pos > length())
return npos;
size_type i = __RWSTD::rw_traits<charT,traits>::find_first_not_of(__data_.data()+pos,s) + pos;
return i >= length() ? npos : i;
}
template <class charT, class traits , class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::size_type
basic_string<charT, traits, Allocator>::find_first_not_of (charT c,
size_type pos) const
{
charT tmp[2];
*tmp = c;
tmp[1] = 0;
return find_first_not_of(tmp, pos);
}
template <class charT, class traits, class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::size_type
basic_string<charT, traits, Allocator>::find_last_not_of (
const basic_string<charT, traits, Allocator>& str,
size_type pos) const
{
return find_last_not_of(str.c_str(), pos, str.length());
}
template <class charT, class traits , class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::size_type
basic_string<charT, traits, Allocator>::find_last_not_of (const charT* s,
size_type pos) const
{
size_type len = traits::length(s);
return find_last_not_of(s, pos, len);
}
template <class charT, class traits , class Allocator >
inline _TYPENAME basic_string<charT, traits, Allocator>::size_type
basic_string<charT, traits, Allocator>::find_last_not_of (charT c,
size_type pos) const
{
charT tmp[2];
*tmp = c;
tmp[1] = 0;
return find_last_not_of(tmp, pos);
}
template <class charT, class traits, class Allocator >
inline int
basic_string<charT, traits, Allocator>::compare (
const basic_string<charT, traits, Allocator>& str) const
{
return compare(0,length(),str.c_str(),str.length());
}
template <class charT, class traits , class Allocator >
inline int
basic_string<charT, traits, Allocator>::compare (size_type pos,
size_type n1,
const charT* s) const
{
size_type len = traits::length(s);
return compare(pos,n1,s,len);
}
template <class charT, class traits , class Allocator >
inline int
basic_string<charT, traits, Allocator>::compare (const charT* s) const
{
size_type len = traits::length(s);
return compare(0,length(),s,len);
}
//
// Inlined non-member operators
//
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> operator+(
const basic_string<charT, traits, Allocator>& lhs,
const basic_string<charT, traits, Allocator>& rhs)
{
return basic_string<charT, traits, Allocator>(lhs).append(rhs);
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> operator+(
const charT* lhs,
const basic_string<charT, traits, Allocator>& rhs)
{
return basic_string<charT, traits, Allocator>(lhs).append(rhs);
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> operator+(
charT lhs, const basic_string<charT, traits, Allocator>& rhs)
{
return basic_string<charT, traits, Allocator>(1,lhs).append(rhs);
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> operator+(
const basic_string<charT, traits, Allocator>& lhs,
const charT* rhs)
{
return basic_string<charT,traits,Allocator>(lhs).append(basic_string<charT, traits, Allocator>(rhs));
}
template <class charT, class traits , class Allocator >
inline basic_string<charT, traits, Allocator> operator+(
const basic_string<charT, traits, Allocator>& lhs,
charT rhs)
{
return basic_string<charT,traits,Allocator>(lhs).append(basic_string<charT, traits, Allocator>(1,rhs));
}
template <class charT, class traits , class Allocator >
inline bool operator==(
const basic_string<charT, traits, Allocator>& lhs,
const basic_string<charT, traits, Allocator>& rhs)
{
return lhs.compare(rhs) == 0 ? true : false ;
}
template <class charT, class traits , class Allocator >
inline bool operator==(
const charT* lhs,
const basic_string<charT, traits, Allocator>& rhs)
{
return basic_string<charT,traits,Allocator>(lhs).compare(rhs)==0?true:false;
}
template <class charT, class traits , class Allocator >
inline bool operator==(
const basic_string<charT, traits, Allocator>& lhs,
const charT* rhs)
{
return lhs.compare(basic_string<charT,traits,Allocator>(rhs))==0?true:false;
}
template <class charT, class traits , class Allocator >
inline bool operator<(
const basic_string<charT, traits, Allocator>& lhs,
const basic_string<charT, traits, Allocator>& rhs)
{
return lhs.compare(rhs) < 0 ? true:false ;
}
template <class charT, class traits , class Allocator >
inline bool operator<(
const charT* lhs,
const basic_string<charT, traits, Allocator>& rhs)
{
return basic_string<charT,traits,Allocator>(lhs).compare(rhs)<0?true:false;
}
template <class charT, class traits , class Allocator >
inline bool operator<(
const basic_string<charT, traits, Allocator>& lhs,
const charT* rhs)
{
return lhs.compare(basic_string<charT,traits,Allocator>(rhs))<0?true:false;
}
#if !defined(_RWSTD_NO_NAMESPACE) || !defined(_RWSTD_NO_PART_SPEC_OVERLOAD)
template <class charT, class traits , class Allocator >
inline bool operator!=(
const basic_string<charT, traits, Allocator>& lhs,
const basic_string<charT, traits, Allocator>& rhs)
{
return lhs.compare(rhs) != 0 ? true : false;
}
#endif
template <class charT, class traits , class Allocator >
inline bool operator!=(
const charT* lhs,
const basic_string<charT, traits, Allocator>& rhs)
{
return basic_string<charT,traits,Allocator>(lhs).compare(rhs)!=0?true:false;
}
template <class charT, class traits , class Allocator >
inline bool operator!=(
const basic_string<charT, traits, Allocator>& lhs,
const charT* rhs)
{
return lhs.compare(basic_string<charT,traits,Allocator>(rhs))!=0?true:false;
}
#if !defined(_RWSTD_NO_NAMESPACE) || !defined(_RWSTD_NO_PART_SPEC_OVERLOAD)
template <class charT, class traits , class Allocator >
inline bool operator>(
const basic_string<charT, traits, Allocator>& lhs,
const basic_string<charT, traits, Allocator>& rhs)
{
return lhs.compare(rhs) > 0 ? true : false;
}
#endif
template <class charT, class traits , class Allocator >
inline bool operator>(
const charT* lhs,
const basic_string<charT, traits, Allocator>& rhs)
{
return basic_string<charT,traits,Allocator>(lhs).compare(rhs)>0?true:false;
}
template <class charT, class traits , class Allocator >
inline bool operator>(
const basic_string<charT, traits, Allocator>& lhs,
const charT* rhs)
{
return lhs.compare(basic_string<charT,traits,Allocator>(rhs))>0?true:false;
}
#if !defined(_RWSTD_NO_NAMESPACE) || !defined(_RWSTD_NO_PART_SPEC_OVERLOAD)
template <class charT, class traits , class Allocator >
inline bool operator<=(
const basic_string<charT, traits, Allocator>& lhs,
const basic_string<charT, traits, Allocator>& rhs)
{
return lhs.compare(rhs) <= 0 ? true : false;
}
#endif
template <class charT, class traits , class Allocator >
inline bool operator<=(
const charT* lhs,
const basic_string<charT, traits, Allocator>& rhs)
{
return basic_string<charT,traits,Allocator>(lhs).compare(rhs)<=0?true:false;
}
template <class charT, class traits , class Allocator >
inline bool operator<=(
const basic_string<charT, traits, Allocator>& lhs,
const charT* rhs)
{
return lhs.compare(basic_string<charT,traits,Allocator>(rhs))<=0?true:false;
}
#if !defined(_RWSTD_NO_NAMESPACE) || !defined(_RWSTD_NO_PART_SPEC_OVERLOAD)
template <class charT, class traits , class Allocator >
inline bool operator>=(
const basic_string<charT, traits, Allocator>& lhs,
const basic_string<charT, traits, Allocator>& rhs)
{
return lhs.compare(rhs) >= 0 ? true:false;
}
#endif
template <class charT, class traits , class Allocator >
inline bool operator>=(
const charT* lhs,
const basic_string<charT, traits, Allocator>& rhs)
{
return basic_string<charT,traits,Allocator>(lhs).compare(rhs)>=0?true:false;
}
template <class charT, class traits , class Allocator >
inline bool operator>=(
const basic_string<charT, traits, Allocator>& lhs,
const charT* rhs)
{
return lhs.compare(basic_string<charT,traits,Allocator>(rhs))>=0?true:false;
}
#if !defined(_RWSTD_NO_NAMESPACE) || !defined(_RWSTD_NO_PART_SPEC_OVERLOAD)
template <class charT, class traits, class Allocator>
inline void swap(basic_string<charT,traits,Allocator>& a,
basic_string<charT,traits,Allocator>& b)
{
a.swap(b);
}
#endif
#ifndef _RW_STD_IOSTREAM
template<class charT, class traits , class Allocator >
istream & _RWSTDExportTemplate operator >> (
istream & is, basic_string<charT, traits, Allocator > & str);
template<class charT, class traits , class Allocator >
ostream& _RWSTDExportTemplate operator << (
ostream & os, const basic_string<charT, traits, Allocator > & str);
template<class Stream, class charT, class traits , class Allocator >
Stream& _RWSTDExportTemplate getline(Stream& is,
basic_string<charT, traits,Allocator>& str, charT delim);
template<class Stream, class charT, class traits , class Allocator >
Stream& _RWSTDExportTemplate getline(Stream& is,
basic_string<charT, traits,Allocator>& str)
{ return getline(is,str,'\n'); }
#endif /*_RW_STD_IOSTREAM*/
#ifdef _RWSTD_MSC22_STATIC_INIT_BUG
#undef npos
#endif
#ifndef _RWSTD_NO_NAMESPACE
}
#endif
#ifdef _RWSTD_COMPILE_INSTANTIATE
#include <string.cc>
#endif
#endif /*defined __STD_STRING*/
#pragma option pop
#endif /* __STRING_STL */
Reference in a new issue Copy permalink