Fix #39 . added into_inner

danielrh · danielrh · commit 1b2a153177b0 · 2019-02-10T22:53:16.000-08:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "brotli"
-version = "3.1.8"
+version = "3.2.0"
 authors = ["Daniel Reiter Horn <danielrh@dropbox.com>", "The Brotli Authors"]
 description = "A brotli compressor and decompressor that with an interface avoiding the rust stdlib. This makes it suitable for embedded devices and kernels. It is designed with a pluggable allocator so that the standard lib's allocator may be employed. The default build also includes a stdlib allocator and stream interface. Disable this with --features=no-stdlib. All included code is safe."
 license = "BSD-3-Clause/MIT"
@@ -27,7 +27,7 @@ incremental=false
 
 [dependencies]
 "alloc-no-stdlib" = {version="2.0"}
-"brotli-decompressor" = {version="~2.1", default-features=false}
+"brotli-decompressor" = {version="~2.2", default-features=false}
 "alloc-stdlib" = {version="~0.2", optional=true}
 "packed_simd" = {version="0.3", optional=true}
 "sha2" = {version="~0.8", optional=true}
diff --git a/README.md b/README.md
@@ -3,6 +3,10 @@
 [![crates.io](http://meritbadge.herokuapp.com/brotli)](https://crates.io/crates/brotli)
 [![Build Status](https://travis-ci.org/dropbox/rust-brotli.svg?branch=master)](https://travis-ci.org/dropbox/rust-brotli)
 
+
+## What's new in 3.2
+* into_inner conversions for both Reader and Writer classes
+
 ## What's new in 3.0
 * A fully compatible FFI for drop-in compatibiltiy with the https://github.com/google/brotli binaries
   * custom allocators fully supported
diff --git a/src/bin/integration_tests.rs b/src/bin/integration_tests.rs
@@ -183,7 +183,6 @@ fn decompress_internal<InputType, OutputType, Run: Runner>(r: &mut InputType,
         available_out = output.slice().len()
       }
     }
-    brotli_state.BrotliStateCleanup();
   });
   if timing_error {
     let _r = super::writeln0(&mut io::stderr(), "Timing error");
diff --git a/src/enc/reader.rs b/src/enc/reader.rs
@@ -59,6 +59,9 @@ impl<R: Read,
     pub fn get_ref(&self) -> &R {
         &self.0.get_ref().0
     }
+    pub fn into_inner(self) -> R {
+        self.0.into_inner().0
+    }
 }
 
 #[cfg(feature="std")]
@@ -93,13 +96,16 @@ impl<R: Read> CompressorReader<R> {
 
   pub fn with_params(r: R, buffer_size: usize, params: &BrotliEncoderParams) -> Self {
     let mut reader = Self::new(r, buffer_size, params.quality as u32, params.lgwin as u32);
-    (reader.0).0.state.params = params.clone();
+    (reader.0).0.state.0.params = params.clone();
     reader
   }
 
   pub fn get_ref(&self) -> &R {
       self.0.get_ref()
   }
+  pub fn into_inner(self) -> R {
+    self.0.into_inner()
+  }
 }
 
 
@@ -123,7 +129,14 @@ pub struct CompressorReaderCustomIo<ErrType,
   input: R,
   input_eof: bool,
   error_if_invalid_data: Option<ErrType>,
-  state: BrotliEncoderStateStruct<Alloc>,
+  state: StateWrapper<Alloc>,
+}
+struct StateWrapper<Alloc:BrotliAlloc>(BrotliEncoderStateStruct<Alloc>);
+
+impl<Alloc: BrotliAlloc> Drop for StateWrapper <Alloc> {
+    fn drop(&mut self) {
+        BrotliEncoderDestroyInstance(&mut self.0);
+    }
 }
 
 impl<ErrType,
@@ -145,13 +158,13 @@ CompressorReaderCustomIo<ErrType, R, BufferType, Alloc>
             input_len : 0,
             input_eof : false,
             input: r,
-            state : BrotliEncoderCreateInstance(alloc),
+            state : StateWrapper(BrotliEncoderCreateInstance(alloc)),
             error_if_invalid_data : Some(invalid_data_error_type),
         };
-        BrotliEncoderSetParameter(&mut ret.state,
+        BrotliEncoderSetParameter(&mut ret.state.0,
                                   BrotliEncoderParameter::BROTLI_PARAM_QUALITY,
                                   q as (u32));
-        BrotliEncoderSetParameter(&mut ret.state,
+        BrotliEncoderSetParameter(&mut ret.state.0,
                                   BrotliEncoderParameter::BROTLI_PARAM_LGWIN,
                                   lgwin as (u32));
 
@@ -169,21 +182,26 @@ CompressorReaderCustomIo<ErrType, R, BufferType, Alloc>
             self.input_offset = 0;
         }
     }
-
+    pub fn into_inner(self) -> R{
+      match self {
+        CompressorReaderCustomIo {
+          input_buffer:_ib,
+          total_out:_to,
+          input_offset: _io,
+          input_len: _len,
+          input,
+          input_eof:_ieof,
+          error_if_invalid_data: _eiid,
+          state: _state,
+        } => {
+          input
+        }
+      }
+    }
     pub fn get_ref(&self) -> &R {
         &self.input
     }
 }
-
-impl<ErrType,
-     R: CustomRead<ErrType>,
-     BufferType : SliceWrapperMut<u8>,
-     Alloc: BrotliAlloc> Drop for
-CompressorReaderCustomIo<ErrType, R, BufferType, Alloc> {
-    fn drop(&mut self) {
-        BrotliEncoderDestroyInstance(&mut self.state);
-    }
-}
 impl<ErrType,
      R: CustomRead<ErrType>,
      BufferType : SliceWrapperMut<u8>,
@@ -215,7 +233,7 @@ CompressorReaderCustomIo<ErrType, R, BufferType, Alloc> {
                 op = BrotliEncoderOperation::BROTLI_OPERATION_PROCESS;
             }
             let ret = BrotliEncoderCompressStream(
-                &mut self.state,
+                &mut self.state.0,
                 op,
                 &mut avail_in,
                 &self.input_buffer.slice_mut()[..],
@@ -231,7 +249,7 @@ CompressorReaderCustomIo<ErrType, R, BufferType, Alloc> {
             if ret <= 0 {
                 return Err(self.error_if_invalid_data.take().unwrap());
             }
-            let fin = BrotliEncoderIsFinished(&mut self.state);
+            let fin = BrotliEncoderIsFinished(&mut self.state.0);
             if fin != 0 {
                 break;
             }
@@ -241,152 +259,3 @@ CompressorReaderCustomIo<ErrType, R, BufferType, Alloc> {
 }
 
 
-
-/*
-
-/////////////////BOGUS////////////////////////////////////
-pub struct SimpleReader<R: Read,
-                        BufferType: SliceWrapperMut<u8>>
-{
-  input_buffer: BufferType,
-  total_out: Option<usize>,
-  input_offset: usize,
-  input_len: usize,
-  input_eof: bool,
-  input: R,
-  error_if_invalid_data: Option<io::Error>,
-  read_error: Option<io::Error>,
-  state: BrotliEncoderStateStruct<HeapAlloc<u8>, HeapAlloc<u16>, HeapAlloc<u32>, HeapAlloc<i32>, HeapAlloc<Command>>,
-}
-
-impl<R: Read,
-     BufferType : SliceWrapperMut<u8>>
-SimpleReader<R, BufferType>
-{
-
-    pub fn new(r: R, buffer : BufferType,
-               q: u32,
-               lgwin: u32) -> Option<Self> {
-        let mut ret = SimpleReader{
-            input_buffer : buffer,
-            total_out : Some(0),
-            input_offset : 0,
-            input_len : 0,
-            input_eof : false,
-            input: r,
-            state : BrotliEncoderCreateInstance(HeapAlloc{default_value:0},
-                                                HeapAlloc{default_value:0},
-                                                HeapAlloc{default_value:0},
-                                                HeapAlloc{default_value:0},
-                                                HeapAlloc{default_value:Command::default()}),
-            error_if_invalid_data : Some(Error::new(ErrorKind::InvalidData,
-                         "Invalid Data")),
-            read_error : None,
-        };
-        BrotliEncoderSetParameter(&mut ret.state,
-                                  BrotliEncoderParameter::BROTLI_PARAM_QUALITY,
-                                  q as (u32));
-        BrotliEncoderSetParameter(&mut ret.state,
-                                  BrotliEncoderParameter::BROTLI_PARAM_LGWIN,
-                                  lgwin as (u32));
-
-        Some(ret)
-    }
-    pub fn copy_to_front(&mut self) {
-        let avail_in = self.input_len - self.input_offset;
-        if self.input_offset == self.input_buffer.slice_mut().len() {
-            self.input_offset = 0;
-            self.input_len = 0;
-        } else if self.input_offset + 256 > self.input_buffer.slice_mut().len() && avail_in < self.input_offset {
-            let (first, second) = self.input_buffer.slice_mut().split_at_mut(self.input_offset);
-            first[0..avail_in].clone_from_slice(&second[0..avail_in]);
-            self.input_len -= self.input_offset;
-            self.input_offset = 0;
-        }
-    }
-
-    pub fn get_ref(&self) -> &R {
-        &self.input
-    }
-}
-
-impl<R: Read,
-     BufferType : SliceWrapperMut<u8>> Drop for
-SimpleReader<R, BufferType> {
-    fn drop(&mut self) {
-        BrotliEncoderDestroyInstance(&mut self.state);
-    }
-}
-impl<R: Read,
-     BufferType : SliceWrapperMut<u8>> Read for
-SimpleReader<R, BufferType> {
-	fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
-        let mut nop_callback = |_data:&[interface::Command<input_pair::InputReferenceMut>]|();
-        let mut output_offset : usize = 0;
-        let mut avail_out = buf.len() - output_offset;
-        let mut avail_in = self.input_len - self.input_offset;
-        let mut needs_input = false;
-        while avail_out == buf.len() && (!needs_input || !self.input_eof) {
-            if self.input_len < self.input_buffer.slice_mut().len() && !self.input_eof {
-                match self.input.read(&mut self.input_buffer.slice_mut()[self.input_len..]) {
-                    Err(e) => {
-                        self.read_error = Some(e);
-                        self.input_eof = true;
-                    },
-                    Ok(size) => if size == 0 {
-                        self.input_eof = true;
-                    }else {
-                        needs_input = false;
-                        self.input_len += size;
-                        avail_in = self.input_len - self.input_offset;
-                    },
-                }
-            }
-            let op : BrotliEncoderOperation;
-            if avail_in == 0 {
-                op = BrotliEncoderOperation::BROTLI_OPERATION_FINISH;
-            } else {
-                op = BrotliEncoderOperation::BROTLI_OPERATION_PROCESS;
-            }
-            let ret = BrotliEncoderCompressStream(
-                &mut self.state,
-                &mut HeapAlloc{default_value:0},
-                &mut HeapAlloc{default_value:0.0},
-                &mut HeapAlloc{default_value:Mem256f::default()},
-                &mut HeapAlloc{default_value:HistogramLiteral::default()},
-                &mut HeapAlloc{default_value:HistogramCommand::default()},
-                &mut HeapAlloc{default_value:HistogramDistance::default()},
-                &mut HeapAlloc{default_value:HistogramPair::default()},
-                &mut HeapAlloc{default_value:ContextType::default()},
-                &mut HeapAlloc{default_value:HuffmanTree::default()},
-                &mut HeapAlloc{default_value:ZopfliNode::default()},
-                op,
-                &mut avail_in,
-                &self.input_buffer.slice_mut()[..],
-                &mut self.input_offset,
-                &mut avail_out,
-                buf,
-                &mut output_offset,
-                &mut self.total_out,
-                &mut nop_callback);
-          if avail_in == 0 {
-            match self.read_error.take() {
-              Some(err) => return Err(err),
-              None => {
-                needs_input = true;
-                self.copy_to_front();
-              },
-            }
-          }
-          if ret <= 0 {
-              return Err(self.error_if_invalid_data.take().unwrap());
-          }
-          let fin = BrotliEncoderIsFinished(&mut self.state);
-          if fin != 0 {
-              break;
-          }
-        }
-        Ok(output_offset)
-      }
-}
- */
diff --git a/src/enc/test.rs b/src/enc/test.rs
@@ -219,7 +219,6 @@ fn oneshot_decompress(compressed: &[u8], mut output: &mut [u8]) -> (BrotliResult
                                       &mut output,
                                       &mut written,
                                       &mut brotli_state);
-  brotli_state.BrotliStateCleanup();
   return (result, input_offset, output_offset);
 
 }
diff --git a/src/enc/writer.rs b/src/enc/writer.rs
@@ -1,4 +1,5 @@
 #![cfg_attr(not(feature="std"), allow(unused_imports))]
+use core;
 use super::encode::{BrotliEncoderCreateInstance, BrotliEncoderDestroyInstance,
                     BrotliEncoderParameter, BrotliEncoderSetParameter, BrotliEncoderOperation,
                     BrotliEncoderStateStruct, BrotliEncoderCompressStream, BrotliEncoderIsFinished};
@@ -56,6 +57,9 @@ impl<W: Write,
     pub fn get_ref(&self) -> &W {
       &self.0.get_ref().0
     }
+    pub fn into_inner(self) -> W {
+      self.0.into_inner().0
+    }
 }
 
 #[cfg(feature="std")]
@@ -101,6 +105,9 @@ impl<W: Write> CompressorWriter<W> {
   pub fn get_ref(&self) -> &W {
     self.0.get_ref()
   }
+  pub fn into_inner(self) -> W {
+    self.0.into_inner()
+  }
 }
 
 
@@ -122,7 +129,7 @@ pub struct CompressorWriterCustomIo<ErrType,
 {
   output_buffer: BufferType,
   total_out: Option<usize>,
-  output: W,
+  output: Option<W>,
   error_if_invalid_data: Option<ErrType>,
   state: BrotliEncoderStateStruct<Alloc>,
 }
@@ -150,7 +157,7 @@ CompressorWriterCustomIo<ErrType, W, BufferType, Alloc>
         let mut ret = CompressorWriterCustomIo{
             output_buffer : buffer,
             total_out : Some(0),
-            output: w,
+            output: Some(w),
             state : BrotliEncoderCreateInstance(alloc),
             error_if_invalid_data : Some(invalid_data_error_type),
         };
@@ -185,7 +192,7 @@ CompressorWriterCustomIo<ErrType, W, BufferType, Alloc>
                 &mut self.total_out,
                 &mut nop_callback);
            if output_offset > 0 {
-             match write_all(&mut self.output, &self.output_buffer.slice_mut()[..output_offset]) {
+             match write_all(self.output.as_mut().unwrap(), &self.output_buffer.slice_mut()[..output_offset]) {
                Ok(_) => {},
                Err(e) => return Err(e),
              }
@@ -203,7 +210,10 @@ CompressorWriterCustomIo<ErrType, W, BufferType, Alloc>
     }
 
     pub fn get_ref(&self) -> &W {
-      &self.output
+      self.output.as_ref().unwrap()
+    }
+    pub fn into_inner(mut self) -> W {
+      core::mem::replace(&mut self.output, None).unwrap()
     }
 }
 
@@ -246,7 +256,7 @@ CompressorWriterCustomIo<ErrType, W, BufferType, Alloc> {
                 &mut self.total_out,
                 &mut nop_callback);
            if output_offset > 0 {
-             match write_all(&mut self.output, &self.output_buffer.slice_mut()[..output_offset]) {
+             match write_all(self.output.as_mut().unwrap(), &self.output_buffer.slice_mut()[..output_offset]) {
               Ok(_) => {},
               Err(e) => return Err(e),
              }
@@ -262,6 +272,6 @@ CompressorWriterCustomIo<ErrType, W, BufferType, Alloc> {
               Ok(_) => {},
               Err(e) => return Err(e),
         }
-        self.output.flush()
+        self.output.as_mut().unwrap().flush()
       }
 }

Original file line number	Diff line number	Diff line change
`@@ -183,7 +183,6 @@ fn decompress_internal<InputType, OutputType, Run: Runner>(r: &mut InputType,`
`183`	`183`	`available_out = output.slice().len()`
`184`	`184`	`}`
`185`	`185`	`}`
`186`		`- brotli_state.BrotliStateCleanup();`
`187`	`186`	`});`
`188`	`187`	`if timing_error {`
`189`	`188`	`let _r = super::writeln0(&mut io::stderr(), "Timing error");`
Original file line number	Diff line number	Diff line change
`@@ -219,7 +219,6 @@ fn oneshot_decompress(compressed: &[u8], mut output: &mut [u8]) -> (BrotliResult`
`219`	`219`	`&mut output,`
`220`	`220`	`&mut written,`
`221`	`221`	`&mut brotli_state);`
`222`		`- brotli_state.BrotliStateCleanup();`
`223`	`222`	`return (result, input_offset, output_offset);`
`224`	`223`
`225`	`224`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`#![cfg_attr(not(feature="std"), allow(unused_imports))]`
	`2`	`+use core;`
`2`	`3`	`use super::encode::{BrotliEncoderCreateInstance, BrotliEncoderDestroyInstance,`
`3`	`4`	`BrotliEncoderParameter, BrotliEncoderSetParameter, BrotliEncoderOperation,`
`4`	`5`	`BrotliEncoderStateStruct, BrotliEncoderCompressStream, BrotliEncoderIsFinished};`
`@@ -56,6 +57,9 @@ impl<W: Write,`
`56`	`57`	`pub fn get_ref(&self) -> &W {`
`57`	`58`	`&self.0.get_ref().0`
`58`	`59`	`}`
	`60`	`+ pub fn into_inner(self) -> W {`
	`61`	`+ self.0.into_inner().0`
	`62`	`+ }`
`59`	`63`	`}`
`60`	`64`
`61`	`65`	`#[cfg(feature="std")]`
`@@ -101,6 +105,9 @@ impl<W: Write> CompressorWriter<W> {`
`101`	`105`	`pub fn get_ref(&self) -> &W {`
`102`	`106`	`self.0.get_ref()`
`103`	`107`	`}`
	`108`	`+ pub fn into_inner(self) -> W {`
	`109`	`+ self.0.into_inner()`
	`110`	`+ }`
`104`	`111`	`}`
`105`	`112`
`106`	`113`
`@@ -122,7 +129,7 @@ pub struct CompressorWriterCustomIo<ErrType,`
`122`	`129`	`{`
`123`	`130`	`output_buffer: BufferType,`
`124`	`131`	`total_out: Option<usize>,`
`125`		`- output: W,`
	`132`	`+ output: Option<W>,`
`126`	`133`	`error_if_invalid_data: Option<ErrType>,`
`127`	`134`	`state: BrotliEncoderStateStruct<Alloc>,`
`128`	`135`	`}`
`@@ -150,7 +157,7 @@ CompressorWriterCustomIo<ErrType, W, BufferType, Alloc>`
`150`	`157`	`let mut ret = CompressorWriterCustomIo{`
`151`	`158`	`output_buffer : buffer,`
`152`	`159`	`total_out : Some(0),`
`153`		`- output: w,`
	`160`	`+ output: Some(w),`
`154`	`161`	`state : BrotliEncoderCreateInstance(alloc),`
`155`	`162`	`error_if_invalid_data : Some(invalid_data_error_type),`
`156`	`163`	`};`
`@@ -185,7 +192,7 @@ CompressorWriterCustomIo<ErrType, W, BufferType, Alloc>`
`185`	`192`	`&mut self.total_out,`
`186`	`193`	`&mut nop_callback);`
`187`	`194`	`if output_offset > 0 {`
`188`		`- match write_all(&mut self.output, &self.output_buffer.slice_mut()[..output_offset]) {`
	`195`	`+ match write_all(self.output.as_mut().unwrap(), &self.output_buffer.slice_mut()[..output_offset]) {`
`189`	`196`	`Ok(_) => {},`
`190`	`197`	`Err(e) => return Err(e),`
`191`	`198`	`}`
`@@ -203,7 +210,10 @@ CompressorWriterCustomIo<ErrType, W, BufferType, Alloc>`
`203`	`210`	`}`
`204`	`211`
`205`	`212`	`pub fn get_ref(&self) -> &W {`
`206`		`- &self.output`
	`213`	`+ self.output.as_ref().unwrap()`
	`214`	`+ }`
	`215`	`+ pub fn into_inner(mut self) -> W {`
	`216`	`+ core::mem::replace(&mut self.output, None).unwrap()`
`207`	`217`	`}`
`208`	`218`	`}`
`209`	`219`
`@@ -246,7 +256,7 @@ CompressorWriterCustomIo<ErrType, W, BufferType, Alloc> {`
`246`	`256`	`&mut self.total_out,`
`247`	`257`	`&mut nop_callback);`
`248`	`258`	`if output_offset > 0 {`
`249`		`- match write_all(&mut self.output, &self.output_buffer.slice_mut()[..output_offset]) {`
	`259`	`+ match write_all(self.output.as_mut().unwrap(), &self.output_buffer.slice_mut()[..output_offset]) {`
`250`	`260`	`Ok(_) => {},`
`251`	`261`	`Err(e) => return Err(e),`
`252`	`262`	`}`
`@@ -262,6 +272,6 @@ CompressorWriterCustomIo<ErrType, W, BufferType, Alloc> {`
`262`	`272`	`Ok(_) => {},`
`263`	`273`	`Err(e) => return Err(e),`
`264`	`274`	`}`
`265`		`- self.output.flush()`
	`275`	`+ self.output.as_mut().unwrap().flush()`
`266`	`276`	`}`
`267`	`277`	`}`