ACE/ace/SString.cpp

   1 #include "ace/Malloc_T.h"
   2 #include "ace/OS_Memory.h"
   3 #include "ace/SString.h"
   4 #include "ace/OS_NS_string.h"
   5 #include "ace/Numeric_Limits.h"
   6
   7 #if !defined (ACE_LACKS_IOSTREAM_TOTALLY)
   8 // FUZZ: disable check_for_streams_include
   9 # include "ace/streams.h"
  10 #endif /* ! ACE_LACKS_IOSTREAM_TOTALLY */
  11
  12 #if !defined (__ACE_INLINE__)
  13 #include "ace/SString.inl"
  14 #endif /* __ACE_INLINE__ */
  15
  16 // ************************************************************
  17
  18 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  19
  20 #if !defined (ACE_LACKS_IOSTREAM_TOTALLY)
  21 ACE_OSTREAM_TYPE &
  22 operator<< (ACE_OSTREAM_TYPE &os, const ACE_CString &cs)
  23 {
  24   if (cs.fast_rep () != 0)
  25     os << cs.fast_rep ();
  26   return os;
  27 }
  28
  29 ACE_OSTREAM_TYPE &
  30 operator<< (ACE_OSTREAM_TYPE &os, const ACE_WString &ws)
  31 {
  32   // @@ Need to figure out how to print the "wide" string
  33   //    on platforms that don't support "wide" strings.
  34 #if defined (ACE_HAS_WCHAR)
  35   os << ACE_Wide_To_Ascii (ws.fast_rep ()).char_rep ();
  36 #else
  37   ACE_UNUSED_ARG (ws);
  38   os << "(*non-printable string*)";
  39 #endif
  40   return os;
  41 }
  42
  43 ACE_OSTREAM_TYPE &
  44 operator<< (ACE_OSTREAM_TYPE &os, const ACE_SString &ss)
  45 {
  46   if (ss.fast_rep () != 0)
  47     os << ss.fast_rep ();
  48   return os;
  49 }
  50 #endif /* !ACE_LACKS_IOSTREAM_TOTALLY */
  51
  52 // *****************************************************************
  53
  54 char *
  55 ACE_NS_WString::char_rep () const
  56 {
  57   ACE_TRACE ("ACE_NS_WString::char_rep");
  58   if (this->len_ == 0)
  59     return 0;
  60   else
  61     {
  62       char *t = 0;
  63
  64 #if defined (ACE_HAS_ALLOC_HOOKS)
  65       ACE_ALLOCATOR_RETURN (t,
  66                             static_cast<char*>(ACE_Allocator::instance()->malloc (sizeof (char) * (this->len_ + 1))),
  67                             0);
  68 #else
  69       ACE_NEW_RETURN (t,
  70                       char[this->len_ + 1],
  71                       0);
  72 #endif
  73
  74       for (size_type i = 0; i < this->len_; ++i)
  75         // Note that this cast may lose data if wide chars are
  76         // actually used!
  77         t[i] = char (this->rep_[i]);
  78
  79       t[this->len_] = '\0';
  80       return t;
  81     }
  82 }
  83
  84 ACE_UINT16 *
  85 ACE_NS_WString::ushort_rep () const
  86 {
  87   ACE_TRACE ("ACE_NS_WString::ushort_rep");
  88   if (this->len_ <= 0)
  89     return 0;
  90   else
  91     {
  92       ACE_UINT16 *t = 0;
  93
  94 #if defined (ACE_HAS_ALLOC_HOOKS)
  95       ACE_ALLOCATOR_RETURN (t,
  96                             static_cast<ACE_UINT16*> (ACE_Allocator::instance()->malloc(sizeof(ACE_UINT16) * (this->len_ + 1))),
  97                             0);
  98 #else
  99       ACE_NEW_RETURN (t,
 100                       ACE_UINT16[this->len_ + 1],
 101                       0);
 102 #endif
 103
 104       for (size_type i = 0; i < this->len_; ++i)
 105         // Note that this cast may lose data if wide chars are
 106         // actually used!
 107         t[i] = (ACE_UINT16)this->rep_[i];
 108
 109       t[this->len_] = 0;
 110       return t;
 111     }
 112 }
 113
 114 ACE_NS_WString::ACE_NS_WString (const char *s,
 115                                 ACE_Allocator *alloc)
 116   : ACE_WString (alloc)
 117 {
 118   if (s == 0)
 119     return;
 120
 121   this->len_ = this->buf_len_ = ACE_OS::strlen (s);
 122
 123   if (this->buf_len_ == 0)
 124     return;
 125
 126   ACE_ALLOCATOR (this->rep_,
 127                  (ACE_WSTRING_TYPE *)
 128                  this->allocator_->malloc ((this->buf_len_ + 1) *
 129                                            sizeof (ACE_WSTRING_TYPE)));
 130   this->release_ = 1;
 131   for (size_type i = 0; i <= this->buf_len_; ++i)
 132     this->rep_[i] = s[i];
 133 }
 134
 135 #if defined (ACE_WSTRING_HAS_USHORT_SUPPORT)
 136 ACE_NS_WString::ACE_NS_WString (const ACE_UINT16 *s,
 137                                 size_type len,
 138                                 ACE_Allocator *alloc)
 139   : ACE_WString (alloc)
 140 {
 141   if (s == 0)
 142     return;
 143
 144   this->buf_len_ = len;
 145
 146   if (this->buf_len_ == 0)
 147     return;
 148
 149   ACE_ALLOCATOR (this->rep_,
 150                  (ACE_WSTRING_TYPE *)
 151                  this->allocator_->malloc ((this->buf_len_) *
 152                                            sizeof (ACE_WSTRING_TYPE)));
 153   this->release_ = 1;
 154   for (size_type i = 0; i < this->buf_len_; ++i)
 155     this->rep_[i] = s[i];
 156 }
 157 #endif /* ACE_WSTRING_HAS_USHORT_SUPPORT */
 158
 159 // *****************************************************************
 160
 161 ACE_SString::size_type const ACE_SString::npos =
 162   ACE_Numeric_Limits<ACE_SString::size_type>::max ();
 163
 164 ACE_ALLOC_HOOK_DEFINE(ACE_SString)
 165
 166 void
 167 ACE_SString::dump () const
 168 {
 169 #if defined (ACE_HAS_DUMP)
 170   ACE_TRACE ("ACE_SString::dump");
 171 #endif /* ACE_HAS_DUMP */
 172 }
 173
 174 // Copy constructor.
 175
 176 ACE_SString::ACE_SString (const ACE_SString &s)
 177   : allocator_ (s.allocator_),
 178     len_ (s.len_)
 179 {
 180   ACE_TRACE ("ACE_SString::ACE_SString");
 181
 182   if (this->allocator_ == 0)
 183     this->allocator_ = ACE_Allocator::instance ();
 184
 185   this->rep_ = (char *) this->allocator_->malloc (s.len_ + 1);
 186   ACE_OS::memcpy ((void *) this->rep_,
 187                   (const void *) s.rep_,
 188                   this->len_);
 189   this->rep_[this->len_] = '\0';
 190 }
 191
 192 // Default constructor.
 193
 194 ACE_SString::ACE_SString (ACE_Allocator *alloc)
 195   : allocator_ (alloc),
 196     len_ (0),
 197     rep_ (0)
 198
 199 {
 200   ACE_TRACE ("ACE_SString::ACE_SString");
 201
 202   if (this->allocator_ == 0)
 203     this->allocator_ = ACE_Allocator::instance ();
 204
 205   this->len_ = 0;
 206   this->rep_ = (char *) this->allocator_->malloc (this->len_ + 1);
 207   this->rep_[this->len_] = '\0';
 208 }
 209
 210 // Set the underlying pointer (does not copy memory).
 211
 212 void
 213 ACE_SString::rep (char *s)
 214 {
 215   ACE_TRACE ("ACE_SString::rep");
 216
 217   this->rep_ = s;
 218
 219   if (s == 0)
 220     this->len_ = 0;
 221   else
 222     this->len_ = ACE_OS::strlen (s);
 223 }
 224
 225 // Constructor that actually copies memory.
 226
 227 ACE_SString::ACE_SString (const char *s,
 228                           ACE_Allocator *alloc)
 229   : allocator_ (alloc)
 230 {
 231   ACE_TRACE ("ACE_SString::ACE_SString");
 232
 233   if (this->allocator_ == 0)
 234     this->allocator_ = ACE_Allocator::instance ();
 235
 236   if (s == 0)
 237     {
 238       this->len_ = 0;
 239       this->rep_ = (char *) this->allocator_->malloc (this->len_ + 1);
 240       this->rep_[this->len_] = '\0';
 241     }
 242   else
 243     {
 244       this->len_ = ACE_OS::strlen (s);
 245       this->rep_ = (char *) this->allocator_->malloc (this->len_ + 1);
 246       ACE_OS::strcpy (this->rep_, s);
 247     }
 248 }
 249
 250 ACE_SString::ACE_SString (char c,
 251                           ACE_Allocator *alloc)
 252   : allocator_ (alloc)
 253 {
 254   ACE_TRACE ("ACE_SString::ACE_SString");
 255
 256   if (this->allocator_ == 0)
 257     this->allocator_ = ACE_Allocator::instance ();
 258
 259   this->len_ = 1;
 260   this->rep_ = (char *) this->allocator_->malloc (this->len_ + 1);
 261   this->rep_[0] = c;
 262   this->rep_[this->len_] = '\0';
 263 }
 264
 265 // Constructor that actually copies memory.
 266
 267 ACE_SString::ACE_SString (const char *s,
 268                           size_type len,
 269                           ACE_Allocator *alloc)
 270   : allocator_ (alloc)
 271 {
 272   ACE_TRACE ("ACE_SString::ACE_SString");
 273
 274   if (this->allocator_ == 0)
 275     this->allocator_ = ACE_Allocator::instance ();
 276
 277   if (s == 0)
 278     {
 279       this->len_ = 0;
 280       this->rep_ = (char *) this->allocator_->malloc (this->len_ + 1);
 281       this->rep_[this->len_] = '\0';
 282     }
 283   else
 284     {
 285       this->len_ = len;
 286       this->rep_ = (char *) this->allocator_->malloc (this->len_ + 1);
 287       ACE_OS::memcpy (this->rep_, s, len);
 288       this->rep_[len] = '\0'; // Make sure to NUL terminate this!
 289     }
 290 }
 291
 292 // Assignment operator (does copy memory).
 293
 294 ACE_SString &
 295 ACE_SString::operator= (const ACE_SString &s)
 296 {
 297   ACE_TRACE ("ACE_SString::operator=");
 298   // Check for identify.
 299
 300   if (this != &s)
 301     {
 302       // Only reallocate if we don't have enough space...
 303       if (this->len_ < s.len_)
 304         {
 305           this->allocator_->free (this->rep_);
 306           this->rep_ = (char *) this->allocator_->malloc (s.len_ + 1);
 307         }
 308       this->len_ = s.len_;
 309       ACE_OS::strcpy (this->rep_, s.rep_);
 310     }
 311
 312   return *this;
 313 }
 314
 315 // Return substring.
 316 ACE_SString
 317 ACE_SString::substring (size_type offset,
 318                         size_type length) const
 319 {
 320   size_t count = length;
 321
 322   // case 1. empty string
 323   if (len_ == 0)
 324     return ACE_SString ();
 325
 326   // case 2. start pos l
 327   if (offset >= len_)
 328     return ACE_SString ();
 329
 330   // get all remaining bytes
 331   if (length == npos || count > (this->len_ - offset))
 332     count = len_ - offset;
 333
 334   return ACE_SString (&rep_[offset], count, this->allocator_);
 335 }
 336
 337 // ************************************************************
 338
 339 #if defined (ACE_HAS_EXPLICIT_STATIC_TEMPLATE_MEMBER_INSTANTIATION)
 340 template char ACE_String_Base<char>::NULL_String_;
 341 template ACE_WSTRING_TYPE ACE_String_Base<ACE_WSTRING_TYPE>::NULL_String_;
 342 #endif /* ACE_HAS_EXPLICIT_STATIC_TEMPLATE_MEMBER_INSTANTIATION */
 343
 344 ACE_END_VERSIONED_NAMESPACE_DECL