00001
00002
00003
00004
00005
00006
00007
00018 #ifndef OSCL_ERROR_H_INCLUDED
00019 #define OSCL_ERROR_H_INCLUDED
00020
00021 #ifndef OSCL_HEAPBASE_H_INCLUDED
00022 #include "oscl_heapbase.h"
00023 #endif
00024
00025 #ifndef OSCL_DEFALLOC_H_INCLUDED
00026 #include "oscl_defalloc.h"
00027 #endif
00028
00029 #ifndef OSCL_ERROR_CODES_H_INCLUDED
00030 #include "oscl_error_codes.h"
00031 #endif
00032
00036 class OsclErrorTrapImp;
00037 class OsclErrorTrap
00038 {
00039 public:
00047 OSCL_IMPORT_REF static int32 Init(Oscl_DefAlloc *aAlloc = NULL);
00053 OSCL_IMPORT_REF static int32 Cleanup();
00058 OSCL_IMPORT_REF static OsclErrorTrapImp* GetErrorTrapImp();
00059 };
00060
00061
00065 class OsclError
00066 {
00067 public:
00074 OSCL_IMPORT_REF static void PushL(_OsclHeapBase * aPtr);
00075
00078 OSCL_IMPORT_REF static void PushL(OsclAny* aPtr);
00079
00082 OSCL_IMPORT_REF static void PushL(OsclTrapItem anItem);
00083
00086 OSCL_IMPORT_REF static void Pop();
00087
00090 OSCL_IMPORT_REF static void Pop(int32 aCount);
00091
00095 OSCL_IMPORT_REF static void PopDealloc();
00096
00099 OSCL_IMPORT_REF static void PopDealloc(int32 aCount);
00100
00106 OSCL_IMPORT_REF static void Leave(int32 aReason);
00107
00111 OSCL_IMPORT_REF static void LeaveIfNull(OsclAny *a);
00112
00117 OSCL_IMPORT_REF static void LeaveIfError(int32 aReason);
00118
00119 };
00120
00123 #define OSCL_TRAPSTACK_PUSH(a) OsclError::PushL(a)
00124 #define OSCL_TRAPSTACK_POP() OsclError::Pop()
00125 #define OSCL_TRAPSTACK_POPDEALLOC() OsclError::PopDealloc()
00126
00131
00132
00133
00134 static const int32 _OsclBaseToErrorMap[] =
00135 {
00136 OsclErrGeneral
00137 ,0
00138 ,OsclErrAlreadyInstalled
00139 ,OsclErrNoMemory
00140 ,OsclErrSystemCallFailed
00141 ,0
00142 ,OsclErrNotSupported
00143 ,OsclErrNotReady
00144 };
00145
00146 #include "oscl_singleton.h"
00147 #include "oscl_assert.h"
00148 #if(OSCL_HAS_SINGLETON_SUPPORT)
00149 class OsclSingletonRegistryEx
00150 {
00151 public:
00152
00153
00154
00155
00156
00157
00158 static OsclAny* getInstance(uint32 ID)
00159 {
00160 int32 error;
00161 OsclAny* val = OsclSingletonRegistry::getInstance(ID, error);
00162 if (error)
00163 {
00164 OSCL_ASSERT(_OsclBaseToErrorMap[error]);
00165 OsclError::Leave(_OsclBaseToErrorMap[error]);
00166 }
00167 return val;
00168 }
00169
00170
00171
00172
00173
00174
00175
00176 static void registerInstance(OsclAny* ptr, uint32 ID)
00177 {
00178 int32 error;
00179 OsclSingletonRegistry::registerInstance(ptr, ID, error);
00180 if (error)
00181 {
00182 OSCL_ASSERT(_OsclBaseToErrorMap[error]);
00183 OsclError::Leave(_OsclBaseToErrorMap[error]);
00184 }
00185 }
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199 static OsclAny* lockAndGetInstance(uint32 ID)
00200 {
00201 int32 error;
00202 OsclAny* val = OsclSingletonRegistry::lockAndGetInstance(ID, error);
00203 if (error)
00204 {
00205 OSCL_ASSERT(_OsclBaseToErrorMap[error]);
00206 OsclError::Leave(_OsclBaseToErrorMap[error]);
00207 }
00208 return val;
00209 }
00210
00211
00212
00213
00214
00215
00216
00217 static void registerInstanceAndUnlock(OsclAny* ptr, uint32 ID)
00218 {
00219 int32 error;
00220 OsclSingletonRegistry::registerInstanceAndUnlock(ptr, ID, error);
00221 if (error)
00222 {
00223 OSCL_ASSERT(_OsclBaseToErrorMap[error]);
00224 OsclError::Leave(_OsclBaseToErrorMap[error]);
00225 }
00226 }
00227 };
00228
00229 template < class T, uint32 ID, class Registry = OsclSingletonRegistryEx > class OsclSingletonEx
00230 {
00231 private:
00232
00233 OsclSingletonEx& operator=(OsclSingletonEx& _Y)
00234 {
00235 return(*this);
00236 }
00237
00238 protected:
00239 T* _Ptr;
00240
00241 public:
00242 OsclSingletonEx(): _Ptr(OSCL_STATIC_CAST(T*, Registry::getInstance(ID))) {};
00243
00244 ~OsclSingletonEx() {};
00245
00253 T& operator*() const
00254 {
00255 return(*_Ptr);
00256 }
00257
00265 T *operator->() const
00266 {
00267 return(_Ptr);
00268 }
00269
00270
00277 bool set()
00278 {
00279 _Ptr = OSCL_STATIC_CAST(T*, Registry::getInstance(ID));
00280 return (_Ptr ? true : false);
00281 }
00282
00283 };
00284 #endif //OSCL_HAS_SINGLETON_SUPPORT
00285
00286 #include "oscl_tls.h"
00287 #include "oscl_assert.h"
00288 class OsclTLSRegistryEx
00289 {
00290 public:
00291
00292
00293
00294
00295
00296
00297 static OsclAny* getInstance(uint32 ID)
00298 {
00299 int32 error;
00300 OsclAny* val = OsclTLSRegistry::getInstance(ID, error);
00301 if (error)
00302 {
00303 OSCL_ASSERT(_OsclBaseToErrorMap[error]);
00304 OsclError::Leave(_OsclBaseToErrorMap[error]);
00305 }
00306 return val;
00307 }
00308
00309
00310
00311
00312
00313
00314 static void registerInstance(OsclAny* ptr, uint32 ID)
00315 {
00316 int32 error;
00317 OsclTLSRegistry::registerInstance(ptr, ID, error);
00318 if (error)
00319 {
00320 OSCL_ASSERT(_OsclBaseToErrorMap[error]);
00321 OsclError::Leave(_OsclBaseToErrorMap[error]);
00322 }
00323 }
00324 };
00325
00326 template < class T, uint32 ID, class Registry = OsclTLSRegistryEx > class OsclTLSEx
00327 {
00328 private:
00329
00330 OsclTLSEx& operator=(OsclTLSEx& _Y)
00331 {
00332 return(*this);
00333 }
00334
00335 protected:
00336 T* _Ptr;
00337
00338 public:
00339 OsclTLSEx(): _Ptr(OSCL_STATIC_CAST(T*, Registry::getInstance(ID))) {};
00340
00341 ~OsclTLSEx() {};
00342
00350 T& operator*() const
00351 {
00352 return(*_Ptr);
00353 }
00354
00362 T *operator->() const
00363 {
00364 return(_Ptr);
00365 }
00366
00367
00374 bool set()
00375 {
00376 _Ptr = OSCL_STATIC_CAST(T*, Registry::getInstance(ID));
00377 return (_Ptr ? true : false);
00378 }
00379
00380 };
00381
00382 #endif
00383