ACE/ace/SString.inl

   1 // -*- C++ -*-
   2 // Include ACE.h only if it hasn't already been included, e.g., if
   3 // ACE_TEMPLATES_REQUIRE_SOURCE, ACE.h won't have been pulled in by
   4 // String_Base.cpp.
   5 #ifndef ACE_ACE_H
   6 #  include "ace/ACE.h"
   7 #endif /* !ACE_ACE_H */
   8
   9 #include "ace/OS_NS_stdlib.h"
  10
  11 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  12
  13 ACE_INLINE
  14 ACE_NS_WString::ACE_NS_WString (ACE_Allocator *alloc)
  15   : ACE_WString (alloc)
  16 {
  17 }
  18
  19 ACE_INLINE
  20 ACE_NS_WString::ACE_NS_WString (const ACE_WSTRING_TYPE *s,
  21                                 size_type len,
  22                                 ACE_Allocator *alloc)
  23   : ACE_WString (s, len, alloc)
  24 {
  25 }
  26
  27 ACE_INLINE
  28 ACE_NS_WString::ACE_NS_WString (const ACE_WSTRING_TYPE *s,
  29                                 ACE_Allocator *alloc)
  30   : ACE_WString (s, alloc)
  31 {
  32 }
  33
  34 ACE_INLINE
  35 ACE_NS_WString::ACE_NS_WString (size_type len, ACE_Allocator *alloc)
  36   : ACE_WString (len, 0, alloc)
  37 {
  38 }
  39
  40 ACE_INLINE
  41 ACE_NS_WString::ACE_NS_WString (const ACE_NS_WString &s)
  42   : ACE_WString (s)
  43 {
  44 }
  45
  46 ACE_INLINE
  47 ACE_NS_WString::ACE_NS_WString (ACE_WSTRING_TYPE c, ACE_Allocator *alloc)
  48   : ACE_WString (c, alloc)
  49 {
  50 }
  51
  52 ACE_INLINE ACE_NS_WString
  53 operator+ (const ACE_NS_WString &s, const ACE_NS_WString &t)
  54 {
  55   ACE_NS_WString temp (s);
  56   temp += t;
  57   return temp;
  58 }
  59
  60 // -------------------------------------------------------
  61
  62 ACE_INLINE
  63 ACE_SString::~ACE_SString (void)
  64 {
  65 }
  66
  67 ACE_INLINE ACE_SString
  68 ACE_SString::substr (size_type offset,
  69                      size_type length) const
  70 {
  71   return this->substring (offset, length);
  72 }
  73
  74 // Return the <slot'th> character in the string.
  75
  76 ACE_INLINE char
  77 ACE_SString::operator[] (size_type slot) const
  78 {
  79   ACE_TRACE ("ACE_SString::operator[]");
  80   return this->rep_[slot];
  81 }
  82
  83 // Return the <slot'th> character in the string by reference.
  84
  85 ACE_INLINE char &
  86 ACE_SString::operator[] (size_type slot)
  87 {
  88   ACE_TRACE ("ACE_SString::operator[]");
  89   return this->rep_[slot];
  90 }
  91
  92 // Get the underlying pointer (does not make a copy, so beware!).
  93
  94 ACE_INLINE const char *
  95 ACE_SString::rep (void) const
  96 {
  97   ACE_TRACE ("ACE_SString::rep");
  98   return this->rep_;
  99 }
 100
 101 // Get the underlying pointer (does not make a copy, so beware!).
 102
 103 ACE_INLINE const char *
 104 ACE_SString::fast_rep (void) const
 105 {
 106   ACE_TRACE ("ACE_SString::fast_rep");
 107   return this->rep_;
 108 }
 109
 110 // Get the underlying pointer (does not make a copy, so beware!).
 111
 112 ACE_INLINE const char *
 113 ACE_SString::c_str (void) const
 114 {
 115   ACE_TRACE ("ACE_SString::c_str");
 116   return this->rep_;
 117 }
 118
 119 // Comparison operator.
 120
 121 ACE_INLINE bool
 122 ACE_SString::operator== (const ACE_SString &s) const
 123 {
 124   ACE_TRACE ("ACE_SString::operator==");
 125   return this->len_ == s.len_
 126     && ACE_OS::strcmp (this->rep_, s.rep_) == 0;
 127 }
 128
 129 // Less than comparison operator.
 130
 131 ACE_INLINE bool
 132 ACE_SString::operator < (const ACE_SString &s) const
 133 {
 134   ACE_TRACE ("ACE_SString::operator <");
 135
 136   return (this->rep_ && s.rep_)
 137     ? ACE_OS::strcmp (this->rep_, s.rep_) < 0
 138     : ((s.rep_) ? true : false);
 139 }
 140
 141 // Greater than comparison operator.
 142
 143 ACE_INLINE bool
 144 ACE_SString::operator > (const ACE_SString &s) const
 145 {
 146   ACE_TRACE ("ACE_SString::operator >");
 147
 148   return (this->rep_ && s.rep_)
 149     ? ACE_OS::strcmp (this->rep_, s.rep_) > 0
 150     : ((this->rep_) ? true : false );
 151 }
 152
 153 // Comparison operator.
 154
 155 ACE_INLINE bool
 156 ACE_SString::operator!= (const ACE_SString &s) const
 157 {
 158   ACE_TRACE ("ACE_SString::operator!=");
 159   return !(*this == s);
 160 }
 161
 162 ACE_INLINE int
 163 ACE_SString::compare (const ACE_SString &s) const
 164 {
 165   ACE_TRACE ("ACE_SString::compare");
 166   return ACE_OS::strcmp (this->rep_, s.rep_);
 167 }
 168
 169 ACE_INLINE ACE_SString::size_type
 170 ACE_SString::find (const char *s, size_type pos) const
 171 {
 172   char *substr = this->rep_ + pos;
 173   char *pointer = ACE_OS::strstr (substr, s);
 174   if (pointer == 0)
 175     return ACE_SString::npos;
 176   else
 177     return pointer - this->rep_;
 178 }
 179
 180 ACE_INLINE ACE_SString::size_type
 181 ACE_SString::find (char c, size_type pos) const
 182 {
 183   char *substr = this->rep_ + pos;
 184   char *pointer = ACE_OS::strchr (substr, c);
 185   if (pointer == 0)
 186     return ACE_SString::npos;
 187   else
 188     return pointer - this->rep_;
 189 }
 190
 191 ACE_INLINE ACE_SString::size_type
 192 ACE_SString::strstr (const ACE_SString &s) const
 193 {
 194   ACE_TRACE ("ACE_SString::strstr");
 195
 196   return this->find (s.rep_);
 197 }
 198
 199 ACE_INLINE ACE_SString::size_type
 200 ACE_SString::find (const ACE_SString &str, size_type pos) const
 201 {
 202   return this->find (str.rep_, pos);
 203 }
 204
 205 ACE_INLINE ACE_SString::size_type
 206 ACE_SString::rfind (char c, size_type pos) const
 207 {
 208   if (pos == ACE_SString::npos)
 209     pos = this->len_;
 210
 211   // Do not change to prefix operator!  Proper operation of this loop
 212   // depends on postfix decrement behavior.
 213   for (size_type i = pos; i-- != 0; )
 214     if (this->rep_[i] == c)
 215       return i;
 216
 217   return ACE_SString::npos;
 218 }
 219
 220 ACE_INLINE u_long
 221 ACE_SString::hash (void) const
 222 {
 223   return ACE::hash_pjw (this->rep_);
 224 }
 225
 226 ACE_INLINE ACE_SString::size_type
 227 ACE_SString::length (void) const
 228 {
 229   ACE_TRACE ("ACE_SString::length");
 230   return this->len_;
 231 }
 232
 233 ACE_INLINE
 234 ACE_Auto_String_Free::ACE_Auto_String_Free (char* p)
 235   :  p_ (p)
 236 {
 237 }
 238
 239 ACE_INLINE
 240 ACE_Auto_String_Free::ACE_Auto_String_Free (ACE_Auto_String_Free& rhs)
 241   :  p_ (rhs.p_)
 242 {
 243   rhs.p_ = 0;
 244 }
 245
 246 ACE_INLINE void
 247 ACE_Auto_String_Free::reset (char* p)
 248 {
 249 #if defined (ACE_HAS_ALLOC_HOOKS)
 250   ACE_Allocator::instance()->free (this->p_);
 251 #else
 252   ACE_OS::free (this->p_);
 253 #endif /* ACE_HAS_ALLOC_HOOKS */
 254   this->p_ = p;
 255 }
 256
 257 ACE_INLINE ACE_Auto_String_Free&
 258 ACE_Auto_String_Free::operator= (ACE_Auto_String_Free& rhs)
 259 {
 260   if (this != &rhs)
 261     {
 262       this->reset (rhs.p_);
 263       rhs.p_ = 0;
 264     }
 265   return *this;
 266 }
 267
 268 ACE_INLINE
 269 ACE_Auto_String_Free::~ACE_Auto_String_Free (void)
 270 {
 271   this->reset (0);
 272 }
 273
 274 ACE_INLINE char*
 275 ACE_Auto_String_Free::operator* (void) const
 276 {
 277   return this->p_;
 278 }
 279
 280 ACE_INLINE char
 281 ACE_Auto_String_Free::operator[] (size_t i) const
 282 {
 283   return this->p_[i];
 284 }
 285
 286 ACE_INLINE char*
 287 ACE_Auto_String_Free::get (void) const
 288 {
 289   return this->p_;
 290 }
 291
 292 ACE_INLINE char*
 293 ACE_Auto_String_Free::release (void)
 294 {
 295   char* p = this->p_;
 296   this->p_ = 0;
 297   return p;
 298 }
 299
 300 ACE_END_VERSIONED_NAMESPACE_DECL