00001 #ifndef _GAUTOPTR_H_
00002 #define _GAUTOPTR_H_
00003
00004 #include <string.h>
00005 #include "GMem.h"
00006 #include "GString.h"
00007 #include "GArray.h"
00008
00009 #ifdef __cplusplus
00010 template<class X>
00011 class GAutoPtrRef
00012 {
00013 typedef GAutoPtrRef<X> Self;
00014 Self& operator = (Self const&) {}
00015
00016 public:
00017 X *Ptr;
00018
00019 explicit
00020 GAutoPtrRef(X *p)
00021 {
00022 Ptr = p;
00023 }
00024 };
00025
00026 template<class X, bool Arr = false>
00027 class GAutoPtr
00028 {
00029 X *Ptr;
00030
00031 public:
00032 explicit GAutoPtr(X* p=0)
00033 {
00034 Ptr = p;
00035 }
00036
00037 GAutoPtr(GAutoPtr &ap)
00038 {
00039 Ptr = ap.Release();
00040 }
00041
00042 GAutoPtr(GAutoPtrRef<X> apr)
00043 {
00044 Ptr = apr.Ptr;
00045 }
00046
00047
00048
00049 GAutoPtr& operator=(GAutoPtr ap)
00050 {
00051 Reset(ap.Release());
00052 return *this;
00053 }
00054
00055 GAutoPtr& operator=(GAutoPtrRef<X> ap)
00056 {
00057 if (ap.Ptr != Ptr)
00058 {
00059 Reset(ap.Ptr);
00060 }
00061 return *this;
00062 }
00063
00064
00065
00066 ~GAutoPtr()
00067 {
00068 if (Arr)
00069 delete [] Ptr;
00070 else
00071 delete Ptr;
00072 }
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082 operator X*() const
00083 {
00084 return Ptr;
00085 }
00086
00087 X* operator->() const
00088 {
00089 LgiAssert(Ptr);
00090 return Ptr;
00091 }
00092
00093 X* Get() const
00094 {
00095 return Ptr;
00096 }
00097
00098 X* Release()
00099 {
00100 X *p = Ptr;
00101 Ptr = 0;
00102 return p;
00103 }
00104
00105 bool Reset(X* p=0)
00106 {
00107 if (Ptr == p)
00108 return Ptr != 0;
00109
00110 if (Arr)
00111 delete [] Ptr;
00112 else
00113 delete Ptr;
00114 Ptr = p;
00115 return Ptr != 0;
00116 }
00117
00118 template<class Y>
00119 operator GAutoPtrRef<Y>()
00120 {
00121 return GAutoPtrRef<Y>(Release());
00122 }
00123
00124 template<class Y>
00125 operator GAutoPtr<Y>()
00126 {
00127 return GAutoPtr<Y>(Release());
00128 }
00129 };
00130
00131 #if 1
00132
00133 typedef GAutoPtr<char, true> GAutoString;
00134 typedef GAutoPtr<char16, true> GAutoWString;
00135
00136 #else
00137
00138 template<class X>
00139 class GAutoStringRef
00140 {
00141 typedef GAutoStringRef<X> Self;
00142 Self& operator = (Self const&) {}
00143
00144 public:
00145 X *Ptr;
00146
00147 explicit
00148 GAutoStringRef(X *p)
00149 {
00150 Ptr = p;
00151 }
00152 };
00153
00154 class LgiClass GAutoString : public GAutoPtr<char, true>
00155 {
00156 public:
00157 typedef GArray<GAutoString> A;
00158
00159 GAutoString(char *str = 0) : GAutoPtr<char, true>(str) {}
00160 GAutoString(GAutoString &s) : GAutoPtr<char, true>(s) {}
00161 GAutoString(GAutoStringRef<char> r) : GAutoPtr<char, true>(r.Ptr) {}
00162 GAutoString& operator=(GAutoStringRef<char> ap)
00163 {
00164 if (ap.Ptr != Get())
00165 Reset(ap.Ptr);
00166 return *this;
00167 }
00168 template<class Y>
00169 operator GAutoStringRef<Y>()
00170 {
00171 return GAutoStringRef<Y>(Release());
00172 }
00173
00174 int length()
00175 {
00176 return Get() ? strlen(Get()) : 0;
00177 }
00178
00179 int find(char *sub, int start = 0, int end = -1)
00180 {
00181 if (!sub)
00182 return -1;
00183 char *s = Get(), *r;
00184 int i;
00185 for (i=0; i<start && s[i]; i++);
00186 s += i;
00187 if (end >= 0)
00188 r = strnstr(s, sub, end - start);
00189 else
00190 r = strstr(s, sub);
00191 return r ? r - Get() : -1;
00192 }
00193
00194 GAutoString strip(char *ch = 0)
00195 {
00196 if (!ch)
00197 ch = " \t\r\n";
00198 char *s = Get();
00199 while (*s && strchr(ch, *s))
00200 s++;
00201 char *e = s + strlen(s);
00202 while (e > s && strchr(ch, e[-1]))
00203 e--;
00204
00205 return GAutoString(NewStr(s, e-s));
00206 }
00207
00208 GAutoString lower()
00209 {
00210 GAutoString c(NewStr(Get()));
00211 strlwr(c);
00212 return c;
00213 }
00214
00215 GAutoString upper()
00216 {
00217 GAutoString c(NewStr(Get()));
00218 strupr(c);
00219 return c;
00220 }
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245 };
00246
00247 class LgiClass GAutoWString : public GAutoPtr<char16, true>
00248 {
00249 public:
00250 typedef GArray<GAutoWString> A;
00251
00252 GAutoWString(char16 *str = 0) : GAutoPtr<char16, true>(str) {}
00253 GAutoWString(GAutoWString &s) : GAutoPtr<char16, true>(s) {}
00254
00255 int length()
00256 {
00257 return Get() ? StrlenW(Get()) : 0;
00258 }
00259
00260 int find(char16 *sub, int start = 0, int end = -1)
00261 {
00262 if (!sub)
00263 return -1;
00264 char16 *s = Get(), *r;
00265 int i;
00266 for (i=0; i<start && s[i]; i++);
00267 s += i;
00268 if (end >= 0)
00269 r = StrnstrW(s, sub, end - start);
00270 else
00271 r = StrstrW(s, sub);
00272 return r ? r - Get() : -1;
00273 }
00274
00275 GAutoWString strip(char16 *ch = 0)
00276 {
00277 if (!ch)
00278 ch = L" \t\r\n";
00279 char16 *s = Get();
00280 while (*s && StrchrW(ch, *s))
00281 s++;
00282 char16 *e = s + StrlenW(s);
00283 while (e > s && StrchrW(ch, e[-1]))
00284 e--;
00285
00286 return GAutoWString(NewStrW(s, e-s));
00287 }
00288
00289 GAutoWString lower()
00290 {
00291 GAutoWString c(NewStrW(Get()));
00292 _wcslwr(c);
00293 return c;
00294 }
00295
00296 GAutoWString upper()
00297 {
00298 GAutoWString c(NewStrW(Get()));
00299 _wcsupr(c);
00300 return c;
00301 }
00302
00303
00304
00305
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323
00324
00325
00326 };
00327
00328 #endif
00329
00330 #endif // __cplusplus
00331
00332 #endif // _GAUTOPTR_H_