00001
00002
00003
00004
00005
00006
00007
00008 #ifndef ACE_ACE_H
00009 # include "ace/ACE.h"
00010 #endif
00011
00012 #include "ace/OS_NS_stdlib.h"
00013
00014 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00015
00016 ACE_INLINE
00017 ACE_NS_WString::ACE_NS_WString (ACE_Allocator *alloc)
00018 : ACE_WString (alloc)
00019 {
00020 }
00021
00022 ACE_INLINE
00023 ACE_NS_WString::ACE_NS_WString (const ACE_WSTRING_TYPE *s,
00024 size_type len,
00025 ACE_Allocator *alloc)
00026 : ACE_WString (s, len, alloc)
00027 {
00028 }
00029
00030 ACE_INLINE
00031 ACE_NS_WString::ACE_NS_WString (const ACE_WSTRING_TYPE *s,
00032 ACE_Allocator *alloc)
00033 : ACE_WString (s, alloc)
00034 {
00035 }
00036
00037 ACE_INLINE
00038 ACE_NS_WString::ACE_NS_WString (size_type len, ACE_Allocator *alloc)
00039 : ACE_WString (len, 0, alloc)
00040 {
00041 }
00042
00043 ACE_INLINE
00044 ACE_NS_WString::ACE_NS_WString (const ACE_NS_WString &s)
00045 : ACE_WString (s)
00046 {
00047 }
00048
00049 ACE_INLINE
00050 ACE_NS_WString::ACE_NS_WString (ACE_WSTRING_TYPE c, ACE_Allocator *alloc)
00051 : ACE_WString (c, alloc)
00052 {
00053 }
00054
00055 ACE_INLINE ACE_NS_WString
00056 operator+ (const ACE_NS_WString &s, const ACE_NS_WString &t)
00057 {
00058 ACE_NS_WString temp (s);
00059 temp += t;
00060 return temp;
00061 }
00062
00063
00064
00065 ACE_INLINE
00066 ACE_SString::~ACE_SString (void)
00067 {
00068 }
00069
00070 ACE_INLINE ACE_SString
00071 ACE_SString::substr (size_type offset,
00072 size_type length) const
00073 {
00074 return this->substring (offset, length);
00075 }
00076
00077
00078
00079 ACE_INLINE char
00080 ACE_SString::operator[] (size_type slot) const
00081 {
00082 ACE_TRACE ("ACE_SString::operator[]");
00083 return this->rep_[slot];
00084 }
00085
00086
00087
00088 ACE_INLINE char &
00089 ACE_SString::operator[] (size_type slot)
00090 {
00091 ACE_TRACE ("ACE_SString::operator[]");
00092 return this->rep_[slot];
00093 }
00094
00095
00096
00097 ACE_INLINE const char *
00098 ACE_SString::rep (void) const
00099 {
00100 ACE_TRACE ("ACE_SString::rep");
00101 return this->rep_;
00102 }
00103
00104
00105
00106 ACE_INLINE const char *
00107 ACE_SString::fast_rep (void) const
00108 {
00109 ACE_TRACE ("ACE_SString::fast_rep");
00110 return this->rep_;
00111 }
00112
00113
00114
00115 ACE_INLINE const char *
00116 ACE_SString::c_str (void) const
00117 {
00118 ACE_TRACE ("ACE_SString::c_str");
00119 return this->rep_;
00120 }
00121
00122
00123
00124 ACE_INLINE bool
00125 ACE_SString::operator== (const ACE_SString &s) const
00126 {
00127 ACE_TRACE ("ACE_SString::operator==");
00128 return this->len_ == s.len_
00129 && ACE_OS::strcmp (this->rep_, s.rep_) == 0;
00130 }
00131
00132
00133
00134 ACE_INLINE bool
00135 ACE_SString::operator < (const ACE_SString &s) const
00136 {
00137 ACE_TRACE ("ACE_SString::operator <");
00138
00139 return (this->rep_ && s.rep_)
00140 ? ACE_OS::strcmp (this->rep_, s.rep_) < 0
00141 : ((s.rep_) ? true : false);
00142 }
00143
00144
00145
00146 ACE_INLINE bool
00147 ACE_SString::operator > (const ACE_SString &s) const
00148 {
00149 ACE_TRACE ("ACE_SString::operator >");
00150
00151 return (this->rep_ && s.rep_)
00152 ? ACE_OS::strcmp (this->rep_, s.rep_) > 0
00153 : ((this->rep_) ? true : false );
00154 }
00155
00156
00157
00158 ACE_INLINE bool
00159 ACE_SString::operator!= (const ACE_SString &s) const
00160 {
00161 ACE_TRACE ("ACE_SString::operator!=");
00162 return !(*this == s);
00163 }
00164
00165 ACE_INLINE int
00166 ACE_SString::compare (const ACE_SString &s) const
00167 {
00168 ACE_TRACE ("ACE_SString::compare");
00169 return ACE_OS::strcmp (this->rep_, s.rep_);
00170 }
00171
00172 ACE_INLINE ACE_SString::size_type
00173 ACE_SString::find (const char *s, size_type pos) const
00174 {
00175 char *substr = this->rep_ + pos;
00176 char *pointer = ACE_OS::strstr (substr, s);
00177 if (pointer == 0)
00178 return ACE_SString::npos;
00179 else
00180 return pointer - this->rep_;
00181 }
00182
00183 ACE_INLINE ACE_SString::size_type
00184 ACE_SString::find (char c, size_type pos) const
00185 {
00186 char *substr = this->rep_ + pos;
00187 char *pointer = ACE_OS::strchr (substr, c);
00188 if (pointer == 0)
00189 return ACE_SString::npos;
00190 else
00191 return pointer - this->rep_;
00192 }
00193
00194 ACE_INLINE ACE_SString::size_type
00195 ACE_SString::strstr (const ACE_SString &s) const
00196 {
00197 ACE_TRACE ("ACE_SString::strstr");
00198
00199 return this->find (s.rep_);
00200 }
00201
00202 ACE_INLINE ACE_SString::size_type
00203 ACE_SString::find (const ACE_SString &str, size_type pos) const
00204 {
00205 return this->find (str.rep_, pos);
00206 }
00207
00208 ACE_INLINE ACE_SString::size_type
00209 ACE_SString::rfind (char c, size_type pos) const
00210 {
00211 if (pos == ACE_SString::npos)
00212 pos = this->len_;
00213
00214
00215
00216 for (size_type i = pos; i-- != 0; )
00217 if (this->rep_[i] == c)
00218 return i;
00219
00220 return ACE_SString::npos;
00221 }
00222
00223 ACE_INLINE u_long
00224 ACE_SString::hash (void) const
00225 {
00226 return ACE::hash_pjw (this->rep_);
00227 }
00228
00229 ACE_INLINE ACE_SString::size_type
00230 ACE_SString::length (void) const
00231 {
00232 ACE_TRACE ("ACE_SString::length");
00233 return this->len_;
00234 }
00235
00236 ACE_INLINE
00237 ACE_Auto_String_Free::ACE_Auto_String_Free (char* p)
00238 : p_ (p)
00239 {
00240 }
00241
00242 ACE_INLINE
00243 ACE_Auto_String_Free::ACE_Auto_String_Free (ACE_Auto_String_Free& rhs)
00244 : p_ (rhs.p_)
00245 {
00246 rhs.p_ = 0;
00247 }
00248
00249 ACE_INLINE void
00250 ACE_Auto_String_Free::reset (char* p)
00251 {
00252 ACE_OS::free (this->p_);
00253 this->p_ = p;
00254 }
00255
00256 ACE_INLINE ACE_Auto_String_Free&
00257 ACE_Auto_String_Free::operator= (ACE_Auto_String_Free& rhs)
00258 {
00259 if (this != &rhs)
00260 {
00261 this->reset (rhs.p_);
00262 rhs.p_ = 0;
00263 }
00264 return *this;
00265 }
00266
00267 ACE_INLINE
00268 ACE_Auto_String_Free::~ACE_Auto_String_Free (void)
00269 {
00270 this->reset (0);
00271 }
00272
00273 ACE_INLINE char*
00274 ACE_Auto_String_Free::operator* (void) const
00275 {
00276 return this->p_;
00277 }
00278
00279 ACE_INLINE char
00280 ACE_Auto_String_Free::operator[] (size_t i) const
00281 {
00282 return this->p_[i];
00283 }
00284
00285 ACE_INLINE char*
00286 ACE_Auto_String_Free::get (void) const
00287 {
00288 return this->p_;
00289 }
00290
00291 ACE_INLINE char*
00292 ACE_Auto_String_Free::release (void)
00293 {
00294 char* p = this->p_;
00295 this->p_ = 0;
00296 return p;
00297 }
00298
00299 ACE_END_VERSIONED_NAMESPACE_DECL