Unreviewed, rolling out r234489.
[WebKit-https.git] / Source / WTF / wtf / MallocPtr.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 MallocPtr_h
27 #define MallocPtr_h
28
29 #include <wtf/FastMalloc.h>
30
31 // MallocPtr is a smart pointer class that calls fastFree in its destructor.
32 // It is intended to be used for pointers where the C++ lifetime semantics
33 // (calling constructors and destructors) is not desired. 
34
35 namespace WTF {
36
37 template<typename T, typename Malloc = FastMalloc> class MallocPtr {
38 public:
39     MallocPtr()
40         : m_ptr(nullptr)
41     {
42     }
43
44     MallocPtr(std::nullptr_t)
45         : m_ptr(nullptr)
46     {
47     }
48
49     MallocPtr(MallocPtr&& other)
50         : m_ptr(other.leakPtr())
51     {
52     }
53
54     ~MallocPtr()
55     {
56         Malloc::free(m_ptr);
57     }
58
59     T* get() const
60     {
61         return m_ptr;
62     }
63
64     T *leakPtr() WARN_UNUSED_RETURN
65     {
66         return std::exchange(m_ptr, nullptr);
67     }
68
69     explicit operator bool() const
70     {
71         return m_ptr;
72     }
73
74     bool operator!() const
75     {
76         return !m_ptr;
77     }
78
79     T& operator*() const
80     {
81         ASSERT(m_ptr);
82         return *m_ptr;
83     }
84
85     T* operator->() const
86     {
87         return m_ptr;
88     }
89
90     MallocPtr& operator=(MallocPtr&& other)
91     {
92         MallocPtr ptr = WTFMove(other);
93         swap(ptr);
94
95         return *this;
96     }
97
98     void swap(MallocPtr& other)
99     {
100         std::swap(m_ptr, other.m_ptr);
101     }
102
103     template<typename U> friend MallocPtr<U> adoptMallocPtr(U*);
104
105     static MallocPtr malloc(size_t size)
106     {
107         return MallocPtr { static_cast<T*>(Malloc::malloc(size)) };
108     }
109
110     static MallocPtr tryMalloc(size_t size)
111     {
112         return MallocPtr { static_cast<T*>(Malloc::tryMalloc(size)) };
113     }
114
115     void realloc(size_t newSize)
116     {
117         m_ptr = static_cast<T*>(Malloc::realloc(m_ptr, newSize));
118     }
119
120 private:
121     explicit MallocPtr(T* ptr)
122         : m_ptr(ptr)
123     {
124     }
125
126     T* m_ptr;
127 };
128
129 static_assert(sizeof(MallocPtr<int>) == sizeof(int*), "");
130
131 template<typename U> MallocPtr<U> adoptMallocPtr(U* ptr)
132 {
133     return MallocPtr<U>(ptr);
134 }
135
136 } // namespace WTF
137
138 using WTF::MallocPtr;
139 using WTF::adoptMallocPtr;
140
141 #endif // MallocPtr_h