wip: indexed

cucapra · May 22, 2024 · e408dd3 · e408dd3
1 parent 24fa303
commit e408dd3
Show file tree

Hide file tree

Showing 3 changed files with 140 additions and 25 deletions.
diff --git a/src/lib.rs b/src/lib.rs
@@ -18,5 +18,5 @@ pub enum Error {}
 
 pub use ops::{BitVecMutOps, BitVecOps};
 pub use value::borrowed::{BitVecValueMutRef, BitVecValueRef};
-pub use value::indexed::{ValueIndexed, ValueStorage};
+pub use value::indexed::{BitVecValueIndex, ValueStorage};
 pub use value::owned::BitVecValue;
diff --git a/src/value/borrowed.rs b/src/value/borrowed.rs
@@ -8,8 +8,8 @@ use crate::{BitVecMutOps, BitVecOps, WidthInt, Word};
 
 /// Bit-vector value that does not own its storage.
 pub struct BitVecValueRef<'a> {
-    width: WidthInt,
-    words: &'a [Word],
+    pub(crate) width: WidthInt,
+    pub(crate) words: &'a [Word],
 }
 
 impl<'a> std::fmt::Debug for BitVecValueRef<'a> {
@@ -19,8 +19,8 @@ impl<'a> std::fmt::Debug for BitVecValueRef<'a> {
 }
 
 pub struct BitVecValueMutRef<'a> {
-    width: WidthInt,
-    words: &'a mut [Word],
+    pub(crate) width: WidthInt,
+    pub(crate) words: &'a mut [Word],
 }
 
 impl<'a> std::fmt::Debug for BitVecValueMutRef<'a> {

diff --git a/src/value/indexed.rs b/src/value/indexed.rs
@@ -10,31 +10,146 @@ use crate::{WidthInt, Word};
 type WordIndex = u32;
 
 #[derive(Debug)]
-pub struct ValueIndexed {
+pub struct BitVecValueIndex {
     width: WidthInt,
     index: WordIndex,
 }
 
+impl BitVecValueIndex {
+    fn new(index: WordIndex, width: WidthInt) -> Self {
+        Self { index, width }
+    }
+
+    #[inline]
+    fn words(&self) -> usize {
+        self.width.div_ceil(Word::BITS) as usize
+    }
+
+    #[inline]
+    fn to_range(&self) -> std::ops::Range<usize> {
+        let start = self.index as usize;
+        let end = start + self.words();
+        start..end
+    }
+}
+
 pub struct ValueStorage<'a> {
-    values: &'a [Word],
+    values: &'a mut [Word],
 }
 
-// impl<'a> From<&'a [Word]> for ValueStorage<'a> {}
+impl<'a, T: AsMut<[Word]>> From<&'a mut T> for ValueStorage<'a> {
+    #[inline]
+    fn from(value: &'a mut T) -> Self {
+        Self {
+            values: value.as_mut(),
+        }
+    }
+}
 
-// impl ValueIndexed {
-//     pub fn as_ref<'a>(&self, storage: &'a impl ValueStorage) -> BitVecValueRef<'a> {
-//         todo!()
-//         // BitVecValueRef {
-//         //     width: self.width,
-//         //     words: storage.words(self.index),
-//         // }
-//     }
-//
-//     pub fn as_mut<'a>(&self, storage: &'a mut impl ValueStorage) -> BitVecValueMutRef<'a> {
-//         todo!()
-//         // BitVecValueMutRef {
-//         //     width: self.width,
-//         //     words: storage.words_mut(self.index),
-//         // }
-//     }
-// }
+pub trait GetOneRef {
+    fn get_ref(&self, index: &BitVecValueIndex) -> BitVecValueRef;
+    fn get_mut(&mut self, index: &BitVecValueIndex) -> BitVecValueMutRef;
+}
+
+impl<'a> GetOneRef for ValueStorage<'a> {
+    fn get_ref(&self, index: &BitVecValueIndex) -> BitVecValueRef {
+        BitVecValueRef {
+            width: index.width,
+            words: &self.values[index.to_range()],
+        }
+    }
+    fn get_mut(&mut self, index: &BitVecValueIndex) -> BitVecValueMutRef {
+        BitVecValueMutRef {
+            width: index.width,
+            words: &mut self.values[index.to_range()],
+        }
+    }
+}
+
+pub trait GetTwoRef {
+    fn get_ref(
+        &self,
+        a: &BitVecValueIndex,
+        b: &BitVecValueIndex,
+    ) -> (BitVecValueRef, BitVecValueRef);
+    fn get_mut(
+        &mut self,
+        a: &BitVecValueIndex,
+        b: &BitVecValueIndex,
+    ) -> (BitVecValueMutRef, BitVecValueRef);
+}
+
+impl<'a> GetTwoRef for ValueStorage<'a> {
+    fn get_ref(
+        &self,
+        a: &BitVecValueIndex,
+        b: &BitVecValueIndex,
+    ) -> (BitVecValueRef, BitVecValueRef) {
+        todo!()
+    }
+
+    fn get_mut(
+        &mut self,
+        a: &BitVecValueIndex,
+        b: &BitVecValueIndex,
+    ) -> (BitVecValueMutRef, BitVecValueRef) {
+        todo!()
+    }
+}
+
+pub trait GetThreeRef {
+    fn get_ref(
+        &self,
+        a: &BitVecValueIndex,
+        b: &BitVecValueIndex,
+        c: &BitVecValueIndex,
+    ) -> (BitVecValueRef, BitVecValueRef, BitVecValueRef);
+    fn get_mut(
+        &mut self,
+        a: &BitVecValueIndex,
+        b: &BitVecValueIndex,
+        c: &BitVecValueIndex,
+    ) -> (BitVecValueMutRef, BitVecValueRef, BitVecValueRef);
+}
+
+impl<'a> GetThreeRef for ValueStorage<'a> {
+    fn get_ref(
+        &self,
+        a: &BitVecValueIndex,
+        b: &BitVecValueIndex,
+        c: &BitVecValueIndex,
+    ) -> (BitVecValueRef, BitVecValueRef, BitVecValueRef) {
+        todo!()
+    }
+
+    fn get_mut(
+        &mut self,
+        a: &BitVecValueIndex,
+        b: &BitVecValueIndex,
+        c: &BitVecValueIndex,
+    ) -> (BitVecValueMutRef, BitVecValueRef, BitVecValueRef) {
+        todo!()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn type_size() {
+        assert_eq!(std::mem::size_of::<WidthInt>(), 4);
+        assert_eq!(std::mem::size_of::<WordIndex>(), 4);
+        assert_eq!(std::mem::size_of::<BitVecValueIndex>(), 8);
+    }
+
+    #[test]
+    fn test_array_access() {
+        {
+            let mut backend = [0; 16];
+            let storage: ValueStorage = (&mut backend).into();
+            // let (a,b) = storage.get_ref(BitVecValueIndex::new(0, 8), BitVecValueIndex::new(1, 8));
+            // let c = a.add(b);
+        }
+    }
+}