Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00029 #ifndef _UCOMMON_OBJECT_H_
00030 #define _UCOMMON_OBJECT_H_
00031
00032 #ifndef _UCOMMON_CONFIG_H_
00033 #include <ucommon/platform.h>
00034 #endif
00035
00036 #include <stdlib.h>
00037
00038 NAMESPACE_UCOMMON
00039
00047 class __EXPORT Object
00048 {
00049 public:
00053 virtual void retain(void);
00054
00058 virtual void release(void);
00059
00063 virtual ~Object();
00064
00068 Object *copy(void);
00069
00073 inline void operator++(void)
00074 {retain();};
00075
00079 inline void operator--(void)
00080 {release();};
00081 };
00082
00090 class __EXPORT CountedObject : public Object
00091 {
00092 private:
00093 volatile unsigned count;
00094
00095 protected:
00099 CountedObject();
00100
00107 CountedObject(const Object &ref);
00108
00114 virtual void dealloc(void);
00115
00116 public:
00122 inline bool isCopied(void)
00123 {return count > 1;};
00124
00129 inline bool isRetained(void)
00130 {return count > 0;};
00131
00136 inline unsigned copied(void)
00137 {return count;};
00138
00142 void retain(void);
00143
00148 void release(void);
00149 };
00150
00159 class __EXPORT Temporary
00160 {
00161 protected:
00162 friend class auto_delete;
00163 virtual ~Temporary();
00164 };
00165
00174 class __EXPORT auto_delete
00175 {
00176 protected:
00177 Temporary *object;
00178
00179 public:
00180 ~auto_delete();
00181 };
00182
00193 class __EXPORT auto_pointer
00194 {
00195 protected:
00196 Object *object;
00197
00198 auto_pointer();
00199
00200 public:
00205 auto_pointer(Object *object);
00206
00212 auto_pointer(const auto_pointer &pointer);
00213
00219 ~auto_pointer();
00220
00225 void release(void);
00226
00231 bool operator!() const;
00232
00237 operator bool() const;
00238
00244 bool operator==(Object *object) const;
00245
00251 bool operator!=(Object *object) const;
00252
00259 void operator=(Object *object);
00260 };
00261
00273 class __EXPORT sparse_array
00274 {
00275 private:
00276 Object **vector;
00277 unsigned max;
00278
00279 protected:
00285 virtual Object *create(void) = 0;
00286
00290 void purge(void);
00291
00297 Object *get(unsigned offset);
00298
00304 sparse_array(unsigned size);
00305
00306 public:
00310 virtual ~sparse_array();
00311
00316 unsigned count(void);
00317 };
00318
00328 template <class T>
00329 class sarray : public sparse_array
00330 {
00331 public:
00336 inline sarray(unsigned size) : sparse_array(size) {};
00337
00344 inline T *get(unsigned offset)
00345 {static_cast<T*>(sparse_array::get(offset));};
00346
00353 inline T& operator[](unsigned offset)
00354 {return get(offset);};
00355
00356 private:
00357 __LOCAL Object *create(void)
00358 {return new T;};
00359 };
00360
00373 template <class T>
00374 class temporary : public auto_delete
00375 {
00376 public:
00380 inline temporary()
00381 {object = new T;};
00382
00387 inline T& operator*() const
00388 {return *(static_cast<T*>(object));};
00389
00394 inline T* operator->() const
00395 {return static_cast<T*>(object);};
00396 };
00397
00407 template <typename T, class O = CountedObject>
00408 class object_value : public O
00409 {
00410 protected:
00415 inline void set(const T& object)
00416 {value = object;};
00417
00418 public:
00419 T value;
00424 inline object_value() : O() {};
00425
00430 inline object_value(T& existing) : O()
00431 {value = existing;};
00432
00437 inline T& operator*()
00438 {return value;};
00439
00444 inline void operator=(const T& data)
00445 {value = data;};
00446
00451 inline operator T&()
00452 {return value;};
00453
00454 inline T& operator()()
00455 {return value;};
00456
00461 inline void operator()(T& data)
00462 {value = data;};
00463 };
00464
00477 template <class T, class P = auto_pointer>
00478 class pointer : public P
00479 {
00480 public:
00484 inline pointer() : P() {};
00485
00490 inline pointer(T* object) : P(object) {};
00491
00496 inline T* operator*() const
00497 {return static_cast<T*>(P::object);};
00498
00503 inline T& operator()() const
00504 {return *(static_cast<T*>(P::object));};
00505
00510 inline T* operator->() const
00511 {return static_cast<T*>(P::object);};
00512
00517 inline T* get(void) const
00518 {return static_cast<T*>(P::object);};
00519
00524 inline T* operator++()
00525 {P::operator++(); return get();};
00526
00531 inline void operator--()
00532 {P::operator--(); return get();};
00533
00538 inline void operator=(T *typed)
00539 {P::operator=((Object *)typed);};
00540 };
00541
00546 inline void retain(Object *object)
00547 {object->retain();}
00548
00553 inline void release(Object *object)
00554 {object->release();}
00555
00560 inline Object *copy(Object *object)
00561 {return object->copy();}
00562
00568 template<class T>
00569 inline bool is(T& object)
00570 {return object.operator bool();}
00571
00572
00579 template<class T>
00580 inline bool isnull(T& object)
00581 {return (bool)(object.operator*() == NULL);}
00582
00589 template<class T>
00590 inline bool isnullp(T *object)
00591 {return (bool)(object->operator*() == NULL);}
00592
00598 template<typename T>
00599 inline void swap(T& o1, T& o2)
00600 {cpr_memswap(&o1, &o2, sizeof(T));}
00601
00608 template<typename T>
00609 inline T& (max)(T& o1, T& o2)
00610 {
00611 return o1 > o2 ? o1 : o2;
00612 }
00613
00620 template<typename T>
00621 inline T& (min)(T& o1, T& o2)
00622 {
00623 return o1 < o2 ? o1 : o2;
00624 }
00625
00626 END_NAMESPACE
00627
00628 #endif