feat: just-copy (#16)

Author: jjcfrancisco

src/compressor.rs

@@ -10,4 +10,8 @@ pub enum FastPForError {
     CompressError(String),
     #[error("Invalid block size: {0}")]
     InvalidBlockSizeError(String),
+    #[error("Unsupported operation: {0}")]
+    UnsupportedOperationError(String),
+    #[error("Out of bounds access")]
+    OutOfBoundsAccess,
 }

src/error.rs

@@ -0,0 +1,25 @@
+use crate::{FastPFOR, JustCopy, VariableByte};
+
+pub enum Codec {
+    FastPFor(FastPFOR),
+    VariableByte(VariableByte),
+    JustCopy(JustCopy),
+}
+
+impl From<FastPFOR> for Codec {
+    fn from(fastpfor: FastPFOR) -> Self {
+        Codec::FastPFor(fastpfor)
+    }
+}
+
+impl From<VariableByte> for Codec {
+    fn from(vb: VariableByte) -> Self {
+        Codec::VariableByte(vb)
+    }
+}
+
+impl From<JustCopy> for Codec {
+    fn from(jc: JustCopy) -> Self {
+        Codec::JustCopy(jc)
+    }
+}

src/integer_codec.rs

@@ -1,19 +1,18 @@
 use std::io::Cursor;
 
 use crate::cursor::IncrementCursor;
-use crate::integer_codec::IntegerCodec;
-use crate::{Compressor, FastPForResult};
+use crate::{Codec, FastPForResult, Integer};
 
 pub struct Composition {
-    c1: IntegerCodec,
-    c2: IntegerCodec,
+    c1: Codec,
+    c2: Codec,
 }
 
 impl Composition {
     pub fn new<C1, C2>(c1: C1, c2: C2) -> Self
     where
-        C1: Into<IntegerCodec>,
-        C2: Into<IntegerCodec>,
+        C1: Into<Codec>,
+        C2: Into<Codec>,
     {
         Composition {
             c1: c1.into(),
@@ -70,8 +69,8 @@ impl Composition {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::fastpfor::FastPFOR;
-    use crate::variable_byte::VariableByte;
+    use crate::integer_compression::fastpfor::FastPFOR;
+    use crate::integer_compression::variable_byte::VariableByte;
 
     #[test]
     fn test_composition() {

src/bitpacking.rs src/integer_compression/bitpacking.rssrc/bitpacking.rs renamed to src/integer_compression/bitpacking.rs

@@ -1,9 +1,8 @@
 use std::io::Cursor;
 
-use crate::compressor::Compressor;
 use crate::cursor::IncrementCursor;
-use crate::error::FastPForResult;
-use crate::{bitpacking, bytebuffer, helpers};
+use crate::integer_compression::{bitpacking, helpers};
+use crate::{bytebuffer, FastPForError, FastPForResult, Integer, Skippable};
 
 pub const BLOCK_SIZE_256: i32 = 256;
 pub const BLOCK_SIZE_128: i32 = 128;
@@ -21,7 +20,42 @@ pub struct FastPFOR {
     pub block_size: i32,
 }
 
-impl Compressor<i32> for FastPFOR {
+impl Skippable for FastPFOR {
+    fn headless_compress(
+        &mut self,
+        input: &[i32],
+        input_length: i32,
+        input_offset: &mut Cursor<i32>,
+        output: &mut [i32],
+        output_offset: &mut Cursor<i32>,
+    ) -> FastPForResult<()> {
+        let inlength = helpers::greatest_multiple(input_length, self.block_size as i32);
+        let pos = input_offset.position() as i32;
+        let final_inpos = pos + inlength;
+        while input_offset.position() as i32 != final_inpos {
+            let this_size = std::cmp::min(self.page_size, final_inpos - pos);
+            self.encode_page(input, input_offset, this_size, output, output_offset);
+        }
+        FastPForResult::Ok(())
+    }
+
+    #[expect(unused_variables)]
+    fn headless_uncompress(
+        &mut self,
+        input: &[i32],
+        inlength: i32,
+        input_offset: &mut Cursor<i32>,
+        output: &mut [i32],
+        output_offset: &mut Cursor<i32>,
+        num: i32,
+    ) -> FastPForResult<()> {
+        FastPForResult::Err(FastPForError::UnsupportedOperationError(
+            "Unimplemented".to_string(),
+        ))
+    }
+}
+
+impl Integer<i32> for FastPFOR {
     fn compress(
         &mut self,
         input: &[i32],
@@ -37,14 +71,7 @@ impl Compressor<i32> for FastPFOR {
         }
         output[output_offset.position() as usize] = inlength;
         output_offset.increment();
-        let _inlength = helpers::greatest_multiple(inlength, self.block_size as i32);
-        let pos = input_offset.position() as i32;
-        let final_inpos = pos + _inlength;
-        while input_offset.position() as i32 != final_inpos {
-            let this_size = std::cmp::min(self.page_size, final_inpos - pos);
-            self.encode_page(input, input_offset, this_size, output, output_offset);
-        }
-        FastPForResult::Ok(())
+        self.headless_compress(input, inlength, input_offset, output, output_offset)
     }
 
     fn uncompress(

src/integer_compression/codec.rs

@@ -0,0 +1,67 @@
+use std::io::Cursor;
+
+use crate::{Codec, FastPForResult};
+
+pub trait Integer<T> {
+    fn compress(
+        &mut self,
+        input: &[i32],
+        input_length: i32,
+        input_offset: &mut Cursor<i32>,
+        output: &mut [T],
+        output_offset: &mut Cursor<i32>,
+    ) -> FastPForResult<()>;
+
+    fn uncompress(
+        &mut self,
+        input: &[T],
+        input_length: i32,
+        input_offset: &mut Cursor<i32>,
+        output: &mut [i32],
+        output_offset: &mut Cursor<i32>,
+    ) -> FastPForResult<()>;
+}
+
+impl Integer<i32> for Codec {
+    fn compress(
+        &mut self,
+        input: &[i32],
+        input_length: i32,
+        input_offset: &mut Cursor<i32>,
+        output: &mut [i32],
+        output_offset: &mut Cursor<i32>,
+    ) -> FastPForResult<()> {
+        match self {
+            Codec::FastPFor(fastpfor) => {
+                fastpfor.compress(input, input_length, input_offset, output, output_offset)
+            }
+            Codec::VariableByte(vb) => {
+                vb.compress(input, input_length, input_offset, output, output_offset)
+            }
+            Codec::JustCopy(jc) => {
+                jc.compress(input, input_length, input_offset, output, output_offset)
+            }
+        }
+    }
+
+    fn uncompress(
+        &mut self,
+        input: &[i32],
+        input_length: i32,
+        input_offset: &mut Cursor<i32>,
+        output: &mut [i32],
+        output_offset: &mut Cursor<i32>,
+    ) -> FastPForResult<()> {
+        match self {
+            Codec::FastPFor(fastpfor) => {
+                fastpfor.uncompress(input, input_length, input_offset, output, output_offset)
+            }
+            Codec::VariableByte(vb) => {
+                vb.uncompress(input, input_length, input_offset, output, output_offset)
+            }
+            Codec::JustCopy(jc) => {
+                jc.uncompress(input, input_length, input_offset, output, output_offset)
+            }
+        }
+    }
+}