split ordered list, too hard

Author: Lslightly

homework/src/hash_table/split_ordered_list.rs

@@ -53,8 +53,22 @@ impl<V> SplitOrderedList<V> {
         &'s self,
         index: usize,
         guard: &'s Guard,
-    ) -> Cursor<'s, usize, MaybeUninit<V>> {
-        todo!()
+    ) -> (Cursor<'s, usize, MaybeUninit<V>>, bool) {
+        let index_ptr = self.buckets.get(index, guard);
+        let bucket = index_ptr.load(SeqCst, guard);
+        if bucket.is_null() {
+            let new_v = MaybeUninit::uninit();
+            self.list.harris_insert(index, new_v, guard);
+        }
+        let mut cursor = self.list.head(guard);
+        match cursor.find_harris(&index, guard) {
+            Ok(true) => (cursor, true),
+            Ok(false) => (self.list.head(guard), false),
+            Err(_) => {
+                // If the cursor is not valid, we need to reinitialize it.
+                (self.list.head(guard), false)
+            }
+        }
     }
 
     /// Moves the bucket cursor returned from `lookup_bucket` to the position of the given key.
@@ -64,7 +78,8 @@ impl<V> SplitOrderedList<V> {
         key: &usize,
         guard: &'s Guard,
     ) -> (usize, bool, Cursor<'s, usize, MaybeUninit<V>>) {
-        todo!()
+        let (cursor, found) = self.lookup_bucket(*key, guard);
+        (self.size.load(SeqCst), found, cursor)
     }
 
     fn assert_valid_key(key: usize) {
@@ -76,18 +91,45 @@ impl<V> ConcurrentMap<usize, V> for SplitOrderedList<V> {
     fn lookup<'a>(&'a self, key: &usize, guard: &'a Guard) -> Option<&'a V> {
         Self::assert_valid_key(*key);
 
-        todo!()
+        match self.find(key, guard) {
+            (_, true, cursor) => Some(unsafe { cursor.lookup().assume_init_ref() }),
+            (_, false, _) => None,
+        }
     }
 
     fn insert(&self, key: usize, value: V, guard: &Guard) -> Result<(), V> {
         Self::assert_valid_key(key);
 
-        todo!()
+        let (size, found, mut cursor) = self.find(&key, guard);
+        if found {
+            let old_value = unsafe { cursor.lookup().assume_init_read() };
+            Err(old_value)
+        } else {
+            let new_value = MaybeUninit::new(value);
+            if size * Self::LOAD_FACTOR <= self.count.load(SeqCst) {
+                // Resize the buckets if necessary.
+                self.lookup_bucket(size * 2, guard);
+            }
+            // Insert the new value into the list.
+            self.list.harris_insert(key, new_value, guard);
+            self.count.fetch_add(1, SeqCst);
+            Ok(())
+        }
     }
 
     fn delete<'a>(&'a self, key: &usize, guard: &'a Guard) -> Result<&'a V, ()> {
         Self::assert_valid_key(*key);
 
-        todo!()
+        let (size, found, mut cursor) = self.find(key, guard);
+        if !found {
+            return Err(());
+        }
+        // Remove the value from the list.
+        if cursor.delete(guard).is_err() {
+            // If the cursor is not valid, we need to reinitialize it.
+            return Err(());
+        }
+        self.count.fetch_sub(1, SeqCst);
+        Ok(unsafe { cursor.lookup().assume_init_ref() })
     }
 }