Unreviewed, rolling out r234489.
[WebKit-https.git] / Source / WTF / wtf / OSObjectPtr.h
1 /*
2  * Copyright (C) 2014-2018 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 #pragma once
27
28 #include <os/object.h>
29 #include <wtf/StdLibExtras.h>
30
31 namespace WTF {
32
33 template<typename> class OSObjectPtr;
34 template<typename T> OSObjectPtr<T> adoptOSObject(T);
35
36 template<typename T> static inline void retainOSObject(T ptr)
37 {
38 #if __has_feature(objc_arc)
39     UNUSED_PARAM(ptr);
40 #else
41     os_retain(ptr);
42 #endif
43 }
44
45 template<typename T> static inline void releaseOSObject(T ptr)
46 {
47 #if __has_feature(objc_arc)
48     UNUSED_PARAM(ptr);
49 #else
50     os_release(ptr);
51 #endif
52 }
53
54 template<typename T> class OSObjectPtr {
55 public:
56     OSObjectPtr()
57         : m_ptr(nullptr)
58     {
59     }
60
61     ~OSObjectPtr()
62     {
63         if (m_ptr)
64             releaseOSObject(m_ptr);
65     }
66
67     T get() const { return m_ptr; }
68
69     explicit operator bool() const { return m_ptr; }
70     bool operator!() const { return !m_ptr; }
71
72     OSObjectPtr(const OSObjectPtr& other)
73         : m_ptr(other.m_ptr)
74     {
75         if (m_ptr)
76             retainOSObject(m_ptr);
77     }
78
79     OSObjectPtr(OSObjectPtr&& other)
80         : m_ptr(WTFMove(other.m_ptr))
81     {
82         other.m_ptr = nullptr;
83     }
84
85     OSObjectPtr(T ptr)
86         : m_ptr(WTFMove(ptr))
87     {
88         if (m_ptr)
89             retainOSObject(m_ptr);
90     }
91
92     OSObjectPtr& operator=(const OSObjectPtr& other)
93     {
94         OSObjectPtr ptr = other;
95         swap(ptr);
96         return *this;
97     }
98
99     OSObjectPtr& operator=(OSObjectPtr&& other)
100     {
101         OSObjectPtr ptr = WTFMove(other);
102         swap(ptr);
103         return *this;
104     }
105
106     OSObjectPtr& operator=(std::nullptr_t)
107     {
108         if (m_ptr)
109             releaseOSObject(m_ptr);
110         m_ptr = nullptr;
111         return *this;
112     }
113
114     OSObjectPtr& operator=(T other)
115     {
116         OSObjectPtr ptr = WTFMove(other);
117         swap(ptr);
118         return *this;
119     }
120
121     void swap(OSObjectPtr& other)
122     {
123         std::swap(m_ptr, other.m_ptr);
124     }
125
126     T leakRef() WARN_UNUSED_RETURN
127     {
128         return std::exchange(m_ptr, nullptr);
129     }
130
131     friend OSObjectPtr adoptOSObject<T>(T);
132
133 private:
134     struct AdoptOSObject { };
135     OSObjectPtr(AdoptOSObject, T ptr)
136         : m_ptr(WTFMove(ptr))
137     {
138     }
139
140     T m_ptr;
141 };
142
143 template<typename T> inline OSObjectPtr<T> adoptOSObject(T ptr)
144 {
145     return OSObjectPtr<T> { typename OSObjectPtr<T>::AdoptOSObject { }, WTFMove(ptr) };
146 }
147
148 } // namespace WTF
149
150 using WTF::OSObjectPtr;
151 using WTF::adoptOSObject;