Change SlotReader and SlotWriter to take an owned SlotTable

src/composer.rs

@@ -4,8 +4,6 @@ use crate::{
 };
 
 pub struct Composer {
- slot_table: SlotTable,
- insert_table: SlotTable,
  reader: SlotReader,
  writer: SlotWriter,
  is_inserting: bool,
@@ -16,10 +14,8 @@ impl Composer {
  let mut slot_table = SlotTable::default();
  let mut insert_table = SlotTable::default();
  Self {
- reader: slot_table.reader(),
- writer: insert_table.writer(),
- slot_table,
- insert_table,
+ reader: slot_table.into_reader(),
+ writer: insert_table.into_writer(),
  is_inserting: false,
  }
  }
@@ -42,7 +38,7 @@ impl Composer {
 
  fn update_value(&mut self, value: Option<Box<dyn Slot>>) {
  if self.is_inserting {
- self.writer.update(&mut self.insert_table, value);
+ self.writer.update(value);
  // TODO
  } else {
  todo!()
@@ -54,7 +50,7 @@ impl Composer {
  // validateNodeNotExpected()
  None
  } else {
- self.reader.next(&mut self.slot_table)
+ self.reader.next()
  }
  }
 }

src/slot_table/mod.rs

@@ -87,50 +87,22 @@ pub struct SlotTable {
  slots_len: usize,
  groups: Box<[Group]>,
  groups_len: usize,
- reader_count: usize,
- is_writing: bool,
 }
 
 impl SlotTable {
  pub fn is_empty(&self) -> bool {
  self.groups_len == 0
  }
 
- pub fn reader(&mut self) -> SlotReader {
- assert!(!self.is_writing);
- self.reader_count += 1;
-
- SlotReader {
- empty_count: 0,
- current_slot: 0,
- current_slot_end: 0,
- }
+ pub fn into_reader(self) -> SlotReader {
+ SlotReader::new(self)
  }
 
- pub fn writer(&mut self) -> SlotWriter {
- assert!(!self.is_writing && self.reader_count == 0);
- self.is_writing = true;
-
- SlotWriter {
- current_slot: 0,
- current_slot_end: 0,
- slot_gap_start: self.slots_len,
- slot_gap_len: self.slots.len() - self.slots_len,
- insert_count: 0,
- parent: -1,
- group_gap_start: self.groups_len,
- group_gap_len: self.groups.len() / GROUP_FIELDS_SIZE - self.groups_len,
- current_group: 0,
- current_group_end: self.groups_len,
- end_stack: Vec::new(),
- node_count: 0,
- node_count_stack: Vec::new(),
- }
- }
 
- pub fn write(&mut self, f: impl FnOnce(&mut Self, &mut SlotWriter)) {
- let mut writer = self.writer();
- f(self, &mut writer);
- writer.close(self);
+ pub fn into_writer(self) -> SlotWriter {
+ SlotWriter::new(self)
  }
+
+
+
 }

src/slot_table/reader.rs

@@ -1,19 +1,29 @@
 use super::{Slot, SlotTable};
 
 pub struct SlotReader {
- pub(super) empty_count: usize,
- pub(super) current_slot: usize,
- pub(super) current_slot_end: usize,
+ table: SlotTable,
+ empty_count: usize,
+ current_slot: usize,
+ current_slot_end: usize,
 }
 
-impl SlotReader {
- pub fn next(&mut self, table: &mut SlotTable) -> Option<&dyn Slot> {
+impl SlotReader{
+ pub fn new(table: SlotTable) -> Self {
+ Self {
+ empty_count: 0,
+ current_slot: 0,
+ current_slot_end: 0,
+ table
+ }
+ }
+
+ pub fn next(&mut self) -> Option<&dyn Slot> {
  if self.empty_count > 0 || self.current_slot >= self.current_slot_end {
  None
  } else {
- let idx = self.current_slot;
+ let idx = self.current_slot; 
  self.current_slot += 1;
- table.slots[idx].map(|ptr| unsafe { ptr.as_ref().unwrap() })
+ self.table.slots[idx].map(|ptr| unsafe { ptr.as_ref().unwrap() })
  }
  }
 }