/* * Copyright (c) 2018-2020, Andreas Kling * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #pragma once #include #include #include #include #include #include namespace AK { template class RefPtr; template class NonnullRefPtr; template class WeakPtr; template class NonnullOwnPtr { public: using ElementType = T; enum AdoptTag { Adopt }; NonnullOwnPtr(AdoptTag, T& ptr) : m_ptr(&ptr) { static_assert( requires { requires typename T::AllowOwnPtr()(); } || !requires(T obj) { requires !typename T::AllowOwnPtr()(); obj.ref(); obj.unref(); }, "Use NonnullRefPtr<> for RefCounted types"); } NonnullOwnPtr(NonnullOwnPtr&& other) : m_ptr(other.leak_ptr()) { ASSERT(m_ptr); } template NonnullOwnPtr(NonnullOwnPtr&& other) : m_ptr(other.leak_ptr()) { ASSERT(m_ptr); } ~NonnullOwnPtr() { clear(); #ifdef SANITIZE_PTRS if constexpr (sizeof(T*) == 8) m_ptr = (T*)(0xe3e3e3e3e3e3e3e3); else m_ptr = (T*)(0xe3e3e3e3); #endif } NonnullOwnPtr(const NonnullOwnPtr&) = delete; template NonnullOwnPtr(const NonnullOwnPtr&) = delete; NonnullOwnPtr& operator=(const NonnullOwnPtr&) = delete; template NonnullOwnPtr& operator=(const NonnullOwnPtr&) = delete; template> NonnullOwnPtr(const RefPtr&) = delete; template NonnullOwnPtr(const NonnullRefPtr&) = delete; template NonnullOwnPtr(const WeakPtr&) = delete; template> NonnullOwnPtr& operator=(const RefPtr&) = delete; template NonnullOwnPtr& operator=(const NonnullRefPtr&) = delete; template NonnullOwnPtr& operator=(const WeakPtr&) = delete; NonnullOwnPtr& operator=(NonnullOwnPtr&& other) { NonnullOwnPtr ptr(move(other)); swap(ptr); return *this; } template NonnullOwnPtr& operator=(NonnullOwnPtr&& other) { NonnullOwnPtr ptr(move(other)); swap(ptr); return *this; } [[nodiscard]] T* leak_ptr() { return exchange(m_ptr, nullptr); } T* ptr() { return m_ptr; } const T* ptr() const { return m_ptr; } T* operator->() { return m_ptr; } const T* operator->() const { return m_ptr; } T& operator*() { return *m_ptr; } const T& operator*() const { return *m_ptr; } operator const T*() const { return m_ptr; } operator T*() { return m_ptr; } operator bool() const = delete; bool operator!() const = delete; void swap(NonnullOwnPtr& other) { ::swap(m_ptr, other.m_ptr); } template void swap(NonnullOwnPtr& other) { ::swap(m_ptr, other.m_ptr); } template NonnullOwnPtr release_nonnull() { ASSERT(m_ptr); return NonnullOwnPtr(NonnullOwnPtr::Adopt, static_cast(*leak_ptr())); } private: void clear() { if (!m_ptr) return; delete m_ptr; m_ptr = nullptr; } T* m_ptr = nullptr; }; template inline NonnullOwnPtr adopt_own(T& object) { return NonnullOwnPtr(NonnullOwnPtr::Adopt, object); } template inline NonnullOwnPtr make(Args&&... args) { return NonnullOwnPtr(NonnullOwnPtr::Adopt, *new T(forward(args)...)); } template struct Traits> : public GenericTraits> { using PeekType = const T*; static unsigned hash(const NonnullOwnPtr& p) { return int_hash((u32)p.ptr()); } static bool equals(const NonnullOwnPtr& a, const NonnullOwnPtr& b) { return a.ptr() == b.ptr(); } }; template inline const LogStream& operator<<(const LogStream& stream, const NonnullOwnPtr& value) { return stream << value.ptr(); } template inline void swap(NonnullOwnPtr& a, NonnullOwnPtr& b) { a.swap(b); } template struct Formatter> : Formatter { void format(FormatBuilder& builder, const NonnullOwnPtr& value) { Formatter::format(builder, value.ptr()); } }; } using AK::adopt_own; using AK::make; using AK::NonnullOwnPtr;