ACE/ace/String_Base.inl

   1 // -*- C++ -*-
   2 #include "ace/Malloc_Base.h"
   3 #include "ace/Min_Max.h"
   4 #include "ace/OS_NS_string.h"
   5 #include "ace/OS_Memory.h"
   6
   7 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   8
   9 template <class ACE_CHAR_T> ACE_INLINE void
  10 ACE_String_Base<ACE_CHAR_T>::dump () const
  11 {
  12 #if defined (ACE_HAS_DUMP)
  13   ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::dump");
  14 #endif /* ACE_HAS_DUMP */
  15 }
  16
  17 // Assignment method (does not copy memory)
  18 template <class ACE_CHAR_T> ACE_INLINE ACE_String_Base<ACE_CHAR_T> &
  19 ACE_String_Base<ACE_CHAR_T>::assign_nocopy (const ACE_String_Base<ACE_CHAR_T> &s)
  20 {
  21   ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::assign_nocopy");
  22   this->set (s.rep_, s.len_, false);
  23   return *this;
  24 }
  25
  26 template <class ACE_CHAR_T> ACE_INLINE typename ACE_String_Base<ACE_CHAR_T>::size_type
  27 ACE_String_Base<ACE_CHAR_T>::length () const
  28 {
  29   ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::length");
  30   return this->len_;
  31 }
  32
  33 template <class ACE_CHAR_T> ACE_INLINE size_t
  34 ACE_String_Base<ACE_CHAR_T>::capacity () const
  35 {
  36   ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::capacity");
  37   return this->buf_len_;
  38 }
  39
  40 template <class ACE_CHAR_T> ACE_INLINE bool
  41 ACE_String_Base<ACE_CHAR_T>::is_empty () const
  42 {
  43   return this->len_ == 0;
  44 }
  45
  46 template <class ACE_CHAR_T> ACE_INLINE bool
  47 ACE_String_Base<ACE_CHAR_T>::empty () const
  48 {
  49   return this->is_empty ();
  50 }
  51
  52 template <class ACE_CHAR_T> ACE_INLINE ACE_String_Base<ACE_CHAR_T>
  53 ACE_String_Base<ACE_CHAR_T>::substr (
  54   typename ACE_String_Base<ACE_CHAR_T>::size_type offset,
  55   typename ACE_String_Base<ACE_CHAR_T>::size_type length) const
  56 {
  57   ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::substr");
  58   return this->substring (offset, length);
  59 }
  60
  61 // Return the <slot'th> character in the string.
  62
  63 template <class ACE_CHAR_T> ACE_INLINE const ACE_CHAR_T &
  64 ACE_String_Base<ACE_CHAR_T>::operator[] (
  65   typename ACE_String_Base<ACE_CHAR_T>::size_type slot) const
  66 {
  67   ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::operator[]");
  68   return this->rep_[slot];
  69 }
  70
  71 // Return the <slot'th> character in the string by reference.
  72
  73 template <class ACE_CHAR_T> ACE_INLINE ACE_CHAR_T &
  74 ACE_String_Base<ACE_CHAR_T>::operator[] (
  75   typename ACE_String_Base<ACE_CHAR_T>::size_type slot)
  76 {
  77   ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::operator[]");
  78   return this->rep_[slot];
  79 }
  80
  81 template <class ACE_CHAR_T> ACE_INLINE const ACE_CHAR_T *
  82 ACE_String_Base<ACE_CHAR_T>::fast_rep () const
  83 {
  84   return this->rep_;
  85 }
  86
  87 template <class ACE_CHAR_T> ACE_INLINE const ACE_CHAR_T *
  88 ACE_String_Base<ACE_CHAR_T>::c_str () const
  89 {
  90   return this->rep_;
  91 }
  92
  93 // Less than comparison operator.
  94
  95 template <class ACE_CHAR_T> ACE_INLINE bool
  96 ACE_String_Base<ACE_CHAR_T>::operator < (const ACE_String_Base<ACE_CHAR_T> &s) const
  97 {
  98   ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::operator <");
  99   return compare (s) < 0;
 100 }
 101
 102 // Greater than comparison operator.
 103
 104 template <class ACE_CHAR_T> ACE_INLINE bool
 105 ACE_String_Base<ACE_CHAR_T>::operator > (const ACE_String_Base &s) const
 106 {
 107   ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::operator >");
 108   return compare (s) > 0;
 109 }
 110
 111
 112 // Comparison operator.
 113
 114 template <class ACE_CHAR_T> ACE_INLINE bool
 115 ACE_String_Base<ACE_CHAR_T>::operator!= (const ACE_String_Base<ACE_CHAR_T> &s) const
 116 {
 117   ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::operator!=");
 118   return !(*this == s);
 119 }
 120
 121 template <class ACE_CHAR_T> ACE_INLINE bool
 122 ACE_String_Base<ACE_CHAR_T>::operator!= (const ACE_CHAR_T *s) const
 123 {
 124   return !(*this == s);
 125 }
 126
 127 template <class ACE_CHAR_T> ACE_INLINE typename ACE_String_Base<ACE_CHAR_T>::size_type
 128 ACE_String_Base<ACE_CHAR_T>::find (const ACE_String_Base<ACE_CHAR_T>&str,
 129                              typename ACE_String_Base<ACE_CHAR_T>::size_type pos) const
 130 {
 131   ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::find");
 132   return this->find (str.rep_, pos);
 133 }
 134
 135 template <class ACE_CHAR_T> ACE_INLINE typename ACE_String_Base<ACE_CHAR_T>::size_type
 136 ACE_String_Base<ACE_CHAR_T>::strstr (const ACE_String_Base<ACE_CHAR_T> &s) const
 137 {
 138   ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::strstr");
 139   return this->find (s.rep_);
 140 }
 141
 142 template <class ACE_CHAR_T> ACE_INLINE typename ACE_String_Base<ACE_CHAR_T>::iterator
 143 ACE_String_Base<ACE_CHAR_T>::begin ()
 144 {
 145   ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::begin");
 146   return iterator (*this);
 147 }
 148
 149 template <class ACE_CHAR_T> ACE_INLINE typename ACE_String_Base<ACE_CHAR_T>::const_iterator
 150 ACE_String_Base<ACE_CHAR_T>::begin () const
 151 {
 152   ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::begin");
 153   return const_iterator (*this);
 154 }
 155
 156 template <class ACE_CHAR_T> ACE_INLINE typename ACE_String_Base<ACE_CHAR_T>::iterator
 157 ACE_String_Base<ACE_CHAR_T>::end ()
 158 {
 159   ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::end");
 160   return iterator (*this, 1);
 161 }
 162
 163 template <class ACE_CHAR_T> ACE_INLINE typename ACE_String_Base<ACE_CHAR_T>::const_iterator
 164 ACE_String_Base<ACE_CHAR_T>::end () const
 165 {
 166   ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::end");
 167   return const_iterator (*this, 1);
 168 }
 169
 170 // ----------------------------------------------
 171
 172 template <class ACE_CHAR_T> ACE_INLINE
 173 ACE_String_Base_Iterator <ACE_CHAR_T>::
 174 ACE_String_Base_Iterator (ACE_String_Base <ACE_CHAR_T> & str, int end)
 175 : str_ (&str),
 176   index_ (0 == end ? 0 : str.length ())
 177 {
 178   ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::ACE_String_Base_Iterator");
 179 }
 180
 181 template <class ACE_CHAR_T> ACE_INLINE
 182 ACE_String_Base_Iterator <ACE_CHAR_T>::
 183 ACE_String_Base_Iterator (const ACE_String_Base_Iterator <ACE_CHAR_T> & iter)
 184 : str_ (iter.str_),
 185   index_ (iter.index_)
 186 {
 187   ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::ACE_String_Base_Iterator");
 188 }
 189
 190 template <class ACE_CHAR_T> ACE_INLINE
 191 ACE_String_Base_Iterator <ACE_CHAR_T>::~ACE_String_Base_Iterator ()
 192 {
 193   ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::~ACE_String_Base_Iterator");
 194 }
 195
 196 template <class ACE_CHAR_T> ACE_INLINE
 197 int ACE_String_Base_Iterator <ACE_CHAR_T>::done () const
 198 {
 199   ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::done");
 200
 201   return this->index_ >= this->str_->length () ? 1 : 0;
 202 }
 203
 204 template <class ACE_CHAR_T> ACE_INLINE
 205 ACE_CHAR_T & ACE_String_Base_Iterator <ACE_CHAR_T>::operator * ()
 206 {
 207   ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::operator *");
 208
 209   return this->str_->rep_[this->index_];
 210 }
 211
 212 template <class ACE_CHAR_T> ACE_INLINE
 213 ACE_String_Base_Iterator <ACE_CHAR_T> &
 214 ACE_String_Base_Iterator <ACE_CHAR_T>::operator ++ ()
 215 {
 216   ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::operator ++");
 217
 218   if (0 == this->done ())
 219     ++ this->index_;
 220
 221   return *this;
 222 }
 223
 224 template <class ACE_CHAR_T> ACE_INLINE
 225 ACE_String_Base_Iterator <ACE_CHAR_T>
 226 ACE_String_Base_Iterator <ACE_CHAR_T>::operator ++ (int)
 227 {
 228   ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::operator ++ (int)");
 229
 230   ACE_String_Base_Iterator <ACE_CHAR_T> temp (*this);
 231
 232   if (0 == this->done ())
 233     ++ this->index_;
 234
 235   return temp;
 236 }
 237
 238 template <class ACE_CHAR_T> ACE_INLINE
 239 ACE_String_Base_Iterator <ACE_CHAR_T> &
 240 ACE_String_Base_Iterator <ACE_CHAR_T>::operator -- ()
 241 {
 242   ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::operator --");
 243
 244   if (0 < this->index_)
 245     -- this->index_;
 246
 247   return *this;
 248 }
 249
 250 template <class ACE_CHAR_T> ACE_INLINE
 251 ACE_String_Base_Iterator <ACE_CHAR_T>
 252 ACE_String_Base_Iterator <ACE_CHAR_T>::operator -- (int)
 253 {
 254   ACE_TRACE ("ACE_String_Base_Iterator<ACE_CHAR_T>::operator -- (int)");
 255
 256   ACE_String_Base_Iterator <ACE_CHAR_T> temp (*this);
 257
 258   if (0 < this->index_)
 259     -- this->index_;
 260
 261   return temp;
 262 }
 263
 264 template <class ACE_CHAR_T> ACE_INLINE bool
 265 ACE_String_Base_Iterator <ACE_CHAR_T>::
 266 operator == (const ACE_String_Base_Iterator <ACE_CHAR_T> & rhs) const
 267 {
 268   return this->index_ == rhs.index_;
 269 }
 270
 271 template <class ACE_CHAR_T> ACE_INLINE bool
 272 ACE_String_Base_Iterator <ACE_CHAR_T>::
 273 operator != (const ACE_String_Base_Iterator <ACE_CHAR_T> & rhs) const
 274 {
 275   return this->index_ != rhs.index_;
 276 }
 277
 278 template <class ACE_CHAR_T> ACE_INLINE bool
 279 ACE_String_Base_Iterator <ACE_CHAR_T>::
 280 operator < (const ACE_String_Base_Iterator <ACE_CHAR_T> & rhs) const
 281 {
 282   return this->index_ < rhs.index_;
 283 }
 284
 285 template <class ACE_CHAR_T> ACE_INLINE bool
 286 ACE_String_Base_Iterator <ACE_CHAR_T>::
 287 operator > (const ACE_String_Base_Iterator <ACE_CHAR_T> & rhs) const
 288 {
 289   return this->index_ > rhs.index_;
 290 }
 291
 292 template <class ACE_CHAR_T> ACE_INLINE bool
 293 ACE_String_Base_Iterator <ACE_CHAR_T>::
 294 operator >= (const ACE_String_Base_Iterator <ACE_CHAR_T> & rhs) const
 295 {
 296   return this->index_ >= rhs.index_;
 297 }
 298
 299 template <class ACE_CHAR_T> ACE_INLINE bool
 300 ACE_String_Base_Iterator <ACE_CHAR_T>::
 301 operator <= (const ACE_String_Base_Iterator <ACE_CHAR_T> & rhs) const
 302 {
 303   return this->index_ <= rhs.index_;
 304 }
 305
 306 // ----------------------------------------------
 307
 308 template <class ACE_CHAR_T> ACE_INLINE
 309 ACE_String_Base_Const_Iterator <ACE_CHAR_T>::
 310 ACE_String_Base_Const_Iterator (const ACE_String_Base <ACE_CHAR_T> & str, int end)
 311 : str_ (&str),
 312   index_ (0 == end ? 0 : str.length ())
 313 {
 314   ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::ACE_String_Base_Const_Iterator");
 315 }
 316
 317 template <class ACE_CHAR_T> ACE_INLINE
 318 ACE_String_Base_Const_Iterator <ACE_CHAR_T>::
 319 ACE_String_Base_Const_Iterator (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & iter)
 320 : str_ (iter.str_),
 321   index_ (iter.index_)
 322 {
 323   ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::ACE_String_Base_Const_Iterator");
 324 }
 325
 326 template <class ACE_CHAR_T> ACE_INLINE
 327 ACE_String_Base_Const_Iterator <ACE_CHAR_T>::~ACE_String_Base_Const_Iterator ()
 328 {
 329   ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::~ACE_String_Base_Const_Iterator");
 330 }
 331
 332 template <class ACE_CHAR_T> ACE_INLINE
 333 int ACE_String_Base_Const_Iterator <ACE_CHAR_T>::done () const
 334 {
 335   ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::done");
 336
 337   return this->index_ >= this->str_->length () ? 1 : 0;
 338 }
 339
 340 template <class ACE_CHAR_T> ACE_INLINE
 341 const ACE_CHAR_T & ACE_String_Base_Const_Iterator <ACE_CHAR_T>::operator * ()
 342 {
 343   ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::operator *");
 344
 345   return this->str_->rep_[this->index_];
 346 }
 347
 348 template <class ACE_CHAR_T> ACE_INLINE
 349 ACE_String_Base_Const_Iterator <ACE_CHAR_T> &
 350 ACE_String_Base_Const_Iterator <ACE_CHAR_T>::operator ++ ()
 351 {
 352   ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::operator ++");
 353
 354   if (0 == this->done ())
 355     ++ this->index_;
 356
 357   return *this;
 358 }
 359
 360 template <class ACE_CHAR_T> ACE_INLINE
 361 ACE_String_Base_Const_Iterator <ACE_CHAR_T>
 362 ACE_String_Base_Const_Iterator <ACE_CHAR_T>::operator ++ (int)
 363 {
 364   ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::operator ++ (int)");
 365
 366   ACE_String_Base_Const_Iterator <ACE_CHAR_T> temp (*this);
 367
 368   if (0 == this->done ())
 369     ++ this->index_;
 370
 371   return temp;
 372 }
 373
 374 template <class ACE_CHAR_T> ACE_INLINE
 375 ACE_String_Base_Const_Iterator <ACE_CHAR_T> &
 376 ACE_String_Base_Const_Iterator <ACE_CHAR_T>::operator -- ()
 377 {
 378   ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::operator --");
 379
 380   if (0 < this->index_)
 381     -- this->index_;
 382
 383   return *this;
 384 }
 385
 386 template <class ACE_CHAR_T> ACE_INLINE
 387 ACE_String_Base_Const_Iterator <ACE_CHAR_T>
 388 ACE_String_Base_Const_Iterator <ACE_CHAR_T>::operator -- (int)
 389 {
 390   ACE_TRACE ("ACE_String_Base_Const_Iterator<ACE_CHAR_T>::operator -- (int)");
 391
 392   ACE_String_Base_Const_Iterator <ACE_CHAR_T> temp (*this);
 393
 394   if (0 < this->index_)
 395     -- this->index_;
 396
 397   return temp;
 398 }
 399
 400 template <class ACE_CHAR_T> ACE_INLINE bool
 401 ACE_String_Base_Const_Iterator <ACE_CHAR_T>::
 402 operator == (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & rhs) const
 403 {
 404   return this->index_ == rhs.index_;
 405 }
 406
 407 template <class ACE_CHAR_T> ACE_INLINE bool
 408 ACE_String_Base_Const_Iterator <ACE_CHAR_T>::
 409 operator != (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & rhs) const
 410 {
 411   return this->index_ != rhs.index_;
 412 }
 413
 414 template <class ACE_CHAR_T> ACE_INLINE bool
 415 ACE_String_Base_Const_Iterator <ACE_CHAR_T>::
 416 operator < (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & rhs) const
 417 {
 418   return this->index_ < rhs.index_;
 419 }
 420
 421 template <class ACE_CHAR_T> ACE_INLINE bool
 422 ACE_String_Base_Const_Iterator <ACE_CHAR_T>::
 423 operator > (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & rhs) const
 424 {
 425   return this->index_ > rhs.index_;
 426 }
 427
 428 template <class ACE_CHAR_T> ACE_INLINE bool
 429 ACE_String_Base_Const_Iterator <ACE_CHAR_T>::
 430 operator >= (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & rhs) const
 431 {
 432   return this->index_ >= rhs.index_;
 433 }
 434
 435 template <class ACE_CHAR_T> ACE_INLINE bool
 436 ACE_String_Base_Const_Iterator <ACE_CHAR_T>::
 437 operator <= (const ACE_String_Base_Const_Iterator <ACE_CHAR_T> & rhs) const
 438 {
 439   return this->index_ <= rhs.index_;
 440 }
 441
 442 // ----------------------------------------------
 443
 444 template <class ACE_CHAR_T> ACE_INLINE bool
 445 operator== (const ACE_CHAR_T *s, const ACE_String_Base<ACE_CHAR_T> &t)
 446 {
 447   return t == s;
 448 }
 449
 450 template <class ACE_CHAR_T> ACE_INLINE bool
 451 operator!= (const ACE_CHAR_T *s, const ACE_String_Base<ACE_CHAR_T> &t)
 452 {
 453   return !(t == s);
 454 }
 455
 456 ACE_END_VERSIONED_NAMESPACE_DECL