commit c37aa7ad3c9767257dfcfd978a2527dc63fb57cd
author Elliott Hughes <enh@google.com> Tue Aug 08 14:04:02 2023 +0000
committer Elliott Hughes <enh@google.com> Tue Aug 08 14:05:01 2023 +0000
tree b030813fbc91c8e00f1f99655ddd65df21102f8e
parent b88dba9a704108d7cfb4b5802e148e67ec872804

Rename prop_bt.

Presumably "bt" was "binary tree", but "trie_node" is a bit more
specific and removes the guesswork.

Test: treehugger
Change-Id: Ib5fb2dcbcf261ce516728099d484ed9cd6c069bd

libc/system_properties/prop_area.cpp

diff --git a/libc/system_properties/prop_area.cpp b/libc/system_properties/prop_area.cpp
index 42bee9f..4668eed 100644
--- a/libc/system_properties/prop_area.cpp
+++ b/libc/system_properties/prop_area.cpp
@@ -154,16 +154,15 @@
   return data_ + *off;
 }
 
-prop_bt* prop_area::new_prop_bt(const char* name, uint32_t namelen, uint_least32_t* const off) {
+prop_trie_node* prop_area::new_prop_trie_node(const char* name, uint32_t namelen,
+                                              uint_least32_t* const off) {
   uint_least32_t new_offset;
-  void* const p = allocate_obj(sizeof(prop_bt) + namelen + 1, &new_offset);
-  if (p != nullptr) {
-    prop_bt* bt = new (p) prop_bt(name, namelen);
-    *off = new_offset;
-    return bt;
-  }
+  void* const p = allocate_obj(sizeof(prop_trie_node) + namelen + 1, &new_offset);
+  if (p == nullptr) return nullptr;
 
-  return nullptr;
+  prop_trie_node* node = new (p) prop_trie_node(name, namelen);
+  *off = new_offset;
+  return node;
 }
 
 prop_info* prop_area::new_prop_info(const char* name, uint32_t namelen, const char* value,
@@ -200,9 +199,9 @@
   return (data_ + off);
 }
 
-inline prop_bt* prop_area::to_prop_bt(atomic_uint_least32_t* off_p) {
+inline prop_trie_node* prop_area::to_prop_trie_node(atomic_uint_least32_t* off_p) {
   uint_least32_t off = atomic_load_explicit(off_p, memory_order_consume);
-  return reinterpret_cast<prop_bt*>(to_prop_obj(off));
+  return reinterpret_cast<prop_trie_node*>(to_prop_obj(off));
 }
 
 inline prop_info* prop_area::to_prop_info(atomic_uint_least32_t* off_p) {
@@ -210,8 +209,8 @@
   return reinterpret_cast<prop_info*>(to_prop_obj(off));
 }
 
-inline prop_bt* prop_area::root_node() {
-  return reinterpret_cast<prop_bt*>(to_prop_obj(0));
+inline prop_trie_node* prop_area::root_node() {
+  return reinterpret_cast<prop_trie_node*>(to_prop_obj(0));
 }
 
 static int cmp_prop_name(const char* one, uint32_t one_len, const char* two, uint32_t two_len) {
@@ -223,9 +222,9 @@
     return strncmp(one, two, one_len);
 }
 
-prop_bt* prop_area::find_prop_bt(prop_bt* const bt, const char* name, uint32_t namelen,
-                                 bool alloc_if_needed) {
-  prop_bt* current = bt;
+prop_trie_node* prop_area::find_prop_trie_node(prop_trie_node* const trie, const char* name,
+                                               uint32_t namelen, bool alloc_if_needed) {
+  prop_trie_node* current = trie;
   while (true) {
     if (!current) {
       return nullptr;
@@ -239,46 +238,46 @@
     if (ret < 0) {
       uint_least32_t left_offset = atomic_load_explicit(&current->left, memory_order_relaxed);
       if (left_offset != 0) {
-        current = to_prop_bt(&current->left);
+        current = to_prop_trie_node(&current->left);
       } else {
         if (!alloc_if_needed) {
           return nullptr;
         }
 
         uint_least32_t new_offset;
-        prop_bt* new_bt = new_prop_bt(name, namelen, &new_offset);
-        if (new_bt) {
+        prop_trie_node* new_node = new_prop_trie_node(name, namelen, &new_offset);
+        if (new_node) {
           atomic_store_explicit(&current->left, new_offset, memory_order_release);
         }
-        return new_bt;
+        return new_node;
       }
     } else {
       uint_least32_t right_offset = atomic_load_explicit(&current->right, memory_order_relaxed);
       if (right_offset != 0) {
-        current = to_prop_bt(&current->right);
+        current = to_prop_trie_node(&current->right);
       } else {
         if (!alloc_if_needed) {
           return nullptr;
         }
 
         uint_least32_t new_offset;
-        prop_bt* new_bt = new_prop_bt(name, namelen, &new_offset);
-        if (new_bt) {
+        prop_trie_node* new_node = new_prop_trie_node(name, namelen, &new_offset);
+        if (new_node) {
           atomic_store_explicit(&current->right, new_offset, memory_order_release);
         }
-        return new_bt;
+        return new_node;
       }
     }
   }
 }
 
-const prop_info* prop_area::find_property(prop_bt* const trie, const char* name, uint32_t namelen,
-                                          const char* value, uint32_t valuelen,
+const prop_info* prop_area::find_property(prop_trie_node* const trie, const char* name,
+                                          uint32_t namelen, const char* value, uint32_t valuelen,
                                           bool alloc_if_needed) {
   if (!trie) return nullptr;
 
   const char* remaining_name = name;
-  prop_bt* current = trie;
+  prop_trie_node* current = trie;
   while (true) {
     const char* sep = strchr(remaining_name, '.');
     const bool want_subtree = (sep != nullptr);
@@ -288,13 +287,13 @@
       return nullptr;
     }
 
-    prop_bt* root = nullptr;
+    prop_trie_node* root = nullptr;
     uint_least32_t children_offset = atomic_load_explicit(&current->children, memory_order_relaxed);
     if (children_offset != 0) {
-      root = to_prop_bt(&current->children);
+      root = to_prop_trie_node(&current->children);
     } else if (alloc_if_needed) {
       uint_least32_t new_offset;
-      root = new_prop_bt(remaining_name, substr_size, &new_offset);
+      root = new_prop_trie_node(remaining_name, substr_size, &new_offset);
       if (root) {
         atomic_store_explicit(&current->children, new_offset, memory_order_release);
       }
@@ -304,7 +303,7 @@
       return nullptr;
     }
 
-    current = find_prop_bt(root, remaining_name, substr_size, alloc_if_needed);
+    current = find_prop_trie_node(root, remaining_name, substr_size, alloc_if_needed);
     if (!current) {
       return nullptr;
     }
@@ -330,13 +329,13 @@
   }
 }
 
-bool prop_area::foreach_property(prop_bt* const trie,
+bool prop_area::foreach_property(prop_trie_node* const trie,
                                  void (*propfn)(const prop_info* pi, void* cookie), void* cookie) {
   if (!trie) return false;
 
   uint_least32_t left_offset = atomic_load_explicit(&trie->left, memory_order_relaxed);
   if (left_offset != 0) {
-    const int err = foreach_property(to_prop_bt(&trie->left), propfn, cookie);
+    const int err = foreach_property(to_prop_trie_node(&trie->left), propfn, cookie);
     if (err < 0) return false;
   }
   uint_least32_t prop_offset = atomic_load_explicit(&trie->prop, memory_order_relaxed);
@@ -347,12 +346,12 @@
   }
   uint_least32_t children_offset = atomic_load_explicit(&trie->children, memory_order_relaxed);
   if (children_offset != 0) {
-    const int err = foreach_property(to_prop_bt(&trie->children), propfn, cookie);
+    const int err = foreach_property(to_prop_trie_node(&trie->children), propfn, cookie);
     if (err < 0) return false;
   }
   uint_least32_t right_offset = atomic_load_explicit(&trie->right, memory_order_relaxed);
   if (right_offset != 0) {
-    const int err = foreach_property(to_prop_bt(&trie->right), propfn, cookie);
+    const int err = foreach_property(to_prop_trie_node(&trie->right), propfn, cookie);
     if (err < 0) return false;
   }