Main Page   Modules   Class Hierarchy   Data Structures   File List   Data Fields   Globals   Related Pages  

oscl_str_ptr_len.h

Go to the documentation of this file.
00001 // -*- c++ -*-
00002 // = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
00003 
00004 //               O S C L _ S T R _ P T R _ L E N
00005 
00006 //    This file contains C-based data structure definitions for string
00007 //    manipulations.
00008 
00009 // = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
00010 
00022 #ifndef OSCL_STR_PTR_LEN_H_INCLUDED
00023 #define OSCL_STR_PTR_LEN_H_INCLUDED
00024 
00025 // - - Inclusion - - - - - - - - - - - - - - - - - - - - - - - - - - - -
00026 #ifndef OSCL_BASE_H_INCLUDED
00027 #include "oscl_base.h"
00028 #endif
00029 
00030 #ifndef OSCL_STDSTRING_H_INCLUDED
00031 #include "oscl_stdstring.h"
00032 #endif
00033 
00034 //#ifndef OSCL_TYPES_H_INCLUDED
00035 //#include "oscl_types.h"
00036 //#endif
00037 
00038 // - - Definitions - - - - - - - - - - - - - - - - - - - - - - - - - - -
00039 
00040 // this is the XOR difference between any two ascii letters, 32
00041 const uint8 OSCL_ASCII_CASE_MAGIC_BIT = 0x20;
00042 
00044 
00047 typedef struct StrPtrLen
00048 {
00049 protected:
00050     const char* ptr;
00051     int32 len;
00052 
00053     bool isLetter(const char c) const
00054     {
00055         return ((c >= 65 && c <= 90) || (c >= 97 && c <= 122));
00056     }
00057 
00058 public:
00059 
00060     StrPtrLen(const char* newPtr)
00061             : ptr(newPtr)
00062     {
00063         len = oscl_strlen(newPtr);
00064     }
00065 
00066     StrPtrLen(const char* newPtr, uint32 newLen)
00067             : ptr(newPtr), len(newLen)
00068     {}
00069 
00070     StrPtrLen()
00071             : ptr(""), len(0)
00072     {}
00073 
00074     StrPtrLen(const StrPtrLen& rhs)
00075             : ptr(rhs.ptr), len(rhs.len)
00076     {}
00077 
00078     const char* c_str() const
00079     {
00080         return ptr;
00081     }
00082 
00083     int32 length() const
00084     {
00085         return len;
00086     }
00087 
00088     int32 size() const
00089     {
00090         return len;
00091     }
00092 
00093     void setPtrLen(const char* newPtr, uint32 newLen)
00094     {
00095         ptr = newPtr;
00096         len = newLen;
00097     }
00098 
00099     c_bool isCIEquivalentTo(const StrPtrLen& rhs) const
00100     {
00101         if (len != rhs.len)
00102         {
00103             return false;
00104         }
00105         // since they are the same length just check for the prefix condition
00106         return isCIPrefixOf(rhs);
00107     }
00108 
00109     c_bool isCIPrefixOf(const StrPtrLen& rhs) const
00110     {
00111         if (len > rhs.len)
00112         {
00113             return false;
00114         }
00115 
00116         for (int32 ii = 0; ii < len; ++ii)
00117         {
00118             if (ptr[ii] != rhs.ptr[ii])
00119             {
00120                 if (!isLetter(ptr[ii]) ||
00121                         (OSCL_ASCII_CASE_MAGIC_BIT != ((ptr[ii] ^ rhs.ptr[ii]) | OSCL_ASCII_CASE_MAGIC_BIT)))
00122                 {
00123                     return false;
00124                 }
00125             }
00126         }
00127         return true;
00128     }
00129 
00130     int32 operator==(const StrPtrLen& rhs) const
00131     {
00132         if (len != rhs.len)
00133         {
00134             //return (!(len-rhs.len));
00135             return false;
00136         }
00137 
00138         return(!oscl_strncmp(ptr, rhs.ptr, rhs.len));
00139     }
00140 
00141     int32 operator!=(const StrPtrLen& rhs) const
00142     {
00143         return !(*this == rhs);
00144     }
00145 
00146     StrPtrLen &operator=(const StrPtrLen& rhs)
00147     {
00148         this->ptr = rhs.ptr;
00149         this->len = rhs.len;
00150         return *this;
00151     }
00152 
00153     StrPtrLen &operator=(const char* rhs)
00154     {
00155         this->ptr = rhs;
00156         this->len = oscl_strlen(rhs);
00157         return *this;
00158     }
00159 
00160 } StrPtrLen;
00161 
00163 
00166 typedef struct WStrPtrLen
00167 {
00168 protected:
00169     const oscl_wchar* ptr;
00170     int32 len;
00171 
00172 public:
00173 
00174     WStrPtrLen(const oscl_wchar* newPtr)
00175             : ptr(newPtr)
00176     {
00177         len = oscl_strlen(newPtr);
00178     }
00179 
00180     WStrPtrLen(const oscl_wchar* newPtr, uint32 newLen)
00181             : ptr(newPtr), len(newLen)
00182     {}
00183 
00184     WStrPtrLen()
00185             : ptr(NULL), len(0)
00186     {}
00187 
00188     WStrPtrLen(const WStrPtrLen& rhs)
00189             : ptr(rhs.ptr), len(rhs.len)
00190     {}
00191 
00192     const oscl_wchar* c_str() const
00193     {
00194         return ptr;
00195     }
00196 
00197     int32 length() const
00198     {
00199         return len;
00200     }
00201 
00202     int32 size() const
00203     {
00204         return len;
00205     }
00206 
00207     void setPtrLen(const oscl_wchar* newPtr, uint32 newLen)
00208     {
00209         ptr = newPtr;
00210         len = newLen;
00211     }
00212 
00213     c_bool isCIEquivalentTo(const WStrPtrLen& rhs) const
00214     {
00215         if (len != rhs.len)
00216         {
00217             return false;
00218         }
00219 
00220         for (int32 ii = 0; ii < len; ++ii)
00221         {
00222             if (OSCL_ASCII_CASE_MAGIC_BIT != ((ptr[ii] ^ rhs.ptr[ii]) | OSCL_ASCII_CASE_MAGIC_BIT))
00223             {
00224                 return false;
00225             }
00226         }
00227 
00228         return true;
00229     }
00230 
00231     int32 operator==(const WStrPtrLen& rhs) const
00232     {
00233         if (len != rhs.len)
00234         {
00235             return (len - rhs.len);
00236         }
00237         return(!oscl_strncmp(ptr, rhs.ptr, rhs.len));
00238     }
00239 
00240     int32 operator!=(const WStrPtrLen& rhs) const
00241     {
00242         return !(*this == rhs);
00243     }
00244 
00245     WStrPtrLen& operator=(const WStrPtrLen& rhs)
00246     {
00247         this->ptr = rhs.ptr;
00248         this->len = rhs.len;
00249         return *this;
00250     }
00251 
00252     WStrPtrLen& operator=(const oscl_wchar* rhs)
00253     {
00254         this->ptr = rhs;
00255         this->len = oscl_strlen(rhs);
00256         return *this;
00257     }
00258 
00259 } WStrPtrLen;
00260 
00262 typedef struct StrCSumPtrLen : public StrPtrLen
00263 {
00264 public:
00265     typedef int16 CheckSumType;
00266 
00267 protected:
00268     CheckSumType checkSum;
00269 
00270 public:
00271 
00272     void setPtrLen(const char* newPtr, uint32 newLen)
00273     {
00274         StrPtrLen::setPtrLen(newPtr, newLen);
00275         setCheckSum();
00276     }
00277 
00278     CheckSumType getCheckSum() const
00279     {
00280         return checkSum;
00281     }
00282 
00283     OSCL_IMPORT_REF void setCheckSum();
00284 
00285     StrCSumPtrLen()
00286             : checkSum(0)
00287     {}
00288 
00289     StrCSumPtrLen(const char* newPtr)
00290             : StrPtrLen(newPtr)
00291     {
00292         setCheckSum();
00293     }
00294 
00295     StrCSumPtrLen(const char* newPtr, uint32 newLen)
00296             : StrPtrLen(newPtr, newLen)
00297     {
00298         setCheckSum();
00299     }
00300 
00301     StrCSumPtrLen(const StrCSumPtrLen& rhs)
00302             : StrPtrLen(rhs), checkSum(rhs.checkSum)
00303     {}
00304 
00305     StrCSumPtrLen(const StrPtrLen & rhs)
00306             : StrPtrLen(rhs)
00307     {
00308         setCheckSum();
00309     }
00310 
00311 
00312     c_bool isCIEquivalentTo(const StrCSumPtrLen& rhs) const
00313     {
00314         if (getCheckSum() != rhs.getCheckSum())
00315         {
00316             return false;
00317         }
00318 
00319         return static_cast<const StrPtrLen&>(*this).isCIEquivalentTo(
00320                    static_cast<const StrPtrLen&>(rhs));
00321     }
00322 
00323     c_bool operator==(const StrCSumPtrLen& rhs) const
00324     {
00325         if (getCheckSum() != rhs.getCheckSum())
00326         {
00327             return false;
00328         }
00329 
00330         return (static_cast<const StrPtrLen&>(*this)
00331                 ==  static_cast<const StrPtrLen&>(rhs));
00332     }
00333 
00334     c_bool operator!=(const StrCSumPtrLen& rhs) const
00335     {
00336         return !(*this == rhs);
00337     }
00338 
00339     StrCSumPtrLen& operator=(const StrCSumPtrLen& rhs)
00340     {
00341         StrPtrLen::operator=(rhs);
00342         this->checkSum = rhs.checkSum;
00343         return *this;
00344     }
00345 
00346     StrCSumPtrLen& operator=(const StrPtrLen& rhs)
00347     {
00348         StrPtrLen::operator=(rhs);
00349         setCheckSum();
00350         return *this;
00351     }
00352 
00353     StrCSumPtrLen& operator=(const char* rhs)
00354     {
00355         StrPtrLen::operator=(rhs);
00356         setCheckSum();
00357         return *this;
00358     }
00359 
00360 } StrCSumPtrLen;
00361 
00362 // Set character code to UNICODE
00363 typedef WStrPtrLen OSCL_TStrPtrLen;
00364 
00365 #endif // OSCL_STR_PTR_LEN_H_INCLUDED
00366 

OSCL API
Posting Version: CORE_8.000.1.1_RC4