---

ACE_String_Base Class Template Reference

This class provides a wrapper facade for C strings. More...

#include <String_Base.h>

Inheritance diagram for ACE_String_Base:

[legend]Collaboration diagram for ACE_String_Base:

[legend]List of all members.

Public Methods
	ACE_String_Base (ACE_Allocator *alloc=0)
	ACE_String_Base (const CHAR *s, ACE_Allocator *alloc=0, int release=1)
	ACE_String_Base (const CHAR *s, size_t len, ACE_Allocator *alloc=0, int release=1)
	ACE_String_Base (const ACE_String_Base< CHAR > &s)
	ACE_String_Base (CHAR c, ACE_Allocator *alloc=0)
	ACE_String_Base (size_t len, CHAR c=0, ACE_Allocator *alloc=0)
	~ACE_String_Base (void)
const CHAR &	operator[] (size_t slot) const
CHAR &	operator[] (size_t slot)
ACE_String_Base< CHAR > &	operator= (const ACE_String_Base< CHAR > &s)
ACE_String_Base< CHAR > &	assign_nocopy (const ACE_String_Base< CHAR > &s)
void	set (const CHAR *s, int release=1)
void	set (const CHAR *s, size_t len, int release)
void	clear (int release=0)
ACE_String_Base< CHAR >	substring (size_t offset, ssize_t length=-1) const
ACE_String_Base< CHAR >	substr (size_t offset, ssize_t length=-1) const
ACE_String_Base< CHAR > &	operator+= (const ACE_String_Base< CHAR > &s)
u_long	hash (void) const
size_t	length (void) const
CHAR *	rep (void) const
const CHAR *	fast_rep (void) const
const CHAR *	c_str (void) const
ssize_t	strstr (const ACE_String_Base< CHAR > &s) const
ssize_t	find (const ACE_String_Base< CHAR > &str, size_t pos=0) const
ssize_t	find (const CHAR *s, size_t pos=0) const
ssize_t	find (CHAR c, size_t pos=0) const
ssize_t	rfind (CHAR c, ssize_t pos=npos) const
int	operator== (const ACE_String_Base< CHAR > &s) const
int	operator< (const ACE_String_Base< CHAR > &s) const
int	operator> (const ACE_String_Base< CHAR > &s) const
int	operator!= (const ACE_String_Base< CHAR > &s) const
int	compare (const ACE_String_Base< CHAR > &s) const
void	dump (void) const
void	resize (size_t len, CHAR c=0)
Public Attributes
	ACE_ALLOC_HOOK_DECLARE
Protected Attributes
ACE_Allocator *	allocator_
size_t	len_
size_t	buf_len_
CHAR *	rep_
int	release_
Static Protected Attributes
CHAR	NULL_String_ = '\0'

---

Detailed Description

template<class CHAR>
class ACE_String_Base< CHAR >

This class provides a wrapper facade for C strings.

This class uses an ACE_Allocator to allocate memory. The user can make this a persistant class by providing an ACE_Allocator with a persistable memory pool. This class is optimized for efficiency, so it doesn't provide any internal locking. NOTE: if an instance of this class is constructed from or assigned an empty string (with first element of '\0'), then it is not allocated new space. Instead, its internal representation is set equal to a global empty string. CAUTION: in cases when ACE_String_Base is constructed from a provided buffer with the release parameter set to 0, ACE_String_Base is not guaranteed to be '\0' terminated.

Definition at line 46 of file String_Base.h.

---

Constructor & Destructor Documentation

template<class CHAR> ACE_INLINE ACE_String_Base< CHAR >::ACE_String_Base (  ACE_Allocator *    alloc = 0 )

Default constructor. Parameters: alloc  ACE_Allocator associated with string Returns: Default ACE_String_Base string. Definition at line 9 of file String_Base.i. References ACE_TRACE. : allocator_ (alloc ? alloc : ACE_Allocator::instance ()), len_ (0), buf_len_ (0), rep_ (&ACE_String_Base<CHAR>::NULL_String_), release_ (0) { ACE_TRACE ("ACE_String_Base<CHAR>::ACE_String_Base"); }

template<class CHAR> ACE_INLINE ACE_String_Base< CHAR >::ACE_String_Base (  const CHAR *    s, ACE_Allocator *    alloc = 0, int    release = 1 )

Constructor that copies s into dynamically allocated memory. If release is non-0 then the ACE_Allocator is responsible for freeing this memory. Memory is _not_ allocated/freed if release is 0. Parameters: s  Zero terminated input string alloc  ACE_Allocator associated with string release  Allocator responsible(1)/not reponsible(0) for freeing memory. Returns: ACE_String_Base containing const CHAR *s Definition at line 22 of file String_Base.i. References ACE_TRACE, length, set, and ACE_OS_String::strlen. : allocator_ (alloc ? alloc : ACE_Allocator::instance ()), len_ (0), buf_len_ (0), rep_ (0), release_ (0) { ACE_TRACE ("ACE_String_Base<CHAR>::ACE_String_Base"); size_t length; if (s != 0) length = ACE_OS::strlen (s); else length = 0; this->set (s, length, release); }

template<class CHAR> ACE_INLINE ACE_String_Base< CHAR >::ACE_String_Base (  const CHAR *    s, size_t    len, ACE_Allocator *    alloc = 0, int    release = 1 )

Constructor that copies len CHARs of s into dynamically allocated memory (will zero terminate the result). If release is non-0 then the ACE_allocator is responsible for freeing this memory. Memory is _not_ allocated/freed if release is 0. Parameters: s  Non-zero terminated input string len  Length of non-zero terminated input string alloc  ACE_Allocator associated with string release  Allocator responsible(1)/not reponsible(0) for freeing memory. Returns: ACE_String_Base containing const CHAR *s Definition at line 59 of file String_Base.i. References ACE_TRACE, and set. : allocator_ (alloc ? alloc : ACE_Allocator::instance ()), len_ (0), buf_len_ (0), rep_ (0), release_ (0) { ACE_TRACE ("ACE_String_Base<CHAR>::ACE_String_Base"); this->set (s, len, release); }

template<class CHAR> ACE_INLINE ACE_String_Base< CHAR >::ACE_String_Base (  const ACE_String_Base< CHAR > &    s )

Copy constructor. Parameters: s  Input ACE_String_Base string to copy Returns: Copy of input string s Definition at line 77 of file String_Base.i. References ACE_TRACE, and set. : allocator_ (s.allocator_ ? s.allocator_ : ACE_Allocator::instance ()), len_ (0), buf_len_ (0), rep_ (0), release_ (0) { ACE_TRACE ("ACE_String_Base<CHAR>::ACE_String_Base"); this->set (s.rep_, s.len_, 1); }

template<class CHAR> ACE_INLINE ACE_String_Base< CHAR >::ACE_String_Base (  CHAR    c, ACE_Allocator *    alloc = 0 )

Constructor that copies c into dynamically allocated memory. Parameters: c  Single input character. alloc  ACE_Allocator associated with string Returns: ACE_String_Base containing CHAR 'c' Definition at line 43 of file String_Base.i. References ACE_TRACE, and set. : allocator_ (alloc ? alloc : ACE_Allocator::instance ()), len_ (0), buf_len_ (0), rep_ (0), release_ (0) { ACE_TRACE ("ACE_String_Base<CHAR>::ACE_String_Base"); this->set (&c, 1, 1); }

template<class CHAR> ACE_INLINE ACE_String_Base< CHAR >::ACE_String_Base (  size_t    len, CHAR    c = 0, ACE_Allocator *    alloc = 0 )

Constructor that dynamically allocate len long of char array and initialize it to c using alloc to allocate the memory. Parameters: len  Length of character array 'c' c  Input character array alloc  ACE_Allocator associated with string Returns: ACE_String_Base containing character array 'c' Definition at line 90 of file String_Base.i. References ACE_TRACE, and resize. : allocator_ (alloc ? alloc : ACE_Allocator::instance ()), len_ (0), buf_len_ (0), rep_ (0), release_ (0) { ACE_TRACE ("ACE_String_Base<CHAR>::ACE_String_Base"); this->resize (len, c); }

template<class CHAR> ACE_INLINE ACE_String_Base< CHAR >::~ACE_String_Base (  void    )

Deletes the memory... Definition at line 103 of file String_Base.i. References ACE_TRACE, and set. { ACE_TRACE ("ACE_String_Base<CHAR>::~ACE_String_Base"); this->set (0, 0, 0); }

---

Member Function Documentation

template<class CHAR> ACE_INLINE ACE_String_Base< CHAR > & ACE_String_Base< CHAR >::assign_nocopy (  const ACE_String_Base< CHAR > &    s )

Assignment alternative method (does not copy memory). Parameters: s  Input ACE_String_Base string to assign to this object. Returns: Return this string. Definition at line 131 of file String_Base.i. References len_, rep_, and set. { this->set (s.rep_, s.len_, 0); return *this; }

template<class CHAR> ACE_INLINE const CHAR * ACE_String_Base< CHAR >::c_str (  void    )  const

Same as STL String's <c_str> and <fast_rep>. Definition at line 208 of file String_Base.i. References rep_. { return this->rep_; }

template<class CHAR> ACE_INLINE void ACE_String_Base< CHAR >::clear (  int    release = 0 )

Clear this string. Memory is _not_ freed if <release> is 0. Parameters: release  Memory is freed if 1 or not if 0. Definition at line 157 of file String_Base.i. References set. { this->set(0, 0, release); }

template<class CHAR> ACE_INLINE int ACE_String_Base< CHAR >::compare (  const ACE_String_Base< CHAR > &    s )  const

Performs a strncmp comparison. Parameters: s  Input ACE_String_Base string to compare against stored string. Returns: Integer value of result (less than 0, 0, greater than 0) depending on how input string s is to the stored string. Definition at line 214 of file String_Base.i. References ace_min, ACE_TRACE, len_, ACE_OS_String::memcmp, and rep_. Referenced by operator<, operator==, and operator>. { ACE_TRACE ("ACE_String_Base<CHAR>::compare"); // Pick smaller of the two lengths and perform the comparison. size_t smaller_length = ace_min (this->len_, s.len_); int result = ACE_OS::memcmp (this->rep_, s.rep_, smaller_length * sizeof (CHAR)); if (!result) result = ACE_static_cast (int, (this->len_ - s.len_)); return result; }

template<class CHAR> ACE_INLINE void ACE_String_Base< CHAR >::dump (  void    )  const

Dump the state of an object. Definition at line 111 of file String_Base.i. References ACE_TRACE. { ACE_TRACE ("ACE_String_Base<CHAR>::dump"); }

template<class CHAR> ACE_INLINE const CHAR * ACE_String_Base< CHAR >::fast_rep (  void    )  const

Get at the underlying representation directly! _Don't_ even think about casting the result to (char *) and modifying it, if it has length 0! Returns: Pointer reference to the stored string data. No guarantee is that the string is zero terminated. Definition at line 202 of file String_Base.i. References rep_. { return this->rep_; }

template<class CHAR> ACE_INLINE ssize_t ACE_String_Base< CHAR >::find (  CHAR    c, size_t    pos = 0 )  const

Find c starting at pos. Returns the slot of the first location that matches (will be >= pos), else npos. Parameters: c  Input character to search for in stored string. pos  Starting index position to start searching for string str. Returns: Index value of the first location of string str else npos. Definition at line 282 of file String_Base.i. References rep_, ACE_OS_String::strnchr, and substr. { CHAR *substr = this->rep_ + pos; CHAR *pointer = ACE_OS::strnchr (substr, c, this->len_ - pos); if (pointer == 0) return ACE_String_Base<CHAR>::npos; else return pointer - this->rep_; }

template<class CHAR> ACE_INLINE ssize_t ACE_String_Base< CHAR >::find (  const CHAR *    s, size_t    pos = 0 )  const

Find s starting at pos. Returns the slot of the first location that matches (will be >= pos), else npos. Parameters: s  non-zero input string to search for in stored string. pos  Starting index position to start searching for string str. Returns: Index value of the first location of string str else npos. Definition at line 270 of file String_Base.i. References rep_, ACE_OS_String::strlen, ACE_OS_String::strnstr, and substr. { CHAR *substr = this->rep_ + pos; size_t len = ACE_OS::strlen (s); CHAR *pointer = ACE_OS::strnstr (substr, s, len); if (pointer == 0) return ACE_String_Base<CHAR>::npos; else return pointer - this->rep_; }

template<class CHAR> ACE_INLINE ssize_t ACE_String_Base< CHAR >::find (  const ACE_String_Base< CHAR > &    str, size_t    pos = 0 )  const

Find <str> starting at pos. Returns the slot of the first location that matches (will be >= pos), else npos. Parameters: str  Input ACE_String_Base string to search for in stored string. pos  Starting index position to start searching for string str. Returns: Index value of the first location of string str else npos. Definition at line 293 of file String_Base.i. References rep_. Referenced by strstr. { return this->find (str.rep_, pos); }

template<class CHAR> ACE_INLINE u_long ACE_String_Base< CHAR >::hash (  void    )  const

Returns a hash value for this string. Returns: Hash value of string Definition at line 320 of file String_Base.i. References ACE::hash_pjw. { return ACE::hash_pjw ((ACE_reinterpret_cast (char *, ACE_const_cast (CHAR *, this->rep_))), this->len_ * sizeof (CHAR)); }

template<class CHAR> ACE_INLINE size_t ACE_String_Base< CHAR >::length (  void    )  const

Return the length of the string. Returns: Length of stored string Definition at line 150 of file String_Base.i. References ACE_TRACE, and len_. Referenced by ACE_String_Base, set, substr, and substring. { ACE_TRACE ("ACE_String_Base<CHAR>::length"); return this->len_; }

template<class CHAR> ACE_INLINE int ACE_String_Base< CHAR >::operator!= (  const ACE_String_Base< CHAR > &    s )  const

Inequality comparison operator. Parameters: s  Input ACE_String_Base string to compare against stored string. Returns: Integer value of result (1 = not equal, 0 = equal). Definition at line 263 of file String_Base.i. References ACE_TRACE. { ACE_TRACE ("ACE_String_Base<CHAR>::operator!="); return !(*this == s); }

template<class CHAR> ACE_String_Base< CHAR > & ACE_String_Base< CHAR >::operator+= (  const ACE_String_Base< CHAR > &    s )

Concat operator (copies memory). Parameters: s  Input ACE_String_Base string to concatenate to another string. Returns: The combined string (input append to the end of the old). New string is zero terminated. Definition at line 115 of file String_Base.cpp. References ACE_ALLOCATOR_RETURN, ACE_TRACE, allocator_, buf_len_, ACE_Allocator::free, len_, ACE_OS_String::memcpy, release_, and rep_. { ACE_TRACE ("ACE_String_Base<CHAR>::operator+="); if (s.len_ > 0) { size_t new_buf_len = this->len_ + s.len_ + 1; // case 1. No memory allocation needed. if (this->buf_len_ >= new_buf_len) // Copy in data from new string. ACE_OS::memcpy (this->rep_ + this->len_, s.rep_, s.len_ * sizeof (CHAR)); // case 2. Memory reallocation is needed else { CHAR *t = 0; ACE_ALLOCATOR_RETURN (t, (CHAR *) this->allocator_->malloc (new_buf_len * sizeof (CHAR)), *this); // Copy memory from old string into new string. ACE_OS::memcpy (t, this->rep_, this->len_ * sizeof (CHAR)); ACE_OS::memcpy (t + this->len_, s.rep_, s.len_ * sizeof (CHAR)); if (this->release_) this->allocator_->free (this->rep_); this->release_ = 1; this->rep_ = t; this->buf_len_ = new_buf_len; } this->len_ += s.len_; this->rep_[this->len_] = '\0'; } return *this; }

template<class CHAR> ACE_INLINE int ACE_String_Base< CHAR >::operator< (  const ACE_String_Base< CHAR > &    s )  const

Less than comparison operator. Parameters: s  Input ACE_String_Base string to compare against stored string. Returns: Integer value of result (1 = less than, 0 = greater than or equal). Definition at line 244 of file String_Base.i. References ACE_TRACE, and compare. { ACE_TRACE ("ACE_String_Base<CHAR>::operator <"); return compare (s) < 0; }

template<class CHAR> ACE_INLINE ACE_String_Base< CHAR > & ACE_String_Base< CHAR >::operator= (  const ACE_String_Base< CHAR > &    s )

Assignment operator (does copy memory). Parameters: s  Input ACE_String_Base string to assign to this object. Returns: Return a copy of the this string. Definition at line 118 of file String_Base.i. References ACE_TRACE, len_, rep_, and set. { ACE_TRACE ("ACE_String_Base<CHAR>::operator="); // Check for identify. if (this != &s) this->set (s.rep_, s.len_, 1); return *this; }

template<class CHAR> ACE_INLINE int ACE_String_Base< CHAR >::operator== (  const ACE_String_Base< CHAR > &    s )  const

Equality comparison operator (must match entire string). Parameters: s  Input ACE_String_Base string to compare against stored string. Returns: Integer value of result (1 = found, 0 = not found). Definition at line 234 of file String_Base.i. References ACE_TRACE, and compare. { ACE_TRACE ("ACE_String_Base<CHAR>::operator=="); return compare (s) == 0; }

template<class CHAR> ACE_INLINE int ACE_String_Base< CHAR >::operator> (  const ACE_String_Base< CHAR > &    s )  const

Greater than comparison operator. Parameters: s  Input ACE_String_Base string to compare against stored string. Returns: Integer value of result (1 = greater than, 0 = less than or equal). Definition at line 253 of file String_Base.i. References ACE_TRACE, and compare. { ACE_TRACE ("ACE_String_Base<CHAR>::operator >"); return compare (s) > 0; }

template<class CHAR> ACE_INLINE CHAR & ACE_String_Base< CHAR >::operator[] (  size_t    slot )

Return the <slot'th> character by reference in the string (doesn't perform bounds checking). Parameters: slot  Index of the desired character Returns: The character at index slot Definition at line 181 of file String_Base.i. References ACE_TRACE, and rep_. { ACE_TRACE ("ACE_String_Base<CHAR>::operator[]"); return this->rep_[slot]; }

template<class CHAR> ACE_INLINE const CHAR & ACE_String_Base< CHAR >::operator[] (  size_t    slot )  const

Return the <slot'th> character in the string (doesn't perform bounds checking). Parameters: slot  Index of the desired character Returns: The character at index slot Definition at line 172 of file String_Base.i. References ACE_TRACE, and rep_. { ACE_TRACE ("ACE_String_Base<CHAR>::operator[]"); return this->rep_[slot]; }

template<class CHAR> ACE_INLINE CHAR * ACE_String_Base< CHAR >::rep (  void    )  const

Get a copy of the underlying representation. This method allocates memory for a copy of the string and returns a pointer to the new area. The caller is responsible for freeing the memory when finished; use delete [] Returns: Pointer reference to the string data. Returned string is zero terminated. Definition at line 190 of file String_Base.i. References ACE_NEW_RETURN, ACE_TRACE, and ACE_OS_String::strsncpy. { ACE_TRACE ("ACE_String_Base<CHAR>::rep"); CHAR *new_string; ACE_NEW_RETURN (new_string, CHAR[this->len_ + 1], 0); ACE_OS::strsncpy (new_string, this->rep_, this->len_+1); return new_string; }

template<class CHAR> void ACE_String_Base< CHAR >::resize (  size_t    len, CHAR    c = 0 )

This method is designed for high-performance. Please use with care ;-) If the current size of the string is less than <len>, the string is resized to the new length. The data is zero'd out after this operation. Parameters: len  New string size c  New input string Definition at line 164 of file String_Base.cpp. References ACE_TRACE, allocator_, buf_len_, ACE_Allocator::free, len_, ACE_Allocator::malloc, ACE_OS_String::memset, and rep_. Referenced by ACE_String_Base. { ACE_TRACE ("ACE_String_Base<CHAR>::resize"); // Only reallocate if we don't have enough space... if (this->buf_len_ <= len) { if (this->buf_len_ != 0) this->allocator_->free (this->rep_); this->rep_ = (CHAR *) this->allocator_->malloc ((len + 1) * sizeof (CHAR)); this->buf_len_ = len + 1; } this->len_ = 0; ACE_OS::memset (this->rep_, c, this->buf_len_ * sizeof (CHAR)); }

template<class CHAR> ACE_INLINE ssize_t ACE_String_Base< CHAR >::rfind (  CHAR    c, ssize_t    pos = npos )  const

Find c starting at pos (counting from the end). Returns the slot of the first location that matches, else npos. Parameters: c  Input character to search for in stored string. pos  Starting index position to start searching for string str. Returns: Index value of the first location of string str else npos. Definition at line 307 of file String_Base.i. References ACE_String_Base_Const::npos, rep_, and ssize_t. { if (pos == npos || pos > ACE_static_cast (ssize_t, this->len_)) pos = ACE_static_cast (ssize_t, this->len_); for (ssize_t i = pos - 1; i >= 0; i--) if (this->rep_[i] == c) return i; return ACE_String_Base<CHAR>::npos; }

template<class CHAR> void ACE_String_Base< CHAR >::set (  const CHAR *    s, size_t    len, int    release )

Copy len bytes of s (will zero terminate the result). Memory is _not_ allocated/freed if release is 0. Parameters: s  Non-zero terminated input string len  Length of input string 's' release  Allocator responsible(1)/not reponsible(0) for freeing memory. Definition at line 24 of file String_Base.cpp. References ACE_ALLOCATOR, allocator_, buf_len_, ACE_Allocator::free, len_, ACE_OS_String::memcpy, release_, and rep_. { // Case 1. Going from memory to more memory size_t new_buf_len = len + 1; if (s != 0 && len != 0 && release && this->buf_len_ < new_buf_len) { CHAR *temp; ACE_ALLOCATOR (temp, (CHAR *) this->allocator_->malloc (new_buf_len * sizeof (CHAR))); if (this->release_) this->allocator_->free (this->rep_); this->rep_ = temp; this->buf_len_ = new_buf_len; this->release_ = 1; this->len_ = len; ACE_OS::memcpy (this->rep_, s, len * sizeof (CHAR)); // NUL terminate. this->rep_[len] = '\0'; } // Case 2. No memory allocation is necessary. else { // Free memory if necessary and figure out future ownership if (!release || s == 0 || len == 0) { if (this->release_) { this->allocator_->free (this->rep_); this->release_ = 0; } } // else - stay with whatever value for release_ we have. // Populate data. if (s == 0 || len == 0) { this->buf_len_ = 0; this->len_ = 0; this->rep_ = &ACE_String_Base<CHAR>::NULL_String_; } else if (!release) { this->buf_len_ = len; this->len_ = len; this->rep_ = (CHAR *) s; } else { ACE_OS::memcpy (this->rep_, s, len * sizeof (CHAR)); // NUL terminate. this->rep_[len] = 0; this->len_ = len; } } }

template<class CHAR> ACE_INLINE void ACE_String_Base< CHAR >::set (  const CHAR *    s, int    release = 1 )

Copy s into this ACE_String_Base. Memory is _not_ allocated/freed if release is 0. Parameters: s  Null terminated input string release  Allocator responsible(1)/not reponsible(0) for freeing memory. Definition at line 138 of file String_Base.i. References length, and ACE_OS_String::strlen. Referenced by ACE_String_Base, assign_nocopy, clear, operator=, and ~ACE_String_Base. { size_t length; if (s != 0) length = ACE_OS::strlen (s); else length = 0; this->set (s, length, release); }

template<class CHAR> ACE_INLINE ssize_t ACE_String_Base< CHAR >::strstr (  const ACE_String_Base< CHAR > &    s )  const

Comparison operator that will match substrings. Returns the slot of the first location that matches, else -1. Parameters: s  Input ACE_String_Base string Returns: Integer index value of the first location of string s or -1 (not found). Definition at line 299 of file String_Base.i. References ACE_TRACE, find, and rep_. { ACE_TRACE ("ACE_String_Base<CHAR>::strstr"); return this->find (s.rep_); }

template<class CHAR> ACE_INLINE ACE_String_Base< CHAR > ACE_String_Base< CHAR >::substr (  size_t    offset, ssize_t    length = -1 )  const

Same as <substring>. Parameters: offset  Index of first desired character of the substring. length  How many characters to return starting at the offset. Returns: The string containing the desired substring Definition at line 163 of file String_Base.i. References length, ssize_t, and substring. Referenced by find. { return this->substring (offset, length); }

template<class CHAR> ACE_String_Base< CHAR > ACE_String_Base< CHAR >::substring (  size_t    offset, ssize_t    length = -1 )  const

Return a substring given an offset and length, if length == -1 use rest of str. Return empty substring if offset or offset/length are invalid. Parameters: offset  Index of first desired character of the substring. length  How many characters to return starting at the offset. Returns: The string containing the desired substring Definition at line 87 of file String_Base.cpp. References allocator_, len_, length, rep_, and ssize_t. Referenced by substr. { ACE_String_Base<CHAR> nill; size_t count = length; // case 1. empty string if (this->len_ == 0) return nill; // case 2. start pos past our end if (offset >= this->len_) return nill; // No length == empty string. else if (length == 0) return nill; // Get all remaining bytes. else if (length == -1 || count > (this->len_ - offset)) count = this->len_ - offset; return ACE_String_Base<CHAR> (&this->rep_[offset], count, this->allocator_); }

---

Member Data Documentation

template<class CHAR> ACE_String_Base::ACE_ALLOC_HOOK_DECLARE

Declare the dynamic allocation hooks. Definition at line 373 of file String_Base.h.

template<class CHAR> ACE_Allocator* ACE_String_Base::allocator_ [protected]

Pointer to a memory allocator. Definition at line 379 of file String_Base.h. Referenced by operator+=, resize, set, and substring.

template<class CHAR> size_t ACE_String_Base::buf_len_ [protected]

Length of the ACE_String_Base data buffer. Keeping track of the length allows to avoid unnecessary dynamic allocations. Definition at line 390 of file String_Base.h. Referenced by operator+=, resize, and set.

template<class CHAR> size_t ACE_String_Base::len_ [protected]

Length of the ACE_String_Base data (not counting the trailing '\0'). Definition at line 384 of file String_Base.h. Referenced by assign_nocopy, compare, length, operator+=, operator=, resize, set, and substring.

template<class CHAR> CHAR ACE_String_Base< CHAR >::NULL_String_ = '\0' [static, protected]

Represents the "NULL" string to simplify the internal logic. Definition at line 20 of file String_Base.cpp.

template<class CHAR> int ACE_String_Base::release_ [protected]

Flag that indicates if we own the memory Definition at line 400 of file String_Base.h. Referenced by operator+=, and set.

template<class CHAR> CHAR* ACE_String_Base::rep_ [protected]

Pointer to data. Definition at line 395 of file String_Base.h. Referenced by assign_nocopy, c_str, compare, fast_rep, find, operator+=, operator=, operator[], resize, rfind, set, strstr, and substring.

---

The documentation for this class was generated from the following files:

• String_Base.h
• String_Base.cpp
• String_Base.i

---