beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-25 00:50:22 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7
ladybird/AK/RefPtr.h

500 lines
15 KiB
C
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 08:38:21 +00:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
* 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.
*/
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
#pragma once
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
#include <AK/Atomic.h>
AK: Move some of LogStream out of line & add overloads for smart pointers.
2019-07-04 05:05:58 +00:00
#include <AK/LogStream.h>
AK: Rename RetainPtr.h => RefPtr.h, Retained.h => NonnullRefPtr.h.
2019-06-21 16:45:35 +00:00
#include <AK/NonnullRefPtr.h>
AK: Fix ref leaks in RefPtr assignment operators. Many of the RefPtr assignment operators would cause ref leaks when we call them to assign a pointer that's already the one kept.
2019-08-02 09:56:55 +00:00
#include <AK/StdLibExtras.h>
AK: Add basic Traits for RefPtr This allows RefPtr to be stored in a HashTable<RefPtr<T>> :^) It's unfortunate about the const_casts. We'll need to fix HashMap::get to play nice with non-const Traits<T>::PeekType at some point.
2020-02-16 18:36:15 +00:00
#include <AK/Traits.h>
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 09:53:16 +00:00
#include <AK/Types.h>
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
#ifdef KERNEL
# include <Kernel/Arch/i386/CPU.h>
#endif
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
namespace AK {
AK: Delete bad pointer assignment operators and constructors. We shouldn't allow constructing e.g an OwnPtr from a RefPtr, and similar conversions. Instead just delete those functions so the compiler whines loudly if you try to use them. This patch also deletes constructing OwnPtr from a WeakPtr, even though that *may* be a valid thing to do, it's sufficiently weird that we can make the client jump through some hoops if he really wants it. :^)
2019-07-11 14:43:20 +00:00
template<typename T>
class OwnPtr;
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
template<typename T>
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
struct RefPtrTraits {
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
ALWAYS_INLINE static T* as_ptr(FlatPtr bits)
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
return (T*)(bits & ~(FlatPtr)1);
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
}
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
ALWAYS_INLINE static FlatPtr as_bits(T* ptr)
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
ASSERT(!((FlatPtr)ptr & 1));
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
return (FlatPtr)ptr;
}
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
template<typename U, typename PtrTraits>
ALWAYS_INLINE static FlatPtr convert_from(FlatPtr bits)
{
if (PtrTraits::is_null(bits))
return default_null_value;
return as_bits(PtrTraits::as_ptr(bits));
}
ALWAYS_INLINE static bool is_null(FlatPtr bits)
{
return !(bits & ~(FlatPtr)1);
}
ALWAYS_INLINE static FlatPtr exchange(Atomic<FlatPtr>& atomic_var, FlatPtr new_value)
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
// Only exchange when lock is not held
ASSERT(!(new_value & 1));
FlatPtr expected = atomic_var.load(AK::MemoryOrder::memory_order_relaxed);
for (;;) {
expected &= ~(FlatPtr)1; // only if lock bit is not set
if (atomic_var.compare_exchange_strong(expected, new_value, AK::MemoryOrder::memory_order_acq_rel))
break;
#ifdef KERNEL
Kernel::Processor::wait_check();
#endif
}
return expected;
}
ALWAYS_INLINE static bool exchange_if_null(Atomic<FlatPtr>& atomic_var, FlatPtr new_value)
{
// Only exchange when lock is not held
ASSERT(!(new_value & 1));
for (;;) {
FlatPtr expected = default_null_value; // only if lock bit is not set
if (atomic_var.compare_exchange_strong(expected, new_value, AK::MemoryOrder::memory_order_acq_rel))
break;
if (!is_null(expected))
return false;
#ifdef KERNEL
Kernel::Processor::wait_check();
#endif
}
return true;
}
ALWAYS_INLINE static FlatPtr lock(Atomic<FlatPtr>& atomic_var)
{
// This sets the lock bit atomically, preventing further modifications.
// This is important when e.g. copying a RefPtr where the source
// might be released and freed too quickly. This allows us
// to temporarily lock the pointer so we can add a reference, then
// unlock it
FlatPtr bits;
for (;;) {
bits = atomic_var.fetch_or(1, AK::MemoryOrder::memory_order_acq_rel);
if (!(bits & 1))
break;
#ifdef KERNEL
Kernel::Processor::wait_check();
#endif
}
ASSERT(!(bits & 1));
return bits;
}
ALWAYS_INLINE static void unlock(Atomic<FlatPtr>& atomic_var, FlatPtr new_value)
{
ASSERT(!(new_value & 1));
atomic_var.store(new_value, AK::MemoryOrder::memory_order_release);
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
}
static constexpr FlatPtr default_null_value = 0;
AK: Prefer using instead of typedef Problem: - `typedef` is a keyword which comes from C and carries with it old syntax that is hard to read. - Creating type aliases with the `using` keyword allows for easier future maintenance because it supports template syntax. - There is inconsistent use of `typedef` vs `using`. Solution: - Use `clang-tidy`'s checker called `modernize-use-using` to update the syntax to use the newer syntax. - Remove unused functions to make `clang-tidy` happy. - This results in consistency within the codebase.
2020-11-11 22:21:01 +00:00
using NullType = std::nullptr_t;
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
};
template<typename T, typename PtrTraits>
AK: Rename RetainPtr => RefPtr and Retained => NonnullRefPtr.
2019-06-21 16:37:47 +00:00
class RefPtr {
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
template<typename U, typename P>
friend class RefPtr;
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
template<typename U>
friend class WeakPtr;
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
public:
Meta: Tweak .clang-format to not wrap braces after enums.
2019-06-07 15:13:23 +00:00
enum AdoptTag {
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 09:53:16 +00:00
Adopt
};
Meta+AK: Make clang-format-10 clean
2020-09-18 07:49:51 +00:00
RefPtr() { }
AK: Rename RetainPtr => RefPtr and Retained => NonnullRefPtr.
2019-06-21 16:37:47 +00:00
RefPtr(const T* ptr)
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
: m_bits(PtrTraits::as_bits(const_cast<T*>(ptr)))
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 09:53:16 +00:00
{
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
ref_if_not_null(const_cast<T*>(ptr));
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 09:53:16 +00:00
}
AK: Rename RetainPtr => RefPtr and Retained => NonnullRefPtr.
2019-06-21 16:37:47 +00:00
RefPtr(const T& object)
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
: m_bits(PtrTraits::as_bits(const_cast<T*>(&object)))
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 09:53:16 +00:00
{
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
T* ptr = const_cast<T*>(&object);
ASSERT(ptr);
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
ASSERT(!is_null());
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
ptr->ref();
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 09:53:16 +00:00
}
AK: Rename RetainPtr => RefPtr and Retained => NonnullRefPtr.
2019-06-21 16:37:47 +00:00
RefPtr(AdoptTag, T& object)
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
: m_bits(PtrTraits::as_bits(&object))
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 09:53:16 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
ASSERT(!is_null());
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 09:53:16 +00:00
}
AK: Rename RetainPtr => RefPtr and Retained => NonnullRefPtr.
2019-06-21 16:37:47 +00:00
RefPtr(RefPtr&& other)
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
: m_bits(other.leak_ref_raw())
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 09:53:16 +00:00
{
}
AK+Kernel: Help the compiler inline a bunch of trivial methods If these methods get inlined, the compiler is able to statically eliminate most of the assertions. Alas, it doesn't realize this, and believes inlining them to be too expensive. So give it a strong hint that it's not the case. This *decreases* the kernel binary size.
2020-05-20 11:59:31 +00:00
ALWAYS_INLINE RefPtr(const NonnullRefPtr<T>& other)
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
: m_bits(PtrTraits::as_bits(const_cast<T*>(other.add_ref())))
AK: Make it more more pleasant to copy RefPtr's. I had a silly ambition that we would avoid unnecessary ref count churn by forcing explicit use of "copy_ref()" wherever a copy was actually needed. This was making RefPtr a bit clunky to work with, for no real benefit. This patch adds the missing copy construction/assignment stuff to RefPtr.
2019-07-11 13:36:01 +00:00
{
}
template<typename U>
AK+Kernel: Help the compiler inline a bunch of trivial methods If these methods get inlined, the compiler is able to statically eliminate most of the assertions. Alas, it doesn't realize this, and believes inlining them to be too expensive. So give it a strong hint that it's not the case. This *decreases* the kernel binary size.
2020-05-20 11:59:31 +00:00
ALWAYS_INLINE RefPtr(const NonnullRefPtr<U>& other)
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
: m_bits(PtrTraits::as_bits(const_cast<U*>(other.add_ref())))
AK: Make it more more pleasant to copy RefPtr's. I had a silly ambition that we would avoid unnecessary ref count churn by forcing explicit use of "copy_ref()" wherever a copy was actually needed. This was making RefPtr a bit clunky to work with, for no real benefit. This patch adds the missing copy construction/assignment stuff to RefPtr.
2019-07-11 13:36:01 +00:00
{
}
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 09:53:16 +00:00
template<typename U>
AK+Kernel: Help the compiler inline a bunch of trivial methods If these methods get inlined, the compiler is able to statically eliminate most of the assertions. Alas, it doesn't realize this, and believes inlining them to be too expensive. So give it a strong hint that it's not the case. This *decreases* the kernel binary size.
2020-05-20 11:59:31 +00:00
ALWAYS_INLINE RefPtr(NonnullRefPtr<U>&& other)
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
: m_bits(PtrTraits::as_bits(&other.leak_ref()))
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 09:53:16 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
ASSERT(!is_null());
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 09:53:16 +00:00
}
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
template<typename U, typename P = RefPtrTraits<U>>
RefPtr(RefPtr<U, P>&& other)
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
: m_bits(PtrTraits::template convert_from<U, P>(other.leak_ref_raw()))
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 09:53:16 +00:00
{
}
AK: Rename RetainPtr => RefPtr and Retained => NonnullRefPtr.
2019-06-21 16:37:47 +00:00
RefPtr(const RefPtr& other)
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
: m_bits(other.add_ref_raw())
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 09:53:16 +00:00
{
}
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
template<typename U, typename P = RefPtrTraits<U>>
RefPtr(const RefPtr<U, P>& other)
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
: m_bits(other.add_ref_raw())
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 09:53:16 +00:00
{
}
AK+Kernel: Help the compiler inline a bunch of trivial methods If these methods get inlined, the compiler is able to statically eliminate most of the assertions. Alas, it doesn't realize this, and believes inlining them to be too expensive. So give it a strong hint that it's not the case. This *decreases* the kernel binary size.
2020-05-20 11:59:31 +00:00
ALWAYS_INLINE ~RefPtr()
Merge some features from gerbert into OwnPtr and RetainPtr.
2018-10-16 10:20:51 +00:00
{
clear();
#ifdef SANITIZE_PTRS
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 09:53:16 +00:00
if constexpr (sizeof(T*) == 8)
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
m_bits.store(0xe0e0e0e0e0e0e0e0, AK::MemoryOrder::memory_order_relaxed);
Merge some features from gerbert into OwnPtr and RetainPtr.
2018-10-16 10:20:51 +00:00
else
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
m_bits.store(0xe0e0e0e0, AK::MemoryOrder::memory_order_relaxed);
Merge some features from gerbert into OwnPtr and RetainPtr.
2018-10-16 10:20:51 +00:00
#endif
}
Meta+AK: Make clang-format-10 clean
2020-09-18 07:49:51 +00:00
RefPtr(std::nullptr_t) { }
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
AK: Delete bad pointer assignment operators and constructors. We shouldn't allow constructing e.g an OwnPtr from a RefPtr, and similar conversions. Instead just delete those functions so the compiler whines loudly if you try to use them. This patch also deletes constructing OwnPtr from a WeakPtr, even though that *may* be a valid thing to do, it's sufficiently weird that we can make the client jump through some hoops if he really wants it. :^)
2019-07-11 14:43:20 +00:00
template<typename U>
RefPtr(const OwnPtr<U>&) = delete;
template<typename U>
RefPtr& operator=(const OwnPtr<U>&) = delete;
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
void swap(RefPtr& other)
{
if (this == &other)
return;
// NOTE: swap is not atomic!
FlatPtr other_bits = PtrTraits::exchange(other.m_bits, PtrTraits::default_null_value);
FlatPtr bits = PtrTraits::exchange(m_bits, other_bits);
PtrTraits::exchange(other.m_bits, bits);
}
template<typename U, typename P = RefPtrTraits<U>>
void swap(RefPtr<U, P>& other)
AK: Fix ref leaks in RefPtr assignment operators. Many of the RefPtr assignment operators would cause ref leaks when we call them to assign a pointer that's already the one kept.
2019-08-02 09:56:55 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
// NOTE: swap is not atomic!
FlatPtr other_bits = P::exchange(other.m_bits, P::default_null_value);
FlatPtr bits = PtrTraits::exchange(m_bits, PtrTraits::template convert_from<U, P>(other_bits));
P::exchange(other.m_bits, P::template convert_from<U, P>(bits));
AK: Fix ref leaks in RefPtr assignment operators. Many of the RefPtr assignment operators would cause ref leaks when we call them to assign a pointer that's already the one kept.
2019-08-02 09:56:55 +00:00
}
AK+Kernel: Help the compiler inline a bunch of trivial methods If these methods get inlined, the compiler is able to statically eliminate most of the assertions. Alas, it doesn't realize this, and believes inlining them to be too expensive. So give it a strong hint that it's not the case. This *decreases* the kernel binary size.
2020-05-20 11:59:31 +00:00
ALWAYS_INLINE RefPtr& operator=(RefPtr&& other)
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
if (this != &other)
assign_raw(other.leak_ref_raw());
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
return *this;
}
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
template<typename U, typename P = RefPtrTraits<U>>
ALWAYS_INLINE RefPtr& operator=(RefPtr<U, P>&& other)
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
assign_raw(PtrTraits::template convert_from<U, P>(other.leak_ref_raw()));
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
return *this;
}
AK: Improve smart pointer ergonomics a bit.
2019-04-14 00:36:06 +00:00
template<typename U>
AK+Kernel: Help the compiler inline a bunch of trivial methods If these methods get inlined, the compiler is able to statically eliminate most of the assertions. Alas, it doesn't realize this, and believes inlining them to be too expensive. So give it a strong hint that it's not the case. This *decreases* the kernel binary size.
2020-05-20 11:59:31 +00:00
ALWAYS_INLINE RefPtr& operator=(NonnullRefPtr<U>&& other)
AK: Improve smart pointer ergonomics a bit.
2019-04-14 00:36:06 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
assign_raw(PtrTraits::as_bits(&other.leak_ref()));
AK: Improve smart pointer ergonomics a bit.
2019-04-14 00:36:06 +00:00
return *this;
}
AK+Kernel: Help the compiler inline a bunch of trivial methods If these methods get inlined, the compiler is able to statically eliminate most of the assertions. Alas, it doesn't realize this, and believes inlining them to be too expensive. So give it a strong hint that it's not the case. This *decreases* the kernel binary size.
2020-05-20 11:59:31 +00:00
ALWAYS_INLINE RefPtr& operator=(const NonnullRefPtr<T>& other)
AK: Make it more more pleasant to copy RefPtr's. I had a silly ambition that we would avoid unnecessary ref count churn by forcing explicit use of "copy_ref()" wherever a copy was actually needed. This was making RefPtr a bit clunky to work with, for no real benefit. This patch adds the missing copy construction/assignment stuff to RefPtr.
2019-07-11 13:36:01 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
assign_raw(PtrTraits::as_bits(other.add_ref()));
AK: Make it more more pleasant to copy RefPtr's. I had a silly ambition that we would avoid unnecessary ref count churn by forcing explicit use of "copy_ref()" wherever a copy was actually needed. This was making RefPtr a bit clunky to work with, for no real benefit. This patch adds the missing copy construction/assignment stuff to RefPtr.
2019-07-11 13:36:01 +00:00
return *this;
}
AK: Make RetainPtr and Retained more friendly towards const pointers. Also add operator T&'s to Retained since it's nice to be able to pass them to a function that takes a T&.
2019-06-15 16:45:44 +00:00
template<typename U>
AK+Kernel: Help the compiler inline a bunch of trivial methods If these methods get inlined, the compiler is able to statically eliminate most of the assertions. Alas, it doesn't realize this, and believes inlining them to be too expensive. So give it a strong hint that it's not the case. This *decreases* the kernel binary size.
2020-05-20 11:59:31 +00:00
ALWAYS_INLINE RefPtr& operator=(const NonnullRefPtr<U>& other)
AK: Make RetainPtr and Retained more friendly towards const pointers. Also add operator T&'s to Retained since it's nice to be able to pass them to a function that takes a T&.
2019-06-15 16:45:44 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
assign_raw(PtrTraits::as_bits(other.add_ref()));
AK: Make RetainPtr and Retained more friendly towards const pointers. Also add operator T&'s to Retained since it's nice to be able to pass them to a function that takes a T&.
2019-06-15 16:45:44 +00:00
return *this;
}
AK+Kernel: Help the compiler inline a bunch of trivial methods If these methods get inlined, the compiler is able to statically eliminate most of the assertions. Alas, it doesn't realize this, and believes inlining them to be too expensive. So give it a strong hint that it's not the case. This *decreases* the kernel binary size.
2020-05-20 11:59:31 +00:00
ALWAYS_INLINE RefPtr& operator=(const RefPtr& other)
AK: Make it more more pleasant to copy RefPtr's. I had a silly ambition that we would avoid unnecessary ref count churn by forcing explicit use of "copy_ref()" wherever a copy was actually needed. This was making RefPtr a bit clunky to work with, for no real benefit. This patch adds the missing copy construction/assignment stuff to RefPtr.
2019-07-11 13:36:01 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
if (this != &other)
assign_raw(other.add_ref_raw());
AK: Make it more more pleasant to copy RefPtr's. I had a silly ambition that we would avoid unnecessary ref count churn by forcing explicit use of "copy_ref()" wherever a copy was actually needed. This was making RefPtr a bit clunky to work with, for no real benefit. This patch adds the missing copy construction/assignment stuff to RefPtr.
2019-07-11 13:36:01 +00:00
return *this;
}
AK: Make RetainPtr and Retained more friendly towards const pointers. Also add operator T&'s to Retained since it's nice to be able to pass them to a function that takes a T&.
2019-06-15 16:45:44 +00:00
template<typename U>
AK+Kernel: Help the compiler inline a bunch of trivial methods If these methods get inlined, the compiler is able to statically eliminate most of the assertions. Alas, it doesn't realize this, and believes inlining them to be too expensive. So give it a strong hint that it's not the case. This *decreases* the kernel binary size.
2020-05-20 11:59:31 +00:00
ALWAYS_INLINE RefPtr& operator=(const RefPtr<U>& other)
AK: Make RetainPtr and Retained more friendly towards const pointers. Also add operator T&'s to Retained since it's nice to be able to pass them to a function that takes a T&.
2019-06-15 16:45:44 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
assign_raw(other.add_ref_raw());
AK: Make RetainPtr and Retained more friendly towards const pointers. Also add operator T&'s to Retained since it's nice to be able to pass them to a function that takes a T&.
2019-06-15 16:45:44 +00:00
return *this;
}
AK+Kernel: Help the compiler inline a bunch of trivial methods If these methods get inlined, the compiler is able to statically eliminate most of the assertions. Alas, it doesn't realize this, and believes inlining them to be too expensive. So give it a strong hint that it's not the case. This *decreases* the kernel binary size.
2020-05-20 11:59:31 +00:00
ALWAYS_INLINE RefPtr& operator=(const T* ptr)
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
ref_if_not_null(const_cast<T*>(ptr));
assign_raw(PtrTraits::as_bits(const_cast<T*>(ptr)));
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
return *this;
}
AK+Kernel: Help the compiler inline a bunch of trivial methods If these methods get inlined, the compiler is able to statically eliminate most of the assertions. Alas, it doesn't realize this, and believes inlining them to be too expensive. So give it a strong hint that it's not the case. This *decreases* the kernel binary size.
2020-05-20 11:59:31 +00:00
ALWAYS_INLINE RefPtr& operator=(const T& object)
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
const_cast<T&>(object).ref();
assign_raw(PtrTraits::as_bits(const_cast<T*>(&object)));
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
return *this;
}
AK: Rename RetainPtr => RefPtr and Retained => NonnullRefPtr.
2019-06-21 16:37:47 +00:00
RefPtr& operator=(std::nullptr_t)
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
{
clear();
return *this;
}
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
ALWAYS_INLINE bool assign_if_null(RefPtr&& other)
{
if (this == &other)
return is_null();
return PtrTraits::exchange_if_null(m_bits, other.leak_ref_raw());
}
template<typename U, typename P = RefPtrTraits<U>>
ALWAYS_INLINE bool assign_if_null(RefPtr<U, P>&& other)
{
if (this == &other)
return is_null();
return PtrTraits::exchange_if_null(m_bits, PtrTraits::template convert_from<U, P>(other.leak_ref_raw()));
}
AK+Kernel: Help the compiler inline a bunch of trivial methods If these methods get inlined, the compiler is able to statically eliminate most of the assertions. Alas, it doesn't realize this, and believes inlining them to be too expensive. So give it a strong hint that it's not the case. This *decreases* the kernel binary size.
2020-05-20 11:59:31 +00:00
ALWAYS_INLINE void clear()
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
assign_raw(PtrTraits::default_null_value);
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
}
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
bool operator!() const { return PtrTraits::is_null(m_bits.load(AK::MemoryOrder::memory_order_relaxed)); }
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
AK: Simplify RefPtr and NonnullRefPtr's leak_ref() functions Use AK::exchange() to switch out the internal storage. Also mark these functions with [[nodiscard]] to provoke an compile-time error if they are called without using the return value.
2019-08-02 10:05:09 +00:00
[[nodiscard]] T* leak_ref()
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
FlatPtr bits = PtrTraits::exchange(m_bits, PtrTraits::default_null_value);
return PtrTraits::as_ptr(bits);
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
}
AK: Make it possible to use HashMap<K, NonnullOwnPtr>::get() Add the concept of a PeekType to Traits<T>. This is the type we'll return (wrapped in an Optional) from HashMap::get(). The PeekType for OwnPtr<T> and NonnullOwnPtr<T> is const T*, which means that HashMap::get() will return an Optional<const T*> for maps-of-those.
2019-08-14 09:47:38 +00:00
NonnullRefPtr<T> release_nonnull()
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
FlatPtr bits = PtrTraits::exchange(m_bits, PtrTraits::default_null_value);
ASSERT(!PtrTraits::is_null(bits));
return NonnullRefPtr<T>(NonnullRefPtr<T>::Adopt, *PtrTraits::as_ptr(bits));
AK: Make it possible to use HashMap<K, NonnullOwnPtr>::get() Add the concept of a PeekType to Traits<T>. This is the type we'll return (wrapped in an Optional) from HashMap::get(). The PeekType for OwnPtr<T> and NonnullOwnPtr<T> is const T*, which means that HashMap::get() will return an Optional<const T*> for maps-of-those.
2019-08-14 09:47:38 +00:00
}
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
ALWAYS_INLINE T* ptr() { return as_ptr(); }
ALWAYS_INLINE const T* ptr() const { return as_ptr(); }
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
AK+Kernel: Help the compiler inline a bunch of trivial methods If these methods get inlined, the compiler is able to statically eliminate most of the assertions. Alas, it doesn't realize this, and believes inlining them to be too expensive. So give it a strong hint that it's not the case. This *decreases* the kernel binary size.
2020-05-20 11:59:31 +00:00
ALWAYS_INLINE T* operator->()
AK: Add anti-null assertions in RefPtr. This gives us better error messages when dereferencing null RefPtrs.
2019-08-02 10:00:43 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
return as_nonnull_ptr();
AK: Add anti-null assertions in RefPtr. This gives us better error messages when dereferencing null RefPtrs.
2019-08-02 10:00:43 +00:00
}
AK+Kernel: Help the compiler inline a bunch of trivial methods If these methods get inlined, the compiler is able to statically eliminate most of the assertions. Alas, it doesn't realize this, and believes inlining them to be too expensive. So give it a strong hint that it's not the case. This *decreases* the kernel binary size.
2020-05-20 11:59:31 +00:00
ALWAYS_INLINE const T* operator->() const
AK: Add anti-null assertions in RefPtr. This gives us better error messages when dereferencing null RefPtrs.
2019-08-02 10:00:43 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
return as_nonnull_ptr();
AK: Add anti-null assertions in RefPtr. This gives us better error messages when dereferencing null RefPtrs.
2019-08-02 10:00:43 +00:00
}
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
AK+Kernel: Help the compiler inline a bunch of trivial methods If these methods get inlined, the compiler is able to statically eliminate most of the assertions. Alas, it doesn't realize this, and believes inlining them to be too expensive. So give it a strong hint that it's not the case. This *decreases* the kernel binary size.
2020-05-20 11:59:31 +00:00
ALWAYS_INLINE T& operator*()
AK: Add anti-null assertions in RefPtr. This gives us better error messages when dereferencing null RefPtrs.
2019-08-02 10:00:43 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
return *as_nonnull_ptr();
AK: Add anti-null assertions in RefPtr. This gives us better error messages when dereferencing null RefPtrs.
2019-08-02 10:00:43 +00:00
}
AK+Kernel: Help the compiler inline a bunch of trivial methods If these methods get inlined, the compiler is able to statically eliminate most of the assertions. Alas, it doesn't realize this, and believes inlining them to be too expensive. So give it a strong hint that it's not the case. This *decreases* the kernel binary size.
2020-05-20 11:59:31 +00:00
ALWAYS_INLINE const T& operator*() const
AK: Add anti-null assertions in RefPtr. This gives us better error messages when dereferencing null RefPtrs.
2019-08-02 10:00:43 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
return *as_nonnull_ptr();
AK: Add anti-null assertions in RefPtr. This gives us better error messages when dereferencing null RefPtrs.
2019-08-02 10:00:43 +00:00
}
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
ALWAYS_INLINE operator const T*() const { return as_ptr(); }
ALWAYS_INLINE operator T*() { return as_ptr(); }
AK: Improve smart pointer ergonomics a bit.
2019-04-14 00:36:06 +00:00
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
operator bool() { return !is_null(); }
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
bool operator==(std::nullptr_t) const { return is_null(); }
bool operator!=(std::nullptr_t) const { return !is_null(); }
AK: Improve smart pointer ergonomics a bit.
2019-04-14 00:36:06 +00:00
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
bool operator==(const RefPtr& other) const { return as_ptr() == other.as_ptr(); }
bool operator!=(const RefPtr& other) const { return as_ptr() != other.as_ptr(); }
AK: Improve smart pointer ergonomics a bit.
2019-04-14 00:36:06 +00:00
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
bool operator==(RefPtr& other) { return as_ptr() == other.as_ptr(); }
bool operator!=(RefPtr& other) { return as_ptr() != other.as_ptr(); }
AK: And one more RetainPtr::operator==() G++ complains about in LibGUI.
2019-04-19 19:36:11 +00:00
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
bool operator==(const T* other) const { return as_ptr() == other; }
bool operator!=(const T* other) const { return as_ptr() != other; }
AK: Improve smart pointer ergonomics a bit.
2019-04-14 00:36:06 +00:00
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
bool operator==(T* other) { return as_ptr() == other; }
bool operator!=(T* other) { return as_ptr() != other; }
bool is_null() const { return PtrTraits::is_null(m_bits.load(AK::MemoryOrder::memory_order_relaxed)); }
AK: Add RetainPtr::operator==() overload G++ is whining about.
2019-04-19 19:34:47 +00:00
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
template<typename U = T, typename EnableIf<IsSame<U, T>::value && !IsNullPointer<typename PtrTraits::NullType>::value>::Type* = nullptr>
typename PtrTraits::NullType null_value() const
{
// make sure we are holding a null value
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
FlatPtr bits = m_bits.load(AK::MemoryOrder::memory_order_relaxed);
ASSERT(PtrTraits::is_null(bits));
return PtrTraits::to_null_value(bits);
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
}
template<typename U = T, typename EnableIf<IsSame<U, T>::value && !IsNullPointer<typename PtrTraits::NullType>::value>::Type* = nullptr>
void set_null_value(typename PtrTraits::NullType value)
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
// make sure that new null value would be interpreted as a null value
FlatPtr bits = PtrTraits::from_null_value(value);
ASSERT(PtrTraits::is_null(bits));
assign_raw(bits);
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
}
Replace zones with individually tracked physical pages. It's just a simple struct { ref_count, paddr }. This will allow me to implement lazy zeroing and COW pages.
2018-11-05 09:23:00 +00:00
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
private:
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
template<typename F>
void do_while_locked(F f) const
{
#ifdef KERNEL
// We don't want to be pre-empted while we have the lock bit set
Kernel::ScopedCritical critical;
#endif
FlatPtr bits = PtrTraits::lock(m_bits);
T* ptr = PtrTraits::as_ptr(bits);
f(ptr);
PtrTraits::unlock(m_bits, bits);
}
[[nodiscard]] ALWAYS_INLINE FlatPtr leak_ref_raw()
{
return PtrTraits::exchange(m_bits, PtrTraits::default_null_value);
}
[[nodiscard]] ALWAYS_INLINE FlatPtr add_ref_raw() const
{
#ifdef KERNEL
// We don't want to be pre-empted while we have the lock bit set
Kernel::ScopedCritical critical;
#endif
// This prevents a race condition between thread A and B:
// 1. Thread A copies RefPtr, e.g. through assignment or copy constructor,
// gets the pointer from source, but is pre-empted before adding
// another reference
// 2. Thread B calls clear, leak_ref, or release_nonnull on source, and
// then drops the last reference, causing the object to be deleted
// 3. Thread A finishes step #1 by attempting to add a reference to
// the object that was already deleted in step #2
FlatPtr bits = PtrTraits::lock(m_bits);
if (T* ptr = PtrTraits::as_ptr(bits))
ptr->ref();
PtrTraits::unlock(m_bits, bits);
return bits;
}
ALWAYS_INLINE void assign_raw(FlatPtr bits)
{
FlatPtr prev_bits = PtrTraits::exchange(m_bits, bits);
unref_if_not_null(PtrTraits::as_ptr(prev_bits));
}
ALWAYS_INLINE T* as_ptr() const
{
return PtrTraits::as_ptr(m_bits.load(AK::MemoryOrder::memory_order_relaxed));
}
ALWAYS_INLINE T* as_nonnull_ptr() const
{
return as_nonnull_ptr(m_bits.load(AK::MemoryOrder::memory_order_relaxed));
}
ALWAYS_INLINE T* as_nonnull_ptr(FlatPtr bits) const
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
{
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
ASSERT(!PtrTraits::is_null(bits));
return PtrTraits::as_ptr(bits);
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
}
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
mutable Atomic<FlatPtr> m_bits { PtrTraits::default_null_value };
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
};
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
template<typename T, typename PtrTraits = RefPtrTraits<T>>
inline const LogStream& operator<<(const LogStream& stream, const RefPtr<T, PtrTraits>& value)
AK: Move some of LogStream out of line & add overloads for smart pointers.
2019-07-04 05:05:58 +00:00
{
return stream << value.ptr();
}
AK: Add basic Traits for RefPtr This allows RefPtr to be stored in a HashTable<RefPtr<T>> :^) It's unfortunate about the const_casts. We'll need to fix HashMap::get to play nice with non-const Traits<T>::PeekType at some point.
2020-02-16 18:36:15 +00:00
template<typename T>
struct Traits<RefPtr<T>> : public GenericTraits<RefPtr<T>> {
using PeekType = const T*;
AK: Add ptr_hash to use int_hash or u64_hash depending on pointer size
2020-02-17 19:19:28 +00:00
static unsigned hash(const RefPtr<T>& p) { return ptr_hash(p.ptr()); }
AK: Add basic Traits for RefPtr This allows RefPtr to be stored in a HashTable<RefPtr<T>> :^) It's unfortunate about the const_casts. We'll need to fix HashMap::get to play nice with non-const Traits<T>::PeekType at some point.
2020-02-16 18:36:15 +00:00
static bool equals(const RefPtr<T>& a, const RefPtr<T>& b) { return a.ptr() == b.ptr(); }
};
AK: Stop allowing implicit downcast with RefPtr and NonnullRefPtr We were allowing this dangerous kind of thing: RefPtr<Base> base; RefPtr<Derived> derived = base; This patch changes the {Nonnull,}RefPtr constructors so this is no longer possible. To downcast one of these pointers, there is now static_ptr_cast<T>: RefPtr<Derived> derived = static_ptr_cast<Derived>(base); Fixing this exposed a ton of cowboy-downcasts in various places, which we're now forced to fix. :^)
2020-04-05 09:11:07 +00:00
template<typename T, typename U>
inline NonnullRefPtr<T> static_ptr_cast(const NonnullRefPtr<U>& ptr)
{
return NonnullRefPtr<T>(static_cast<const T&>(*ptr));
}
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
template<typename T, typename U, typename PtrTraits = RefPtrTraits<T>>
AK: Stop allowing implicit downcast with RefPtr and NonnullRefPtr We were allowing this dangerous kind of thing: RefPtr<Base> base; RefPtr<Derived> derived = base; This patch changes the {Nonnull,}RefPtr constructors so this is no longer possible. To downcast one of these pointers, there is now static_ptr_cast<T>: RefPtr<Derived> derived = static_ptr_cast<Derived>(base); Fixing this exposed a ton of cowboy-downcasts in various places, which we're now forced to fix. :^)
2020-04-05 09:11:07 +00:00
inline RefPtr<T> static_ptr_cast(const RefPtr<U>& ptr)
{
AK: Add RefPtrTraits to allow implementing custom null pointers This adds the ability to implement custom null states that allow storing state in null pointers.
2020-09-23 16:17:43 +00:00
return RefPtr<T, PtrTraits>(static_cast<const T*>(ptr.ptr()));
AK: Stop allowing implicit downcast with RefPtr and NonnullRefPtr We were allowing this dangerous kind of thing: RefPtr<Base> base; RefPtr<Derived> derived = base; This patch changes the {Nonnull,}RefPtr constructors so this is no longer possible. To downcast one of these pointers, there is now static_ptr_cast<T>: RefPtr<Derived> derived = static_ptr_cast<Derived>(base); Fixing this exposed a ton of cowboy-downcasts in various places, which we're now forced to fix. :^)
2020-04-05 09:11:07 +00:00
}
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe This makes most operations thread safe, especially so that they can safely be used in the Kernel. This includes obtaining a strong reference from a weak reference, which now requires an explicit call to WeakPtr::strong_ref(). Another major change is that Weakable::make_weak_ref() may require the explicit target type. Previously we used reinterpret_cast in WeakPtr, assuming that it can be properly converted. But WeakPtr does not necessarily have the knowledge to be able to do this. Instead, we now ask the class itself to deliver a WeakPtr to the type that we want. Also, WeakLink is no longer specific to a target type. The reason for this is that we want to be able to safely convert e.g. WeakPtr<T> to WeakPtr<U>, and before this we just reinterpret_cast the internal WeakLink<T> to WeakLink<U>, which is a bold assumption that it would actually produce the correct code. Instead, WeakLink now operates on just a raw pointer and we only make those constructors/operators available if we can verify that it can be safely cast. In order to guarantee thread safety, we now use the least significant bit in the pointer for locking purposes. This also means that only properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
template<typename T, typename PtrTraitsT, typename U, typename PtrTraitsU>
inline void swap(RefPtr<T, PtrTraitsT>& a, RefPtr<U, PtrTraitsU>& b)
{
a.swap(b);
}
Import all this stuff into a single repo called Serenity.
2018-10-10 09:53:07 +00:00
}
AK: Rename RetainPtr => RefPtr and Retained => NonnullRefPtr.
2019-06-21 16:37:47 +00:00
using AK::RefPtr;
AK: Stop allowing implicit downcast with RefPtr and NonnullRefPtr We were allowing this dangerous kind of thing: RefPtr<Base> base; RefPtr<Derived> derived = base; This patch changes the {Nonnull,}RefPtr constructors so this is no longer possible. To downcast one of these pointers, there is now static_ptr_cast<T>: RefPtr<Derived> derived = static_ptr_cast<Derived>(base); Fixing this exposed a ton of cowboy-downcasts in various places, which we're now forced to fix. :^)
2020-04-05 09:11:07 +00:00
using AK::static_ptr_cast;
Reference in a new issue Copy permalink