ACE/ace/SString.inl

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