Local_Name_Space.cpp

Go to the documentation of this file.
00001 #include "ace/Local_Name_Space.h"
00002 #include "ace/ACE.h"
00003 #include "ace/RW_Process_Mutex.h"
00004 #include "ace/SString.h"
00005 #include "ace/OS_NS_string.h"
00006 
00007 ACE_RCSID (ace,
00008            Local_Name_Space,
00009            "Local_Name_Space.cpp,v 4.37 2006/04/19 19:13:09 jwillemsen Exp")
00010 
00011 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00012 
00013 ACE_NS_String::~ACE_NS_String (void)
00014 {
00015   if (this->delete_rep_)
00016     delete [] this->rep_;
00017 }
00018 
00019 ACE_WCHAR_T *
00020 ACE_NS_String::fast_rep (void) const
00021 {
00022   ACE_TRACE ("ACE_NS_String::fast_rep");
00023   return this->rep_;
00024 }
00025 
00026 ACE_NS_String::operator ACE_NS_WString () const
00027 {
00028   ACE_TRACE ("ACE_NS_String::operator ACE_NS_WString");
00029   return ACE_NS_WString (this->rep_,
00030                          (this->len_ / sizeof (ACE_WCHAR_T)) - 1);
00031 }
00032 
00033 size_t
00034 ACE_NS_String::len (void) const
00035 {
00036   ACE_TRACE ("ACE_NS_String::len");
00037   return this->len_;
00038 }
00039 
00040 char *
00041 ACE_NS_String::char_rep (void) const
00042 {
00043   ACE_TRACE ("ACE_NS_String::char_rep");
00044   ACE_NS_WString w_string (this->rep_,
00045                            (this->len_ / sizeof (ACE_WCHAR_T)) - 1);
00046   return w_string.char_rep ();
00047 }
00048 
00049 ACE_NS_String::ACE_NS_String (void)
00050   : len_ (0),
00051     rep_ (0),
00052     delete_rep_ (0)
00053 {
00054   ACE_TRACE ("ACE_NS_String::ACE_NS_String");
00055 }
00056 
00057 ACE_NS_String::ACE_NS_String (const ACE_NS_WString &s)
00058   : len_ ((s.length () + 1) * sizeof (ACE_WCHAR_T)),
00059     rep_ (s.rep ()),
00060     delete_rep_ (1)
00061 {
00062   ACE_TRACE ("ACE_NS_String::ACE_NS_String");
00063 }
00064 
00065 int
00066 ACE_NS_String::strstr (const ACE_NS_String &s) const
00067 {
00068   ACE_TRACE ("ACE_NS_String::strstr");
00069 
00070   if (this->len_ < s.len_)
00071     // If they're larger than we are they can't be a substring of us!
00072     return -1;
00073   else if (this->len_ == s.len_)
00074     // Check if we're equal.
00075     return *this == s ? 0 : -1;
00076   else
00077     {
00078       // They're smaller than we are...
00079       const size_t len = (this->len_ - s.len_) / sizeof (ACE_WCHAR_T);
00080       const size_t pat_len = s.len_ / sizeof (ACE_WCHAR_T) - 1;
00081 
00082       for (size_t i = 0; i <= len; ++i)
00083         {
00084           size_t j;
00085 
00086           for (j = 0; j < pat_len; ++j)
00087             if (this->rep_[i + j] != s.rep_[j])
00088               break;
00089 
00090           if (j == pat_len)
00091             // Found a match!  Return the index.
00092             return static_cast<int> (i);
00093         }
00094 
00095       return -1;
00096     }
00097 }
00098 
00099 bool
00100 ACE_NS_String::operator == (const ACE_NS_String &s) const
00101 {
00102   ACE_TRACE ("ACE_NS_String::operator ==");
00103   return this->len_ == s.len_
00104     && ACE_OS::memcmp ((void *) this->rep_,
00105                        (void *) s.rep_, this->len_) == 0;
00106 }
00107 
00108 bool
00109 ACE_NS_String::operator != (const ACE_NS_String &s) const
00110 {
00111   ACE_TRACE ("ACE_NS_String::operator !=");
00112   return !this->operator == (s);
00113 }
00114 
00115 ACE_NS_String::ACE_NS_String (ACE_WCHAR_T *dst,
00116                               const ACE_WCHAR_T *src,
00117                               size_t bytes)
00118   : len_ (bytes),
00119     rep_ (dst),
00120     delete_rep_ (0)
00121 {
00122   ACE_TRACE ("ACE_NS_String::ACE_NS_String");
00123   ACE_OS::memcpy (this->rep_, src, bytes);
00124 }
00125 
00126 u_long
00127 ACE_NS_String::hash (void) const
00128 {
00129   return ACE::hash_pjw
00130     (reinterpret_cast<char *> (const_cast<ACE_WCHAR_T *> (this->rep_)),
00131      this->len_);
00132 }
00133 
00134 ACE_NS_Internal::ACE_NS_Internal (void)
00135   : value_ (),
00136     type_ ()
00137 {
00138 }
00139 
00140 ACE_NS_Internal::ACE_NS_Internal (ACE_NS_String &value, const char *type)
00141   : value_ (value),
00142     type_ (type)
00143 {
00144   ACE_TRACE ("ACE_NS_Internal::ACE_NS_Internal");
00145 }
00146 
00147 bool
00148 ACE_NS_Internal::operator == (const ACE_NS_Internal &s) const
00149 {
00150   ACE_TRACE ("ACE_NS_Internal::operator ==");
00151   return this->value_ == s.value_;
00152 }
00153 
00154 ACE_NS_String
00155 ACE_NS_Internal::value (void)
00156 {
00157   ACE_TRACE ("ACE_NS_Internal::value");
00158   return this->value_;
00159 }
00160 
00161 const char *
00162 ACE_NS_Internal::type (void)
00163 {
00164   ACE_TRACE ("ACE_NS_Internal::type");
00165   return this->type_;
00166 }
00167 
00168 ACE_END_VERSIONED_NAMESPACE_DECL

Generated on Thu Nov 9 09:41:53 2006 for ACE by doxygen 1.3.6