00001
00002
00003
00004
00005
00006
00007
00008
00009
00011
00012
00013 #ifndef LTI_REFERENCE_COUNTED_OBJECT_H
00014 #define LTI_REFERENCE_COUNTED_OBJECT_H
00015
00016
00017 #include "lti_types.h"
00018
00019 LT_BEGIN_NAMESPACE(LizardTech)
00020
00021
00033 class LTIReferenceCountedObject
00034 {
00045 #define LTI_REFERENCE_COUNTED_BOILERPLATE_BASE(classname) \
00046 LT_DISALLOW_COPY_CONSTRUCTOR(classname); \
00047 protected: \
00048 classname(void); \
00049 virtual ~classname(void)
00050
00051 #define LTI_REFERENCE_COUNTED_BOILERPLATE(classname) \
00052 LTI_REFERENCE_COUNTED_BOILERPLATE_BASE(classname); \
00053 public: \
00054 static classname *create(void)
00055
00056 LTI_REFERENCE_COUNTED_BOILERPLATE_BASE(LTIReferenceCountedObject);
00057 public:
00058
00060 virtual void retain(void) const;
00061
00063 virtual void release(void) const;
00064
00065 private:
00066 mutable lt_int32 m_referenceCount;
00067 };
00068
00075 template<typename TYPE> inline TYPE *
00076 LTI_RETAIN(TYPE *object)
00077 {
00078 if(object != NULL)
00079 object->retain();
00080 return object;
00081 }
00082
00084 template<typename TYPE> inline void
00085 LTI_RELEASE(TYPE *&object)
00086 {
00087 if(object != NULL)
00088 object->release();
00089 object = NULL;
00090 }
00091
00092
00099 template<typename TYPE>
00100 class RC
00101 {
00102 public:
00104 ~RC(void) { LTI_RELEASE(m_object); }
00105
00111 RC(void) : m_object(TYPE::create()) {}
00112
00118 RC(TYPE *object) : m_object(LTI_RETAIN(object)) {}
00119 RC &operator=(TYPE *object)
00120 {
00121
00122 LTI_RETAIN(object);
00123 LTI_RELEASE(m_object);
00124 m_object = object;
00125 return *this;
00126 }
00127
00128 RC(const RC &object) : m_object(LTI_RETAIN(object.m_object)) {}
00129 RC &operator=(const RC &object)
00130 {
00131
00132 LTI_RETAIN(object.m_object);
00133 LTI_RELEASE(m_object);
00134 m_object = object.m_object;
00135 return *this;
00136 }
00137
00139 TYPE *operator->(void) { return m_object; }
00140 const TYPE *operator->(void) const { return m_object; }
00142 TYPE &operator*(void) { return *m_object; }
00143 const TYPE &operator*(void) const { return *m_object; }
00144 #ifndef SWIG
00145
00146 operator TYPE *&(void) { return m_object; }
00147 operator const TYPE *&(void) const { return m_object; }
00148 #endif
00149
00150 private:
00151 TYPE *m_object;
00152 };
00153
00155 template<typename TYPE> inline RC<TYPE> &
00156 LTI_RETAIN(RC<TYPE> &object)
00157 {
00158 if(object != NULL)
00159 object->retain();
00160 return object;
00161 }
00162
00163
00164
00165
00166 LT_END_NAMESPACE(LizardTech)
00167
00168 #endif // LTI_REFERENCE_COUNTED_OBJECT_H