src/libdelimit.rs

@@ -18,66 +18,66 @@
  */
 
 use std::{
-    io::{ Read, Result },
+	io::{ Read, Result },
-    mem,
+	mem,
 };
 
 const BUFFER_SIZE: usize = 4096;
 
 pub struct Delimited<T: Read> {
-    delimiter: Vec<u8>,
+	delimiter: Vec<u8>,
-    buffer: Vec<u8>,
+	buffer: Vec<u8>,
-    stream: T,
+	stream: T,
 }
 
 impl<T> Delimited<T> where T: Read {
 	pub fn new(stream: T, delimiter: &[u8]) -> Self {
-        Delimited {
+		Delimited {
-            stream,
+			stream,
-            delimiter: delimiter.to_vec(),
+			delimiter: delimiter.to_vec(),
-            buffer: Vec::with_capacity(BUFFER_SIZE),
+			buffer: Vec::with_capacity(BUFFER_SIZE),
-        }
+		}
-    }
+	}
 }
 
 impl<T> Iterator for Delimited<T> where T: Read {
-    type Item = Result<Vec<u8>>;
+	type Item = Result<Vec<u8>>;
 
-    fn next(&mut self) -> Option<Self::Item> {
+	fn next(&mut self) -> Option<Self::Item> {
-        let mut buf = [0; BUFFER_SIZE];
+		let mut buf = [0; BUFFER_SIZE];
 
-        loop {
+		loop {
-            if let Some(p) = find_subslice(&self.buffer, &self.delimiter) {
+			if let Some(p) = find_subslice(&self.buffer, &self.delimiter) {
-                let chunk = self.buffer.drain(..p).collect::<Vec<_>>();
+				let chunk = self.buffer.drain(..p).collect::<Vec<_>>();
 				
-                let _ = self.buffer.drain(..self.delimiter.len());
+				let _ = self.buffer.drain(..self.delimiter.len());
 
-                return Some(Ok(chunk));
+				return Some(Ok(chunk));
-            }
+			}
 
-            match self.stream.read(&mut buf) {
+			match self.stream.read(&mut buf) {
-                Ok(0) => {
+				Ok(0) => {
-                    let _ = self.buffer.is_empty() && return None;
+					let _ = self.buffer.is_empty() && return None;
 
-                    return Some(Ok(mem::take(&mut self.buffer)));
+					return Some(Ok(mem::take(&mut self.buffer)));
-                },
+				},
-                Ok(n) => {
+				Ok(n) => {
-                    self.buffer.extend_from_slice(&buf[..n]);
+					self.buffer.extend_from_slice(&buf[..n]);
-                },
+				},
-                Err(e) => {
+				Err(e) => {
-                    return Some(Err(e));
+					return Some(Err(e));
-                },
+				},
-            }
+			}
-        }
+		}
-    }
+	}
 }
 
 fn find_subslice(stack: &[u8], key: &[u8]) -> Option<usize> {
-    match key.len() {
+	match key.len() {
-    	/* TODO: is this optimization necessary? */
+		/* TODO: is this optimization necessary? */
-        1 => stack.iter().position(|&b| b == key[0]),
+		1 => stack.iter().position(|&b| b == key[0]),
-        _ => stack.windows(key.len()).position(|w| w == key),
+		_ => stack.windows(key.len()).position(|w| w == key),
-    }
+	}
 }
 
 #[cfg(test)]