From 03202842367892f8f18714775fd05edac6998364 Mon Sep 17 00:00:00 2001 From: Justus Winter Date: Mon, 30 Apr 2018 18:11:53 +0200 Subject: openpgp: Rename 'BufferedReaderState' to 'Cookie'. - The former is too unwieldy, and both are equally expressive in this context. --- openpgp/src/parse/hashed_reader.rs | 38 +++++------ openpgp/src/parse/message_parser.rs | 10 +-- openpgp/src/parse/parse.rs | 132 ++++++++++++++++++------------------ openpgp/src/parse/partial_body.rs | 34 +++++----- 4 files changed, 107 insertions(+), 107 deletions(-) diff --git a/openpgp/src/parse/hashed_reader.rs b/openpgp/src/parse/hashed_reader.rs index 1f3b67dd..b95e1aaa 100644 --- a/openpgp/src/parse/hashed_reader.rs +++ b/openpgp/src/parse/hashed_reader.rs @@ -12,25 +12,25 @@ use buffered_reader::buffered_reader_generic_read_impl; use Result; use HashAlgo; -use parse::{BufferedReaderState, HashesFor}; +use parse::{Cookie, HashesFor}; use super::indent; const TRACE : bool = false; #[derive(Debug)] -pub struct HashedReader> { +pub struct HashedReader> { reader: R, - cookie: BufferedReaderState, + cookie: Cookie, } -impl> HashedReader { +impl> HashedReader { /// Instantiates a new hashed reader. `hashes_for` is the hash's /// purpose. `algos` is a list of algorithms for which we should /// compute the hash. pub fn new(reader: R, hashes_for: HashesFor, algos: Vec) -> Self { - let mut cookie = BufferedReaderState::default(); + let mut cookie = Cookie::default(); for &algo in &algos { cookie.hashes.push((algo, algo.context().unwrap())); } @@ -43,7 +43,7 @@ impl> HashedReader { } } -impl BufferedReaderState { +impl Cookie { fn hash_update(&mut self, data: &[u8]) { if TRACE { eprintln!("{}hash_update({} bytes, {} hashes, enabled: {})", @@ -75,7 +75,7 @@ impl BufferedReaderState { } } -impl> io::Read for HashedReader { +impl> io::Read for HashedReader { fn read(&mut self, buf: &mut [u8]) -> io::Result { return buffered_reader_generic_read_impl(self, buf); } @@ -83,8 +83,8 @@ impl> io::Read for HashedReader { // Wrap a BufferedReader so that any data that is consumed is added to // the hash. -impl> - BufferedReader for HashedReader { +impl> + BufferedReader for HashedReader { fn buffer(&self) -> &[u8] { self.reader.buffer() } @@ -101,7 +101,7 @@ impl> // We need to take the state rather than get a mutable // reference to it, because self.reader.buffer() requires a // reference as well. - let mut state = self.cookie_set(BufferedReaderState::default()); + let mut state = self.cookie_set(Cookie::default()); { // The inner buffered reader must return at least `amount` @@ -122,7 +122,7 @@ impl> // See consume() for an explanation of the following // acrobatics. - let mut state = self.cookie_set(BufferedReaderState::default()); + let mut state = self.cookie_set(Cookie::default()); let got = { let data = self.reader.data(amount)?; @@ -145,7 +145,7 @@ impl> // See consume() for an explanation of the following // acrobatics. - let mut state = self.cookie_set(BufferedReaderState::default()); + let mut state = self.cookie_set(Cookie::default()); { let data = self.reader.data_hard(amount)?; @@ -160,34 +160,34 @@ impl> result } - fn get_mut(&mut self) -> Option<&mut BufferedReader> { + fn get_mut(&mut self) -> Option<&mut BufferedReader> { Some(&mut self.reader) } - fn get_ref(&self) -> Option<&BufferedReader> { + fn get_ref(&self) -> Option<&BufferedReader> { Some(&self.reader) } fn into_inner<'b>(self: Box) - -> Option + 'b>> + -> Option + 'b>> where Self: 'b { Some(Box::new(self.reader)) } - fn cookie_set(&mut self, cookie: BufferedReaderState) -> BufferedReaderState { + fn cookie_set(&mut self, cookie: Cookie) -> Cookie { mem::replace(&mut self.cookie, cookie) } - fn cookie_ref(&self) -> &BufferedReaderState { + fn cookie_ref(&self) -> &Cookie { &self.cookie } - fn cookie_mut(&mut self) -> &mut BufferedReaderState { + fn cookie_mut(&mut self) -> &mut Cookie { &mut self.cookie } } -impl HashedReader> { +impl HashedReader> { /// Hash the specified file. /// /// This is useful when verifying detached signatures. diff --git a/openpgp/src/parse/message_parser.rs b/openpgp/src/parse/message_parser.rs index 25ed5166..1b1b7fd7 100644 --- a/openpgp/src/parse/message_parser.rs +++ b/openpgp/src/parse/message_parser.rs @@ -5,7 +5,7 @@ use std::path::Path; use Result; use super::{PacketParserBuilder, PacketParser, Packet, Container, Message, - BufferedReaderState}; + Cookie}; use buffered_reader::{BufferedReader, BufferedReaderGeneric, BufferedReaderMemory}; @@ -84,7 +84,7 @@ pub struct MessageParser<'a> { message: Message, } -impl> PacketParserBuilder { +impl> PacketParserBuilder { /// Finishes configuring the `PacketParser` and returns a /// `MessageParser`. pub fn to_message_parser<'a>(self) -> Result> @@ -106,7 +106,7 @@ impl<'a> MessageParser<'a> { /// Creates a `MessageParser` to parse the OpenPGP message stored /// in the `BufferedReader` object. - pub fn from_buffered_reader + 'a>(bio: R) + pub fn from_buffered_reader + 'a>(bio: R) -> Result> { Self::from_packet_parser(PacketParser::from_buffered_reader(bio)?) } @@ -116,7 +116,7 @@ impl<'a> MessageParser<'a> { pub fn from_reader(reader: R) -> Result> { let bio = BufferedReaderGeneric::with_cookie( - reader, None, BufferedReaderState::default()); + reader, None, Cookie::default()); MessageParser::from_buffered_reader(bio) } @@ -132,7 +132,7 @@ impl<'a> MessageParser<'a> { pub fn from_bytes(data: &'a [u8]) -> Result> { let bio = BufferedReaderMemory::with_cookie( - data, BufferedReaderState::default()); + data, Cookie::default()); MessageParser::from_buffered_reader(bio) } diff --git a/openpgp/src/parse/parse.rs b/openpgp/src/parse/parse.rs index 69ed8eb0..7e3fa9e6 100644 --- a/openpgp/src/parse/parse.rs +++ b/openpgp/src/parse/parse.rs @@ -263,7 +263,7 @@ impl Header { impl S2K { pub fn parse_naked(r: R) -> io::Result { let bio = BufferedReaderGeneric::with_cookie( - r, None, BufferedReaderState::default()); + r, None, Cookie::default()); let mut parser = PacketParser::new_naked(Box::new(bio)); Self::parse(&mut parser) } @@ -314,17 +314,17 @@ impl Unknown { pub fn to_unknown_packet(reader: R) -> Result { let mut reader = BufferedReaderGeneric::with_cookie( - reader, None, BufferedReaderState::default()); + reader, None, Cookie::default()); let header = Header::parse(&mut reader)?; - let reader : Box> + let reader : Box> = match header.length { BodyLength::Full(len) => Box::new(BufferedReaderLimitor::with_cookie( - Box::new(reader), len as u64, BufferedReaderState::default())), + Box::new(reader), len as u64, Cookie::default())), BodyLength::Partial(len) => Box::new(BufferedReaderPartialBodyFilter::with_cookie( - reader, len, true, BufferedReaderState::default())), + reader, len, true, Cookie::default())), _ => Box::new(reader), }; @@ -344,7 +344,7 @@ pub fn to_unknown_packet(reader: R) impl Signature { fn parse_naked(value: &[u8]) -> Result { let bio = BufferedReaderMemory::with_cookie( - value, BufferedReaderState::default()); + value, Cookie::default()); let parser = PacketParser::new_naked(Box::new(bio)); let mut pp = Signature::parse(parser, None)?; @@ -503,7 +503,7 @@ impl OnePassSig { // discards any following packets. To prevent this, we push a // Limitor on the reader stack. let mut reader = BufferedReaderLimitor::with_cookie( - Box::new(reader), 0, BufferedReaderState::default()); + Box::new(reader), 0, Cookie::default()); reader.cookie_mut().level = Some(recursion_depth as isize); pp.state = State::Body(Box::new(reader)); @@ -710,7 +710,7 @@ impl Literal { bio.data_consume_hard(total_out).unwrap(); // Enable hashing of the body. - BufferedReaderState::hashing( + Cookie::hashing( &mut bio, true, recursion_depth as isize - 1); Ok((bio, ())) })?; @@ -792,7 +792,7 @@ impl CompressedData { // fail. bio.data_consume_hard(total_out).unwrap(); - let bio : Box> = match algo { + let bio : Box> = match algo { 0 => { if TRACE { eprintln!("CompressedData::parse(): Actually, no need \ @@ -805,17 +805,17 @@ impl CompressedData { 1 => { // Zip. Box::new(BufferedReaderDeflate::with_cookie( - bio, BufferedReaderState::new(recursion_depth))) + bio, Cookie::new(recursion_depth))) }, 2 => { // Zlib Box::new(BufferedReaderZlib::with_cookie( - bio, BufferedReaderState::new(recursion_depth))) + bio, Cookie::new(recursion_depth))) }, 3 => { // BZip2 Box::new(BufferedReaderBzip::with_cookie( - bio, BufferedReaderState::new(recursion_depth))) + bio, Cookie::new(recursion_depth))) }, _ => unreachable!(), // Validated above. }; @@ -930,7 +930,7 @@ impl MDC { let mut computed_hash : [u8; 20] = Default::default(); { - let mut r : Option<&mut BufferedReader> + let mut r : Option<&mut BufferedReader> = pp.get_mut(); while let Some(bio) = r { { @@ -1049,17 +1049,17 @@ impl Default for PacketParserSettings { /// will only be needed in exceptional circumstances. Instead use, /// for instance, `PacketParser::from_file` or /// `PacketParser::from_reader` to start parsing an OpenPGP message. -pub struct PacketParserBuilder> { +pub struct PacketParserBuilder> { bio: R, settings: PacketParserSettings, } -impl> PacketParserBuilder { +impl> PacketParserBuilder { /// Creates a `PacketParserBuilder` for an OpenPGP message stored /// in a `BufferedReader` object. /// /// Note: this clears the `level` field of the - /// `BufferedReaderState` cookie. + /// `Cookie` cookie. pub fn from_buffered_reader(mut bio: R) -> Result> { bio.cookie_mut().level = None; @@ -1173,45 +1173,45 @@ impl> PacketParserBuilder { } impl<'a, R: io::Read + 'a> - PacketParserBuilder> { + PacketParserBuilder> { /// Creates a `PacketParserBuilder` for an OpenPGP message stored /// in a `std::io::Read` object. pub fn from_reader(reader: R) -> Result>> { + BufferedReaderGeneric>> { Ok(PacketParserBuilder { bio: BufferedReaderGeneric::with_cookie( - reader, None, BufferedReaderState::default()), + reader, None, Cookie::default()), settings: PacketParserSettings::default(), }) } } -impl PacketParserBuilder> { +impl PacketParserBuilder> { /// Creates a `PacketParserBuilder` for an OpenPGP message stored /// in the file named `path`. pub fn from_file>(path: P) -> Result>> { + BufferedReaderGeneric>> { PacketParserBuilder::from_reader(File::open(path)?) } } -impl <'a> PacketParserBuilder> { +impl <'a> PacketParserBuilder> { /// Creates a `PacketParserBuilder` for an OpenPGP message stored /// in specified buffer. pub fn from_bytes(bytes: &'a [u8]) -> Result>> { + BufferedReaderMemory<'a, Cookie>>> { PacketParserBuilder::from_buffered_reader( BufferedReaderMemory::with_cookie( - bytes, BufferedReaderState::default())) + bytes, Cookie::default())) } } use nettle::Hash; -/// What the hash in the BufferedReaderState is for. +/// What the hash in the Cookie is for. #[derive(Clone, PartialEq, Debug)] pub enum HashesFor { Nothing, @@ -1219,7 +1219,7 @@ pub enum HashesFor { Signature, } -pub struct BufferedReaderState { +pub struct Cookie { // `BufferedReader`s managed by a `PacketParser` have // `Some(level)`; an external `BufferedReader` (i.e., the // underlying `BufferedReader`) has no level. @@ -1275,13 +1275,13 @@ pub struct BufferedReaderState { hashes: Vec<(HashAlgo, Box)>, } -impl fmt::Debug for BufferedReaderState { +impl fmt::Debug for Cookie { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let algos = self.hashes.iter() .map(|&(algo, _)| algo) .collect::>(); - f.debug_struct("BufferedReaderState") + f.debug_struct("Cookie") .field("level", &self.level) .field("hashes_for", &self.hashes_for) .field("hashes", &algos) @@ -1289,9 +1289,9 @@ impl fmt::Debug for BufferedReaderState { } } -impl Default for BufferedReaderState { +impl Default for Cookie { fn default() -> Self { - BufferedReaderState { + Cookie { level: None, hashing: true, hashes_for: HashesFor::Nothing, @@ -1300,9 +1300,9 @@ impl Default for BufferedReaderState { } } -impl BufferedReaderState { - fn new(recursion_depth: usize) -> BufferedReaderState { - BufferedReaderState { +impl Cookie { + fn new(recursion_depth: usize) -> Cookie { + Cookie { level: Some(recursion_depth as isize), hashing: true, hashes_for: HashesFor::Nothing, @@ -1311,15 +1311,15 @@ impl BufferedReaderState { } } -impl BufferedReaderState { +impl Cookie { // Enables or disables signature hashers (HashesFor::Signature) at // level `level`. // // Thus to disable the hashing of a level 3 literal packet's // meta-data, we disable hashing at level 2. - fn hashing(reader: &mut BufferedReader, + fn hashing(reader: &mut BufferedReader, enabled: bool, level: isize) { - let mut reader : Option<&mut BufferedReader> + let mut reader : Option<&mut BufferedReader> = Some(reader); while let Some(r) = reader { { @@ -1346,8 +1346,8 @@ impl BufferedReaderState { // If the reader stack is owned by a PacketParser, it is up to the // caller to adjust PacketParser::recursion_depth, etc. appropriately! fn buffered_reader_stack_pop<'a>( - mut reader: Box + 'a>, depth: isize) - -> Box + 'a> + mut reader: Box + 'a>, depth: isize) + -> Box + 'a> { while let Some(level) = reader.cookie_ref().level { assert!(level <= depth); @@ -1449,7 +1449,7 @@ pub struct PacketParser<'a> { settings: PacketParserSettings, // The cookie. - cookie: BufferedReaderState, + cookie: Cookie, } // PacketParser states. @@ -1462,7 +1462,7 @@ enum State<'a> { // While we are parsing the framing and headers, we dup the inner // reader so that if the parsing fails, we return an unknown // packet with the body intact. - Header(Box>), + Header(Box>), // The inner reader. // @@ -1473,7 +1473,7 @@ enum State<'a> { // what happens when we parse a compressed data packet: we return // a Decompressor (in fact, the actual type is only known at // run-time!). - Body(Box<'a + BufferedReader>), + Body(Box<'a + BufferedReader>), } impl <'a> std::fmt::Debug for PacketParser<'a> { @@ -1492,7 +1492,7 @@ impl <'a> std::fmt::Debug for PacketParser<'a> { // The return value of PacketParser::parse. enum ParserResult<'a> { Success(PacketParser<'a>), - EOF(Box + 'a>), + EOF(Box + 'a>), } impl <'a> PacketParser<'a> { @@ -1500,7 +1500,7 @@ impl <'a> PacketParser<'a> { /// /// This function returns a `PacketParser` for the first packet in /// the stream. - pub fn from_buffered_reader + 'a>(bio: R) + pub fn from_buffered_reader + 'a>(bio: R) -> Result>> { PacketParserBuilder::from_buffered_reader(bio)?.finalize() } @@ -1532,7 +1532,7 @@ impl <'a> PacketParser<'a> { PacketParserBuilder::from_bytes(bytes)?.finalize() } - fn new(inner: Box<'a + BufferedReader>, + fn new(inner: Box<'a + BufferedReader>, settings: PacketParserSettings, recursion_depth: u8, header: Header) -> Self { PacketParser { @@ -1552,7 +1552,7 @@ impl <'a> PacketParser<'a> { } } - fn new_naked(inner: Box<'a + BufferedReader>) + fn new_naked(inner: Box<'a + BufferedReader>) -> Self { PacketParser::new(inner, Default::default(), 0, Header { ctb: CTB::new(Tag::Reserved), @@ -1566,8 +1566,8 @@ impl <'a> PacketParser<'a> { } fn commit_then(&mut self, mut fun: F) -> Result - where F: FnMut(Box<'a + BufferedReader>, usize) - -> Result<(Box<'a + BufferedReader>, R)> { + where F: FnMut(Box<'a + BufferedReader>, usize) + -> Result<(Box<'a + BufferedReader>, R)> { // Steal the reader. let state = ::std::mem::replace( &mut self.state, @@ -1646,7 +1646,7 @@ impl <'a> PacketParser<'a> { // Returns a packet parser for the next OpenPGP packet in the // stream. If there are no packets left, this function returns // `bio`. - fn parse(mut bio: Box + 'a>, + fn parse(mut bio: Box + 'a>, settings: &PacketParserSettings, recursion_depth: usize) -> Result> { @@ -1678,7 +1678,7 @@ impl <'a> PacketParser<'a> { // which would cause the headers to be hashed. If so, we // extract the hash context. let mut bio = BufferedReaderDup::with_cookie( - bio, BufferedReaderState::default()); + bio, Cookie::default()); let header = Header::parse(&mut bio)?; let tag = header.ctb.tag; @@ -1744,12 +1744,12 @@ impl <'a> PacketParser<'a> { // one pass signature packet's hashes. if tag == Tag::Literal || tag == Tag::OnePassSig || tag == Tag::Signature { - BufferedReaderState::hashing( + Cookie::hashing( &mut bio, false, recursion_depth as isize - 1); } bio.consume(consumed); - let bio : Box> + let bio : Box> = match header.length { BodyLength::Full(len) => { if settings.trace { @@ -1760,7 +1760,7 @@ impl <'a> PacketParser<'a> { } Box::new(BufferedReaderLimitor::with_cookie( bio, len as u64, - BufferedReaderState::new(recursion_depth))) + Cookie::new(recursion_depth))) }, BodyLength::Partial(len) => { if settings.trace { @@ -1777,7 +1777,7 @@ impl <'a> PacketParser<'a> { // length information, which includes the // partial body headers. tag != Tag::Literal, - BufferedReaderState::new(recursion_depth))) + Cookie::new(recursion_depth))) }, BodyLength::Indeterminate => { if settings.trace { @@ -1810,7 +1810,7 @@ impl <'a> PacketParser<'a> { }?; if tag == Tag::OnePassSig { - BufferedReaderState::hashing( + Cookie::hashing( &mut result, true, recursion_depth as isize - 1); } @@ -2169,7 +2169,7 @@ impl<'a> io::Read for PacketParser<'a> { /// /// Note: it is safe to mix the use of the `std::io::Read` and /// `BufferedReader` interfaces. -impl<'a> BufferedReader for PacketParser<'a> { +impl<'a> BufferedReader for PacketParser<'a> { fn buffer(&self) -> &[u8] { match self.state { State::Header(ref reader) => reader.buffer(), @@ -2284,14 +2284,14 @@ impl<'a> BufferedReader for PacketParser<'a> { } } - fn get_mut(&mut self) -> Option<&mut BufferedReader> { + fn get_mut(&mut self) -> Option<&mut BufferedReader> { Some(match self.state { State::Header(ref mut reader) => reader.as_mut(), State::Body(ref mut reader) => reader, }) } - fn get_ref(&self) -> Option<&BufferedReader> { + fn get_ref(&self) -> Option<&BufferedReader> { Some(match self.state { State::Header(ref reader) => reader.as_ref(), State::Body(ref reader) => reader, @@ -2299,21 +2299,21 @@ impl<'a> BufferedReader for PacketParser<'a> { } fn into_inner<'b>(self: Box) - -> Option + 'b>> + -> Option + 'b>> where Self: 'b { None } - fn cookie_set(&mut self, cookie: BufferedReaderState) - -> BufferedReaderState { + fn cookie_set(&mut self, cookie: Cookie) + -> Cookie { ::std::mem::replace(&mut self.cookie, cookie) } - fn cookie_ref(&self) -> &BufferedReaderState { + fn cookie_ref(&self) -> &Cookie { &self.cookie } - fn cookie_mut(&mut self) -> &mut BufferedReaderState { + fn cookie_mut(&mut self) -> &mut Cookie { &mut self.cookie } } @@ -2434,7 +2434,7 @@ impl<'a> PacketParser<'a> { // This can't fail, because we create a decryptor above // with the same parameters. let mut reader = BufferedReaderDecryptor::with_cookie( - algo, key, reader, BufferedReaderState::default()).unwrap(); + algo, key, reader, Cookie::default()).unwrap(); reader.cookie_mut().level = Some(self.recursion_depth as isize); if self.settings.trace { @@ -2747,7 +2747,7 @@ impl Message { /// /// [`PacketParser`]: parse/struct.PacketParser.html /// [`MessageParser`]: parse/struct.MessageParser.html - pub fn from_buffered_reader>(bio: R) + pub fn from_buffered_reader>(bio: R) -> Result { PacketParserBuilder::from_buffered_reader(bio)? .buffer_unread_content() @@ -2760,7 +2760,7 @@ impl Message { /// See `from_buffered_reader` for more details and caveats. pub fn from_reader(reader: R) -> Result { let bio = BufferedReaderGeneric::with_cookie( - reader, None, BufferedReaderState::default()); + reader, None, Cookie::default()); Message::from_buffered_reader(bio) } @@ -2777,7 +2777,7 @@ impl Message { /// See `from_buffered_reader` for more details and caveats. pub fn from_bytes(data: &[u8]) -> Result { let bio = BufferedReaderMemory::with_cookie( - data, BufferedReaderState::default()); + data, Cookie::default()); Message::from_buffered_reader(bio) } } diff --git a/openpgp/src/parse/partial_body.rs b/openpgp/src/parse/partial_body.rs index 752a0adc..9604c4d2 100644 --- a/openpgp/src/parse/partial_body.rs +++ b/openpgp/src/parse/partial_body.rs @@ -5,14 +5,14 @@ use std::io::{Error,ErrorKind}; use buffered_reader::{buffered_reader_generic_read_impl, BufferedReader}; use super::BodyLength; -use super::BufferedReaderState; +use super::Cookie; const TRACE : bool = false; /// A `BufferedReader` that transparently handles OpenPGP's chunking /// scheme. This implicitly implements a limitor. -pub struct BufferedReaderPartialBodyFilter> { +pub struct BufferedReaderPartialBodyFilter> { // The underlying reader. reader: T, @@ -32,15 +32,15 @@ pub struct BufferedReaderPartialBodyFilter> std::fmt::Debug +impl> std::fmt::Debug for BufferedReaderPartialBodyFilter { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { f.debug_struct("BufferedReaderPartialBodyFilter") @@ -58,12 +58,12 @@ impl> std::fmt::Debug } } -impl> BufferedReaderPartialBodyFilter { +impl> BufferedReaderPartialBodyFilter { /// Create a new BufferedReaderPartialBodyFilter object. /// `partial_body_length` is the amount of data in the initial /// partial body chunk. pub fn with_cookie(reader: T, partial_body_length: u32, - hash_headers: bool, cookie: BufferedReaderState) -> Self { + hash_headers: bool, cookie: Cookie) -> Self { BufferedReaderPartialBodyFilter { reader: reader, partial_body_length: partial_body_length, @@ -157,7 +157,7 @@ impl> BufferedReaderPartialBodyFilter // Disable hashing, if necessary. if ! self.hash_headers { if let Some(level) = self.reader.cookie_ref().level { - BufferedReaderState::hashing( + Cookie::hashing( &mut self.reader, false, level); } } @@ -170,7 +170,7 @@ impl> BufferedReaderPartialBodyFilter if ! self.hash_headers { if let Some(level) = self.reader.cookie_ref().level { - BufferedReaderState::hashing( + Cookie::hashing( &mut self.reader, true, level); } } @@ -308,14 +308,14 @@ impl> BufferedReaderPartialBodyFilter } -impl> std::io::Read +impl> std::io::Read for BufferedReaderPartialBodyFilter { fn read(&mut self, buf: &mut [u8]) -> Result { return buffered_reader_generic_read_impl(self, buf); } } -impl> BufferedReader +impl> BufferedReader for BufferedReaderPartialBodyFilter { fn buffer(&self) -> &[u8] { if let Some(ref buffer) = self.buffer { @@ -364,30 +364,30 @@ impl> BufferedReader return self.data_helper(amount, true, true); } - fn get_mut(&mut self) -> Option<&mut BufferedReader> { + fn get_mut(&mut self) -> Option<&mut BufferedReader> { Some(&mut self.reader) } - fn get_ref(&self) -> Option<&BufferedReader> { + fn get_ref(&self) -> Option<&BufferedReader> { Some(&self.reader) } - fn into_inner<'b>(self: Box) -> Option + 'b>> + fn into_inner<'b>(self: Box) -> Option + 'b>> where Self: 'b { Some(Box::new(self.reader)) } - fn cookie_set(&mut self, cookie: BufferedReaderState) -> BufferedReaderState { + fn cookie_set(&mut self, cookie: Cookie) -> Cookie { use std::mem; mem::replace(&mut self.cookie, cookie) } - fn cookie_ref(&self) -> &BufferedReaderState { + fn cookie_ref(&self) -> &Cookie { &self.cookie } - fn cookie_mut(&mut self) -> &mut BufferedReaderState { + fn cookie_mut(&mut self) -> &mut Cookie { &mut self.cookie } } -- cgit v1.2.3