RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 00:37:45 +00:00
Code Issues Activity Actions

AK: Add NonnullOwnPtr.

Browse source 
This is just like OwnPtr (also single-owner), except it cannot be null.

NonnullOwnPtr is perfect as the return type of functions that never need to
return nullptr.

It's also useful as an argument type to encode the fact that the argument
must not be nullptr.

The make<Foo>() helper is changed to return NonnullOwnPtr<Foo>.

Note: You can move() out of a NonnullOwnPtr, and after that the object is
in an invalid state. Internally it will be a nullptr at this point, so we'll
still catch misuse, but the only thing that should be done in this state
is running the destructor. I've used consumable annotations to generate some
warnings when using a NonnullOwnPtr after moving from it, but these only
work when compiling with clang, so be aware of that.
This commit is contained in:
Andreas Kling 2019-07-24 08:25:27 +02:00
parent ecc35876af
commit 28da5b002f
2 changed files with 182 additions and 21 deletions
Download patch file Download diff file Expand all files Collapse all files

46
AK/OwnPtr.h
View file

@ -1,19 +1,9 @@
#pragma once
#include <AK/LogStream.h>
#include <AK/StdLibExtras.h>
#include <AK/Traits.h>
#include <AK/Types.h>
#include <AK/NonnullOwnPtr.h>
namespace AK {
template<typename T>
class RefPtr;
template<typename T>
class NonnullRefPtr;
template<typename T>
class WeakPtr;
template<typename T>
class OwnPtr {
public:
@ -26,6 +16,12 @@ public:
: m_ptr(other.leak_ptr())
{
}
template<typename U>
OwnPtr(NonnullOwnPtr<U>&& other)
: m_ptr(static_cast<T*>(other.leak_ptr()))
{
}
template<typename U>
OwnPtr(OwnPtr<U>&& other)
: m_ptr(static_cast<T*>(other.leak_ptr()))
@ -43,6 +39,13 @@ public:
#endif
}
OwnPtr(const OwnPtr&) = delete;
template<typename U>
OwnPtr(const OwnPtr<U>&) = delete;
OwnPtr& operator=(const OwnPtr&) = delete;
template<typename U>
OwnPtr& operator=(const OwnPtr<U>&) = delete;
template<typename U>
OwnPtr(const RefPtr<U>&) = delete;
template<typename U>
@ -75,6 +78,15 @@ public:
return *this;
}
template<typename U>
OwnPtr& operator=(NonnullOwnPtr<U>&& other)
{
ASSERT(m_ptr != other.ptr());
delete m_ptr;
m_ptr = other.leak_ptr();
return *this;
}
OwnPtr& operator=(T* ptr)
{
if (m_ptr != ptr)
@ -99,9 +111,9 @@ public:
T* leak_ptr()
{
T* leakedPtr = m_ptr;
T* leaked_ptr = m_ptr;
m_ptr = nullptr;
return leakedPtr;
return leaked_ptr;
}
T* ptr() { return m_ptr; }
@ -122,13 +134,6 @@ private:
T* m_ptr = nullptr;
};
template<class T, class... Args>
inline OwnPtr<T>
make(Args&&... args)
{
return OwnPtr<T>(new T(AK::forward<Args>(args)...));
}
template<typename T>
struct Traits<OwnPtr<T>> : public GenericTraits<OwnPtr<T>> {
static unsigned hash(const OwnPtr<T>& p) { return (unsigned)p.ptr(); }
@ -144,5 +149,4 @@ inline const LogStream& operator<<(const LogStream& stream, const OwnPtr<T>& val
}
using AK::make;
using AK::OwnPtr;