Home | History | Annotate | Download | only in API 
      1 /*
      2  * Copyright (C) 2005, 2006, 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  *
      8  * 1.  Redistributions of source code must retain the above copyright
      9  *     notice, this list of conditions and the following disclaimer.
     10  * 2.  Redistributions in binary form must reproduce the above copyright
     11  *     notice, this list of conditions and the following disclaimer in the
     12  *     documentation and/or other materials provided with the distribution.
     13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
     14  *     its contributors may be used to endorse or promote products derived
     15  *     from this software without specific prior written permission.
     16  *
     17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
     18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
     20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
     21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
     22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
     23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
     24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27  */
     28 
     29 #ifndef JSRetainPtr_h
     30 #define JSRetainPtr_h
     31 
     32 #include <JavaScriptCore/JSStringRef.h>
     33 #include <algorithm>
     34 
     35 inline void JSRetain(JSStringRef string) { JSStringRetain(string); }
     36 inline void JSRelease(JSStringRef string) { JSStringRelease(string); }
     37 
     38 enum AdoptTag { Adopt };
     39 
     40 template <typename T> class JSRetainPtr {
     41 public:
     42     JSRetainPtr() : m_ptr(0) {}
     43     JSRetainPtr(T ptr) : m_ptr(ptr) { if (ptr) JSRetain(ptr); }
     44 
     45     JSRetainPtr(AdoptTag, T ptr) : m_ptr(ptr) { }
     46 
     47     JSRetainPtr(const JSRetainPtr& o) : m_ptr(o.m_ptr) { if (T ptr = m_ptr) JSRetain(ptr); }
     48 
     49     ~JSRetainPtr() { if (T ptr = m_ptr) JSRelease(ptr); }
     50 
     51     template <typename U> JSRetainPtr(const JSRetainPtr<U>& o) : m_ptr(o.get()) { if (T ptr = m_ptr) JSRetain(ptr); }
     52 
     53     T get() const { return m_ptr; }
     54 
     55     T releaseRef() { T tmp = m_ptr; m_ptr = 0; return tmp; }
     56 
     57     T operator->() const { return m_ptr; }
     58 
     59     bool operator!() const { return !m_ptr; }
     60 
     61     // This conversion operator allows implicit conversion to bool but not to other integer types.
     62     typedef T JSRetainPtr::*UnspecifiedBoolType;
     63     operator UnspecifiedBoolType() const { return m_ptr ? &JSRetainPtr::m_ptr : 0; }
     64 
     65     JSRetainPtr& operator=(const JSRetainPtr&);
     66     template <typename U> JSRetainPtr& operator=(const JSRetainPtr<U>&);
     67     JSRetainPtr& operator=(T);
     68     template <typename U> JSRetainPtr& operator=(U*);
     69 
     70     void adopt(T);
     71 
     72     void swap(JSRetainPtr&);
     73 
     74 private:
     75     T m_ptr;
     76 };
     77 
     78 template <typename T> inline JSRetainPtr<T>& JSRetainPtr<T>::operator=(const JSRetainPtr<T>& o)
     79 {
     80     T optr = o.get();
     81     if (optr)
     82         JSRetain(optr);
     83     T ptr = m_ptr;
     84     m_ptr = optr;
     85     if (ptr)
     86         JSRelease(ptr);
     87     return *this;
     88 }
     89 
     90 template <typename T> template <typename U> inline JSRetainPtr<T>& JSRetainPtr<T>::operator=(const JSRetainPtr<U>& o)
     91 {
     92     T optr = o.get();
     93     if (optr)
     94         JSRetain(optr);
     95     T ptr = m_ptr;
     96     m_ptr = optr;
     97     if (ptr)
     98         JSRelease(ptr);
     99     return *this;
    100 }
    101 
    102 template <typename T> inline JSRetainPtr<T>& JSRetainPtr<T>::operator=(T optr)
    103 {
    104     if (optr)
    105         JSRetain(optr);
    106     T ptr = m_ptr;
    107     m_ptr = optr;
    108     if (ptr)
    109         JSRelease(ptr);
    110     return *this;
    111 }
    112 
    113 template <typename T> inline void JSRetainPtr<T>::adopt(T optr)
    114 {
    115     T ptr = m_ptr;
    116     m_ptr = optr;
    117     if (ptr)
    118         JSRelease(ptr);
    119 }
    120 
    121 template <typename T> template <typename U> inline JSRetainPtr<T>& JSRetainPtr<T>::operator=(U* optr)
    122 {
    123     if (optr)
    124         JSRetain(optr);
    125     T ptr = m_ptr;
    126     m_ptr = optr;
    127     if (ptr)
    128         JSRelease(ptr);
    129     return *this;
    130 }
    131 
    132 template <class T> inline void JSRetainPtr<T>::swap(JSRetainPtr<T>& o)
    133 {
    134     std::swap(m_ptr, o.m_ptr);
    135 }
    136 
    137 template <class T> inline void swap(JSRetainPtr<T>& a, JSRetainPtr<T>& b)
    138 {
    139     a.swap(b);
    140 }
    141 
    142 template <typename T, typename U> inline bool operator==(const JSRetainPtr<T>& a, const JSRetainPtr<U>& b)
    143 {
    144     return a.get() == b.get();
    145 }
    146 
    147 template <typename T, typename U> inline bool operator==(const JSRetainPtr<T>& a, U* b)
    148 {
    149     return a.get() == b;
    150 }
    151 
    152 template <typename T, typename U> inline bool operator==(T* a, const JSRetainPtr<U>& b)
    153 {
    154     return a == b.get();
    155 }
    156 
    157 template <typename T, typename U> inline bool operator!=(const JSRetainPtr<T>& a, const JSRetainPtr<U>& b)
    158 {
    159     return a.get() != b.get();
    160 }
    161 
    162 template <typename T, typename U> inline bool operator!=(const JSRetainPtr<T>& a, U* b)
    163 {
    164     return a.get() != b;
    165 }
    166 
    167 template <typename T, typename U> inline bool operator!=(T* a, const JSRetainPtr<U>& b)
    168 {
    169     return a != b.get();
    170 }
    171 
    172 
    173 #endif // JSRetainPtr_h
    174