From 65b8f0063dd4ba3a3f263e4a81a3e5158a5db0ef Mon Sep 17 00:00:00 2001 From: Sebastian Thiel Date: Sat, 18 Jan 2020 14:46:53 +0800 Subject: [PATCH] Rewrite deprecated features, such as try! As taken from https://github.com/Byron/google-apis-rs/pull/247 --- src/mako/api/lib/mbuild.mako | 6 ++--- src/mako/lib/util.py | 8 +++---- src/rust/api/cmn.rs | 44 ++++++++++++++++++------------------ 3 files changed, 29 insertions(+), 29 deletions(-) diff --git a/src/mako/api/lib/mbuild.mako b/src/mako/api/lib/mbuild.mako index b854339972..03f01f1f9c 100644 --- a/src/mako/api/lib/mbuild.mako +++ b/src/mako/api/lib/mbuild.mako @@ -493,7 +493,7 @@ match result { use std::io::{Read, Seek}; use hyper::header::{ContentType, ContentLength, Authorization, Bearer, UserAgent, Location}; let mut dd = DefaultDelegate; - let mut dlg: &mut Delegate = match ${delegate} { + let mut dlg: &mut dyn Delegate = match ${delegate} { Some(d) => d, None => &mut dd }; @@ -722,9 +722,9 @@ else { mp_reader.add_part(&mut request_value_reader, request_size, json_mime_type.clone()) .add_part(&mut reader, size, reader_mime_type.clone()); let mime_type = mp_reader.mime_type(); - (&mut mp_reader as &mut io::Read, ContentType(mime_type)) + (&mut mp_reader as &mut dyn io::Read, ContentType(mime_type)) }, - _ => (&mut request_value_reader as &mut io::Read, ContentType(json_mime_type.clone())), + _ => (&mut request_value_reader as &mut dyn io::Read, ContentType(json_mime_type.clone())), }; % endif let mut client = &mut *self.hub.client.borrow_mut(); diff --git a/src/mako/lib/util.py b/src/mako/lib/util.py index 67d442ee44..6d03c89732 100644 --- a/src/mako/lib/util.py +++ b/src/mako/lib/util.py @@ -641,8 +641,8 @@ def build_all_params(c, m): params.insert(0, schema_to_required_property(request_value, REQUEST_VALUE_PROPERTY_NAME)) # add the delegate. It's a type parameter, which has to remain in sync with the type-parameters we actually build. dp = type(m)({ 'name': DELEGATE_PROPERTY_NAME, - TREF: "&'a mut %s" % DELEGATE_TYPE, - 'input_type': "&'a mut %s" % DELEGATE_TYPE, + TREF: "&'a mut dyn %s" % DELEGATE_TYPE, + 'input_type': "&'a mut dyn %s" % DELEGATE_TYPE, 'clone_value': '{}', 'skip_example' : True, 'priority': 0, @@ -855,10 +855,10 @@ def to_extern_crate_name(crate_name): def docs_rs_url(base_url, crate_name, version): return base_url + '/' + crate_name + '/' + version - + def crate_name(name, version, make): return library_to_crate_name(library_name(name, version), make.target_suffix) - + def gen_crate_dir(name, version, ti): return to_extern_crate_name(library_to_crate_name(library_name(name, version), ti.target_suffix)) diff --git a/src/rust/api/cmn.rs b/src/rust/api/cmn.rs index 253452652d..d7663c95e1 100644 --- a/src/rust/api/cmn.rs +++ b/src/rust/api/cmn.rs @@ -161,7 +161,7 @@ pub trait Delegate { /// impending failure. /// The given Error provides information about why the token couldn't be acquired in the /// first place - fn token(&mut self, err: &error::Error) -> Option { + fn token(&mut self, err: &dyn error::Error) -> Option { let _ = err; None } @@ -272,7 +272,7 @@ pub enum Error { MissingAPIKey, /// We required a Token, but didn't get one from the Authenticator - MissingToken(Box), + MissingToken(Box), /// The delgate instructed to cancel the operation Cancelled, @@ -301,16 +301,16 @@ impl Display for Error { writeln!(f, "It is used as there are no Scopes defined for this method.") }, Error::BadRequest(ref err) => { - try!(writeln!(f, "Bad Request ({}): {}", err.error.code, err.error.message)); + writeln!(f, "Bad Request ({}): {}", err.error.code, err.error.message)?; for err in err.error.errors.iter() { - try!(writeln!(f, " {}: {}, {}{}", - err.domain, - err.message, - err.reason, - match &err.location { - &Some(ref loc) => format!("@{}", loc), - &None => String::new(), - })); + writeln!(f, " {}: {}, {}{}", + err.domain, + err.message, + err.reason, + match &err.location { + &Some(ref loc) => format!("@{}", loc), + &None => String::new(), + })?; } Ok(()) }, @@ -337,10 +337,10 @@ impl error::Error for Error { } } - fn cause(&self) -> Option<&error::Error> { + fn cause(&self) -> Option<&dyn error::Error> { match *self { - Error::HttpError(ref err) => err.cause(), - Error::JsonDecodeError(_, ref err) => err.cause(), + Error::HttpError(ref err) => err.source(), + Error::JsonDecodeError(_, ref err) => err.source(), _ => None } } @@ -363,8 +363,8 @@ const BOUNDARY: &'static str = "MDuXWGyeE33QFXGchb2VFWc4Z7945d"; /// to google APIs, and might not be a fully-featured implementation. #[derive(Default)] pub struct MultiPartReader<'a> { - raw_parts: Vec<(Headers, &'a mut Read)>, - current_part: Option<(Cursor>, &'a mut Read)>, + raw_parts: Vec<(Headers, &'a mut dyn Read)>, + current_part: Option<(Cursor>, &'a mut dyn Read)>, last_part_boundary: Option>>, } @@ -386,7 +386,7 @@ impl<'a> MultiPartReader<'a> { /// `size` - the amount of bytes provided by the reader. It will be put onto the header as /// content-size. /// `mime` - It will be put onto the content type - pub fn add_part(&mut self, reader: &'a mut Read, size: u64, mime_type: Mime) -> &mut MultiPartReader<'a> { + pub fn add_part(&mut self, reader: &'a mut dyn Read, size: u64, mime_type: Mime) -> &mut MultiPartReader<'a> { let mut headers = Headers::new(); headers.set(ContentType(mime_type)); headers.set(ContentLength(size)); @@ -567,10 +567,10 @@ impl Header for ContentRange { impl HeaderFormat for ContentRange { fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - try!(fmt.write_str("bytes ")); + fmt.write_str("bytes ")?; match self.range { - Some(ref c) => try!(c.fmt(fmt)), - None => try!(fmt.write_str("*")) + Some(ref c) => c.fmt(fmt)?, + None => fmt.write_str("*")? } (write!(fmt, "/{}", self.total_length)).ok(); Ok(()) @@ -611,13 +611,13 @@ impl HeaderFormat for RangeResponseHeader { /// A utility type to perform a resumable upload from start to end. pub struct ResumableUploadHelper<'a, A: 'a> { pub client: &'a mut hyper::client::Client, - pub delegate: &'a mut Delegate, + pub delegate: &'a mut dyn Delegate, pub start_at: Option, pub auth: &'a mut A, pub user_agent: &'a str, pub auth_header: Authorization, pub url: &'a str, - pub reader: &'a mut ReadSeek, + pub reader: &'a mut dyn ReadSeek, pub media_type: Mime, pub content_length: u64 }