WebCore/platform/win/COMPtr.h

   1 /*
   2  * Copyright (C) 2007 Apple Inc.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef COMPtr_h
  27 #define COMPtr_h
  28
  29 #include <WTF/Assertions.h>
  30
  31 typedef long HRESULT;
  32
  33 enum AdoptCOMTag { AdoptCOM };
  34
  35 template <typename T> class COMPtr {
  36 public:
  37     COMPtr() : m_ptr(0) { }
  38     COMPtr(T* ptr) : m_ptr(ptr) { if (m_ptr) m_ptr->AddRef(); }
  39     COMPtr(AdoptCOMTag, T* ptr) : m_ptr(ptr) { }
  40     COMPtr(const COMPtr& o) : m_ptr(o.m_ptr) { if (T* ptr = m_ptr) ptr->AddRef(); }
  41
  42     ~COMPtr() { if (m_ptr) m_ptr->Release(); }
  43
  44     T *get() const { return m_ptr; }
  45
  46     T& operator*() const { return *m_ptr; }
  47     T* operator->() const { return m_ptr; }
  48
  49     T** operator&() { ASSERT(!m_ptr); return &m_ptr; }
  50
  51     bool operator!() const { return !m_ptr; }
  52
  53     // This conversion operator allows implicit conversion to bool but not to other integer types.
  54     typedef T * (COMPtr::*UnspecifiedBoolType)() const;
  55     operator UnspecifiedBoolType() const { return m_ptr ? &COMPtr::get : 0; }
  56
  57     COMPtr& operator=(const COMPtr&);
  58     COMPtr& operator=(T*);
  59     template <typename U> COMPtr& operator=(const COMPtr<U>&);
  60
  61     HRESULT copyRefTo(T**);
  62     void adoptRef(T*);
  63
  64 private:
  65     T* m_ptr;
  66 };
  67
  68 template <typename T> inline HRESULT COMPtr<T>::copyRefTo(T** ptr)
  69 {
  70     if (!ptr)
  71         return E_POINTER;
  72
  73     *ptr = m_ptr;
  74     if (m_ptr)
  75         m_ptr->AddRef();
  76     return S_OK;
  77 }
  78
  79 template <typename T> inline void COMPtr<T>::adoptRef(T *ptr)
  80 {
  81     if (m_ptr)
  82         m_ptr->Release();
  83     m_ptr = ptr;
  84 }
  85
  86 template <typename T> inline COMPtr<T>& COMPtr<T>::operator=(const COMPtr<T>& o)
  87 {
  88     T* optr = o.get();
  89     if (optr)
  90         optr->AddRef();
  91     T* ptr = m_ptr;
  92     m_ptr = optr;
  93     if (ptr)
  94         ptr->Release();
  95     return *this;
  96 }
  97
  98 template <typename T> template <typename U> inline COMPtr<T>& COMPtr<T>::operator=(const COMPtr<U>& o)
  99 {
 100     T* optr = o.get();
 101     if (optr)
 102         optr->AddRef();
 103     T* ptr = m_ptr;
 104     m_ptr = optr;
 105     if (ptr)
 106         ptr->Release();
 107     return *this;
 108 }
 109
 110 template <typename T> inline COMPtr<T>& COMPtr<T>::operator=(T* optr)
 111 {
 112     if (optr)
 113         optr->AddRef();
 114     T* ptr = m_ptr;
 115     m_ptr = optr;
 116     if (ptr)
 117         ptr->Release();
 118     return *this;
 119 }
 120
 121 template <typename T, typename U> inline bool operator==(const COMPtr<T>& a, const COMPtr<U>& b)
 122 {
 123     return a.get() == b.get();
 124 }
 125
 126 template <typename T, typename U> inline bool operator==(const COMPtr<T>& a, U* b)
 127 {
 128     return a.get() == b;
 129 }
 130
 131 template <typename T, typename U> inline bool operator==(T* a, const COMPtr<U>& b)
 132 {
 133     return a == b.get();
 134 }
 135
 136 template <typename T, typename U> inline bool operator!=(const COMPtr<T>& a, const COMPtr<U>& b)
 137 {
 138     return a.get() != b.get();
 139 }
 140
 141 template <typename T, typename U> inline bool operator!=(const COMPtr<T>& a, U* b)
 142 {
 143     return a.get() != b;
 144 }
 145
 146 template <typename T, typename U> inline bool operator!=(T* a, const COMPtr<U>& b)
 147 {
 148     return a != b.get();
 149 }
 150
 151 #endif