Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages

MNRope Class Reference
[Ropes that hold unsigned characters]

#include <MNRope.h>

Collaboration diagram for MNRope:

Collaboration graph
[legend]
List of all members.

Public Types

typedef uchar_t value_type
typedef ptrdiff_t difference_type
typedef uchar_t const_reference
typedef const uchar_t * const_pointer
typedef MNRefProxy reference
typedef MNPtrProxy pointer
typedef reverse_iterator<
MNRopeConstIterator > 		const_reverse_iterator
typedef reverse_iterator<
MNRopeConstIterator, value_type,
const_reference, difference_type > 		const_reverse_iterator
typedef reverse_iterator<
iterator > 		reverse_iterator
typedef reverse_iterator<
iterator, value_type, reference,
difference_type > 		reverse_iterator

Public Member Functions

void apply_to_pieces (size_t __begin, size_t __end, MNRopeCharConsumer &__c) const
bool empty () const
int compare (const MNRope &__y) const
 MNRope (const uchar_t *__s)
 MNRope (const uchar_t *__s, size_t __len)
 MNRope (const uchar_t *__s, const uchar_t *__e)
 MNRope (uchar_t __c)
 MNRope (size_t __n, uchar_t __c)
 MNRope ()
 MNRope (MNRopeCharProducer *__fn, size_t __len, bool __delete_fn)
 Construct a rope from a function that can compute its members.
 MNRope (const MNRope &__x)
 MNRope (MNRopeRep *__t)
 ~MNRope ()
MNRope & operator= (const MNRope &__x)
void clear ()
void push_back (uchar_t __x)
void pop_back ()
uchar_t back () const
void push_front (uchar_t __x)
void pop_front ()
uchar_t front () const
void balance ()
void copy (uchar_t *__buffer) const
size_t copy (size_t __pos, size_t __n, uchar_t *__buffer) const
void dump ()
const uchar_t * c_str () const
const uchar_t * replace_with_c_str ()
void delete_c_str ()
uchar_t operator[] (size_t __pos) const
uchar_t at (size_t __pos) const
size_t size () const
size_t length () const
size_t max_size () const
MNRope & append (const uchar_t *__iter, size_t __n)
MNRope & append (const uchar_t *__c_string)
MNRope & append (const uchar_t *__s, const uchar_t *__e)
MNRope & append (uchar_t __c)
MNRope & append ()
MNRope & append (const MNRope &__y)
MNRope & append (size_t __n, uchar_t __c)
void swap (MNRope &__b)
void insert (size_t __p, const MNRope &__r)
void insert (size_t __p, size_t __n, uchar_t __c)
void insert (size_t __p, const uchar_t *__i, size_t __n)
void insert (size_t __p, const uchar_t *__c_string)
void insert (size_t __p, uchar_t __c)
void insert (size_t __p)
void insert (size_t __p, const uchar_t *__i, const uchar_t *__j)
void erase (size_t __p, size_t __n)
 Erase, (position, size) variant.
void erase (size_t __p)
 Erase, single character.
MNRope substr (size_t __start, size_t __len=1) const
size_t find (uchar_t __c, size_t __pos=0) const
reference mutable_reference_at (size_t __pos)
reference operator[] (size_t __pos)
reference at (size_t __pos)
void resize (size_t __n, uchar_t __c)
void resize (size_t __n)
void reserve (size_t __res_arg=0)
size_t capacity () const
size_t copy (uchar_t *__buffer, size_t __n, size_t __pos=0) const
 MNRope (const MNRopeConstIterator &__s, const MNRopeConstIterator &__e)
 MNRope (const MNRopeIterator &__s, const MNRopeIterator &__e)
MNRopeConstIterator begin () const
MNRopeConstIterator const_begin () const
 An easy way to get a const iterator from a non-const container.
MNRopeConstIterator end () const
MNRopeConstIterator const_end () const
const_reverse_iterator rbegin () const
const_reverse_iterator const_rbegin () const
const_reverse_iterator rend () const
const_reverse_iterator const_rend () const
MNRope & append (MNRopeConstIterator __s, MNRopeConstIterator __e)
void insert (size_t __p, const MNRopeConstIterator &__i, const MNRopeConstIterator &__j)
void insert (size_t __p, const MNRopeIterator &__i, const MNRopeIterator &__j)
void replace (size_t __p, size_t __n, const MNRopeConstIterator &__i, const MNRopeConstIterator &__j)
void replace (size_t __p, size_t __n, const MNRopeIterator &__i, const MNRopeIterator &__j)
size_t find (const uchar_t *__s, size_t __pos=0) const
MNRopeIterator mutable_begin ()
MNRopeIterator mutable_end ()
reverse_iterator mutable_rbegin ()
reverse_iterator mutable_rend ()
iterator end ()
iterator begin ()
reverse_iterator rend ()
reverse_iterator rbegin ()
MNRopeConstIterator end ()
MNRopeConstIterator begin ()
const_reverse_iterator rend ()
const_reverse_iterator rbegin ()
void replace (size_t __p, size_t __n, const MNRope &__r)
void replace (size_t __p, size_t __n, const uchar_t *__i, size_t __i_len)
void replace (size_t __p, size_t __n, uchar_t __c)
void replace (size_t __p, size_t __n, const uchar_t *__c_string)
void replace (size_t __p, size_t __n, const uchar_t *__i, const uchar_t *__j)
void replace (size_t __p, const MNRope &__r)
void replace (size_t __p, const uchar_t *__i, size_t __i_len)
void replace (size_t __p, const uchar_t *__c_string)
void replace (size_t __p, const uchar_t *__i, const uchar_t *__j)
void replace (size_t __p, uchar_t __c)
void replace (size_t __p, const MNRopeConstIterator &__i, const MNRopeConstIterator &__j)
void replace (size_t __p, const MNRopeIterator &__i, const MNRopeIterator &__j)
MNRopeIterator insert (const MNRopeIterator &__p, const MNRope &__r)
MNRopeIterator insert (const MNRopeIterator &__p, size_t __n, uchar_t __c)
MNRopeIterator insert (const MNRopeIterator &__p, uchar_t __c)
MNRopeIterator insert (const MNRopeIterator &__p)
MNRopeIterator insert (const MNRopeIterator &__p, const uchar_t *c_string)
MNRopeIterator insert (const MNRopeIterator &__p, const uchar_t *__i, size_t __n)
MNRopeIterator insert (const MNRopeIterator &__p, const uchar_t *__i, const uchar_t *__j)
MNRopeIterator insert (const MNRopeIterator &__p, const MNRopeConstIterator &__i, const MNRopeConstIterator &__j)
MNRopeIterator insert (const MNRopeIterator &__p, const MNRopeIterator &__i, const MNRopeIterator &__j)
void replace (const MNRopeIterator &__p, const MNRopeIterator &__q, const MNRope &__r)
void replace (const MNRopeIterator &__p, const MNRopeIterator &__q, uchar_t __c)
void replace (const MNRopeIterator &__p, const MNRopeIterator &__q, const uchar_t *__c_string)
void replace (const MNRopeIterator &__p, const MNRopeIterator &__q, const uchar_t *__i, size_t __n)
void replace (const MNRopeIterator &__p, const MNRopeIterator &__q, const uchar_t *__i, const uchar_t *__j)
void replace (const MNRopeIterator &__p, const MNRopeIterator &__q, const MNRopeConstIterator &__i, const MNRopeConstIterator &__j)
void replace (const MNRopeIterator &__p, const MNRopeIterator &__q, const MNRopeIterator &__i, const MNRopeIterator &__j)
void replace (const MNRopeIterator &__p, const MNRope &__r)
void replace (const MNRopeIterator &__p, uchar_t __c)
void replace (const MNRopeIterator &__p, const uchar_t *__c_string)
void replace (const MNRopeIterator &__p, const uchar_t *__i, size_t __n)
void replace (const MNRopeIterator &__p, const uchar_t *__i, const uchar_t *__j)
void replace (const MNRopeIterator &__p, MNRopeConstIterator __i, MNRopeConstIterator __j)
void replace (const MNRopeIterator &__p, MNRopeIterator __i, MNRopeIterator __j)
MNRopeIterator erase (const MNRopeIterator &__p, const MNRopeIterator &__q)
MNRopeIterator erase (const MNRopeIterator &__p)
MNRope substr (MNRopeIterator __start, MNRopeIterator __end) const
MNRope substr (MNRopeIterator __start) const
MNRope substr (MNRopeConstIterator __start, MNRopeConstIterator __end) const
MNRope substr (MNRopeConstIterator __start)

Static Public Attributes

const size_t npos

Protected Types

typedef uchar_t * _Cstrptr
enum  { _S_copy_max = 23 }

Static Protected Member Functions

bool _S_is0 (uchar_t __c)
uchar_t _S_fetch (MNRopeRep *__r, size_t __pos)
 Retrieve a character at the indicated position.
uchar_t * _S_fetch_ptr (MNRopeRep *__r, size_t __pos)
bool _S_apply_to_pieces (MNRopeCharConsumer &__c, const MNRopeRep *__r, size_t __begin, size_t __end)
void _S_unref (MNRopeRep *__t)
void _S_ref (MNRopeRep *__t)
MNRopeRep * _S_substring (MNRopeRep *__base, size_t __start, size_t __endp1)
 _Result is counted in refcount.
MNRopeRep * _S_concat_char_iter (MNRopeRep *__r, const uchar_t *__iter, size_t __slen)
MNRopeRep * _S_destr_concat_char_iter (MNRopeRep *__r, const uchar_t *__iter, size_t __slen)
MNRopeRep * _S_concat (MNRopeRep *__left, MNRopeRep *__right)
size_t _S_rounded_up_size (size_t __n)
size_t _S_allocated_capacity (size_t __n)
MNRopeLeaf * _S_newMNRopeLeaf (uchar_t *__s, size_t __size)
MNRopeConcat * _S_newMNRopeConcat (MNRopeRep *__left, MNRopeRep *__right)
MNRopeFunction * _S_newMNRopeFunction (MNRopeCharProducer *__f, size_t __size, bool __d)
MNRopeSubstring * _S_newMNRopeSubstring (MNRopeRep *__b, size_t __s, size_t __l)
MNRopeLeaf * _SMNRopeLeaf_from_unowned_char_ptr (const uchar_t *__s, size_t __size)
MNRopeRep * _S_tree_concat (MNRopeRep *__left, MNRopeRep *__right)
MNRopeLeaf * _S_leaf_concat_char_iter (MNRopeLeaf *__r, const uchar_t *__iter, size_t __slen)
 Concatenation helper functions.
MNRopeLeaf * _S_destr_leaf_concat_char_iter (MNRopeLeaf *__r, const uchar_t *__iter, size_t __slen)
MNRopeRep * replace (MNRopeRep *__old, size_t __pos1, size_t __pos2, MNRopeRep *__r)
 Result is included in refcount.

Static Protected Attributes

uchar_t _S_empty_c_str [1]

Friends

MNRope operator+ (const MNRope &__left, const MNRope &__right)
MNRope operator+ (const MNRope &__left, const uchar_t *__right)
MNRope operator+ (const MNRope &__left, uchar_t __right)

Detailed Description

rope is a sequence of uchar_t. Ropes appear to be mutable, but update operations really copy enough of the data structure to leave the original valid. Thus ropes can be logically copied by just copying a pointer value.

Member Typedef Documentation

typedef uchar_t* MNRope::_Cstrptr [protected]
 

typedef const uchar_t* MNRope::const_pointer
 

typedef uchar_t MNRope::const_reference
 

typedef reverse_iterator<MNRopeConstIterator, value_type, const_reference, difference_type> MNRope::const_reverse_iterator
 

typedef reverse_iterator<MNRopeConstIterator> MNRope::const_reverse_iterator
 

typedef ptrdiff_t MNRope::difference_type
 

typedef MNPtrProxy MNRope::pointer
 

typedef MNRefProxy MNRope::reference
 

typedef reverse_iterator<iterator, value_type, reference, difference_type> MNRope::reverse_iterator
 

typedef reverse_iterator<iterator> MNRope::reverse_iterator
 

typedef uchar_t MNRope::value_type
 

Member Enumeration Documentation

anonymous enum [protected]
 

For strings shorter than _S_copy_max, we copy to concatenate.

Enumeration values:
_S_copy_max 

Constructor & Destructor Documentation

MNRope::MNRope (  const uchar_t *  __s  )  [inline]
 

MNRope::MNRope (  const uchar_t *  __s,
size_t  __len
)  [inline]
 

MNRope::MNRope (  const uchar_t *  __s,
const uchar_t *  __e
)  [inline]
 

Should perhaps be templatized with respect to the Iterator type and use Sequence_buffer. (It should perhaps use sequence_buffer even now.)

MNRope::MNRope (  uchar_t  __c  )  [inline]
 

MNRope::MNRope (  size_t  __n,
uchar_t  __c
) 
 

MNRope::MNRope (   )  [inline]
 

MNRope::MNRope (  MNRopeCharProducer *  __fn,
size_t  __len,
bool  __delete_fn
)  [inline]
 

Construct a rope from a function that can compute its members.

MNRope::MNRope (  const MNRope &  __x  )  [inline]
 

MNRope::MNRope (  MNRopeRep *  __t  )  [inline]
 

This constructor is PRIVATE in the original. It does not copy that data that it is given. You with extensive care.

MNRope::~MNRope (   )  [inline]
 

MNRope::MNRope (  const MNRopeConstIterator &  __s,
const MNRopeConstIterator &  __e
)  [inline]
 

MNRope::MNRope (  const MNRopeIterator &  __s,
const MNRopeIterator &  __e
)  [inline]
 

Member Function Documentation

size_t MNRope::_S_allocated_capacity (  size_t  __n  )  [inline, static, protected]
 

bool MNRope::_S_apply_to_pieces (  MNRopeCharConsumer &  __c,
const MNRopeRep *  __r,
size_t  __begin,
size_t  __end
)  [static, protected]
 

MNRopeRep* MNRope::_S_concat (  MNRopeRep *  __left,
MNRopeRep *  __right
)  [static, protected]
 

General concatenation on MNRopeRep. _Result has refcount of 1. Adjusts argument refcounts.

MNRopeRep* MNRope::_S_concat_char_iter (  MNRopeRep *  __r,
const uchar_t *  __iter,
size_t  __slen
)  [static, protected]
 

Concatenate rope and char ptr, copying __s. Should really take an arbitrary Iterator. Result is counted in refcount.

MNRopeRep* MNRope::_S_destr_concat_char_iter (  MNRopeRep *  __r,
const uchar_t *  __iter,
size_t  __slen
)  [static, protected]
 

As above, but one reference to __r is about to be destroyed. Thus the pieces may be recycled if all relevent reference counts are 1.

MNRopeLeaf* MNRope::_S_destr_leaf_concat_char_iter (  MNRopeLeaf *  __r,
const uchar_t *  __iter,
size_t  __slen
)  [static, protected]
 

Concatenate by copying leaf. should take an arbitrary Iterator result has refcount 1.

uchar_t MNRope::_S_fetch (  MNRopeRep *  __r,
size_t  __pos
)  [static, protected]
 

Retrieve a character at the indicated position.

uchar_t* MNRope::_S_fetch_ptr (  MNRopeRep *  __r,
size_t  __pos
)  [static, protected]
 

Obtain a pointer to the character at the indicated position. The pointer can be used to change the character. If such a pointer cannot be produced, as is frequently the case, 0 is returned instead. (Returns nonzero only if all nodes in the path have a refcount of 1.)

bool MNRope::_S_is0 (  uchar_t  __c  )  [inline, static, protected]
 

MNRopeLeaf* MNRope::_S_leaf_concat_char_iter (  MNRopeLeaf *  __r,
const uchar_t *  __iter,
size_t  __slen
)  [static, protected]
 

Concatenation helper functions.

MNRopeConcat* MNRope::_S_newMNRopeConcat (  MNRopeRep *  __left,
MNRopeRep *  __right
)  [inline, static, protected]
 

MNRopeFunction* MNRope::_S_newMNRopeFunction (  MNRopeCharProducer *  __f,
size_t  __size,
bool  __d
)  [inline, static, protected]
 

MNRopeLeaf* MNRope::_S_newMNRopeLeaf (  uchar_t *  __s,
size_t  __size
)  [inline, static, protected]
 

MNRopeSubstring* MNRope::_S_newMNRopeSubstring (  MNRopeRep *  __b,
size_t  __s,
size_t  __l
)  [inline, static, protected]
 

void MNRope::_S_ref (  MNRopeRep *  __t  )  [inline, static, protected]
 

size_t MNRope::_S_rounded_up_size (  size_t  __n  )  [inline, static, protected]
 

MNRopeRep* MNRope::_S_substring (  MNRopeRep *  __base,
size_t  __start,
size_t  __endp1
)  [static, protected]
 

_Result is counted in refcount.

MNRopeRep* MNRope::_S_tree_concat (  MNRopeRep *  __left,
MNRopeRep *  __right
)  [static, protected]
 

Concatenation of nonempty strings. Always builds a concatenation node. Rebalances if the result is too deep. Result has refcount 1. Does not increment left and right ref counts even though they are referenced.

void MNRope::_S_unref (  MNRopeRep *  __t  )  [inline, static, protected]
 

MNRopeLeaf* MNRope::_SMNRopeLeaf_from_unowned_char_ptr (  const uchar_t *  __s,
size_t  __size
)  [inline, static, protected]
 

MNRope& MNRope::append (  MNRopeConstIterator  __s,
MNRopeConstIterator  __e
)  [inline]
 

MNRope& MNRope::append (  size_t  __n,
uchar_t  __c
)  [inline]
 

MNRope& MNRope::append (  const MNRope &  __y  )  [inline]
 

MNRope& MNRope::append (   )  [inline]
 

MNRope& MNRope::append (  uchar_t  __c  )  [inline]
 

MNRope& MNRope::append (  const uchar_t *  __s,
const uchar_t *  __e
)  [inline]
 

MNRope& MNRope::append (  const uchar_t *  __c_string  )  [inline]
 

MNRope& MNRope::append (  const uchar_t *  __iter,
size_t  __n
)  [inline]
 

void MNRope::apply_to_pieces (  size_t  __begin,
size_t  __end,
MNRopeCharConsumer &  __c
)  const [inline]
 

reference MNRope::at (  size_t  __pos  )  [inline]
 

uchar_t MNRope::at (  size_t  __pos  )  const [inline]
 

uchar_t MNRope::back (   )  const [inline]
 

void MNRope::balance (   )  [inline]
 

MNRopeConstIterator MNRope::begin (   )  [inline]
 

iterator MNRope::begin (   )  [inline]
 

MNRopeConstIterator MNRope::begin (   )  const [inline]
 

const uchar_t* MNRope::c_str (   )  const
 

Convert to 0 terminated string in new allocated memory. Embedded 0s in the input do not terminate the copy.

size_t MNRope::capacity (   )  const [inline]
 

void MNRope::clear (   )  [inline]
 

int MNRope::compare (  const MNRope &  __y  )  const [inline]
 

Comparison member function. This is public only for those clients that need a ternary comparison. Others should use the comparison operators below.

MNRopeConstIterator MNRope::const_begin (   )  const [inline]
 

An easy way to get a const iterator from a non-const container.

MNRopeConstIterator MNRope::const_end (   )  const [inline]
 

const_reverse_iterator MNRope::const_rbegin (   )  const [inline]
 

const_reverse_iterator MNRope::const_rend (   )  const [inline]
 

size_t MNRope::copy (  uchar_t *  __buffer,
size_t  __n,
size_t  __pos = 0
)  const [inline]
 

size_t MNRope::copy (  size_t  __pos,
size_t  __n,
uchar_t *  __buffer
)  const [inline]
 

Copy data from the rope to a memory buffer.
This is the copy function from the standard, but with the arguments reordered to make it consistent with the rest of the interface. Note that this guaranteed not to compile if the draft standard order is assumed.

Parameters:
__pos The start position for the copy operation. Must be smaller than the size of the rope (not checked).
__n The requested number of elements to copy into the buffer. If not enough elements are present, copy the number of available elements.
__buffer The destination of the copy operation. The caller must ensure that there is enough space for __n elements.
Returns:
The number of elements that were actually copied.

void MNRope::copy (  uchar_t *  __buffer  )  const [inline]
 

void MNRope::delete_c_str (   )  [inline]
 

Reclaim memory for the c_str generated flattened string. Intentionally undocumented, since it's hard to say when this is safe for multiple threads.

void MNRope::dump (   )  [inline]
 

Print to stdout, exposing structure. May be useful for performance debugging.

bool MNRope::empty (   )  const [inline]
 

MNRopeConstIterator MNRope::end (   )  [inline]
 

iterator MNRope::end (   )  [inline]
 

MNRopeConstIterator MNRope::end (   )  const [inline]
 

MNRopeIterator MNRope::erase (  const MNRopeIterator &  __p  )  [inline]
 

MNRopeIterator MNRope::erase (  const MNRopeIterator &  __p,
const MNRopeIterator &  __q
)  [inline]
 

void MNRope::erase (  size_t  __p  )  [inline]
 

Erase, single character.

void MNRope::erase (  size_t  __p,
size_t  __n
)  [inline]
 

Erase, (position, size) variant.

size_t MNRope::find (  const uchar_t *  __s,
size_t  __pos = 0
)  const [inline]
 

size_t MNRope::find (  uchar_t  __c,
size_t  __pos = 0
)  const
 

uchar_t MNRope::front (   )  const [inline]
 

MNRopeIterator MNRope::insert (  const MNRopeIterator &  __p,
const MNRopeIterator &  __i,
const MNRopeIterator &  __j
)  [inline]
 

MNRopeIterator MNRope::insert (  const MNRopeIterator &  __p,
const MNRopeConstIterator &  __i,
const MNRopeConstIterator &  __j
)  [inline]
 

MNRopeIterator MNRope::insert (  const MNRopeIterator &  __p,
const uchar_t *  __i,
const uchar_t *  __j
)  [inline]
 

MNRopeIterator MNRope::insert (  const MNRopeIterator &  __p,
const uchar_t *  __i,
size_t  __n
)  [inline]
 

MNRopeIterator MNRope::insert (  const MNRopeIterator &  __p,
const uchar_t *  c_string
)  [inline]
 

MNRopeIterator MNRope::insert (  const MNRopeIterator &  __p  )  [inline]
 

MNRopeIterator MNRope::insert (  const MNRopeIterator &  __p,
uchar_t  __c
)  [inline]
 

MNRopeIterator MNRope::insert (  const MNRopeIterator &  __p,
size_t  __n,
uchar_t  __c
)  [inline]
 

MNRopeIterator MNRope::insert (  const MNRopeIterator &  __p,
const MNRope &  __r
)  [inline]
 

void MNRope::insert (  size_t  __p,
const MNRopeIterator &  __i,
const MNRopeIterator &  __j
)  [inline]
 

void MNRope::insert (  size_t  __p,
const MNRopeConstIterator &  __i,
const MNRopeConstIterator &  __j
)  [inline]
 

void MNRope::insert (  size_t  __p,
const uchar_t *  __i,
const uchar_t *  __j
)  [inline]
 

void MNRope::insert (  size_t  __p  )  [inline]
 

void MNRope::insert (  size_t  __p,
uchar_t  __c
)  [inline]
 

void MNRope::insert (  size_t  __p,
const uchar_t *  __c_string
)  [inline]
 

void MNRope::insert (  size_t  __p,
const uchar_t *  __i,
size_t  __n
)  [inline]
 

void MNRope::insert (  size_t  __p,
size_t  __n,
uchar_t  __c
)  [inline]
 

void MNRope::insert (  size_t  __p,
const MNRope &  __r
)  [inline]
 

size_t MNRope::length (   )  const [inline]
 

Return the number of elements in the rope.

size_t MNRope::max_size (   )  const [inline]
 

MNRopeIterator MNRope::mutable_begin (   )  [inline]
 

MNRopeIterator MNRope::mutable_end (   )  [inline]
 

reverse_iterator MNRope::mutable_rbegin (   )  [inline]
 

reference MNRope::mutable_reference_at (  size_t  __pos  )  [inline]
 

reverse_iterator MNRope::mutable_rend (   )  [inline]
 

MNRope& MNRope::operator= (  const MNRope &  __x  )  [inline]
 

reference MNRope::operator[] (  size_t  __pos  )  [inline]
 

uchar_t MNRope::operator[] (  size_t  __pos  )  const [inline]
 

void MNRope::pop_back (   )  [inline]
 

void MNRope::pop_front (   )  [inline]
 

void MNRope::push_back (  uchar_t  __x  )  [inline]
 

void MNRope::push_front (  uchar_t  __x  )  [inline]
 

const_reverse_iterator MNRope::rbegin (   )  [inline]
 

reverse_iterator MNRope::rbegin (   )  [inline]
 

const_reverse_iterator MNRope::rbegin (   )  const [inline]
 

const_reverse_iterator MNRope::rend (   )  [inline]
 

reverse_iterator MNRope::rend (   )  [inline]
 

const_reverse_iterator MNRope::rend (   )  const [inline]
 

void MNRope::replace (  const MNRopeIterator &  __p,
MNRopeIterator  __i,
MNRopeIterator  __j
)  [inline]
 

void MNRope::replace (  const MNRopeIterator &  __p,
MNRopeConstIterator  __i,
MNRopeConstIterator  __j
)  [inline]
 

void MNRope::replace (  const MNRopeIterator &  __p,
const uchar_t *  __i,
const uchar_t *  __j
)  [inline]
 

void MNRope::replace (  const MNRopeIterator &  __p,
const uchar_t *  __i,
size_t  __n
)  [inline]
 

void MNRope::replace (  const MNRopeIterator &  __p,
const uchar_t *  __c_string
)  [inline]
 

void MNRope::replace (  const MNRopeIterator &  __p,
uchar_t  __c
)  [inline]
 

void MNRope::replace (  const MNRopeIterator &  __p,
const MNRope &  __r
)  [inline]
 

void MNRope::replace (  const MNRopeIterator &  __p,
const MNRopeIterator &  __q,
const MNRopeIterator &  __i,
const MNRopeIterator &  __j
)  [inline]
 

void MNRope::replace (  const MNRopeIterator &  __p,
const MNRopeIterator &  __q,
const MNRopeConstIterator &  __i,
const MNRopeConstIterator &  __j
)  [inline]
 

void MNRope::replace (  const MNRopeIterator &  __p,
const MNRopeIterator &  __q,
const uchar_t *  __i,
const uchar_t *  __j
)  [inline]
 

void MNRope::replace (  const MNRopeIterator &  __p,
const MNRopeIterator &  __q,
const uchar_t *  __i,
size_t  __n
)  [inline]
 

void MNRope::replace (  const MNRopeIterator &  __p,
const MNRopeIterator &  __q,
const uchar_t *  __c_string
)  [inline]
 

void MNRope::replace (  const MNRopeIterator &  __p,
const MNRopeIterator &  __q,
uchar_t  __c
)  [inline]
 

void MNRope::replace (  const MNRopeIterator &  __p,
const MNRopeIterator &  __q,
const MNRope &  __r
)  [inline]
 

void MNRope::replace (  size_t  __p,
const MNRopeIterator &  __i,
const MNRopeIterator &  __j
)  [inline]
 

void MNRope::replace (  size_t  __p,
const MNRopeConstIterator &  __i,
const MNRopeConstIterator &  __j
)  [inline]
 

void MNRope::replace (  size_t  __p,
uchar_t  __c
)  [inline]
 

void MNRope::replace (  size_t  __p,
size_t  __n,
const MNRopeIterator &  __i,
const MNRopeIterator &  __j
)  [inline]
 

void MNRope::replace (  size_t  __p,
size_t  __n,
const MNRopeConstIterator &  __i,
const MNRopeConstIterator &  __j
)  [inline]
 

void MNRope::replace (  size_t  __p,
const uchar_t *  __i,
const uchar_t *  __j
)  [inline]
 

void MNRope::replace (  size_t  __p,
const uchar_t *  __c_string
)  [inline]
 

void MNRope::replace (  size_t  __p,
const uchar_t *  __i,
size_t  __i_len
)  [inline]
 

void MNRope::replace (  size_t  __p,
const MNRope &  __r
)  [inline]
 

void MNRope::replace (  size_t  __p,
size_t  __n,
const uchar_t *  __i,
const uchar_t *  __j
)  [inline]
 

void MNRope::replace (  size_t  __p,
size_t  __n,
const uchar_t *  __c_string
)  [inline]
 

void MNRope::replace (  size_t  __p,
size_t  __n,
uchar_t  __c
)  [inline]
 

void MNRope::replace (  size_t  __p,
size_t  __n,
const uchar_t *  __i,
size_t  __i_len
)  [inline]
 

void MNRope::replace (  size_t  __p,
size_t  __n,
const MNRope &  __r
)  [inline]
 

MNRopeRep* MNRope::replace (  MNRopeRep *  __old,
size_t  __pos1,
size_t  __pos2,
MNRopeRep *  __r
)  [inline, static, protected]
 

Result is included in refcount.

const uchar_t* MNRope::replace_with_c_str (   ) 
 

As above, but lso use the flattened representation as the the new rope representation.

void MNRope::reserve (  size_t  __res_arg = 0  )  [inline]
 

void MNRope::resize (  size_t  __n  )  [inline]
 

void MNRope::resize (  size_t  __n,
uchar_t  __c
)  [inline]
 

size_t MNRope::size (   )  const [inline]
 

Return the number of elements in the rope.

MNRope MNRope::substr (  MNRopeConstIterator  __start  )  [inline]
 

MNRope MNRope::substr (  MNRopeConstIterator  __start,
MNRopeConstIterator  __end
)  const [inline]
 

MNRope MNRope::substr (  MNRopeIterator  __start  )  const [inline]
 

MNRope MNRope::substr (  MNRopeIterator  __start,
MNRopeIterator  __end
)  const [inline]
 

MNRope MNRope::substr (  size_t  __start,
size_t  __len = 1
)  const [inline]
 

void MNRope::swap (  MNRope &  __b  )  [inline]
 

Friends And Related Function Documentation

MNRope operator+ (  const MNRope &  __left,
uchar_t  __right
)  [friend]
 

MNRope operator+ (  const MNRope &  __left,
const uchar_t *  __right
)  [friend]
 

MNRope operator+ (  const MNRope &  __left,
const MNRope &  __right
)  [friend]
 

Addition operators. The symmetric cases are intentionally omitted, since they're presumed to be less common, and we don't handle them as well. The following should really be templatized. The first argument should be an input Iterator or forward Iterator with value_type uchar_t.

Member Data Documentation

uchar_t MNRope::_S_empty_c_str[1] [static, protected]
 

const size_t MNRope::npos [static]
 

The documentation for this class was generated from the following file:
Generated on Sun Mar 6 13:35:58 2005 for Komssys by doxygen 1.3.8