#include <String_Base.h>
Inheritance diagram for ACE_String_Base< CHAR >:
Public Types | |
typedef ACE_Allocator::size_type | size_type |
Public Member Functions | |
ACE_String_Base (ACE_Allocator *the_allocator=0) | |
ACE_String_Base (const CHAR *s, ACE_Allocator *the_allocator=0, bool release=true) | |
ACE_String_Base (const CHAR *s, size_type len, ACE_Allocator *the_allocator=0, bool release=true) | |
ACE_String_Base (const ACE_String_Base< CHAR > &s) | |
ACE_String_Base (CHAR c, ACE_Allocator *the_allocator=0) | |
ACE_String_Base (size_type len, CHAR c=0, ACE_Allocator *the_allocator=0) | |
~ACE_String_Base (void) | |
const CHAR & | operator[] (size_type slot) const |
CHAR & | operator[] (size_type slot) |
ACE_String_Base< CHAR > & | operator= (const CHAR *s) |
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, bool release=true) |
void | set (const CHAR *s, size_type len, bool release) |
void | clear (bool release=false) |
void | fast_clear (void) |
ACE_String_Base< CHAR > | substring (size_type offset, size_type length=npos) const |
ACE_String_Base< CHAR > | substr (size_type offset, size_type length=npos) const |
ACE_String_Base< CHAR > & | operator+= (const ACE_String_Base< CHAR > &s) |
ACE_String_Base< CHAR > & | operator+= (const CHAR *s) |
ACE_String_Base< CHAR > & | operator+= (const CHAR c) |
ACE_String_Base< CHAR > & | append (const CHAR *s, size_type slen) |
u_long | hash (void) const |
size_type | length (void) const |
size_t | capacity (void) const |
bool | is_empty (void) const |
bool | empty (void) const |
CHAR * | rep (void) const |
const CHAR * | fast_rep (void) const |
const CHAR * | c_str (void) const |
size_type | strstr (const ACE_String_Base< CHAR > &s) const |
size_type | find (const ACE_String_Base< CHAR > &str, size_type pos=0) const |
size_type | find (const CHAR *s, size_type pos=0) const |
size_type | find (CHAR c, size_type pos=0) const |
size_type | rfind (CHAR c, size_type pos=npos) const |
bool | operator== (const ACE_String_Base< CHAR > &s) const |
bool | operator== (const CHAR *s) const |
bool | operator< (const ACE_String_Base< CHAR > &s) const |
bool | operator> (const ACE_String_Base< CHAR > &s) const |
bool | operator!= (const ACE_String_Base< CHAR > &s) const |
bool | operator!= (const CHAR *s) const |
int | compare (const ACE_String_Base< CHAR > &s) const |
void | dump (void) const |
void | resize (size_type len, CHAR c=0) |
void | fast_resize (size_t len) |
void | swap (ACE_String_Base< CHAR > &str) |
Swap the contents of this ACE_String_Base with str. | |
Public Attributes | |
ACE_ALLOC_HOOK_DECLARE | |
Protected Attributes | |
ACE_Allocator * | allocator_ |
size_type | len_ |
size_type | buf_len_ |
CHAR * | rep_ |
bool | release_ |
Static Protected Attributes | |
CHAR | NULL_String_ = 0 |
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.
typedef
found in all ACE string classes. This typedef is analogous to the "@c size_type" typedef
found in the standard C++ string class as well as many STL class templates. If you find yourself casting you're probably doing something wrong.
Definition at line 58 of file String_Base.h.
|
Definition at line 41 of file String_Base_Const.h. |
|
Default constructor.
Definition at line 28 of file String_Base.cpp. References ACE_TRACE.
00029 : allocator_ (the_allocator ? the_allocator : ACE_Allocator::instance ()), 00030 len_ (0), 00031 buf_len_ (0), 00032 rep_ (&ACE_String_Base<CHAR>::NULL_String_), 00033 release_ (false) 00034 { 00035 ACE_TRACE ("ACE_String_Base<CHAR>::ACE_String_Base"); 00036 } |
|
Constructor that copies s into dynamically allocated memory. if release == true then a new buffer is allocated internally, and s is copied to the internal buffer. if release == false then the s buffer is used directly. If s == 0 then it will _not_ be used, and instead the internal buffer is set to NULL_String_.
Definition at line 41 of file String_Base.cpp. References ACE_TRACE, and ACE_String_Base< CHAR >::set().
|
|
Constructor that copies len CHARs of s into dynamically allocated memory (will zero terminate the result). if release == true then a new buffer is allocated internally. s is copied to the internal buffer. if release == false then the s buffer is used directly. If s == 0 then it will _not_ be used, and instead the internal buffer is set to NULL_String_.
Definition at line 71 of file String_Base.cpp. References ACE_TRACE, and ACE_String_Base< CHAR >::set().
|
|
Copy constructor.
Definition at line 90 of file String_Base.cpp. References ACE_TRACE, ACE_String_Base< CHAR >::len_, ACE_String_Base< CHAR >::rep_, and ACE_String_Base< CHAR >::set().
00091 : allocator_ (s.allocator_ ? s.allocator_ : ACE_Allocator::instance ()), 00092 len_ (0), 00093 buf_len_ (0), 00094 rep_ (0), 00095 release_ (false) 00096 { 00097 ACE_TRACE ("ACE_String_Base<CHAR>::ACE_String_Base"); 00098 00099 this->set (s.rep_, s.len_, true); 00100 } |
|
Constructor that copies c into dynamically allocated memory.
Definition at line 55 of file String_Base.cpp. References ACE_TRACE, and ACE_String_Base< CHAR >::set().
|
|
Constructor that allocates a len long string. Warning : This constructor was incorrectly documented in the past. It simply calls resize(len, c). It is probably not advisable to use the second parameter. See resize() for more information.
Definition at line 103 of file String_Base.cpp. References ACE_TRACE, and ACE_String_Base< CHAR >::resize().
|
|
Deletes the memory... Definition at line 119 of file String_Base.cpp. References ACE_TRACE, ACE_String_Base< CHAR >::buf_len_, ACE_Allocator::free(), and ACE_String_Base< CHAR >::release_.
00120 { 00121 ACE_TRACE ("ACE_String_Base<CHAR>::~ACE_String_Base"); 00122 00123 if (this->buf_len_ != 0 && this->release_) 00124 this->allocator_->free (this->rep_); 00125 } |
|
Append function (copies memory).
Definition at line 213 of file String_Base.cpp. References ACE_ALLOCATOR_RETURN, ace_max(), ACE_TRACE, ACE_String_Base< CHAR >::buf_len_, ACE_Allocator::free(), ACE_OS::memcpy(), and ACE_String_Base< CHAR >::release_. Referenced by operator+(), and ACE_String_Base< CHAR >::operator+=().
00215 { 00216 ACE_TRACE ("ACE_String_Base<CHAR>::append(const CHAR*, size_type)"); 00217 if (slen > 0 && slen != npos) 00218 { 00219 // case 1. No memory allocation needed. 00220 if (this->buf_len_ >= this->len_ + slen + 1) 00221 { 00222 // Copy in data from new string. 00223 ACE_OS::memcpy (this->rep_ + this->len_, s, slen * sizeof (CHAR)); 00224 } 00225 else // case 2. Memory reallocation is needed 00226 { 00227 const size_type new_buf_len = 00228 ace_max(this->len_ + slen + 1, this->buf_len_ + this->buf_len_ / 2); 00229 00230 CHAR *t = 0; 00231 00232 ACE_ALLOCATOR_RETURN (t, 00233 (CHAR *) this->allocator_->malloc (new_buf_len * sizeof (CHAR)), *this); 00234 00235 // Copy memory from old string into new string. 00236 ACE_OS::memcpy (t, this->rep_, this->len_ * sizeof (CHAR)); 00237 00238 ACE_OS::memcpy (t + this->len_, s, slen * sizeof (CHAR)); 00239 00240 if (this->buf_len_ != 0 && this->release_) 00241 this->allocator_->free (this->rep_); 00242 00243 this->release_ = true; 00244 this->rep_ = t; 00245 this->buf_len_ = new_buf_len; 00246 } 00247 00248 this->len_ += slen; 00249 this->rep_[this->len_] = 0; 00250 } 00251 00252 return *this; 00253 } |
|
Assignment alternative method (does not copy memory).
Definition at line 22 of file String_Base.inl. References ACE_TRACE, ACE_String_Base< CHAR >::len_, ACE_String_Base< CHAR >::rep_, and ACE_String_Base< CHAR >::set(). Referenced by ACE_Configuration_Heap::load_key().
|
|
Same as STL String's and . Definition at line 91 of file String_Base.inl. Referenced by ACE_Get_Opt::dump(), ACE_Utils::UUID::from_string_i(), ACE_Capabilities::getent(), ACE_Capabilities::is_entry(), ACE_Get_Opt::last_option(), ACE_Codeset_Registry::locale_to_registry(), ACE_Codeset_Registry::locale_to_registry_i(), ACE_DLL_Handle::open(), ACE_Configuration_Heap::open_section(), ACE_Configuration::operator==(), ACE_Get_Opt::optstring(), ACE_Utils::UUID::to_string(), ACE_OutputCDR::write_string(), and ACE_SizeCDR::write_string().
00092 { 00093 return this->rep_; 00094 } |
|
Return the number of allocated CHARs in the string object. This may be greater than the current length of the string.
Definition at line 37 of file String_Base.inl. References ACE_TRACE, and ACE_String_Base< CHAR >::buf_len_.
|
|
Clear this string. Memory is _not_ freed if release is false. Warning: This method was incorrectly documented in the past, but the current implementation has been changed to match the documented behavior. Warning: clear(false) behaves like fast_clear() below.
Definition at line 296 of file String_Base.cpp. References ACE_String_Base< CHAR >::buf_len_, ACE_String_Base< CHAR >::fast_clear(), ACE_Allocator::free(), and ACE_String_Base< CHAR >::release_.
00297 { 00298 // This can't use set(), because that would free memory if release=false 00299 if (release) 00300 { 00301 if (this->buf_len_ != 0 && this->release_) 00302 this->allocator_->free (this->rep_); 00303 00304 this->rep_ = &ACE_String_Base<CHAR>::NULL_String_; 00305 this->len_ = 0; 00306 this->buf_len_ = 0; 00307 this->release_ = false; 00308 } 00309 else 00310 { 00311 this->fast_clear (); 00312 } 00313 } |
|
Performs a strncmp comparison.
Definition at line 383 of file String_Base.cpp. References ace_min(), ACE_TRACE, ACE_String_Base< CHAR >::len_, ACE_OS::memcmp(), and ACE_String_Base< CHAR >::rep_. Referenced by ACE_String_Base< CHAR >::operator<(), and ACE_String_Base< CHAR >::operator>().
00384 { 00385 ACE_TRACE ("ACE_String_Base<CHAR>::compare"); 00386 00387 if (this->rep_ == s.rep_) 00388 return 0; 00389 00390 // Pick smaller of the two lengths and perform the comparison. 00391 size_type smaller_length = ace_min (this->len_, s.len_); 00392 00393 int result = ACE_OS::memcmp (this->rep_, 00394 s.rep_, 00395 smaller_length * sizeof (CHAR)); 00396 00397 if (!result) 00398 result = static_cast<int> (this->len_ - s.len_); 00399 return result; 00400 } |
|
Dump the state of an object. Definition at line 13 of file String_Base.inl. References ACE_TRACE.
00014 { 00015 #if defined (ACE_HAS_DUMP) 00016 ACE_TRACE ("ACE_String_Base<CHAR>::dump"); 00017 #endif /* ACE_HAS_DUMP */ 00018 } |
|
Return Definition at line 50 of file String_Base.inl. References ACE_String_Base< CHAR >::is_empty().
00051 { 00052 return this->is_empty (); 00053 } |
|
A more specialized version of clear(): "fast clear". fast_clear() resets the string to 0 length. If the string owns the buffer (
Definition at line 351 of file String_Base.cpp. References ACE_String_Base< CHAR >::buf_len_, and ACE_String_Base< CHAR >::release_. Referenced by ACE_String_Base< CHAR >::clear().
00352 { 00353 this->len_ = 0; 00354 if (this->release_) 00355 { 00356 // String retains the original buffer. 00357 if (this->rep_ != &ACE_String_Base<CHAR>::NULL_String_) 00358 this->rep_[0] = 0; 00359 } 00360 else 00361 { 00362 // External buffer: string relinquishes control of it. 00363 this->buf_len_ = 0; 00364 this->rep_ = &ACE_String_Base<CHAR>::NULL_String_; 00365 } 00366 } |
|
|
Definition at line 275 of file String_Base.cpp. References ACE_TRACE, ACE_String_Base< CHAR >::buf_len_, ACE_Allocator::free(), ACE_Allocator::malloc(), and ACE_String_Base< CHAR >::release_. Referenced by ACE_String_Base< CHAR >::resize().
00276 { 00277 ACE_TRACE ("ACE_String_Base<CHAR>::fast_resize"); 00278 00279 // Only reallocate if we don't have enough space... 00280 if (this->buf_len_ <= len) 00281 { 00282 if (this->buf_len_ != 0 && this->release_) 00283 this->allocator_->free (this->rep_); 00284 00285 this->rep_ = static_cast<CHAR*> 00286 (this->allocator_->malloc ((len + 1) * sizeof (CHAR))); 00287 this->buf_len_ = len + 1; 00288 this->release_ = true; 00289 } 00290 this->len_ = 0; 00291 if (len > 0) 00292 this->rep_[0] = 0; 00293 } |
|
Find c starting at pos. Returns the slot of the first location that matches (will be >= pos), else
Definition at line 438 of file String_Base.cpp. References ACE_OS::strnchr().
00441 { 00442 CHAR *substr = this->rep_ + pos; 00443 CHAR *pointer = ACE_OS::strnchr (substr, c, this->len_ - pos); 00444 if (pointer == 0) 00445 return ACE_String_Base<CHAR>::npos; 00446 else 00447 return pointer - this->rep_; 00448 } |
|
Find s starting at pos. Returns the slot of the first location that matches (will be >= pos), else
Definition at line 424 of file String_Base.cpp. References ACE_OS::strlen(), and ACE_OS::strnstr().
00427 { 00428 CHAR *substr = this->rep_ + pos; 00429 size_t len = ACE_OS::strlen (s); 00430 CHAR *pointer = ACE_OS::strnstr (substr, s, len); 00431 if (pointer == 0) 00432 return ACE_String_Base<CHAR>::npos; 00433 else 00434 return pointer - this->rep_; 00435 } |
|
Find starting at pos. Returns the slot of the first location that matches (will be >= pos), else
Definition at line 131 of file String_Base.inl. References ACE_TRACE, and ACE_String_Base< CHAR >::rep_. Referenced by ACE_Utils::UUID::from_string_i(), ACE_Get_Opt::long_option_i(), and ACE_String_Base< CHAR >::strstr().
|
|
Returns a hash value for this string.
Definition at line 256 of file String_Base.cpp. References ACE::hash_pjw(). Referenced by ACE_Configuration_ExtId::hash(), and ACE_Hash< ACE_CString >::operator()().
00257 { 00258 return 00259 ACE::hash_pjw (reinterpret_cast<char *> ( 00260 const_cast<CHAR *> (this->rep_)), 00261 this->len_ * sizeof (CHAR)); 00262 } |
|
Return Definition at line 44 of file String_Base.inl. Referenced by ACE_String_Base< CHAR >::empty().
00045 { 00046 return this->len_ == 0; 00047 } |
|
|
Inequality comparison operator.
Definition at line 125 of file String_Base.inl.
00126 { 00127 return !(*this == s); 00128 } |
|
Inequality comparison operator.
Definition at line 118 of file String_Base.inl. References ACE_TRACE.
00119 { 00120 ACE_TRACE ("ACE_String_Base<CHAR>::operator!="); 00121 return !(*this == s); 00122 } |
|
Concat operator (copies memory).
Definition at line 554 of file String_Base.cpp. References ACE_TRACE, and ACE_String_Base< CHAR >::append().
|
|
Concat operator (copies memory).
Definition at line 536 of file String_Base.cpp. References ACE_String_Base< CHAR >::append(), and ACE_OS::strlen().
00537 { 00538 size_t slen = 0; 00539 if (s != 0) 00540 slen = ACE_OS::strlen (s); 00541 return this->append (s, slen); 00542 } |
|
Concat operator (copies memory).
Definition at line 546 of file String_Base.cpp. References ACE_TRACE, ACE_String_Base< CHAR >::append(), ACE_String_Base< CHAR >::len_, and ACE_String_Base< CHAR >::rep_.
|
|
Less than comparison operator.
Definition at line 99 of file String_Base.inl. References ACE_TRACE, and ACE_String_Base< CHAR >::compare().
|
|
Assignment operator (does copy memory).
Definition at line 327 of file String_Base.cpp. References ACE_TRACE, ACE_String_Base< CHAR >::len_, ACE_String_Base< CHAR >::rep_, and ACE_String_Base< CHAR >::set().
|
|
Assignment operator (does copy memory).
Definition at line 317 of file String_Base.cpp. References ACE_TRACE, and ACE_String_Base< CHAR >::set().
|
|
Equality comparison operator (must match entire string).
Definition at line 414 of file String_Base.cpp. References ACE_OS::memcmp(), and ACE_OS::strlen().
00415 { 00416 size_t len = ACE_OS::strlen (s); 00417 return this->len_ == len && 00418 ACE_OS::memcmp (this->rep_, 00419 s, 00420 len * sizeof (CHAR)) == 0; 00421 } |
|
Equality comparison operator (must match entire string).
Definition at line 405 of file String_Base.cpp. References ACE_String_Base< CHAR >::len_, ACE_OS::memcmp(), and ACE_String_Base< CHAR >::rep_.
00406 { 00407 return this->len_ == s.len_ && 00408 ACE_OS::memcmp (this->rep_, 00409 s.rep_, 00410 this->len_ * sizeof (CHAR)) == 0; 00411 } |
|
Greater than comparison operator.
Definition at line 108 of file String_Base.inl. References ACE_TRACE, and ACE_String_Base< CHAR >::compare().
|
|
Return the <slot'th> character by reference in the string (doesn't perform bounds checking).
Definition at line 77 of file String_Base.inl. References ACE_TRACE.
|
|
Return the <slot'th> character in the string (doesn't perform bounds checking).
Definition at line 67 of file String_Base.inl. References ACE_TRACE.
|
|
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 []
Definition at line 371 of file String_Base.cpp. References ACE_NEW_RETURN, ACE_TRACE, and ACE_OS::strsncpy(). Referenced by ACE_Remote_Name_Space::bind(), ACE_Configuration::expand_path(), ACE_Remote_Name_Space::list_name_entries(), ACE_Remote_Name_Space::list_names(), ACE_Remote_Name_Space::list_type_entries(), ACE_Remote_Name_Space::list_types(), ACE_Remote_Name_Space::list_value_entries(), ACE_Remote_Name_Space::list_values(), ACE_Remote_Name_Space::rebind(), ACE_Remote_Name_Space::resolve(), ACE_Local_Name_Space<, ACE_LOCK >::shared_bind_i(), and ACE_Remote_Name_Space::unbind().
00372 { 00373 ACE_TRACE ("ACE_String_Base<CHAR>::rep"); 00374 00375 CHAR *new_string; 00376 ACE_NEW_RETURN (new_string, CHAR[this->len_ + 1], 0); 00377 ACE_OS::strsncpy (new_string, this->rep_, this->len_+1); 00378 00379 return new_string; 00380 } |
|
This method is designed for high-performance. Please use with care ;-) Warning : This method was documented incorrectly in the past. The original intention was to change the length of the string to len, and to fill the whole thing with c CHARs. However, what was actually done was to set the length of the string to zero, and fill the buffer with c's. The buffer was also not null-terminated unless c happened to be zero. Rather than fix the method to work as documented, the code is left as is, but the second parameter should probably not be used. fast_resize just adjusts the buffer if needed and sets the length, it doesn't fill the buffer, so is much faster.
Definition at line 265 of file String_Base.cpp. References ACE_TRACE, ACE_String_Base< CHAR >::fast_resize(), and ACE_OS::memset(). Referenced by ACE_String_Base< CHAR >::ACE_String_Base().
00267 { 00268 ACE_TRACE ("ACE_String_Base<CHAR>::resize"); 00269 00270 fast_resize(len); 00271 ACE_OS::memset (this->rep_, c, this->buf_len_ * sizeof (CHAR)); 00272 } |
|
Find c starting at pos (counting from the end). Returns the slot of the first location that matches, else
Definition at line 451 of file String_Base.cpp. Referenced by ACE_DLL_Handle::get_dll_names().
00454 { 00455 if (pos == npos || pos > this->len_) 00456 pos = this->len_; 00457 00458 // Do not change to prefix operator! Proper operation of this loop 00459 // depends on postfix decrement behavior. 00460 for (size_type i = pos; i-- != 0; ) 00461 if (this->rep_[i] == c) 00462 return i; 00463 00464 return ACE_String_Base<CHAR>::npos; 00465 } |
|
Copy len bytes of s (will zero terminate the result). If release == true then a new buffer is allocated internally if the existing one is not big enough to hold s. If the existing buffer is big enough, then it will be used. This means that set(*, *, 1) is illegal when the string is constructed with a non-owned const char*. (e.g. ACE_String_Base("test", 0, 0)) If release == false then the s buffer is used directly, and any existing buffer is destroyed. If s == 0 then it will _not_ be used, and instead the internal buffer is set to NULL_String_.
Definition at line 129 of file String_Base.cpp. References ACE_ALLOCATOR, ACE_String_Base< CHAR >::buf_len_, ACE_Allocator::free(), ACE_OS::memcpy(), and ACE_String_Base< CHAR >::release_.
00132 { 00133 // Case 1. Going from memory to more memory 00134 size_type new_buf_len = len + 1; 00135 if (s != 0 && len != 0 && release && this->buf_len_ < new_buf_len) 00136 { 00137 CHAR *temp; 00138 ACE_ALLOCATOR (temp, 00139 (CHAR *) this->allocator_->malloc (new_buf_len * sizeof (CHAR))); 00140 00141 if (this->buf_len_ != 0 && this->release_) 00142 this->allocator_->free (this->rep_); 00143 00144 this->rep_ = temp; 00145 this->buf_len_ = new_buf_len; 00146 this->release_ = true; 00147 this->len_ = len; 00148 ACE_OS::memcpy (this->rep_, s, len * sizeof (CHAR)); 00149 this->rep_[len] = 0; 00150 } 00151 else // Case 2. No memory allocation is necessary. 00152 { 00153 // Free memory if necessary and figure out future ownership 00154 if (!release || s == 0 || len == 0) 00155 { 00156 if (this->buf_len_ != 0 && this->release_) 00157 { 00158 this->allocator_->free (this->rep_); 00159 this->release_ = false; 00160 } 00161 } 00162 // Populate data. 00163 if (s == 0 || len == 0) 00164 { 00165 this->buf_len_ = 0; 00166 this->len_ = 0; 00167 this->rep_ = &ACE_String_Base<CHAR>::NULL_String_; 00168 this->release_ = false; 00169 } 00170 else if (!release) // Note: No guarantee that rep_ is null terminated. 00171 { 00172 this->buf_len_ = len; 00173 this->len_ = len; 00174 this->rep_ = const_cast <CHAR *> (s); 00175 this->release_ = false; 00176 } 00177 else 00178 { 00179 ACE_OS::memcpy (this->rep_, s, len * sizeof (CHAR)); 00180 this->rep_[len] = 0; 00181 this->len_ = len; 00182 } 00183 } 00184 } |
|
Copy s into this ACE_String_Base. If release == true then a new buffer is allocated internally if the existing one is not big enough to hold s. If the existing buffer is big enough, then it will be used. This means that set(*, 1) can be illegal when the string is constructed with a const char*. (e.g. ACE_String_Base("test", 0, false)). if release == false then the s buffer is used directly, and any existing buffer is destroyed. If s == 0 then it will _not_ be used, and instead the internal buffer is set to NULL_String_.
Definition at line 341 of file String_Base.cpp. References ACE_OS::strlen(). Referenced by ACE_String_Base< CHAR >::ACE_String_Base(), ACE_String_Base< CHAR >::assign_nocopy(), ACE_Capabilities::getline(), ACE_String_Base< CHAR >::operator=(), ACE_Codeset_Registry::registry_to_locale(), and ACE_Codeset_Registry::registry_to_locale_i().
00342 { 00343 size_t length = 0; 00344 if (s != 0) 00345 length = ACE_OS::strlen (s); 00346 00347 this->set (s, length, release); 00348 } |
|
Comparison operator that will match substrings. Returns the slot of the first location that matches, else
Definition at line 139 of file String_Base.inl. References ACE_TRACE, ACE_String_Base< CHAR >::find(), and ACE_String_Base< CHAR >::rep_. Referenced by ACE_DLL_Handle::open().
|
|
Same as .
Definition at line 56 of file String_Base.inl. References ACE_TRACE, and ACE_String_Base< CHAR >::substring(). Referenced by ACE_Utils::UUID::from_string_i(), and ACE_DLL_Handle::get_dll_names().
|
|
Return a substring given an offset and length. If length ==
Definition at line 188 of file String_Base.cpp. Referenced by ACE_String_Base< CHAR >::substr().
00191 { 00192 ACE_String_Base<CHAR> nill; 00193 size_type count = length; 00194 00195 // case 1. empty string 00196 if (this->len_ == 0) 00197 return nill; 00198 00199 // case 2. start pos past our end 00200 if (offset >= this->len_) 00201 return nill; 00202 // No length == empty string. 00203 else if (length == 0) 00204 return nill; 00205 // Get all remaining bytes. 00206 else if (length == npos || count > (this->len_ - offset)) 00207 count = this->len_ - offset; 00208 00209 return ACE_String_Base<CHAR> (&this->rep_[offset], count, this->allocator_); 00210 } |
|
Swap the contents of this
Definition at line 468 of file String_Base.cpp. References ACE_String_Base< CHAR >::allocator_, ACE_String_Base< CHAR >::buf_len_, ACE_String_Base< CHAR >::len_, ACE_String_Base< CHAR >::release_, and ACE_String_Base< CHAR >::rep_.
00469 { 00470 std::swap (this->allocator_ , str.allocator_); 00471 std::swap (this->len_ , str.len_); 00472 std::swap (this->buf_len_ , str.buf_len_); 00473 std::swap (this->rep_ , str.rep_); 00474 std::swap (this->release_ , str.release_); 00475 } |
|
Declare the dynamic allocation hooks. Definition at line 535 of file String_Base.h. |
|
Pointer to a memory allocator. Definition at line 541 of file String_Base.h. Referenced by ACE_String_Base< CHAR >::swap(). |
|
Length of the ACE_String_Base data buffer. Keeping track of the length allows to avoid unnecessary dynamic allocations. Definition at line 552 of file String_Base.h. Referenced by ACE_String_Base< CHAR >::append(), ACE_String_Base< CHAR >::capacity(), ACE_String_Base< CHAR >::clear(), ACE_String_Base< CHAR >::fast_clear(), ACE_String_Base< CHAR >::fast_resize(), ACE_String_Base< CHAR >::set(), ACE_String_Base< CHAR >::swap(), and ACE_String_Base< CHAR >::~ACE_String_Base(). |
|
Length of the ACE_String_Base data (not counting the trailing ''). Definition at line 546 of file String_Base.h. Referenced by ACE_String_Base< CHAR >::ACE_String_Base(), ACE_String_Base< CHAR >::assign_nocopy(), ACE_String_Base< CHAR >::compare(), ACE_String_Base< CHAR >::operator+=(), ACE_String_Base< CHAR >::operator=(), ACE_String_Base< CHAR >::operator==(), and ACE_String_Base< CHAR >::swap(). |
|
Represents the "NULL" string to simplify the internal logic. Definition at line 23 of file String_Base.cpp. |
|
Flag that indicates if we own the memory Definition at line 562 of file String_Base.h. Referenced by ACE_String_Base< CHAR >::append(), ACE_String_Base< CHAR >::clear(), ACE_String_Base< CHAR >::fast_clear(), ACE_String_Base< CHAR >::fast_resize(), ACE_String_Base< CHAR >::set(), ACE_String_Base< CHAR >::swap(), and ACE_String_Base< CHAR >::~ACE_String_Base(). |
|