core: use explicit types and minor cleanups (#5826)

* core: Use uint8_t type instead of unsigned char
* core: Use small base type for enum
* core: use noexcept for move ctors
* core: Remove unimplemented methods
* core: use struct for node
* core: remove top level const qualifier which has no effect

Signed-off-by: Abhijat Malviya <[email protected]>

Author: abhijat

src/core/qlist.cc

@@ -398,10 +398,10 @@ size_t QList::DefragIfNeeded(PageUsage* page_usage) {
     // of their constant (and relatively small, ~40 bytes per object) size. Defragmentation fixes
     // fragmented memory allocation, which usually happens when variable-sized blocks of data are
     // allocated and deallocated, which is not expected with nodes.
-    auto new_entry = static_cast<unsigned char*>(zmalloc(curr->sz));
+    uint8_t* new_entry = static_cast<uint8_t*>(zmalloc(curr->sz));
     memcpy(new_entry, curr->entry, curr->sz);
 
-    unsigned char* old_entry = curr->entry;
+    uint8_t* old_entry = curr->entry;
     curr->entry = new_entry;
 
     zfree(old_entry);
@@ -414,7 +414,7 @@ QList::QList(int fill, int compress) : fill_(fill), compress_(compress), bookmar
   compr_method_ = 0;
 }
 
-QList::QList(QList&& other)
+QList::QList(QList&& other) noexcept
     : head_(other.head_),
       count_(other.count_),
       len_(other.len_),
@@ -429,7 +429,7 @@ QList::~QList() {
   Clear();
 }
 
-QList& QList::operator=(QList&& other) {
+QList& QList::operator=(QList&& other) noexcept {
   if (this != &other) {
     Clear();
     head_ = other.head_;
@@ -445,15 +445,15 @@ QList& QList::operator=(QList&& other) {
   return *this;
 }
 
-void QList::Clear() {
+void QList::Clear() noexcept {
   Node* current = head_;
 
   while (len_) {
     Node* next = current->next;
     if (current->encoding != QUICKLIST_NODE_ENCODING_RAW) {
       quicklistLZF* lzf = (quicklistLZF*)current->entry;
-      QList::stats.compressed_bytes -= lzf->sz;
-      QList::stats.raw_compressed_bytes -= current->sz;
+      stats.compressed_bytes -= lzf->sz;
+      stats.raw_compressed_bytes -= current->sz;
     }
     zfree(current->entry);
     zfree(current);

src/core/qlist.h

@@ -19,8 +19,8 @@ class PageUsage;
 
 class QList {
  public:
-  enum Where { TAIL, HEAD };
-  enum COMPR_METHOD { LZF = 0, LZ4 = 1 };
+  enum Where : uint8_t { TAIL, HEAD };
+  enum COMPR_METHOD : uint8_t { LZF = 0, LZ4 = 1 };
 
   /* Node is a 40 byte struct describing a listpack for a quicklist.
    * We use bit fields keep the Node at 40 bytes.
@@ -33,9 +33,9 @@ class QList {
    * extra: 9 bits, free for future use; pads out the remainder of 32 bits
    * */
 
-  typedef struct Node {
-    struct Node* prev;
-    struct Node* next;
+  struct Node {
+    Node* prev;
+    Node* next;
     unsigned char* entry;
     size_t sz;                           /* entry size in bytes */
     unsigned int count : 16;             /* count of items in listpack */
@@ -45,7 +45,7 @@ class QList {
     unsigned int attempted_compress : 1; /* node can't compress; too small */
     unsigned int dont_compress : 1;      /* prevent compression of entry that will be used later */
     unsigned int extra : 25;             /* more bits to steal for future usage */
-  } Node;
+  };
 
   // Provides wrapper around the references to the listpack entries.
   class Entry {
@@ -103,7 +103,7 @@ class QList {
   };
 
   using IterateFunc = absl::FunctionRef<bool(Entry)>;
-  enum InsertOpt { BEFORE, AFTER };
+  enum InsertOpt : uint8_t { BEFORE, AFTER };
 
   /**
    * fill: The number of entries allowed per internal list node can be specified
@@ -138,18 +138,18 @@ class QList {
    */
   explicit QList(int fill = -2, int compress = 0);
 
-  QList(QList&&);
+  QList(QList&&) noexcept;
   QList(const QList&) = delete;
   ~QList();
 
   QList& operator=(const QList&) = delete;
-  QList& operator=(QList&&);
+  QList& operator=(QList&&) noexcept;
 
   size_t Size() const {
     return count_;
   }
 
-  void Clear();
+  void Clear() noexcept;
 
   void Push(std::string_view value, Where where);
 
@@ -194,7 +194,7 @@ class QList {
 
   // Returns true if elements were deleted, false if list has not changed.
   // Negative start index is allowed.
-  bool Erase(const long start, unsigned count);
+  bool Erase(long start, unsigned count);
 
   // Needed by tests and the rdb code.
   const Node* Head() const {
@@ -246,9 +246,6 @@ class QList {
     return head_ ? head_->prev : nullptr;
   }
 
-  void OnPreUpdate(Node* node);
-  void OnPostUpdate(Node* node);
-
   // Returns newly created plain node.
   Node* InsertPlainNode(Node* old_node, std::string_view, InsertOpt insert_opt);
   void InsertNode(Node* old_node, Node* new_node, InsertOpt insert_opt);