sdk_ref_ptr.h

Go to the documentation of this file.

#ifndef SDK_SDK_REF_PTR_H_
#define SDK_SDK_REF_PTR_H_
 
#include <base/inc/base_types.h>
 
SDK_BEGIN_NAMESPACE
 
 
template<class T>
class SDKRefPtr {
 public:
  SDKRefPtr() throw() : m_instance(NULL) {}
 
  SDKRefPtr(const SDKRefPtr& lp) throw() : m_instance(NULL) {
    if (lp) {
      m_instance = lp.m_instance;
      if (m_instance)
        m_instance->AddRef();
    }
  }
  
  SDKRefPtr(T* lp) throw() {
    m_instance = lp;
    if (m_instance)
      m_instance->AddRef();
  }
 
  ~SDKRefPtr() throw() {
    if (m_instance)
      m_instance->Release();
  }
 
  operator T*() const throw() { return m_instance; }
  T& operator*() const throw() { return *m_instance; }
  T** operator&() throw() { return &m_instance; }
  T* operator->() const throw() { return m_instance; }
  bool operator!() const throw() { return (NULL == m_instance); }
  bool operator!=(T* p) const throw() { return !operator==(p); }
  bool operator==(T* p) const throw() { return m_instance == p; }
  
  SDKRefPtr& operator=(const SDKRefPtr& lp) throw() {
    AssignNewPtr(lp.m_instance);
    return *this;
  }
 
  SDKAtomicRefCount Release() throw()
  {
    T* tmp = m_instance;
    if (tmp)
    {
      m_instance = NULL;
      return tmp->Release();
    }
 
    return 0;
  }
 
  T* Get() const throw() { return m_instance; }
 
  void Attach(T* p) throw() {
    T* tmp = m_instance;
    m_instance = p;
    if (tmp)
      tmp->Release();
  }
 
  T* Detach() throw() {
    T* p = m_instance;
    m_instance = NULL;
    return p;
  }
  
  template< class I >
  SDKRefPtr<I> GetInterface() const throw() {
    SDKRefPtr<I> out;
    if (m_instance) {
      m_instance->GetInterface(I::IID(), reinterpret_cast<void**>(&out));
    }
    return out;
  }
 
 private:
 
  inline void AssignNewPtr(T* p) {
    if (p != m_instance) {
      if (p)
        p->AddRef();
      T* tmp = m_instance;
      m_instance = p;
      if (tmp)
        tmp->Release();
    }
  }
  
  T* m_instance;
};
 
template<class T> class RefPtr : public SDKRefPtr<T> { public: };
 
template <class T>
class STLAdapt {
public:
  STLAdapt() {
  }
 
  STLAdapt(const T& src) {
    m_T = src;
  }
 
  STLAdapt(const STLAdapt& src_a) {
    m_T = src_a.m_T;
  }
 
  STLAdapt& operator=(const T& src) {
    m_T = src;
    return *this;
  }
 
  bool operator<(const T& src) const {
    return m_T < src;
  }
 
  bool operator==(const T& src) const {
    return m_T == src;
  }
 
  operator T&() {
    return m_T;
  }
 
  operator const T&() const {
    return m_T;
  }
 
  T m_T;
};
 
SDK_END_NAMESPACE
 
#endif // SDK_SDK_REF_PTR_H_