35944450d3087836fe26dfff50025234fc964a39
[WebKit-https.git] / Source / WebCore / rendering / RenderPtr.h
1 /*
2  * Copyright (C) 2013 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 INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef RenderPtr_h
27 #define RenderPtr_h
28
29 #include <wtf/Assertions.h>
30 #include <algorithm>
31 #include <cstddef>
32 #include <memory>
33
34 namespace WebCore {
35
36 template<typename T> class RenderPtr {
37 public:
38     typedef T ValueType;
39     typedef ValueType* PtrType;
40
41     RenderPtr() : m_ptr(nullptr) { }
42     RenderPtr(std::nullptr_t) : m_ptr(nullptr) { }
43     explicit RenderPtr(T* ptr) : m_ptr(ptr) { }
44
45     ~RenderPtr()
46     {
47         if (m_ptr)
48             m_ptr->destroy();
49     }
50
51     PtrType get() const { return m_ptr; }
52
53     void clear();
54     PtrType leakPtr() WARN_UNUSED_RETURN;
55
56     ValueType& operator*() const { ASSERT(m_ptr); return *m_ptr; }
57     PtrType operator->() const { ASSERT(m_ptr); 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 PtrType RenderPtr::*UnspecifiedBoolType;
63     operator UnspecifiedBoolType() const { return m_ptr ? &RenderPtr::m_ptr : nullptr; }
64
65     RenderPtr& operator=(std::nullptr_t) { clear(); return *this; }
66
67     RenderPtr(RenderPtr&&);
68     template<typename U> RenderPtr(RenderPtr<U>&&);
69
70     RenderPtr& operator=(RenderPtr&&);
71     template<typename U> RenderPtr& operator=(RenderPtr<U>&&);
72
73     void swap(RenderPtr& o) { std::swap(m_ptr, o.m_ptr); }
74
75 private:
76     // We should never have two RenderPtrs for the same underlying object (otherwise we'll get
77     // double-destruction), so these equality operators should never be needed.
78     template<typename U> bool operator==(const RenderPtr<U>&) { COMPILE_ASSERT(!sizeof(U*), RenderPtrs_should_never_be_equal); return false; }
79     template<typename U> bool operator!=(const RenderPtr<U>&) { COMPILE_ASSERT(!sizeof(U*), RenderPtrs_should_never_be_equal); return false; }
80
81     PtrType m_ptr;
82 };
83
84 template<typename T> inline void RenderPtr<T>::clear()
85 {
86     if (m_ptr)
87         m_ptr->destroy();
88     m_ptr = nullptr;
89 }
90
91 template<typename T> inline typename RenderPtr<T>::PtrType RenderPtr<T>::leakPtr()
92 {
93     PtrType ptr = m_ptr;
94     m_ptr = nullptr;
95     return ptr;
96 }
97
98 template<typename T> inline RenderPtr<T>::RenderPtr(RenderPtr<T>&& o)
99     : m_ptr(o.leakPtr())
100 {
101 }
102
103 template<typename T> template<typename U> inline RenderPtr<T>::RenderPtr(RenderPtr<U>&& o)
104     : m_ptr(o.leakPtr())
105 {
106 }
107
108 template<typename T> inline auto RenderPtr<T>::operator=(RenderPtr&& o) -> RenderPtr&
109 {
110     ASSERT(!o || o != m_ptr);
111     RenderPtr ptr = std::move(o);
112     swap(ptr);
113     return *this;
114 }
115
116 template<typename T> template<typename U> inline auto RenderPtr<T>::operator=(RenderPtr<U>&& o) -> RenderPtr&
117 {
118     ASSERT(!o || o != m_ptr);
119     RenderPtr ptr = std::move(o);
120     swap(ptr);
121     return *this;
122 }
123
124 template<typename T> inline void swap(RenderPtr<T>& a, RenderPtr<T>& b)
125 {
126     a.swap(b);
127 }
128
129 template<typename T, typename U> inline bool operator==(const RenderPtr<T>& a, U* b)
130 {
131     return a.get() == b;
132 }
133
134 template<typename T, typename U> inline bool operator==(T* a, const RenderPtr<U>& b) 
135 {
136     return a == b.get();
137 }
138
139 template<typename T, typename U> inline bool operator!=(const RenderPtr<T>& a, U* b)
140 {
141     return a.get() != b;
142 }
143
144 template<typename T, typename U> inline bool operator!=(T* a, const RenderPtr<U>& b)
145 {
146     return a != b.get();
147 }
148
149 template<typename T> inline typename RenderPtr<T>::PtrType getPtr(const RenderPtr<T>& p)
150 {
151     return p.get();
152 }
153
154 template<class T, class... Args> inline RenderPtr<T>
155 createRenderer(Args&&... args)
156 {
157     return RenderPtr<T>(new T(std::forward<Args>(args)...));
158 }
159
160 } // namespace WebCore
161
162 #endif // RenderPtr_h