AK: Rename Retainable => RefCounted.

(And various related renames that go along with it.)
fleximus · Jun 21, 2019 · 77b9fa8 · 77b9fa8
1 parent ef1bfcb
commit 77b9fa8
Show file tree

Hide file tree

Showing 45 changed files with 118 additions and 118 deletions.
diff --git a/AK/ByteBuffer.h b/AK/ByteBuffer.h
@@ -8,7 +8,7 @@
 
 namespace AK {
 
-class ByteBufferImpl : public Retainable<ByteBufferImpl> {
+class ByteBufferImpl : public RefCounted<ByteBufferImpl> {
 public:
  static Retained<ByteBufferImpl> create_uninitialized(int size);
  static Retained<ByteBufferImpl> create_zeroed(int);

diff --git a/AK/JsonValue.cpp b/AK/JsonValue.cpp
@@ -30,7 +30,7 @@ void JsonValue::copy_from(const JsonValue& other)
  switch (m_type) {
  case Type::String:
  m_value.as_string = other.m_value.as_string;
- AK::retain_if_not_null(m_value.as_string);
+ AK::ref_if_not_null(m_value.as_string);
  break;
  case Type::Object:
  m_value.as_object = new JsonObject(*other.m_value.as_object);
@@ -101,7 +101,7 @@ JsonValue::JsonValue(const String& value)
  } else {
  m_type = Type::String;
  m_value.as_string = const_cast<StringImpl*>(value.impl());
- AK::retain_if_not_null(m_value.as_string);
+ AK::ref_if_not_null(m_value.as_string);
  }
 }
 
@@ -121,7 +121,7 @@ void JsonValue::clear()
 {
  switch (m_type) {
  case Type::String:
- AK::release_if_not_null(m_value.as_string);
+ AK::deref_if_not_null(m_value.as_string);
  break;
  case Type::Object:
  delete m_value.as_object;

diff --git a/AK/RetainPtr.h b/AK/RetainPtr.h
@@ -16,22 +16,22 @@ class RetainPtr {
  RetainPtr(const T* ptr)
  : m_ptr(const_cast<T*>(ptr))
  {
- retain_if_not_null(m_ptr);
+ ref_if_not_null(m_ptr);
  }
  RetainPtr(T* ptr)
  : m_ptr(ptr)
  {
- retain_if_not_null(m_ptr);
+ ref_if_not_null(m_ptr);
  }
  RetainPtr(T& object)
  : m_ptr(&object)
  {
- m_ptr->retain();
+ m_ptr->ref();
  }
  RetainPtr(const T& object)
  : m_ptr(const_cast<T*>(&object))
  {
- m_ptr->retain();
+ m_ptr->ref();
  }
  RetainPtr(AdoptTag, T& object)
  : m_ptr(&object)
@@ -79,7 +79,7 @@ class RetainPtr {
  RetainPtr& operator=(RetainPtr&& other)
  {
  if (this != &other) {
- release_if_not_null(m_ptr);
+ deref_if_not_null(m_ptr);
  m_ptr = other.leak_ref();
  }
  return *this;
@@ -89,7 +89,7 @@ class RetainPtr {
  RetainPtr& operator=(RetainPtr<U>&& other)
  {
  if (this != static_cast<void*>(&other)) {
- release_if_not_null(m_ptr);
+ deref_if_not_null(m_ptr);
  m_ptr = other.leak_ref();
  }
  return *this;
@@ -98,7 +98,7 @@ class RetainPtr {
  template<typename U>
  RetainPtr& operator=(Retained<U>&& other)
  {
- release_if_not_null(m_ptr);
+ deref_if_not_null(m_ptr);
  m_ptr = &other.leak_ref();
  return *this;
  }
@@ -107,38 +107,38 @@ class RetainPtr {
  RetainPtr& operator=(const Retained<U>& other)
  {
  if (m_ptr != other.ptr())
- release_if_not_null(m_ptr);
+ deref_if_not_null(m_ptr);
  m_ptr = const_cast<T*>(other.ptr());
  ASSERT(m_ptr);
- retain_if_not_null(m_ptr);
+ ref_if_not_null(m_ptr);
  return *this;
  }
 
  template<typename U>
  RetainPtr& operator=(const RetainPtr<U>& other)
  {
  if (m_ptr != other.ptr())
- release_if_not_null(m_ptr);
+ deref_if_not_null(m_ptr);
  m_ptr = const_cast<T*>(other.ptr());
- retain_if_not_null(m_ptr);
+ ref_if_not_null(m_ptr);
  return *this;
  }
 
  RetainPtr& operator=(const T* ptr)
  {
  if (m_ptr != ptr)
- release_if_not_null(m_ptr);
+ deref_if_not_null(m_ptr);
  m_ptr = const_cast<T*>(ptr);
- retain_if_not_null(m_ptr);
+ ref_if_not_null(m_ptr);
  return *this;
  }
 
  RetainPtr& operator=(const T& object)
  {
  if (m_ptr != &object)
- release_if_not_null(m_ptr);
+ deref_if_not_null(m_ptr);
  m_ptr = const_cast<T*>(&object);
- retain_if_not_null(m_ptr);
+ ref_if_not_null(m_ptr);
  return *this;
  }
 
@@ -155,7 +155,7 @@ class RetainPtr {
 
  void clear()
  {
- release_if_not_null(m_ptr);
+ deref_if_not_null(m_ptr);
  m_ptr = nullptr;
  }
 

diff --git a/AK/Retainable.h b/AK/Retainable.h
@@ -18,61 +18,61 @@ constexpr auto call_will_be_destroyed_if_present(...) -> FalseType
 }
 
 template<class T>
-constexpr auto call_one_retain_left_if_present(T* object) -> decltype(object->one_retain_left(), TrueType {})
+constexpr auto call_one_ref_left_if_present(T* object) -> decltype(object->one_ref_left(), TrueType {})
 {
- object->one_retain_left();
+ object->one_ref_left();
  return {};
 }
 
-constexpr auto call_one_retain_left_if_present(...) -> FalseType
+constexpr auto call_one_ref_left_if_present(...) -> FalseType
 {
  return {};
 }
 
-class RetainableBase {
+class RefCountedBase {
 public:
- void retain()
+ void ref()
  {
- ASSERT(m_retain_count);
- ++m_retain_count;
+ ASSERT(m_ref_count);
+ ++m_ref_count;
  }
 
- int retain_count() const
+ int ref_count() const
  {
- return m_retain_count;
+ return m_ref_count;
  }
 
 protected:
- RetainableBase() {}
- ~RetainableBase()
+ RefCountedBase() {}
+ ~RefCountedBase()
  {
- ASSERT(!m_retain_count);
+ ASSERT(!m_ref_count);
  }
 
- void release_base()
+ void deref_base()
  {
- ASSERT(m_retain_count);
- --m_retain_count;
+ ASSERT(m_ref_count);
+ --m_ref_count;
  }
 
- int m_retain_count { 1 };
+ int m_ref_count { 1 };
 };
 
 template<typename T>
-class Retainable : public RetainableBase {
+class RefCounted : public RefCountedBase {
 public:
- void release()
+ void deref()
  {
- release_base();
- if (m_retain_count == 0) {
+ deref_base();
+ if (m_ref_count == 0) {
  call_will_be_destroyed_if_present(static_cast<T*>(this));
  delete static_cast<T*>(this);
- } else if (m_retain_count == 1) {
- call_one_retain_left_if_present(static_cast<T*>(this));
+ } else if (m_ref_count == 1) {
+ call_one_ref_left_if_present(static_cast<T*>(this));
  }
  }
 };
 
 }
 
-using AK::Retainable;
+using AK::RefCounted;
diff --git a/AK/Retained.h b/AK/Retained.h
@@ -18,17 +18,17 @@
 namespace AK {
 
 template<typename T>
-inline void retain_if_not_null(T* ptr)
+inline void ref_if_not_null(T* ptr)
 {
  if (ptr)
- ptr->retain();
+ ptr->ref();
 }
 
 template<typename T>
-inline void release_if_not_null(T* ptr)
+inline void deref_if_not_null(T* ptr)
 {
  if (ptr)
- ptr->release();
+ ptr->deref();
 }
 
 template<typename T>
@@ -42,14 +42,14 @@ class CONSUMABLE(unconsumed) Retained {
  Retained(const T& object)
  : m_ptr(const_cast<T*>(&object))
  {
- m_ptr->retain();
+ m_ptr->ref();
  }
  template<typename U>
  RETURN_TYPESTATE(unconsumed)
  Retained(const U& object)
  : m_ptr(&const_cast<T&>(static_cast<const T&>(object)))
  {
- m_ptr->retain();
+ m_ptr->ref();
  }
  RETURN_TYPESTATE(unconsumed)
  Retained(AdoptTag, T& object)
@@ -85,7 +85,7 @@ class CONSUMABLE(unconsumed) Retained {
  }
  ~Retained()
  {
- release_if_not_null(m_ptr);
+ deref_if_not_null(m_ptr);
  m_ptr = nullptr;
 #ifdef SANITIZE_PTRS
  if constexpr (sizeof(T*) == 8)
@@ -99,7 +99,7 @@ class CONSUMABLE(unconsumed) Retained {
  Retained& operator=(Retained&& other)
  {
  if (this != &other) {
- release_if_not_null(m_ptr);
+ deref_if_not_null(m_ptr);
  m_ptr = &other.leak_ref();
  }
  return *this;
@@ -110,7 +110,7 @@ class CONSUMABLE(unconsumed) Retained {
  Retained& operator=(Retained<U>&& other)
  {
  if (this != static_cast<void*>(&other)) {
- release_if_not_null(m_ptr);
+ deref_if_not_null(m_ptr);
  m_ptr = &other.leak_ref();
  }
  return *this;
@@ -120,9 +120,9 @@ class CONSUMABLE(unconsumed) Retained {
  Retained& operator=(T& object)
  {
  if (m_ptr != &object)
- release_if_not_null(m_ptr);
+ deref_if_not_null(m_ptr);
  m_ptr = &object;
- m_ptr->retain();
+ m_ptr->ref();
  return *this;
  }
 

diff --git a/AK/StringImpl.h b/AK/StringImpl.h
@@ -12,7 +12,7 @@ enum ShouldChomp {
  Chomp
 };
 
-class StringImpl : public Retainable<StringImpl> {
+class StringImpl : public RefCounted<StringImpl> {
 public:
  static Retained<StringImpl> create_uninitialized(int length, char*& buffer);
  static RetainPtr<StringImpl> create(const char* cstring, ShouldChomp = NoChomp);

diff --git a/AK/Weakable.h b/AK/Weakable.h
@@ -12,7 +12,7 @@ template<typename T>
 class WeakPtr;
 
 template<typename T>
-class WeakLink : public Retainable<WeakLink<T>> {
+class WeakLink : public RefCounted<WeakLink<T>> {
  friend class Weakable<T>;
 
 public:

diff --git a/Applications/IRCClient/IRCChannel.h b/Applications/IRCClient/IRCChannel.h
@@ -11,7 +11,7 @@ class IRCClient;
 class IRCChannelMemberListModel;
 class IRCWindow;
 
-class IRCChannel : public Retainable<IRCChannel> {
+class IRCChannel : public RefCounted<IRCChannel> {
 public:
  static Retained<IRCChannel> create(IRCClient&, const String&);
  ~IRCChannel();

diff --git a/Applications/IRCClient/IRCLogBuffer.h b/Applications/IRCClient/IRCLogBuffer.h
@@ -8,7 +8,7 @@
 
 class IRCLogBufferModel;
 
-class IRCLogBuffer : public Retainable<IRCLogBuffer> {
+class IRCLogBuffer : public RefCounted<IRCLogBuffer> {
 public:
  static Retained<IRCLogBuffer> create();
  ~IRCLogBuffer();

diff --git a/Applications/IRCClient/IRCQuery.h b/Applications/IRCClient/IRCQuery.h
@@ -10,7 +10,7 @@
 class IRCClient;
 class IRCWindow;
 
-class IRCQuery : public Retainable<IRCQuery> {
+class IRCQuery : public RefCounted<IRCQuery> {
 public:
  static Retained<IRCQuery> create(IRCClient&, const String& name);
  ~IRCQuery();

diff --git a/DevTools/VisualBuilder/VBWidget.h b/DevTools/VisualBuilder/VBWidget.h
@@ -39,7 +39,7 @@ inline void for_each_direction(Callback callback)
  callback(Direction::DownLeft);
 }
 
-class VBWidget : public Retainable<VBWidget>
+class VBWidget : public RefCounted<VBWidget>
  , public Weakable<VBWidget> {
  friend class VBWidgetPropertyModel;
 

diff --git a/Kernel/Devices/DiskDevice.h b/Kernel/Devices/DiskDevice.h
@@ -6,7 +6,7 @@
 // FIXME: Support 64-bit DiskOffset
 typedef dword DiskOffset;
 
-class DiskDevice : public Retainable<DiskDevice> {
+class DiskDevice : public RefCounted<DiskDevice> {
 public:
  virtual ~DiskDevice();
 

diff --git a/Kernel/File.h b/Kernel/File.h
@@ -39,7 +39,7 @@ class Region;
 // - Called by mmap() when userspace wants to memory-map this File somewhere.
 // - Should create a Region in the Process and return it if successful.
 
-class File : public Retainable<File> {
+class File : public RefCounted<File> {
 public:
  virtual ~File();
 

diff --git a/Kernel/FileSystem/Custody.h b/Kernel/FileSystem/Custody.h
@@ -10,7 +10,7 @@ class VFS;
 
 // FIXME: Custody needs some locking.
 
-class Custody : public Retainable<Custody> {
+class Custody : public RefCounted<Custody> {
 public:
  static Custody* get_if_cached(Custody* parent, const String& name);
  static Retained<Custody> get_or_create(Custody* parent, const String& name, Inode&);

diff --git a/Kernel/FileSystem/Ext2FileSystem.cpp b/Kernel/FileSystem/Ext2FileSystem.cpp
@@ -1232,7 +1232,7 @@ InodeIdentifier Ext2FSInode::lookup(StringView name)
  return {};
 }
 
-void Ext2FSInode::one_retain_left()
+void Ext2FSInode::one_ref_left()
 {
  // FIXME: I would like to not live forever, but uncached Ext2FS is fucking painful right now.
 }