From 16bc060407fc23660994bf3f4894cfecf2a46148 Mon Sep 17 00:00:00 2001 From: Paul Woolcock Date: Tue, 9 Jun 2020 09:11:18 -0400 Subject: [PATCH] Update to the 2018 edition Only 2 years later :eyeroll: --- Cargo.toml | 1 + examples/follow_profile.rs | 4 +- examples/follows_me.rs | 4 +- examples/home_timeline.rs | 4 +- examples/print_your_profile.rs | 4 +- examples/register/mod.rs | 8 +- examples/search.rs | 4 +- examples/upload_photo.rs | 4 +- macro-dbg | 30158 +++++++++++++++++++++++++++ src/apps.rs | 4 +- src/entities/account.rs | 2 +- src/entities/event.rs | 2 +- src/entities/itemsiter.rs | 4 +- src/entities/status.rs | 4 +- src/errors.rs | 8 +- src/helpers/cli.rs | 8 +- src/helpers/env.rs | 4 +- src/helpers/json.rs | 4 +- src/helpers/toml.rs | 6 +- src/http_send.rs | 2 +- src/lib.rs | 38 +- src/mastodon_client.rs | 12 +- src/page.rs | 4 +- src/registration.rs | 16 +- src/requests/filter.rs | 2 +- src/requests/push.rs | 10 +- src/requests/statuses.rs | 2 +- src/requests/update_credentials.rs | 10 +- src/scopes.rs | 2 +- 29 files changed, 30247 insertions(+), 88 deletions(-) create mode 100644 macro-dbg diff --git a/Cargo.toml b/Cargo.toml index 2212631..b4d758e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,6 +8,7 @@ readme = "README.md" repository = "https://github.com/pwoolcoc/elefren.git" keywords = ["api", "web", "social", "mastodon", "wrapper"] categories = ["web-programming", "web-programming::http-client", "api-bindings"] +edition = "2018" [dependencies] doc-comment = "0.3" diff --git a/examples/follow_profile.rs b/examples/follow_profile.rs index 84b2998..2d97380 100644 --- a/examples/follow_profile.rs +++ b/examples/follow_profile.rs @@ -5,11 +5,11 @@ extern crate pretty_env_logger; extern crate elefren; mod register; -use register::MastodonClient; +use crate::register::MastodonClient; use std::error; #[cfg(feature = "toml")] -fn main() -> Result<(), Box> { +fn main() -> Result<(), Box> { let mastodon = register::get_mastodon_data()?; let input = register::read_line("Enter the account id you'd like to follow: ")?; let new_follow = mastodon.follow(input.trim())?; diff --git a/examples/follows_me.rs b/examples/follows_me.rs index 0df4414..2008fb5 100644 --- a/examples/follows_me.rs +++ b/examples/follows_me.rs @@ -5,11 +5,11 @@ extern crate pretty_env_logger; extern crate elefren; mod register; -use register::MastodonClient; +use crate::register::MastodonClient; use std::error; #[cfg(feature = "toml")] -fn main() -> Result<(), Box> { +fn main() -> Result<(), Box> { let mastodon = register::get_mastodon_data()?; for account in mastodon.follows_me()?.items_iter() { println!("{}", account.acct); diff --git a/examples/home_timeline.rs b/examples/home_timeline.rs index 46519e3..0f3c920 100644 --- a/examples/home_timeline.rs +++ b/examples/home_timeline.rs @@ -5,11 +5,11 @@ extern crate pretty_env_logger; extern crate elefren; mod register; -use register::MastodonClient; +use crate::register::MastodonClient; use std::error; #[cfg(feature = "toml")] -fn main() -> Result<(), Box> { +fn main() -> Result<(), Box> { let mastodon = register::get_mastodon_data()?; let tl = mastodon.get_home_timeline()?; diff --git a/examples/print_your_profile.rs b/examples/print_your_profile.rs index cbcd372..126110a 100644 --- a/examples/print_your_profile.rs +++ b/examples/print_your_profile.rs @@ -5,11 +5,11 @@ extern crate pretty_env_logger; extern crate elefren; mod register; -use register::MastodonClient; +use crate::register::MastodonClient; use std::error; #[cfg(feature = "toml")] -fn main() -> Result<(), Box> { +fn main() -> Result<(), Box> { let mastodon = register::get_mastodon_data()?; let you = mastodon.verify_credentials()?; diff --git a/examples/register/mod.rs b/examples/register/mod.rs index d8dbaff..1c429b5 100644 --- a/examples/register/mod.rs +++ b/examples/register/mod.rs @@ -11,14 +11,14 @@ use elefren::helpers::toml; #[allow(dead_code)] #[cfg(feature = "toml")] -fn main() -> Result<(), Box> { +fn main() -> Result<(), Box> { register()?; Ok(()) } #[allow(dead_code)] #[cfg(feature = "toml")] -pub fn get_mastodon_data() -> Result> { +pub fn get_mastodon_data() -> Result> { if let Ok(data) = toml::from_file("mastodon-data.toml") { Ok(Mastodon::from(data)) } else { @@ -27,7 +27,7 @@ pub fn get_mastodon_data() -> Result> { } #[cfg(feature = "toml")] -pub fn register() -> Result> { +pub fn register() -> Result> { let website = read_line("Please enter your mastodon instance url:")?; let registration = Registration::new(website.trim()) .client_name("elefren-examples") @@ -43,7 +43,7 @@ pub fn register() -> Result> { } #[cfg(feature = "toml")] -pub fn read_line(message: &str) -> Result> { +pub fn read_line(message: &str) -> Result> { println!("{}", message); let mut input = String::new(); diff --git a/examples/search.rs b/examples/search.rs index ec13f6d..c619a74 100644 --- a/examples/search.rs +++ b/examples/search.rs @@ -5,11 +5,11 @@ extern crate pretty_env_logger; extern crate elefren; mod register; -use register::MastodonClient; +use crate::register::MastodonClient; use std::error; #[cfg(feature = "toml")] -fn main() -> Result<(), Box> { +fn main() -> Result<(), Box> { let mastodon = register::get_mastodon_data()?; let input = register::read_line("Enter the term you'd like to search: ")?; let result = mastodon.search(&input, false)?; diff --git a/examples/upload_photo.rs b/examples/upload_photo.rs index a2e6688..fa2dee9 100644 --- a/examples/upload_photo.rs +++ b/examples/upload_photo.rs @@ -5,11 +5,11 @@ extern crate pretty_env_logger; extern crate elefren; mod register; -use register::MastodonClient; +use crate::register::MastodonClient; use std::error; #[cfg(feature = "toml")] -fn main() -> Result<(), Box> { +fn main() -> Result<(), Box> { let mastodon = register::get_mastodon_data()?; let input = register::read_line("Enter the path to the photo you'd like to post: ")?; diff --git a/macro-dbg b/macro-dbg new file mode 100644 index 0000000..27be5c5 --- /dev/null +++ b/macro-dbg @@ -0,0 +1,30158 @@ +#![feature(prelude_import)] +//! # Elefren: API Wrapper around the Mastodon API. +//! +//! Most of the api is documented on [Mastodon's website](https://docs.joinmastodon.org/client/intro/) +//! +//! ```no_run +//! # extern crate elefren; +//! # fn main() { +//! # run().unwrap(); +//! # } +//! # fn run() -> elefren::Result<()> { +//! use elefren::{helpers::cli, prelude::*}; +//! +//! let registration = Registration::new("https://mastodon.social") +//! .client_name("elefren_test") +//! .build()?; +//! let mastodon = cli::authenticate(registration)?; +//! +//! println!( +//! "{:?}", +//! mastodon +//! .get_home_timeline()? +//! .items_iter() +//! .take(100) +//! .collect::>() +//! ); +//! # Ok(()) +//! # } +//! ``` +//! +//! Elefren also supports Mastodon's Streaming API: +//! +//! # Example +//! +//! ```no_run +//! # extern crate elefren; +//! # use elefren::prelude::*; +//! # use std::error::Error; +//! use elefren::entities::event::Event; +//! # fn main() -> Result<(), Box> { +//! # let data = Data { +//! # base: "".into(), +//! # client_id: "".into(), +//! # client_secret: "".into(), +//! # redirect: "".into(), +//! # token: "".into(), +//! # }; +//! let client = Mastodon::from(data); +//! for event in client.streaming_user()? { +//! match event { +//! Event::Update(ref status) => { /* .. */ }, +//! Event::Notification(ref notification) => { /* .. */ }, +//! Event::Delete(ref id) => { /* .. */ }, +//! Event::FiltersChanged => { /* .. */ }, +//! } +//! } +//! # Ok(()) +//! # } +//! ``` + +#![deny(missing_docs, warnings, missing_debug_implementations, + missing_copy_implementations, trivial_casts, trivial_numeric_casts, + unsafe_code, unstable_features, unused_import_braces, + unused_qualifications)] +#![allow(intra_doc_link_resolution_failure)] +#[prelude_import] +use std::prelude::v1::*; +#[macro_use] +extern crate std; + +#[macro_use] +extern crate log; +#[macro_use] +extern crate serde_derive; +#[macro_use] +extern crate doc_comment; +extern crate hyper_old_types; +extern crate isolang; +#[macro_use] +extern crate serde_json; +extern crate chrono; +extern crate reqwest; +extern crate serde; +extern crate serde_qs; +extern crate serde_urlencoded; +extern crate tap_reader; +extern crate try_from; +extern crate url; +extern crate tungstenite; + + + + + +use std::{borrow::Cow, + /* + io::BufRead, + */ + ops}; + +use async_trait::async_trait; +use reqwest::{Client, RequestBuilder, Response}; +use tap_reader::Tap; +/* +use tungstenite::client::AutoStream; +*/ + +use crate::entities::prelude::*; +use crate::page::Page; + +pub use crate::data::Data; +pub use crate::errors::{ApiError, Error, Result}; +pub use isolang::Language; +pub use crate::mastodon_client::{MastodonClient, MastodonUnauthenticated}; +pub use crate::registration::Registration; +pub use crate::requests::{AddFilterRequest, AddPushRequest, StatusesRequest, + UpdateCredsRequest, UpdatePushRequest}; +pub use crate::status_builder::{NewStatus, StatusBuilder}; + +/// Registering your App +pub mod apps { + + + + + + + /* + type Stream = EventReader; + */ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + /* + /// returns events that are relevant to the authorized user, i.e. home + /// timeline & notifications + /// + /// # Example + /// + /// ```no_run + /// # extern crate elefren; + /// # use elefren::prelude::*; + /// # use std::error::Error; + /// use elefren::entities::event::Event; + /// # fn main() -> Result<(), Box> { + /// # let data = Data { + /// # base: "".into(), + /// # client_id: "".into(), + /// # client_secret: "".into(), + /// # redirect: "".into(), + /// # token: "".into(), + /// # }; + /// let client = Mastodon::from(data); + /// for event in client.streaming_user()? { + /// match event { + /// Event::Update(ref status) => { /* .. */ }, + /// Event::Notification(ref notification) => { /* .. */ }, + /// Event::Delete(ref id) => { /* .. */ }, + /// Event::FiltersChanged => { /* .. */ }, + /// } + /// } + /// # Ok(()) + /// # } + /// ``` + fn streaming_user(&self) -> Result { + let mut url: url::Url = self.route("/api/v1/streaming").parse()?; + url.query_pairs_mut() + .append_pair("access_token", &self.token) + .append_pair("stream", "user"); + let mut url: url::Url = reqwest::get(url.as_str())?.url().as_str().parse()?; + let new_scheme = match url.scheme() { + "http" => "ws", + "https" => "wss", + x => return Err(Error::Other(format!("Bad URL scheme: {}", x))), + }; + url.set_scheme(new_scheme).map_err(|_| Error::Other("Bad URL scheme!".to_string()))?; + + let client = tungstenite::connect(url.as_str())?.0; + + Ok(EventReader(WebSocket(client))) + } + + /// returns all public statuses + fn streaming_public(&self) -> Result { + let mut url: url::Url = self.route("/api/v1/streaming").parse()?; + url.query_pairs_mut() + .append_pair("access_token", &self.token) + .append_pair("stream", "public"); + let mut url: url::Url = reqwest::get(url.as_str())?.url().as_str().parse()?; + let new_scheme = match url.scheme() { + "http" => "ws", + "https" => "wss", + x => return Err(Error::Other(format!("Bad URL scheme: {}", x))), + }; + url.set_scheme(new_scheme).map_err(|_| Error::Other("Bad URL scheme!".to_string()))?; + + let client = tungstenite::connect(url.as_str())?.0; + + Ok(EventReader(WebSocket(client))) + } + + /// Returns all local statuses + fn streaming_local(&self) -> Result { + let mut url: url::Url = self.route("/api/v1/streaming").parse()?; + url.query_pairs_mut() + .append_pair("access_token", &self.token) + .append_pair("stream", "public:local"); + let mut url: url::Url = reqwest::get(url.as_str())?.url().as_str().parse()?; + let new_scheme = match url.scheme() { + "http" => "ws", + "https" => "wss", + x => return Err(Error::Other(format!("Bad URL scheme: {}", x))), + }; + url.set_scheme(new_scheme).map_err(|_| Error::Other("Bad URL scheme!".to_string()))?; + + let client = tungstenite::connect(url.as_str())?.0; + + Ok(EventReader(WebSocket(client))) + } + + /// Returns all public statuses for a particular hashtag + fn streaming_public_hashtag(&self, hashtag: &str) -> Result { + let mut url: url::Url = self.route("/api/v1/streaming").parse()?; + url.query_pairs_mut() + .append_pair("access_token", &self.token) + .append_pair("stream", "hashtag") + .append_pair("tag", hashtag); + let mut url: url::Url = reqwest::get(url.as_str())?.url().as_str().parse()?; + let new_scheme = match url.scheme() { + "http" => "ws", + "https" => "wss", + x => return Err(Error::Other(format!("Bad URL scheme: {}", x))), + }; + url.set_scheme(new_scheme).map_err(|_| Error::Other("Bad URL scheme!".to_string()))?; + + let client = tungstenite::connect(url.as_str())?.0; + + Ok(EventReader(WebSocket(client))) + } + + /// Returns all local statuses for a particular hashtag + fn streaming_local_hashtag(&self, hashtag: &str) -> Result { + let mut url: url::Url = self.route("/api/v1/streaming").parse()?; + url.query_pairs_mut() + .append_pair("access_token", &self.token) + .append_pair("stream", "hashtag:local") + .append_pair("tag", hashtag); + let mut url: url::Url = reqwest::get(url.as_str())?.url().as_str().parse()?; + let new_scheme = match url.scheme() { + "http" => "ws", + "https" => "wss", + x => return Err(Error::Other(format!("Bad URL scheme: {}", x))), + }; + url.set_scheme(new_scheme).map_err(|_| Error::Other("Bad URL scheme!".to_string()))?; + + let client = tungstenite::connect(url.as_str())?.0; + + Ok(EventReader(WebSocket(client))) + } + + /// Returns statuses for a list + fn streaming_list(&self, list_id: &str) -> Result { + let mut url: url::Url = self.route("/api/v1/streaming").parse()?; + url.query_pairs_mut() + .append_pair("access_token", &self.token) + .append_pair("stream", "list") + .append_pair("list", list_id); + let mut url: url::Url = reqwest::get(url.as_str())?.url().as_str().parse()?; + let new_scheme = match url.scheme() { + "http" => "ws", + "https" => "wss", + x => return Err(Error::Other(format!("Bad URL scheme: {}", x))), + }; + url.set_scheme(new_scheme).map_err(|_| Error::Other("Bad URL scheme!".to_string()))?; + + let client = tungstenite::connect(url.as_str())?.0; + + Ok(EventReader(WebSocket(client))) + } + + /// Returns all direct messages + fn streaming_direct(&self) -> Result { + let mut url: url::Url = self.route("/api/v1/streaming").parse()?; + url.query_pairs_mut() + .append_pair("access_token", &self.token) + .append_pair("stream", "direct"); + let mut url: url::Url = reqwest::get(url.as_str())?.url().as_str().parse()?; + let new_scheme = match url.scheme() { + "http" => "ws", + "https" => "wss", + x => return Err(Error::Other(format!("Bad URL scheme: {}", x))), + }; + url.set_scheme(new_scheme).map_err(|_| Error::Other("Bad URL scheme!".to_string()))?; + + let client = tungstenite::connect(url.as_str())?.0; + + Ok(EventReader(WebSocket(client))) + } + */ + + /* + #[derive(Debug)] + /// WebSocket newtype so that EventStream can be implemented without coherency issues + pub struct WebSocket(tungstenite::protocol::WebSocket); + + /// A type that streaming events can be read from + pub trait EventStream { + /// Read a message from this stream + fn read_message(&mut self) -> Result; + } + + impl EventStream for R { + fn read_message(&mut self) -> Result { + let mut buf = String::new(); + self.read_line(&mut buf)?; + Ok(buf) + } + } + + impl EventStream for WebSocket { + fn read_message(&mut self) -> Result { + Ok(self.0.read_message()?.into_text()?) + } + } + + #[derive(Debug)] + /// Iterator that produces events from a mastodon streaming API event stream + pub struct EventReader(R); + impl Iterator for EventReader { + type Item = Event; + + fn next(&mut self) -> Option { + let mut lines = Vec::new(); + loop { + if let Ok(line) = self.0.read_message() { + let line = line.trim().to_string(); + if line.starts_with(":") || line.is_empty() { + continue; + } + lines.push(line); + if let Ok(event) = self.make_event(&lines) { + lines.clear(); + return Some(event); + } else { + continue; + } + } + } + } + } + + impl EventReader { + fn make_event(&self, lines: &[String]) -> Result { + let event; + let data; + if let Some(event_line) = lines + .iter() + .find(|line| line.starts_with("event:")) + { + event = event_line[6..].trim().to_string(); + data = lines.iter().find(|line| line.starts_with("data:")).map(|x| x[5..].trim().to_string()); + } else { + #[derive(Deserialize)] + struct Message { + pub event: String, + pub payload: Option, + } + let message = serde_json::from_str::(&lines[0])?; + event = message.event; + data = message.payload; + } + let event: &str = &event; + Ok(match event { + "notification" => { + let data = data.ok_or_else(|| { + Error::Other("Missing `data` line for notification".to_string()) + })?; + let notification = serde_json::from_str::(&data)?; + Event::Notification(notification) + }, + "update" => { + let data = + data.ok_or_else(|| Error::Other("Missing `data` line for update".to_string()))?; + let status = serde_json::from_str::(&data)?; + Event::Update(status) + }, + "delete" => { + let data = + data.ok_or_else(|| Error::Other("Missing `data` line for delete".to_string()))?; + Event::Delete(data) + }, + "filters_changed" => Event::FiltersChanged, + _ => return Err(Error::Other(format!("Unknown event `{}`", event))), + }) + } + } + */ + + + + + + + + + + + + + + + + // Convert the HTTP response body from JSON. Pass up deserialization errors + // transparently. + + // If deserializing into the desired type fails try again to + // see if this is an error response. + use std::borrow::Cow; + use try_from::TryInto; + use crate::errors::{Error, Result}; + use crate::scopes::Scopes; + /// Represents an application that can be registered with a mastodon instance + pub struct App { + client_name: String, + redirect_uris: String, + scopes: Scopes, + #[serde(skip_serializing_if = "Option::is_none")] + website: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for App { + #[inline] + fn clone(&self) -> App { + match *self { + App { + client_name: ref __self_0_0, + redirect_uris: ref __self_0_1, + scopes: ref __self_0_2, + website: ref __self_0_3 } => + App{client_name: ::core::clone::Clone::clone(&(*__self_0_0)), + redirect_uris: + ::core::clone::Clone::clone(&(*__self_0_1)), + scopes: ::core::clone::Clone::clone(&(*__self_0_2)), + website: ::core::clone::Clone::clone(&(*__self_0_3)),}, + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for App { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + App { + client_name: ref __self_0_0, + redirect_uris: ref __self_0_1, + scopes: ref __self_0_2, + website: ref __self_0_3 } => { + let mut debug_trait_builder = f.debug_struct("App"); + let _ = + debug_trait_builder.field("client_name", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("redirect_uris", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("scopes", &&(*__self_0_2)); + let _ = + debug_trait_builder.field("website", &&(*__self_0_3)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::default::Default for App { + #[inline] + fn default() -> App { + App{client_name: ::core::default::Default::default(), + redirect_uris: ::core::default::Default::default(), + scopes: ::core::default::Default::default(), + website: ::core::default::Default::default(),} + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _IMPL_SERIALIZE_FOR_App: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl _serde::Serialize for App { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "App", + false as + usize + + 1 + 1 + + 1 + + if Option::is_none(&self.website) + { + 0 + } else { + 1 + }) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "client_name", + &self.client_name) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "redirect_uris", + &self.redirect_uris) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "scopes", + &self.scopes) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + if !Option::is_none(&self.website) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "website", + &self.website) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "website") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::marker::StructuralPartialEq for App { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for App { + #[inline] + fn eq(&self, other: &App) -> bool { + match *other { + App { + client_name: ref __self_1_0, + redirect_uris: ref __self_1_1, + scopes: ref __self_1_2, + website: ref __self_1_3 } => + match *self { + App { + client_name: ref __self_0_0, + redirect_uris: ref __self_0_1, + scopes: ref __self_0_2, + website: ref __self_0_3 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3), + }, + } + } + #[inline] + fn ne(&self, other: &App) -> bool { + match *other { + App { + client_name: ref __self_1_0, + redirect_uris: ref __self_1_1, + scopes: ref __self_1_2, + website: ref __self_1_3 } => + match *self { + App { + client_name: ref __self_0_0, + redirect_uris: ref __self_0_1, + scopes: ref __self_0_2, + website: ref __self_0_3 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3), + }, + } + } + } + impl App { + /// Get an AppBuilder object + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// use elefren::apps::App; + /// + /// let mut builder = App::builder(); + /// ``` + pub fn builder<'a>() -> AppBuilder<'a> { AppBuilder::new() } + /// Retrieve the list of scopes that apply to this App + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// # use elefren::Error; + /// use elefren::{apps::App, scopes::Scopes}; + /// + /// # fn main() -> Result<(), Error> { + /// let mut builder = App::builder(); + /// builder.client_name("elefren-test"); + /// let app = builder.build()?; + /// let scopes = app.scopes(); + /// assert_eq!(scopes, &Scopes::read_all()); + /// # Ok(()) + /// # } + /// ``` + pub fn scopes(&self) -> &Scopes { &self.scopes } + } + /// Builder struct for defining your application. + /// ``` + /// use elefren::apps::App; + /// use std::error::Error; + /// + /// # fn main() -> Result<(), Box> { + /// let mut builder = App::builder(); + /// builder.client_name("elefren_test"); + /// let app = builder.build()?; + /// # Ok(()) + /// # } + /// ``` + pub struct AppBuilder<'a> { + client_name: Option>, + redirect_uris: Option>, + scopes: Option, + website: Option>, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl <'a> ::core::clone::Clone for AppBuilder<'a> { + #[inline] + fn clone(&self) -> AppBuilder<'a> { + match *self { + AppBuilder { + client_name: ref __self_0_0, + redirect_uris: ref __self_0_1, + scopes: ref __self_0_2, + website: ref __self_0_3 } => + AppBuilder{client_name: + ::core::clone::Clone::clone(&(*__self_0_0)), + redirect_uris: + ::core::clone::Clone::clone(&(*__self_0_1)), + scopes: + ::core::clone::Clone::clone(&(*__self_0_2)), + website: + ::core::clone::Clone::clone(&(*__self_0_3)),}, + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl <'a> ::core::fmt::Debug for AppBuilder<'a> { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + AppBuilder { + client_name: ref __self_0_0, + redirect_uris: ref __self_0_1, + scopes: ref __self_0_2, + website: ref __self_0_3 } => { + let mut debug_trait_builder = + f.debug_struct("AppBuilder"); + let _ = + debug_trait_builder.field("client_name", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("redirect_uris", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("scopes", &&(*__self_0_2)); + let _ = + debug_trait_builder.field("website", &&(*__self_0_3)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl <'a> ::core::default::Default for AppBuilder<'a> { + #[inline] + fn default() -> AppBuilder<'a> { + AppBuilder{client_name: ::core::default::Default::default(), + redirect_uris: ::core::default::Default::default(), + scopes: ::core::default::Default::default(), + website: ::core::default::Default::default(),} + } + } + impl <'a> ::core::marker::StructuralPartialEq for AppBuilder<'a> { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl <'a> ::core::cmp::PartialEq for AppBuilder<'a> { + #[inline] + fn eq(&self, other: &AppBuilder<'a>) -> bool { + match *other { + AppBuilder { + client_name: ref __self_1_0, + redirect_uris: ref __self_1_1, + scopes: ref __self_1_2, + website: ref __self_1_3 } => + match *self { + AppBuilder { + client_name: ref __self_0_0, + redirect_uris: ref __self_0_1, + scopes: ref __self_0_2, + website: ref __self_0_3 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3), + }, + } + } + #[inline] + fn ne(&self, other: &AppBuilder<'a>) -> bool { + match *other { + AppBuilder { + client_name: ref __self_1_0, + redirect_uris: ref __self_1_1, + scopes: ref __self_1_2, + website: ref __self_1_3 } => + match *self { + AppBuilder { + client_name: ref __self_0_0, + redirect_uris: ref __self_0_1, + scopes: ref __self_0_2, + website: ref __self_0_3 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3), + }, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _IMPL_SERIALIZE_FOR_AppBuilder: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'a> _serde::Serialize for AppBuilder<'a> { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "AppBuilder", + false as + usize + + 1 + 1 + + 1 + 1) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "client_name", + &self.client_name) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "redirect_uris", + &self.redirect_uris) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "scopes", + &self.scopes) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "website", + &self.website) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl <'a> AppBuilder<'a> { + /// Creates a new AppBuilder object + pub fn new() -> Self { Default::default() } + /// Name of the application. Will be displayed when the user is deciding to + /// grant permission. + /// + /// In order to turn this builder into an App, this needs to be provided + pub fn client_name>>(&mut self, name: I) + -> &mut Self { + self.client_name = Some(name.into()); + self + } + /// Where the user should be redirected after authorization + /// + /// If none is specified, the default is `urn:ietf:wg:oauth:2.0:oob` + pub fn redirect_uris>>(&mut self, uris: I) + -> &mut Self { + self.redirect_uris = Some(uris.into()); + self + } + /// Permission scope of the application. + /// + /// IF none is specified, the default is Scopes::read_all() + pub fn scopes(&mut self, scopes: Scopes) -> &mut Self { + self.scopes = Some(scopes); + self + } + /// URL to the homepage of your application. + pub fn website>>(&mut self, website: I) + -> &mut Self { + self.website = Some(website.into()); + self + } + /// Attempts to convert this build into an `App` + /// + /// Will fail if no `client_name` was provided + pub fn build(self) -> Result { + Ok(App{client_name: + self.client_name.ok_or_else(|| + Error::MissingField("client_name"))?.into(), + redirect_uris: + self.redirect_uris.unwrap_or_else(|| + "urn:ietf:wg:oauth:2.0:oob".into()).into(), + scopes: self.scopes.unwrap_or_else(|| Scopes::read_all()), + website: self.website.map(|s| s.into()),}) + } + } + impl TryInto for App { + type Err = Error; + fn try_into(self) -> Result { Ok(self) } + } + impl <'a> TryInto for AppBuilder<'a> { + type Err = Error; + fn try_into(self) -> Result { Ok(self.build()?) } + } +} +/// Contains the struct that holds the client auth data +pub mod data { + use std::borrow::Cow; + /// Raw data about mastodon app. Save `Data` using `serde` to prevent needing + /// to authenticate on every run. + pub struct Data { + /// Base url of instance eg. `https://mastodon.social`. + pub base: Cow<'static, str>, + /// The client's id given by the instance. + pub client_id: Cow<'static, str>, + /// The client's secret given by the instance. + pub client_secret: Cow<'static, str>, + /// Url to redirect back to your application from the instance signup. + pub redirect: Cow<'static, str>, + /// The client's access token. + pub token: Cow<'static, str>, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Data { + #[inline] + fn clone(&self) -> Data { + match *self { + Data { + base: ref __self_0_0, + client_id: ref __self_0_1, + client_secret: ref __self_0_2, + redirect: ref __self_0_3, + token: ref __self_0_4 } => + Data{base: ::core::clone::Clone::clone(&(*__self_0_0)), + client_id: ::core::clone::Clone::clone(&(*__self_0_1)), + client_secret: + ::core::clone::Clone::clone(&(*__self_0_2)), + redirect: ::core::clone::Clone::clone(&(*__self_0_3)), + token: ::core::clone::Clone::clone(&(*__self_0_4)),}, + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Data { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + Data { + base: ref __self_0_0, + client_id: ref __self_0_1, + client_secret: ref __self_0_2, + redirect: ref __self_0_3, + token: ref __self_0_4 } => { + let mut debug_trait_builder = f.debug_struct("Data"); + let _ = + debug_trait_builder.field("base", &&(*__self_0_0)); + let _ = + debug_trait_builder.field("client_id", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("client_secret", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("redirect", + &&(*__self_0_3)); + let _ = + debug_trait_builder.field("token", &&(*__self_0_4)); + debug_trait_builder.finish() + } + } + } + } + impl ::core::marker::StructuralPartialEq for Data { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Data { + #[inline] + fn eq(&self, other: &Data) -> bool { + match *other { + Data { + base: ref __self_1_0, + client_id: ref __self_1_1, + client_secret: ref __self_1_2, + redirect: ref __self_1_3, + token: ref __self_1_4 } => + match *self { + Data { + base: ref __self_0_0, + client_id: ref __self_0_1, + client_secret: ref __self_0_2, + redirect: ref __self_0_3, + token: ref __self_0_4 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3) && + (*__self_0_4) == (*__self_1_4), + }, + } + } + #[inline] + fn ne(&self, other: &Data) -> bool { + match *other { + Data { + base: ref __self_1_0, + client_id: ref __self_1_1, + client_secret: ref __self_1_2, + redirect: ref __self_1_3, + token: ref __self_1_4 } => + match *self { + Data { + base: ref __self_0_0, + client_id: ref __self_0_1, + client_secret: ref __self_0_2, + redirect: ref __self_0_3, + token: ref __self_0_4 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3) || + (*__self_0_4) != (*__self_1_4), + }, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Data: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Data { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __field4, + __ignore, + } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => _serde::export::Ok(__Field::__field0), + 1u64 => _serde::export::Ok(__Field::__field1), + 2u64 => _serde::export::Ok(__Field::__field2), + 3u64 => _serde::export::Ok(__Field::__field3), + 4u64 => _serde::export::Ok(__Field::__field4), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 5")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "base" => + _serde::export::Ok(__Field::__field0), + "client_id" => + _serde::export::Ok(__Field::__field1), + "client_secret" => + _serde::export::Ok(__Field::__field2), + "redirect" => + _serde::export::Ok(__Field::__field3), + "token" => + _serde::export::Ok(__Field::__field4), + _ => { _serde::export::Ok(__Field::__ignore) } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"base" => + _serde::export::Ok(__Field::__field0), + b"client_id" => + _serde::export::Ok(__Field::__field1), + b"client_secret" => + _serde::export::Ok(__Field::__field2), + b"redirect" => + _serde::export::Ok(__Field::__field3), + b"token" => + _serde::export::Ok(__Field::__field4), + _ => { _serde::export::Ok(__Field::__ignore) } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Data; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct Data") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> _serde::export::Result + where __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct Data with 5 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct Data with 5 elements")); + } + }; + let __field2 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(2usize, + &"struct Data with 5 elements")); + } + }; + let __field3 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(3usize, + &"struct Data with 5 elements")); + } + }; + let __field4 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(4usize, + &"struct Data with 5 elements")); + } + }; + _serde::export::Ok(Data{base: __field0, + client_id: __field1, + client_secret: __field2, + redirect: __field3, + token: __field4,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> _serde::export::Result + where __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option> = + _serde::export::None; + let mut __field1: + _serde::export::Option> = + _serde::export::None; + let mut __field2: + _serde::export::Option> = + _serde::export::None; + let mut __field3: + _serde::export::Option> = + _serde::export::None; + let mut __field4: + _serde::export::Option> = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("base")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("client_id")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("client_secret")); + } + __field2 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field3 => { + if _serde::export::Option::is_some(&__field3) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("redirect")); + } + __field3 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field4 => { + if _serde::export::Option::is_some(&__field4) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("token")); + } + __field4 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => + { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("base") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("client_id") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field2 = + match __field2 { + _serde::export::Some(__field2) => + __field2, + _serde::export::None => + match _serde::private::de::missing_field("client_secret") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field3 = + match __field3 { + _serde::export::Some(__field3) => + __field3, + _serde::export::None => + match _serde::private::de::missing_field("redirect") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field4 = + match __field4 { + _serde::export::Some(__field4) => + __field4, + _serde::export::None => + match _serde::private::de::missing_field("token") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(Data{base: __field0, + client_id: __field1, + client_secret: __field2, + redirect: __field3, + token: __field4,}) + } + } + const FIELDS: &'static [&'static str] = + &["base", "client_id", "client_secret", "redirect", + "token"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "Data", FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _IMPL_SERIALIZE_FOR_Data: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl _serde::Serialize for Data { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "Data", + false as + usize + + 1 + 1 + + 1 + 1 + + 1) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "base", + &self.base) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "client_id", + &self.client_id) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "client_secret", + &self.client_secret) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "redirect", + &self.redirect) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "token", + &self.token) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; +} +/// Entities returned from the API +pub mod entities { + /// Data structures for ser/de of account-related resources + pub mod account { + //! A module containing everything relating to a account returned from the api. + use chrono::prelude::*; + use serde::de::{self, Deserialize, Deserializer, Unexpected}; + use crate::status_builder; + use std::path::PathBuf; + /// A struct representing an Account. + pub struct Account { + /// Equals `username` for local users, includes `@domain` for remote ones. + pub acct: String, + /// URL to the avatar image + pub avatar: String, + /// URL to the avatar static image (gif) + pub avatar_static: String, + /// The time the account was created. + pub created_at: DateTime, + /// The account's display name. + pub display_name: String, + /// The number of followers for the account. + pub followers_count: u64, + /// The number of accounts the given account is following. + pub following_count: u64, + /// URL to the header image. + pub header: String, + /// URL to the header static image (gif). + pub header_static: String, + /// The ID of the account. + pub id: String, + /// Boolean for when the account cannot be followed without waiting for + /// approval first. + pub locked: bool, + /// Biography of user. + pub note: String, + /// The number of statuses the account has made. + pub statuses_count: u64, + /// URL of the user's profile page (can be remote). + pub url: String, + /// The username of the account. + pub username: String, + /// An extra attribute given from `verify_credentials` giving defaults about + /// a user + pub source: Option, + /// If the owner decided to switch accounts, new account is in + /// this attribute + pub moved: Option>, + /// List of profile metadata fields + pub fields: Option>, + /// Boolean indicating whether this account is a bot or not + pub bot: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Account { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Account { + acct: ref __self_0_0, + avatar: ref __self_0_1, + avatar_static: ref __self_0_2, + created_at: ref __self_0_3, + display_name: ref __self_0_4, + followers_count: ref __self_0_5, + following_count: ref __self_0_6, + header: ref __self_0_7, + header_static: ref __self_0_8, + id: ref __self_0_9, + locked: ref __self_0_10, + note: ref __self_0_11, + statuses_count: ref __self_0_12, + url: ref __self_0_13, + username: ref __self_0_14, + source: ref __self_0_15, + moved: ref __self_0_16, + fields: ref __self_0_17, + bot: ref __self_0_18 } => { + let mut debug_trait_builder = + f.debug_struct("Account"); + let _ = + debug_trait_builder.field("acct", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("avatar", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("avatar_static", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("created_at", + &&(*__self_0_3)); + let _ = + debug_trait_builder.field("display_name", + &&(*__self_0_4)); + let _ = + debug_trait_builder.field("followers_count", + &&(*__self_0_5)); + let _ = + debug_trait_builder.field("following_count", + &&(*__self_0_6)); + let _ = + debug_trait_builder.field("header", + &&(*__self_0_7)); + let _ = + debug_trait_builder.field("header_static", + &&(*__self_0_8)); + let _ = + debug_trait_builder.field("id", &&(*__self_0_9)); + let _ = + debug_trait_builder.field("locked", + &&(*__self_0_10)); + let _ = + debug_trait_builder.field("note", + &&(*__self_0_11)); + let _ = + debug_trait_builder.field("statuses_count", + &&(*__self_0_12)); + let _ = + debug_trait_builder.field("url", + &&(*__self_0_13)); + let _ = + debug_trait_builder.field("username", + &&(*__self_0_14)); + let _ = + debug_trait_builder.field("source", + &&(*__self_0_15)); + let _ = + debug_trait_builder.field("moved", + &&(*__self_0_16)); + let _ = + debug_trait_builder.field("fields", + &&(*__self_0_17)); + let _ = + debug_trait_builder.field("bot", + &&(*__self_0_18)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Account { + #[inline] + fn clone(&self) -> Account { + match *self { + Account { + acct: ref __self_0_0, + avatar: ref __self_0_1, + avatar_static: ref __self_0_2, + created_at: ref __self_0_3, + display_name: ref __self_0_4, + followers_count: ref __self_0_5, + following_count: ref __self_0_6, + header: ref __self_0_7, + header_static: ref __self_0_8, + id: ref __self_0_9, + locked: ref __self_0_10, + note: ref __self_0_11, + statuses_count: ref __self_0_12, + url: ref __self_0_13, + username: ref __self_0_14, + source: ref __self_0_15, + moved: ref __self_0_16, + fields: ref __self_0_17, + bot: ref __self_0_18 } => + Account{acct: ::core::clone::Clone::clone(&(*__self_0_0)), + avatar: + ::core::clone::Clone::clone(&(*__self_0_1)), + avatar_static: + ::core::clone::Clone::clone(&(*__self_0_2)), + created_at: + ::core::clone::Clone::clone(&(*__self_0_3)), + display_name: + ::core::clone::Clone::clone(&(*__self_0_4)), + followers_count: + ::core::clone::Clone::clone(&(*__self_0_5)), + following_count: + ::core::clone::Clone::clone(&(*__self_0_6)), + header: + ::core::clone::Clone::clone(&(*__self_0_7)), + header_static: + ::core::clone::Clone::clone(&(*__self_0_8)), + id: ::core::clone::Clone::clone(&(*__self_0_9)), + locked: + ::core::clone::Clone::clone(&(*__self_0_10)), + note: + ::core::clone::Clone::clone(&(*__self_0_11)), + statuses_count: + ::core::clone::Clone::clone(&(*__self_0_12)), + url: ::core::clone::Clone::clone(&(*__self_0_13)), + username: + ::core::clone::Clone::clone(&(*__self_0_14)), + source: + ::core::clone::Clone::clone(&(*__self_0_15)), + moved: + ::core::clone::Clone::clone(&(*__self_0_16)), + fields: + ::core::clone::Clone::clone(&(*__self_0_17)), + bot: + ::core::clone::Clone::clone(&(*__self_0_18)),}, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Account: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Account { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __field4, + __field5, + __field6, + __field7, + __field8, + __field9, + __field10, + __field11, + __field12, + __field13, + __field14, + __field15, + __field16, + __field17, + __field18, + __ignore, + } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + 2u64 => + _serde::export::Ok(__Field::__field2), + 3u64 => + _serde::export::Ok(__Field::__field3), + 4u64 => + _serde::export::Ok(__Field::__field4), + 5u64 => + _serde::export::Ok(__Field::__field5), + 6u64 => + _serde::export::Ok(__Field::__field6), + 7u64 => + _serde::export::Ok(__Field::__field7), + 8u64 => + _serde::export::Ok(__Field::__field8), + 9u64 => + _serde::export::Ok(__Field::__field9), + 10u64 => + _serde::export::Ok(__Field::__field10), + 11u64 => + _serde::export::Ok(__Field::__field11), + 12u64 => + _serde::export::Ok(__Field::__field12), + 13u64 => + _serde::export::Ok(__Field::__field13), + 14u64 => + _serde::export::Ok(__Field::__field14), + 15u64 => + _serde::export::Ok(__Field::__field15), + 16u64 => + _serde::export::Ok(__Field::__field16), + 17u64 => + _serde::export::Ok(__Field::__field17), + 18u64 => + _serde::export::Ok(__Field::__field18), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 19")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "acct" => + _serde::export::Ok(__Field::__field0), + "avatar" => + _serde::export::Ok(__Field::__field1), + "avatar_static" => + _serde::export::Ok(__Field::__field2), + "created_at" => + _serde::export::Ok(__Field::__field3), + "display_name" => + _serde::export::Ok(__Field::__field4), + "followers_count" => + _serde::export::Ok(__Field::__field5), + "following_count" => + _serde::export::Ok(__Field::__field6), + "header" => + _serde::export::Ok(__Field::__field7), + "header_static" => + _serde::export::Ok(__Field::__field8), + "id" => + _serde::export::Ok(__Field::__field9), + "locked" => + _serde::export::Ok(__Field::__field10), + "note" => + _serde::export::Ok(__Field::__field11), + "statuses_count" => + _serde::export::Ok(__Field::__field12), + "url" => + _serde::export::Ok(__Field::__field13), + "username" => + _serde::export::Ok(__Field::__field14), + "source" => + _serde::export::Ok(__Field::__field15), + "moved" => + _serde::export::Ok(__Field::__field16), + "fields" => + _serde::export::Ok(__Field::__field17), + "bot" => + _serde::export::Ok(__Field::__field18), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"acct" => + _serde::export::Ok(__Field::__field0), + b"avatar" => + _serde::export::Ok(__Field::__field1), + b"avatar_static" => + _serde::export::Ok(__Field::__field2), + b"created_at" => + _serde::export::Ok(__Field::__field3), + b"display_name" => + _serde::export::Ok(__Field::__field4), + b"followers_count" => + _serde::export::Ok(__Field::__field5), + b"following_count" => + _serde::export::Ok(__Field::__field6), + b"header" => + _serde::export::Ok(__Field::__field7), + b"header_static" => + _serde::export::Ok(__Field::__field8), + b"id" => + _serde::export::Ok(__Field::__field9), + b"locked" => + _serde::export::Ok(__Field::__field10), + b"note" => + _serde::export::Ok(__Field::__field11), + b"statuses_count" => + _serde::export::Ok(__Field::__field12), + b"url" => + _serde::export::Ok(__Field::__field13), + b"username" => + _serde::export::Ok(__Field::__field14), + b"source" => + _serde::export::Ok(__Field::__field15), + b"moved" => + _serde::export::Ok(__Field::__field16), + b"fields" => + _serde::export::Ok(__Field::__field17), + b"bot" => + _serde::export::Ok(__Field::__field18), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = Account; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct Account") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct Account with 19 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct Account with 19 elements")); + } + }; + let __field2 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(2usize, + &"struct Account with 19 elements")); + } + }; + let __field3 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(3usize, + &"struct Account with 19 elements")); + } + }; + let __field4 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(4usize, + &"struct Account with 19 elements")); + } + }; + let __field5 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(5usize, + &"struct Account with 19 elements")); + } + }; + let __field6 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(6usize, + &"struct Account with 19 elements")); + } + }; + let __field7 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(7usize, + &"struct Account with 19 elements")); + } + }; + let __field8 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(8usize, + &"struct Account with 19 elements")); + } + }; + let __field9 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(9usize, + &"struct Account with 19 elements")); + } + }; + let __field10 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(10usize, + &"struct Account with 19 elements")); + } + }; + let __field11 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(11usize, + &"struct Account with 19 elements")); + } + }; + let __field12 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(12usize, + &"struct Account with 19 elements")); + } + }; + let __field13 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(13usize, + &"struct Account with 19 elements")); + } + }; + let __field14 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(14usize, + &"struct Account with 19 elements")); + } + }; + let __field15 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(15usize, + &"struct Account with 19 elements")); + } + }; + let __field16 = + match match _serde::de::SeqAccess::next_element::>>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(16usize, + &"struct Account with 19 elements")); + } + }; + let __field17 = + match match _serde::de::SeqAccess::next_element::>>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(17usize, + &"struct Account with 19 elements")); + } + }; + let __field18 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(18usize, + &"struct Account with 19 elements")); + } + }; + _serde::export::Ok(Account{acct: __field0, + avatar: __field1, + avatar_static: + __field2, + created_at: + __field3, + display_name: + __field4, + followers_count: + __field5, + following_count: + __field6, + header: __field7, + header_static: + __field8, + id: __field9, + locked: __field10, + note: __field11, + statuses_count: + __field12, + url: __field13, + username: + __field14, + source: __field15, + moved: __field16, + fields: __field17, + bot: __field18,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option = + _serde::export::None; + let mut __field1: + _serde::export::Option = + _serde::export::None; + let mut __field2: + _serde::export::Option = + _serde::export::None; + let mut __field3: + _serde::export::Option> = + _serde::export::None; + let mut __field4: + _serde::export::Option = + _serde::export::None; + let mut __field5: + _serde::export::Option = + _serde::export::None; + let mut __field6: + _serde::export::Option = + _serde::export::None; + let mut __field7: + _serde::export::Option = + _serde::export::None; + let mut __field8: + _serde::export::Option = + _serde::export::None; + let mut __field9: + _serde::export::Option = + _serde::export::None; + let mut __field10: + _serde::export::Option = + _serde::export::None; + let mut __field11: + _serde::export::Option = + _serde::export::None; + let mut __field12: + _serde::export::Option = + _serde::export::None; + let mut __field13: + _serde::export::Option = + _serde::export::None; + let mut __field14: + _serde::export::Option = + _serde::export::None; + let mut __field15: + _serde::export::Option> = + _serde::export::None; + let mut __field16: + _serde::export::Option>> = + _serde::export::None; + let mut __field17: + _serde::export::Option>> = + _serde::export::None; + let mut __field18: + _serde::export::Option> = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("acct")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("avatar")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("avatar_static")); + } + __field2 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field3 => { + if _serde::export::Option::is_some(&__field3) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("created_at")); + } + __field3 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field4 => { + if _serde::export::Option::is_some(&__field4) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("display_name")); + } + __field4 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field5 => { + if _serde::export::Option::is_some(&__field5) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("followers_count")); + } + __field5 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field6 => { + if _serde::export::Option::is_some(&__field6) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("following_count")); + } + __field6 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field7 => { + if _serde::export::Option::is_some(&__field7) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("header")); + } + __field7 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field8 => { + if _serde::export::Option::is_some(&__field8) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("header_static")); + } + __field8 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field9 => { + if _serde::export::Option::is_some(&__field9) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("id")); + } + __field9 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field10 => { + if _serde::export::Option::is_some(&__field10) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("locked")); + } + __field10 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field11 => { + if _serde::export::Option::is_some(&__field11) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("note")); + } + __field11 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field12 => { + if _serde::export::Option::is_some(&__field12) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("statuses_count")); + } + __field12 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field13 => { + if _serde::export::Option::is_some(&__field13) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("url")); + } + __field13 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field14 => { + if _serde::export::Option::is_some(&__field14) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("username")); + } + __field14 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field15 => { + if _serde::export::Option::is_some(&__field15) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("source")); + } + __field15 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field16 => { + if _serde::export::Option::is_some(&__field16) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("moved")); + } + __field16 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field17 => { + if _serde::export::Option::is_some(&__field17) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("fields")); + } + __field17 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field18 => { + if _serde::export::Option::is_some(&__field18) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("bot")); + } + __field18 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("acct") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("avatar") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field2 = + match __field2 { + _serde::export::Some(__field2) => + __field2, + _serde::export::None => + match _serde::private::de::missing_field("avatar_static") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field3 = + match __field3 { + _serde::export::Some(__field3) => + __field3, + _serde::export::None => + match _serde::private::de::missing_field("created_at") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field4 = + match __field4 { + _serde::export::Some(__field4) => + __field4, + _serde::export::None => + match _serde::private::de::missing_field("display_name") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field5 = + match __field5 { + _serde::export::Some(__field5) => + __field5, + _serde::export::None => + match _serde::private::de::missing_field("followers_count") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field6 = + match __field6 { + _serde::export::Some(__field6) => + __field6, + _serde::export::None => + match _serde::private::de::missing_field("following_count") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field7 = + match __field7 { + _serde::export::Some(__field7) => + __field7, + _serde::export::None => + match _serde::private::de::missing_field("header") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field8 = + match __field8 { + _serde::export::Some(__field8) => + __field8, + _serde::export::None => + match _serde::private::de::missing_field("header_static") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field9 = + match __field9 { + _serde::export::Some(__field9) => + __field9, + _serde::export::None => + match _serde::private::de::missing_field("id") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field10 = + match __field10 { + _serde::export::Some(__field10) => + __field10, + _serde::export::None => + match _serde::private::de::missing_field("locked") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field11 = + match __field11 { + _serde::export::Some(__field11) => + __field11, + _serde::export::None => + match _serde::private::de::missing_field("note") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field12 = + match __field12 { + _serde::export::Some(__field12) => + __field12, + _serde::export::None => + match _serde::private::de::missing_field("statuses_count") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field13 = + match __field13 { + _serde::export::Some(__field13) => + __field13, + _serde::export::None => + match _serde::private::de::missing_field("url") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field14 = + match __field14 { + _serde::export::Some(__field14) => + __field14, + _serde::export::None => + match _serde::private::de::missing_field("username") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field15 = + match __field15 { + _serde::export::Some(__field15) => + __field15, + _serde::export::None => + match _serde::private::de::missing_field("source") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field16 = + match __field16 { + _serde::export::Some(__field16) => + __field16, + _serde::export::None => + match _serde::private::de::missing_field("moved") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field17 = + match __field17 { + _serde::export::Some(__field17) => + __field17, + _serde::export::None => + match _serde::private::de::missing_field("fields") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field18 = + match __field18 { + _serde::export::Some(__field18) => + __field18, + _serde::export::None => + match _serde::private::de::missing_field("bot") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(Account{acct: __field0, + avatar: __field1, + avatar_static: + __field2, + created_at: + __field3, + display_name: + __field4, + followers_count: + __field5, + following_count: + __field6, + header: __field7, + header_static: + __field8, + id: __field9, + locked: __field10, + note: __field11, + statuses_count: + __field12, + url: __field13, + username: + __field14, + source: __field15, + moved: __field16, + fields: __field17, + bot: __field18,}) + } + } + const FIELDS: &'static [&'static str] = + &["acct", "avatar", "avatar_static", "created_at", + "display_name", "followers_count", + "following_count", "header", "header_static", + "id", "locked", "note", "statuses_count", "url", + "username", "source", "moved", "fields", "bot"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "Account", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl ::core::marker::StructuralPartialEq for Account { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Account { + #[inline] + fn eq(&self, other: &Account) -> bool { + match *other { + Account { + acct: ref __self_1_0, + avatar: ref __self_1_1, + avatar_static: ref __self_1_2, + created_at: ref __self_1_3, + display_name: ref __self_1_4, + followers_count: ref __self_1_5, + following_count: ref __self_1_6, + header: ref __self_1_7, + header_static: ref __self_1_8, + id: ref __self_1_9, + locked: ref __self_1_10, + note: ref __self_1_11, + statuses_count: ref __self_1_12, + url: ref __self_1_13, + username: ref __self_1_14, + source: ref __self_1_15, + moved: ref __self_1_16, + fields: ref __self_1_17, + bot: ref __self_1_18 } => + match *self { + Account { + acct: ref __self_0_0, + avatar: ref __self_0_1, + avatar_static: ref __self_0_2, + created_at: ref __self_0_3, + display_name: ref __self_0_4, + followers_count: ref __self_0_5, + following_count: ref __self_0_6, + header: ref __self_0_7, + header_static: ref __self_0_8, + id: ref __self_0_9, + locked: ref __self_0_10, + note: ref __self_0_11, + statuses_count: ref __self_0_12, + url: ref __self_0_13, + username: ref __self_0_14, + source: ref __self_0_15, + moved: ref __self_0_16, + fields: ref __self_0_17, + bot: ref __self_0_18 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3) && + (*__self_0_4) == (*__self_1_4) && + (*__self_0_5) == (*__self_1_5) && + (*__self_0_6) == (*__self_1_6) && + (*__self_0_7) == (*__self_1_7) && + (*__self_0_8) == (*__self_1_8) && + (*__self_0_9) == (*__self_1_9) && + (*__self_0_10) == (*__self_1_10) && + (*__self_0_11) == (*__self_1_11) && + (*__self_0_12) == (*__self_1_12) && + (*__self_0_13) == (*__self_1_13) && + (*__self_0_14) == (*__self_1_14) && + (*__self_0_15) == (*__self_1_15) && + (*__self_0_16) == (*__self_1_16) && + (*__self_0_17) == (*__self_1_17) && + (*__self_0_18) == (*__self_1_18), + }, + } + } + #[inline] + fn ne(&self, other: &Account) -> bool { + match *other { + Account { + acct: ref __self_1_0, + avatar: ref __self_1_1, + avatar_static: ref __self_1_2, + created_at: ref __self_1_3, + display_name: ref __self_1_4, + followers_count: ref __self_1_5, + following_count: ref __self_1_6, + header: ref __self_1_7, + header_static: ref __self_1_8, + id: ref __self_1_9, + locked: ref __self_1_10, + note: ref __self_1_11, + statuses_count: ref __self_1_12, + url: ref __self_1_13, + username: ref __self_1_14, + source: ref __self_1_15, + moved: ref __self_1_16, + fields: ref __self_1_17, + bot: ref __self_1_18 } => + match *self { + Account { + acct: ref __self_0_0, + avatar: ref __self_0_1, + avatar_static: ref __self_0_2, + created_at: ref __self_0_3, + display_name: ref __self_0_4, + followers_count: ref __self_0_5, + following_count: ref __self_0_6, + header: ref __self_0_7, + header_static: ref __self_0_8, + id: ref __self_0_9, + locked: ref __self_0_10, + note: ref __self_0_11, + statuses_count: ref __self_0_12, + url: ref __self_0_13, + username: ref __self_0_14, + source: ref __self_0_15, + moved: ref __self_0_16, + fields: ref __self_0_17, + bot: ref __self_0_18 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3) || + (*__self_0_4) != (*__self_1_4) || + (*__self_0_5) != (*__self_1_5) || + (*__self_0_6) != (*__self_1_6) || + (*__self_0_7) != (*__self_1_7) || + (*__self_0_8) != (*__self_1_8) || + (*__self_0_9) != (*__self_1_9) || + (*__self_0_10) != (*__self_1_10) || + (*__self_0_11) != (*__self_1_11) || + (*__self_0_12) != (*__self_1_12) || + (*__self_0_13) != (*__self_1_13) || + (*__self_0_14) != (*__self_1_14) || + (*__self_0_15) != (*__self_1_15) || + (*__self_0_16) != (*__self_1_16) || + (*__self_0_17) != (*__self_1_17) || + (*__self_0_18) != (*__self_1_18), + }, + } + } + } + /// A single name: value pair from a user's profile + pub struct MetadataField { + /// name part of metadata + pub name: String, + /// value part of metadata + pub value: String, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for MetadataField { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + MetadataField { + name: ref __self_0_0, value: ref __self_0_1 } => { + let mut debug_trait_builder = + f.debug_struct("MetadataField"); + let _ = + debug_trait_builder.field("name", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("value", + &&(*__self_0_1)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for MetadataField { + #[inline] + fn clone(&self) -> MetadataField { + match *self { + MetadataField { + name: ref __self_0_0, value: ref __self_0_1 } => + MetadataField{name: + ::core::clone::Clone::clone(&(*__self_0_0)), + value: + ::core::clone::Clone::clone(&(*__self_0_1)),}, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_SERIALIZE_FOR_MetadataField: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl _serde::Serialize for MetadataField { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "MetadataField", + false + as + usize + + 1 + + + 1) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "name", + &self.name) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "value", + &self.value) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_MetadataField: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for MetadataField { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { __field0, __field1, __ignore, } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 2")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "name" => + _serde::export::Ok(__Field::__field0), + "value" => + _serde::export::Ok(__Field::__field1), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"name" => + _serde::export::Ok(__Field::__field0), + b"value" => + _serde::export::Ok(__Field::__field1), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = MetadataField; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct MetadataField") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct MetadataField with 2 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct MetadataField with 2 elements")); + } + }; + _serde::export::Ok(MetadataField{name: + __field0, + value: + __field1,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option = + _serde::export::None; + let mut __field1: + _serde::export::Option = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("name")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("value")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("name") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("value") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(MetadataField{name: + __field0, + value: + __field1,}) + } + } + const FIELDS: &'static [&'static str] = + &["name", "value"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "MetadataField", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl ::core::marker::StructuralPartialEq for MetadataField { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for MetadataField { + #[inline] + fn eq(&self, other: &MetadataField) -> bool { + match *other { + MetadataField { + name: ref __self_1_0, value: ref __self_1_1 } => + match *self { + MetadataField { + name: ref __self_0_0, value: ref __self_0_1 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1), + }, + } + } + #[inline] + fn ne(&self, other: &MetadataField) -> bool { + match *other { + MetadataField { + name: ref __self_1_0, value: ref __self_1_1 } => + match *self { + MetadataField { + name: ref __self_0_0, value: ref __self_0_1 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1), + }, + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::default::Default for MetadataField { + #[inline] + fn default() -> MetadataField { + MetadataField{name: ::core::default::Default::default(), + value: ::core::default::Default::default(),} + } + } + impl MetadataField { + pub(crate) fn new(name: &str, value: &str) -> MetadataField { + MetadataField{name: name.into(), value: value.into(),} + } + } + /// An extra object given from `verify_credentials` giving defaults about a user + pub struct Source { + privacy: Option, + #[serde(deserialize_with = "string_or_bool")] + sensitive: bool, + note: Option, + fields: Option>, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Source { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Source { + privacy: ref __self_0_0, + sensitive: ref __self_0_1, + note: ref __self_0_2, + fields: ref __self_0_3 } => { + let mut debug_trait_builder = + f.debug_struct("Source"); + let _ = + debug_trait_builder.field("privacy", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("sensitive", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("note", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("fields", + &&(*__self_0_3)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Source { + #[inline] + fn clone(&self) -> Source { + match *self { + Source { + privacy: ref __self_0_0, + sensitive: ref __self_0_1, + note: ref __self_0_2, + fields: ref __self_0_3 } => + Source{privacy: + ::core::clone::Clone::clone(&(*__self_0_0)), + sensitive: + ::core::clone::Clone::clone(&(*__self_0_1)), + note: ::core::clone::Clone::clone(&(*__self_0_2)), + fields: + ::core::clone::Clone::clone(&(*__self_0_3)),}, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Source: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Source { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + 2u64 => + _serde::export::Ok(__Field::__field2), + 3u64 => + _serde::export::Ok(__Field::__field3), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 4")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "privacy" => + _serde::export::Ok(__Field::__field0), + "sensitive" => + _serde::export::Ok(__Field::__field1), + "note" => + _serde::export::Ok(__Field::__field2), + "fields" => + _serde::export::Ok(__Field::__field3), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"privacy" => + _serde::export::Ok(__Field::__field0), + b"sensitive" => + _serde::export::Ok(__Field::__field1), + b"note" => + _serde::export::Ok(__Field::__field2), + b"fields" => + _serde::export::Ok(__Field::__field3), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = Source; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct Source") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct Source with 4 elements")); + } + }; + let __field1 = + match { + struct __DeserializeWith<'de> { + value: bool, + phantom: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> + _serde::Deserialize<'de> for + __DeserializeWith<'de> { + fn deserialize<__D>(__deserializer: + __D) + -> + _serde::export::Result + where + __D: _serde::Deserializer<'de> { + _serde::export::Ok(__DeserializeWith{value: + match string_or_bool(__deserializer) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => + { + return _serde::export::Err(__err); + } + }, + phantom: + _serde::export::PhantomData, + lifetime: + _serde::export::PhantomData,}) + } + } + _serde::export::Option::map(match _serde::de::SeqAccess::next_element::<__DeserializeWith<'de>>(&mut __seq) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => + { + return _serde::export::Err(__err); + } + }, + |__wrap| + __wrap.value) + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct Source with 4 elements")); + } + }; + let __field2 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(2usize, + &"struct Source with 4 elements")); + } + }; + let __field3 = + match match _serde::de::SeqAccess::next_element::>>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(3usize, + &"struct Source with 4 elements")); + } + }; + _serde::export::Ok(Source{privacy: __field0, + sensitive: __field1, + note: __field2, + fields: __field3,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option> = + _serde::export::None; + let mut __field1: + _serde::export::Option = + _serde::export::None; + let mut __field2: + _serde::export::Option> = + _serde::export::None; + let mut __field3: + _serde::export::Option>> = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("privacy")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("sensitive")); + } + __field1 = + _serde::export::Some({ + struct __DeserializeWith<'de> { + value: bool, + phantom: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> + _serde::Deserialize<'de> + for + __DeserializeWith<'de> + { + fn deserialize<__D>(__deserializer: + __D) + -> + _serde::export::Result + where + __D: _serde::Deserializer<'de> { + _serde::export::Ok(__DeserializeWith{value: + match string_or_bool(__deserializer) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => + { + return _serde::export::Err(__err); + } + }, + phantom: + _serde::export::PhantomData, + lifetime: + _serde::export::PhantomData,}) + } + } + match _serde::de::MapAccess::next_value::<__DeserializeWith<'de>>(&mut __map) + { + _serde::export::Ok(__wrapper) + => + __wrapper.value, + _serde::export::Err(__err) + => + { + return _serde::export::Err(__err); + } + } + }); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("note")); + } + __field2 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field3 => { + if _serde::export::Option::is_some(&__field3) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("fields")); + } + __field3 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("privacy") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::missing_field("sensitive")), + }; + let __field2 = + match __field2 { + _serde::export::Some(__field2) => + __field2, + _serde::export::None => + match _serde::private::de::missing_field("note") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field3 = + match __field3 { + _serde::export::Some(__field3) => + __field3, + _serde::export::None => + match _serde::private::de::missing_field("fields") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(Source{privacy: __field0, + sensitive: __field1, + note: __field2, + fields: __field3,}) + } + } + const FIELDS: &'static [&'static str] = + &["privacy", "sensitive", "note", "fields"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "Source", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl ::core::marker::StructuralPartialEq for Source { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Source { + #[inline] + fn eq(&self, other: &Source) -> bool { + match *other { + Source { + privacy: ref __self_1_0, + sensitive: ref __self_1_1, + note: ref __self_1_2, + fields: ref __self_1_3 } => + match *self { + Source { + privacy: ref __self_0_0, + sensitive: ref __self_0_1, + note: ref __self_0_2, + fields: ref __self_0_3 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3), + }, + } + } + #[inline] + fn ne(&self, other: &Source) -> bool { + match *other { + Source { + privacy: ref __self_1_0, + sensitive: ref __self_1_1, + note: ref __self_1_2, + fields: ref __self_1_3 } => + match *self { + Source { + privacy: ref __self_0_0, + sensitive: ref __self_0_1, + note: ref __self_0_2, + fields: ref __self_0_3 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3), + }, + } + } + } + fn string_or_bool<'de, D: Deserializer<'de>>(val: D) + -> ::std::result::Result { + #[serde(untagged)] + pub enum BoolOrString { Bool(bool), Str(String), } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for BoolOrString { + #[inline] + fn clone(&self) -> BoolOrString { + match (&*self,) { + (&BoolOrString::Bool(ref __self_0),) => + BoolOrString::Bool(::core::clone::Clone::clone(&(*__self_0))), + (&BoolOrString::Str(ref __self_0),) => + BoolOrString::Str(::core::clone::Clone::clone(&(*__self_0))), + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for BoolOrString { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match (&*self,) { + (&BoolOrString::Bool(ref __self_0),) => { + let mut debug_trait_builder = + f.debug_tuple("Bool"); + let _ = debug_trait_builder.field(&&(*__self_0)); + debug_trait_builder.finish() + } + (&BoolOrString::Str(ref __self_0),) => { + let mut debug_trait_builder = + f.debug_tuple("Str"); + let _ = debug_trait_builder.field(&&(*__self_0)); + debug_trait_builder.finish() + } + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_BoolOrString: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde + :: export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for BoolOrString { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + let __content = + match <_serde::private::de::Content as + _serde::Deserialize>::deserialize(__deserializer) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + if let _serde::export::Ok(__ok) = + _serde::export::Result::map(::deserialize(_serde::private::de::ContentRefDeserializer::<__D::Error>::new(&__content)), + BoolOrString::Bool) + { + return _serde::export::Ok(__ok); + } + if let _serde::export::Ok(__ok) = + _serde::export::Result::map(::deserialize(_serde::private::de::ContentRefDeserializer::<__D::Error>::new(&__content)), + BoolOrString::Str) + { + return _serde::export::Ok(__ok); + } + _serde::export::Err(_serde::de::Error::custom("data did not match any variant of untagged enum BoolOrString")) + } + } + }; + impl ::core::marker::StructuralPartialEq for BoolOrString { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for BoolOrString { + #[inline] + fn eq(&self, other: &BoolOrString) -> bool { + { + let __self_vi = + unsafe { + ::core::intrinsics::discriminant_value(&*self) + }; + let __arg_1_vi = + unsafe { + ::core::intrinsics::discriminant_value(&*other) + }; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { + (&BoolOrString::Bool(ref __self_0), + &BoolOrString::Bool(ref __arg_1_0)) => + (*__self_0) == (*__arg_1_0), + (&BoolOrString::Str(ref __self_0), + &BoolOrString::Str(ref __arg_1_0)) => + (*__self_0) == (*__arg_1_0), + _ => unsafe { + ::core::intrinsics::unreachable() + } + } + } else { false } + } + } + #[inline] + fn ne(&self, other: &BoolOrString) -> bool { + { + let __self_vi = + unsafe { + ::core::intrinsics::discriminant_value(&*self) + }; + let __arg_1_vi = + unsafe { + ::core::intrinsics::discriminant_value(&*other) + }; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { + (&BoolOrString::Bool(ref __self_0), + &BoolOrString::Bool(ref __arg_1_0)) => + (*__self_0) != (*__arg_1_0), + (&BoolOrString::Str(ref __self_0), + &BoolOrString::Str(ref __arg_1_0)) => + (*__self_0) != (*__arg_1_0), + _ => unsafe { + ::core::intrinsics::unreachable() + } + } + } else { true } + } + } + } + Ok(match BoolOrString::deserialize(val)? { + BoolOrString::Bool(b) => b, + BoolOrString::Str(ref s) => { + if s == "true" { + true + } else if s == "false" { + false + } else { + return Err(de::Error::invalid_value(Unexpected::Str(s), + &"true or false")); + } + } + }) + } + pub(crate) struct UpdateSource { + #[serde(skip_serializing_if = "Option::is_none")] + pub(crate) privacy: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub(crate) sensitive: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for UpdateSource { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + UpdateSource { + privacy: ref __self_0_0, sensitive: ref __self_0_1 } => { + let mut debug_trait_builder = + f.debug_struct("UpdateSource"); + let _ = + debug_trait_builder.field("privacy", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("sensitive", + &&(*__self_0_1)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::default::Default for UpdateSource { + #[inline] + fn default() -> UpdateSource { + UpdateSource{privacy: ::core::default::Default::default(), + sensitive: ::core::default::Default::default(),} + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for UpdateSource { + #[inline] + fn clone(&self) -> UpdateSource { + match *self { + UpdateSource { + privacy: ref __self_0_0, sensitive: ref __self_0_1 } => + UpdateSource{privacy: + ::core::clone::Clone::clone(&(*__self_0_0)), + sensitive: + ::core::clone::Clone::clone(&(*__self_0_1)),}, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_SERIALIZE_FOR_UpdateSource: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl _serde::Serialize for UpdateSource { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "UpdateSource", + false + as + usize + + + if Option::is_none(&self.privacy) + { + 0 + } else { + 1 + } + + if Option::is_none(&self.sensitive) + { + 0 + } else { + 1 + }) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + if !Option::is_none(&self.privacy) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "privacy", + &self.privacy) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "privacy") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + if !Option::is_none(&self.sensitive) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "sensitive", + &self.sensitive) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "sensitive") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::marker::StructuralPartialEq for UpdateSource { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for UpdateSource { + #[inline] + fn eq(&self, other: &UpdateSource) -> bool { + match *other { + UpdateSource { + privacy: ref __self_1_0, sensitive: ref __self_1_1 } => + match *self { + UpdateSource { + privacy: ref __self_0_0, sensitive: ref __self_0_1 } + => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1), + }, + } + } + #[inline] + fn ne(&self, other: &UpdateSource) -> bool { + match *other { + UpdateSource { + privacy: ref __self_1_0, sensitive: ref __self_1_1 } => + match *self { + UpdateSource { + privacy: ref __self_0_0, sensitive: ref __self_0_1 } + => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1), + }, + } + } + } + pub(crate) struct Credentials { + #[serde(skip_serializing_if = "Option::is_none")] + pub(crate) display_name: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub(crate) note: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub(crate) avatar: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub(crate) header: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub(crate) source: Option, + #[serde(serialize_with = "fields_attributes_ser::ser")] + pub(crate) fields_attributes: Vec, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Credentials { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Credentials { + display_name: ref __self_0_0, + note: ref __self_0_1, + avatar: ref __self_0_2, + header: ref __self_0_3, + source: ref __self_0_4, + fields_attributes: ref __self_0_5 } => { + let mut debug_trait_builder = + f.debug_struct("Credentials"); + let _ = + debug_trait_builder.field("display_name", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("note", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("avatar", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("header", + &&(*__self_0_3)); + let _ = + debug_trait_builder.field("source", + &&(*__self_0_4)); + let _ = + debug_trait_builder.field("fields_attributes", + &&(*__self_0_5)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::default::Default for Credentials { + #[inline] + fn default() -> Credentials { + Credentials{display_name: ::core::default::Default::default(), + note: ::core::default::Default::default(), + avatar: ::core::default::Default::default(), + header: ::core::default::Default::default(), + source: ::core::default::Default::default(), + fields_attributes: + ::core::default::Default::default(),} + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_SERIALIZE_FOR_Credentials: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl _serde::Serialize for Credentials { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "Credentials", + false + as + usize + + + if Option::is_none(&self.display_name) + { + 0 + } else { + 1 + } + + if Option::is_none(&self.note) + { + 0 + } else { + 1 + } + + if Option::is_none(&self.avatar) + { + 0 + } else { + 1 + } + + if Option::is_none(&self.header) + { + 0 + } else { + 1 + } + + if Option::is_none(&self.source) + { + 0 + } else { + 1 + } + + 1) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + if !Option::is_none(&self.display_name) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "display_name", + &self.display_name) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "display_name") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + if !Option::is_none(&self.note) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "note", + &self.note) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "note") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + if !Option::is_none(&self.avatar) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "avatar", + &self.avatar) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "avatar") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + if !Option::is_none(&self.header) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "header", + &self.header) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "header") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + if !Option::is_none(&self.source) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "source", + &self.source) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "source") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "fields_attributes", + { + struct __SerializeWith<'__a> { + values: (&'__a Vec,), + phantom: _serde::export::PhantomData, + } + impl <'__a> + _serde::Serialize + for + __SerializeWith<'__a> + { + fn serialize<__S>(&self, + __s: + __S) + -> + _serde::export::Result<__S::Ok, + __S::Error> + where + __S: _serde::Serializer { + fields_attributes_ser::ser(self.values.0, + __s) + } + } + &__SerializeWith{values: + (&self.fields_attributes,), + phantom: + _serde::export::PhantomData::,} + }) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::marker::StructuralPartialEq for Credentials { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Credentials { + #[inline] + fn eq(&self, other: &Credentials) -> bool { + match *other { + Credentials { + display_name: ref __self_1_0, + note: ref __self_1_1, + avatar: ref __self_1_2, + header: ref __self_1_3, + source: ref __self_1_4, + fields_attributes: ref __self_1_5 } => + match *self { + Credentials { + display_name: ref __self_0_0, + note: ref __self_0_1, + avatar: ref __self_0_2, + header: ref __self_0_3, + source: ref __self_0_4, + fields_attributes: ref __self_0_5 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3) && + (*__self_0_4) == (*__self_1_4) && + (*__self_0_5) == (*__self_1_5), + }, + } + } + #[inline] + fn ne(&self, other: &Credentials) -> bool { + match *other { + Credentials { + display_name: ref __self_1_0, + note: ref __self_1_1, + avatar: ref __self_1_2, + header: ref __self_1_3, + source: ref __self_1_4, + fields_attributes: ref __self_1_5 } => + match *self { + Credentials { + display_name: ref __self_0_0, + note: ref __self_0_1, + avatar: ref __self_0_2, + header: ref __self_0_3, + source: ref __self_0_4, + fields_attributes: ref __self_0_5 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3) || + (*__self_0_4) != (*__self_1_4) || + (*__self_0_5) != (*__self_1_5), + }, + } + } + } + mod fields_attributes_ser { + use super::*; + use serde::ser::{SerializeMap, Serializer}; + pub(crate) fn ser(attrs: &Vec, serializer: S) + -> Result where S: Serializer { + let mut map = serializer.serialize_map(Some(attrs.len()))?; + for (i, field) in attrs.iter().enumerate() { + map.serialize_entry(&i, &field)?; + } + map.end() + } + } + } + /// Data structures for ser/de of attachment-related resources + pub mod attachment { + //! Module containing everything related to media attachements. + /// A struct representing a media attachment. + pub struct Attachment { + /// ID of the attachment. + pub id: String, + /// The media type of an attachment. + #[serde(rename = "type")] + pub media_type: MediaType, + /// URL of the locally hosted version of the image. + pub url: String, + /// For remote images, the remote URL of the original image. + pub remote_url: Option, + /// URL of the preview image. + pub preview_url: String, + /// Shorter URL for the image, for insertion into text + /// (only present on local images) + pub text_url: Option, + /// Meta information about the attachment. + pub meta: Option, + /// Noop will be removed. + pub description: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Attachment { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Attachment { + id: ref __self_0_0, + media_type: ref __self_0_1, + url: ref __self_0_2, + remote_url: ref __self_0_3, + preview_url: ref __self_0_4, + text_url: ref __self_0_5, + meta: ref __self_0_6, + description: ref __self_0_7 } => { + let mut debug_trait_builder = + f.debug_struct("Attachment"); + let _ = + debug_trait_builder.field("id", &&(*__self_0_0)); + let _ = + debug_trait_builder.field("media_type", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("url", &&(*__self_0_2)); + let _ = + debug_trait_builder.field("remote_url", + &&(*__self_0_3)); + let _ = + debug_trait_builder.field("preview_url", + &&(*__self_0_4)); + let _ = + debug_trait_builder.field("text_url", + &&(*__self_0_5)); + let _ = + debug_trait_builder.field("meta", + &&(*__self_0_6)); + let _ = + debug_trait_builder.field("description", + &&(*__self_0_7)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Attachment { + #[inline] + fn clone(&self) -> Attachment { + match *self { + Attachment { + id: ref __self_0_0, + media_type: ref __self_0_1, + url: ref __self_0_2, + remote_url: ref __self_0_3, + preview_url: ref __self_0_4, + text_url: ref __self_0_5, + meta: ref __self_0_6, + description: ref __self_0_7 } => + Attachment{id: + ::core::clone::Clone::clone(&(*__self_0_0)), + media_type: + ::core::clone::Clone::clone(&(*__self_0_1)), + url: + ::core::clone::Clone::clone(&(*__self_0_2)), + remote_url: + ::core::clone::Clone::clone(&(*__self_0_3)), + preview_url: + ::core::clone::Clone::clone(&(*__self_0_4)), + text_url: + ::core::clone::Clone::clone(&(*__self_0_5)), + meta: + ::core::clone::Clone::clone(&(*__self_0_6)), + description: + ::core::clone::Clone::clone(&(*__self_0_7)),}, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Attachment: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Attachment { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __field4, + __field5, + __field6, + __field7, + __ignore, + } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + 2u64 => + _serde::export::Ok(__Field::__field2), + 3u64 => + _serde::export::Ok(__Field::__field3), + 4u64 => + _serde::export::Ok(__Field::__field4), + 5u64 => + _serde::export::Ok(__Field::__field5), + 6u64 => + _serde::export::Ok(__Field::__field6), + 7u64 => + _serde::export::Ok(__Field::__field7), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 8")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "id" => + _serde::export::Ok(__Field::__field0), + "type" => + _serde::export::Ok(__Field::__field1), + "url" => + _serde::export::Ok(__Field::__field2), + "remote_url" => + _serde::export::Ok(__Field::__field3), + "preview_url" => + _serde::export::Ok(__Field::__field4), + "text_url" => + _serde::export::Ok(__Field::__field5), + "meta" => + _serde::export::Ok(__Field::__field6), + "description" => + _serde::export::Ok(__Field::__field7), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"id" => + _serde::export::Ok(__Field::__field0), + b"type" => + _serde::export::Ok(__Field::__field1), + b"url" => + _serde::export::Ok(__Field::__field2), + b"remote_url" => + _serde::export::Ok(__Field::__field3), + b"preview_url" => + _serde::export::Ok(__Field::__field4), + b"text_url" => + _serde::export::Ok(__Field::__field5), + b"meta" => + _serde::export::Ok(__Field::__field6), + b"description" => + _serde::export::Ok(__Field::__field7), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = Attachment; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct Attachment") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct Attachment with 8 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct Attachment with 8 elements")); + } + }; + let __field2 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(2usize, + &"struct Attachment with 8 elements")); + } + }; + let __field3 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(3usize, + &"struct Attachment with 8 elements")); + } + }; + let __field4 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(4usize, + &"struct Attachment with 8 elements")); + } + }; + let __field5 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(5usize, + &"struct Attachment with 8 elements")); + } + }; + let __field6 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(6usize, + &"struct Attachment with 8 elements")); + } + }; + let __field7 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(7usize, + &"struct Attachment with 8 elements")); + } + }; + _serde::export::Ok(Attachment{id: __field0, + media_type: + __field1, + url: __field2, + remote_url: + __field3, + preview_url: + __field4, + text_url: + __field5, + meta: __field6, + description: + __field7,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option = + _serde::export::None; + let mut __field1: + _serde::export::Option = + _serde::export::None; + let mut __field2: + _serde::export::Option = + _serde::export::None; + let mut __field3: + _serde::export::Option> = + _serde::export::None; + let mut __field4: + _serde::export::Option = + _serde::export::None; + let mut __field5: + _serde::export::Option> = + _serde::export::None; + let mut __field6: + _serde::export::Option> = + _serde::export::None; + let mut __field7: + _serde::export::Option> = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("id")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("type")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("url")); + } + __field2 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field3 => { + if _serde::export::Option::is_some(&__field3) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("remote_url")); + } + __field3 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field4 => { + if _serde::export::Option::is_some(&__field4) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("preview_url")); + } + __field4 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field5 => { + if _serde::export::Option::is_some(&__field5) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("text_url")); + } + __field5 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field6 => { + if _serde::export::Option::is_some(&__field6) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("meta")); + } + __field6 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field7 => { + if _serde::export::Option::is_some(&__field7) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("description")); + } + __field7 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("id") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("type") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field2 = + match __field2 { + _serde::export::Some(__field2) => + __field2, + _serde::export::None => + match _serde::private::de::missing_field("url") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field3 = + match __field3 { + _serde::export::Some(__field3) => + __field3, + _serde::export::None => + match _serde::private::de::missing_field("remote_url") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field4 = + match __field4 { + _serde::export::Some(__field4) => + __field4, + _serde::export::None => + match _serde::private::de::missing_field("preview_url") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field5 = + match __field5 { + _serde::export::Some(__field5) => + __field5, + _serde::export::None => + match _serde::private::de::missing_field("text_url") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field6 = + match __field6 { + _serde::export::Some(__field6) => + __field6, + _serde::export::None => + match _serde::private::de::missing_field("meta") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field7 = + match __field7 { + _serde::export::Some(__field7) => + __field7, + _serde::export::None => + match _serde::private::de::missing_field("description") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(Attachment{id: __field0, + media_type: + __field1, + url: __field2, + remote_url: + __field3, + preview_url: + __field4, + text_url: + __field5, + meta: __field6, + description: + __field7,}) + } + } + const FIELDS: &'static [&'static str] = + &["id", "type", "url", "remote_url", + "preview_url", "text_url", "meta", + "description"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "Attachment", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl ::core::marker::StructuralPartialEq for Attachment { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Attachment { + #[inline] + fn eq(&self, other: &Attachment) -> bool { + match *other { + Attachment { + id: ref __self_1_0, + media_type: ref __self_1_1, + url: ref __self_1_2, + remote_url: ref __self_1_3, + preview_url: ref __self_1_4, + text_url: ref __self_1_5, + meta: ref __self_1_6, + description: ref __self_1_7 } => + match *self { + Attachment { + id: ref __self_0_0, + media_type: ref __self_0_1, + url: ref __self_0_2, + remote_url: ref __self_0_3, + preview_url: ref __self_0_4, + text_url: ref __self_0_5, + meta: ref __self_0_6, + description: ref __self_0_7 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3) && + (*__self_0_4) == (*__self_1_4) && + (*__self_0_5) == (*__self_1_5) && + (*__self_0_6) == (*__self_1_6) && + (*__self_0_7) == (*__self_1_7), + }, + } + } + #[inline] + fn ne(&self, other: &Attachment) -> bool { + match *other { + Attachment { + id: ref __self_1_0, + media_type: ref __self_1_1, + url: ref __self_1_2, + remote_url: ref __self_1_3, + preview_url: ref __self_1_4, + text_url: ref __self_1_5, + meta: ref __self_1_6, + description: ref __self_1_7 } => + match *self { + Attachment { + id: ref __self_0_0, + media_type: ref __self_0_1, + url: ref __self_0_2, + remote_url: ref __self_0_3, + preview_url: ref __self_0_4, + text_url: ref __self_0_5, + meta: ref __self_0_6, + description: ref __self_0_7 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3) || + (*__self_0_4) != (*__self_1_4) || + (*__self_0_5) != (*__self_1_5) || + (*__self_0_6) != (*__self_1_6) || + (*__self_0_7) != (*__self_1_7), + }, + } + } + } + /// Information about the attachment itself. + pub struct Meta { + /// Original version. + pub original: Option, + /// Smaller version. + pub small: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Meta { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Meta { original: ref __self_0_0, small: ref __self_0_1 } + => { + let mut debug_trait_builder = f.debug_struct("Meta"); + let _ = + debug_trait_builder.field("original", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("small", + &&(*__self_0_1)); + debug_trait_builder.finish() + } + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Meta: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Meta { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { __field0, __field1, __ignore, } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 2")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "original" => + _serde::export::Ok(__Field::__field0), + "small" => + _serde::export::Ok(__Field::__field1), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"original" => + _serde::export::Ok(__Field::__field0), + b"small" => + _serde::export::Ok(__Field::__field1), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = Meta; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct Meta") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct Meta with 2 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct Meta with 2 elements")); + } + }; + _serde::export::Ok(Meta{original: __field0, + small: __field1,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option> = + _serde::export::None; + let mut __field1: + _serde::export::Option> = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("original")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("small")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("original") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("small") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(Meta{original: __field0, + small: __field1,}) + } + } + const FIELDS: &'static [&'static str] = + &["original", "small"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "Meta", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Meta { + #[inline] + fn clone(&self) -> Meta { + match *self { + Meta { original: ref __self_0_0, small: ref __self_0_1 } + => + Meta{original: + ::core::clone::Clone::clone(&(*__self_0_0)), + small: ::core::clone::Clone::clone(&(*__self_0_1)),}, + } + } + } + impl ::core::marker::StructuralPartialEq for Meta { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Meta { + #[inline] + fn eq(&self, other: &Meta) -> bool { + match *other { + Meta { original: ref __self_1_0, small: ref __self_1_1 } + => + match *self { + Meta { original: ref __self_0_0, small: ref __self_0_1 + } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1), + }, + } + } + #[inline] + fn ne(&self, other: &Meta) -> bool { + match *other { + Meta { original: ref __self_1_0, small: ref __self_1_1 } + => + match *self { + Meta { original: ref __self_0_0, small: ref __self_0_1 + } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1), + }, + } + } + } + /// Dimensions of an attachement. + pub struct ImageDetails { + /// width of attachment. + width: u64, + /// height of attachment. + height: u64, + /// A string of `widthxheight`. + size: Option, + /// The aspect ratio of the attachment. + aspect: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for ImageDetails { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + ImageDetails { + width: ref __self_0_0, + height: ref __self_0_1, + size: ref __self_0_2, + aspect: ref __self_0_3 } => { + let mut debug_trait_builder = + f.debug_struct("ImageDetails"); + let _ = + debug_trait_builder.field("width", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("height", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("size", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("aspect", + &&(*__self_0_3)); + debug_trait_builder.finish() + } + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_ImageDetails: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for ImageDetails { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + 2u64 => + _serde::export::Ok(__Field::__field2), + 3u64 => + _serde::export::Ok(__Field::__field3), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 4")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "width" => + _serde::export::Ok(__Field::__field0), + "height" => + _serde::export::Ok(__Field::__field1), + "size" => + _serde::export::Ok(__Field::__field2), + "aspect" => + _serde::export::Ok(__Field::__field3), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"width" => + _serde::export::Ok(__Field::__field0), + b"height" => + _serde::export::Ok(__Field::__field1), + b"size" => + _serde::export::Ok(__Field::__field2), + b"aspect" => + _serde::export::Ok(__Field::__field3), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = ImageDetails; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct ImageDetails") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct ImageDetails with 4 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct ImageDetails with 4 elements")); + } + }; + let __field2 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(2usize, + &"struct ImageDetails with 4 elements")); + } + }; + let __field3 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(3usize, + &"struct ImageDetails with 4 elements")); + } + }; + _serde::export::Ok(ImageDetails{width: + __field0, + height: + __field1, + size: + __field2, + aspect: + __field3,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option = + _serde::export::None; + let mut __field1: + _serde::export::Option = + _serde::export::None; + let mut __field2: + _serde::export::Option> = + _serde::export::None; + let mut __field3: + _serde::export::Option> = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("width")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("height")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("size")); + } + __field2 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field3 => { + if _serde::export::Option::is_some(&__field3) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("aspect")); + } + __field3 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("width") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("height") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field2 = + match __field2 { + _serde::export::Some(__field2) => + __field2, + _serde::export::None => + match _serde::private::de::missing_field("size") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field3 = + match __field3 { + _serde::export::Some(__field3) => + __field3, + _serde::export::None => + match _serde::private::de::missing_field("aspect") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(ImageDetails{width: + __field0, + height: + __field1, + size: + __field2, + aspect: + __field3,}) + } + } + const FIELDS: &'static [&'static str] = + &["width", "height", "size", "aspect"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "ImageDetails", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for ImageDetails { + #[inline] + fn clone(&self) -> ImageDetails { + match *self { + ImageDetails { + width: ref __self_0_0, + height: ref __self_0_1, + size: ref __self_0_2, + aspect: ref __self_0_3 } => + ImageDetails{width: + ::core::clone::Clone::clone(&(*__self_0_0)), + height: + ::core::clone::Clone::clone(&(*__self_0_1)), + size: + ::core::clone::Clone::clone(&(*__self_0_2)), + aspect: + ::core::clone::Clone::clone(&(*__self_0_3)),}, + } + } + } + impl ::core::marker::StructuralPartialEq for ImageDetails { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for ImageDetails { + #[inline] + fn eq(&self, other: &ImageDetails) -> bool { + match *other { + ImageDetails { + width: ref __self_1_0, + height: ref __self_1_1, + size: ref __self_1_2, + aspect: ref __self_1_3 } => + match *self { + ImageDetails { + width: ref __self_0_0, + height: ref __self_0_1, + size: ref __self_0_2, + aspect: ref __self_0_3 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3), + }, + } + } + #[inline] + fn ne(&self, other: &ImageDetails) -> bool { + match *other { + ImageDetails { + width: ref __self_1_0, + height: ref __self_1_1, + size: ref __self_1_2, + aspect: ref __self_1_3 } => + match *self { + ImageDetails { + width: ref __self_0_0, + height: ref __self_0_1, + size: ref __self_0_2, + aspect: ref __self_0_3 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3), + }, + } + } + } + /// The type of media attachment. + pub enum MediaType { + + /// An image. + #[serde(rename = "image")] + Image, + + /// A video file. + #[serde(rename = "video")] + Video, + + /// A gifv format file. + #[serde(rename = "gifv")] + Gifv, + + /// Unknown format. + #[serde(rename = "unknown")] + Unknown, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for MediaType { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match (&*self,) { + (&MediaType::Image,) => { + let mut debug_trait_builder = f.debug_tuple("Image"); + debug_trait_builder.finish() + } + (&MediaType::Video,) => { + let mut debug_trait_builder = f.debug_tuple("Video"); + debug_trait_builder.finish() + } + (&MediaType::Gifv,) => { + let mut debug_trait_builder = f.debug_tuple("Gifv"); + debug_trait_builder.finish() + } + (&MediaType::Unknown,) => { + let mut debug_trait_builder = + f.debug_tuple("Unknown"); + debug_trait_builder.finish() + } + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_MediaType: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for MediaType { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "variant identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + 2u64 => + _serde::export::Ok(__Field::__field2), + 3u64 => + _serde::export::Ok(__Field::__field3), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 4")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "image" => + _serde::export::Ok(__Field::__field0), + "video" => + _serde::export::Ok(__Field::__field1), + "gifv" => + _serde::export::Ok(__Field::__field2), + "unknown" => + _serde::export::Ok(__Field::__field3), + _ => { + _serde::export::Err(_serde::de::Error::unknown_variant(__value, + VARIANTS)) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"image" => + _serde::export::Ok(__Field::__field0), + b"video" => + _serde::export::Ok(__Field::__field1), + b"gifv" => + _serde::export::Ok(__Field::__field2), + b"unknown" => + _serde::export::Ok(__Field::__field3), + _ => { + let __value = + &_serde::export::from_utf8_lossy(__value); + _serde::export::Err(_serde::de::Error::unknown_variant(__value, + VARIANTS)) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = MediaType; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "enum MediaType") + } + fn visit_enum<__A>(self, __data: __A) + -> + _serde::export::Result where + __A: _serde::de::EnumAccess<'de> { + match match _serde::de::EnumAccess::variant(__data) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + (__Field::__field0, __variant) => { + match _serde::de::VariantAccess::unit_variant(__variant) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::export::Ok(MediaType::Image) + } + (__Field::__field1, __variant) => { + match _serde::de::VariantAccess::unit_variant(__variant) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::export::Ok(MediaType::Video) + } + (__Field::__field2, __variant) => { + match _serde::de::VariantAccess::unit_variant(__variant) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::export::Ok(MediaType::Gifv) + } + (__Field::__field3, __variant) => { + match _serde::de::VariantAccess::unit_variant(__variant) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::export::Ok(MediaType::Unknown) + } + } + } + } + const VARIANTS: &'static [&'static str] = + &["image", "video", "gifv", "unknown"]; + _serde::Deserializer::deserialize_enum(__deserializer, + "MediaType", + VARIANTS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for MediaType { + #[inline] + fn clone(&self) -> MediaType { { *self } } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::marker::Copy for MediaType { } + impl ::core::marker::StructuralPartialEq for MediaType { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for MediaType { + #[inline] + fn eq(&self, other: &MediaType) -> bool { + { + let __self_vi = + unsafe { + ::core::intrinsics::discriminant_value(&*self) + }; + let __arg_1_vi = + unsafe { + ::core::intrinsics::discriminant_value(&*other) + }; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { _ => true, } + } else { false } + } + } + } + } + /// Data structures for ser/de of card-related resources + pub mod card { + //! Module representing cards of statuses. + /// A card of a status. + pub struct Card { + /// The url associated with the card. + pub url: String, + /// The title of the card. + pub title: String, + /// The card description. + pub description: String, + /// The image associated with the card, if any. + pub image: Option, + /// OEmbed data + author_name: Option, + /// OEmbed data + author_url: Option, + /// OEmbed data + provider_name: Option, + /// OEmbed data + provider_url: Option, + /// OEmbed data + html: Option, + /// OEmbed data + width: Option, + /// OEmbed data + height: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Card { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Card { + url: ref __self_0_0, + title: ref __self_0_1, + description: ref __self_0_2, + image: ref __self_0_3, + author_name: ref __self_0_4, + author_url: ref __self_0_5, + provider_name: ref __self_0_6, + provider_url: ref __self_0_7, + html: ref __self_0_8, + width: ref __self_0_9, + height: ref __self_0_10 } => { + let mut debug_trait_builder = f.debug_struct("Card"); + let _ = + debug_trait_builder.field("url", &&(*__self_0_0)); + let _ = + debug_trait_builder.field("title", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("description", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("image", + &&(*__self_0_3)); + let _ = + debug_trait_builder.field("author_name", + &&(*__self_0_4)); + let _ = + debug_trait_builder.field("author_url", + &&(*__self_0_5)); + let _ = + debug_trait_builder.field("provider_name", + &&(*__self_0_6)); + let _ = + debug_trait_builder.field("provider_url", + &&(*__self_0_7)); + let _ = + debug_trait_builder.field("html", + &&(*__self_0_8)); + let _ = + debug_trait_builder.field("width", + &&(*__self_0_9)); + let _ = + debug_trait_builder.field("height", + &&(*__self_0_10)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Card { + #[inline] + fn clone(&self) -> Card { + match *self { + Card { + url: ref __self_0_0, + title: ref __self_0_1, + description: ref __self_0_2, + image: ref __self_0_3, + author_name: ref __self_0_4, + author_url: ref __self_0_5, + provider_name: ref __self_0_6, + provider_url: ref __self_0_7, + html: ref __self_0_8, + width: ref __self_0_9, + height: ref __self_0_10 } => + Card{url: ::core::clone::Clone::clone(&(*__self_0_0)), + title: ::core::clone::Clone::clone(&(*__self_0_1)), + description: + ::core::clone::Clone::clone(&(*__self_0_2)), + image: ::core::clone::Clone::clone(&(*__self_0_3)), + author_name: + ::core::clone::Clone::clone(&(*__self_0_4)), + author_url: + ::core::clone::Clone::clone(&(*__self_0_5)), + provider_name: + ::core::clone::Clone::clone(&(*__self_0_6)), + provider_url: + ::core::clone::Clone::clone(&(*__self_0_7)), + html: ::core::clone::Clone::clone(&(*__self_0_8)), + width: ::core::clone::Clone::clone(&(*__self_0_9)), + height: + ::core::clone::Clone::clone(&(*__self_0_10)),}, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Card: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Card { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __field4, + __field5, + __field6, + __field7, + __field8, + __field9, + __field10, + __ignore, + } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + 2u64 => + _serde::export::Ok(__Field::__field2), + 3u64 => + _serde::export::Ok(__Field::__field3), + 4u64 => + _serde::export::Ok(__Field::__field4), + 5u64 => + _serde::export::Ok(__Field::__field5), + 6u64 => + _serde::export::Ok(__Field::__field6), + 7u64 => + _serde::export::Ok(__Field::__field7), + 8u64 => + _serde::export::Ok(__Field::__field8), + 9u64 => + _serde::export::Ok(__Field::__field9), + 10u64 => + _serde::export::Ok(__Field::__field10), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 11")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "url" => + _serde::export::Ok(__Field::__field0), + "title" => + _serde::export::Ok(__Field::__field1), + "description" => + _serde::export::Ok(__Field::__field2), + "image" => + _serde::export::Ok(__Field::__field3), + "author_name" => + _serde::export::Ok(__Field::__field4), + "author_url" => + _serde::export::Ok(__Field::__field5), + "provider_name" => + _serde::export::Ok(__Field::__field6), + "provider_url" => + _serde::export::Ok(__Field::__field7), + "html" => + _serde::export::Ok(__Field::__field8), + "width" => + _serde::export::Ok(__Field::__field9), + "height" => + _serde::export::Ok(__Field::__field10), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"url" => + _serde::export::Ok(__Field::__field0), + b"title" => + _serde::export::Ok(__Field::__field1), + b"description" => + _serde::export::Ok(__Field::__field2), + b"image" => + _serde::export::Ok(__Field::__field3), + b"author_name" => + _serde::export::Ok(__Field::__field4), + b"author_url" => + _serde::export::Ok(__Field::__field5), + b"provider_name" => + _serde::export::Ok(__Field::__field6), + b"provider_url" => + _serde::export::Ok(__Field::__field7), + b"html" => + _serde::export::Ok(__Field::__field8), + b"width" => + _serde::export::Ok(__Field::__field9), + b"height" => + _serde::export::Ok(__Field::__field10), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = Card; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct Card") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct Card with 11 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct Card with 11 elements")); + } + }; + let __field2 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(2usize, + &"struct Card with 11 elements")); + } + }; + let __field3 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(3usize, + &"struct Card with 11 elements")); + } + }; + let __field4 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(4usize, + &"struct Card with 11 elements")); + } + }; + let __field5 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(5usize, + &"struct Card with 11 elements")); + } + }; + let __field6 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(6usize, + &"struct Card with 11 elements")); + } + }; + let __field7 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(7usize, + &"struct Card with 11 elements")); + } + }; + let __field8 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(8usize, + &"struct Card with 11 elements")); + } + }; + let __field9 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(9usize, + &"struct Card with 11 elements")); + } + }; + let __field10 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(10usize, + &"struct Card with 11 elements")); + } + }; + _serde::export::Ok(Card{url: __field0, + title: __field1, + description: __field2, + image: __field3, + author_name: __field4, + author_url: __field5, + provider_name: + __field6, + provider_url: + __field7, + html: __field8, + width: __field9, + height: __field10,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option = + _serde::export::None; + let mut __field1: + _serde::export::Option = + _serde::export::None; + let mut __field2: + _serde::export::Option = + _serde::export::None; + let mut __field3: + _serde::export::Option> = + _serde::export::None; + let mut __field4: + _serde::export::Option> = + _serde::export::None; + let mut __field5: + _serde::export::Option> = + _serde::export::None; + let mut __field6: + _serde::export::Option> = + _serde::export::None; + let mut __field7: + _serde::export::Option> = + _serde::export::None; + let mut __field8: + _serde::export::Option> = + _serde::export::None; + let mut __field9: + _serde::export::Option> = + _serde::export::None; + let mut __field10: + _serde::export::Option> = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("url")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("title")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("description")); + } + __field2 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field3 => { + if _serde::export::Option::is_some(&__field3) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("image")); + } + __field3 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field4 => { + if _serde::export::Option::is_some(&__field4) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("author_name")); + } + __field4 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field5 => { + if _serde::export::Option::is_some(&__field5) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("author_url")); + } + __field5 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field6 => { + if _serde::export::Option::is_some(&__field6) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("provider_name")); + } + __field6 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field7 => { + if _serde::export::Option::is_some(&__field7) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("provider_url")); + } + __field7 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field8 => { + if _serde::export::Option::is_some(&__field8) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("html")); + } + __field8 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field9 => { + if _serde::export::Option::is_some(&__field9) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("width")); + } + __field9 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field10 => { + if _serde::export::Option::is_some(&__field10) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("height")); + } + __field10 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("url") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("title") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field2 = + match __field2 { + _serde::export::Some(__field2) => + __field2, + _serde::export::None => + match _serde::private::de::missing_field("description") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field3 = + match __field3 { + _serde::export::Some(__field3) => + __field3, + _serde::export::None => + match _serde::private::de::missing_field("image") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field4 = + match __field4 { + _serde::export::Some(__field4) => + __field4, + _serde::export::None => + match _serde::private::de::missing_field("author_name") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field5 = + match __field5 { + _serde::export::Some(__field5) => + __field5, + _serde::export::None => + match _serde::private::de::missing_field("author_url") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field6 = + match __field6 { + _serde::export::Some(__field6) => + __field6, + _serde::export::None => + match _serde::private::de::missing_field("provider_name") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field7 = + match __field7 { + _serde::export::Some(__field7) => + __field7, + _serde::export::None => + match _serde::private::de::missing_field("provider_url") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field8 = + match __field8 { + _serde::export::Some(__field8) => + __field8, + _serde::export::None => + match _serde::private::de::missing_field("html") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field9 = + match __field9 { + _serde::export::Some(__field9) => + __field9, + _serde::export::None => + match _serde::private::de::missing_field("width") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field10 = + match __field10 { + _serde::export::Some(__field10) => + __field10, + _serde::export::None => + match _serde::private::de::missing_field("height") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(Card{url: __field0, + title: __field1, + description: __field2, + image: __field3, + author_name: __field4, + author_url: __field5, + provider_name: + __field6, + provider_url: + __field7, + html: __field8, + width: __field9, + height: __field10,}) + } + } + const FIELDS: &'static [&'static str] = + &["url", "title", "description", "image", + "author_name", "author_url", "provider_name", + "provider_url", "html", "width", "height"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "Card", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl ::core::marker::StructuralPartialEq for Card { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Card { + #[inline] + fn eq(&self, other: &Card) -> bool { + match *other { + Card { + url: ref __self_1_0, + title: ref __self_1_1, + description: ref __self_1_2, + image: ref __self_1_3, + author_name: ref __self_1_4, + author_url: ref __self_1_5, + provider_name: ref __self_1_6, + provider_url: ref __self_1_7, + html: ref __self_1_8, + width: ref __self_1_9, + height: ref __self_1_10 } => + match *self { + Card { + url: ref __self_0_0, + title: ref __self_0_1, + description: ref __self_0_2, + image: ref __self_0_3, + author_name: ref __self_0_4, + author_url: ref __self_0_5, + provider_name: ref __self_0_6, + provider_url: ref __self_0_7, + html: ref __self_0_8, + width: ref __self_0_9, + height: ref __self_0_10 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3) && + (*__self_0_4) == (*__self_1_4) && + (*__self_0_5) == (*__self_1_5) && + (*__self_0_6) == (*__self_1_6) && + (*__self_0_7) == (*__self_1_7) && + (*__self_0_8) == (*__self_1_8) && + (*__self_0_9) == (*__self_1_9) && + (*__self_0_10) == (*__self_1_10), + }, + } + } + #[inline] + fn ne(&self, other: &Card) -> bool { + match *other { + Card { + url: ref __self_1_0, + title: ref __self_1_1, + description: ref __self_1_2, + image: ref __self_1_3, + author_name: ref __self_1_4, + author_url: ref __self_1_5, + provider_name: ref __self_1_6, + provider_url: ref __self_1_7, + html: ref __self_1_8, + width: ref __self_1_9, + height: ref __self_1_10 } => + match *self { + Card { + url: ref __self_0_0, + title: ref __self_0_1, + description: ref __self_0_2, + image: ref __self_0_3, + author_name: ref __self_0_4, + author_url: ref __self_0_5, + provider_name: ref __self_0_6, + provider_url: ref __self_0_7, + html: ref __self_0_8, + width: ref __self_0_9, + height: ref __self_0_10 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3) || + (*__self_0_4) != (*__self_1_4) || + (*__self_0_5) != (*__self_1_5) || + (*__self_0_6) != (*__self_1_6) || + (*__self_0_7) != (*__self_1_7) || + (*__self_0_8) != (*__self_1_8) || + (*__self_0_9) != (*__self_1_9) || + (*__self_0_10) != (*__self_1_10), + }, + } + } + } + } + /// Data structures for ser/de of contetx-related resources + pub mod context { + //! A module about contexts of statuses. + use super::status::Status; + /// A context of a status returning a list of statuses it replied to and + /// statuses replied to it. + pub struct Context { + /// Statuses that were replied to. + pub ancestors: Vec, + /// Statuses that replied to this status. + pub descendants: Vec, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Context { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Context { + ancestors: ref __self_0_0, descendants: ref __self_0_1 } + => { + let mut debug_trait_builder = + f.debug_struct("Context"); + let _ = + debug_trait_builder.field("ancestors", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("descendants", + &&(*__self_0_1)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Context { + #[inline] + fn clone(&self) -> Context { + match *self { + Context { + ancestors: ref __self_0_0, descendants: ref __self_0_1 } + => + Context{ancestors: + ::core::clone::Clone::clone(&(*__self_0_0)), + descendants: + ::core::clone::Clone::clone(&(*__self_0_1)),}, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Context: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Context { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { __field0, __field1, __ignore, } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 2")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "ancestors" => + _serde::export::Ok(__Field::__field0), + "descendants" => + _serde::export::Ok(__Field::__field1), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"ancestors" => + _serde::export::Ok(__Field::__field0), + b"descendants" => + _serde::export::Ok(__Field::__field1), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = Context; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct Context") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct Context with 2 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct Context with 2 elements")); + } + }; + _serde::export::Ok(Context{ancestors: + __field0, + descendants: + __field1,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option> = + _serde::export::None; + let mut __field1: + _serde::export::Option> = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("ancestors")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("descendants")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("ancestors") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("descendants") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(Context{ancestors: + __field0, + descendants: + __field1,}) + } + } + const FIELDS: &'static [&'static str] = + &["ancestors", "descendants"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "Context", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl ::core::marker::StructuralPartialEq for Context { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Context { + #[inline] + fn eq(&self, other: &Context) -> bool { + match *other { + Context { + ancestors: ref __self_1_0, descendants: ref __self_1_1 } + => + match *self { + Context { + ancestors: ref __self_0_0, descendants: ref __self_0_1 + } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1), + }, + } + } + #[inline] + fn ne(&self, other: &Context) -> bool { + match *other { + Context { + ancestors: ref __self_1_0, descendants: ref __self_1_1 } + => + match *self { + Context { + ancestors: ref __self_0_0, descendants: ref __self_0_1 + } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1), + }, + } + } + } + } + /// Data structures for ser/de of streaming events + pub mod event { + use crate::entities::{notification::Notification, status::Status}; + /// Events that come from the /streaming/user API call + pub enum Event { + + /// Update event + Update(Status), + + /// Notification event + Notification(Notification), + + /// Delete event + Delete(String), + + /// FiltersChanged event + FiltersChanged, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Event { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match (&*self,) { + (&Event::Update(ref __self_0),) => { + let mut debug_trait_builder = f.debug_tuple("Update"); + let _ = debug_trait_builder.field(&&(*__self_0)); + debug_trait_builder.finish() + } + (&Event::Notification(ref __self_0),) => { + let mut debug_trait_builder = + f.debug_tuple("Notification"); + let _ = debug_trait_builder.field(&&(*__self_0)); + debug_trait_builder.finish() + } + (&Event::Delete(ref __self_0),) => { + let mut debug_trait_builder = f.debug_tuple("Delete"); + let _ = debug_trait_builder.field(&&(*__self_0)); + debug_trait_builder.finish() + } + (&Event::FiltersChanged,) => { + let mut debug_trait_builder = + f.debug_tuple("FiltersChanged"); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Event { + #[inline] + fn clone(&self) -> Event { + match (&*self,) { + (&Event::Update(ref __self_0),) => + Event::Update(::core::clone::Clone::clone(&(*__self_0))), + (&Event::Notification(ref __self_0),) => + Event::Notification(::core::clone::Clone::clone(&(*__self_0))), + (&Event::Delete(ref __self_0),) => + Event::Delete(::core::clone::Clone::clone(&(*__self_0))), + (&Event::FiltersChanged,) => Event::FiltersChanged, + } + } + } + } + /// Data structures for ser/de of filter-related resources + pub mod filter { + /// Represents a single Filter + pub struct Filter { + id: String, + phrase: String, + context: Vec, + expires_at: Option, + irreversible: bool, + whole_word: bool, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Filter { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Filter { + id: ref __self_0_0, + phrase: ref __self_0_1, + context: ref __self_0_2, + expires_at: ref __self_0_3, + irreversible: ref __self_0_4, + whole_word: ref __self_0_5 } => { + let mut debug_trait_builder = + f.debug_struct("Filter"); + let _ = + debug_trait_builder.field("id", &&(*__self_0_0)); + let _ = + debug_trait_builder.field("phrase", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("context", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("expires_at", + &&(*__self_0_3)); + let _ = + debug_trait_builder.field("irreversible", + &&(*__self_0_4)); + let _ = + debug_trait_builder.field("whole_word", + &&(*__self_0_5)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Filter { + #[inline] + fn clone(&self) -> Filter { + match *self { + Filter { + id: ref __self_0_0, + phrase: ref __self_0_1, + context: ref __self_0_2, + expires_at: ref __self_0_3, + irreversible: ref __self_0_4, + whole_word: ref __self_0_5 } => + Filter{id: ::core::clone::Clone::clone(&(*__self_0_0)), + phrase: + ::core::clone::Clone::clone(&(*__self_0_1)), + context: + ::core::clone::Clone::clone(&(*__self_0_2)), + expires_at: + ::core::clone::Clone::clone(&(*__self_0_3)), + irreversible: + ::core::clone::Clone::clone(&(*__self_0_4)), + whole_word: + ::core::clone::Clone::clone(&(*__self_0_5)),}, + } + } + } + impl ::core::marker::StructuralPartialEq for Filter { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Filter { + #[inline] + fn eq(&self, other: &Filter) -> bool { + match *other { + Filter { + id: ref __self_1_0, + phrase: ref __self_1_1, + context: ref __self_1_2, + expires_at: ref __self_1_3, + irreversible: ref __self_1_4, + whole_word: ref __self_1_5 } => + match *self { + Filter { + id: ref __self_0_0, + phrase: ref __self_0_1, + context: ref __self_0_2, + expires_at: ref __self_0_3, + irreversible: ref __self_0_4, + whole_word: ref __self_0_5 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3) && + (*__self_0_4) == (*__self_1_4) && + (*__self_0_5) == (*__self_1_5), + }, + } + } + #[inline] + fn ne(&self, other: &Filter) -> bool { + match *other { + Filter { + id: ref __self_1_0, + phrase: ref __self_1_1, + context: ref __self_1_2, + expires_at: ref __self_1_3, + irreversible: ref __self_1_4, + whole_word: ref __self_1_5 } => + match *self { + Filter { + id: ref __self_0_0, + phrase: ref __self_0_1, + context: ref __self_0_2, + expires_at: ref __self_0_3, + irreversible: ref __self_0_4, + whole_word: ref __self_0_5 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3) || + (*__self_0_4) != (*__self_1_4) || + (*__self_0_5) != (*__self_1_5), + }, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_SERIALIZE_FOR_Filter: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl _serde::Serialize for Filter { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "Filter", + false + as + usize + + 1 + + 1 + + 1 + + 1 + + 1 + + + 1) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "id", + &self.id) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "phrase", + &self.phrase) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "context", + &self.context) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "expires_at", + &self.expires_at) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "irreversible", + &self.irreversible) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "whole_word", + &self.whole_word) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Filter: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Filter { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __field4, + __field5, + __ignore, + } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + 2u64 => + _serde::export::Ok(__Field::__field2), + 3u64 => + _serde::export::Ok(__Field::__field3), + 4u64 => + _serde::export::Ok(__Field::__field4), + 5u64 => + _serde::export::Ok(__Field::__field5), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 6")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "id" => + _serde::export::Ok(__Field::__field0), + "phrase" => + _serde::export::Ok(__Field::__field1), + "context" => + _serde::export::Ok(__Field::__field2), + "expires_at" => + _serde::export::Ok(__Field::__field3), + "irreversible" => + _serde::export::Ok(__Field::__field4), + "whole_word" => + _serde::export::Ok(__Field::__field5), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"id" => + _serde::export::Ok(__Field::__field0), + b"phrase" => + _serde::export::Ok(__Field::__field1), + b"context" => + _serde::export::Ok(__Field::__field2), + b"expires_at" => + _serde::export::Ok(__Field::__field3), + b"irreversible" => + _serde::export::Ok(__Field::__field4), + b"whole_word" => + _serde::export::Ok(__Field::__field5), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = Filter; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct Filter") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct Filter with 6 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct Filter with 6 elements")); + } + }; + let __field2 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(2usize, + &"struct Filter with 6 elements")); + } + }; + let __field3 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(3usize, + &"struct Filter with 6 elements")); + } + }; + let __field4 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(4usize, + &"struct Filter with 6 elements")); + } + }; + let __field5 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(5usize, + &"struct Filter with 6 elements")); + } + }; + _serde::export::Ok(Filter{id: __field0, + phrase: __field1, + context: __field2, + expires_at: + __field3, + irreversible: + __field4, + whole_word: + __field5,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option = + _serde::export::None; + let mut __field1: + _serde::export::Option = + _serde::export::None; + let mut __field2: + _serde::export::Option> = + _serde::export::None; + let mut __field3: + _serde::export::Option> = + _serde::export::None; + let mut __field4: + _serde::export::Option = + _serde::export::None; + let mut __field5: + _serde::export::Option = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("id")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("phrase")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("context")); + } + __field2 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field3 => { + if _serde::export::Option::is_some(&__field3) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("expires_at")); + } + __field3 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field4 => { + if _serde::export::Option::is_some(&__field4) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("irreversible")); + } + __field4 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field5 => { + if _serde::export::Option::is_some(&__field5) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("whole_word")); + } + __field5 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("id") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("phrase") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field2 = + match __field2 { + _serde::export::Some(__field2) => + __field2, + _serde::export::None => + match _serde::private::de::missing_field("context") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field3 = + match __field3 { + _serde::export::Some(__field3) => + __field3, + _serde::export::None => + match _serde::private::de::missing_field("expires_at") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field4 = + match __field4 { + _serde::export::Some(__field4) => + __field4, + _serde::export::None => + match _serde::private::de::missing_field("irreversible") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field5 = + match __field5 { + _serde::export::Some(__field5) => + __field5, + _serde::export::None => + match _serde::private::de::missing_field("whole_word") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(Filter{id: __field0, + phrase: __field1, + context: __field2, + expires_at: + __field3, + irreversible: + __field4, + whole_word: + __field5,}) + } + } + const FIELDS: &'static [&'static str] = + &["id", "phrase", "context", "expires_at", + "irreversible", "whole_word"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "Filter", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + /// Represents the various types of Filter contexts + pub enum FilterContext { + + /// Represents the "home" context + #[serde(rename = "home")] + Home, + + /// Represents the "notifications" context + #[serde(rename = "notifications")] + Notifications, + + /// Represents the "public" context + #[serde(rename = "public")] + Public, + + /// Represents the "thread" context + #[serde(rename = "thread")] + Thread, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for FilterContext { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match (&*self,) { + (&FilterContext::Home,) => { + let mut debug_trait_builder = f.debug_tuple("Home"); + debug_trait_builder.finish() + } + (&FilterContext::Notifications,) => { + let mut debug_trait_builder = + f.debug_tuple("Notifications"); + debug_trait_builder.finish() + } + (&FilterContext::Public,) => { + let mut debug_trait_builder = f.debug_tuple("Public"); + debug_trait_builder.finish() + } + (&FilterContext::Thread,) => { + let mut debug_trait_builder = f.debug_tuple("Thread"); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for FilterContext { + #[inline] + fn clone(&self) -> FilterContext { { *self } } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::marker::Copy for FilterContext { } + impl ::core::marker::StructuralPartialEq for FilterContext { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for FilterContext { + #[inline] + fn eq(&self, other: &FilterContext) -> bool { + { + let __self_vi = + unsafe { + ::core::intrinsics::discriminant_value(&*self) + }; + let __arg_1_vi = + unsafe { + ::core::intrinsics::discriminant_value(&*other) + }; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { _ => true, } + } else { false } + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_SERIALIZE_FOR_FilterContext: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl _serde::Serialize for FilterContext { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + match *self { + FilterContext::Home => + _serde::Serializer::serialize_unit_variant(__serializer, + "FilterContext", + 0u32, + "home"), + FilterContext::Notifications => + _serde::Serializer::serialize_unit_variant(__serializer, + "FilterContext", + 1u32, + "notifications"), + FilterContext::Public => + _serde::Serializer::serialize_unit_variant(__serializer, + "FilterContext", + 2u32, + "public"), + FilterContext::Thread => + _serde::Serializer::serialize_unit_variant(__serializer, + "FilterContext", + 3u32, + "thread"), + } + } + } + }; + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_FilterContext: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for FilterContext { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "variant identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + 2u64 => + _serde::export::Ok(__Field::__field2), + 3u64 => + _serde::export::Ok(__Field::__field3), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 4")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "home" => + _serde::export::Ok(__Field::__field0), + "notifications" => + _serde::export::Ok(__Field::__field1), + "public" => + _serde::export::Ok(__Field::__field2), + "thread" => + _serde::export::Ok(__Field::__field3), + _ => { + _serde::export::Err(_serde::de::Error::unknown_variant(__value, + VARIANTS)) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"home" => + _serde::export::Ok(__Field::__field0), + b"notifications" => + _serde::export::Ok(__Field::__field1), + b"public" => + _serde::export::Ok(__Field::__field2), + b"thread" => + _serde::export::Ok(__Field::__field3), + _ => { + let __value = + &_serde::export::from_utf8_lossy(__value); + _serde::export::Err(_serde::de::Error::unknown_variant(__value, + VARIANTS)) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = FilterContext; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "enum FilterContext") + } + fn visit_enum<__A>(self, __data: __A) + -> + _serde::export::Result where + __A: _serde::de::EnumAccess<'de> { + match match _serde::de::EnumAccess::variant(__data) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + (__Field::__field0, __variant) => { + match _serde::de::VariantAccess::unit_variant(__variant) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::export::Ok(FilterContext::Home) + } + (__Field::__field1, __variant) => { + match _serde::de::VariantAccess::unit_variant(__variant) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::export::Ok(FilterContext::Notifications) + } + (__Field::__field2, __variant) => { + match _serde::de::VariantAccess::unit_variant(__variant) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::export::Ok(FilterContext::Public) + } + (__Field::__field3, __variant) => { + match _serde::de::VariantAccess::unit_variant(__variant) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::export::Ok(FilterContext::Thread) + } + } + } + } + const VARIANTS: &'static [&'static str] = + &["home", "notifications", "public", "thread"]; + _serde::Deserializer::deserialize_enum(__deserializer, + "FilterContext", + VARIANTS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + } + /// Data structures for ser/de of instance-related resources + pub mod instance { + //! Module containing everything related to an instance. + use super::account::Account; + /// A struct containing info of an instance. + pub struct Instance { + /// URI of the current instance + pub uri: String, + /// The instance's title. + pub title: String, + /// A description for the instance. + pub description: String, + /// An email address which can be used to contact the + /// instance administrator. + pub email: String, + /// The Mastodon version used by instance. + pub version: String, + /// Urls to the streaming api. + pub urls: Option, + /// Stats about the instance. + pub stats: Option, + /// Thumbnail of the server image. + pub thumbnail: Option, + /// List of languages used on the server. + pub languages: Option>, + /// Contact account for the server. + pub contact_account: Option, + /// The maximum number of characters allowed in a status + pub max_toot_chars: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Instance { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Instance { + uri: ref __self_0_0, + title: ref __self_0_1, + description: ref __self_0_2, + email: ref __self_0_3, + version: ref __self_0_4, + urls: ref __self_0_5, + stats: ref __self_0_6, + thumbnail: ref __self_0_7, + languages: ref __self_0_8, + contact_account: ref __self_0_9, + max_toot_chars: ref __self_0_10 } => { + let mut debug_trait_builder = + f.debug_struct("Instance"); + let _ = + debug_trait_builder.field("uri", &&(*__self_0_0)); + let _ = + debug_trait_builder.field("title", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("description", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("email", + &&(*__self_0_3)); + let _ = + debug_trait_builder.field("version", + &&(*__self_0_4)); + let _ = + debug_trait_builder.field("urls", + &&(*__self_0_5)); + let _ = + debug_trait_builder.field("stats", + &&(*__self_0_6)); + let _ = + debug_trait_builder.field("thumbnail", + &&(*__self_0_7)); + let _ = + debug_trait_builder.field("languages", + &&(*__self_0_8)); + let _ = + debug_trait_builder.field("contact_account", + &&(*__self_0_9)); + let _ = + debug_trait_builder.field("max_toot_chars", + &&(*__self_0_10)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Instance { + #[inline] + fn clone(&self) -> Instance { + match *self { + Instance { + uri: ref __self_0_0, + title: ref __self_0_1, + description: ref __self_0_2, + email: ref __self_0_3, + version: ref __self_0_4, + urls: ref __self_0_5, + stats: ref __self_0_6, + thumbnail: ref __self_0_7, + languages: ref __self_0_8, + contact_account: ref __self_0_9, + max_toot_chars: ref __self_0_10 } => + Instance{uri: ::core::clone::Clone::clone(&(*__self_0_0)), + title: + ::core::clone::Clone::clone(&(*__self_0_1)), + description: + ::core::clone::Clone::clone(&(*__self_0_2)), + email: + ::core::clone::Clone::clone(&(*__self_0_3)), + version: + ::core::clone::Clone::clone(&(*__self_0_4)), + urls: + ::core::clone::Clone::clone(&(*__self_0_5)), + stats: + ::core::clone::Clone::clone(&(*__self_0_6)), + thumbnail: + ::core::clone::Clone::clone(&(*__self_0_7)), + languages: + ::core::clone::Clone::clone(&(*__self_0_8)), + contact_account: + ::core::clone::Clone::clone(&(*__self_0_9)), + max_toot_chars: + ::core::clone::Clone::clone(&(*__self_0_10)),}, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Instance: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Instance { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __field4, + __field5, + __field6, + __field7, + __field8, + __field9, + __field10, + __ignore, + } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + 2u64 => + _serde::export::Ok(__Field::__field2), + 3u64 => + _serde::export::Ok(__Field::__field3), + 4u64 => + _serde::export::Ok(__Field::__field4), + 5u64 => + _serde::export::Ok(__Field::__field5), + 6u64 => + _serde::export::Ok(__Field::__field6), + 7u64 => + _serde::export::Ok(__Field::__field7), + 8u64 => + _serde::export::Ok(__Field::__field8), + 9u64 => + _serde::export::Ok(__Field::__field9), + 10u64 => + _serde::export::Ok(__Field::__field10), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 11")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "uri" => + _serde::export::Ok(__Field::__field0), + "title" => + _serde::export::Ok(__Field::__field1), + "description" => + _serde::export::Ok(__Field::__field2), + "email" => + _serde::export::Ok(__Field::__field3), + "version" => + _serde::export::Ok(__Field::__field4), + "urls" => + _serde::export::Ok(__Field::__field5), + "stats" => + _serde::export::Ok(__Field::__field6), + "thumbnail" => + _serde::export::Ok(__Field::__field7), + "languages" => + _serde::export::Ok(__Field::__field8), + "contact_account" => + _serde::export::Ok(__Field::__field9), + "max_toot_chars" => + _serde::export::Ok(__Field::__field10), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"uri" => + _serde::export::Ok(__Field::__field0), + b"title" => + _serde::export::Ok(__Field::__field1), + b"description" => + _serde::export::Ok(__Field::__field2), + b"email" => + _serde::export::Ok(__Field::__field3), + b"version" => + _serde::export::Ok(__Field::__field4), + b"urls" => + _serde::export::Ok(__Field::__field5), + b"stats" => + _serde::export::Ok(__Field::__field6), + b"thumbnail" => + _serde::export::Ok(__Field::__field7), + b"languages" => + _serde::export::Ok(__Field::__field8), + b"contact_account" => + _serde::export::Ok(__Field::__field9), + b"max_toot_chars" => + _serde::export::Ok(__Field::__field10), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = Instance; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct Instance") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct Instance with 11 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct Instance with 11 elements")); + } + }; + let __field2 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(2usize, + &"struct Instance with 11 elements")); + } + }; + let __field3 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(3usize, + &"struct Instance with 11 elements")); + } + }; + let __field4 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(4usize, + &"struct Instance with 11 elements")); + } + }; + let __field5 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(5usize, + &"struct Instance with 11 elements")); + } + }; + let __field6 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(6usize, + &"struct Instance with 11 elements")); + } + }; + let __field7 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(7usize, + &"struct Instance with 11 elements")); + } + }; + let __field8 = + match match _serde::de::SeqAccess::next_element::>>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(8usize, + &"struct Instance with 11 elements")); + } + }; + let __field9 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(9usize, + &"struct Instance with 11 elements")); + } + }; + let __field10 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(10usize, + &"struct Instance with 11 elements")); + } + }; + _serde::export::Ok(Instance{uri: __field0, + title: __field1, + description: + __field2, + email: __field3, + version: __field4, + urls: __field5, + stats: __field6, + thumbnail: + __field7, + languages: + __field8, + contact_account: + __field9, + max_toot_chars: + __field10,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option = + _serde::export::None; + let mut __field1: + _serde::export::Option = + _serde::export::None; + let mut __field2: + _serde::export::Option = + _serde::export::None; + let mut __field3: + _serde::export::Option = + _serde::export::None; + let mut __field4: + _serde::export::Option = + _serde::export::None; + let mut __field5: + _serde::export::Option> = + _serde::export::None; + let mut __field6: + _serde::export::Option> = + _serde::export::None; + let mut __field7: + _serde::export::Option> = + _serde::export::None; + let mut __field8: + _serde::export::Option>> = + _serde::export::None; + let mut __field9: + _serde::export::Option> = + _serde::export::None; + let mut __field10: + _serde::export::Option> = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("uri")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("title")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("description")); + } + __field2 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field3 => { + if _serde::export::Option::is_some(&__field3) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("email")); + } + __field3 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field4 => { + if _serde::export::Option::is_some(&__field4) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("version")); + } + __field4 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field5 => { + if _serde::export::Option::is_some(&__field5) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("urls")); + } + __field5 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field6 => { + if _serde::export::Option::is_some(&__field6) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("stats")); + } + __field6 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field7 => { + if _serde::export::Option::is_some(&__field7) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("thumbnail")); + } + __field7 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field8 => { + if _serde::export::Option::is_some(&__field8) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("languages")); + } + __field8 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field9 => { + if _serde::export::Option::is_some(&__field9) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("contact_account")); + } + __field9 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field10 => { + if _serde::export::Option::is_some(&__field10) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("max_toot_chars")); + } + __field10 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("uri") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("title") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field2 = + match __field2 { + _serde::export::Some(__field2) => + __field2, + _serde::export::None => + match _serde::private::de::missing_field("description") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field3 = + match __field3 { + _serde::export::Some(__field3) => + __field3, + _serde::export::None => + match _serde::private::de::missing_field("email") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field4 = + match __field4 { + _serde::export::Some(__field4) => + __field4, + _serde::export::None => + match _serde::private::de::missing_field("version") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field5 = + match __field5 { + _serde::export::Some(__field5) => + __field5, + _serde::export::None => + match _serde::private::de::missing_field("urls") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field6 = + match __field6 { + _serde::export::Some(__field6) => + __field6, + _serde::export::None => + match _serde::private::de::missing_field("stats") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field7 = + match __field7 { + _serde::export::Some(__field7) => + __field7, + _serde::export::None => + match _serde::private::de::missing_field("thumbnail") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field8 = + match __field8 { + _serde::export::Some(__field8) => + __field8, + _serde::export::None => + match _serde::private::de::missing_field("languages") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field9 = + match __field9 { + _serde::export::Some(__field9) => + __field9, + _serde::export::None => + match _serde::private::de::missing_field("contact_account") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field10 = + match __field10 { + _serde::export::Some(__field10) => + __field10, + _serde::export::None => + match _serde::private::de::missing_field("max_toot_chars") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(Instance{uri: __field0, + title: __field1, + description: + __field2, + email: __field3, + version: __field4, + urls: __field5, + stats: __field6, + thumbnail: + __field7, + languages: + __field8, + contact_account: + __field9, + max_toot_chars: + __field10,}) + } + } + const FIELDS: &'static [&'static str] = + &["uri", "title", "description", "email", + "version", "urls", "stats", "thumbnail", + "languages", "contact_account", + "max_toot_chars"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "Instance", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl ::core::marker::StructuralPartialEq for Instance { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Instance { + #[inline] + fn eq(&self, other: &Instance) -> bool { + match *other { + Instance { + uri: ref __self_1_0, + title: ref __self_1_1, + description: ref __self_1_2, + email: ref __self_1_3, + version: ref __self_1_4, + urls: ref __self_1_5, + stats: ref __self_1_6, + thumbnail: ref __self_1_7, + languages: ref __self_1_8, + contact_account: ref __self_1_9, + max_toot_chars: ref __self_1_10 } => + match *self { + Instance { + uri: ref __self_0_0, + title: ref __self_0_1, + description: ref __self_0_2, + email: ref __self_0_3, + version: ref __self_0_4, + urls: ref __self_0_5, + stats: ref __self_0_6, + thumbnail: ref __self_0_7, + languages: ref __self_0_8, + contact_account: ref __self_0_9, + max_toot_chars: ref __self_0_10 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3) && + (*__self_0_4) == (*__self_1_4) && + (*__self_0_5) == (*__self_1_5) && + (*__self_0_6) == (*__self_1_6) && + (*__self_0_7) == (*__self_1_7) && + (*__self_0_8) == (*__self_1_8) && + (*__self_0_9) == (*__self_1_9) && + (*__self_0_10) == (*__self_1_10), + }, + } + } + #[inline] + fn ne(&self, other: &Instance) -> bool { + match *other { + Instance { + uri: ref __self_1_0, + title: ref __self_1_1, + description: ref __self_1_2, + email: ref __self_1_3, + version: ref __self_1_4, + urls: ref __self_1_5, + stats: ref __self_1_6, + thumbnail: ref __self_1_7, + languages: ref __self_1_8, + contact_account: ref __self_1_9, + max_toot_chars: ref __self_1_10 } => + match *self { + Instance { + uri: ref __self_0_0, + title: ref __self_0_1, + description: ref __self_0_2, + email: ref __self_0_3, + version: ref __self_0_4, + urls: ref __self_0_5, + stats: ref __self_0_6, + thumbnail: ref __self_0_7, + languages: ref __self_0_8, + contact_account: ref __self_0_9, + max_toot_chars: ref __self_0_10 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3) || + (*__self_0_4) != (*__self_1_4) || + (*__self_0_5) != (*__self_1_5) || + (*__self_0_6) != (*__self_1_6) || + (*__self_0_7) != (*__self_1_7) || + (*__self_0_8) != (*__self_1_8) || + (*__self_0_9) != (*__self_1_9) || + (*__self_0_10) != (*__self_1_10), + }, + } + } + } + /// Object containing url for streaming api. + pub struct StreamingApi { + /// Url for streaming API, typically a `wss://` url. + pub streaming_api: String, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for StreamingApi { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + StreamingApi { streaming_api: ref __self_0_0 } => { + let mut debug_trait_builder = + f.debug_struct("StreamingApi"); + let _ = + debug_trait_builder.field("streaming_api", + &&(*__self_0_0)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for StreamingApi { + #[inline] + fn clone(&self) -> StreamingApi { + match *self { + StreamingApi { streaming_api: ref __self_0_0 } => + StreamingApi{streaming_api: + ::core::clone::Clone::clone(&(*__self_0_0)),}, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_StreamingApi: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for StreamingApi { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { __field0, __ignore, } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 1")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "streaming_api" => + _serde::export::Ok(__Field::__field0), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"streaming_api" => + _serde::export::Ok(__Field::__field0), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = StreamingApi; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct StreamingApi") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct StreamingApi with 1 element")); + } + }; + _serde::export::Ok(StreamingApi{streaming_api: + __field0,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("streaming_api")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("streaming_api") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(StreamingApi{streaming_api: + __field0,}) + } + } + const FIELDS: &'static [&'static str] = + &["streaming_api"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "StreamingApi", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl ::core::marker::StructuralPartialEq for StreamingApi { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for StreamingApi { + #[inline] + fn eq(&self, other: &StreamingApi) -> bool { + match *other { + StreamingApi { streaming_api: ref __self_1_0 } => + match *self { + StreamingApi { streaming_api: ref __self_0_0 } => + (*__self_0_0) == (*__self_1_0), + }, + } + } + #[inline] + fn ne(&self, other: &StreamingApi) -> bool { + match *other { + StreamingApi { streaming_api: ref __self_1_0 } => + match *self { + StreamingApi { streaming_api: ref __self_0_0 } => + (*__self_0_0) != (*__self_1_0), + }, + } + } + } + /// Statistics about the Mastodon instance. + pub struct Stats { + user_count: u64, + status_count: u64, + domain_count: u64, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Stats { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Stats { + user_count: ref __self_0_0, + status_count: ref __self_0_1, + domain_count: ref __self_0_2 } => { + let mut debug_trait_builder = f.debug_struct("Stats"); + let _ = + debug_trait_builder.field("user_count", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("status_count", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("domain_count", + &&(*__self_0_2)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Stats { + #[inline] + fn clone(&self) -> Stats { + { + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + *self + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::marker::Copy for Stats { } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Stats: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Stats { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + 2u64 => + _serde::export::Ok(__Field::__field2), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 3")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "user_count" => + _serde::export::Ok(__Field::__field0), + "status_count" => + _serde::export::Ok(__Field::__field1), + "domain_count" => + _serde::export::Ok(__Field::__field2), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"user_count" => + _serde::export::Ok(__Field::__field0), + b"status_count" => + _serde::export::Ok(__Field::__field1), + b"domain_count" => + _serde::export::Ok(__Field::__field2), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = Stats; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct Stats") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct Stats with 3 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct Stats with 3 elements")); + } + }; + let __field2 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(2usize, + &"struct Stats with 3 elements")); + } + }; + _serde::export::Ok(Stats{user_count: __field0, + status_count: + __field1, + domain_count: + __field2,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option = + _serde::export::None; + let mut __field1: + _serde::export::Option = + _serde::export::None; + let mut __field2: + _serde::export::Option = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("user_count")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("status_count")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("domain_count")); + } + __field2 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("user_count") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("status_count") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field2 = + match __field2 { + _serde::export::Some(__field2) => + __field2, + _serde::export::None => + match _serde::private::de::missing_field("domain_count") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(Stats{user_count: __field0, + status_count: + __field1, + domain_count: + __field2,}) + } + } + const FIELDS: &'static [&'static str] = + &["user_count", "status_count", "domain_count"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "Stats", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl ::core::marker::StructuralPartialEq for Stats { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Stats { + #[inline] + fn eq(&self, other: &Stats) -> bool { + match *other { + Stats { + user_count: ref __self_1_0, + status_count: ref __self_1_1, + domain_count: ref __self_1_2 } => + match *self { + Stats { + user_count: ref __self_0_0, + status_count: ref __self_0_1, + domain_count: ref __self_0_2 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2), + }, + } + } + #[inline] + fn ne(&self, other: &Stats) -> bool { + match *other { + Stats { + user_count: ref __self_1_0, + status_count: ref __self_1_1, + domain_count: ref __self_1_2 } => + match *self { + Stats { + user_count: ref __self_0_0, + status_count: ref __self_0_1, + domain_count: ref __self_0_2 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2), + }, + } + } + } + } + /// Data structures for ser/de of list-related resources + pub mod list { + /// Used for ser/de of list resources + pub struct List { + id: String, + title: String, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for List { + #[inline] + fn clone(&self) -> List { + match *self { + List { id: ref __self_0_0, title: ref __self_0_1 } => + List{id: ::core::clone::Clone::clone(&(*__self_0_0)), + title: ::core::clone::Clone::clone(&(*__self_0_1)),}, + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for List { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + List { id: ref __self_0_0, title: ref __self_0_1 } => { + let mut debug_trait_builder = f.debug_struct("List"); + let _ = + debug_trait_builder.field("id", &&(*__self_0_0)); + let _ = + debug_trait_builder.field("title", + &&(*__self_0_1)); + debug_trait_builder.finish() + } + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_List: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for List { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { __field0, __field1, __ignore, } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 2")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "id" => + _serde::export::Ok(__Field::__field0), + "title" => + _serde::export::Ok(__Field::__field1), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"id" => + _serde::export::Ok(__Field::__field0), + b"title" => + _serde::export::Ok(__Field::__field1), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = List; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct List") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct List with 2 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct List with 2 elements")); + } + }; + _serde::export::Ok(List{id: __field0, + title: __field1,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option = + _serde::export::None; + let mut __field1: + _serde::export::Option = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("id")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("title")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("id") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("title") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(List{id: __field0, + title: __field1,}) + } + } + const FIELDS: &'static [&'static str] = + &["id", "title"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "List", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl ::core::marker::StructuralPartialEq for List { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for List { + #[inline] + fn eq(&self, other: &List) -> bool { + match *other { + List { id: ref __self_1_0, title: ref __self_1_1 } => + match *self { + List { id: ref __self_0_0, title: ref __self_0_1 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1), + }, + } + } + #[inline] + fn ne(&self, other: &List) -> bool { + match *other { + List { id: ref __self_1_0, title: ref __self_1_1 } => + match *self { + List { id: ref __self_0_0, title: ref __self_0_1 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1), + }, + } + } + } + } + /// Data structures for ser/de of mention-related resources + pub mod mention { + /// Represents a `mention` used in a status + pub struct Mention { + /// URL of user's profile (can be remote) + pub url: String, + /// The username of the account + pub username: String, + /// Equals username for local users, includes `@domain` for remote ones + pub acct: String, + /// Account ID + pub id: String, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Mention { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Mention { + url: ref __self_0_0, + username: ref __self_0_1, + acct: ref __self_0_2, + id: ref __self_0_3 } => { + let mut debug_trait_builder = + f.debug_struct("Mention"); + let _ = + debug_trait_builder.field("url", &&(*__self_0_0)); + let _ = + debug_trait_builder.field("username", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("acct", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("id", &&(*__self_0_3)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Mention { + #[inline] + fn clone(&self) -> Mention { + match *self { + Mention { + url: ref __self_0_0, + username: ref __self_0_1, + acct: ref __self_0_2, + id: ref __self_0_3 } => + Mention{url: ::core::clone::Clone::clone(&(*__self_0_0)), + username: + ::core::clone::Clone::clone(&(*__self_0_1)), + acct: ::core::clone::Clone::clone(&(*__self_0_2)), + id: ::core::clone::Clone::clone(&(*__self_0_3)),}, + } + } + } + impl ::core::marker::StructuralPartialEq for Mention { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Mention { + #[inline] + fn eq(&self, other: &Mention) -> bool { + match *other { + Mention { + url: ref __self_1_0, + username: ref __self_1_1, + acct: ref __self_1_2, + id: ref __self_1_3 } => + match *self { + Mention { + url: ref __self_0_0, + username: ref __self_0_1, + acct: ref __self_0_2, + id: ref __self_0_3 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3), + }, + } + } + #[inline] + fn ne(&self, other: &Mention) -> bool { + match *other { + Mention { + url: ref __self_1_0, + username: ref __self_1_1, + acct: ref __self_1_2, + id: ref __self_1_3 } => + match *self { + Mention { + url: ref __self_0_0, + username: ref __self_0_1, + acct: ref __self_0_2, + id: ref __self_0_3 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3), + }, + } + } + } + } + /// Data structures for ser/de of notification-related resources + pub mod notification { + //! Module containing all info about notifications. + use super::{account::Account, status::Status}; + use chrono::prelude::*; + /// A struct containing info about a notification. + pub struct Notification { + /// The notification ID. + pub id: String, + /// The type of notification. + #[serde(rename = "type")] + pub notification_type: NotificationType, + /// The time the notification was created. + pub created_at: DateTime, + /// The Account sending the notification to the user. + pub account: Account, + /// The Status associated with the notification, if applicable. + pub status: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Notification { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Notification { + id: ref __self_0_0, + notification_type: ref __self_0_1, + created_at: ref __self_0_2, + account: ref __self_0_3, + status: ref __self_0_4 } => { + let mut debug_trait_builder = + f.debug_struct("Notification"); + let _ = + debug_trait_builder.field("id", &&(*__self_0_0)); + let _ = + debug_trait_builder.field("notification_type", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("created_at", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("account", + &&(*__self_0_3)); + let _ = + debug_trait_builder.field("status", + &&(*__self_0_4)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Notification { + #[inline] + fn clone(&self) -> Notification { + match *self { + Notification { + id: ref __self_0_0, + notification_type: ref __self_0_1, + created_at: ref __self_0_2, + account: ref __self_0_3, + status: ref __self_0_4 } => + Notification{id: + ::core::clone::Clone::clone(&(*__self_0_0)), + notification_type: + ::core::clone::Clone::clone(&(*__self_0_1)), + created_at: + ::core::clone::Clone::clone(&(*__self_0_2)), + account: + ::core::clone::Clone::clone(&(*__self_0_3)), + status: + ::core::clone::Clone::clone(&(*__self_0_4)),}, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Notification: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Notification { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __field4, + __ignore, + } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + 2u64 => + _serde::export::Ok(__Field::__field2), + 3u64 => + _serde::export::Ok(__Field::__field3), + 4u64 => + _serde::export::Ok(__Field::__field4), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 5")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "id" => + _serde::export::Ok(__Field::__field0), + "type" => + _serde::export::Ok(__Field::__field1), + "created_at" => + _serde::export::Ok(__Field::__field2), + "account" => + _serde::export::Ok(__Field::__field3), + "status" => + _serde::export::Ok(__Field::__field4), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"id" => + _serde::export::Ok(__Field::__field0), + b"type" => + _serde::export::Ok(__Field::__field1), + b"created_at" => + _serde::export::Ok(__Field::__field2), + b"account" => + _serde::export::Ok(__Field::__field3), + b"status" => + _serde::export::Ok(__Field::__field4), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = Notification; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct Notification") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct Notification with 5 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct Notification with 5 elements")); + } + }; + let __field2 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(2usize, + &"struct Notification with 5 elements")); + } + }; + let __field3 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(3usize, + &"struct Notification with 5 elements")); + } + }; + let __field4 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(4usize, + &"struct Notification with 5 elements")); + } + }; + _serde::export::Ok(Notification{id: __field0, + notification_type: + __field1, + created_at: + __field2, + account: + __field3, + status: + __field4,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option = + _serde::export::None; + let mut __field1: + _serde::export::Option = + _serde::export::None; + let mut __field2: + _serde::export::Option> = + _serde::export::None; + let mut __field3: + _serde::export::Option = + _serde::export::None; + let mut __field4: + _serde::export::Option> = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("id")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("type")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("created_at")); + } + __field2 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field3 => { + if _serde::export::Option::is_some(&__field3) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("account")); + } + __field3 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field4 => { + if _serde::export::Option::is_some(&__field4) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("status")); + } + __field4 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("id") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("type") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field2 = + match __field2 { + _serde::export::Some(__field2) => + __field2, + _serde::export::None => + match _serde::private::de::missing_field("created_at") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field3 = + match __field3 { + _serde::export::Some(__field3) => + __field3, + _serde::export::None => + match _serde::private::de::missing_field("account") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field4 = + match __field4 { + _serde::export::Some(__field4) => + __field4, + _serde::export::None => + match _serde::private::de::missing_field("status") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(Notification{id: __field0, + notification_type: + __field1, + created_at: + __field2, + account: + __field3, + status: + __field4,}) + } + } + const FIELDS: &'static [&'static str] = + &["id", "type", "created_at", "account", + "status"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "Notification", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl ::core::marker::StructuralPartialEq for Notification { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Notification { + #[inline] + fn eq(&self, other: &Notification) -> bool { + match *other { + Notification { + id: ref __self_1_0, + notification_type: ref __self_1_1, + created_at: ref __self_1_2, + account: ref __self_1_3, + status: ref __self_1_4 } => + match *self { + Notification { + id: ref __self_0_0, + notification_type: ref __self_0_1, + created_at: ref __self_0_2, + account: ref __self_0_3, + status: ref __self_0_4 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3) && + (*__self_0_4) == (*__self_1_4), + }, + } + } + #[inline] + fn ne(&self, other: &Notification) -> bool { + match *other { + Notification { + id: ref __self_1_0, + notification_type: ref __self_1_1, + created_at: ref __self_1_2, + account: ref __self_1_3, + status: ref __self_1_4 } => + match *self { + Notification { + id: ref __self_0_0, + notification_type: ref __self_0_1, + created_at: ref __self_0_2, + account: ref __self_0_3, + status: ref __self_0_4 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3) || + (*__self_0_4) != (*__self_1_4), + }, + } + } + } + /// The type of notification. + #[serde(rename_all = "lowercase")] + pub enum NotificationType { + + /// Someone mentioned the application client in another status. + Mention, + + /// Someone reblogged one of the application client's statuses. + Reblog, + + /// Someone favourited one of the application client's statuses. + Favourite, + + /// Someone followed the application client. + Follow, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for NotificationType { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match (&*self,) { + (&NotificationType::Mention,) => { + let mut debug_trait_builder = + f.debug_tuple("Mention"); + debug_trait_builder.finish() + } + (&NotificationType::Reblog,) => { + let mut debug_trait_builder = f.debug_tuple("Reblog"); + debug_trait_builder.finish() + } + (&NotificationType::Favourite,) => { + let mut debug_trait_builder = + f.debug_tuple("Favourite"); + debug_trait_builder.finish() + } + (&NotificationType::Follow,) => { + let mut debug_trait_builder = f.debug_tuple("Follow"); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for NotificationType { + #[inline] + fn clone(&self) -> NotificationType { { *self } } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::marker::Copy for NotificationType { } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_NotificationType: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for NotificationType { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "variant identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + 2u64 => + _serde::export::Ok(__Field::__field2), + 3u64 => + _serde::export::Ok(__Field::__field3), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 4")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "mention" => + _serde::export::Ok(__Field::__field0), + "reblog" => + _serde::export::Ok(__Field::__field1), + "favourite" => + _serde::export::Ok(__Field::__field2), + "follow" => + _serde::export::Ok(__Field::__field3), + _ => { + _serde::export::Err(_serde::de::Error::unknown_variant(__value, + VARIANTS)) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"mention" => + _serde::export::Ok(__Field::__field0), + b"reblog" => + _serde::export::Ok(__Field::__field1), + b"favourite" => + _serde::export::Ok(__Field::__field2), + b"follow" => + _serde::export::Ok(__Field::__field3), + _ => { + let __value = + &_serde::export::from_utf8_lossy(__value); + _serde::export::Err(_serde::de::Error::unknown_variant(__value, + VARIANTS)) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = NotificationType; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "enum NotificationType") + } + fn visit_enum<__A>(self, __data: __A) + -> + _serde::export::Result where + __A: _serde::de::EnumAccess<'de> { + match match _serde::de::EnumAccess::variant(__data) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + (__Field::__field0, __variant) => { + match _serde::de::VariantAccess::unit_variant(__variant) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::export::Ok(NotificationType::Mention) + } + (__Field::__field1, __variant) => { + match _serde::de::VariantAccess::unit_variant(__variant) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::export::Ok(NotificationType::Reblog) + } + (__Field::__field2, __variant) => { + match _serde::de::VariantAccess::unit_variant(__variant) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::export::Ok(NotificationType::Favourite) + } + (__Field::__field3, __variant) => { + match _serde::de::VariantAccess::unit_variant(__variant) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::export::Ok(NotificationType::Follow) + } + } + } + } + const VARIANTS: &'static [&'static str] = + &["mention", "reblog", "favourite", "follow"]; + _serde::Deserializer::deserialize_enum(__deserializer, + "NotificationType", + VARIANTS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl ::core::marker::StructuralPartialEq for NotificationType { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for NotificationType { + #[inline] + fn eq(&self, other: &NotificationType) -> bool { + { + let __self_vi = + unsafe { + ::core::intrinsics::discriminant_value(&*self) + }; + let __arg_1_vi = + unsafe { + ::core::intrinsics::discriminant_value(&*other) + }; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { _ => true, } + } else { false } + } + } + } + } + /// Data structures for ser/de of push-subscription-related resources + pub mod push { + /// Represents the `alerts` key of the `Subscription` object + pub struct Alerts { + /// flag for follow alerts + pub follow: Option, + /// flag for favourite alerts + pub favourite: Option, + /// flag for reblog alerts + pub reblog: Option, + /// flag for mention alerts + pub mention: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Alerts { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Alerts { + follow: ref __self_0_0, + favourite: ref __self_0_1, + reblog: ref __self_0_2, + mention: ref __self_0_3 } => { + let mut debug_trait_builder = + f.debug_struct("Alerts"); + let _ = + debug_trait_builder.field("follow", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("favourite", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("reblog", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("mention", + &&(*__self_0_3)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Alerts { + #[inline] + fn clone(&self) -> Alerts { + { + let _: ::core::clone::AssertParamIsClone>; + let _: ::core::clone::AssertParamIsClone>; + let _: ::core::clone::AssertParamIsClone>; + let _: ::core::clone::AssertParamIsClone>; + *self + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::marker::Copy for Alerts { } + impl ::core::marker::StructuralPartialEq for Alerts { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Alerts { + #[inline] + fn eq(&self, other: &Alerts) -> bool { + match *other { + Alerts { + follow: ref __self_1_0, + favourite: ref __self_1_1, + reblog: ref __self_1_2, + mention: ref __self_1_3 } => + match *self { + Alerts { + follow: ref __self_0_0, + favourite: ref __self_0_1, + reblog: ref __self_0_2, + mention: ref __self_0_3 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3), + }, + } + } + #[inline] + fn ne(&self, other: &Alerts) -> bool { + match *other { + Alerts { + follow: ref __self_1_0, + favourite: ref __self_1_1, + reblog: ref __self_1_2, + mention: ref __self_1_3 } => + match *self { + Alerts { + follow: ref __self_0_0, + favourite: ref __self_0_1, + reblog: ref __self_0_2, + mention: ref __self_0_3 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3), + }, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_SERIALIZE_FOR_Alerts: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl _serde::Serialize for Alerts { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "Alerts", + false + as + usize + + 1 + + 1 + + 1 + + + 1) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "follow", + &self.follow) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "favourite", + &self.favourite) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "reblog", + &self.reblog) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "mention", + &self.mention) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Alerts: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Alerts { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + 2u64 => + _serde::export::Ok(__Field::__field2), + 3u64 => + _serde::export::Ok(__Field::__field3), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 4")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "follow" => + _serde::export::Ok(__Field::__field0), + "favourite" => + _serde::export::Ok(__Field::__field1), + "reblog" => + _serde::export::Ok(__Field::__field2), + "mention" => + _serde::export::Ok(__Field::__field3), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"follow" => + _serde::export::Ok(__Field::__field0), + b"favourite" => + _serde::export::Ok(__Field::__field1), + b"reblog" => + _serde::export::Ok(__Field::__field2), + b"mention" => + _serde::export::Ok(__Field::__field3), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = Alerts; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct Alerts") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct Alerts with 4 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct Alerts with 4 elements")); + } + }; + let __field2 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(2usize, + &"struct Alerts with 4 elements")); + } + }; + let __field3 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(3usize, + &"struct Alerts with 4 elements")); + } + }; + _serde::export::Ok(Alerts{follow: __field0, + favourite: __field1, + reblog: __field2, + mention: __field3,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option> = + _serde::export::None; + let mut __field1: + _serde::export::Option> = + _serde::export::None; + let mut __field2: + _serde::export::Option> = + _serde::export::None; + let mut __field3: + _serde::export::Option> = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("follow")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("favourite")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("reblog")); + } + __field2 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field3 => { + if _serde::export::Option::is_some(&__field3) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("mention")); + } + __field3 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("follow") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("favourite") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field2 = + match __field2 { + _serde::export::Some(__field2) => + __field2, + _serde::export::None => + match _serde::private::de::missing_field("reblog") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field3 = + match __field3 { + _serde::export::Some(__field3) => + __field3, + _serde::export::None => + match _serde::private::de::missing_field("mention") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(Alerts{follow: __field0, + favourite: __field1, + reblog: __field2, + mention: __field3,}) + } + } + const FIELDS: &'static [&'static str] = + &["follow", "favourite", "reblog", "mention"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "Alerts", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::default::Default for Alerts { + #[inline] + fn default() -> Alerts { + Alerts{follow: ::core::default::Default::default(), + favourite: ::core::default::Default::default(), + reblog: ::core::default::Default::default(), + mention: ::core::default::Default::default(),} + } + } + /// Represents a new Push subscription + pub struct Subscription { + /// The `id` of the subscription + pub id: String, + /// The endpoint of the subscription + pub endpoint: String, + /// The server key of the subscription + pub server_key: String, + /// The status of the alerts for this subscription + pub alerts: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Subscription { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Subscription { + id: ref __self_0_0, + endpoint: ref __self_0_1, + server_key: ref __self_0_2, + alerts: ref __self_0_3 } => { + let mut debug_trait_builder = + f.debug_struct("Subscription"); + let _ = + debug_trait_builder.field("id", &&(*__self_0_0)); + let _ = + debug_trait_builder.field("endpoint", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("server_key", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("alerts", + &&(*__self_0_3)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Subscription { + #[inline] + fn clone(&self) -> Subscription { + match *self { + Subscription { + id: ref __self_0_0, + endpoint: ref __self_0_1, + server_key: ref __self_0_2, + alerts: ref __self_0_3 } => + Subscription{id: + ::core::clone::Clone::clone(&(*__self_0_0)), + endpoint: + ::core::clone::Clone::clone(&(*__self_0_1)), + server_key: + ::core::clone::Clone::clone(&(*__self_0_2)), + alerts: + ::core::clone::Clone::clone(&(*__self_0_3)),}, + } + } + } + impl ::core::marker::StructuralPartialEq for Subscription { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Subscription { + #[inline] + fn eq(&self, other: &Subscription) -> bool { + match *other { + Subscription { + id: ref __self_1_0, + endpoint: ref __self_1_1, + server_key: ref __self_1_2, + alerts: ref __self_1_3 } => + match *self { + Subscription { + id: ref __self_0_0, + endpoint: ref __self_0_1, + server_key: ref __self_0_2, + alerts: ref __self_0_3 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3), + }, + } + } + #[inline] + fn ne(&self, other: &Subscription) -> bool { + match *other { + Subscription { + id: ref __self_1_0, + endpoint: ref __self_1_1, + server_key: ref __self_1_2, + alerts: ref __self_1_3 } => + match *self { + Subscription { + id: ref __self_0_0, + endpoint: ref __self_0_1, + server_key: ref __self_0_2, + alerts: ref __self_0_3 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3), + }, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Subscription: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Subscription { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + 2u64 => + _serde::export::Ok(__Field::__field2), + 3u64 => + _serde::export::Ok(__Field::__field3), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 4")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "id" => + _serde::export::Ok(__Field::__field0), + "endpoint" => + _serde::export::Ok(__Field::__field1), + "server_key" => + _serde::export::Ok(__Field::__field2), + "alerts" => + _serde::export::Ok(__Field::__field3), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"id" => + _serde::export::Ok(__Field::__field0), + b"endpoint" => + _serde::export::Ok(__Field::__field1), + b"server_key" => + _serde::export::Ok(__Field::__field2), + b"alerts" => + _serde::export::Ok(__Field::__field3), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = Subscription; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct Subscription") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct Subscription with 4 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct Subscription with 4 elements")); + } + }; + let __field2 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(2usize, + &"struct Subscription with 4 elements")); + } + }; + let __field3 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(3usize, + &"struct Subscription with 4 elements")); + } + }; + _serde::export::Ok(Subscription{id: __field0, + endpoint: + __field1, + server_key: + __field2, + alerts: + __field3,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option = + _serde::export::None; + let mut __field1: + _serde::export::Option = + _serde::export::None; + let mut __field2: + _serde::export::Option = + _serde::export::None; + let mut __field3: + _serde::export::Option> = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("id")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("endpoint")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("server_key")); + } + __field2 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field3 => { + if _serde::export::Option::is_some(&__field3) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("alerts")); + } + __field3 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("id") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("endpoint") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field2 = + match __field2 { + _serde::export::Some(__field2) => + __field2, + _serde::export::None => + match _serde::private::de::missing_field("server_key") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field3 = + match __field3 { + _serde::export::Some(__field3) => + __field3, + _serde::export::None => + match _serde::private::de::missing_field("alerts") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(Subscription{id: __field0, + endpoint: + __field1, + server_key: + __field2, + alerts: + __field3,}) + } + } + const FIELDS: &'static [&'static str] = + &["id", "endpoint", "server_key", "alerts"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "Subscription", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + pub(crate) mod add_subscription { + use super::Alerts; + pub(crate) struct Form { + pub(crate) subscription: Subscription, + pub(crate) data: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Form { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Form { + subscription: ref __self_0_0, data: ref __self_0_1 } + => { + let mut debug_trait_builder = + f.debug_struct("Form"); + let _ = + debug_trait_builder.field("subscription", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("data", + &&(*__self_0_1)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Form { + #[inline] + fn clone(&self) -> Form { + match *self { + Form { + subscription: ref __self_0_0, data: ref __self_0_1 } + => + Form{subscription: + ::core::clone::Clone::clone(&(*__self_0_0)), + data: + ::core::clone::Clone::clone(&(*__self_0_1)),}, + } + } + } + impl ::core::marker::StructuralPartialEq for Form { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Form { + #[inline] + fn eq(&self, other: &Form) -> bool { + match *other { + Form { + subscription: ref __self_1_0, data: ref __self_1_1 } + => + match *self { + Form { + subscription: ref __self_0_0, data: ref __self_0_1 + } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1), + }, + } + } + #[inline] + fn ne(&self, other: &Form) -> bool { + match *other { + Form { + subscription: ref __self_1_0, data: ref __self_1_1 } + => + match *self { + Form { + subscription: ref __self_0_0, data: ref __self_0_1 + } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1), + }, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_SERIALIZE_FOR_Form: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde + :: export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl _serde::Serialize for Form { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "Form", + false + as + usize + + + 1 + + + 1) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "subscription", + &self.subscription) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "data", + &self.data) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::default::Default for Form { + #[inline] + fn default() -> Form { + Form{subscription: ::core::default::Default::default(), + data: ::core::default::Default::default(),} + } + } + pub(crate) struct Subscription { + pub(crate) endpoint: String, + pub(crate) keys: Keys, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Subscription { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Subscription { + endpoint: ref __self_0_0, keys: ref __self_0_1 } => { + let mut debug_trait_builder = + f.debug_struct("Subscription"); + let _ = + debug_trait_builder.field("endpoint", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("keys", + &&(*__self_0_1)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Subscription { + #[inline] + fn clone(&self) -> Subscription { + match *self { + Subscription { + endpoint: ref __self_0_0, keys: ref __self_0_1 } => + Subscription{endpoint: + ::core::clone::Clone::clone(&(*__self_0_0)), + keys: + ::core::clone::Clone::clone(&(*__self_0_1)),}, + } + } + } + impl ::core::marker::StructuralPartialEq for Subscription { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Subscription { + #[inline] + fn eq(&self, other: &Subscription) -> bool { + match *other { + Subscription { + endpoint: ref __self_1_0, keys: ref __self_1_1 } => + match *self { + Subscription { + endpoint: ref __self_0_0, keys: ref __self_0_1 } + => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1), + }, + } + } + #[inline] + fn ne(&self, other: &Subscription) -> bool { + match *other { + Subscription { + endpoint: ref __self_1_0, keys: ref __self_1_1 } => + match *self { + Subscription { + endpoint: ref __self_0_0, keys: ref __self_0_1 } + => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1), + }, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_SERIALIZE_FOR_Subscription: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde + :: export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl _serde::Serialize for Subscription { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "Subscription", + false + as + usize + + + 1 + + + 1) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "endpoint", + &self.endpoint) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "keys", + &self.keys) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::default::Default for Subscription { + #[inline] + fn default() -> Subscription { + Subscription{endpoint: + ::core::default::Default::default(), + keys: ::core::default::Default::default(),} + } + } + pub(crate) struct Keys { + pub(crate) p256dh: String, + pub(crate) auth: String, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Keys { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Keys { p256dh: ref __self_0_0, auth: ref __self_0_1 } + => { + let mut debug_trait_builder = + f.debug_struct("Keys"); + let _ = + debug_trait_builder.field("p256dh", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("auth", + &&(*__self_0_1)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Keys { + #[inline] + fn clone(&self) -> Keys { + match *self { + Keys { p256dh: ref __self_0_0, auth: ref __self_0_1 } + => + Keys{p256dh: + ::core::clone::Clone::clone(&(*__self_0_0)), + auth: + ::core::clone::Clone::clone(&(*__self_0_1)),}, + } + } + } + impl ::core::marker::StructuralPartialEq for Keys { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Keys { + #[inline] + fn eq(&self, other: &Keys) -> bool { + match *other { + Keys { p256dh: ref __self_1_0, auth: ref __self_1_1 } + => + match *self { + Keys { + p256dh: ref __self_0_0, auth: ref __self_0_1 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1), + }, + } + } + #[inline] + fn ne(&self, other: &Keys) -> bool { + match *other { + Keys { p256dh: ref __self_1_0, auth: ref __self_1_1 } + => + match *self { + Keys { + p256dh: ref __self_0_0, auth: ref __self_0_1 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1), + }, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_SERIALIZE_FOR_Keys: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde + :: export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl _serde::Serialize for Keys { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "Keys", + false + as + usize + + + 1 + + + 1) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "p256dh", + &self.p256dh) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "auth", + &self.auth) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::default::Default for Keys { + #[inline] + fn default() -> Keys { + Keys{p256dh: ::core::default::Default::default(), + auth: ::core::default::Default::default(),} + } + } + pub(crate) struct Data { + pub(crate) alerts: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Data { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Data { alerts: ref __self_0_0 } => { + let mut debug_trait_builder = + f.debug_struct("Data"); + let _ = + debug_trait_builder.field("alerts", + &&(*__self_0_0)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Data { + #[inline] + fn clone(&self) -> Data { + match *self { + Data { alerts: ref __self_0_0 } => + Data{alerts: + ::core::clone::Clone::clone(&(*__self_0_0)),}, + } + } + } + impl ::core::marker::StructuralPartialEq for Data { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Data { + #[inline] + fn eq(&self, other: &Data) -> bool { + match *other { + Data { alerts: ref __self_1_0 } => + match *self { + Data { alerts: ref __self_0_0 } => + (*__self_0_0) == (*__self_1_0), + }, + } + } + #[inline] + fn ne(&self, other: &Data) -> bool { + match *other { + Data { alerts: ref __self_1_0 } => + match *self { + Data { alerts: ref __self_0_0 } => + (*__self_0_0) != (*__self_1_0), + }, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_SERIALIZE_FOR_Data: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde + :: export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl _serde::Serialize for Data { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "Data", + false + as + usize + + + 1) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "alerts", + &self.alerts) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::default::Default for Data { + #[inline] + fn default() -> Data { + Data{alerts: ::core::default::Default::default(),} + } + } + } + pub(crate) mod update_data { + use super::Alerts; + pub(crate) struct Data { + pub(crate) alerts: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Data { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Data { alerts: ref __self_0_0 } => { + let mut debug_trait_builder = + f.debug_struct("Data"); + let _ = + debug_trait_builder.field("alerts", + &&(*__self_0_0)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Data { + #[inline] + fn clone(&self) -> Data { + match *self { + Data { alerts: ref __self_0_0 } => + Data{alerts: + ::core::clone::Clone::clone(&(*__self_0_0)),}, + } + } + } + impl ::core::marker::StructuralPartialEq for Data { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Data { + #[inline] + fn eq(&self, other: &Data) -> bool { + match *other { + Data { alerts: ref __self_1_0 } => + match *self { + Data { alerts: ref __self_0_0 } => + (*__self_0_0) == (*__self_1_0), + }, + } + } + #[inline] + fn ne(&self, other: &Data) -> bool { + match *other { + Data { alerts: ref __self_1_0 } => + match *self { + Data { alerts: ref __self_0_0 } => + (*__self_0_0) != (*__self_1_0), + }, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_SERIALIZE_FOR_Data: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde + :: export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl _serde::Serialize for Data { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "Data", + false + as + usize + + + 1) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "alerts", + &self.alerts) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::default::Default for Data { + #[inline] + fn default() -> Data { + Data{alerts: ::core::default::Default::default(),} + } + } + pub(crate) struct Form { + pub(crate) id: String, + pub(crate) data: Data, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Form { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Form { id: ref __self_0_0, data: ref __self_0_1 } => { + let mut debug_trait_builder = + f.debug_struct("Form"); + let _ = + debug_trait_builder.field("id", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("data", + &&(*__self_0_1)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Form { + #[inline] + fn clone(&self) -> Form { + match *self { + Form { id: ref __self_0_0, data: ref __self_0_1 } => + Form{id: ::core::clone::Clone::clone(&(*__self_0_0)), + data: + ::core::clone::Clone::clone(&(*__self_0_1)),}, + } + } + } + impl ::core::marker::StructuralPartialEq for Form { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Form { + #[inline] + fn eq(&self, other: &Form) -> bool { + match *other { + Form { id: ref __self_1_0, data: ref __self_1_1 } => + match *self { + Form { id: ref __self_0_0, data: ref __self_0_1 } + => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1), + }, + } + } + #[inline] + fn ne(&self, other: &Form) -> bool { + match *other { + Form { id: ref __self_1_0, data: ref __self_1_1 } => + match *self { + Form { id: ref __self_0_0, data: ref __self_0_1 } + => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1), + }, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_SERIALIZE_FOR_Form: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde + :: export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl _serde::Serialize for Form { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "Form", + false + as + usize + + + 1 + + + 1) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "id", + &self.id) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "data", + &self.data) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::default::Default for Form { + #[inline] + fn default() -> Form { + Form{id: ::core::default::Default::default(), + data: ::core::default::Default::default(),} + } + } + } + } + /// Data structures for ser/de of relationship-related resources + pub mod relationship { + //! module containing everything relating to a relationship with + //! another account. + /// A struct containing information about a relationship with another account. + pub struct Relationship { + /// Target account id + pub id: String, + /// Whether the application client follows the account. + pub following: bool, + /// Whether the account follows the application client. + pub followed_by: bool, + /// Whether the application client blocks the account. + pub blocking: bool, + /// Whether the application client blocks the account. + pub muting: bool, + /// Whether the application client has requested to follow the account. + pub requested: bool, + /// Whether the user is also muting notifications + pub muting_notifications: bool, + /// Whether the user is currently blocking the accounts's domain + pub domain_blocking: bool, + /// Whether the user's reblogs will show up in the home timeline + pub showing_reblogs: bool, + /// Whether the user is currently endorsing the account + /// + /// This field is not techincally nullable with mastodon >= 2.5.0, but + /// making it `Option` here means we shouldn't get deser errors when + /// making calls to pleroma or mastodon<2.5.0 instances + pub endorsed: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Relationship { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Relationship { + id: ref __self_0_0, + following: ref __self_0_1, + followed_by: ref __self_0_2, + blocking: ref __self_0_3, + muting: ref __self_0_4, + requested: ref __self_0_5, + muting_notifications: ref __self_0_6, + domain_blocking: ref __self_0_7, + showing_reblogs: ref __self_0_8, + endorsed: ref __self_0_9 } => { + let mut debug_trait_builder = + f.debug_struct("Relationship"); + let _ = + debug_trait_builder.field("id", &&(*__self_0_0)); + let _ = + debug_trait_builder.field("following", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("followed_by", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("blocking", + &&(*__self_0_3)); + let _ = + debug_trait_builder.field("muting", + &&(*__self_0_4)); + let _ = + debug_trait_builder.field("requested", + &&(*__self_0_5)); + let _ = + debug_trait_builder.field("muting_notifications", + &&(*__self_0_6)); + let _ = + debug_trait_builder.field("domain_blocking", + &&(*__self_0_7)); + let _ = + debug_trait_builder.field("showing_reblogs", + &&(*__self_0_8)); + let _ = + debug_trait_builder.field("endorsed", + &&(*__self_0_9)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Relationship { + #[inline] + fn clone(&self) -> Relationship { + match *self { + Relationship { + id: ref __self_0_0, + following: ref __self_0_1, + followed_by: ref __self_0_2, + blocking: ref __self_0_3, + muting: ref __self_0_4, + requested: ref __self_0_5, + muting_notifications: ref __self_0_6, + domain_blocking: ref __self_0_7, + showing_reblogs: ref __self_0_8, + endorsed: ref __self_0_9 } => + Relationship{id: + ::core::clone::Clone::clone(&(*__self_0_0)), + following: + ::core::clone::Clone::clone(&(*__self_0_1)), + followed_by: + ::core::clone::Clone::clone(&(*__self_0_2)), + blocking: + ::core::clone::Clone::clone(&(*__self_0_3)), + muting: + ::core::clone::Clone::clone(&(*__self_0_4)), + requested: + ::core::clone::Clone::clone(&(*__self_0_5)), + muting_notifications: + ::core::clone::Clone::clone(&(*__self_0_6)), + domain_blocking: + ::core::clone::Clone::clone(&(*__self_0_7)), + showing_reblogs: + ::core::clone::Clone::clone(&(*__self_0_8)), + endorsed: + ::core::clone::Clone::clone(&(*__self_0_9)),}, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Relationship: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Relationship { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __field4, + __field5, + __field6, + __field7, + __field8, + __field9, + __ignore, + } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + 2u64 => + _serde::export::Ok(__Field::__field2), + 3u64 => + _serde::export::Ok(__Field::__field3), + 4u64 => + _serde::export::Ok(__Field::__field4), + 5u64 => + _serde::export::Ok(__Field::__field5), + 6u64 => + _serde::export::Ok(__Field::__field6), + 7u64 => + _serde::export::Ok(__Field::__field7), + 8u64 => + _serde::export::Ok(__Field::__field8), + 9u64 => + _serde::export::Ok(__Field::__field9), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 10")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "id" => + _serde::export::Ok(__Field::__field0), + "following" => + _serde::export::Ok(__Field::__field1), + "followed_by" => + _serde::export::Ok(__Field::__field2), + "blocking" => + _serde::export::Ok(__Field::__field3), + "muting" => + _serde::export::Ok(__Field::__field4), + "requested" => + _serde::export::Ok(__Field::__field5), + "muting_notifications" => + _serde::export::Ok(__Field::__field6), + "domain_blocking" => + _serde::export::Ok(__Field::__field7), + "showing_reblogs" => + _serde::export::Ok(__Field::__field8), + "endorsed" => + _serde::export::Ok(__Field::__field9), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"id" => + _serde::export::Ok(__Field::__field0), + b"following" => + _serde::export::Ok(__Field::__field1), + b"followed_by" => + _serde::export::Ok(__Field::__field2), + b"blocking" => + _serde::export::Ok(__Field::__field3), + b"muting" => + _serde::export::Ok(__Field::__field4), + b"requested" => + _serde::export::Ok(__Field::__field5), + b"muting_notifications" => + _serde::export::Ok(__Field::__field6), + b"domain_blocking" => + _serde::export::Ok(__Field::__field7), + b"showing_reblogs" => + _serde::export::Ok(__Field::__field8), + b"endorsed" => + _serde::export::Ok(__Field::__field9), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = Relationship; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct Relationship") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct Relationship with 10 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct Relationship with 10 elements")); + } + }; + let __field2 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(2usize, + &"struct Relationship with 10 elements")); + } + }; + let __field3 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(3usize, + &"struct Relationship with 10 elements")); + } + }; + let __field4 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(4usize, + &"struct Relationship with 10 elements")); + } + }; + let __field5 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(5usize, + &"struct Relationship with 10 elements")); + } + }; + let __field6 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(6usize, + &"struct Relationship with 10 elements")); + } + }; + let __field7 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(7usize, + &"struct Relationship with 10 elements")); + } + }; + let __field8 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(8usize, + &"struct Relationship with 10 elements")); + } + }; + let __field9 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(9usize, + &"struct Relationship with 10 elements")); + } + }; + _serde::export::Ok(Relationship{id: __field0, + following: + __field1, + followed_by: + __field2, + blocking: + __field3, + muting: + __field4, + requested: + __field5, + muting_notifications: + __field6, + domain_blocking: + __field7, + showing_reblogs: + __field8, + endorsed: + __field9,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option = + _serde::export::None; + let mut __field1: + _serde::export::Option = + _serde::export::None; + let mut __field2: + _serde::export::Option = + _serde::export::None; + let mut __field3: + _serde::export::Option = + _serde::export::None; + let mut __field4: + _serde::export::Option = + _serde::export::None; + let mut __field5: + _serde::export::Option = + _serde::export::None; + let mut __field6: + _serde::export::Option = + _serde::export::None; + let mut __field7: + _serde::export::Option = + _serde::export::None; + let mut __field8: + _serde::export::Option = + _serde::export::None; + let mut __field9: + _serde::export::Option> = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("id")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("following")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("followed_by")); + } + __field2 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field3 => { + if _serde::export::Option::is_some(&__field3) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("blocking")); + } + __field3 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field4 => { + if _serde::export::Option::is_some(&__field4) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("muting")); + } + __field4 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field5 => { + if _serde::export::Option::is_some(&__field5) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("requested")); + } + __field5 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field6 => { + if _serde::export::Option::is_some(&__field6) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("muting_notifications")); + } + __field6 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field7 => { + if _serde::export::Option::is_some(&__field7) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("domain_blocking")); + } + __field7 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field8 => { + if _serde::export::Option::is_some(&__field8) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("showing_reblogs")); + } + __field8 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field9 => { + if _serde::export::Option::is_some(&__field9) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("endorsed")); + } + __field9 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("id") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("following") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field2 = + match __field2 { + _serde::export::Some(__field2) => + __field2, + _serde::export::None => + match _serde::private::de::missing_field("followed_by") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field3 = + match __field3 { + _serde::export::Some(__field3) => + __field3, + _serde::export::None => + match _serde::private::de::missing_field("blocking") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field4 = + match __field4 { + _serde::export::Some(__field4) => + __field4, + _serde::export::None => + match _serde::private::de::missing_field("muting") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field5 = + match __field5 { + _serde::export::Some(__field5) => + __field5, + _serde::export::None => + match _serde::private::de::missing_field("requested") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field6 = + match __field6 { + _serde::export::Some(__field6) => + __field6, + _serde::export::None => + match _serde::private::de::missing_field("muting_notifications") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field7 = + match __field7 { + _serde::export::Some(__field7) => + __field7, + _serde::export::None => + match _serde::private::de::missing_field("domain_blocking") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field8 = + match __field8 { + _serde::export::Some(__field8) => + __field8, + _serde::export::None => + match _serde::private::de::missing_field("showing_reblogs") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field9 = + match __field9 { + _serde::export::Some(__field9) => + __field9, + _serde::export::None => + match _serde::private::de::missing_field("endorsed") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(Relationship{id: __field0, + following: + __field1, + followed_by: + __field2, + blocking: + __field3, + muting: + __field4, + requested: + __field5, + muting_notifications: + __field6, + domain_blocking: + __field7, + showing_reblogs: + __field8, + endorsed: + __field9,}) + } + } + const FIELDS: &'static [&'static str] = + &["id", "following", "followed_by", "blocking", + "muting", "requested", "muting_notifications", + "domain_blocking", "showing_reblogs", + "endorsed"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "Relationship", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl ::core::marker::StructuralPartialEq for Relationship { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Relationship { + #[inline] + fn eq(&self, other: &Relationship) -> bool { + match *other { + Relationship { + id: ref __self_1_0, + following: ref __self_1_1, + followed_by: ref __self_1_2, + blocking: ref __self_1_3, + muting: ref __self_1_4, + requested: ref __self_1_5, + muting_notifications: ref __self_1_6, + domain_blocking: ref __self_1_7, + showing_reblogs: ref __self_1_8, + endorsed: ref __self_1_9 } => + match *self { + Relationship { + id: ref __self_0_0, + following: ref __self_0_1, + followed_by: ref __self_0_2, + blocking: ref __self_0_3, + muting: ref __self_0_4, + requested: ref __self_0_5, + muting_notifications: ref __self_0_6, + domain_blocking: ref __self_0_7, + showing_reblogs: ref __self_0_8, + endorsed: ref __self_0_9 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3) && + (*__self_0_4) == (*__self_1_4) && + (*__self_0_5) == (*__self_1_5) && + (*__self_0_6) == (*__self_1_6) && + (*__self_0_7) == (*__self_1_7) && + (*__self_0_8) == (*__self_1_8) && + (*__self_0_9) == (*__self_1_9), + }, + } + } + #[inline] + fn ne(&self, other: &Relationship) -> bool { + match *other { + Relationship { + id: ref __self_1_0, + following: ref __self_1_1, + followed_by: ref __self_1_2, + blocking: ref __self_1_3, + muting: ref __self_1_4, + requested: ref __self_1_5, + muting_notifications: ref __self_1_6, + domain_blocking: ref __self_1_7, + showing_reblogs: ref __self_1_8, + endorsed: ref __self_1_9 } => + match *self { + Relationship { + id: ref __self_0_0, + following: ref __self_0_1, + followed_by: ref __self_0_2, + blocking: ref __self_0_3, + muting: ref __self_0_4, + requested: ref __self_0_5, + muting_notifications: ref __self_0_6, + domain_blocking: ref __self_0_7, + showing_reblogs: ref __self_0_8, + endorsed: ref __self_0_9 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3) || + (*__self_0_4) != (*__self_1_4) || + (*__self_0_5) != (*__self_1_5) || + (*__self_0_6) != (*__self_1_6) || + (*__self_0_7) != (*__self_1_7) || + (*__self_0_8) != (*__self_1_8) || + (*__self_0_9) != (*__self_1_9), + }, + } + } + } + } + /// Data structures for ser/de of report-related resources + pub mod report { + //! module containing information about a finished report of a user. + /// A struct containing info about a report. + pub struct Report { + /// The ID of the report. + pub id: String, + /// The action taken in response to the report. + pub action_taken: String, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Report { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Report { id: ref __self_0_0, action_taken: ref __self_0_1 + } => { + let mut debug_trait_builder = + f.debug_struct("Report"); + let _ = + debug_trait_builder.field("id", &&(*__self_0_0)); + let _ = + debug_trait_builder.field("action_taken", + &&(*__self_0_1)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Report { + #[inline] + fn clone(&self) -> Report { + match *self { + Report { id: ref __self_0_0, action_taken: ref __self_0_1 + } => + Report{id: ::core::clone::Clone::clone(&(*__self_0_0)), + action_taken: + ::core::clone::Clone::clone(&(*__self_0_1)),}, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Report: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Report { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { __field0, __field1, __ignore, } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 2")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "id" => + _serde::export::Ok(__Field::__field0), + "action_taken" => + _serde::export::Ok(__Field::__field1), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"id" => + _serde::export::Ok(__Field::__field0), + b"action_taken" => + _serde::export::Ok(__Field::__field1), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = Report; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct Report") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct Report with 2 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct Report with 2 elements")); + } + }; + _serde::export::Ok(Report{id: __field0, + action_taken: + __field1,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option = + _serde::export::None; + let mut __field1: + _serde::export::Option = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("id")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("action_taken")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("id") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("action_taken") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(Report{id: __field0, + action_taken: + __field1,}) + } + } + const FIELDS: &'static [&'static str] = + &["id", "action_taken"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "Report", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl ::core::marker::StructuralPartialEq for Report { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Report { + #[inline] + fn eq(&self, other: &Report) -> bool { + match *other { + Report { id: ref __self_1_0, action_taken: ref __self_1_1 + } => + match *self { + Report { + id: ref __self_0_0, action_taken: ref __self_0_1 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1), + }, + } + } + #[inline] + fn ne(&self, other: &Report) -> bool { + match *other { + Report { id: ref __self_1_0, action_taken: ref __self_1_1 + } => + match *self { + Report { + id: ref __self_0_0, action_taken: ref __self_0_1 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1), + }, + } + } + } + } + /// Data structures for ser/de of search-related resources + pub mod search_result { + //! A module containing info relating to a search result. + use super::{prelude::{Account, Status}, status::Tag}; + /// A struct containing results of a search. + pub struct SearchResult { + /// An array of matched Accounts. + pub accounts: Vec, + /// An array of matched Statuses. + pub statuses: Vec, + /// An array of matched hashtags, as strings. + pub hashtags: Vec, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for SearchResult { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + SearchResult { + accounts: ref __self_0_0, + statuses: ref __self_0_1, + hashtags: ref __self_0_2 } => { + let mut debug_trait_builder = + f.debug_struct("SearchResult"); + let _ = + debug_trait_builder.field("accounts", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("statuses", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("hashtags", + &&(*__self_0_2)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for SearchResult { + #[inline] + fn clone(&self) -> SearchResult { + match *self { + SearchResult { + accounts: ref __self_0_0, + statuses: ref __self_0_1, + hashtags: ref __self_0_2 } => + SearchResult{accounts: + ::core::clone::Clone::clone(&(*__self_0_0)), + statuses: + ::core::clone::Clone::clone(&(*__self_0_1)), + hashtags: + ::core::clone::Clone::clone(&(*__self_0_2)),}, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_SearchResult: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for SearchResult { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + 2u64 => + _serde::export::Ok(__Field::__field2), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 3")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "accounts" => + _serde::export::Ok(__Field::__field0), + "statuses" => + _serde::export::Ok(__Field::__field1), + "hashtags" => + _serde::export::Ok(__Field::__field2), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"accounts" => + _serde::export::Ok(__Field::__field0), + b"statuses" => + _serde::export::Ok(__Field::__field1), + b"hashtags" => + _serde::export::Ok(__Field::__field2), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = SearchResult; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct SearchResult") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct SearchResult with 3 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct SearchResult with 3 elements")); + } + }; + let __field2 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(2usize, + &"struct SearchResult with 3 elements")); + } + }; + _serde::export::Ok(SearchResult{accounts: + __field0, + statuses: + __field1, + hashtags: + __field2,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option> = + _serde::export::None; + let mut __field1: + _serde::export::Option> = + _serde::export::None; + let mut __field2: + _serde::export::Option> = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("accounts")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("statuses")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("hashtags")); + } + __field2 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("accounts") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("statuses") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field2 = + match __field2 { + _serde::export::Some(__field2) => + __field2, + _serde::export::None => + match _serde::private::de::missing_field("hashtags") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(SearchResult{accounts: + __field0, + statuses: + __field1, + hashtags: + __field2,}) + } + } + const FIELDS: &'static [&'static str] = + &["accounts", "statuses", "hashtags"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "SearchResult", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl ::core::marker::StructuralPartialEq for SearchResult { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for SearchResult { + #[inline] + fn eq(&self, other: &SearchResult) -> bool { + match *other { + SearchResult { + accounts: ref __self_1_0, + statuses: ref __self_1_1, + hashtags: ref __self_1_2 } => + match *self { + SearchResult { + accounts: ref __self_0_0, + statuses: ref __self_0_1, + hashtags: ref __self_0_2 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2), + }, + } + } + #[inline] + fn ne(&self, other: &SearchResult) -> bool { + match *other { + SearchResult { + accounts: ref __self_1_0, + statuses: ref __self_1_1, + hashtags: ref __self_1_2 } => + match *self { + SearchResult { + accounts: ref __self_0_0, + statuses: ref __self_0_1, + hashtags: ref __self_0_2 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2), + }, + } + } + } + /// A struct containing results of a search, with `Tag` objects in the + /// `hashtags` field + pub struct SearchResultV2 { + /// An array of matched Accounts. + pub accounts: Vec, + /// An array of matched Statuses. + pub statuses: Vec, + /// An array of matched hashtags, as `Tag` objects. + pub hashtags: Vec, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for SearchResultV2 { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + SearchResultV2 { + accounts: ref __self_0_0, + statuses: ref __self_0_1, + hashtags: ref __self_0_2 } => { + let mut debug_trait_builder = + f.debug_struct("SearchResultV2"); + let _ = + debug_trait_builder.field("accounts", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("statuses", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("hashtags", + &&(*__self_0_2)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for SearchResultV2 { + #[inline] + fn clone(&self) -> SearchResultV2 { + match *self { + SearchResultV2 { + accounts: ref __self_0_0, + statuses: ref __self_0_1, + hashtags: ref __self_0_2 } => + SearchResultV2{accounts: + ::core::clone::Clone::clone(&(*__self_0_0)), + statuses: + ::core::clone::Clone::clone(&(*__self_0_1)), + hashtags: + ::core::clone::Clone::clone(&(*__self_0_2)),}, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_SearchResultV2: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for SearchResultV2 { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + 2u64 => + _serde::export::Ok(__Field::__field2), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 3")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "accounts" => + _serde::export::Ok(__Field::__field0), + "statuses" => + _serde::export::Ok(__Field::__field1), + "hashtags" => + _serde::export::Ok(__Field::__field2), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"accounts" => + _serde::export::Ok(__Field::__field0), + b"statuses" => + _serde::export::Ok(__Field::__field1), + b"hashtags" => + _serde::export::Ok(__Field::__field2), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = SearchResultV2; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct SearchResultV2") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct SearchResultV2 with 3 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct SearchResultV2 with 3 elements")); + } + }; + let __field2 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(2usize, + &"struct SearchResultV2 with 3 elements")); + } + }; + _serde::export::Ok(SearchResultV2{accounts: + __field0, + statuses: + __field1, + hashtags: + __field2,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option> = + _serde::export::None; + let mut __field1: + _serde::export::Option> = + _serde::export::None; + let mut __field2: + _serde::export::Option> = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("accounts")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("statuses")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("hashtags")); + } + __field2 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("accounts") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("statuses") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field2 = + match __field2 { + _serde::export::Some(__field2) => + __field2, + _serde::export::None => + match _serde::private::de::missing_field("hashtags") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(SearchResultV2{accounts: + __field0, + statuses: + __field1, + hashtags: + __field2,}) + } + } + const FIELDS: &'static [&'static str] = + &["accounts", "statuses", "hashtags"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "SearchResultV2", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl ::core::marker::StructuralPartialEq for SearchResultV2 { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for SearchResultV2 { + #[inline] + fn eq(&self, other: &SearchResultV2) -> bool { + match *other { + SearchResultV2 { + accounts: ref __self_1_0, + statuses: ref __self_1_1, + hashtags: ref __self_1_2 } => + match *self { + SearchResultV2 { + accounts: ref __self_0_0, + statuses: ref __self_0_1, + hashtags: ref __self_0_2 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2), + }, + } + } + #[inline] + fn ne(&self, other: &SearchResultV2) -> bool { + match *other { + SearchResultV2 { + accounts: ref __self_1_0, + statuses: ref __self_1_1, + hashtags: ref __self_1_2 } => + match *self { + SearchResultV2 { + accounts: ref __self_0_0, + statuses: ref __self_0_1, + hashtags: ref __self_0_2 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2), + }, + } + } + } + } + /// Data structures for ser/de of status-related resources + pub mod status { + //! Module containing all info relating to a status. + use super::prelude::*; + use chrono::prelude::*; + use crate::entities::card::Card; + use crate::status_builder::Visibility; + /// A status from the instance. + pub struct Status { + /// The ID of the status. + pub id: String, + /// A Fediverse-unique resource ID. + pub uri: String, + /// URL to the status page (can be remote) + pub url: Option, + /// The Account which posted the status. + pub account: Account, + /// The ID of the status this status is replying to, if the status is + /// a reply. + pub in_reply_to_id: Option, + /// The ID of the account this status is replying to, if the status is + /// a reply. + pub in_reply_to_account_id: Option, + /// If this status is a reblogged Status of another User. + pub reblog: Option>, + /// Body of the status; this will contain HTML + /// (remote HTML already sanitized) + pub content: String, + /// The time the status was created. + pub created_at: DateTime, + /// An array of Emoji + pub emojis: Vec, + /// The numbef or replies to this status. + pub replies_count: Option, + /// The number of reblogs for the status. + pub reblogs_count: u64, + /// The number of favourites for the status. + pub favourites_count: u64, + /// Whether the application client has reblogged the status. + pub reblogged: Option, + /// Whether the application client has favourited the status. + pub favourited: Option, + /// Whether media attachments should be hidden by default. + pub sensitive: bool, + /// If not empty, warning text that should be displayed before the actual + /// content. + pub spoiler_text: String, + /// The visibilty of the status. + pub visibility: Visibility, + /// An array of attachments. + pub media_attachments: Vec, + /// An array of mentions. + pub mentions: Vec, + /// An array of tags. + pub tags: Vec, + /// The associated card + pub card: Option, + /// Name of application used to post status. + pub application: Option, + /// The detected language for the status, if detected. + pub language: Option, + /// Whether this is the pinned status for the account that posted it. + pub pinned: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Status { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Status { + id: ref __self_0_0, + uri: ref __self_0_1, + url: ref __self_0_2, + account: ref __self_0_3, + in_reply_to_id: ref __self_0_4, + in_reply_to_account_id: ref __self_0_5, + reblog: ref __self_0_6, + content: ref __self_0_7, + created_at: ref __self_0_8, + emojis: ref __self_0_9, + replies_count: ref __self_0_10, + reblogs_count: ref __self_0_11, + favourites_count: ref __self_0_12, + reblogged: ref __self_0_13, + favourited: ref __self_0_14, + sensitive: ref __self_0_15, + spoiler_text: ref __self_0_16, + visibility: ref __self_0_17, + media_attachments: ref __self_0_18, + mentions: ref __self_0_19, + tags: ref __self_0_20, + card: ref __self_0_21, + application: ref __self_0_22, + language: ref __self_0_23, + pinned: ref __self_0_24 } => { + let mut debug_trait_builder = + f.debug_struct("Status"); + let _ = + debug_trait_builder.field("id", &&(*__self_0_0)); + let _ = + debug_trait_builder.field("uri", &&(*__self_0_1)); + let _ = + debug_trait_builder.field("url", &&(*__self_0_2)); + let _ = + debug_trait_builder.field("account", + &&(*__self_0_3)); + let _ = + debug_trait_builder.field("in_reply_to_id", + &&(*__self_0_4)); + let _ = + debug_trait_builder.field("in_reply_to_account_id", + &&(*__self_0_5)); + let _ = + debug_trait_builder.field("reblog", + &&(*__self_0_6)); + let _ = + debug_trait_builder.field("content", + &&(*__self_0_7)); + let _ = + debug_trait_builder.field("created_at", + &&(*__self_0_8)); + let _ = + debug_trait_builder.field("emojis", + &&(*__self_0_9)); + let _ = + debug_trait_builder.field("replies_count", + &&(*__self_0_10)); + let _ = + debug_trait_builder.field("reblogs_count", + &&(*__self_0_11)); + let _ = + debug_trait_builder.field("favourites_count", + &&(*__self_0_12)); + let _ = + debug_trait_builder.field("reblogged", + &&(*__self_0_13)); + let _ = + debug_trait_builder.field("favourited", + &&(*__self_0_14)); + let _ = + debug_trait_builder.field("sensitive", + &&(*__self_0_15)); + let _ = + debug_trait_builder.field("spoiler_text", + &&(*__self_0_16)); + let _ = + debug_trait_builder.field("visibility", + &&(*__self_0_17)); + let _ = + debug_trait_builder.field("media_attachments", + &&(*__self_0_18)); + let _ = + debug_trait_builder.field("mentions", + &&(*__self_0_19)); + let _ = + debug_trait_builder.field("tags", + &&(*__self_0_20)); + let _ = + debug_trait_builder.field("card", + &&(*__self_0_21)); + let _ = + debug_trait_builder.field("application", + &&(*__self_0_22)); + let _ = + debug_trait_builder.field("language", + &&(*__self_0_23)); + let _ = + debug_trait_builder.field("pinned", + &&(*__self_0_24)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Status { + #[inline] + fn clone(&self) -> Status { + match *self { + Status { + id: ref __self_0_0, + uri: ref __self_0_1, + url: ref __self_0_2, + account: ref __self_0_3, + in_reply_to_id: ref __self_0_4, + in_reply_to_account_id: ref __self_0_5, + reblog: ref __self_0_6, + content: ref __self_0_7, + created_at: ref __self_0_8, + emojis: ref __self_0_9, + replies_count: ref __self_0_10, + reblogs_count: ref __self_0_11, + favourites_count: ref __self_0_12, + reblogged: ref __self_0_13, + favourited: ref __self_0_14, + sensitive: ref __self_0_15, + spoiler_text: ref __self_0_16, + visibility: ref __self_0_17, + media_attachments: ref __self_0_18, + mentions: ref __self_0_19, + tags: ref __self_0_20, + card: ref __self_0_21, + application: ref __self_0_22, + language: ref __self_0_23, + pinned: ref __self_0_24 } => + Status{id: ::core::clone::Clone::clone(&(*__self_0_0)), + uri: ::core::clone::Clone::clone(&(*__self_0_1)), + url: ::core::clone::Clone::clone(&(*__self_0_2)), + account: + ::core::clone::Clone::clone(&(*__self_0_3)), + in_reply_to_id: + ::core::clone::Clone::clone(&(*__self_0_4)), + in_reply_to_account_id: + ::core::clone::Clone::clone(&(*__self_0_5)), + reblog: + ::core::clone::Clone::clone(&(*__self_0_6)), + content: + ::core::clone::Clone::clone(&(*__self_0_7)), + created_at: + ::core::clone::Clone::clone(&(*__self_0_8)), + emojis: + ::core::clone::Clone::clone(&(*__self_0_9)), + replies_count: + ::core::clone::Clone::clone(&(*__self_0_10)), + reblogs_count: + ::core::clone::Clone::clone(&(*__self_0_11)), + favourites_count: + ::core::clone::Clone::clone(&(*__self_0_12)), + reblogged: + ::core::clone::Clone::clone(&(*__self_0_13)), + favourited: + ::core::clone::Clone::clone(&(*__self_0_14)), + sensitive: + ::core::clone::Clone::clone(&(*__self_0_15)), + spoiler_text: + ::core::clone::Clone::clone(&(*__self_0_16)), + visibility: + ::core::clone::Clone::clone(&(*__self_0_17)), + media_attachments: + ::core::clone::Clone::clone(&(*__self_0_18)), + mentions: + ::core::clone::Clone::clone(&(*__self_0_19)), + tags: ::core::clone::Clone::clone(&(*__self_0_20)), + card: ::core::clone::Clone::clone(&(*__self_0_21)), + application: + ::core::clone::Clone::clone(&(*__self_0_22)), + language: + ::core::clone::Clone::clone(&(*__self_0_23)), + pinned: + ::core::clone::Clone::clone(&(*__self_0_24)),}, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Status: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Status { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __field4, + __field5, + __field6, + __field7, + __field8, + __field9, + __field10, + __field11, + __field12, + __field13, + __field14, + __field15, + __field16, + __field17, + __field18, + __field19, + __field20, + __field21, + __field22, + __field23, + __field24, + __ignore, + } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + 2u64 => + _serde::export::Ok(__Field::__field2), + 3u64 => + _serde::export::Ok(__Field::__field3), + 4u64 => + _serde::export::Ok(__Field::__field4), + 5u64 => + _serde::export::Ok(__Field::__field5), + 6u64 => + _serde::export::Ok(__Field::__field6), + 7u64 => + _serde::export::Ok(__Field::__field7), + 8u64 => + _serde::export::Ok(__Field::__field8), + 9u64 => + _serde::export::Ok(__Field::__field9), + 10u64 => + _serde::export::Ok(__Field::__field10), + 11u64 => + _serde::export::Ok(__Field::__field11), + 12u64 => + _serde::export::Ok(__Field::__field12), + 13u64 => + _serde::export::Ok(__Field::__field13), + 14u64 => + _serde::export::Ok(__Field::__field14), + 15u64 => + _serde::export::Ok(__Field::__field15), + 16u64 => + _serde::export::Ok(__Field::__field16), + 17u64 => + _serde::export::Ok(__Field::__field17), + 18u64 => + _serde::export::Ok(__Field::__field18), + 19u64 => + _serde::export::Ok(__Field::__field19), + 20u64 => + _serde::export::Ok(__Field::__field20), + 21u64 => + _serde::export::Ok(__Field::__field21), + 22u64 => + _serde::export::Ok(__Field::__field22), + 23u64 => + _serde::export::Ok(__Field::__field23), + 24u64 => + _serde::export::Ok(__Field::__field24), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 25")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "id" => + _serde::export::Ok(__Field::__field0), + "uri" => + _serde::export::Ok(__Field::__field1), + "url" => + _serde::export::Ok(__Field::__field2), + "account" => + _serde::export::Ok(__Field::__field3), + "in_reply_to_id" => + _serde::export::Ok(__Field::__field4), + "in_reply_to_account_id" => + _serde::export::Ok(__Field::__field5), + "reblog" => + _serde::export::Ok(__Field::__field6), + "content" => + _serde::export::Ok(__Field::__field7), + "created_at" => + _serde::export::Ok(__Field::__field8), + "emojis" => + _serde::export::Ok(__Field::__field9), + "replies_count" => + _serde::export::Ok(__Field::__field10), + "reblogs_count" => + _serde::export::Ok(__Field::__field11), + "favourites_count" => + _serde::export::Ok(__Field::__field12), + "reblogged" => + _serde::export::Ok(__Field::__field13), + "favourited" => + _serde::export::Ok(__Field::__field14), + "sensitive" => + _serde::export::Ok(__Field::__field15), + "spoiler_text" => + _serde::export::Ok(__Field::__field16), + "visibility" => + _serde::export::Ok(__Field::__field17), + "media_attachments" => + _serde::export::Ok(__Field::__field18), + "mentions" => + _serde::export::Ok(__Field::__field19), + "tags" => + _serde::export::Ok(__Field::__field20), + "card" => + _serde::export::Ok(__Field::__field21), + "application" => + _serde::export::Ok(__Field::__field22), + "language" => + _serde::export::Ok(__Field::__field23), + "pinned" => + _serde::export::Ok(__Field::__field24), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"id" => + _serde::export::Ok(__Field::__field0), + b"uri" => + _serde::export::Ok(__Field::__field1), + b"url" => + _serde::export::Ok(__Field::__field2), + b"account" => + _serde::export::Ok(__Field::__field3), + b"in_reply_to_id" => + _serde::export::Ok(__Field::__field4), + b"in_reply_to_account_id" => + _serde::export::Ok(__Field::__field5), + b"reblog" => + _serde::export::Ok(__Field::__field6), + b"content" => + _serde::export::Ok(__Field::__field7), + b"created_at" => + _serde::export::Ok(__Field::__field8), + b"emojis" => + _serde::export::Ok(__Field::__field9), + b"replies_count" => + _serde::export::Ok(__Field::__field10), + b"reblogs_count" => + _serde::export::Ok(__Field::__field11), + b"favourites_count" => + _serde::export::Ok(__Field::__field12), + b"reblogged" => + _serde::export::Ok(__Field::__field13), + b"favourited" => + _serde::export::Ok(__Field::__field14), + b"sensitive" => + _serde::export::Ok(__Field::__field15), + b"spoiler_text" => + _serde::export::Ok(__Field::__field16), + b"visibility" => + _serde::export::Ok(__Field::__field17), + b"media_attachments" => + _serde::export::Ok(__Field::__field18), + b"mentions" => + _serde::export::Ok(__Field::__field19), + b"tags" => + _serde::export::Ok(__Field::__field20), + b"card" => + _serde::export::Ok(__Field::__field21), + b"application" => + _serde::export::Ok(__Field::__field22), + b"language" => + _serde::export::Ok(__Field::__field23), + b"pinned" => + _serde::export::Ok(__Field::__field24), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = Status; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct Status") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct Status with 25 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct Status with 25 elements")); + } + }; + let __field2 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(2usize, + &"struct Status with 25 elements")); + } + }; + let __field3 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(3usize, + &"struct Status with 25 elements")); + } + }; + let __field4 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(4usize, + &"struct Status with 25 elements")); + } + }; + let __field5 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(5usize, + &"struct Status with 25 elements")); + } + }; + let __field6 = + match match _serde::de::SeqAccess::next_element::>>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(6usize, + &"struct Status with 25 elements")); + } + }; + let __field7 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(7usize, + &"struct Status with 25 elements")); + } + }; + let __field8 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(8usize, + &"struct Status with 25 elements")); + } + }; + let __field9 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(9usize, + &"struct Status with 25 elements")); + } + }; + let __field10 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(10usize, + &"struct Status with 25 elements")); + } + }; + let __field11 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(11usize, + &"struct Status with 25 elements")); + } + }; + let __field12 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(12usize, + &"struct Status with 25 elements")); + } + }; + let __field13 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(13usize, + &"struct Status with 25 elements")); + } + }; + let __field14 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(14usize, + &"struct Status with 25 elements")); + } + }; + let __field15 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(15usize, + &"struct Status with 25 elements")); + } + }; + let __field16 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(16usize, + &"struct Status with 25 elements")); + } + }; + let __field17 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(17usize, + &"struct Status with 25 elements")); + } + }; + let __field18 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(18usize, + &"struct Status with 25 elements")); + } + }; + let __field19 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(19usize, + &"struct Status with 25 elements")); + } + }; + let __field20 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(20usize, + &"struct Status with 25 elements")); + } + }; + let __field21 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(21usize, + &"struct Status with 25 elements")); + } + }; + let __field22 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(22usize, + &"struct Status with 25 elements")); + } + }; + let __field23 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(23usize, + &"struct Status with 25 elements")); + } + }; + let __field24 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(24usize, + &"struct Status with 25 elements")); + } + }; + _serde::export::Ok(Status{id: __field0, + uri: __field1, + url: __field2, + account: __field3, + in_reply_to_id: + __field4, + in_reply_to_account_id: + __field5, + reblog: __field6, + content: __field7, + created_at: + __field8, + emojis: __field9, + replies_count: + __field10, + reblogs_count: + __field11, + favourites_count: + __field12, + reblogged: + __field13, + favourited: + __field14, + sensitive: + __field15, + spoiler_text: + __field16, + visibility: + __field17, + media_attachments: + __field18, + mentions: __field19, + tags: __field20, + card: __field21, + application: + __field22, + language: __field23, + pinned: __field24,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option = + _serde::export::None; + let mut __field1: + _serde::export::Option = + _serde::export::None; + let mut __field2: + _serde::export::Option> = + _serde::export::None; + let mut __field3: + _serde::export::Option = + _serde::export::None; + let mut __field4: + _serde::export::Option> = + _serde::export::None; + let mut __field5: + _serde::export::Option> = + _serde::export::None; + let mut __field6: + _serde::export::Option>> = + _serde::export::None; + let mut __field7: + _serde::export::Option = + _serde::export::None; + let mut __field8: + _serde::export::Option> = + _serde::export::None; + let mut __field9: + _serde::export::Option> = + _serde::export::None; + let mut __field10: + _serde::export::Option> = + _serde::export::None; + let mut __field11: + _serde::export::Option = + _serde::export::None; + let mut __field12: + _serde::export::Option = + _serde::export::None; + let mut __field13: + _serde::export::Option> = + _serde::export::None; + let mut __field14: + _serde::export::Option> = + _serde::export::None; + let mut __field15: + _serde::export::Option = + _serde::export::None; + let mut __field16: + _serde::export::Option = + _serde::export::None; + let mut __field17: + _serde::export::Option = + _serde::export::None; + let mut __field18: + _serde::export::Option> = + _serde::export::None; + let mut __field19: + _serde::export::Option> = + _serde::export::None; + let mut __field20: + _serde::export::Option> = + _serde::export::None; + let mut __field21: + _serde::export::Option> = + _serde::export::None; + let mut __field22: + _serde::export::Option> = + _serde::export::None; + let mut __field23: + _serde::export::Option> = + _serde::export::None; + let mut __field24: + _serde::export::Option> = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("id")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("uri")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("url")); + } + __field2 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field3 => { + if _serde::export::Option::is_some(&__field3) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("account")); + } + __field3 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field4 => { + if _serde::export::Option::is_some(&__field4) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("in_reply_to_id")); + } + __field4 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field5 => { + if _serde::export::Option::is_some(&__field5) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("in_reply_to_account_id")); + } + __field5 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field6 => { + if _serde::export::Option::is_some(&__field6) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("reblog")); + } + __field6 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field7 => { + if _serde::export::Option::is_some(&__field7) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("content")); + } + __field7 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field8 => { + if _serde::export::Option::is_some(&__field8) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("created_at")); + } + __field8 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field9 => { + if _serde::export::Option::is_some(&__field9) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("emojis")); + } + __field9 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field10 => { + if _serde::export::Option::is_some(&__field10) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("replies_count")); + } + __field10 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field11 => { + if _serde::export::Option::is_some(&__field11) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("reblogs_count")); + } + __field11 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field12 => { + if _serde::export::Option::is_some(&__field12) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("favourites_count")); + } + __field12 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field13 => { + if _serde::export::Option::is_some(&__field13) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("reblogged")); + } + __field13 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field14 => { + if _serde::export::Option::is_some(&__field14) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("favourited")); + } + __field14 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field15 => { + if _serde::export::Option::is_some(&__field15) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("sensitive")); + } + __field15 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field16 => { + if _serde::export::Option::is_some(&__field16) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("spoiler_text")); + } + __field16 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field17 => { + if _serde::export::Option::is_some(&__field17) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("visibility")); + } + __field17 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field18 => { + if _serde::export::Option::is_some(&__field18) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("media_attachments")); + } + __field18 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field19 => { + if _serde::export::Option::is_some(&__field19) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("mentions")); + } + __field19 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field20 => { + if _serde::export::Option::is_some(&__field20) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("tags")); + } + __field20 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field21 => { + if _serde::export::Option::is_some(&__field21) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("card")); + } + __field21 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field22 => { + if _serde::export::Option::is_some(&__field22) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("application")); + } + __field22 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field23 => { + if _serde::export::Option::is_some(&__field23) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("language")); + } + __field23 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field24 => { + if _serde::export::Option::is_some(&__field24) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("pinned")); + } + __field24 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("id") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("uri") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field2 = + match __field2 { + _serde::export::Some(__field2) => + __field2, + _serde::export::None => + match _serde::private::de::missing_field("url") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field3 = + match __field3 { + _serde::export::Some(__field3) => + __field3, + _serde::export::None => + match _serde::private::de::missing_field("account") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field4 = + match __field4 { + _serde::export::Some(__field4) => + __field4, + _serde::export::None => + match _serde::private::de::missing_field("in_reply_to_id") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field5 = + match __field5 { + _serde::export::Some(__field5) => + __field5, + _serde::export::None => + match _serde::private::de::missing_field("in_reply_to_account_id") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field6 = + match __field6 { + _serde::export::Some(__field6) => + __field6, + _serde::export::None => + match _serde::private::de::missing_field("reblog") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field7 = + match __field7 { + _serde::export::Some(__field7) => + __field7, + _serde::export::None => + match _serde::private::de::missing_field("content") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field8 = + match __field8 { + _serde::export::Some(__field8) => + __field8, + _serde::export::None => + match _serde::private::de::missing_field("created_at") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field9 = + match __field9 { + _serde::export::Some(__field9) => + __field9, + _serde::export::None => + match _serde::private::de::missing_field("emojis") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field10 = + match __field10 { + _serde::export::Some(__field10) => + __field10, + _serde::export::None => + match _serde::private::de::missing_field("replies_count") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field11 = + match __field11 { + _serde::export::Some(__field11) => + __field11, + _serde::export::None => + match _serde::private::de::missing_field("reblogs_count") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field12 = + match __field12 { + _serde::export::Some(__field12) => + __field12, + _serde::export::None => + match _serde::private::de::missing_field("favourites_count") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field13 = + match __field13 { + _serde::export::Some(__field13) => + __field13, + _serde::export::None => + match _serde::private::de::missing_field("reblogged") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field14 = + match __field14 { + _serde::export::Some(__field14) => + __field14, + _serde::export::None => + match _serde::private::de::missing_field("favourited") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field15 = + match __field15 { + _serde::export::Some(__field15) => + __field15, + _serde::export::None => + match _serde::private::de::missing_field("sensitive") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field16 = + match __field16 { + _serde::export::Some(__field16) => + __field16, + _serde::export::None => + match _serde::private::de::missing_field("spoiler_text") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field17 = + match __field17 { + _serde::export::Some(__field17) => + __field17, + _serde::export::None => + match _serde::private::de::missing_field("visibility") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field18 = + match __field18 { + _serde::export::Some(__field18) => + __field18, + _serde::export::None => + match _serde::private::de::missing_field("media_attachments") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field19 = + match __field19 { + _serde::export::Some(__field19) => + __field19, + _serde::export::None => + match _serde::private::de::missing_field("mentions") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field20 = + match __field20 { + _serde::export::Some(__field20) => + __field20, + _serde::export::None => + match _serde::private::de::missing_field("tags") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field21 = + match __field21 { + _serde::export::Some(__field21) => + __field21, + _serde::export::None => + match _serde::private::de::missing_field("card") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field22 = + match __field22 { + _serde::export::Some(__field22) => + __field22, + _serde::export::None => + match _serde::private::de::missing_field("application") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field23 = + match __field23 { + _serde::export::Some(__field23) => + __field23, + _serde::export::None => + match _serde::private::de::missing_field("language") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field24 = + match __field24 { + _serde::export::Some(__field24) => + __field24, + _serde::export::None => + match _serde::private::de::missing_field("pinned") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(Status{id: __field0, + uri: __field1, + url: __field2, + account: __field3, + in_reply_to_id: + __field4, + in_reply_to_account_id: + __field5, + reblog: __field6, + content: __field7, + created_at: + __field8, + emojis: __field9, + replies_count: + __field10, + reblogs_count: + __field11, + favourites_count: + __field12, + reblogged: + __field13, + favourited: + __field14, + sensitive: + __field15, + spoiler_text: + __field16, + visibility: + __field17, + media_attachments: + __field18, + mentions: __field19, + tags: __field20, + card: __field21, + application: + __field22, + language: __field23, + pinned: __field24,}) + } + } + const FIELDS: &'static [&'static str] = + &["id", "uri", "url", "account", "in_reply_to_id", + "in_reply_to_account_id", "reblog", "content", + "created_at", "emojis", "replies_count", + "reblogs_count", "favourites_count", + "reblogged", "favourited", "sensitive", + "spoiler_text", "visibility", + "media_attachments", "mentions", "tags", "card", + "application", "language", "pinned"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "Status", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl ::core::marker::StructuralPartialEq for Status { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Status { + #[inline] + fn eq(&self, other: &Status) -> bool { + match *other { + Status { + id: ref __self_1_0, + uri: ref __self_1_1, + url: ref __self_1_2, + account: ref __self_1_3, + in_reply_to_id: ref __self_1_4, + in_reply_to_account_id: ref __self_1_5, + reblog: ref __self_1_6, + content: ref __self_1_7, + created_at: ref __self_1_8, + emojis: ref __self_1_9, + replies_count: ref __self_1_10, + reblogs_count: ref __self_1_11, + favourites_count: ref __self_1_12, + reblogged: ref __self_1_13, + favourited: ref __self_1_14, + sensitive: ref __self_1_15, + spoiler_text: ref __self_1_16, + visibility: ref __self_1_17, + media_attachments: ref __self_1_18, + mentions: ref __self_1_19, + tags: ref __self_1_20, + card: ref __self_1_21, + application: ref __self_1_22, + language: ref __self_1_23, + pinned: ref __self_1_24 } => + match *self { + Status { + id: ref __self_0_0, + uri: ref __self_0_1, + url: ref __self_0_2, + account: ref __self_0_3, + in_reply_to_id: ref __self_0_4, + in_reply_to_account_id: ref __self_0_5, + reblog: ref __self_0_6, + content: ref __self_0_7, + created_at: ref __self_0_8, + emojis: ref __self_0_9, + replies_count: ref __self_0_10, + reblogs_count: ref __self_0_11, + favourites_count: ref __self_0_12, + reblogged: ref __self_0_13, + favourited: ref __self_0_14, + sensitive: ref __self_0_15, + spoiler_text: ref __self_0_16, + visibility: ref __self_0_17, + media_attachments: ref __self_0_18, + mentions: ref __self_0_19, + tags: ref __self_0_20, + card: ref __self_0_21, + application: ref __self_0_22, + language: ref __self_0_23, + pinned: ref __self_0_24 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3) && + (*__self_0_4) == (*__self_1_4) && + (*__self_0_5) == (*__self_1_5) && + (*__self_0_6) == (*__self_1_6) && + (*__self_0_7) == (*__self_1_7) && + (*__self_0_8) == (*__self_1_8) && + (*__self_0_9) == (*__self_1_9) && + (*__self_0_10) == (*__self_1_10) && + (*__self_0_11) == (*__self_1_11) && + (*__self_0_12) == (*__self_1_12) && + (*__self_0_13) == (*__self_1_13) && + (*__self_0_14) == (*__self_1_14) && + (*__self_0_15) == (*__self_1_15) && + (*__self_0_16) == (*__self_1_16) && + (*__self_0_17) == (*__self_1_17) && + (*__self_0_18) == (*__self_1_18) && + (*__self_0_19) == (*__self_1_19) && + (*__self_0_20) == (*__self_1_20) && + (*__self_0_21) == (*__self_1_21) && + (*__self_0_22) == (*__self_1_22) && + (*__self_0_23) == (*__self_1_23) && + (*__self_0_24) == (*__self_1_24), + }, + } + } + #[inline] + fn ne(&self, other: &Status) -> bool { + match *other { + Status { + id: ref __self_1_0, + uri: ref __self_1_1, + url: ref __self_1_2, + account: ref __self_1_3, + in_reply_to_id: ref __self_1_4, + in_reply_to_account_id: ref __self_1_5, + reblog: ref __self_1_6, + content: ref __self_1_7, + created_at: ref __self_1_8, + emojis: ref __self_1_9, + replies_count: ref __self_1_10, + reblogs_count: ref __self_1_11, + favourites_count: ref __self_1_12, + reblogged: ref __self_1_13, + favourited: ref __self_1_14, + sensitive: ref __self_1_15, + spoiler_text: ref __self_1_16, + visibility: ref __self_1_17, + media_attachments: ref __self_1_18, + mentions: ref __self_1_19, + tags: ref __self_1_20, + card: ref __self_1_21, + application: ref __self_1_22, + language: ref __self_1_23, + pinned: ref __self_1_24 } => + match *self { + Status { + id: ref __self_0_0, + uri: ref __self_0_1, + url: ref __self_0_2, + account: ref __self_0_3, + in_reply_to_id: ref __self_0_4, + in_reply_to_account_id: ref __self_0_5, + reblog: ref __self_0_6, + content: ref __self_0_7, + created_at: ref __self_0_8, + emojis: ref __self_0_9, + replies_count: ref __self_0_10, + reblogs_count: ref __self_0_11, + favourites_count: ref __self_0_12, + reblogged: ref __self_0_13, + favourited: ref __self_0_14, + sensitive: ref __self_0_15, + spoiler_text: ref __self_0_16, + visibility: ref __self_0_17, + media_attachments: ref __self_0_18, + mentions: ref __self_0_19, + tags: ref __self_0_20, + card: ref __self_0_21, + application: ref __self_0_22, + language: ref __self_0_23, + pinned: ref __self_0_24 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3) || + (*__self_0_4) != (*__self_1_4) || + (*__self_0_5) != (*__self_1_5) || + (*__self_0_6) != (*__self_1_6) || + (*__self_0_7) != (*__self_1_7) || + (*__self_0_8) != (*__self_1_8) || + (*__self_0_9) != (*__self_1_9) || + (*__self_0_10) != (*__self_1_10) || + (*__self_0_11) != (*__self_1_11) || + (*__self_0_12) != (*__self_1_12) || + (*__self_0_13) != (*__self_1_13) || + (*__self_0_14) != (*__self_1_14) || + (*__self_0_15) != (*__self_1_15) || + (*__self_0_16) != (*__self_1_16) || + (*__self_0_17) != (*__self_1_17) || + (*__self_0_18) != (*__self_1_18) || + (*__self_0_19) != (*__self_1_19) || + (*__self_0_20) != (*__self_1_20) || + (*__self_0_21) != (*__self_1_21) || + (*__self_0_22) != (*__self_1_22) || + (*__self_0_23) != (*__self_1_23) || + (*__self_0_24) != (*__self_1_24), + }, + } + } + } + /// A mention of another user. + pub struct Mention { + /// URL of user's profile (can be remote). + pub url: String, + /// The username of the account. + pub username: String, + /// Equals `username` for local users, includes `@domain` for remote ones. + pub acct: String, + /// Account ID. + pub id: String, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Mention { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Mention { + url: ref __self_0_0, + username: ref __self_0_1, + acct: ref __self_0_2, + id: ref __self_0_3 } => { + let mut debug_trait_builder = + f.debug_struct("Mention"); + let _ = + debug_trait_builder.field("url", &&(*__self_0_0)); + let _ = + debug_trait_builder.field("username", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("acct", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("id", &&(*__self_0_3)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Mention { + #[inline] + fn clone(&self) -> Mention { + match *self { + Mention { + url: ref __self_0_0, + username: ref __self_0_1, + acct: ref __self_0_2, + id: ref __self_0_3 } => + Mention{url: ::core::clone::Clone::clone(&(*__self_0_0)), + username: + ::core::clone::Clone::clone(&(*__self_0_1)), + acct: ::core::clone::Clone::clone(&(*__self_0_2)), + id: ::core::clone::Clone::clone(&(*__self_0_3)),}, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Mention: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Mention { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + 2u64 => + _serde::export::Ok(__Field::__field2), + 3u64 => + _serde::export::Ok(__Field::__field3), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 4")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "url" => + _serde::export::Ok(__Field::__field0), + "username" => + _serde::export::Ok(__Field::__field1), + "acct" => + _serde::export::Ok(__Field::__field2), + "id" => + _serde::export::Ok(__Field::__field3), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"url" => + _serde::export::Ok(__Field::__field0), + b"username" => + _serde::export::Ok(__Field::__field1), + b"acct" => + _serde::export::Ok(__Field::__field2), + b"id" => + _serde::export::Ok(__Field::__field3), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = Mention; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct Mention") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct Mention with 4 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct Mention with 4 elements")); + } + }; + let __field2 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(2usize, + &"struct Mention with 4 elements")); + } + }; + let __field3 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(3usize, + &"struct Mention with 4 elements")); + } + }; + _serde::export::Ok(Mention{url: __field0, + username: __field1, + acct: __field2, + id: __field3,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option = + _serde::export::None; + let mut __field1: + _serde::export::Option = + _serde::export::None; + let mut __field2: + _serde::export::Option = + _serde::export::None; + let mut __field3: + _serde::export::Option = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("url")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("username")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("acct")); + } + __field2 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field3 => { + if _serde::export::Option::is_some(&__field3) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("id")); + } + __field3 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("url") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("username") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field2 = + match __field2 { + _serde::export::Some(__field2) => + __field2, + _serde::export::None => + match _serde::private::de::missing_field("acct") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field3 = + match __field3 { + _serde::export::Some(__field3) => + __field3, + _serde::export::None => + match _serde::private::de::missing_field("id") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(Mention{url: __field0, + username: __field1, + acct: __field2, + id: __field3,}) + } + } + const FIELDS: &'static [&'static str] = + &["url", "username", "acct", "id"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "Mention", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl ::core::marker::StructuralPartialEq for Mention { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Mention { + #[inline] + fn eq(&self, other: &Mention) -> bool { + match *other { + Mention { + url: ref __self_1_0, + username: ref __self_1_1, + acct: ref __self_1_2, + id: ref __self_1_3 } => + match *self { + Mention { + url: ref __self_0_0, + username: ref __self_0_1, + acct: ref __self_0_2, + id: ref __self_0_3 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3), + }, + } + } + #[inline] + fn ne(&self, other: &Mention) -> bool { + match *other { + Mention { + url: ref __self_1_0, + username: ref __self_1_1, + acct: ref __self_1_2, + id: ref __self_1_3 } => + match *self { + Mention { + url: ref __self_0_0, + username: ref __self_0_1, + acct: ref __self_0_2, + id: ref __self_0_3 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3), + }, + } + } + } + /// Struct representing an emoji within text. + pub struct Emoji { + /// The shortcode of the emoji + pub shortcode: String, + /// URL to the emoji static image + pub static_url: String, + /// URL to the emoji image + pub url: String, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Emoji { + #[inline] + fn clone(&self) -> Emoji { + match *self { + Emoji { + shortcode: ref __self_0_0, + static_url: ref __self_0_1, + url: ref __self_0_2 } => + Emoji{shortcode: + ::core::clone::Clone::clone(&(*__self_0_0)), + static_url: + ::core::clone::Clone::clone(&(*__self_0_1)), + url: ::core::clone::Clone::clone(&(*__self_0_2)),}, + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Emoji { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Emoji { + shortcode: ref __self_0_0, + static_url: ref __self_0_1, + url: ref __self_0_2 } => { + let mut debug_trait_builder = f.debug_struct("Emoji"); + let _ = + debug_trait_builder.field("shortcode", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("static_url", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("url", &&(*__self_0_2)); + debug_trait_builder.finish() + } + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Emoji: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Emoji { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + 2u64 => + _serde::export::Ok(__Field::__field2), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 3")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "shortcode" => + _serde::export::Ok(__Field::__field0), + "static_url" => + _serde::export::Ok(__Field::__field1), + "url" => + _serde::export::Ok(__Field::__field2), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"shortcode" => + _serde::export::Ok(__Field::__field0), + b"static_url" => + _serde::export::Ok(__Field::__field1), + b"url" => + _serde::export::Ok(__Field::__field2), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = Emoji; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct Emoji") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct Emoji with 3 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct Emoji with 3 elements")); + } + }; + let __field2 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(2usize, + &"struct Emoji with 3 elements")); + } + }; + _serde::export::Ok(Emoji{shortcode: __field0, + static_url: __field1, + url: __field2,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option = + _serde::export::None; + let mut __field1: + _serde::export::Option = + _serde::export::None; + let mut __field2: + _serde::export::Option = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("shortcode")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("static_url")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("url")); + } + __field2 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("shortcode") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("static_url") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field2 = + match __field2 { + _serde::export::Some(__field2) => + __field2, + _serde::export::None => + match _serde::private::de::missing_field("url") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(Emoji{shortcode: __field0, + static_url: __field1, + url: __field2,}) + } + } + const FIELDS: &'static [&'static str] = + &["shortcode", "static_url", "url"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "Emoji", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl ::core::marker::StructuralPartialEq for Emoji { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Emoji { + #[inline] + fn eq(&self, other: &Emoji) -> bool { + match *other { + Emoji { + shortcode: ref __self_1_0, + static_url: ref __self_1_1, + url: ref __self_1_2 } => + match *self { + Emoji { + shortcode: ref __self_0_0, + static_url: ref __self_0_1, + url: ref __self_0_2 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2), + }, + } + } + #[inline] + fn ne(&self, other: &Emoji) -> bool { + match *other { + Emoji { + shortcode: ref __self_1_0, + static_url: ref __self_1_1, + url: ref __self_1_2 } => + match *self { + Emoji { + shortcode: ref __self_0_0, + static_url: ref __self_0_1, + url: ref __self_0_2 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2), + }, + } + } + } + /// Hashtags in the status. + pub struct Tag { + /// The hashtag, not including the preceding `#`. + pub name: String, + /// The URL of the hashtag. + pub url: String, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Tag { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Tag { name: ref __self_0_0, url: ref __self_0_1 } => { + let mut debug_trait_builder = f.debug_struct("Tag"); + let _ = + debug_trait_builder.field("name", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("url", &&(*__self_0_1)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Tag { + #[inline] + fn clone(&self) -> Tag { + match *self { + Tag { name: ref __self_0_0, url: ref __self_0_1 } => + Tag{name: ::core::clone::Clone::clone(&(*__self_0_0)), + url: ::core::clone::Clone::clone(&(*__self_0_1)),}, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Tag: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Tag { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { __field0, __field1, __ignore, } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 2")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "name" => + _serde::export::Ok(__Field::__field0), + "url" => + _serde::export::Ok(__Field::__field1), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"name" => + _serde::export::Ok(__Field::__field0), + b"url" => + _serde::export::Ok(__Field::__field1), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = Tag; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct Tag") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct Tag with 2 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct Tag with 2 elements")); + } + }; + _serde::export::Ok(Tag{name: __field0, + url: __field1,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option = + _serde::export::None; + let mut __field1: + _serde::export::Option = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("name")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("url")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("name") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("url") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(Tag{name: __field0, + url: __field1,}) + } + } + const FIELDS: &'static [&'static str] = + &["name", "url"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "Tag", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl ::core::marker::StructuralPartialEq for Tag { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Tag { + #[inline] + fn eq(&self, other: &Tag) -> bool { + match *other { + Tag { name: ref __self_1_0, url: ref __self_1_1 } => + match *self { + Tag { name: ref __self_0_0, url: ref __self_0_1 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1), + }, + } + } + #[inline] + fn ne(&self, other: &Tag) -> bool { + match *other { + Tag { name: ref __self_1_0, url: ref __self_1_1 } => + match *self { + Tag { name: ref __self_0_0, url: ref __self_0_1 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1), + }, + } + } + } + /// Application details. + pub struct Application { + /// Name of the application. + pub name: String, + /// Homepage URL of the application. + pub website: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Application { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Application { + name: ref __self_0_0, website: ref __self_0_1 } => { + let mut debug_trait_builder = + f.debug_struct("Application"); + let _ = + debug_trait_builder.field("name", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("website", + &&(*__self_0_1)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Application { + #[inline] + fn clone(&self) -> Application { + match *self { + Application { + name: ref __self_0_0, website: ref __self_0_1 } => + Application{name: + ::core::clone::Clone::clone(&(*__self_0_0)), + website: + ::core::clone::Clone::clone(&(*__self_0_1)),}, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Application: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Application { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { __field0, __field1, __ignore, } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor + { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => + _serde::export::Ok(__Field::__field0), + 1u64 => + _serde::export::Ok(__Field::__field1), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 2")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "name" => + _serde::export::Ok(__Field::__field0), + "website" => + _serde::export::Ok(__Field::__field1), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"name" => + _serde::export::Ok(__Field::__field0), + b"website" => + _serde::export::Ok(__Field::__field1), + _ => { + _serde::export::Ok(__Field::__ignore) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> + { + type Value = Application; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct Application") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> + _serde::export::Result where + __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct Application with 2 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => + __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct Application with 2 elements")); + } + }; + _serde::export::Ok(Application{name: __field0, + website: + __field1,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> + _serde::export::Result where + __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option = + _serde::export::None; + let mut __field1: + _serde::export::Option> = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("name")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("website")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => + __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("name") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("website") + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(Application{name: __field0, + website: + __field1,}) + } + } + const FIELDS: &'static [&'static str] = + &["name", "website"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "Application", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl ::core::marker::StructuralPartialEq for Application { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Application { + #[inline] + fn eq(&self, other: &Application) -> bool { + match *other { + Application { + name: ref __self_1_0, website: ref __self_1_1 } => + match *self { + Application { + name: ref __self_0_0, website: ref __self_0_1 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1), + }, + } + } + #[inline] + fn ne(&self, other: &Application) -> bool { + match *other { + Application { + name: ref __self_1_0, website: ref __self_1_1 } => + match *self { + Application { + name: ref __self_0_0, website: ref __self_0_1 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1), + }, + } + } + } + } + /// An empty JSON object. + pub struct Empty { + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Empty: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Empty { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { __ignore, } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 0")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + _ => { _serde::export::Ok(__Field::__ignore) } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + _ => { _serde::export::Ok(__Field::__ignore) } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Empty; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct Empty") + } + #[inline] + fn visit_seq<__A>(self, _: __A) + -> _serde::export::Result + where __A: _serde::de::SeqAccess<'de> { + _serde::export::Ok(Empty{}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> _serde::export::Result + where __A: _serde::de::MapAccess<'de> { + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => + { + return _serde::export::Err(__err); + } + }; + } + } + } + _serde::export::Ok(Empty{}) + } + } + const FIELDS: &'static [&'static str] = &[]; + _serde::Deserializer::deserialize_struct(__deserializer, + "Empty", FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Empty { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + Empty { } => { + let mut debug_trait_builder = f.debug_struct("Empty"); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::marker::Copy for Empty { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Empty { + #[inline] + fn clone(&self) -> Empty { { *self } } + } + impl ::core::marker::StructuralPartialEq for Empty { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Empty { + #[inline] + fn eq(&self, other: &Empty) -> bool { + match *other { + Empty { } => match *self { Empty { } => true, }, + } + } + } + /// The purpose of this module is to alleviate imports of many common + /// structs by adding a glob import to the top of mastodon heavy + /// modules: + pub mod prelude { + pub use super::{account::{Account, Source}, + attachment::{Attachment, MediaType}, card::Card, + context::Context, event::Event, + filter::{Filter, FilterContext}, instance::*, + list::List, mention::Mention, + notification::Notification, push::Subscription, + relationship::Relationship, report::Report, + search_result::{SearchResult, SearchResultV2}, + status::{Application, Emoji, Status}, Empty}; + } +} +/// Errors +pub mod errors { + use std::{error, fmt, io::Error as IoError}; + use hyper_old_types::Error as HeaderParseError; + use reqwest::{header::ToStrError as HeaderStrError, Error as HttpError, + StatusCode}; + use serde_json::Error as SerdeError; + use serde_qs::Error as SerdeQsError; + use serde_urlencoded::ser::Error as UrlEncodedError; + use url::ParseError as UrlError; + use tungstenite::error::Error as WebSocketError; + /// Convience type over `std::result::Result` with `Error` as the error type. + pub type Result = ::std::result::Result; + /// enum of possible errors encountered using the mastodon API. + pub enum Error { + + /// Error from the Mastodon API. This typically means something went + /// wrong with your authentication or data. + Api(ApiError), + + /// Error deserialising to json. Typically represents a breaking change in + /// the Mastodon API + Serde(SerdeError), + + /// Error serializing to url-encoded string + UrlEncoded(UrlEncodedError), + + /// Error encountered in the HTTP backend while requesting a route. + Http(HttpError), + + /// Wrapper around the `std::io::Error` struct. + Io(IoError), + + /// Wrapper around the `url::ParseError` struct. + Url(UrlError), + + /// Missing Client Id. + ClientIdRequired, + + /// Missing Client Secret. + ClientSecretRequired, + + /// Missing Access Token. + AccessTokenRequired, + + /// Generic client error. + Client(StatusCode), + + /// Generic server error. + Server(StatusCode), + + /// MastodonBuilder & AppBuilder error + MissingField(&'static str), + + /// Error converting an http header to a string + HeaderStrError(HeaderStrError), + + /// Error parsing the http Link header + HeaderParseError(HeaderParseError), + + /// Error serializing to a query string + SerdeQs(SerdeQsError), + + /// WebSocket error + WebSocket(WebSocketError), + + /// Other errors + Other(String), + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Error { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match (&*self,) { + (&Error::Api(ref __self_0),) => { + let mut debug_trait_builder = f.debug_tuple("Api"); + let _ = debug_trait_builder.field(&&(*__self_0)); + debug_trait_builder.finish() + } + (&Error::Serde(ref __self_0),) => { + let mut debug_trait_builder = f.debug_tuple("Serde"); + let _ = debug_trait_builder.field(&&(*__self_0)); + debug_trait_builder.finish() + } + (&Error::UrlEncoded(ref __self_0),) => { + let mut debug_trait_builder = f.debug_tuple("UrlEncoded"); + let _ = debug_trait_builder.field(&&(*__self_0)); + debug_trait_builder.finish() + } + (&Error::Http(ref __self_0),) => { + let mut debug_trait_builder = f.debug_tuple("Http"); + let _ = debug_trait_builder.field(&&(*__self_0)); + debug_trait_builder.finish() + } + (&Error::Io(ref __self_0),) => { + let mut debug_trait_builder = f.debug_tuple("Io"); + let _ = debug_trait_builder.field(&&(*__self_0)); + debug_trait_builder.finish() + } + (&Error::Url(ref __self_0),) => { + let mut debug_trait_builder = f.debug_tuple("Url"); + let _ = debug_trait_builder.field(&&(*__self_0)); + debug_trait_builder.finish() + } + (&Error::ClientIdRequired,) => { + let mut debug_trait_builder = + f.debug_tuple("ClientIdRequired"); + debug_trait_builder.finish() + } + (&Error::ClientSecretRequired,) => { + let mut debug_trait_builder = + f.debug_tuple("ClientSecretRequired"); + debug_trait_builder.finish() + } + (&Error::AccessTokenRequired,) => { + let mut debug_trait_builder = + f.debug_tuple("AccessTokenRequired"); + debug_trait_builder.finish() + } + (&Error::Client(ref __self_0),) => { + let mut debug_trait_builder = f.debug_tuple("Client"); + let _ = debug_trait_builder.field(&&(*__self_0)); + debug_trait_builder.finish() + } + (&Error::Server(ref __self_0),) => { + let mut debug_trait_builder = f.debug_tuple("Server"); + let _ = debug_trait_builder.field(&&(*__self_0)); + debug_trait_builder.finish() + } + (&Error::MissingField(ref __self_0),) => { + let mut debug_trait_builder = + f.debug_tuple("MissingField"); + let _ = debug_trait_builder.field(&&(*__self_0)); + debug_trait_builder.finish() + } + (&Error::HeaderStrError(ref __self_0),) => { + let mut debug_trait_builder = + f.debug_tuple("HeaderStrError"); + let _ = debug_trait_builder.field(&&(*__self_0)); + debug_trait_builder.finish() + } + (&Error::HeaderParseError(ref __self_0),) => { + let mut debug_trait_builder = + f.debug_tuple("HeaderParseError"); + let _ = debug_trait_builder.field(&&(*__self_0)); + debug_trait_builder.finish() + } + (&Error::SerdeQs(ref __self_0),) => { + let mut debug_trait_builder = f.debug_tuple("SerdeQs"); + let _ = debug_trait_builder.field(&&(*__self_0)); + debug_trait_builder.finish() + } + (&Error::WebSocket(ref __self_0),) => { + let mut debug_trait_builder = f.debug_tuple("WebSocket"); + let _ = debug_trait_builder.field(&&(*__self_0)); + debug_trait_builder.finish() + } + (&Error::Other(ref __self_0),) => { + let mut debug_trait_builder = f.debug_tuple("Other"); + let _ = debug_trait_builder.field(&&(*__self_0)); + debug_trait_builder.finish() + } + } + } + } + impl fmt::Display for Error { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_fmt(::core::fmt::Arguments::new_v1(&[""], + &match (&self,) { + (arg0,) => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Debug::fmt)], + })) + } + } + impl error::Error for Error { + fn source(&self) -> Option<&(dyn error::Error + 'static)> { + Some(match *self { + Error::Api(ref e) => e, + Error::Serde(ref e) => e, + Error::UrlEncoded(ref e) => e, + Error::Http(ref e) => e, + Error::Io(ref e) => e, + Error::Url(ref e) => e, + Error::HeaderStrError(ref e) => e, + Error::HeaderParseError(ref e) => e, + Error::SerdeQs(ref e) => e, + Error::WebSocket(ref e) => e, + Error::Client(..) | Error::Server(..) => { return None } + Error::ClientIdRequired => return None, + Error::ClientSecretRequired => return None, + Error::AccessTokenRequired => return None, + Error::MissingField(_) => return None, + Error::Other(..) => return None, + }) + } + } + /// Error returned from the Mastodon API. + pub struct ApiError { + /// The type of error. + pub error: Option, + /// The description of the error. + pub error_description: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for ApiError { + #[inline] + fn clone(&self) -> ApiError { + match *self { + ApiError { + error: ref __self_0_0, error_description: ref __self_0_1 } => + ApiError{error: ::core::clone::Clone::clone(&(*__self_0_0)), + error_description: + ::core::clone::Clone::clone(&(*__self_0_1)),}, + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for ApiError { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + ApiError { + error: ref __self_0_0, error_description: ref __self_0_1 } => + { + let mut debug_trait_builder = f.debug_struct("ApiError"); + let _ = + debug_trait_builder.field("error", &&(*__self_0_0)); + let _ = + debug_trait_builder.field("error_description", + &&(*__self_0_1)); + debug_trait_builder.finish() + } + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_ApiError: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for ApiError { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { __field0, __field1, __ignore, } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => _serde::export::Ok(__Field::__field0), + 1u64 => _serde::export::Ok(__Field::__field1), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 2")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "error" => + _serde::export::Ok(__Field::__field0), + "error_description" => + _serde::export::Ok(__Field::__field1), + _ => { _serde::export::Ok(__Field::__ignore) } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"error" => + _serde::export::Ok(__Field::__field0), + b"error_description" => + _serde::export::Ok(__Field::__field1), + _ => { _serde::export::Ok(__Field::__ignore) } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = ApiError; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct ApiError") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> _serde::export::Result + where __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct ApiError with 2 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::>(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct ApiError with 2 elements")); + } + }; + _serde::export::Ok(ApiError{error: __field0, + error_description: + __field1,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> _serde::export::Result + where __A: _serde::de::MapAccess<'de> { + let mut __field0: + _serde::export::Option> = + _serde::export::None; + let mut __field1: + _serde::export::Option> = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("error")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("error_description")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::>(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => + { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("error") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("error_description") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(ApiError{error: __field0, + error_description: + __field1,}) + } + } + const FIELDS: &'static [&'static str] = + &["error", "error_description"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "ApiError", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl fmt::Display for ApiError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_fmt(::core::fmt::Arguments::new_v1(&[""], + &match (&self,) { + (arg0,) => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Debug::fmt)], + })) + } + } + impl error::Error for ApiError { } + macro_rules! from { + ($ ($ (# [$ met : meta]) * $ typ : ident, $ variant : ident,) *) => + { + $ + ($ (# [$ met]) * impl From < $ typ > for Error + { + fn from(from : $ typ) -> Self + { use crate :: Error :: * ; $ variant(from) } + }) * + } + } + impl From for Error { + fn from(from: HttpError) -> Self { + use crate::Error::*; + Http(from) + } + } + impl From for Error { + fn from(from: IoError) -> Self { + use crate::Error::*; + Io(from) + } + } + impl From for Error { + fn from(from: SerdeError) -> Self { + use crate::Error::*; + Serde(from) + } + } + impl From for Error { + fn from(from: UrlEncodedError) -> Self { + use crate::Error::*; + UrlEncoded(from) + } + } + impl From for Error { + fn from(from: UrlError) -> Self { + use crate::Error::*; + Url(from) + } + } + impl From for Error { + fn from(from: ApiError) -> Self { + use crate::Error::*; + Api(from) + } + } + impl From for Error { + fn from(from: HeaderStrError) -> Self { + use crate::Error::*; + HeaderStrError(from) + } + } + impl From for Error { + fn from(from: HeaderParseError) -> Self { + use crate::Error::*; + HeaderParseError(from) + } + } + impl From for Error { + fn from(from: SerdeQsError) -> Self { + use crate::Error::*; + SerdeQs(from) + } + } + impl From for Error { + fn from(from: WebSocketError) -> Self { + use crate::Error::*; + WebSocket(from) + } + } + impl From for Error { + fn from(from: String) -> Self { + use crate::Error::*; + Other(from) + } + } + #[macro_export] + /// Used to easily create errors from strings + macro_rules! format_err { + ($ ($ arg : tt) *) => + { { use elefren :: Error ; Error :: Other(format ! ($ ($ arg) *)) } } + } +} +/// Collection of helpers for serializing/deserializing `Data` objects +pub mod helpers { + /// Helpers for working with the command line + pub mod cli { + use std::io::{self, BufRead, Write}; + use crate::errors::Result; + use crate::registration::Registered; + use crate::Mastodon; + /// Finishes the authentication process for the given `Registered` object, + /// using the command-line + pub fn authenticate(registration: Registered) -> Result { + let url = registration.authorize_url()?; + let stdout = io::stdout(); + let stdin = io::stdin(); + let mut stdout = stdout.lock(); + let mut stdin = stdin.lock(); + (&mut stdout).write_fmt(::core::fmt::Arguments::new_v1(&["Click this link to authorize: ", + "\n"], + &match (&url,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + }))?; + (&mut stdout).write_fmt(::core::fmt::Arguments::new_v1(&["Paste the returned authorization code: "], + &match () { + () => + [], + }))?; + stdout.flush()?; + let mut input = String::new(); + stdin.read_line(&mut input)?; + let code = input.trim(); + Ok(registration.complete(code)?) + } + } +} +mod mastodon_client { + use async_trait::async_trait; + use std::borrow::Cow; + use crate::entities::prelude::*; + use crate::errors::Result; + use crate::page::Page; + use crate::requests::{AddFilterRequest, AddPushRequest, StatusesRequest, + UpdateCredsRequest, UpdatePushRequest}; + use crate::status_builder::NewStatus; + #[doc = + " Represents the set of methods that a Mastodon Client can do, so that"] + #[doc = " implementations might be swapped out for testing"] + #[allow(unused)] + pub trait MastodonClient { + #[doc = " GET /api/v1/favourites"] + #[must_use] + fn favourites<'life0, 'async_trait>(&'life0 self) + -> + ::core::pin::Pin>> + + ::core::marker::Send + 'async_trait>> where + 'life0: 'async_trait, Self: ::core::marker::Sync + 'async_trait { + #[allow(clippy :: missing_docs_in_private_items, clippy :: + type_repetition_in_bounds, clippy :: + used_underscore_binding,)] + async fn __favourites(_self: &AsyncTrait) + -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + Box::pin(__favourites::(self)) + } + #[doc = " GET /api/v1/blocks"] + #[must_use] + fn blocks<'life0, 'async_trait>(&'life0 self) + -> + ::core::pin::Pin>> + + ::core::marker::Send + 'async_trait>> where + 'life0: 'async_trait, Self: ::core::marker::Sync + 'async_trait { + #[allow(clippy :: missing_docs_in_private_items, clippy :: + type_repetition_in_bounds, clippy :: + used_underscore_binding,)] + async fn __blocks(_self: &AsyncTrait) + -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + Box::pin(__blocks::(self)) + } + #[doc = " GET /api/v1/domain_blocks"] + #[must_use] + fn domain_blocks<'life0, 'async_trait>(&'life0 self) + -> + ::core::pin::Pin>> + + ::core::marker::Send + 'async_trait>> where + 'life0: 'async_trait, Self: ::core::marker::Sync + 'async_trait { + #[allow(clippy :: missing_docs_in_private_items, clippy :: + type_repetition_in_bounds, clippy :: + used_underscore_binding,)] + async fn __domain_blocks(_self: &AsyncTrait) + -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + Box::pin(__domain_blocks::(self)) + } + #[doc = " GET /api/v1/follow_requests"] + #[must_use] + fn follow_requests<'life0, 'async_trait>(&'life0 self) + -> + ::core::pin::Pin>> + + ::core::marker::Send + 'async_trait>> where + 'life0: 'async_trait, Self: ::core::marker::Sync + 'async_trait { + #[allow(clippy :: missing_docs_in_private_items, clippy :: + type_repetition_in_bounds, clippy :: + used_underscore_binding,)] + async fn __follow_requests(_self: + &AsyncTrait) + -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + Box::pin(__follow_requests::(self)) + } + #[doc = " GET /api/v1/timelines/home"] + #[must_use] + fn get_home_timeline<'life0, 'async_trait>(&'life0 self) + -> + ::core::pin::Pin>> + + ::core::marker::Send + 'async_trait>> where + 'life0: 'async_trait, Self: ::core::marker::Sync + 'async_trait { + #[allow(clippy :: missing_docs_in_private_items, clippy :: + type_repetition_in_bounds, clippy :: + used_underscore_binding,)] + async fn __get_home_timeline(_self: + &AsyncTrait) + -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + Box::pin(__get_home_timeline::(self)) + } + #[doc = " GET /api/v1/custom_emojis"] + #[must_use] + fn get_emojis<'life0, 'async_trait>(&'life0 self) + -> + ::core::pin::Pin>> + + ::core::marker::Send + 'async_trait>> where + 'life0: 'async_trait, Self: ::core::marker::Sync + 'async_trait { + #[allow(clippy :: missing_docs_in_private_items, clippy :: + type_repetition_in_bounds, clippy :: + used_underscore_binding,)] + async fn __get_emojis(_self: &AsyncTrait) + -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + Box::pin(__get_emojis::(self)) + } + #[doc = " GET /api/v1/mutes"] + #[must_use] + fn mutes<'life0, 'async_trait>(&'life0 self) + -> + ::core::pin::Pin>> + + ::core::marker::Send + 'async_trait>> where + 'life0: 'async_trait, Self: ::core::marker::Sync + 'async_trait { + #[allow(clippy :: missing_docs_in_private_items, clippy :: + type_repetition_in_bounds, clippy :: + used_underscore_binding,)] + async fn __mutes(_self: &AsyncTrait) + -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + Box::pin(__mutes::(self)) + } + #[doc = " GET /api/v1/notifications"] + #[must_use] + fn notifications<'life0, 'async_trait>(&'life0 self) + -> + ::core::pin::Pin>> + + ::core::marker::Send + 'async_trait>> where + 'life0: 'async_trait, Self: ::core::marker::Sync + 'async_trait { + #[allow(clippy :: missing_docs_in_private_items, clippy :: + type_repetition_in_bounds, clippy :: + used_underscore_binding,)] + async fn __notifications(_self: &AsyncTrait) + -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + Box::pin(__notifications::(self)) + } + #[doc = " GET /api/v1/reports"] + #[must_use] + fn reports<'life0, 'async_trait>(&'life0 self) + -> + ::core::pin::Pin>> + + ::core::marker::Send + 'async_trait>> where + 'life0: 'async_trait, Self: ::core::marker::Sync + 'async_trait { + #[allow(clippy :: missing_docs_in_private_items, clippy :: + type_repetition_in_bounds, clippy :: + used_underscore_binding,)] + async fn __reports(_self: &AsyncTrait) + -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + Box::pin(__reports::(self)) + } + #[doc = " GET /api/v1/accounts/:id/followers"] + fn followers(&self, id: &str) -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/accounts/:id/following"] + fn following(&self, id: &str) -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/statuses/:id/reblogged_by"] + fn reblogged_by(&self, id: &str) -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/statuses/:id/favourited_by"] + fn favourited_by(&self, id: &str) -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " DELETE /api/v1/domain_blocks"] + fn unblock_domain(&self, domain: String) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/instance"] + fn instance(&self) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/accounts/verify_credentials"] + fn verify_credentials(&self) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " POST /api/v1/reports"] + fn report(&self, account_id: &str, status_ids: Vec<&str>, + comment: String) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " POST /api/v1/domain_blocks"] + fn block_domain(&self, domain: String) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " POST /api/v1/accounts/follow_requests/authorize"] + fn authorize_follow_request(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " POST /api/v1/accounts/follow_requests/reject"] + fn reject_follow_request(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/search"] + fn search<'a>(&self, q: &'a str, resolve: bool) + -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v2/search"] + fn search_v2<'a>(&self, q: &'a str, resolve: bool) + -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " POST /api/v1/follows"] + fn follows(&self, uri: Cow<'static, str>) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " POST /api/v1/media"] + fn media(&self, file: Cow<'static, str>) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " POST /api/v1/notifications/clear"] + fn clear_notifications(&self) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " POST /api/v1/notifications/dismiss"] + fn dismiss_notification(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/accounts/:id"] + fn get_account(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " POST /api/v1/accounts/:id/follow"] + fn follow(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " POST /api/v1/accounts/:id/unfollow"] + fn unfollow(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/accounts/:id/block"] + fn block(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/accounts/:id/unblock"] + fn unblock(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/accounts/:id/mute"] + fn mute(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/accounts/:id/unmute"] + fn unmute(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/notifications/:id"] + fn get_notification(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/statuses/:id"] + fn get_status(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/statuses/:id/context"] + fn get_context(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/statuses/:id/card"] + fn get_card(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " POST /api/v1/statuses/:id/reblog"] + fn reblog(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " POST /api/v1/statuses/:id/unreblog"] + fn unreblog(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " POST /api/v1/statuses/:id/favourite"] + fn favourite(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " POST /api/v1/statuses/:id/unfavourite"] + fn unfavourite(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " DELETE /api/v1/statuses/:id"] + fn delete_status(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " PATCH /api/v1/accounts/update_credentials"] + fn update_credentials(&self, builder: &mut UpdateCredsRequest) + -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " POST /api/v1/statuses"] + fn new_status(&self, status: NewStatus) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/timelines/public"] + fn get_public_timeline(&self, local: bool) -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/timelines/tag/:hashtag"] + fn get_tagged_timeline(&self, hashtag: String, local: bool) + -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/accounts/:id/statuses"] + fn statuses<'a, 'b: 'a, S>(&'b self, id: &'b str, request: S) + -> Result> where S: Into>> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/accounts/relationships"] + fn relationships(&self, ids: &[&str]) -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = + " GET /api/v1/accounts/search?q=:query&limit=:limit&following=:following"] + #[must_use] + fn search_accounts<'life0, 'life1, + 'async_trait>(&'life0 self, query: &'life1 str, + limit: Option, following: bool) + -> + ::core::pin::Pin>> + + ::core::marker::Send + 'async_trait>> where + 'life0: 'async_trait, 'life1: 'async_trait, + Self: ::core::marker::Sync + 'async_trait { + #[allow(clippy :: missing_docs_in_private_items, clippy :: + type_repetition_in_bounds, clippy :: + used_underscore_binding,)] + async fn __search_accounts(_self: + &AsyncTrait, + query: &str, + limit: + Option, + following: bool) + -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + Box::pin(__search_accounts::(self, query, limit, following)) + } + #[doc = " POST /api/v1/push/subscription"] + fn add_push_subscription(&self, request: &AddPushRequest) + -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " PUT /api/v1/push/subscription"] + fn update_push_data(&self, request: &UpdatePushRequest) + -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/push/subscription"] + fn get_push_subscription(&self) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " DELETE /api/v1/push/subscription"] + fn delete_push_subscription(&self) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/filters"] + fn get_filters(&self) -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " POST /api/v1/filters"] + fn add_filter(&self, request: &mut AddFilterRequest) + -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/filters/:id"] + fn get_filter(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " PUT /api/v1/filters/:id"] + fn update_filter(&self, id: &str, request: &mut AddFilterRequest) + -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " DELETE /api/v1/filters/:id"] + fn delete_filter(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/suggestions"] + fn get_follow_suggestions(&self) -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " DELETE /api/v1/suggestions/:account_id"] + fn delete_from_suggestions(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " GET /api/v1/endorsements"] + #[must_use] + fn get_endorsements<'life0, 'async_trait>(&'life0 self) + -> + ::core::pin::Pin>> + + ::core::marker::Send + 'async_trait>> where + 'life0: 'async_trait, Self: ::core::marker::Sync + 'async_trait { + #[allow(clippy :: missing_docs_in_private_items, clippy :: + type_repetition_in_bounds, clippy :: + used_underscore_binding,)] + async fn __get_endorsements(_self: + &AsyncTrait) + -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + Box::pin(__get_endorsements::(self)) + } + #[doc = " POST /api/v1/accounts/:id/pin"] + fn endorse_user(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " POST /api/v1/accounts/:id/unpin"] + fn unendorse_user(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = + " Shortcut for: `let me = client.verify_credentials(); client.followers()`"] + #[doc = ""] + #[doc = " ```no_run"] + #[doc = " # extern crate elefren;"] + #[doc = " # use std::error::Error;"] + #[doc = " # use elefren::prelude::*;"] + #[doc = " # fn main() -> Result<(), Box> {"] + #[doc = " # let data = Data {"] + #[doc = " # base: \"\".into(),"] + #[doc = " # client_id: \"\".into(),"] + #[doc = " # client_secret: \"\".into(),"] + #[doc = " # redirect: \"\".into(),"] + #[doc = " # token: \"\".into(),"] + #[doc = " # };"] + #[doc = " # let client = Mastodon::from(data);"] + #[doc = " let follows_me = client.follows_me()?;"] + #[doc = " # Ok(())"] + #[doc = " # }"] + fn follows_me(&self) -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + #[doc = " Shortcut for"] + #[doc = + " `let me = client.verify_credentials(); client.following(&me.id)`"] + #[doc = ""] + #[doc = " ```no_run"] + #[doc = " # extern crate elefren;"] + #[doc = " # use std::error::Error;"] + #[doc = " # use elefren::prelude::*;"] + #[doc = " # fn main() -> Result<(), Box> {"] + #[doc = " # let data = Data {"] + #[doc = " # base: \"\".into(),"] + #[doc = " # client_id: \"\".into(),"] + #[doc = " # client_secret: \"\".into(),"] + #[doc = " # redirect: \"\".into(),"] + #[doc = " # token: \"\".into(),"] + #[doc = " # };"] + #[doc = " # let client = Mastodon::from(data);"] + #[doc = " let follows_me = client.followed_by_me()?;"] + #[doc = " # Ok(())"] + #[doc = " # }"] + fn followed_by_me(&self) -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + } + /// Trait that represents clients that can make unauthenticated calls to a + /// mastodon instance + #[allow(unused)] + pub trait MastodonUnauthenticated { + /// GET /api/v1/statuses/:id + fn get_status(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + /// GET /api/v1/statuses/:id/context + fn get_context(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + /// GET /api/v1/statuses/:id/card + fn get_card(&self, id: &str) -> Result { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + /// GET /api/v1/statuses/:id/reblogged_by + fn reblogged_by(&self, id: &str) -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + /// GET /api/v1/statuses/:id/favourited_by + fn favourited_by(&self, id: &str) -> Result> { + { + ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(&["not implemented: "], + &match (&::core::fmt::Arguments::new_v1(&["This method was not implemented"], + &match () + { + () + => + [], + }),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + }; + } + } +} +/// Handling multiple pages of entities. +pub mod page { + use super::{deserialise, Mastodon, Result}; + use hyper_old_types::header::{parsing, Link, RelationType}; + use reqwest::{header::LINK, Response}; + use serde::Deserialize; + use url::Url; + macro_rules! pages { + ($ ($ direction : ident : $ fun : ident), *) => + { + $ + (doc_comment ! + (concat ! + ("Method to retrieve the ", stringify ! ($ direction), + " page of results"), pub async fn $ fun(& mut self) -> Result < + Option < Vec < T >> > + { + let url = match self . $ direction . take() + { Some(s) => s, None => return Ok(None), } ; let response = + self . mastodon . send(self . mastodon . client . get(url)) + ? ; let(prev, next) = get_links(& response) ? ; self . next + = next ; self . prev = prev ; deserialise(response) + }) ;) * + } + } + /// Owned version of the `Page` struct in this module. Allows this to be more + /// easily stored for later use + /// + /// # Example + /// + /// ```no_run + /// # extern crate elefren; + /// # use elefren::Mastodon; + /// # use elefren::page::OwnedPage; + /// # use elefren::entities::status::Status; + /// # use std::cell::RefCell; + /// # use elefren::prelude::*; + /// # fn main() -> Result<(), elefren::Error> { + /// # let data = Data { + /// # base: "".into(), + /// # client_id: "".into(), + /// # client_secret: "".into(), + /// # redirect: "".into(), + /// # token: "".into(), + /// # }; + /// struct HomeTimeline { + /// client: Mastodon, + /// page: RefCell>>, + /// } + /// let client = Mastodon::from(data); + /// let home = client.get_home_timeline()?.to_owned(); + /// let tl = HomeTimeline { + /// client, + /// page: RefCell::new(Some(home)), + /// }; + /// # Ok(()) + /// # } + /// ``` + pub struct OwnedPage Deserialize<'de>> { + mastodon: Mastodon, + next: Option, + prev: Option, + /// Initial set of items + pub initial_items: Vec, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl Deserialize<'de>> + ::core::fmt::Debug for OwnedPage { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + OwnedPage { + mastodon: ref __self_0_0, + next: ref __self_0_1, + prev: ref __self_0_2, + initial_items: ref __self_0_3 } => { + let mut debug_trait_builder = f.debug_struct("OwnedPage"); + let _ = + debug_trait_builder.field("mastodon", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("next", &&(*__self_0_1)); + let _ = + debug_trait_builder.field("prev", &&(*__self_0_2)); + let _ = + debug_trait_builder.field("initial_items", + &&(*__self_0_3)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl Deserialize<'de>> + ::core::clone::Clone for OwnedPage { + #[inline] + fn clone(&self) -> OwnedPage { + match *self { + OwnedPage { + mastodon: ref __self_0_0, + next: ref __self_0_1, + prev: ref __self_0_2, + initial_items: ref __self_0_3 } => + OwnedPage{mastodon: + ::core::clone::Clone::clone(&(*__self_0_0)), + next: ::core::clone::Clone::clone(&(*__self_0_1)), + prev: ::core::clone::Clone::clone(&(*__self_0_2)), + initial_items: + ::core::clone::Clone::clone(&(*__self_0_3)),}, + } + } + } + impl Deserialize<'de>> OwnedPage { + #[doc = "Method to retrieve the next page of results"] + pub async fn next_page(&mut self) -> Result>> { + let url = + match self.next.take() { + Some(s) => s, + None => return Ok(None), + }; + let response = self.mastodon.send(self.mastodon.client.get(url))?; + let (prev, next) = get_links(&response)?; + self.next = next; + self.prev = prev; + deserialise(response) + } + #[doc = "Method to retrieve the prev page of results"] + pub async fn prev_page(&mut self) -> Result>> { + let url = + match self.prev.take() { + Some(s) => s, + None => return Ok(None), + }; + let response = self.mastodon.send(self.mastodon.client.get(url))?; + let (prev, next) = get_links(&response)?; + self.next = next; + self.prev = prev; + deserialise(response) + } + } + impl <'a, T: for<'de> Deserialize<'de>> From> for OwnedPage + { + fn from(page: Page<'a, T>) -> OwnedPage { + OwnedPage{mastodon: page.mastodon.clone(), + next: page.next, + prev: page.prev, + initial_items: page.initial_items,} + } + } + /// Represents a single page of API results + pub struct Page<'a, T: for<'de> Deserialize<'de>> { + mastodon: &'a Mastodon, + next: Option, + prev: Option, + /// Initial set of items + pub initial_items: Vec, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl <'a, T: ::core::fmt::Debug + for<'de> Deserialize<'de>> + ::core::fmt::Debug for Page<'a, T> { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + Page { + mastodon: ref __self_0_0, + next: ref __self_0_1, + prev: ref __self_0_2, + initial_items: ref __self_0_3 } => { + let mut debug_trait_builder = f.debug_struct("Page"); + let _ = + debug_trait_builder.field("mastodon", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("next", &&(*__self_0_1)); + let _ = + debug_trait_builder.field("prev", &&(*__self_0_2)); + let _ = + debug_trait_builder.field("initial_items", + &&(*__self_0_3)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl <'a, T: ::core::clone::Clone + for<'de> Deserialize<'de>> + ::core::clone::Clone for Page<'a, T> { + #[inline] + fn clone(&self) -> Page<'a, T> { + match *self { + Page { + mastodon: ref __self_0_0, + next: ref __self_0_1, + prev: ref __self_0_2, + initial_items: ref __self_0_3 } => + Page{mastodon: ::core::clone::Clone::clone(&(*__self_0_0)), + next: ::core::clone::Clone::clone(&(*__self_0_1)), + prev: ::core::clone::Clone::clone(&(*__self_0_2)), + initial_items: + ::core::clone::Clone::clone(&(*__self_0_3)),}, + } + } + } + impl <'a, T: for<'de> Deserialize<'de>> Page<'a, T> { + #[doc = "Method to retrieve the next page of results"] + pub async fn next_page(&mut self) -> Result>> { + let url = + match self.next.take() { + Some(s) => s, + None => return Ok(None), + }; + let response = self.mastodon.send(self.mastodon.client.get(url))?; + let (prev, next) = get_links(&response)?; + self.next = next; + self.prev = prev; + deserialise(response) + } + #[doc = "Method to retrieve the prev page of results"] + pub async fn prev_page(&mut self) -> Result>> { + let url = + match self.prev.take() { + Some(s) => s, + None => return Ok(None), + }; + let response = self.mastodon.send(self.mastodon.client.get(url))?; + let (prev, next) = get_links(&response)?; + self.next = next; + self.prev = prev; + deserialise(response) + } + pub(crate) fn new(mastodon: &'a Mastodon, response: Response) + -> Result { + let (prev, next) = get_links(&response)?; + Ok(Page{initial_items: deserialise(response)?, + next, + prev, + mastodon,}) + } + } + impl <'a, T: Clone + for<'de> Deserialize<'de>> Page<'a, T> { + /// Returns an owned version of this struct that doesn't borrow the client + /// that created it + /// + /// # Example + /// + /// ```no_run + /// # extern crate elefren; + /// # use elefren::Mastodon; + /// # use elefren::page::OwnedPage; + /// # use elefren::entities::status::Status; + /// # use std::cell::RefCell; + /// # use elefren::prelude::*; + /// # fn main() -> Result<(), elefren::Error> { + /// # let data = Data { + /// # base: "".into(), + /// # client_id: "".into(), + /// # client_secret: "".into(), + /// # redirect: "".into(), + /// # token: "".into(), + /// # }; + /// struct HomeTimeline { + /// client: Mastodon, + /// page: RefCell>>, + /// } + /// let client = Mastodon::from(data); + /// let home = client.get_home_timeline()?.to_owned(); + /// let tl = HomeTimeline { + /// client, + /// page: RefCell::new(Some(home)), + /// }; + /// # Ok(()) + /// # } + /// ``` + pub fn to_owned(self) -> OwnedPage { OwnedPage::from(self) } + } + fn get_links(response: &Response) -> Result<(Option, Option)> { + let mut prev = None; + let mut next = None; + if let Some(link_header) = response.headers().get(LINK) { + let link_header = link_header.to_str()?; + let link_header = link_header.as_bytes(); + let link_header: Link = parsing::from_raw_str(&link_header)?; + for value in link_header.values() { + if let Some(relations) = value.rel() { + if relations.contains(&RelationType::Next) { + next = Some(Url::parse(value.link())?); + } + if relations.contains(&RelationType::Prev) { + prev = Some(Url::parse(value.link())?); + } + } + } + } + Ok((prev, next)) + } +} +/// Registering your app. +pub mod registration { + use std::borrow::Cow; + use reqwest::{Client, RequestBuilder, Response}; + use try_from::TryInto; + use url::percent_encoding::{utf8_percent_encode, DEFAULT_ENCODE_SET}; + use crate::apps::{App, AppBuilder}; + use crate::scopes::Scopes; + use crate::Data; + use crate::Error; + use crate::Mastodon; + use crate::MastodonBuilder; + use crate::Result; + const DEFAULT_REDIRECT_URI: &'static str = "urn:ietf:wg:oauth:2.0:oob"; + /// Handles registering your mastodon app to your instance. It is recommended + /// you cache your data struct to avoid registering on every run. + pub struct Registration<'a> { + base: String, + client: Client, + app_builder: AppBuilder<'a>, + force_login: bool, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl <'a> ::core::fmt::Debug for Registration<'a> { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + Registration { + base: ref __self_0_0, + client: ref __self_0_1, + app_builder: ref __self_0_2, + force_login: ref __self_0_3 } => { + let mut debug_trait_builder = + f.debug_struct("Registration"); + let _ = + debug_trait_builder.field("base", &&(*__self_0_0)); + let _ = + debug_trait_builder.field("client", &&(*__self_0_1)); + let _ = + debug_trait_builder.field("app_builder", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("force_login", + &&(*__self_0_3)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl <'a> ::core::clone::Clone for Registration<'a> { + #[inline] + fn clone(&self) -> Registration<'a> { + match *self { + Registration { + base: ref __self_0_0, + client: ref __self_0_1, + app_builder: ref __self_0_2, + force_login: ref __self_0_3 } => + Registration{base: + ::core::clone::Clone::clone(&(*__self_0_0)), + client: + ::core::clone::Clone::clone(&(*__self_0_1)), + app_builder: + ::core::clone::Clone::clone(&(*__self_0_2)), + force_login: + ::core::clone::Clone::clone(&(*__self_0_3)),}, + } + } + } + struct OAuth { + client_id: String, + client_secret: String, + #[serde(default = "default_redirect_uri")] + redirect_uri: String, + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_OAuth: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for OAuth { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { __field0, __field1, __field2, __ignore, } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => _serde::export::Ok(__Field::__field0), + 1u64 => _serde::export::Ok(__Field::__field1), + 2u64 => _serde::export::Ok(__Field::__field2), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 3")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "client_id" => + _serde::export::Ok(__Field::__field0), + "client_secret" => + _serde::export::Ok(__Field::__field1), + "redirect_uri" => + _serde::export::Ok(__Field::__field2), + _ => { _serde::export::Ok(__Field::__ignore) } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"client_id" => + _serde::export::Ok(__Field::__field0), + b"client_secret" => + _serde::export::Ok(__Field::__field1), + b"redirect_uri" => + _serde::export::Ok(__Field::__field2), + _ => { _serde::export::Ok(__Field::__ignore) } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = OAuth; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct OAuth") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> _serde::export::Result + where __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct OAuth with 3 elements")); + } + }; + let __field1 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(1usize, + &"struct OAuth with 3 elements")); + } + }; + let __field2 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + default_redirect_uri() + } + }; + _serde::export::Ok(OAuth{client_id: __field0, + client_secret: __field1, + redirect_uri: __field2,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> _serde::export::Result + where __A: _serde::de::MapAccess<'de> { + let mut __field0: _serde::export::Option = + _serde::export::None; + let mut __field1: _serde::export::Option = + _serde::export::None; + let mut __field2: _serde::export::Option = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("client_id")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("client_secret")); + } + __field1 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("redirect_uri")); + } + __field2 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => + { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("client_id") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = + match __field1 { + _serde::export::Some(__field1) => + __field1, + _serde::export::None => + match _serde::private::de::missing_field("client_secret") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field2 = + match __field2 { + _serde::export::Some(__field2) => + __field2, + _serde::export::None => + default_redirect_uri(), + }; + _serde::export::Ok(OAuth{client_id: __field0, + client_secret: __field1, + redirect_uri: __field2,}) + } + } + const FIELDS: &'static [&'static str] = + &["client_id", "client_secret", "redirect_uri"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "OAuth", FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + fn default_redirect_uri() -> String { DEFAULT_REDIRECT_URI.to_string() } + struct AccessToken { + access_token: String, + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_AccessToken: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for AccessToken { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { __field0, __ignore, } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "field identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => _serde::export::Ok(__Field::__field0), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 1")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "access_token" => + _serde::export::Ok(__Field::__field0), + _ => { _serde::export::Ok(__Field::__ignore) } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"access_token" => + _serde::export::Ok(__Field::__field0), + _ => { _serde::export::Ok(__Field::__ignore) } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = AccessToken; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "struct AccessToken") + } + #[inline] + fn visit_seq<__A>(self, mut __seq: __A) + -> _serde::export::Result + where __A: _serde::de::SeqAccess<'de> { + let __field0 = + match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length(0usize, + &"struct AccessToken with 1 element")); + } + }; + _serde::export::Ok(AccessToken{access_token: + __field0,}) + } + #[inline] + fn visit_map<__A>(self, mut __map: __A) + -> _serde::export::Result + where __A: _serde::de::MapAccess<'de> { + let mut __field0: _serde::export::Option = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) + { + return _serde::export::Err(<__A::Error + as + _serde::de::Error>::duplicate_field("access_token")); + } + __field0 = + _serde::export::Some(match _serde::de::MapAccess::next_value::(&mut __map) + { + _serde::export::Ok(__val) + => __val, + _serde::export::Err(__err) + => { + return _serde::export::Err(__err); + } + }); + } + _ => { + let _ = + match _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map) + { + _serde::export::Ok(__val) => + __val, + _serde::export::Err(__err) => + { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = + match __field0 { + _serde::export::Some(__field0) => + __field0, + _serde::export::None => + match _serde::private::de::missing_field("access_token") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(AccessToken{access_token: + __field0,}) + } + } + const FIELDS: &'static [&'static str] = &["access_token"]; + _serde::Deserializer::deserialize_struct(__deserializer, + "AccessToken", + FIELDS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + impl <'a> Registration<'a> { + /// Construct a new registration process to the instance of the `base` url. + /// ``` + /// use elefren::prelude::*; + /// + /// let registration = Registration::new("https://mastodon.social"); + /// ``` + pub fn new>(base: I) -> Self { + Registration{base: base.into(), + client: Client::new(), + app_builder: AppBuilder::new(), + force_login: false,} + } + } + impl <'a> Registration<'a> { + /// Sets the name of this app + /// + /// This is required, and if this isn't set then the AppBuilder::build + /// method will fail + pub fn client_name>>(&mut self, name: I) + -> &mut Self { + self.app_builder.client_name(name.into()); + self + } + /// Sets the redirect uris that this app uses + pub fn redirect_uris>>(&mut self, uris: I) + -> &mut Self { + self.app_builder.redirect_uris(uris); + self + } + /// Sets the scopes that this app requires + /// + /// The default for an app is Scopes::Read + pub fn scopes(&mut self, scopes: Scopes) -> &mut Self { + self.app_builder.scopes(scopes); + self + } + /// Sets the optional "website" to register the app with + pub fn website>>(&mut self, website: I) + -> &mut Self { + self.app_builder.website(website); + self + } + /// Forces the user to re-login (useful if you need to re-auth as a + /// different user on the same instance + pub fn force_login(&mut self, force_login: bool) -> &mut Self { + self.force_login = force_login; + self + } + fn send(&self, req: RequestBuilder) -> Result { + let req = req.build()?; + Ok(self.client.execute(req)?) + } + /// Register the given application + /// + /// ```no_run + /// # extern crate elefren; + /// # fn main () -> elefren::Result<()> { + /// use elefren::{apps::App, prelude::*}; + /// + /// let mut app = App::builder(); + /// app.client_name("elefren_test"); + /// + /// let registration = Registration::new("https://mastodon.social").register(app)?; + /// let url = registration.authorize_url()?; + /// // Here you now need to open the url in the browser + /// // And handle a the redirect url coming back with the code. + /// let code = String::from("RETURNED_FROM_BROWSER"); + /// let mastodon = registration.complete(&code)?; + /// + /// println!("{:?}", mastodon.get_home_timeline()?.initial_items); + /// # Ok(()) + /// # } + /// ``` + pub fn register>(&mut self, app: I) + -> Result where Error: From<>::Err> { + let app = app.try_into()?; + let oauth = self.send_app(&app)?; + Ok(Registered{base: self.base.clone(), + client: self.client.clone(), + client_id: oauth.client_id, + client_secret: oauth.client_secret, + redirect: oauth.redirect_uri, + scopes: app.scopes().clone(), + force_login: self.force_login,}) + } + /// Register the application with the server from the `base` url. + /// + /// ```no_run + /// # extern crate elefren; + /// # fn main () -> elefren::Result<()> { + /// use elefren::prelude::*; + /// + /// let registration = Registration::new("https://mastodon.social") + /// .client_name("elefren_test") + /// .build()?; + /// let url = registration.authorize_url()?; + /// // Here you now need to open the url in the browser + /// // And handle a the redirect url coming back with the code. + /// let code = String::from("RETURNED_FROM_BROWSER"); + /// let mastodon = registration.complete(&code)?; + /// + /// println!("{:?}", mastodon.get_home_timeline()?.initial_items); + /// # Ok(()) + /// # } + /// ``` + pub fn build(&mut self) -> Result { + let app: App = self.app_builder.clone().build()?; + let oauth = self.send_app(&app)?; + Ok(Registered{base: self.base.clone(), + client: self.client.clone(), + client_id: oauth.client_id, + client_secret: oauth.client_secret, + redirect: oauth.redirect_uri, + scopes: app.scopes().clone(), + force_login: self.force_login,}) + } + fn send_app(&self, app: &App) -> Result { + let url = + { + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["", + "/api/v1/apps"], + &match (&self.base,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + }; + Ok(self.send(self.client.post(&url).json(&app))?.json()?) + } + } + impl Registered { + /// Skip having to retrieve the client id and secret from the server by + /// creating a `Registered` struct directly + /// + /// # Example + /// + /// ```no_run + /// # extern crate elefren; + /// # fn main() -> elefren::Result<()> { + /// use elefren::{prelude::*, registration::Registered}; + /// + /// let registration = Registered::from_parts( + /// "https://example.com", + /// "the-client-id", + /// "the-client-secret", + /// "https://example.com/redirect", + /// Scopes::read_all(), + /// false, + /// ); + /// let url = registration.authorize_url()?; + /// // Here you now need to open the url in the browser + /// // And handle a the redirect url coming back with the code. + /// let code = String::from("RETURNED_FROM_BROWSER"); + /// let mastodon = registration.complete(&code)?; + /// + /// println!("{:?}", mastodon.get_home_timeline()?.initial_items); + /// # Ok(()) + /// # } + /// ``` + pub fn from_parts(base: &str, client_id: &str, client_secret: &str, + redirect: &str, scopes: Scopes, force_login: bool) + -> Registered { + Registered{base: base.to_string(), + client: Client::new(), + client_id: client_id.to_string(), + client_secret: client_secret.to_string(), + redirect: redirect.to_string(), + scopes, + force_login,} + } + } + impl Registered { + fn send(&self, req: RequestBuilder) -> Result { + let req = req.build()?; + Ok(self.client.execute(req)?) + } + /// Returns the parts of the `Registered` struct that can be used to + /// recreate another `Registered` struct + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// use elefren::{prelude::*, registration::Registered}; + /// # fn main() -> Result<(), Box> { + /// + /// let origbase = "https://example.social"; + /// let origclient_id = "some-client_id"; + /// let origclient_secret = "some-client-secret"; + /// let origredirect = "https://example.social/redirect"; + /// let origscopes = Scopes::all(); + /// let origforce_login = false; + /// + /// let registered = Registered::from_parts( + /// origbase, + /// origclient_id, + /// origclient_secret, + /// origredirect, + /// origscopes.clone(), + /// origforce_login, + /// ); + /// + /// let (base, client_id, client_secret, redirect, scopes, force_login) = registered.into_parts(); + /// + /// assert_eq!(origbase, &base); + /// assert_eq!(origclient_id, &client_id); + /// assert_eq!(origclient_secret, &client_secret); + /// assert_eq!(origredirect, &redirect); + /// assert_eq!(origscopes, scopes); + /// assert_eq!(origforce_login, force_login); + /// # Ok(()) + /// # } + /// ``` + pub fn into_parts(self) + -> (String, String, String, String, Scopes, bool) { + (self.base, self.client_id, self.client_secret, self.redirect, + self.scopes, self.force_login) + } + /// Returns the full url needed for authorisation. This needs to be opened + /// in a browser. + pub fn authorize_url(&self) -> Result { + let scopes = + { + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&[""], + &match (&self.scopes,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + }; + let scopes: String = + utf8_percent_encode(&scopes, DEFAULT_ENCODE_SET).collect(); + let url = + if self.force_login { + { + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["", + "/oauth/authorize?client_id=", + "&redirect_uri=", + "&scope=", + "&force_login=true&response_type=code"], + &match (&self.base, + &self.client_id, + &self.redirect, + &scopes) + { + (arg0, + arg1, + arg2, + arg3) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt), + ::core::fmt::ArgumentV1::new(arg1, + ::core::fmt::Display::fmt), + ::core::fmt::ArgumentV1::new(arg2, + ::core::fmt::Display::fmt), + ::core::fmt::ArgumentV1::new(arg3, + ::core::fmt::Display::fmt)], + })); + res + } + } else { + { + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["", + "/oauth/authorize?client_id=", + "&redirect_uri=", + "&scope=", + "&response_type=code"], + &match (&self.base, + &self.client_id, + &self.redirect, + &scopes) + { + (arg0, + arg1, + arg2, + arg3) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt), + ::core::fmt::ArgumentV1::new(arg1, + ::core::fmt::Display::fmt), + ::core::fmt::ArgumentV1::new(arg2, + ::core::fmt::Display::fmt), + ::core::fmt::ArgumentV1::new(arg3, + ::core::fmt::Display::fmt)], + })); + res + } + }; + Ok(url) + } + /// Create an access token from the client id, client secret, and code + /// provided by the authorisation url. + pub fn complete(&self, code: &str) -> Result { + let url = + { + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["", + "/oauth/token?client_id=", + "&client_secret=", + "&code=", + "&grant_type=authorization_code&redirect_uri="], + &match (&self.base, + &self.client_id, + &self.client_secret, + &code, + &self.redirect) + { + (arg0, + arg1, + arg2, + arg3, + arg4) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt), + ::core::fmt::ArgumentV1::new(arg1, + ::core::fmt::Display::fmt), + ::core::fmt::ArgumentV1::new(arg2, + ::core::fmt::Display::fmt), + ::core::fmt::ArgumentV1::new(arg3, + ::core::fmt::Display::fmt), + ::core::fmt::ArgumentV1::new(arg4, + ::core::fmt::Display::fmt)], + })); + res + }; + let token: AccessToken = + self.send(self.client.post(&url))?.json()?; + let data = + Data{base: self.base.clone().into(), + client_id: self.client_id.clone().into(), + client_secret: self.client_secret.clone().into(), + redirect: self.redirect.clone().into(), + token: token.access_token.into(),}; + let mut builder = MastodonBuilder::new(); + builder.client(self.client.clone()).data(data); + Ok(builder.build()?) + } + } + /// Represents the state of the auth flow when the app has been registered but + /// the user is not authenticated + pub struct Registered { + base: String, + client: Client, + client_id: String, + client_secret: String, + redirect: String, + scopes: Scopes, + force_login: bool, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Registered { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + Registered { + base: ref __self_0_0, + client: ref __self_0_1, + client_id: ref __self_0_2, + client_secret: ref __self_0_3, + redirect: ref __self_0_4, + scopes: ref __self_0_5, + force_login: ref __self_0_6 } => { + let mut debug_trait_builder = + f.debug_struct("Registered"); + let _ = + debug_trait_builder.field("base", &&(*__self_0_0)); + let _ = + debug_trait_builder.field("client", &&(*__self_0_1)); + let _ = + debug_trait_builder.field("client_id", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("client_secret", + &&(*__self_0_3)); + let _ = + debug_trait_builder.field("redirect", + &&(*__self_0_4)); + let _ = + debug_trait_builder.field("scopes", &&(*__self_0_5)); + let _ = + debug_trait_builder.field("force_login", + &&(*__self_0_6)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Registered { + #[inline] + fn clone(&self) -> Registered { + match *self { + Registered { + base: ref __self_0_0, + client: ref __self_0_1, + client_id: ref __self_0_2, + client_secret: ref __self_0_3, + redirect: ref __self_0_4, + scopes: ref __self_0_5, + force_login: ref __self_0_6 } => + Registered{base: ::core::clone::Clone::clone(&(*__self_0_0)), + client: + ::core::clone::Clone::clone(&(*__self_0_1)), + client_id: + ::core::clone::Clone::clone(&(*__self_0_2)), + client_secret: + ::core::clone::Clone::clone(&(*__self_0_3)), + redirect: + ::core::clone::Clone::clone(&(*__self_0_4)), + scopes: + ::core::clone::Clone::clone(&(*__self_0_5)), + force_login: + ::core::clone::Clone::clone(&(*__self_0_6)),}, + } + } + } +} +/// Requests +pub mod requests { + /// Data structure for the MastodonClient::add_filter method + pub use self::filter::AddFilterRequest; + /// Data structure for the MastodonClient::add_push_subscription method + pub use self::push::{AddPushRequest, Keys, UpdatePushRequest}; + /// Data structure for the MastodonClient::statuses method + pub use self::statuses::StatusesRequest; + /// Data structure for the MastodonClient::update_credentials method + pub use self::update_credentials::UpdateCredsRequest; + mod filter { + use crate::entities::filter::FilterContext; + use std::time::Duration; + /// Form used to create a filter + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// # use std::error::Error; + /// use elefren::{entities::filter::FilterContext, requests::AddFilterRequest}; + /// # fn main() -> Result<(), Box> { + /// let request = AddFilterRequest::new("foo", FilterContext::Home); + /// # Ok(()) + /// # } + /// ``` + pub struct AddFilterRequest { + phrase: String, + context: FilterContext, + irreversible: Option, + whole_word: Option, + #[serde(serialize_with = "serialize_duration::ser")] + expires_in: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for AddFilterRequest { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + AddFilterRequest { + phrase: ref __self_0_0, + context: ref __self_0_1, + irreversible: ref __self_0_2, + whole_word: ref __self_0_3, + expires_in: ref __self_0_4 } => { + let mut debug_trait_builder = + f.debug_struct("AddFilterRequest"); + let _ = + debug_trait_builder.field("phrase", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("context", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("irreversible", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("whole_word", + &&(*__self_0_3)); + let _ = + debug_trait_builder.field("expires_in", + &&(*__self_0_4)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for AddFilterRequest { + #[inline] + fn clone(&self) -> AddFilterRequest { + match *self { + AddFilterRequest { + phrase: ref __self_0_0, + context: ref __self_0_1, + irreversible: ref __self_0_2, + whole_word: ref __self_0_3, + expires_in: ref __self_0_4 } => + AddFilterRequest{phrase: + ::core::clone::Clone::clone(&(*__self_0_0)), + context: + ::core::clone::Clone::clone(&(*__self_0_1)), + irreversible: + ::core::clone::Clone::clone(&(*__self_0_2)), + whole_word: + ::core::clone::Clone::clone(&(*__self_0_3)), + expires_in: + ::core::clone::Clone::clone(&(*__self_0_4)),}, + } + } + } + impl ::core::marker::StructuralPartialEq for AddFilterRequest { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for AddFilterRequest { + #[inline] + fn eq(&self, other: &AddFilterRequest) -> bool { + match *other { + AddFilterRequest { + phrase: ref __self_1_0, + context: ref __self_1_1, + irreversible: ref __self_1_2, + whole_word: ref __self_1_3, + expires_in: ref __self_1_4 } => + match *self { + AddFilterRequest { + phrase: ref __self_0_0, + context: ref __self_0_1, + irreversible: ref __self_0_2, + whole_word: ref __self_0_3, + expires_in: ref __self_0_4 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3) && + (*__self_0_4) == (*__self_1_4), + }, + } + } + #[inline] + fn ne(&self, other: &AddFilterRequest) -> bool { + match *other { + AddFilterRequest { + phrase: ref __self_1_0, + context: ref __self_1_1, + irreversible: ref __self_1_2, + whole_word: ref __self_1_3, + expires_in: ref __self_1_4 } => + match *self { + AddFilterRequest { + phrase: ref __self_0_0, + context: ref __self_0_1, + irreversible: ref __self_0_2, + whole_word: ref __self_0_3, + expires_in: ref __self_0_4 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3) || + (*__self_0_4) != (*__self_1_4), + }, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_SERIALIZE_FOR_AddFilterRequest: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl _serde::Serialize for AddFilterRequest { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "AddFilterRequest", + false + as + usize + + 1 + + 1 + + 1 + + 1 + + + 1) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "phrase", + &self.phrase) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "context", + &self.context) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "irreversible", + &self.irreversible) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "whole_word", + &self.whole_word) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "expires_in", + { + struct __SerializeWith<'__a> { + values: (&'__a Option,), + phantom: _serde::export::PhantomData, + } + impl <'__a> + _serde::Serialize + for + __SerializeWith<'__a> + { + fn serialize<__S>(&self, + __s: + __S) + -> + _serde::export::Result<__S::Ok, + __S::Error> + where + __S: _serde::Serializer { + serialize_duration::ser(self.values.0, + __s) + } + } + &__SerializeWith{values: + (&self.expires_in,), + phantom: + _serde::export::PhantomData::,} + }) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl AddFilterRequest { + /// Create a new AddFilterRequest + pub fn new(phrase: &str, context: FilterContext) + -> AddFilterRequest { + AddFilterRequest{phrase: phrase.to_string(), + context, + irreversible: None, + whole_word: None, + expires_in: None,} + } + /// Set `irreversible` to `true` + pub fn irreversible(&mut self) -> &mut Self { + self.irreversible = Some(true); + self + } + /// Set `whole_word` to `true` + pub fn whole_word(&mut self) -> &mut Self { + self.whole_word = Some(true); + self + } + /// Set `expires_in` to a duration + pub fn expires_in(&mut self, d: Duration) -> &mut Self { + self.expires_in = Some(d); + self + } + } + mod serialize_duration { + use serde::ser::Serializer; + use std::time::Duration; + pub(crate) fn ser(duration: &Option, s: S) + -> Result where S: Serializer { + if let Some(d) = duration { + let sec = d.as_secs(); + s.serialize_u64(sec) + } else { s.serialize_none() } + } + } + } + mod push { + use crate::entities::push::{add_subscription, update_data}; + use crate::errors::Result; + /// Container for the key & auth strings for an AddPushRequest + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// use elefren::requests::Keys; + /// + /// let keys = Keys::new("anetohias===", "oeatssah="); + /// ``` + pub struct Keys { + pub(crate) p256dh: String, + pub(crate) auth: String, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Keys { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + Keys { p256dh: ref __self_0_0, auth: ref __self_0_1 } => { + let mut debug_trait_builder = f.debug_struct("Keys"); + let _ = + debug_trait_builder.field("p256dh", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("auth", + &&(*__self_0_1)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::default::Default for Keys { + #[inline] + fn default() -> Keys { + Keys{p256dh: ::core::default::Default::default(), + auth: ::core::default::Default::default(),} + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Keys { + #[inline] + fn clone(&self) -> Keys { + match *self { + Keys { p256dh: ref __self_0_0, auth: ref __self_0_1 } => + Keys{p256dh: ::core::clone::Clone::clone(&(*__self_0_0)), + auth: ::core::clone::Clone::clone(&(*__self_0_1)),}, + } + } + } + impl ::core::marker::StructuralPartialEq for Keys { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Keys { + #[inline] + fn eq(&self, other: &Keys) -> bool { + match *other { + Keys { p256dh: ref __self_1_0, auth: ref __self_1_1 } => + match *self { + Keys { p256dh: ref __self_0_0, auth: ref __self_0_1 } + => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1), + }, + } + } + #[inline] + fn ne(&self, other: &Keys) -> bool { + match *other { + Keys { p256dh: ref __self_1_0, auth: ref __self_1_1 } => + match *self { + Keys { p256dh: ref __self_0_0, auth: ref __self_0_1 } + => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1), + }, + } + } + } + impl Keys { + /// Create the `Keys` container + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// use elefren::requests::Keys; + /// + /// let keys = Keys::new("anetohias===", "oeatssah="); + /// ``` + pub fn new(p256dh: &str, auth: &str) -> Keys { + Keys{p256dh: p256dh.to_string(), auth: auth.to_string(),} + } + } + /// Builder to pass to the Mastodon::add_push_subscription method + /// + /// # Example + /// + /// ```no_run + /// # extern crate elefren; + /// # use elefren::{MastodonClient, Mastodon, Data}; + /// # fn main() -> Result<(), elefren::Error> { + /// # let data = Data { + /// # base: "".into(), + /// # client_id: "".into(), + /// # client_secret: "".into(), + /// # redirect: "".into(), + /// # token: "".into(), + /// # }; + /// use elefren::requests::{AddPushRequest, Keys}; + /// + /// let client = Mastodon::from(data); + /// + /// let keys = Keys::new("stahesuahoei293ise===", "tasecoa,nmeozka=="); + /// let mut request = AddPushRequest::new("http://example.com/push/endpoint", &keys); + /// request.follow().reblog(); + /// + /// client.add_push_subscription(&request)?; + /// # Ok(()) + /// # } + /// ``` + pub struct AddPushRequest { + endpoint: String, + p256dh: String, + auth: String, + follow: Option, + favourite: Option, + reblog: Option, + mention: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for AddPushRequest { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + AddPushRequest { + endpoint: ref __self_0_0, + p256dh: ref __self_0_1, + auth: ref __self_0_2, + follow: ref __self_0_3, + favourite: ref __self_0_4, + reblog: ref __self_0_5, + mention: ref __self_0_6 } => { + let mut debug_trait_builder = + f.debug_struct("AddPushRequest"); + let _ = + debug_trait_builder.field("endpoint", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("p256dh", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("auth", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("follow", + &&(*__self_0_3)); + let _ = + debug_trait_builder.field("favourite", + &&(*__self_0_4)); + let _ = + debug_trait_builder.field("reblog", + &&(*__self_0_5)); + let _ = + debug_trait_builder.field("mention", + &&(*__self_0_6)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::default::Default for AddPushRequest { + #[inline] + fn default() -> AddPushRequest { + AddPushRequest{endpoint: ::core::default::Default::default(), + p256dh: ::core::default::Default::default(), + auth: ::core::default::Default::default(), + follow: ::core::default::Default::default(), + favourite: ::core::default::Default::default(), + reblog: ::core::default::Default::default(), + mention: ::core::default::Default::default(),} + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for AddPushRequest { + #[inline] + fn clone(&self) -> AddPushRequest { + match *self { + AddPushRequest { + endpoint: ref __self_0_0, + p256dh: ref __self_0_1, + auth: ref __self_0_2, + follow: ref __self_0_3, + favourite: ref __self_0_4, + reblog: ref __self_0_5, + mention: ref __self_0_6 } => + AddPushRequest{endpoint: + ::core::clone::Clone::clone(&(*__self_0_0)), + p256dh: + ::core::clone::Clone::clone(&(*__self_0_1)), + auth: + ::core::clone::Clone::clone(&(*__self_0_2)), + follow: + ::core::clone::Clone::clone(&(*__self_0_3)), + favourite: + ::core::clone::Clone::clone(&(*__self_0_4)), + reblog: + ::core::clone::Clone::clone(&(*__self_0_5)), + mention: + ::core::clone::Clone::clone(&(*__self_0_6)),}, + } + } + } + impl ::core::marker::StructuralPartialEq for AddPushRequest { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for AddPushRequest { + #[inline] + fn eq(&self, other: &AddPushRequest) -> bool { + match *other { + AddPushRequest { + endpoint: ref __self_1_0, + p256dh: ref __self_1_1, + auth: ref __self_1_2, + follow: ref __self_1_3, + favourite: ref __self_1_4, + reblog: ref __self_1_5, + mention: ref __self_1_6 } => + match *self { + AddPushRequest { + endpoint: ref __self_0_0, + p256dh: ref __self_0_1, + auth: ref __self_0_2, + follow: ref __self_0_3, + favourite: ref __self_0_4, + reblog: ref __self_0_5, + mention: ref __self_0_6 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3) && + (*__self_0_4) == (*__self_1_4) && + (*__self_0_5) == (*__self_1_5) && + (*__self_0_6) == (*__self_1_6), + }, + } + } + #[inline] + fn ne(&self, other: &AddPushRequest) -> bool { + match *other { + AddPushRequest { + endpoint: ref __self_1_0, + p256dh: ref __self_1_1, + auth: ref __self_1_2, + follow: ref __self_1_3, + favourite: ref __self_1_4, + reblog: ref __self_1_5, + mention: ref __self_1_6 } => + match *self { + AddPushRequest { + endpoint: ref __self_0_0, + p256dh: ref __self_0_1, + auth: ref __self_0_2, + follow: ref __self_0_3, + favourite: ref __self_0_4, + reblog: ref __self_0_5, + mention: ref __self_0_6 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3) || + (*__self_0_4) != (*__self_1_4) || + (*__self_0_5) != (*__self_1_5) || + (*__self_0_6) != (*__self_1_6), + }, + } + } + } + impl AddPushRequest { + /// Construct a new AddPushRequest + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// use elefren::requests::{AddPushRequest, Keys}; + /// let keys = Keys::new("abcdef===", "foobar=="); + /// let push_endpoint = "https://example.com/push/endpoint"; + /// let request = AddPushRequest::new(push_endpoint, &keys); + /// ``` + pub fn new(endpoint: &str, keys: &Keys) -> AddPushRequest { + AddPushRequest{endpoint: endpoint.to_string(), + p256dh: keys.p256dh.clone(), + auth: keys.auth.clone(), ..Default::default()} + } + /// A flag that indicates if you want follow notifications pushed + /// + /// # Example + /// ``` + /// # extern crate elefren; + /// use elefren::requests::{AddPushRequest, Keys}; + /// let keys = Keys::new("abcdef===", "foobar=="); + /// let push_endpoint = "https://example.com/push/endpoint"; + /// let mut request = AddPushRequest::new(push_endpoint, &keys); + /// request.follow(); + /// ``` + pub fn follow(&mut self) -> &mut Self { + self.follow = Some(true); + self + } + /// A flag that indicates if you want favourite notifications pushed + /// + /// # Example + /// ``` + /// # extern crate elefren; + /// use elefren::requests::{AddPushRequest, Keys}; + /// let keys = Keys::new("abcdef===", "foobar=="); + /// let push_endpoint = "https://example.com/push/endpoint"; + /// let mut request = AddPushRequest::new(push_endpoint, &keys); + /// request.favourite(); + /// ``` + pub fn favourite(&mut self) -> &mut Self { + self.favourite = Some(true); + self + } + /// A flag that indicates if you want reblog notifications pushed + /// + /// # Example + /// ``` + /// # extern crate elefren; + /// use elefren::requests::{AddPushRequest, Keys}; + /// let keys = Keys::new("abcdef===", "foobar=="); + /// let push_endpoint = "https://example.com/push/endpoint"; + /// let mut request = AddPushRequest::new(push_endpoint, &keys); + /// request.reblog(); + /// ``` + pub fn reblog(&mut self) -> &mut Self { + self.reblog = Some(true); + self + } + /// A flag that indicates if you want mention notifications pushed + /// + /// # Example + /// ``` + /// # extern crate elefren; + /// use elefren::requests::{AddPushRequest, Keys}; + /// let keys = Keys::new("abcdef===", "foobar=="); + /// let push_endpoint = "https://example.com/push/endpoint"; + /// let mut request = AddPushRequest::new(push_endpoint, &keys); + /// request.mention(); + /// ``` + pub fn mention(&mut self) -> &mut Self { + self.mention = Some(true); + self + } + fn flags_present(&self) -> bool { + self.follow.is_some() || self.favourite.is_some() || + self.reblog.is_some() || self.mention.is_some() + } + pub(crate) fn build(&self) -> Result { + use crate::entities::push::{add_subscription::{Data, Form, + Keys, + Subscription}, + Alerts}; + let mut form = + Form{subscription: + Subscription{endpoint: self.endpoint.clone(), + keys: + Keys{p256dh: + self.p256dh.clone(), + auth: + self.auth.clone(),},}, + data: None,}; + if self.flags_present() { + let mut alerts = Alerts::default(); + if let Some(follow) = self.follow { + alerts.follow = Some(follow); + } + if let Some(favourite) = self.favourite { + alerts.favourite = Some(favourite); + } + if let Some(reblog) = self.reblog { + alerts.reblog = Some(reblog); + } + if let Some(mention) = self.mention { + alerts.mention = Some(mention); + } + form.data = Some(Data{alerts: Some(alerts),}); + } + Ok(form) + } + } + /// Builder to pass to the Mastodon::update_push_data method + /// + /// # Example + /// + /// ```no_run + /// # extern crate elefren; + /// # use elefren::{MastodonClient, Mastodon, Data}; + /// # fn main() -> Result<(), elefren::Error> { + /// # let data = Data { + /// # base: "".into(), + /// # client_id: "".into(), + /// # client_secret: "".into(), + /// # redirect: "".into(), + /// # token: "".into(), + /// # }; + /// use elefren::requests::UpdatePushRequest; + /// + /// let client = Mastodon::from(data); + /// + /// let mut request = UpdatePushRequest::new("foobar"); + /// request.follow(true).reblog(true); + /// + /// client.update_push_data(&request)?; + /// # Ok(()) + /// # } + /// ``` + pub struct UpdatePushRequest { + id: String, + follow: Option, + favourite: Option, + reblog: Option, + mention: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for UpdatePushRequest { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + UpdatePushRequest { + id: ref __self_0_0, + follow: ref __self_0_1, + favourite: ref __self_0_2, + reblog: ref __self_0_3, + mention: ref __self_0_4 } => { + let mut debug_trait_builder = + f.debug_struct("UpdatePushRequest"); + let _ = + debug_trait_builder.field("id", &&(*__self_0_0)); + let _ = + debug_trait_builder.field("follow", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("favourite", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("reblog", + &&(*__self_0_3)); + let _ = + debug_trait_builder.field("mention", + &&(*__self_0_4)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::default::Default for UpdatePushRequest { + #[inline] + fn default() -> UpdatePushRequest { + UpdatePushRequest{id: ::core::default::Default::default(), + follow: ::core::default::Default::default(), + favourite: + ::core::default::Default::default(), + reblog: ::core::default::Default::default(), + mention: + ::core::default::Default::default(),} + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for UpdatePushRequest { + #[inline] + fn clone(&self) -> UpdatePushRequest { + match *self { + UpdatePushRequest { + id: ref __self_0_0, + follow: ref __self_0_1, + favourite: ref __self_0_2, + reblog: ref __self_0_3, + mention: ref __self_0_4 } => + UpdatePushRequest{id: + ::core::clone::Clone::clone(&(*__self_0_0)), + follow: + ::core::clone::Clone::clone(&(*__self_0_1)), + favourite: + ::core::clone::Clone::clone(&(*__self_0_2)), + reblog: + ::core::clone::Clone::clone(&(*__self_0_3)), + mention: + ::core::clone::Clone::clone(&(*__self_0_4)),}, + } + } + } + impl ::core::marker::StructuralPartialEq for UpdatePushRequest { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for UpdatePushRequest { + #[inline] + fn eq(&self, other: &UpdatePushRequest) -> bool { + match *other { + UpdatePushRequest { + id: ref __self_1_0, + follow: ref __self_1_1, + favourite: ref __self_1_2, + reblog: ref __self_1_3, + mention: ref __self_1_4 } => + match *self { + UpdatePushRequest { + id: ref __self_0_0, + follow: ref __self_0_1, + favourite: ref __self_0_2, + reblog: ref __self_0_3, + mention: ref __self_0_4 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3) && + (*__self_0_4) == (*__self_1_4), + }, + } + } + #[inline] + fn ne(&self, other: &UpdatePushRequest) -> bool { + match *other { + UpdatePushRequest { + id: ref __self_1_0, + follow: ref __self_1_1, + favourite: ref __self_1_2, + reblog: ref __self_1_3, + mention: ref __self_1_4 } => + match *self { + UpdatePushRequest { + id: ref __self_0_0, + follow: ref __self_0_1, + favourite: ref __self_0_2, + reblog: ref __self_0_3, + mention: ref __self_0_4 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3) || + (*__self_0_4) != (*__self_1_4), + }, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_SERIALIZE_FOR_UpdatePushRequest: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl _serde::Serialize for UpdatePushRequest { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "UpdatePushRequest", + false + as + usize + + 1 + + 1 + + 1 + + 1 + + + 1) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "id", + &self.id) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "follow", + &self.follow) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "favourite", + &self.favourite) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "reblog", + &self.reblog) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "mention", + &self.mention) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl UpdatePushRequest { + /// Construct a new UpdatePushRequest + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// use elefren::requests::UpdatePushRequest; + /// let request = UpdatePushRequest::new("some-id"); + /// ``` + pub fn new(id: &str) -> UpdatePushRequest { + UpdatePushRequest{id: id.to_string(), ..Default::default()} + } + /// A flag that indicates if you want follow notifications pushed + /// + /// # Example + /// ``` + /// # extern crate elefren; + /// use elefren::requests::UpdatePushRequest; + /// let mut request = UpdatePushRequest::new("foobar"); + /// request.follow(true); + /// ``` + pub fn follow(&mut self, follow: bool) -> &mut Self { + self.follow = Some(follow); + self + } + /// A flag that indicates if you want favourite notifications pushed + /// + /// # Example + /// ``` + /// # extern crate elefren; + /// use elefren::requests::UpdatePushRequest; + /// let mut request = UpdatePushRequest::new("foobar"); + /// request.favourite(true); + /// ``` + pub fn favourite(&mut self, favourite: bool) -> &mut Self { + self.favourite = Some(favourite); + self + } + /// A flag that indicates if you want reblog notifications pushed + /// + /// # Example + /// ``` + /// # extern crate elefren; + /// use elefren::requests::UpdatePushRequest; + /// let mut request = UpdatePushRequest::new("foobar"); + /// request.reblog(true); + /// ``` + pub fn reblog(&mut self, reblog: bool) -> &mut Self { + self.reblog = Some(reblog); + self + } + /// A flag that indicates if you want mention notifications pushed + /// + /// # Example + /// ``` + /// # extern crate elefren; + /// use elefren::requests::UpdatePushRequest; + /// let mut request = UpdatePushRequest::new("foobar"); + /// request.mention(true); + /// ``` + pub fn mention(&mut self, mention: bool) -> &mut Self { + self.mention = Some(mention); + self + } + fn flags_present(&self) -> bool { + self.follow.is_some() || self.favourite.is_some() || + self.reblog.is_some() || self.mention.is_some() + } + pub(crate) fn build(&self) -> update_data::Form { + use crate::entities::push::{update_data::{Data, Form}, + Alerts}; + let mut form = + Form{id: self.id.clone(), ..Default::default()}; + if self.flags_present() { + let mut alerts = Alerts::default(); + if let Some(follow) = self.follow { + alerts.follow = Some(follow); + } + if let Some(favourite) = self.favourite { + alerts.favourite = Some(favourite); + } + if let Some(reblog) = self.reblog { + alerts.reblog = Some(reblog); + } + if let Some(mention) = self.mention { + alerts.mention = Some(mention); + } + form.data = Data{alerts: Some(alerts),}; + } + form + } + } + } + mod statuses { + use crate::errors::Error; + use serde_qs; + use std::{borrow::Cow, convert::Into}; + mod bool_qs_serialize { + use serde::Serializer; + pub fn is_false(b: &bool) -> bool { !*b } + pub fn serialize(b: &bool, s: S) + -> Result { + if *b { s.serialize_i64(1) } else { s.serialize_i64(0) } + } + } + /// Builder for making a client.statuses() call + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// # use elefren::StatusesRequest; + /// let mut request = StatusesRequest::new(); + /// request.only_media().pinned().since_id("foo"); + /// # assert_eq!(&request.to_querystring().expect("Couldn't serialize qs")[..], "?only_media=1&pinned=1&since_id=foo"); + /// ``` + pub struct StatusesRequest<'a> { + #[serde(skip_serializing_if = "bool_qs_serialize::is_false")] + #[serde(serialize_with = "bool_qs_serialize::serialize")] + only_media: bool, + #[serde(skip_serializing_if = "bool_qs_serialize::is_false")] + #[serde(serialize_with = "bool_qs_serialize::serialize")] + exclude_replies: bool, + #[serde(skip_serializing_if = "bool_qs_serialize::is_false")] + #[serde(serialize_with = "bool_qs_serialize::serialize")] + pinned: bool, + #[serde(skip_serializing_if = "Option::is_none")] + max_id: Option>, + #[serde(skip_serializing_if = "Option::is_none")] + since_id: Option>, + #[serde(skip_serializing_if = "Option::is_none")] + limit: Option, + #[serde(skip_serializing_if = "Option::is_none")] + min_id: Option>, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl <'a> ::core::clone::Clone for StatusesRequest<'a> { + #[inline] + fn clone(&self) -> StatusesRequest<'a> { + match *self { + StatusesRequest { + only_media: ref __self_0_0, + exclude_replies: ref __self_0_1, + pinned: ref __self_0_2, + max_id: ref __self_0_3, + since_id: ref __self_0_4, + limit: ref __self_0_5, + min_id: ref __self_0_6 } => + StatusesRequest{only_media: + ::core::clone::Clone::clone(&(*__self_0_0)), + exclude_replies: + ::core::clone::Clone::clone(&(*__self_0_1)), + pinned: + ::core::clone::Clone::clone(&(*__self_0_2)), + max_id: + ::core::clone::Clone::clone(&(*__self_0_3)), + since_id: + ::core::clone::Clone::clone(&(*__self_0_4)), + limit: + ::core::clone::Clone::clone(&(*__self_0_5)), + min_id: + ::core::clone::Clone::clone(&(*__self_0_6)),}, + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl <'a> ::core::fmt::Debug for StatusesRequest<'a> { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + StatusesRequest { + only_media: ref __self_0_0, + exclude_replies: ref __self_0_1, + pinned: ref __self_0_2, + max_id: ref __self_0_3, + since_id: ref __self_0_4, + limit: ref __self_0_5, + min_id: ref __self_0_6 } => { + let mut debug_trait_builder = + f.debug_struct("StatusesRequest"); + let _ = + debug_trait_builder.field("only_media", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("exclude_replies", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("pinned", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("max_id", + &&(*__self_0_3)); + let _ = + debug_trait_builder.field("since_id", + &&(*__self_0_4)); + let _ = + debug_trait_builder.field("limit", + &&(*__self_0_5)); + let _ = + debug_trait_builder.field("min_id", + &&(*__self_0_6)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl <'a> ::core::default::Default for StatusesRequest<'a> { + #[inline] + fn default() -> StatusesRequest<'a> { + StatusesRequest{only_media: + ::core::default::Default::default(), + exclude_replies: + ::core::default::Default::default(), + pinned: ::core::default::Default::default(), + max_id: ::core::default::Default::default(), + since_id: ::core::default::Default::default(), + limit: ::core::default::Default::default(), + min_id: ::core::default::Default::default(),} + } + } + impl <'a> ::core::marker::StructuralPartialEq for StatusesRequest<'a> + { + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl <'a> ::core::cmp::PartialEq for StatusesRequest<'a> { + #[inline] + fn eq(&self, other: &StatusesRequest<'a>) -> bool { + match *other { + StatusesRequest { + only_media: ref __self_1_0, + exclude_replies: ref __self_1_1, + pinned: ref __self_1_2, + max_id: ref __self_1_3, + since_id: ref __self_1_4, + limit: ref __self_1_5, + min_id: ref __self_1_6 } => + match *self { + StatusesRequest { + only_media: ref __self_0_0, + exclude_replies: ref __self_0_1, + pinned: ref __self_0_2, + max_id: ref __self_0_3, + since_id: ref __self_0_4, + limit: ref __self_0_5, + min_id: ref __self_0_6 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3) && + (*__self_0_4) == (*__self_1_4) && + (*__self_0_5) == (*__self_1_5) && + (*__self_0_6) == (*__self_1_6), + }, + } + } + #[inline] + fn ne(&self, other: &StatusesRequest<'a>) -> bool { + match *other { + StatusesRequest { + only_media: ref __self_1_0, + exclude_replies: ref __self_1_1, + pinned: ref __self_1_2, + max_id: ref __self_1_3, + since_id: ref __self_1_4, + limit: ref __self_1_5, + min_id: ref __self_1_6 } => + match *self { + StatusesRequest { + only_media: ref __self_0_0, + exclude_replies: ref __self_0_1, + pinned: ref __self_0_2, + max_id: ref __self_0_3, + since_id: ref __self_0_4, + limit: ref __self_0_5, + min_id: ref __self_0_6 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3) || + (*__self_0_4) != (*__self_1_4) || + (*__self_0_5) != (*__self_1_5) || + (*__self_0_6) != (*__self_1_6), + }, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_SERIALIZE_FOR_StatusesRequest: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'a> _serde::Serialize for StatusesRequest<'a> { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "StatusesRequest", + false + as + usize + + + if bool_qs_serialize::is_false(&self.only_media) + { + 0 + } else { + 1 + } + + if bool_qs_serialize::is_false(&self.exclude_replies) + { + 0 + } else { + 1 + } + + if bool_qs_serialize::is_false(&self.pinned) + { + 0 + } else { + 1 + } + + if Option::is_none(&self.max_id) + { + 0 + } else { + 1 + } + + if Option::is_none(&self.since_id) + { + 0 + } else { + 1 + } + + if Option::is_none(&self.limit) + { + 0 + } else { + 1 + } + + if Option::is_none(&self.min_id) + { + 0 + } else { + 1 + }) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + if !bool_qs_serialize::is_false(&self.only_media) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "only_media", + { + struct __SerializeWith<'__a, + 'a: '__a> { + values: (&'__a bool,), + phantom: _serde::export::PhantomData>, + } + impl <'__a, + 'a: '__a> + _serde::Serialize + for + __SerializeWith<'__a, + 'a> + { + fn serialize<__S>(&self, + __s: + __S) + -> + _serde::export::Result<__S::Ok, + __S::Error> + where + __S: _serde::Serializer { + bool_qs_serialize::serialize(self.values.0, + __s) + } + } + &__SerializeWith{values: + (&self.only_media,), + phantom: + _serde::export::PhantomData::>,} + }) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "only_media") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + if !bool_qs_serialize::is_false(&self.exclude_replies) + { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "exclude_replies", + { + struct __SerializeWith<'__a, + 'a: '__a> { + values: (&'__a bool,), + phantom: _serde::export::PhantomData>, + } + impl <'__a, + 'a: '__a> + _serde::Serialize + for + __SerializeWith<'__a, + 'a> + { + fn serialize<__S>(&self, + __s: + __S) + -> + _serde::export::Result<__S::Ok, + __S::Error> + where + __S: _serde::Serializer { + bool_qs_serialize::serialize(self.values.0, + __s) + } + } + &__SerializeWith{values: + (&self.exclude_replies,), + phantom: + _serde::export::PhantomData::>,} + }) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "exclude_replies") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + if !bool_qs_serialize::is_false(&self.pinned) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "pinned", + { + struct __SerializeWith<'__a, + 'a: '__a> { + values: (&'__a bool,), + phantom: _serde::export::PhantomData>, + } + impl <'__a, + 'a: '__a> + _serde::Serialize + for + __SerializeWith<'__a, + 'a> + { + fn serialize<__S>(&self, + __s: + __S) + -> + _serde::export::Result<__S::Ok, + __S::Error> + where + __S: _serde::Serializer { + bool_qs_serialize::serialize(self.values.0, + __s) + } + } + &__SerializeWith{values: + (&self.pinned,), + phantom: + _serde::export::PhantomData::>,} + }) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "pinned") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + if !Option::is_none(&self.max_id) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "max_id", + &self.max_id) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "max_id") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + if !Option::is_none(&self.since_id) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "since_id", + &self.since_id) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "since_id") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + if !Option::is_none(&self.limit) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "limit", + &self.limit) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "limit") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + if !Option::is_none(&self.min_id) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "min_id", + &self.min_id) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "min_id") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl <'a> Into>> for + &'a mut StatusesRequest<'a> { + fn into(self) -> Option> { + Some(StatusesRequest{only_media: self.only_media, + exclude_replies: self.exclude_replies, + pinned: self.pinned, + max_id: self.max_id.clone(), + since_id: self.since_id.clone(), + limit: self.limit.clone(), + min_id: self.min_id.clone(),}) + } + } + impl <'a> StatusesRequest<'a> { + /// Construct a new `StatusesRequest` object + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// # use elefren::StatusesRequest; + /// let request = StatusesRequest::new(); + /// ``` + pub fn new() -> Self { Self::default() } + /// Set the `?only_media=1` flag for the .statuses() request + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// # use elefren::StatusesRequest; + /// let mut request = StatusesRequest::new(); + /// assert_eq!(&request.only_media().to_querystring().expect("Couldn't serialize qs"), "?only_media=1"); + pub fn only_media(&mut self) -> &mut Self { + self.only_media = true; + self + } + /// Set the `?exclude_replies=1` flag for the .statuses() request + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// # use elefren::StatusesRequest; + /// let mut request = StatusesRequest::new(); + /// assert_eq!( + /// &request + /// .exclude_replies() + /// .to_querystring() + /// .expect("Couldn't serialize qs"), + /// "?exclude_replies=1" + /// ); + /// ``` + pub fn exclude_replies(&mut self) -> &mut Self { + self.exclude_replies = true; + self + } + /// Set the `?pinned=1` flag for the .statuses() request + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// # use elefren::StatusesRequest; + /// let mut request = StatusesRequest::new(); + /// assert_eq!( + /// &request + /// .pinned() + /// .to_querystring() + /// .expect("Couldn't serialize qs"), + /// "?pinned=1" + /// ); + /// ``` + pub fn pinned(&mut self) -> &mut Self { self.pinned = true; self } + /// Set the `?max_id=:max_id` flag for the .statuses() request + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// # use elefren::StatusesRequest; + /// let mut request = StatusesRequest::new(); + /// assert_eq!( + /// &request + /// .max_id("foo") + /// .to_querystring() + /// .expect("Couldn't serialize qs"), + /// "?max_id=foo" + /// ); + /// ``` + pub fn max_id>>(&mut self, max_id: S) + -> &mut Self { + self.max_id = Some(max_id.into()); + self + } + /// Set the `?since_id=:since_id` flag for the .statuses() request + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// # use elefren::StatusesRequest; + /// let mut request = StatusesRequest::new(); + /// assert_eq!( + /// &request + /// .since_id("foo") + /// .to_querystring() + /// .expect("Couldn't serialize qs"), + /// "?since_id=foo" + /// ); + /// ``` + pub fn since_id>>(&mut self, since_id: S) + -> &mut Self { + self.since_id = Some(since_id.into()); + self + } + /// Set the `?limit=:limit` flag for the .statuses() request + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// # use elefren::StatusesRequest; + /// let mut request = StatusesRequest::new(); + /// assert_eq!( + /// &request + /// .limit(10) + /// .to_querystring() + /// .expect("Couldn't serialize qs"), + /// "?limit=10" + /// ); + /// ``` + pub fn limit(&mut self, limit: usize) -> &mut Self { + self.limit = Some(limit); + self + } + /// Set the `?min_id=:min_id` flag for the .statuses() request + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// # use elefren::StatusesRequest; + /// let mut request = StatusesRequest::new(); + /// assert_eq!( + /// &request + /// .min_id("foobar") + /// .to_querystring() + /// .expect("Couldn't serialize qs"), + /// "?min_id=foobar" + /// ); + /// ``` + pub fn min_id>>(&mut self, min_id: S) + -> &mut Self { + self.min_id = Some(min_id.into()); + self + } + /// Turns this builder into a querystring + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// # use elefren::StatusesRequest; + /// let mut request = StatusesRequest::new(); + /// assert_eq!( + /// &request + /// .limit(10) + /// .pinned() + /// .to_querystring() + /// .expect("Couldn't serialize qs"), + /// "?pinned=1&limit=10" + /// ); + /// ``` + pub fn to_querystring(&self) -> Result { + Ok({ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["?"], + &match (&serde_qs::to_string(&self)?,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + }) + } + } + } + mod update_credentials { + use std::{fmt::Display, path::{Path, PathBuf}}; + use crate::entities::account::{Credentials, MetadataField, + UpdateSource}; + use crate::errors::Result; + use crate::status_builder; + /// Builder to pass to the Mastodon::update_credentials method + /// + /// # Example + /// + /// ```no_run + /// # extern crate elefren; + /// # use elefren::Data; + /// # fn main() -> Result<(), elefren::Error> { + /// # let data = Data { + /// # base: "".into(), + /// # client_id: "".into(), + /// # client_secret: "".into(), + /// # redirect: "".into(), + /// # token: "".into(), + /// # }; + /// use elefren::{prelude::*, status_builder::Visibility, UpdateCredsRequest}; + /// + /// let client = Mastodon::from(data); + /// let mut builder = UpdateCredsRequest::new(); + /// + /// builder.privacy(Visibility::Unlisted); + /// + /// let result = client.update_credentials(&mut builder)?; + /// # Ok(()) + /// # } + /// ``` + pub struct UpdateCredsRequest { + display_name: Option, + note: Option, + avatar: Option, + header: Option, + field_attributes: Vec, + privacy: Option, + sensitive: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for UpdateCredsRequest { + fn fmt(&self, f: &mut ::core::fmt::Formatter) + -> ::core::fmt::Result { + match *self { + UpdateCredsRequest { + display_name: ref __self_0_0, + note: ref __self_0_1, + avatar: ref __self_0_2, + header: ref __self_0_3, + field_attributes: ref __self_0_4, + privacy: ref __self_0_5, + sensitive: ref __self_0_6 } => { + let mut debug_trait_builder = + f.debug_struct("UpdateCredsRequest"); + let _ = + debug_trait_builder.field("display_name", + &&(*__self_0_0)); + let _ = + debug_trait_builder.field("note", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("avatar", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("header", + &&(*__self_0_3)); + let _ = + debug_trait_builder.field("field_attributes", + &&(*__self_0_4)); + let _ = + debug_trait_builder.field("privacy", + &&(*__self_0_5)); + let _ = + debug_trait_builder.field("sensitive", + &&(*__self_0_6)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::default::Default for UpdateCredsRequest { + #[inline] + fn default() -> UpdateCredsRequest { + UpdateCredsRequest{display_name: + ::core::default::Default::default(), + note: ::core::default::Default::default(), + avatar: + ::core::default::Default::default(), + header: + ::core::default::Default::default(), + field_attributes: + ::core::default::Default::default(), + privacy: + ::core::default::Default::default(), + sensitive: + ::core::default::Default::default(),} + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for UpdateCredsRequest { + #[inline] + fn clone(&self) -> UpdateCredsRequest { + match *self { + UpdateCredsRequest { + display_name: ref __self_0_0, + note: ref __self_0_1, + avatar: ref __self_0_2, + header: ref __self_0_3, + field_attributes: ref __self_0_4, + privacy: ref __self_0_5, + sensitive: ref __self_0_6 } => + UpdateCredsRequest{display_name: + ::core::clone::Clone::clone(&(*__self_0_0)), + note: + ::core::clone::Clone::clone(&(*__self_0_1)), + avatar: + ::core::clone::Clone::clone(&(*__self_0_2)), + header: + ::core::clone::Clone::clone(&(*__self_0_3)), + field_attributes: + ::core::clone::Clone::clone(&(*__self_0_4)), + privacy: + ::core::clone::Clone::clone(&(*__self_0_5)), + sensitive: + ::core::clone::Clone::clone(&(*__self_0_6)),}, + } + } + } + impl ::core::marker::StructuralPartialEq for UpdateCredsRequest { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for UpdateCredsRequest { + #[inline] + fn eq(&self, other: &UpdateCredsRequest) -> bool { + match *other { + UpdateCredsRequest { + display_name: ref __self_1_0, + note: ref __self_1_1, + avatar: ref __self_1_2, + header: ref __self_1_3, + field_attributes: ref __self_1_4, + privacy: ref __self_1_5, + sensitive: ref __self_1_6 } => + match *self { + UpdateCredsRequest { + display_name: ref __self_0_0, + note: ref __self_0_1, + avatar: ref __self_0_2, + header: ref __self_0_3, + field_attributes: ref __self_0_4, + privacy: ref __self_0_5, + sensitive: ref __self_0_6 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3) && + (*__self_0_4) == (*__self_1_4) && + (*__self_0_5) == (*__self_1_5) && + (*__self_0_6) == (*__self_1_6), + }, + } + } + #[inline] + fn ne(&self, other: &UpdateCredsRequest) -> bool { + match *other { + UpdateCredsRequest { + display_name: ref __self_1_0, + note: ref __self_1_1, + avatar: ref __self_1_2, + header: ref __self_1_3, + field_attributes: ref __self_1_4, + privacy: ref __self_1_5, + sensitive: ref __self_1_6 } => + match *self { + UpdateCredsRequest { + display_name: ref __self_0_0, + note: ref __self_0_1, + avatar: ref __self_0_2, + header: ref __self_0_3, + field_attributes: ref __self_0_4, + privacy: ref __self_0_5, + sensitive: ref __self_0_6 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3) || + (*__self_0_4) != (*__self_1_4) || + (*__self_0_5) != (*__self_1_5) || + (*__self_0_6) != (*__self_1_6), + }, + } + } + } + impl UpdateCredsRequest { + /// Create a new UpdateCredsRequest + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// use elefren::UpdateCredsRequest; + /// + /// let mut builder = UpdateCredsRequest::new(); + /// ``` + pub fn new() -> UpdateCredsRequest { Default::default() } + /// Set the new display_name value + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// use elefren::UpdateCredsRequest; + /// + /// let mut builder = UpdateCredsRequest::new(); + /// + /// builder.display_name("my new display name"); + /// ``` + pub fn display_name(&mut self, name: D) -> &mut Self { + self.display_name = Some(name.to_string()); + self + } + /// Set the new note value + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// use elefren::UpdateCredsRequest; + /// + /// let mut builder = UpdateCredsRequest::new(); + /// + /// builder.note("my new note"); + /// ``` + pub fn note(&mut self, note: D) -> &mut Self { + self.note = Some(note.to_string()); + self + } + /// Set the new avatar value + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// use elefren::UpdateCredsRequest; + /// + /// let mut builder = UpdateCredsRequest::new(); + /// + /// builder.avatar("/path/to/my/new/avatar"); + /// ``` + pub fn avatar>(&mut self, path: P) -> &mut Self { + let path = path.as_ref(); + let path = path.to_path_buf(); + self.avatar = Some(path); + self + } + /// Set the new header value + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// use elefren::UpdateCredsRequest; + /// + /// let mut builder = UpdateCredsRequest::new(); + /// + /// builder.header("/path/to/my/new/header"); + /// ``` + pub fn header>(&mut self, path: P) -> &mut Self { + let path = path.as_ref(); + let path = path.to_path_buf(); + self.header = Some(path); + self + } + /// Set the new privacy value + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// use elefren::{status_builder::Visibility, UpdateCredsRequest}; + /// + /// let mut builder = UpdateCredsRequest::new(); + /// + /// builder.privacy(Visibility::Public); + /// ``` + pub fn privacy(&mut self, privacy: status_builder::Visibility) + -> &mut Self { + self.privacy = Some(privacy); + self + } + /// Set the new sensitive value + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// use elefren::UpdateCredsRequest; + /// + /// let mut builder = UpdateCredsRequest::new(); + /// + /// builder.sensitive(true); + /// ``` + pub fn sensitive(&mut self, sensitive: bool) -> &mut Self { + self.sensitive = Some(sensitive); + self + } + /// Add a metadata field + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// use elefren::UpdateCredsRequest; + /// + /// let mut builder = UpdateCredsRequest::new(); + /// + /// builder.field_attribute("some key", "some value"); + /// ``` + pub fn field_attribute(&mut self, name: &str, value: &str) + -> &mut Self { + self.field_attributes.push(MetadataField::new(name, value)); + self + } + pub(crate) fn build(&mut self) -> Result { + Ok(Credentials{display_name: self.display_name.clone(), + note: self.note.clone(), + avatar: self.avatar.clone(), + header: self.avatar.clone(), + source: + Some(UpdateSource{privacy: + self.privacy.clone(), + sensitive: + self.sensitive.clone(),}), + fields_attributes: + self.field_attributes.clone(),}) + } + } + } +} +/// OAuth Scopes +pub mod scopes { + use std::{cmp::{Ordering, PartialEq, PartialOrd}, collections::HashSet, + fmt, ops::BitOr, str::FromStr}; + use serde::ser::{Serialize, Serializer}; + use crate::errors::Error; + use serde::{Deserialize, Deserializer}; + use serde::de::{self, Visitor}; + /// Represents a set of OAuth scopes + /// + /// # Example + /// + /// ```rust + /// use elefren::prelude::*; + /// + /// let read = Scopes::read_all(); + /// let write = Scopes::write_all(); + /// let follow = Scopes::follow(); + /// let all = read | write | follow; + /// ``` + pub struct Scopes { + scopes: HashSet, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Scopes { + #[inline] + fn clone(&self) -> Scopes { + match *self { + Scopes { scopes: ref __self_0_0 } => + Scopes{scopes: ::core::clone::Clone::clone(&(*__self_0_0)),}, + } + } + } + impl FromStr for Scopes { + type Err = Error; + fn from_str(s: &str) -> Result { + let mut set = HashSet::new(); + for scope in s.split_whitespace() { + let scope = Scope::from_str(&scope)?; + set.insert(scope); + } + Ok(Scopes{scopes: set,}) + } + } + impl Serialize for Scopes { + fn serialize(&self, serializer: S) + -> ::std::result::Result where S: Serializer { + let repr = + { + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&[""], + &match (&self,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + }; + serializer.serialize_str(&repr) + } + } + struct DeserializeScopesVisitor; + impl <'de> Visitor<'de> for DeserializeScopesVisitor { + type Value = Scopes; + fn expecting(&self, formatter: &mut fmt::Formatter) + -> Result<(), fmt::Error> { + formatter.write_fmt(::core::fmt::Arguments::new_v1(&["space separated scopes"], + &match () { + () => [], + })) + } + fn visit_str(self, v: &str) -> Result where + E: de::Error { + Scopes::from_str(v).map_err(de::Error::custom) + } + } + impl <'de> Deserialize<'de> for Scopes { + fn deserialize(deserializer: D) + -> Result>::Error> where + D: Deserializer<'de> { + deserializer.deserialize_str(DeserializeScopesVisitor) + } + } + impl Scopes { + /// Represents all available oauth scopes: "read write follow push" + /// + /// ``` + /// # extern crate elefren; + /// # use std::error::Error; + /// use elefren::scopes::Scopes; + /// + /// # fn main() -> Result<(), Box> { + /// let scope = Scopes::all(); + /// assert_eq!(&format!("{}", scope), "read write follow push"); + /// # Ok(()) + /// # } + /// ``` + pub fn all() -> Scopes { + Scopes::read_all() | Scopes::write_all() | Scopes::follow() | + Scopes::push() + } + /// Represents the full "read" scope + /// + /// ``` + /// # extern crate elefren; + /// # use std::error::Error; + /// use elefren::scopes::Scopes; + /// + /// # fn main() -> Result<(), Box> { + /// let scope = Scopes::read_all(); + /// assert_eq!(&format!("{}", scope), "read"); + /// # Ok(()) + /// # } + /// ``` + pub fn read_all() -> Scopes { Scopes::_read(None) } + /// Represents a specific "read:___" scope + /// + /// ``` + /// # extern crate elefren; + /// # use std::error::Error; + /// use elefren::scopes::{Read, Scopes}; + /// + /// # fn main() -> Result<(), Box> { + /// let scope = Scopes::read(Read::Accounts); + /// assert_eq!(&format!("{}", scope), "read:accounts"); + /// # Ok(()) + /// # } + /// ``` + pub fn read(subscope: Read) -> Scopes { + Scopes::_read(Some(subscope)) + } + /// Represents the full "write" scope + /// + /// ``` + /// # extern crate elefren; + /// # use std::error::Error; + /// use elefren::scopes::Scopes; + /// + /// # fn main() -> Result<(), Box> { + /// let scope = Scopes::write_all(); + /// assert_eq!(&format!("{}", scope), "write"); + /// # Ok(()) + /// # } + /// ``` + pub fn write_all() -> Scopes { Scopes::_write(None) } + /// Represents a specific "write:___" scope + /// + /// ``` + /// # extern crate elefren; + /// # use std::error::Error; + /// use elefren::scopes::{Scopes, Write}; + /// + /// # fn main() -> Result<(), Box> { + /// let scope = Scopes::write(Write::Accounts); + /// assert_eq!(&format!("{}", scope), "write:accounts"); + /// # Ok(()) + /// # } + /// ``` + pub fn write(subscope: Write) -> Scopes { + Scopes::_write(Some(subscope)) + } + /// Represents the "follow" scope + /// + /// ``` + /// # extern crate elefren; + /// # use std::error::Error; + /// use elefren::scopes::Scopes; + /// + /// # fn main() -> Result<(), Box> { + /// let scope = Scopes::follow(); + /// assert_eq!(&format!("{}", scope), "follow"); + /// # Ok(()) + /// # } + /// ``` + pub fn follow() -> Scopes { Scopes::new(Scope::Follow) } + /// Represents the full "push" scope + /// + /// ``` + /// # extern crate elefren; + /// # use std::error::Error; + /// use elefren::scopes::Scopes; + /// + /// # fn main() -> Result<(), Box> { + /// let scope = Scopes::push(); + /// assert_eq!(&format!("{}", scope), "push"); + /// # Ok(()) + /// # } + /// ``` + pub fn push() -> Scopes { Scopes::new(Scope::Push) } + /// Combines 2 scopes together + /// + /// # Example + /// + /// ```rust + /// use elefren::prelude::*; + /// + /// let read = Scopes::read_all(); + /// let write = Scopes::write_all(); + /// let read_write = read.and(write); + /// ``` + pub fn and(self, other: Scopes) -> Scopes { + let newset: HashSet<_> = + self.scopes.union(&other.scopes).into_iter().map(|s| + *s).collect(); + Scopes{scopes: newset,} + } + fn _write(subscope: Option) -> Scopes { + Scopes::new(Scope::Write(subscope)) + } + fn _read(subscope: Option) -> Scopes { + Scopes::new(Scope::Read(subscope)) + } + fn new(scope: Scope) -> Scopes { + let mut set = HashSet::new(); + set.insert(scope); + Scopes{scopes: set,} + } + } + impl BitOr for Scopes { + type Output = Scopes; + fn bitor(self, other: Scopes) -> Self::Output { self.and(other) } + } + impl PartialEq for Scopes { + fn eq(&self, other: &Scopes) -> bool { + self.scopes.symmetric_difference(&other.scopes).next().is_none() + } + } + impl Default for Scopes { + fn default() -> Scopes { Scopes::read_all() } + } + impl fmt::Debug for Scopes { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_fmt(::core::fmt::Arguments::new_v1(&["["], + &match () { + () => [], + }))?; + for scope in &self.scopes { + f.write_fmt(::core::fmt::Arguments::new_v1(&[""], + &match (&&scope,) { + (arg0,) => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Debug::fmt)], + }))?; + } + Ok(f.write_fmt(::core::fmt::Arguments::new_v1(&["]"], + &match () { + () => [], + }))?) + } + } + impl fmt::Display for Scopes { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let mut start = true; + let scopes = + { + let mut scopes = self.scopes.iter().collect::>(); + scopes.sort(); + scopes + }; + for scope in &scopes { + if !start { + f.write_fmt(::core::fmt::Arguments::new_v1(&[" "], + &match () { + () => [], + }))?; + } else { start = false; } + f.write_fmt(::core::fmt::Arguments::new_v1(&[""], + &match (&&scope,) { + (arg0,) => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + }))?; + } + Ok(()) + } + } + /// Permission scope of the application. + /// [Details on what each permission provides][1] + /// [1]: https://github.com/tootsuite/documentation/blob/master/Using-the-API/OAuth-details.md) + enum Scope { + + /// Read only permissions. + #[serde(rename = "read")] + Read(Option), + + /// Write only permissions. + #[serde(rename = "write")] + Write(Option), + + /// Only permission to add and remove followers. + #[serde(rename = "follow")] + Follow, + + /// Push permissions + #[serde(rename = "push")] + Push, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Scope { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match (&*self,) { + (&Scope::Read(ref __self_0),) => { + let mut debug_trait_builder = f.debug_tuple("Read"); + let _ = debug_trait_builder.field(&&(*__self_0)); + debug_trait_builder.finish() + } + (&Scope::Write(ref __self_0),) => { + let mut debug_trait_builder = f.debug_tuple("Write"); + let _ = debug_trait_builder.field(&&(*__self_0)); + debug_trait_builder.finish() + } + (&Scope::Follow,) => { + let mut debug_trait_builder = f.debug_tuple("Follow"); + debug_trait_builder.finish() + } + (&Scope::Push,) => { + let mut debug_trait_builder = f.debug_tuple("Push"); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Scope { + #[inline] + fn clone(&self) -> Scope { + { + let _: ::core::clone::AssertParamIsClone>; + let _: ::core::clone::AssertParamIsClone>; + *self + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::marker::Copy for Scope { } + impl ::core::marker::StructuralPartialEq for Scope { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Scope { + #[inline] + fn eq(&self, other: &Scope) -> bool { + { + let __self_vi = + unsafe { ::core::intrinsics::discriminant_value(&*self) }; + let __arg_1_vi = + unsafe { + ::core::intrinsics::discriminant_value(&*other) + }; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { + (&Scope::Read(ref __self_0), + &Scope::Read(ref __arg_1_0)) => + (*__self_0) == (*__arg_1_0), + (&Scope::Write(ref __self_0), + &Scope::Write(ref __arg_1_0)) => + (*__self_0) == (*__arg_1_0), + _ => true, + } + } else { false } + } + } + #[inline] + fn ne(&self, other: &Scope) -> bool { + { + let __self_vi = + unsafe { ::core::intrinsics::discriminant_value(&*self) }; + let __arg_1_vi = + unsafe { + ::core::intrinsics::discriminant_value(&*other) + }; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { + (&Scope::Read(ref __self_0), + &Scope::Read(ref __arg_1_0)) => + (*__self_0) != (*__arg_1_0), + (&Scope::Write(ref __self_0), + &Scope::Write(ref __arg_1_0)) => + (*__self_0) != (*__arg_1_0), + _ => false, + } + } else { true } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialOrd for Scope { + #[inline] + fn partial_cmp(&self, other: &Scope) + -> ::core::option::Option<::core::cmp::Ordering> { + { + let __self_vi = + unsafe { ::core::intrinsics::discriminant_value(&*self) }; + let __arg_1_vi = + unsafe { + ::core::intrinsics::discriminant_value(&*other) + }; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { + (&Scope::Read(ref __self_0), + &Scope::Read(ref __arg_1_0)) => + match ::core::cmp::PartialOrd::partial_cmp(&(*__self_0), + &(*__arg_1_0)) + { + ::core::option::Option::Some(::core::cmp::Ordering::Equal) + => + ::core::option::Option::Some(::core::cmp::Ordering::Equal), + cmp => cmp, + }, + (&Scope::Write(ref __self_0), + &Scope::Write(ref __arg_1_0)) => + match ::core::cmp::PartialOrd::partial_cmp(&(*__self_0), + &(*__arg_1_0)) + { + ::core::option::Option::Some(::core::cmp::Ordering::Equal) + => + ::core::option::Option::Some(::core::cmp::Ordering::Equal), + cmp => cmp, + }, + _ => + ::core::option::Option::Some(::core::cmp::Ordering::Equal), + } + } else { __self_vi.partial_cmp(&__arg_1_vi) } + } + } + #[inline] + fn lt(&self, other: &Scope) -> bool { + { + let __self_vi = + unsafe { ::core::intrinsics::discriminant_value(&*self) }; + let __arg_1_vi = + unsafe { + ::core::intrinsics::discriminant_value(&*other) + }; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { + (&Scope::Read(ref __self_0), + &Scope::Read(ref __arg_1_0)) => + ::core::option::Option::unwrap_or(::core::cmp::PartialOrd::partial_cmp(&(*__self_0), + &(*__arg_1_0)), + ::core::cmp::Ordering::Greater) + == ::core::cmp::Ordering::Less, + (&Scope::Write(ref __self_0), + &Scope::Write(ref __arg_1_0)) => + ::core::option::Option::unwrap_or(::core::cmp::PartialOrd::partial_cmp(&(*__self_0), + &(*__arg_1_0)), + ::core::cmp::Ordering::Greater) + == ::core::cmp::Ordering::Less, + _ => false, + } + } else { __self_vi.lt(&__arg_1_vi) } + } + } + #[inline] + fn le(&self, other: &Scope) -> bool { + { + let __self_vi = + unsafe { ::core::intrinsics::discriminant_value(&*self) }; + let __arg_1_vi = + unsafe { + ::core::intrinsics::discriminant_value(&*other) + }; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { + (&Scope::Read(ref __self_0), + &Scope::Read(ref __arg_1_0)) => + ::core::option::Option::unwrap_or(::core::cmp::PartialOrd::partial_cmp(&(*__self_0), + &(*__arg_1_0)), + ::core::cmp::Ordering::Greater) + != ::core::cmp::Ordering::Greater, + (&Scope::Write(ref __self_0), + &Scope::Write(ref __arg_1_0)) => + ::core::option::Option::unwrap_or(::core::cmp::PartialOrd::partial_cmp(&(*__self_0), + &(*__arg_1_0)), + ::core::cmp::Ordering::Greater) + != ::core::cmp::Ordering::Greater, + _ => true, + } + } else { __self_vi.le(&__arg_1_vi) } + } + } + #[inline] + fn gt(&self, other: &Scope) -> bool { + { + let __self_vi = + unsafe { ::core::intrinsics::discriminant_value(&*self) }; + let __arg_1_vi = + unsafe { + ::core::intrinsics::discriminant_value(&*other) + }; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { + (&Scope::Read(ref __self_0), + &Scope::Read(ref __arg_1_0)) => + ::core::option::Option::unwrap_or(::core::cmp::PartialOrd::partial_cmp(&(*__self_0), + &(*__arg_1_0)), + ::core::cmp::Ordering::Less) + == ::core::cmp::Ordering::Greater, + (&Scope::Write(ref __self_0), + &Scope::Write(ref __arg_1_0)) => + ::core::option::Option::unwrap_or(::core::cmp::PartialOrd::partial_cmp(&(*__self_0), + &(*__arg_1_0)), + ::core::cmp::Ordering::Less) + == ::core::cmp::Ordering::Greater, + _ => false, + } + } else { __self_vi.gt(&__arg_1_vi) } + } + } + #[inline] + fn ge(&self, other: &Scope) -> bool { + { + let __self_vi = + unsafe { ::core::intrinsics::discriminant_value(&*self) }; + let __arg_1_vi = + unsafe { + ::core::intrinsics::discriminant_value(&*other) + }; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { + (&Scope::Read(ref __self_0), + &Scope::Read(ref __arg_1_0)) => + ::core::option::Option::unwrap_or(::core::cmp::PartialOrd::partial_cmp(&(*__self_0), + &(*__arg_1_0)), + ::core::cmp::Ordering::Less) + != ::core::cmp::Ordering::Less, + (&Scope::Write(ref __self_0), + &Scope::Write(ref __arg_1_0)) => + ::core::option::Option::unwrap_or(::core::cmp::PartialOrd::partial_cmp(&(*__self_0), + &(*__arg_1_0)), + ::core::cmp::Ordering::Less) + != ::core::cmp::Ordering::Less, + _ => true, + } + } else { __self_vi.ge(&__arg_1_vi) } + } + } + } + impl ::core::marker::StructuralEq for Scope { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::Eq for Scope { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + { + let _: ::core::cmp::AssertParamIsEq>; + let _: ::core::cmp::AssertParamIsEq>; + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::hash::Hash for Scope { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match (&*self,) { + (&Scope::Read(ref __self_0),) => { + ::core::hash::Hash::hash(&unsafe { + ::core::intrinsics::discriminant_value(self) + }, state); + ::core::hash::Hash::hash(&(*__self_0), state) + } + (&Scope::Write(ref __self_0),) => { + ::core::hash::Hash::hash(&unsafe { + ::core::intrinsics::discriminant_value(self) + }, state); + ::core::hash::Hash::hash(&(*__self_0), state) + } + _ => { + ::core::hash::Hash::hash(&unsafe { + ::core::intrinsics::discriminant_value(self) + }, state) + } + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _IMPL_SERIALIZE_FOR_Scope: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl _serde::Serialize for Scope { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + match *self { + Scope::Read(ref __field0) => + _serde::Serializer::serialize_newtype_variant(__serializer, + "Scope", + 0u32, + "read", + __field0), + Scope::Write(ref __field0) => + _serde::Serializer::serialize_newtype_variant(__serializer, + "Scope", + 1u32, + "write", + __field0), + Scope::Follow => + _serde::Serializer::serialize_unit_variant(__serializer, + "Scope", + 2u32, + "follow"), + Scope::Push => + _serde::Serializer::serialize_unit_variant(__serializer, + "Scope", + 3u32, + "push"), + } + } + } + }; + impl FromStr for Scope { + type Err = Error; + fn from_str(s: &str) -> Result { + Ok(match s { + "read" => Scope::Read(None), + "write" => Scope::Write(None), + "follow" => Scope::Follow, + "push" => Scope::Push, + read if read.starts_with("read:") => { + let r: Read = Read::from_str(&read[5..])?; + Scope::Read(Some(r)) + } + write if write.starts_with("write:") => { + let w: Write = Write::from_str(&write[6..])?; + Scope::Write(Some(w)) + } + _ => return Err(Error::Other("Unknown scope".to_string())), + }) + } + } + impl Ord for Scope { + fn cmp(&self, other: &Scope) -> Ordering { + match (*self, *other) { + (Scope::Read(None), Scope::Read(None)) => Ordering::Equal, + (Scope::Read(None), Scope::Read(Some(..))) => Ordering::Less, + (Scope::Read(Some(..)), Scope::Read(None)) => + Ordering::Greater, + (Scope::Read(Some(ref a)), Scope::Read(Some(ref b))) => + a.cmp(b), + (Scope::Write(None), Scope::Write(None)) => Ordering::Equal, + (Scope::Write(None), Scope::Write(Some(..))) => + Ordering::Less, + (Scope::Write(Some(..)), Scope::Write(None)) => + Ordering::Greater, + (Scope::Write(Some(ref a)), Scope::Write(Some(ref b))) => + a.cmp(b), + (Scope::Read(..), Scope::Write(..)) => Ordering::Less, + (Scope::Read(..), Scope::Follow) => Ordering::Less, + (Scope::Read(..), Scope::Push) => Ordering::Less, + (Scope::Write(..), Scope::Read(..)) => Ordering::Greater, + (Scope::Write(..), Scope::Follow) => Ordering::Less, + (Scope::Write(..), Scope::Push) => Ordering::Less, + (Scope::Follow, Scope::Read(..)) => Ordering::Greater, + (Scope::Follow, Scope::Write(..)) => Ordering::Greater, + (Scope::Follow, Scope::Follow) => Ordering::Equal, + (Scope::Follow, Scope::Push) => Ordering::Less, + (Scope::Push, Scope::Push) => Ordering::Equal, + (Scope::Push, _) => Ordering::Greater, + } + } + } + impl fmt::Display for Scope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + use self::Scope::*; + let s = + match *self { + Read(Some(ref r)) => return fmt::Display::fmt(r, f), + Read(None) => "read", + Write(Some(ref w)) => return fmt::Display::fmt(w, f), + Write(None) => "write", + Follow => "follow", + Push => "push", + }; + f.write_fmt(::core::fmt::Arguments::new_v1(&[""], + &match (&s,) { + (arg0,) => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + } + } + impl Default for Scope { + fn default() -> Self { Scope::Read(None) } + } + /// Represents the granular "read:___" oauth scopes + pub enum Read { + + /// Accounts + #[serde(rename = "accounts")] + Accounts, + + /// Blocks + #[serde(rename = "blocks")] + Blocks, + + /// Favourites + #[serde(rename = "favourites")] + Favourites, + + /// Filters + #[serde(rename = "filters")] + Filters, + + /// Follows + #[serde(rename = "follows")] + Follows, + + /// Lists + #[serde(rename = "lists")] + Lists, + + /// Mutes + #[serde(rename = "mutes")] + Mutes, + + /// Notifications + #[serde(rename = "notifications")] + Notifications, + + /// Reports + #[serde(rename = "reports")] + Reports, + + /// Search + #[serde(rename = "search")] + Search, + + /// Statuses + #[serde(rename = "statuses")] + Statuses, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Read { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match (&*self,) { + (&Read::Accounts,) => { + let mut debug_trait_builder = f.debug_tuple("Accounts"); + debug_trait_builder.finish() + } + (&Read::Blocks,) => { + let mut debug_trait_builder = f.debug_tuple("Blocks"); + debug_trait_builder.finish() + } + (&Read::Favourites,) => { + let mut debug_trait_builder = f.debug_tuple("Favourites"); + debug_trait_builder.finish() + } + (&Read::Filters,) => { + let mut debug_trait_builder = f.debug_tuple("Filters"); + debug_trait_builder.finish() + } + (&Read::Follows,) => { + let mut debug_trait_builder = f.debug_tuple("Follows"); + debug_trait_builder.finish() + } + (&Read::Lists,) => { + let mut debug_trait_builder = f.debug_tuple("Lists"); + debug_trait_builder.finish() + } + (&Read::Mutes,) => { + let mut debug_trait_builder = f.debug_tuple("Mutes"); + debug_trait_builder.finish() + } + (&Read::Notifications,) => { + let mut debug_trait_builder = + f.debug_tuple("Notifications"); + debug_trait_builder.finish() + } + (&Read::Reports,) => { + let mut debug_trait_builder = f.debug_tuple("Reports"); + debug_trait_builder.finish() + } + (&Read::Search,) => { + let mut debug_trait_builder = f.debug_tuple("Search"); + debug_trait_builder.finish() + } + (&Read::Statuses,) => { + let mut debug_trait_builder = f.debug_tuple("Statuses"); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Read { + #[inline] + fn clone(&self) -> Read { { *self } } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::marker::Copy for Read { } + impl ::core::marker::StructuralPartialEq for Read { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Read { + #[inline] + fn eq(&self, other: &Read) -> bool { + { + let __self_vi = + unsafe { ::core::intrinsics::discriminant_value(&*self) }; + let __arg_1_vi = + unsafe { + ::core::intrinsics::discriminant_value(&*other) + }; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { _ => true, } + } else { false } + } + } + } + impl ::core::marker::StructuralEq for Read { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::Eq for Read { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { { } } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::hash::Hash for Read { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match (&*self,) { + _ => { + ::core::hash::Hash::hash(&unsafe { + ::core::intrinsics::discriminant_value(self) + }, state) + } + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _IMPL_SERIALIZE_FOR_Read: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl _serde::Serialize for Read { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + match *self { + Read::Accounts => + _serde::Serializer::serialize_unit_variant(__serializer, + "Read", + 0u32, + "accounts"), + Read::Blocks => + _serde::Serializer::serialize_unit_variant(__serializer, + "Read", + 1u32, + "blocks"), + Read::Favourites => + _serde::Serializer::serialize_unit_variant(__serializer, + "Read", + 2u32, + "favourites"), + Read::Filters => + _serde::Serializer::serialize_unit_variant(__serializer, + "Read", + 3u32, + "filters"), + Read::Follows => + _serde::Serializer::serialize_unit_variant(__serializer, + "Read", + 4u32, + "follows"), + Read::Lists => + _serde::Serializer::serialize_unit_variant(__serializer, + "Read", + 5u32, + "lists"), + Read::Mutes => + _serde::Serializer::serialize_unit_variant(__serializer, + "Read", + 6u32, + "mutes"), + Read::Notifications => + _serde::Serializer::serialize_unit_variant(__serializer, + "Read", + 7u32, + "notifications"), + Read::Reports => + _serde::Serializer::serialize_unit_variant(__serializer, + "Read", + 8u32, + "reports"), + Read::Search => + _serde::Serializer::serialize_unit_variant(__serializer, + "Read", + 9u32, + "search"), + Read::Statuses => + _serde::Serializer::serialize_unit_variant(__serializer, + "Read", + 10u32, + "statuses"), + } + } + } + }; + impl FromStr for Read { + type Err = Error; + fn from_str(s: &str) -> Result { + Ok(match s { + "accounts" => Read::Accounts, + "blocks" => Read::Blocks, + "favourites" => Read::Favourites, + "filters" => Read::Filters, + "follows" => Read::Follows, + "lists" => Read::Lists, + "mutes" => Read::Mutes, + "notifications" => Read::Notifications, + "reports" => Read::Reports, + "search" => Read::Search, + "statuses" => Read::Statuses, + _ => + return Err(Error::Other("Unknown 'read' subcategory".to_string())), + }) + } + } + impl PartialOrd for Read { + fn partial_cmp(&self, other: &Read) -> Option { + Some(self.cmp(other)) + } + } + impl Ord for Read { + fn cmp(&self, other: &Read) -> Ordering { + let a = + { + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&[""], + &match (&self,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Debug::fmt)], + })); + res + }; + let b = + { + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&[""], + &match (&other,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Debug::fmt)], + })); + res + }; + a.cmp(&b) + } + } + impl fmt::Display for Read { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_fmt(::core::fmt::Arguments::new_v1(&["read:"], + &match (&match *self { + Read::Accounts + => + "accounts", + Read::Blocks + => + "blocks", + Read::Favourites + => + "favourites", + Read::Filters + => + "filters", + Read::Follows + => + "follows", + Read::Lists + => + "lists", + Read::Mutes + => + "mutes", + Read::Notifications + => + "notifications", + Read::Reports + => + "reports", + Read::Search + => + "search", + Read::Statuses + => + "statuses", + },) { + (arg0,) => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + } + } + /// Represents the granular "write:___" oauth scopes + pub enum Write { + + /// Accounts + #[serde(rename = "accounts")] + Accounts, + + /// Blocks + #[serde(rename = "blocks")] + Blocks, + + /// Favourites + #[serde(rename = "favourites")] + Favourites, + + /// Filters + #[serde(rename = "filters")] + Filters, + + /// Follows + #[serde(rename = "follows")] + Follows, + + /// Lists + #[serde(rename = "lists")] + Lists, + + /// Media + #[serde(rename = "media")] + Media, + + /// Mutes + #[serde(rename = "mutes")] + Mutes, + + /// Notifications + #[serde(rename = "notifications")] + Notifications, + + /// Reports + #[serde(rename = "reports")] + Reports, + + /// Statuses + #[serde(rename = "statuses")] + Statuses, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Write { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match (&*self,) { + (&Write::Accounts,) => { + let mut debug_trait_builder = f.debug_tuple("Accounts"); + debug_trait_builder.finish() + } + (&Write::Blocks,) => { + let mut debug_trait_builder = f.debug_tuple("Blocks"); + debug_trait_builder.finish() + } + (&Write::Favourites,) => { + let mut debug_trait_builder = f.debug_tuple("Favourites"); + debug_trait_builder.finish() + } + (&Write::Filters,) => { + let mut debug_trait_builder = f.debug_tuple("Filters"); + debug_trait_builder.finish() + } + (&Write::Follows,) => { + let mut debug_trait_builder = f.debug_tuple("Follows"); + debug_trait_builder.finish() + } + (&Write::Lists,) => { + let mut debug_trait_builder = f.debug_tuple("Lists"); + debug_trait_builder.finish() + } + (&Write::Media,) => { + let mut debug_trait_builder = f.debug_tuple("Media"); + debug_trait_builder.finish() + } + (&Write::Mutes,) => { + let mut debug_trait_builder = f.debug_tuple("Mutes"); + debug_trait_builder.finish() + } + (&Write::Notifications,) => { + let mut debug_trait_builder = + f.debug_tuple("Notifications"); + debug_trait_builder.finish() + } + (&Write::Reports,) => { + let mut debug_trait_builder = f.debug_tuple("Reports"); + debug_trait_builder.finish() + } + (&Write::Statuses,) => { + let mut debug_trait_builder = f.debug_tuple("Statuses"); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Write { + #[inline] + fn clone(&self) -> Write { { *self } } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::marker::Copy for Write { } + impl ::core::marker::StructuralPartialEq for Write { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Write { + #[inline] + fn eq(&self, other: &Write) -> bool { + { + let __self_vi = + unsafe { ::core::intrinsics::discriminant_value(&*self) }; + let __arg_1_vi = + unsafe { + ::core::intrinsics::discriminant_value(&*other) + }; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { _ => true, } + } else { false } + } + } + } + impl ::core::marker::StructuralEq for Write { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::Eq for Write { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { { } } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::hash::Hash for Write { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match (&*self,) { + _ => { + ::core::hash::Hash::hash(&unsafe { + ::core::intrinsics::discriminant_value(self) + }, state) + } + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _IMPL_SERIALIZE_FOR_Write: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl _serde::Serialize for Write { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + match *self { + Write::Accounts => + _serde::Serializer::serialize_unit_variant(__serializer, + "Write", + 0u32, + "accounts"), + Write::Blocks => + _serde::Serializer::serialize_unit_variant(__serializer, + "Write", + 1u32, + "blocks"), + Write::Favourites => + _serde::Serializer::serialize_unit_variant(__serializer, + "Write", + 2u32, + "favourites"), + Write::Filters => + _serde::Serializer::serialize_unit_variant(__serializer, + "Write", + 3u32, + "filters"), + Write::Follows => + _serde::Serializer::serialize_unit_variant(__serializer, + "Write", + 4u32, + "follows"), + Write::Lists => + _serde::Serializer::serialize_unit_variant(__serializer, + "Write", + 5u32, + "lists"), + Write::Media => + _serde::Serializer::serialize_unit_variant(__serializer, + "Write", + 6u32, + "media"), + Write::Mutes => + _serde::Serializer::serialize_unit_variant(__serializer, + "Write", + 7u32, + "mutes"), + Write::Notifications => + _serde::Serializer::serialize_unit_variant(__serializer, + "Write", + 8u32, + "notifications"), + Write::Reports => + _serde::Serializer::serialize_unit_variant(__serializer, + "Write", + 9u32, + "reports"), + Write::Statuses => + _serde::Serializer::serialize_unit_variant(__serializer, + "Write", + 10u32, + "statuses"), + } + } + } + }; + impl FromStr for Write { + type Err = Error; + fn from_str(s: &str) -> Result { + Ok(match s { + "accounts" => Write::Accounts, + "blocks" => Write::Blocks, + "favourites" => Write::Favourites, + "filters" => Write::Filters, + "follows" => Write::Follows, + "lists" => Write::Lists, + "media" => Write::Media, + "mutes" => Write::Mutes, + "notifications" => Write::Notifications, + "reports" => Write::Reports, + "statuses" => Write::Statuses, + _ => + return Err(Error::Other("Unknown 'write' subcategory".to_string())), + }) + } + } + impl PartialOrd for Write { + fn partial_cmp(&self, other: &Write) -> Option { + Some(self.cmp(other)) + } + } + impl Ord for Write { + fn cmp(&self, other: &Write) -> Ordering { + let a = + { + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&[""], + &match (&self,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Debug::fmt)], + })); + res + }; + let b = + { + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&[""], + &match (&other,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Debug::fmt)], + })); + res + }; + a.cmp(&b) + } + } + impl fmt::Display for Write { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_fmt(::core::fmt::Arguments::new_v1(&["write:"], + &match (&match *self { + Write::Accounts + => + "accounts", + Write::Blocks + => + "blocks", + Write::Favourites + => + "favourites", + Write::Filters + => + "filters", + Write::Follows + => + "follows", + Write::Lists + => + "lists", + Write::Media + => + "media", + Write::Mutes + => + "mutes", + Write::Notifications + => + "notifications", + Write::Reports + => + "reports", + Write::Statuses + => + "statuses", + },) { + (arg0,) => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })) + } + } +} +/// Constructing a status +pub mod status_builder { + use isolang::Language; + /// A builder pattern struct for constructing a status. + /// + /// # Example + /// + /// ``` + /// # extern crate elefren; + /// # use elefren::{Language, StatusBuilder}; + /// + /// # fn main() -> Result<(), elefren::Error> { + /// let status = StatusBuilder::new() + /// .status("a status") + /// .sensitive(true) + /// .spoiler_text("a CW") + /// .language(Language::Eng) + /// .build()?; + /// # Ok(()) + /// # } + /// ``` + pub struct StatusBuilder { + status: Option, + in_reply_to_id: Option, + media_ids: Option>, + sensitive: Option, + spoiler_text: Option, + content_type: Option, + visibility: Option, + language: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for StatusBuilder { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + StatusBuilder { + status: ref __self_0_0, + in_reply_to_id: ref __self_0_1, + media_ids: ref __self_0_2, + sensitive: ref __self_0_3, + spoiler_text: ref __self_0_4, + content_type: ref __self_0_5, + visibility: ref __self_0_6, + language: ref __self_0_7 } => { + let mut debug_trait_builder = + f.debug_struct("StatusBuilder"); + let _ = + debug_trait_builder.field("status", &&(*__self_0_0)); + let _ = + debug_trait_builder.field("in_reply_to_id", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("media_ids", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("sensitive", + &&(*__self_0_3)); + let _ = + debug_trait_builder.field("spoiler_text", + &&(*__self_0_4)); + let _ = + debug_trait_builder.field("content_type", + &&(*__self_0_5)); + let _ = + debug_trait_builder.field("visibility", + &&(*__self_0_6)); + let _ = + debug_trait_builder.field("language", + &&(*__self_0_7)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::default::Default for StatusBuilder { + #[inline] + fn default() -> StatusBuilder { + StatusBuilder{status: ::core::default::Default::default(), + in_reply_to_id: ::core::default::Default::default(), + media_ids: ::core::default::Default::default(), + sensitive: ::core::default::Default::default(), + spoiler_text: ::core::default::Default::default(), + content_type: ::core::default::Default::default(), + visibility: ::core::default::Default::default(), + language: ::core::default::Default::default(),} + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for StatusBuilder { + #[inline] + fn clone(&self) -> StatusBuilder { + match *self { + StatusBuilder { + status: ref __self_0_0, + in_reply_to_id: ref __self_0_1, + media_ids: ref __self_0_2, + sensitive: ref __self_0_3, + spoiler_text: ref __self_0_4, + content_type: ref __self_0_5, + visibility: ref __self_0_6, + language: ref __self_0_7 } => + StatusBuilder{status: + ::core::clone::Clone::clone(&(*__self_0_0)), + in_reply_to_id: + ::core::clone::Clone::clone(&(*__self_0_1)), + media_ids: + ::core::clone::Clone::clone(&(*__self_0_2)), + sensitive: + ::core::clone::Clone::clone(&(*__self_0_3)), + spoiler_text: + ::core::clone::Clone::clone(&(*__self_0_4)), + content_type: + ::core::clone::Clone::clone(&(*__self_0_5)), + visibility: + ::core::clone::Clone::clone(&(*__self_0_6)), + language: + ::core::clone::Clone::clone(&(*__self_0_7)),}, + } + } + } + impl ::core::marker::StructuralPartialEq for StatusBuilder { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for StatusBuilder { + #[inline] + fn eq(&self, other: &StatusBuilder) -> bool { + match *other { + StatusBuilder { + status: ref __self_1_0, + in_reply_to_id: ref __self_1_1, + media_ids: ref __self_1_2, + sensitive: ref __self_1_3, + spoiler_text: ref __self_1_4, + content_type: ref __self_1_5, + visibility: ref __self_1_6, + language: ref __self_1_7 } => + match *self { + StatusBuilder { + status: ref __self_0_0, + in_reply_to_id: ref __self_0_1, + media_ids: ref __self_0_2, + sensitive: ref __self_0_3, + spoiler_text: ref __self_0_4, + content_type: ref __self_0_5, + visibility: ref __self_0_6, + language: ref __self_0_7 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3) && + (*__self_0_4) == (*__self_1_4) && + (*__self_0_5) == (*__self_1_5) && + (*__self_0_6) == (*__self_1_6) && + (*__self_0_7) == (*__self_1_7), + }, + } + } + #[inline] + fn ne(&self, other: &StatusBuilder) -> bool { + match *other { + StatusBuilder { + status: ref __self_1_0, + in_reply_to_id: ref __self_1_1, + media_ids: ref __self_1_2, + sensitive: ref __self_1_3, + spoiler_text: ref __self_1_4, + content_type: ref __self_1_5, + visibility: ref __self_1_6, + language: ref __self_1_7 } => + match *self { + StatusBuilder { + status: ref __self_0_0, + in_reply_to_id: ref __self_0_1, + media_ids: ref __self_0_2, + sensitive: ref __self_0_3, + spoiler_text: ref __self_0_4, + content_type: ref __self_0_5, + visibility: ref __self_0_6, + language: ref __self_0_7 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3) || + (*__self_0_4) != (*__self_1_4) || + (*__self_0_5) != (*__self_1_5) || + (*__self_0_6) != (*__self_1_6) || + (*__self_0_7) != (*__self_1_7), + }, + } + } + } + impl StatusBuilder { + /// Create a StatusBuilder object + /// + /// # Example + /// + /// ```rust,no_run + /// # use elefren::prelude::*; + /// # use elefren::status_builder::Visibility; + /// # fn main() -> Result<(), elefren::Error> { + /// # let data = Data { + /// # base: "".into(), + /// # client_id: "".into(), + /// # client_secret: "".into(), + /// # redirect: "".into(), + /// # token: "".into(), + /// # }; + /// # let client = Mastodon::from(data); + /// let status = StatusBuilder::new() + /// .status("a status") + /// .visibility(Visibility::Public) + /// .build()?; + /// client.new_status(status)?; + /// # Ok(()) + /// # } + /// ``` + pub fn new() -> StatusBuilder { StatusBuilder::default() } + /// Set the text for the post + /// + /// # Example + /// + /// ```rust + /// # use elefren::prelude::*; + /// # fn main() -> Result<(), elefren::Error> { + /// let status = StatusBuilder::new().status("awoooooo").build()?; + /// # Ok(()) + /// # } + /// ``` + pub fn status>(&mut self, status: I) -> &mut Self { + self.status = Some(status.into()); + self + } + /// Set the in_reply_to_id for the post + /// + /// # Example + /// + /// ```rust + /// # use elefren::prelude::*; + /// # fn main() -> Result<(), elefren::Error> { + /// let status = StatusBuilder::new() + /// .status("awooooo") + /// .in_reply_to("12345") + /// .build()?; + /// # Ok(()) + /// # } + /// ``` + pub fn in_reply_to>(&mut self, id: I) -> &mut Self { + self.in_reply_to_id = Some(id.into()); + self + } + /// Set the media_ids for the post + /// + /// # Example + /// + /// ```rust + /// # use elefren::prelude::*; + /// # fn main() -> Result<(), elefren::Error> { + /// let status = StatusBuilder::new().media_ids(&["foo", "bar"]).build()?; + /// # Ok(()) + /// # } + /// ``` + pub fn media_ids>(&mut self, ids: I) + -> &mut Self { + self.media_ids = + Some(ids.into_iter().map(|s| + s.to_string()).collect::>()); + self + } + /// Set the sensitive attribute for the post + /// + /// # Example + /// + /// ```rust + /// # use elefren::prelude::*; + /// # fn main() -> Result<(), elefren::Error> { + /// let status = StatusBuilder::new() + /// .media_ids(&["foo", "bar"]) + /// .sensitive(true) + /// .build()?; + /// # Ok(()) + /// # } + /// ``` + pub fn sensitive(&mut self, sensitive: bool) -> &mut Self { + self.sensitive = Some(sensitive); + self + } + /// Set the spoiler text/CW for the post + /// + /// # Example + /// + /// ```rust + /// # use elefren::prelude::*; + /// # fn main() -> Result<(), elefren::Error> { + /// let status = StatusBuilder::new() + /// .status("awoooo!!") + /// .spoiler_text("awoo inside") + /// .build()?; + /// # Ok(()) + /// # } + /// ``` + pub fn spoiler_text>(&mut self, spoiler_text: I) + -> &mut Self { + self.spoiler_text = Some(spoiler_text.into()); + self + } + /// Set the content type of the post + /// + /// This is a Pleroma and Glitch-soc extension of the API. + /// + /// # Possible values + /// - `text/plain` + /// - `text/html` + /// - `text/markdown` + /// - `text/bbcode` (Pleroma only) + /// + /// The set of supported content types may vary by server. + /// + /// # Example + /// + /// ```rust + /// # use elefren::prelude::*; + /// # fn main() -> Result<(), elefren::Error> { + /// let status = StatusBuilder::new() + /// .status("thicc") + /// .content_type("text/html") + /// .build()?; + /// # Ok(()) + /// # } + /// ``` + pub fn content_type>(&mut self, content_type: I) + -> &mut Self { + self.content_type = Some(content_type.into()); + self + } + /// Set the visibility for the post + /// + /// # Example + /// + /// ```rust + /// # use elefren::prelude::*; + /// # use elefren::status_builder::Visibility; + /// # fn main() -> Result<(), elefren::Error> { + /// let status = StatusBuilder::new() + /// .status("awooooooo") + /// .visibility(Visibility::Public) + /// .build()?; + /// # Ok(()) + /// # } + /// ``` + pub fn visibility(&mut self, visibility: Visibility) -> &mut Self { + self.visibility = Some(visibility); + self + } + /// Set the language for the post + /// + /// # Example + /// + /// ```rust + /// # use elefren::prelude::*; + /// # use elefren::Language; + /// # fn main() -> Result<(), elefren::Error> { + /// let status = StatusBuilder::new() + /// .status("awoo!!!!") + /// .language(Language::Eng) + /// .build()?; + /// # Ok(()) + /// # } + /// ``` + pub fn language(&mut self, language: Language) -> &mut Self { + self.language = Some(language); + self + } + /// Constructs a NewStatus + /// + /// # Example + /// + /// ```rust + /// # use elefren::prelude::*; + /// # fn main() -> Result<(), elefren::Error> { + /// let status = StatusBuilder::new().status("awoo!").build()?; + /// # Ok(()) + /// # } + /// ``` + pub fn build(&self) -> Result { + if self.status.is_none() && self.media_ids.is_none() { + return Err(crate::Error::Other("status text or media ids are required in order to post a status".to_string())); + } + Ok(NewStatus{status: self.status.clone(), + in_reply_to_id: self.in_reply_to_id.clone(), + media_ids: self.media_ids.clone(), + sensitive: self.sensitive.clone(), + spoiler_text: self.spoiler_text.clone(), + visibility: self.visibility.clone(), + language: self.language.clone(), + content_type: self.content_type.clone(),}) + } + } + /// Represents a post that can be sent to the POST /api/v1/status endpoint + pub struct NewStatus { + #[serde(skip_serializing_if = "Option::is_none")] + status: Option, + #[serde(skip_serializing_if = "Option::is_none")] + in_reply_to_id: Option, + #[serde(skip_serializing_if = "Option::is_none")] + media_ids: Option>, + #[serde(skip_serializing_if = "Option::is_none")] + sensitive: Option, + #[serde(skip_serializing_if = "Option::is_none")] + spoiler_text: Option, + #[serde(skip_serializing_if = "Option::is_none")] + visibility: Option, + #[serde(skip_serializing_if = "Option::is_none")] + language: Option, + #[serde(skip_serializing_if = "Option::is_none")] + content_type: Option, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for NewStatus { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + NewStatus { + status: ref __self_0_0, + in_reply_to_id: ref __self_0_1, + media_ids: ref __self_0_2, + sensitive: ref __self_0_3, + spoiler_text: ref __self_0_4, + visibility: ref __self_0_5, + language: ref __self_0_6, + content_type: ref __self_0_7 } => { + let mut debug_trait_builder = f.debug_struct("NewStatus"); + let _ = + debug_trait_builder.field("status", &&(*__self_0_0)); + let _ = + debug_trait_builder.field("in_reply_to_id", + &&(*__self_0_1)); + let _ = + debug_trait_builder.field("media_ids", + &&(*__self_0_2)); + let _ = + debug_trait_builder.field("sensitive", + &&(*__self_0_3)); + let _ = + debug_trait_builder.field("spoiler_text", + &&(*__self_0_4)); + let _ = + debug_trait_builder.field("visibility", + &&(*__self_0_5)); + let _ = + debug_trait_builder.field("language", + &&(*__self_0_6)); + let _ = + debug_trait_builder.field("content_type", + &&(*__self_0_7)); + debug_trait_builder.finish() + } + } + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::default::Default for NewStatus { + #[inline] + fn default() -> NewStatus { + NewStatus{status: ::core::default::Default::default(), + in_reply_to_id: ::core::default::Default::default(), + media_ids: ::core::default::Default::default(), + sensitive: ::core::default::Default::default(), + spoiler_text: ::core::default::Default::default(), + visibility: ::core::default::Default::default(), + language: ::core::default::Default::default(), + content_type: ::core::default::Default::default(),} + } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for NewStatus { + #[inline] + fn clone(&self) -> NewStatus { + match *self { + NewStatus { + status: ref __self_0_0, + in_reply_to_id: ref __self_0_1, + media_ids: ref __self_0_2, + sensitive: ref __self_0_3, + spoiler_text: ref __self_0_4, + visibility: ref __self_0_5, + language: ref __self_0_6, + content_type: ref __self_0_7 } => + NewStatus{status: ::core::clone::Clone::clone(&(*__self_0_0)), + in_reply_to_id: + ::core::clone::Clone::clone(&(*__self_0_1)), + media_ids: + ::core::clone::Clone::clone(&(*__self_0_2)), + sensitive: + ::core::clone::Clone::clone(&(*__self_0_3)), + spoiler_text: + ::core::clone::Clone::clone(&(*__self_0_4)), + visibility: + ::core::clone::Clone::clone(&(*__self_0_5)), + language: + ::core::clone::Clone::clone(&(*__self_0_6)), + content_type: + ::core::clone::Clone::clone(&(*__self_0_7)),}, + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _IMPL_SERIALIZE_FOR_NewStatus: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl _serde::Serialize for NewStatus { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "NewStatus", + false as + usize + + if Option::is_none(&self.status) + { + 0 + } else { + 1 + } + + if Option::is_none(&self.in_reply_to_id) + { + 0 + } else { + 1 + } + + if Option::is_none(&self.media_ids) + { + 0 + } else { + 1 + } + + if Option::is_none(&self.sensitive) + { + 0 + } else { + 1 + } + + if Option::is_none(&self.spoiler_text) + { + 0 + } else { + 1 + } + + if Option::is_none(&self.visibility) + { + 0 + } else { + 1 + } + + if Option::is_none(&self.language) + { + 0 + } else { + 1 + } + + if Option::is_none(&self.content_type) + { + 0 + } else { + 1 + }) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + if !Option::is_none(&self.status) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "status", + &self.status) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "status") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + if !Option::is_none(&self.in_reply_to_id) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "in_reply_to_id", + &self.in_reply_to_id) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "in_reply_to_id") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + if !Option::is_none(&self.media_ids) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "media_ids", + &self.media_ids) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "media_ids") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + if !Option::is_none(&self.sensitive) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "sensitive", + &self.sensitive) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "sensitive") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + if !Option::is_none(&self.spoiler_text) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "spoiler_text", + &self.spoiler_text) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "spoiler_text") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + if !Option::is_none(&self.visibility) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "visibility", + &self.visibility) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "visibility") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + if !Option::is_none(&self.language) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "language", + &self.language) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "language") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + if !Option::is_none(&self.content_type) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "content_type", + &self.content_type) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "content_type") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::marker::StructuralPartialEq for NewStatus { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for NewStatus { + #[inline] + fn eq(&self, other: &NewStatus) -> bool { + match *other { + NewStatus { + status: ref __self_1_0, + in_reply_to_id: ref __self_1_1, + media_ids: ref __self_1_2, + sensitive: ref __self_1_3, + spoiler_text: ref __self_1_4, + visibility: ref __self_1_5, + language: ref __self_1_6, + content_type: ref __self_1_7 } => + match *self { + NewStatus { + status: ref __self_0_0, + in_reply_to_id: ref __self_0_1, + media_ids: ref __self_0_2, + sensitive: ref __self_0_3, + spoiler_text: ref __self_0_4, + visibility: ref __self_0_5, + language: ref __self_0_6, + content_type: ref __self_0_7 } => + (*__self_0_0) == (*__self_1_0) && + (*__self_0_1) == (*__self_1_1) && + (*__self_0_2) == (*__self_1_2) && + (*__self_0_3) == (*__self_1_3) && + (*__self_0_4) == (*__self_1_4) && + (*__self_0_5) == (*__self_1_5) && + (*__self_0_6) == (*__self_1_6) && + (*__self_0_7) == (*__self_1_7), + }, + } + } + #[inline] + fn ne(&self, other: &NewStatus) -> bool { + match *other { + NewStatus { + status: ref __self_1_0, + in_reply_to_id: ref __self_1_1, + media_ids: ref __self_1_2, + sensitive: ref __self_1_3, + spoiler_text: ref __self_1_4, + visibility: ref __self_1_5, + language: ref __self_1_6, + content_type: ref __self_1_7 } => + match *self { + NewStatus { + status: ref __self_0_0, + in_reply_to_id: ref __self_0_1, + media_ids: ref __self_0_2, + sensitive: ref __self_0_3, + spoiler_text: ref __self_0_4, + visibility: ref __self_0_5, + language: ref __self_0_6, + content_type: ref __self_0_7 } => + (*__self_0_0) != (*__self_1_0) || + (*__self_0_1) != (*__self_1_1) || + (*__self_0_2) != (*__self_1_2) || + (*__self_0_3) != (*__self_1_3) || + (*__self_0_4) != (*__self_1_4) || + (*__self_0_5) != (*__self_1_5) || + (*__self_0_6) != (*__self_1_6) || + (*__self_0_7) != (*__self_1_7), + }, + } + } + } + /// The visibility of a status. + #[serde(rename_all = "lowercase")] + pub enum Visibility { + + /// A Direct message to a user + Direct, + + /// Only available to followers + Private, + + /// Not shown in public timelines + Unlisted, + + /// Posted to public timelines + Public, + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::clone::Clone for Visibility { + #[inline] + fn clone(&self) -> Visibility { { *self } } + } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::marker::Copy for Visibility { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::fmt::Debug for Visibility { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match (&*self,) { + (&Visibility::Direct,) => { + let mut debug_trait_builder = f.debug_tuple("Direct"); + debug_trait_builder.finish() + } + (&Visibility::Private,) => { + let mut debug_trait_builder = f.debug_tuple("Private"); + debug_trait_builder.finish() + } + (&Visibility::Unlisted,) => { + let mut debug_trait_builder = f.debug_tuple("Unlisted"); + debug_trait_builder.finish() + } + (&Visibility::Public,) => { + let mut debug_trait_builder = f.debug_tuple("Public"); + debug_trait_builder.finish() + } + } + } + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _IMPL_DESERIALIZE_FOR_Visibility: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'de> _serde::Deserialize<'de> for Visibility { + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + #[allow(non_camel_case_types)] + enum __Field { __field0, __field1, __field2, __field3, } + struct __FieldVisitor; + impl <'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "variant identifier") + } + fn visit_u64<__E>(self, __value: u64) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + 0u64 => _serde::export::Ok(__Field::__field0), + 1u64 => _serde::export::Ok(__Field::__field1), + 2u64 => _serde::export::Ok(__Field::__field2), + 3u64 => _serde::export::Ok(__Field::__field3), + _ => + _serde::export::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 4")), + } + } + fn visit_str<__E>(self, __value: &str) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + "direct" => + _serde::export::Ok(__Field::__field0), + "private" => + _serde::export::Ok(__Field::__field1), + "unlisted" => + _serde::export::Ok(__Field::__field2), + "public" => + _serde::export::Ok(__Field::__field3), + _ => { + _serde::export::Err(_serde::de::Error::unknown_variant(__value, + VARIANTS)) + } + } + } + fn visit_bytes<__E>(self, __value: &[u8]) + -> _serde::export::Result where + __E: _serde::de::Error { + match __value { + b"direct" => + _serde::export::Ok(__Field::__field0), + b"private" => + _serde::export::Ok(__Field::__field1), + b"unlisted" => + _serde::export::Ok(__Field::__field2), + b"public" => + _serde::export::Ok(__Field::__field3), + _ => { + let __value = + &_serde::export::from_utf8_lossy(__value); + _serde::export::Err(_serde::de::Error::unknown_variant(__value, + VARIANTS)) + } + } + } + } + impl <'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) + -> _serde::export::Result where + __D: _serde::Deserializer<'de> { + _serde::Deserializer::deserialize_identifier(__deserializer, + __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl <'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Visibility; + fn expecting(&self, + __formatter: + &mut _serde::export::Formatter) + -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, + "enum Visibility") + } + fn visit_enum<__A>(self, __data: __A) + -> _serde::export::Result + where __A: _serde::de::EnumAccess<'de> { + match match _serde::de::EnumAccess::variant(__data) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + (__Field::__field0, __variant) => { + match _serde::de::VariantAccess::unit_variant(__variant) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::export::Ok(Visibility::Direct) + } + (__Field::__field1, __variant) => { + match _serde::de::VariantAccess::unit_variant(__variant) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::export::Ok(Visibility::Private) + } + (__Field::__field2, __variant) => { + match _serde::de::VariantAccess::unit_variant(__variant) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::export::Ok(Visibility::Unlisted) + } + (__Field::__field3, __variant) => { + match _serde::de::VariantAccess::unit_variant(__variant) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::export::Ok(Visibility::Public) + } + } + } + } + const VARIANTS: &'static [&'static str] = + &["direct", "private", "unlisted", "public"]; + _serde::Deserializer::deserialize_enum(__deserializer, + "Visibility", + VARIANTS, + __Visitor{marker: + _serde::export::PhantomData::, + lifetime: + _serde::export::PhantomData,}) + } + } + }; + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _IMPL_SERIALIZE_FOR_Visibility: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl _serde::Serialize for Visibility { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + match *self { + Visibility::Direct => + _serde::Serializer::serialize_unit_variant(__serializer, + "Visibility", + 0u32, + "direct"), + Visibility::Private => + _serde::Serializer::serialize_unit_variant(__serializer, + "Visibility", + 1u32, + "private"), + Visibility::Unlisted => + _serde::Serializer::serialize_unit_variant(__serializer, + "Visibility", + 2u32, + "unlisted"), + Visibility::Public => + _serde::Serializer::serialize_unit_variant(__serializer, + "Visibility", + 3u32, + "public"), + } + } + } + }; + impl ::core::marker::StructuralPartialEq for Visibility { } + #[automatically_derived] + #[allow(unused_qualifications)] + impl ::core::cmp::PartialEq for Visibility { + #[inline] + fn eq(&self, other: &Visibility) -> bool { + { + let __self_vi = + unsafe { ::core::intrinsics::discriminant_value(&*self) }; + let __arg_1_vi = + unsafe { + ::core::intrinsics::discriminant_value(&*other) + }; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { _ => true, } + } else { false } + } + } + } + impl Default for Visibility { + fn default() -> Self { Visibility::Public } + } +} +#[macro_use] +mod macros { + macro_rules! methods { + ($ ($ method : ident,) +) => + { + $ + (fn $ method < T : for < 'de > serde :: Deserialize < 'de >> + (& self, url : String) -> Result < T > + { + let response = self . send(self . client . $ method(& url)) ? + ; deserialise(response) + }) + + } ; + } + macro_rules! paged_routes { + (($ method : ident) $ name : ident : $ url : expr => $ ret : ty, $ + ($ rest : tt) *) => + { + doc_comment ! + { + concat ! + ("Equivalent to `", stringify ! ($ method), " /api/v1/", $ + url, "`\n# Errors\nIf `access_token` is not set.", "\n", + "```no_run", "# extern crate elefren;\n", + "# use elefren::prelude::*;\n", + "# fn main() -> Result<(), Box<::std::error::Error>> {\n", + "# let data = Data {\n", + "# base: \"https://example.com\".into(),\n", + "# client_id: \"taosuah\".into(),\n", + "# client_secret: \"htnjdiuae\".into(),\n", + "# redirect: \"https://example.com\".into(),\n", + "# token: \"tsaohueaheis\".into(),\n", "# };\n", + "let client = Mastodon::from(data);\n", "client.", stringify + ! ($ name), "();\n", "# Ok(())\n", "# }\n", "```"), async + fn $ name(& self) -> Result < Page < '_, $ ret >> + { + let url = self . route(concat ! ("/api/v1/", $ url)) ; let + response = self . send(self . client . $ method(& url)) ? + ; Page :: new(self, response) + } + } paged_routes ! { $ ($ rest) * } + } ; + ((get($ ($ (# [$ m : meta]) * $ param : ident : $ typ : ty,) *)) $ + name : ident : $ url : expr => $ ret : ty, $ ($ rest : tt) *) => + { + doc_comment ! + { + concat ! + ("Equivalent to `get /api/v1/", $ url, + "`\n# Errors\nIf `access_token` is not set."), async fn $ + name < 'a > (& self, $ ($ param : $ typ,) *) -> Result < Page + < '_, $ ret >> + { + use serde_urlencoded ; # [derive(Serialize)] struct Data < + 'a > + { + $ ($ (# [$ m]) * $ param : $ typ,) * # [serde(skip)] + _marker : :: std :: marker :: PhantomData < & 'a () >, + } let qs_data = Data + { + $ ($ param : $ param,) * _marker : :: std :: marker :: + PhantomData, + } ; let qs = serde_urlencoded :: to_string(& qs_data) ? ; + let url = format ! + (concat ! ("/api/v1/", $ url, "?{}"), & qs) ; let response + = self . send(self . client . get(& url)) ? ; Page :: + new(self, response) + } + } paged_routes ! { $ ($ rest) * } + } ; () => { } + } + macro_rules! route_v2 { + ((get($ ($ param : ident : $ typ : ty,) *)) $ name : ident : $ url : + expr => $ ret : ty, $ ($ rest : tt) *) => + { + doc_comment ! + { + concat ! + ("Equivalent to `get /api/v2/", $ url, + "`\n# Errors\nIf `access_token` is not set."), fn $ name < 'a + > (& self, $ ($ param : $ typ,) *) -> Result < $ ret > + { + use serde_urlencoded ; # [derive(Serialize)] struct Data < + 'a > + { + $ ($ param : $ typ,) * # [serde(skip)] _marker : :: + std :: marker :: PhantomData < & 'a () >, + } let qs_data = Data + { + $ ($ param : $ param,) * _marker : :: std :: marker :: + PhantomData, + } ; let qs = serde_urlencoded :: to_string(& qs_data) ? ; + let url = format ! + (concat ! ("/api/v2/", $ url, "?{}"), & qs) ; + Ok(self . get(self . route(& url)) ?) + } + } route_v2 ! { $ ($ rest) * } + } ; () => { } + } + macro_rules! route { + ((post multipart($ ($ param : ident : $ typ : ty,) *)) $ name : ident + : $ url : expr => $ ret : ty, $ ($ rest : tt) *) => + { + doc_comment ! + { + concat ! + ("Equivalent to `post /api/v1/", $ url, + "`\n# Errors\nIf `access_token` is not set."), fn $ + name(& self, $ ($ param : $ typ,) *) -> Result < $ ret > + { + use reqwest :: multipart :: Form ; let form_data = Form :: + new() $ + (. file(stringify ! ($ param), $ param . as_ref()) ?) * ; + let response = self . + send(self . client . + post(& self . route(concat ! ("/api/v1/", $ url))) . + multipart(form_data)) ? ; let status = response . + status() . clone() ; if status . is_client_error() + { return Err(Error :: Client(status)) ; } else if status . + is_server_error() + { return Err(Error :: Server(status)) ; } + deserialise(response) + } + } route ! { $ ($ rest) * } + } ; + ((get($ ($ param : ident : $ typ : ty,) *)) $ name : ident : $ url : + expr => $ ret : ty, $ ($ rest : tt) *) => + { + doc_comment ! + { + concat ! + ("Equivalent to `get /api/v1/", $ url, + "`\n# Errors\nIf `access_token` is not set."), fn $ name < 'a + > (& self, $ ($ param : $ typ,) *) -> Result < $ ret > + { + use serde_urlencoded ; # [derive(Serialize)] struct Data < + 'a > + { + $ ($ param : $ typ,) * # [serde(skip)] _marker : :: + std :: marker :: PhantomData < & 'a () >, + } let qs_data = Data + { + $ ($ param : $ param,) * _marker : :: std :: marker :: + PhantomData, + } ; let qs = serde_urlencoded :: to_string(& qs_data) ? ; + let url = format ! + (concat ! ("/api/v1/", $ url, "?{}"), & qs) ; + Ok(self . get(self . route(& url)) ?) + } + } route ! { $ ($ rest) * } + } ; + (($ method : ident($ ($ param : ident : $ typ : ty,) *)) $ name : + ident : $ url : expr => $ ret : ty, $ ($ rest : tt) *) => + { + doc_comment ! + { + concat ! + ("Equivalent to `", stringify ! ($ method), " /api/v1/", $ + url, "`\n# Errors\nIf `access_token` is not set.",), fn $ + name(& self, $ ($ param : $ typ,) *) -> Result < $ ret > + { + let form_data = json ! + ({ $ (stringify ! ($ param) : $ param,) * }) ; let + response = self . + send(self . client . $ + method(& self . route(concat ! ("/api/v1/", $ url))) + . json(& form_data)) ? ; let status = response . + status() . clone() ; if status . is_client_error() + { return Err(Error :: Client(status)) ; } else if status . + is_server_error() + { return Err(Error :: Server(status)) ; } + deserialise(response) + } + } route ! { $ ($ rest) * } + } ; + (($ method : ident) $ name : ident : $ url : expr => $ ret : ty, $ + ($ rest : tt) *) => + { + doc_comment ! + { + concat ! + ("Equivalent to `", stringify ! ($ method), " /api/v1/", $ + url, "`\n# Errors\nIf `access_token` is not set.", "\n", + "```no_run", "# extern crate elefren;\n", + "# use elefren::prelude::*;\n", + "# fn main() -> Result<(), Box<::std::error::Error>> {\n", + "# let data = Data {\n", + "# base: \"https://example.com\".into(),\n", + "# client_id: \"taosuah\".into(),\n", + "# client_secret: \"htnjdiuae\".into(),\n", + "# redirect: \"https://example.com\".into(),\n", + "# token: \"tsaohueaheis\".into(),\n", "# };\n", + "let client = Mastodon::from(data);\n", "client.", stringify + ! ($ name), "();\n", "# Ok(())\n", "# }\n", "```"), fn $ + name(& self) -> Result < $ ret > + { + self . $ + method(self . route(concat ! ("/api/v1/", $ url))) + } + } route ! { $ ($ rest) * } + } ; () => { } + } + macro_rules! route_id { + ($ (($ method : ident) $ name : ident : $ url : expr => $ ret : ty,) + *) => + { + $ + (doc_comment ! + { + concat ! + ("Equivalent to `", stringify ! ($ method), " /api/v1/", $ + url, "`\n# Errors\nIf `access_token` is not set.", "\n", + "```no_run", "# extern crate elefren;\n", + "# use elefren::prelude::*;\n", + "# fn main() -> Result<(), Box<::std::error::Error>> {\n", + "# let data = Data {\n", + "# base: \"https://example.com\".into(),\n", + "# client_id: \"taosuah\".into(),\n", + "# client_secret: \"htnjdiuae\".into(),\n", + "# redirect: \"https://example.com\".into(),\n", + "# token: \"tsaohueaheis\".into(),\n", "# };\n", + "let client = Mastodon::from(data);\n", "client.", stringify + ! ($ name), "(\"42\");\n", "# Ok(())\n", "# }\n", "```"), + fn $ name(& self, id : & str) -> Result < $ ret > + { + self . $ + method(self . + route(& format ! + (concat ! ("/api/v1/", $ url), id))) + } + }) * + } + } + macro_rules! paged_routes_with_id { + (($ method : ident) $ name : ident : $ url : expr => $ ret : ty, $ + ($ rest : tt) *) => + { + doc_comment ! + { + concat ! + ("Equivalent to `", stringify ! ($ method), " /api/v1/", $ + url, "`\n# Errors\nIf `access_token` is not set.", "\n", + "```no_run", "# extern crate elefren;\n", + "# use elefren::prelude::*;\n", + "# fn main() -> Result<(), Box<::std::error::Error>> {\n", + "# let data = Data {\n", + "# base: \"https://example.com\".into(),\n", + "# client_id: \"taosuah\".into(),\n", + "# client_secret: \"htnjdiuae\".into(),\n", + "# redirect: \"https://example.com\".into(),\n", + "# token: \"tsaohueaheis\".into(),\n", "# };\n", + "let client = Mastodon::from(data);\n", "client.", stringify + ! ($ name), "(\"some-id\");\n", "# Ok(())\n", "# }\n", + "```"), fn $ name(& self, id : & str) -> Result < Page < $ + ret >> + { + let url = self . + route(& format ! (concat ! ("/api/v1/", $ url), id)) ; let + response = self . send(self . client . $ method(& url)) ? + ; Page :: new(self, response) + } + } paged_routes_with_id ! { $ ($ rest) * } + } ; () => { } + } +} +/// Automatically import the things you need +pub mod prelude { + pub use crate::scopes::Scopes; + pub use crate::Data; + pub use crate::Mastodon; + pub use crate::MastodonClient; + pub use crate::NewStatus; + pub use crate::Registration; + pub use crate::StatusBuilder; + pub use crate::StatusesRequest; +} +/// Your mastodon application client, handles all requests to and from Mastodon. +pub struct Mastodon { + client: Client, + /// Raw data about your mastodon instance. + pub data: Data, +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Mastodon { + #[inline] + fn clone(&self) -> Mastodon { + match *self { + Mastodon { client: ref __self_0_0, data: ref __self_0_1 } => + Mastodon{client: ::core::clone::Clone::clone(&(*__self_0_0)), + data: ::core::clone::Clone::clone(&(*__self_0_1)),}, + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Mastodon { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + Mastodon { client: ref __self_0_0, data: ref __self_0_1 } => { + let mut debug_trait_builder = f.debug_struct("Mastodon"); + let _ = debug_trait_builder.field("client", &&(*__self_0_0)); + let _ = debug_trait_builder.field("data", &&(*__self_0_1)); + debug_trait_builder.finish() + } + } + } +} +impl Mastodon { + fn get serde::Deserialize<'de>>(&self, url: String) + -> Result { + let response = self.send(self.client.get(&url))?; + deserialise(response) + } + fn post serde::Deserialize<'de>>(&self, url: String) + -> Result { + let response = self.send(self.client.post(&url))?; + deserialise(response) + } + fn delete serde::Deserialize<'de>>(&self, url: String) + -> Result { + let response = self.send(self.client.delete(&url))?; + deserialise(response) + } + fn route(&self, url: &str) -> String { + { + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["", ""], + &match (&self.base, + &url) + { + (arg0, + arg1) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt), + ::core::fmt::ArgumentV1::new(arg1, + ::core::fmt::Display::fmt)], + })); + res + } + } + pub(crate) fn send(&self, req: RequestBuilder) -> Result { + let req = req.bearer_auth(&self.token).build()?; + Ok(self.client.execute(req)?) + } +} +impl From for Mastodon { + /// Creates a mastodon instance from the data struct. + fn from(data: Data) -> Mastodon { + let mut builder = MastodonBuilder::new(); + builder.data(data); + builder.build().expect("We know `data` is present, so this should be fine") + } +} +impl MastodonClient for Mastodon { + #[doc = + "Equivalent to `get /api/v1/favourites`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.favourites();\n# Ok(())\n# }\n```"] + async fn favourites(&self) -> Result> { + let url = self.route("/api/v1/favourites"); + let response = self.send(self.client.get(&url))?; + Page::new(self, response) + } + #[doc = + "Equivalent to `get /api/v1/blocks`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.blocks();\n# Ok(())\n# }\n```"] + async fn blocks(&self) -> Result> { + let url = self.route("/api/v1/blocks"); + let response = self.send(self.client.get(&url))?; + Page::new(self, response) + } + #[doc = + "Equivalent to `get /api/v1/domain_blocks`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.domain_blocks();\n# Ok(())\n# }\n```"] + async fn domain_blocks(&self) -> Result> { + let url = self.route("/api/v1/domain_blocks"); + let response = self.send(self.client.get(&url))?; + Page::new(self, response) + } + #[doc = + "Equivalent to `get /api/v1/follow_requests`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.follow_requests();\n# Ok(())\n# }\n```"] + async fn follow_requests(&self) -> Result> { + let url = self.route("/api/v1/follow_requests"); + let response = self.send(self.client.get(&url))?; + Page::new(self, response) + } + #[doc = + "Equivalent to `get /api/v1/timelines/home`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_home_timeline();\n# Ok(())\n# }\n```"] + async fn get_home_timeline(&self) -> Result> { + let url = self.route("/api/v1/timelines/home"); + let response = self.send(self.client.get(&url))?; + Page::new(self, response) + } + #[doc = + "Equivalent to `get /api/v1/custom_emojis`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_emojis();\n# Ok(())\n# }\n```"] + async fn get_emojis(&self) -> Result> { + let url = self.route("/api/v1/custom_emojis"); + let response = self.send(self.client.get(&url))?; + Page::new(self, response) + } + #[doc = + "Equivalent to `get /api/v1/mutes`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.mutes();\n# Ok(())\n# }\n```"] + async fn mutes(&self) -> Result> { + let url = self.route("/api/v1/mutes"); + let response = self.send(self.client.get(&url))?; + Page::new(self, response) + } + #[doc = + "Equivalent to `get /api/v1/notifications`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.notifications();\n# Ok(())\n# }\n```"] + async fn notifications(&self) -> Result> { + let url = self.route("/api/v1/notifications"); + let response = self.send(self.client.get(&url))?; + Page::new(self, response) + } + #[doc = + "Equivalent to `get /api/v1/reports`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.reports();\n# Ok(())\n# }\n```"] + async fn reports(&self) -> Result> { + let url = self.route("/api/v1/reports"); + let response = self.send(self.client.get(&url))?; + Page::new(self, response) + } + #[doc = + "Equivalent to `get /api/v1/accounts/search`\n# Errors\nIf `access_token` is not set."] + async fn search_accounts<'a>(&self, q: &'a str, limit: Option, + following: bool) + -> Result> { + use serde_urlencoded; + struct Data<'a> { + q: &'a str, + #[serde(skip_serializing_if = "Option::is_none")] + limit: Option, + following: bool, + #[serde(skip)] + _marker: ::std::marker::PhantomData<&'a ()>, + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_SERIALIZE_FOR_Data: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'a> _serde::Serialize for Data<'a> { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "Data", + false + as + usize + + 1 + + + if Option::is_none(&self.limit) + { + 0 + } else { + 1 + } + + 1) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "q", + &self.q) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + if !Option::is_none(&self.limit) { + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "limit", + &self.limit) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } else { + match _serde::ser::SerializeStruct::skip_field(&mut __serde_state, + "limit") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "following", + &self.following) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + let qs_data = + Data{q: q, + limit: limit, + following: following, + _marker: ::std::marker::PhantomData,}; + let qs = serde_urlencoded::to_string(&qs_data)?; + let url = + { + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/search?"], + &match (&&qs,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + }; + let response = self.send(self.client.get(&url))?; + Page::new(self, response) + } + #[doc = + "Equivalent to `get /api/v1/endorsements`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_endorsements();\n# Ok(())\n# }\n```"] + async fn get_endorsements(&self) -> Result> { + let url = self.route("/api/v1/endorsements"); + let response = self.send(self.client.get(&url))?; + Page::new(self, response) + } + #[doc = + "Equivalent to `get /api/v1/accounts/{}/followers`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.followers(\"some-id\");\n# Ok(())\n# }\n```"] + fn followers(&self, id: &str) -> Result> { + let url = + self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/", + "/followers"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + }); + let response = self.send(self.client.get(&url))?; + Page::new(self, response) + } + #[doc = + "Equivalent to `get /api/v1/accounts/{}/following`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.following(\"some-id\");\n# Ok(())\n# }\n```"] + fn following(&self, id: &str) -> Result> { + let url = + self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/", + "/following"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + }); + let response = self.send(self.client.get(&url))?; + Page::new(self, response) + } + #[doc = + "Equivalent to `get /api/v1/statuses/{}/reblogged_by`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.reblogged_by(\"some-id\");\n# Ok(())\n# }\n```"] + fn reblogged_by(&self, id: &str) -> Result> { + let url = + self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/statuses/", + "/reblogged_by"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + }); + let response = self.send(self.client.get(&url))?; + Page::new(self, response) + } + #[doc = + "Equivalent to `get /api/v1/statuses/{}/favourited_by`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.favourited_by(\"some-id\");\n# Ok(())\n# }\n```"] + fn favourited_by(&self, id: &str) -> Result> { + let url = + self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/statuses/", + "/favourited_by"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + }); + let response = self.send(self.client.get(&url))?; + Page::new(self, response) + } + #[doc = + "Equivalent to `delete /api/v1/domain_blocks`\n# Errors\nIf `access_token` is not set."] + fn unblock_domain(&self, domain: String) -> Result { + let form_data = + ::serde_json::Value::Object({ + let mut object = + ::serde_json::Map::new(); + let _ = + object.insert(("domain").into(), + ::serde_json::to_value(&domain).unwrap()); + object + }); + let response = + self.send(self.client.delete(&self.route("/api/v1/domain_blocks")).json(&form_data))?; + let status = response.status().clone(); + if status.is_client_error() { + return Err(Error::Client(status)); + } else if status.is_server_error() { + return Err(Error::Server(status)); + } + deserialise(response) + } + #[doc = + "Equivalent to `get /api/v1/instance`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.instance();\n# Ok(())\n# }\n```"] + fn instance(&self) -> Result { + self.get(self.route("/api/v1/instance")) + } + #[doc = + "Equivalent to `get /api/v1/accounts/verify_credentials`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.verify_credentials();\n# Ok(())\n# }\n```"] + fn verify_credentials(&self) -> Result { + self.get(self.route("/api/v1/accounts/verify_credentials")) + } + #[doc = + "Equivalent to `post /api/v1/reports`\n# Errors\nIf `access_token` is not set."] + fn report(&self, account_id: &str, status_ids: Vec<&str>, comment: String) + -> Result { + let form_data = + ::serde_json::Value::Object({ + let mut object = + ::serde_json::Map::new(); + let _ = + object.insert(("account_id").into(), + ::serde_json::to_value(&account_id).unwrap()); + let _ = + object.insert(("status_ids").into(), + ::serde_json::to_value(&status_ids).unwrap()); + let _ = + object.insert(("comment").into(), + ::serde_json::to_value(&comment).unwrap()); + object + }); + let response = + self.send(self.client.post(&self.route("/api/v1/reports")).json(&form_data))?; + let status = response.status().clone(); + if status.is_client_error() { + return Err(Error::Client(status)); + } else if status.is_server_error() { + return Err(Error::Server(status)); + } + deserialise(response) + } + #[doc = + "Equivalent to `post /api/v1/domain_blocks`\n# Errors\nIf `access_token` is not set."] + fn block_domain(&self, domain: String) -> Result { + let form_data = + ::serde_json::Value::Object({ + let mut object = + ::serde_json::Map::new(); + let _ = + object.insert(("domain").into(), + ::serde_json::to_value(&domain).unwrap()); + object + }); + let response = + self.send(self.client.post(&self.route("/api/v1/domain_blocks")).json(&form_data))?; + let status = response.status().clone(); + if status.is_client_error() { + return Err(Error::Client(status)); + } else if status.is_server_error() { + return Err(Error::Server(status)); + } + deserialise(response) + } + #[doc = + "Equivalent to `post /api/v1/accounts/follow_requests/authorize`\n# Errors\nIf `access_token` is not set."] + fn authorize_follow_request(&self, id: &str) -> Result { + let form_data = + ::serde_json::Value::Object({ + let mut object = + ::serde_json::Map::new(); + let _ = + object.insert(("id").into(), + ::serde_json::to_value(&id).unwrap()); + object + }); + let response = + self.send(self.client.post(&self.route("/api/v1/accounts/follow_requests/authorize")).json(&form_data))?; + let status = response.status().clone(); + if status.is_client_error() { + return Err(Error::Client(status)); + } else if status.is_server_error() { + return Err(Error::Server(status)); + } + deserialise(response) + } + #[doc = + "Equivalent to `post /api/v1/accounts/follow_requests/reject`\n# Errors\nIf `access_token` is not set."] + fn reject_follow_request(&self, id: &str) -> Result { + let form_data = + ::serde_json::Value::Object({ + let mut object = + ::serde_json::Map::new(); + let _ = + object.insert(("id").into(), + ::serde_json::to_value(&id).unwrap()); + object + }); + let response = + self.send(self.client.post(&self.route("/api/v1/accounts/follow_requests/reject")).json(&form_data))?; + let status = response.status().clone(); + if status.is_client_error() { + return Err(Error::Client(status)); + } else if status.is_server_error() { + return Err(Error::Server(status)); + } + deserialise(response) + } + #[doc = + "Equivalent to `get /api/v1/search`\n# Errors\nIf `access_token` is not set."] + fn search<'a>(&self, q: &'a str, resolve: bool) -> Result { + use serde_urlencoded; + struct Data<'a> { + q: &'a str, + resolve: bool, + #[serde(skip)] + _marker: ::std::marker::PhantomData<&'a ()>, + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_SERIALIZE_FOR_Data: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'a> _serde::Serialize for Data<'a> { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "Data", + false + as + usize + + 1 + + + 1) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "q", + &self.q) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "resolve", + &self.resolve) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + let qs_data = + Data{q: q, + resolve: resolve, + _marker: ::std::marker::PhantomData,}; + let qs = serde_urlencoded::to_string(&qs_data)?; + let url = + { + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/search?"], + &match (&&qs,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + }; + Ok(self.get(self.route(&url))?) + } + #[doc = + "Equivalent to `get /api/v1/timelines/public`\n# Errors\nIf `access_token` is not set."] + fn get_public_timeline<'a>(&self, local: bool) -> Result> { + use serde_urlencoded; + struct Data<'a> { + local: bool, + #[serde(skip)] + _marker: ::std::marker::PhantomData<&'a ()>, + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_SERIALIZE_FOR_Data: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'a> _serde::Serialize for Data<'a> { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "Data", + false + as + usize + + + 1) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "local", + &self.local) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + let qs_data = + Data{local: local, _marker: ::std::marker::PhantomData,}; + let qs = serde_urlencoded::to_string(&qs_data)?; + let url = + { + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/timelines/public?"], + &match (&&qs,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + }; + Ok(self.get(self.route(&url))?) + } + #[doc = + "Equivalent to `post /api/v1/follows`\n# Errors\nIf `access_token` is not set."] + fn follows(&self, uri: Cow<'static, str>) -> Result { + let form_data = + ::serde_json::Value::Object({ + let mut object = + ::serde_json::Map::new(); + let _ = + object.insert(("uri").into(), + ::serde_json::to_value(&uri).unwrap()); + object + }); + let response = + self.send(self.client.post(&self.route("/api/v1/follows")).json(&form_data))?; + let status = response.status().clone(); + if status.is_client_error() { + return Err(Error::Client(status)); + } else if status.is_server_error() { + return Err(Error::Server(status)); + } + deserialise(response) + } + #[doc = + "Equivalent to `post /api/v1/media`\n# Errors\nIf `access_token` is not set."] + fn media(&self, file: Cow<'static, str>) -> Result { + use reqwest::multipart::Form; + let form_data = Form::new().file("file", file.as_ref())?; + let response = + self.send(self.client.post(&self.route("/api/v1/media")).multipart(form_data))?; + let status = response.status().clone(); + if status.is_client_error() { + return Err(Error::Client(status)); + } else if status.is_server_error() { + return Err(Error::Server(status)); + } + deserialise(response) + } + #[doc = + "Equivalent to `post /api/v1/notifications/clear`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.clear_notifications();\n# Ok(())\n# }\n```"] + fn clear_notifications(&self) -> Result { + self.post(self.route("/api/v1/notifications/clear")) + } + #[doc = + "Equivalent to `post /api/v1/notifications/dismiss`\n# Errors\nIf `access_token` is not set."] + fn dismiss_notification(&self, id: &str) -> Result { + let form_data = + ::serde_json::Value::Object({ + let mut object = + ::serde_json::Map::new(); + let _ = + object.insert(("id").into(), + ::serde_json::to_value(&id).unwrap()); + object + }); + let response = + self.send(self.client.post(&self.route("/api/v1/notifications/dismiss")).json(&form_data))?; + let status = response.status().clone(); + if status.is_client_error() { + return Err(Error::Client(status)); + } else if status.is_server_error() { + return Err(Error::Server(status)); + } + deserialise(response) + } + #[doc = + "Equivalent to `get /api/v1/push/subscription`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_push_subscription();\n# Ok(())\n# }\n```"] + fn get_push_subscription(&self) -> Result { + self.get(self.route("/api/v1/push/subscription")) + } + #[doc = + "Equivalent to `delete /api/v1/push/subscription`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.delete_push_subscription();\n# Ok(())\n# }\n```"] + fn delete_push_subscription(&self) -> Result { + self.delete(self.route("/api/v1/push/subscription")) + } + #[doc = + "Equivalent to `get /api/v1/filters`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_filters();\n# Ok(())\n# }\n```"] + fn get_filters(&self) -> Result> { + self.get(self.route("/api/v1/filters")) + } + #[doc = + "Equivalent to `get /api/v1/suggestions`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_follow_suggestions();\n# Ok(())\n# }\n```"] + fn get_follow_suggestions(&self) -> Result> { + self.get(self.route("/api/v1/suggestions")) + } + #[doc = + "Equivalent to `get /api/v2/search`\n# Errors\nIf `access_token` is not set."] + fn search_v2<'a>(&self, q: &'a str, resolve: bool) + -> Result { + use serde_urlencoded; + struct Data<'a> { + q: &'a str, + resolve: bool, + #[serde(skip)] + _marker: ::std::marker::PhantomData<&'a ()>, + } + #[doc(hidden)] + #[allow(non_upper_case_globals, unused_attributes, + unused_qualifications)] + const _IMPL_SERIALIZE_FOR_Data: () = + { + #[allow(rust_2018_idioms, clippy :: useless_attribute)] + extern crate serde as _serde; + #[allow(unused_macros)] + macro_rules! try { + ($ __expr : expr) => + { + match $ __expr + { + _serde :: export :: Ok(__val) => __val, _serde :: + export :: Err(__err) => + { return _serde :: export :: Err(__err) ; } + } + } + } + #[automatically_derived] + impl <'a> _serde::Serialize for Data<'a> { + fn serialize<__S>(&self, __serializer: __S) + -> _serde::export::Result<__S::Ok, __S::Error> where + __S: _serde::Serializer { + let mut __serde_state = + match _serde::Serializer::serialize_struct(__serializer, + "Data", + false + as + usize + + 1 + + + 1) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "q", + &self.q) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, + "resolve", + &self.resolve) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + let qs_data = + Data{q: q, + resolve: resolve, + _marker: ::std::marker::PhantomData,}; + let qs = serde_urlencoded::to_string(&qs_data)?; + let url = + { + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v2/search?"], + &match (&&qs,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + }; + Ok(self.get(self.route(&url))?) + } + #[doc = + "Equivalent to `get /api/v1/accounts/{}`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_account(\"42\");\n# Ok(())\n# }\n```"] + fn get_account(&self, id: &str) -> Result { + self.get(self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + })) + } + #[doc = + "Equivalent to `post /api/v1/accounts/{}/follow`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.follow(\"42\");\n# Ok(())\n# }\n```"] + fn follow(&self, id: &str) -> Result { + self.post(self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/", + "/follow"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + })) + } + #[doc = + "Equivalent to `post /api/v1/accounts/{}/unfollow`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.unfollow(\"42\");\n# Ok(())\n# }\n```"] + fn unfollow(&self, id: &str) -> Result { + self.post(self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/", + "/unfollow"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + })) + } + #[doc = + "Equivalent to `post /api/v1/accounts/{}/block`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.block(\"42\");\n# Ok(())\n# }\n```"] + fn block(&self, id: &str) -> Result { + self.post(self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/", + "/block"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + })) + } + #[doc = + "Equivalent to `post /api/v1/accounts/{}/unblock`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.unblock(\"42\");\n# Ok(())\n# }\n```"] + fn unblock(&self, id: &str) -> Result { + self.post(self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/", + "/unblock"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + })) + } + #[doc = + "Equivalent to `get /api/v1/accounts/{}/mute`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.mute(\"42\");\n# Ok(())\n# }\n```"] + fn mute(&self, id: &str) -> Result { + self.get(self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/", + "/mute"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + })) + } + #[doc = + "Equivalent to `get /api/v1/accounts/{}/unmute`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.unmute(\"42\");\n# Ok(())\n# }\n```"] + fn unmute(&self, id: &str) -> Result { + self.get(self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/", + "/unmute"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + })) + } + #[doc = + "Equivalent to `get /api/v1/notifications/{}`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_notification(\"42\");\n# Ok(())\n# }\n```"] + fn get_notification(&self, id: &str) -> Result { + self.get(self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/notifications/"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + })) + } + #[doc = + "Equivalent to `get /api/v1/statuses/{}`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_status(\"42\");\n# Ok(())\n# }\n```"] + fn get_status(&self, id: &str) -> Result { + self.get(self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/statuses/"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + })) + } + #[doc = + "Equivalent to `get /api/v1/statuses/{}/context`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_context(\"42\");\n# Ok(())\n# }\n```"] + fn get_context(&self, id: &str) -> Result { + self.get(self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/statuses/", + "/context"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + })) + } + #[doc = + "Equivalent to `get /api/v1/statuses/{}/card`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_card(\"42\");\n# Ok(())\n# }\n```"] + fn get_card(&self, id: &str) -> Result { + self.get(self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/statuses/", + "/card"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + })) + } + #[doc = + "Equivalent to `post /api/v1/statuses/{}/reblog`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.reblog(\"42\");\n# Ok(())\n# }\n```"] + fn reblog(&self, id: &str) -> Result { + self.post(self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/statuses/", + "/reblog"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + })) + } + #[doc = + "Equivalent to `post /api/v1/statuses/{}/unreblog`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.unreblog(\"42\");\n# Ok(())\n# }\n```"] + fn unreblog(&self, id: &str) -> Result { + self.post(self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/statuses/", + "/unreblog"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + })) + } + #[doc = + "Equivalent to `post /api/v1/statuses/{}/favourite`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.favourite(\"42\");\n# Ok(())\n# }\n```"] + fn favourite(&self, id: &str) -> Result { + self.post(self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/statuses/", + "/favourite"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + })) + } + #[doc = + "Equivalent to `post /api/v1/statuses/{}/unfavourite`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.unfavourite(\"42\");\n# Ok(())\n# }\n```"] + fn unfavourite(&self, id: &str) -> Result { + self.post(self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/statuses/", + "/unfavourite"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + })) + } + #[doc = + "Equivalent to `delete /api/v1/statuses/{}`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.delete_status(\"42\");\n# Ok(())\n# }\n```"] + fn delete_status(&self, id: &str) -> Result { + self.delete(self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/statuses/"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + })) + } + #[doc = + "Equivalent to `get /api/v1/filters/{}`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.get_filter(\"42\");\n# Ok(())\n# }\n```"] + fn get_filter(&self, id: &str) -> Result { + self.get(self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/filters/"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + })) + } + #[doc = + "Equivalent to `delete /api/v1/filters/{}`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.delete_filter(\"42\");\n# Ok(())\n# }\n```"] + fn delete_filter(&self, id: &str) -> Result { + self.delete(self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/filters/"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + })) + } + #[doc = + "Equivalent to `delete /api/v1/suggestions/{}`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.delete_from_suggestions(\"42\");\n# Ok(())\n# }\n```"] + fn delete_from_suggestions(&self, id: &str) -> Result { + self.delete(self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/suggestions/"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + })) + } + #[doc = + "Equivalent to `post /api/v1/accounts/{}/pin`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.endorse_user(\"42\");\n# Ok(())\n# }\n```"] + fn endorse_user(&self, id: &str) -> Result { + self.post(self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/", + "/pin"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + })) + } + #[doc = + "Equivalent to `post /api/v1/accounts/{}/unpin`\n# Errors\nIf `access_token` is not set.\n```no_run# extern crate elefren;\n# use elefren::prelude::*;\n# fn main() -> Result<(), Box<::std::error::Error>> {\n# let data = Data {\n# base: \"https://example.com\".into(),\n# client_id: \"taosuah\".into(),\n# client_secret: \"htnjdiuae\".into(),\n# redirect: \"https://example.com\".into(),\n# token: \"tsaohueaheis\".into(),\n# };\nlet client = Mastodon::from(data);\nclient.unendorse_user(\"42\");\n# Ok(())\n# }\n```"] + fn unendorse_user(&self, id: &str) -> Result { + self.post(self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/accounts/", + "/unpin"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + })) + } + fn add_filter(&self, request: &mut AddFilterRequest) -> Result { + let url = self.route("/api/v1/filters"); + let response = self.send(self.client.post(&url).json(&request))?; + let status = response.status(); + if status.is_client_error() { + return Err(Error::Client(status.clone())); + } else if status.is_server_error() { + return Err(Error::Server(status.clone())); + } + deserialise(response) + } + #[doc = " PUT /api/v1/filters/:id"] + fn update_filter(&self, id: &str, request: &mut AddFilterRequest) + -> Result { + let url = + self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["/api/v1/filters/"], + &match (&id,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + }); + let response = self.send(self.client.put(&url).json(&request))?; + let status = response.status(); + if status.is_client_error() { + return Err(Error::Client(status.clone())); + } else if status.is_server_error() { + return Err(Error::Server(status.clone())); + } + deserialise(response) + } + fn update_credentials(&self, builder: &mut UpdateCredsRequest) + -> Result { + let changes = builder.build()?; + let url = self.route("/api/v1/accounts/update_credentials"); + let response = self.send(self.client.patch(&url).json(&changes))?; + let status = response.status(); + if status.is_client_error() { + return Err(Error::Client(status.clone())); + } else if status.is_server_error() { + return Err(Error::Server(status.clone())); + } + deserialise(response) + } + #[doc = " Post a new status to the account."] + fn new_status(&self, status: NewStatus) -> Result { + let response = + self.send(self.client.post(&self.route("/api/v1/statuses")).json(&status))?; + deserialise(response) + } + #[doc = + " Get timeline filtered by a hashtag(eg. `#coffee`) either locally or"] + #[doc = " federated."] + fn get_tagged_timeline(&self, hashtag: String, local: bool) + -> Result> { + let base = "/api/v1/timelines/tag/"; + let url = + if local { + self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["", + "", + "?local=1"], + &match (&base, + &hashtag) + { + (arg0, + arg1) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt), + ::core::fmt::ArgumentV1::new(arg1, + ::core::fmt::Display::fmt)], + })); + res + }) + } else { + self.route(&{ + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["", + ""], + &match (&base, + &hashtag) + { + (arg0, + arg1) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt), + ::core::fmt::ArgumentV1::new(arg1, + ::core::fmt::Display::fmt)], + })); + res + }) + }; + self.get(url) + } + #[doc = + " Get statuses of a single account by id. Optionally only with pictures"] + #[doc = " and or excluding replies."] + #[doc = ""] + #[doc = " # Example"] + #[doc = ""] + #[doc = " ```no_run"] + #[doc = " # extern crate elefren;"] + #[doc = " # use elefren::prelude::*;"] + #[doc = " # use std::error::Error;"] + #[doc = " # fn main() -> Result<(), Box> {"] + #[doc = " # let data = Data {"] + #[doc = " # base: \"\".into(),"] + #[doc = " # client_id: \"\".into(),"] + #[doc = " # client_secret: \"\".into(),"] + #[doc = " # redirect: \"\".into(),"] + #[doc = " # token: \"\".into(),"] + #[doc = " # };"] + #[doc = " let client = Mastodon::from(data);"] + #[doc = " let statuses = client.statuses(\"user-id\", None)?;"] + #[doc = " # Ok(())"] + #[doc = " # }"] + #[doc = " ```"] + #[doc = ""] + #[doc = " ```no_run"] + #[doc = " # extern crate elefren;"] + #[doc = " # use elefren::prelude::*;"] + #[doc = " # use std::error::Error;"] + #[doc = " # fn main() -> Result<(), Box> {"] + #[doc = " # let data = Data {"] + #[doc = " # base: \"\".into(),"] + #[doc = " # client_id: \"\".into(),"] + #[doc = " # client_secret: \"\".into(),"] + #[doc = " # redirect: \"\".into(),"] + #[doc = " # token: \"\".into(),"] + #[doc = " # };"] + #[doc = " let client = Mastodon::from(data);"] + #[doc = " let mut request = StatusesRequest::new();"] + #[doc = " request.only_media();"] + #[doc = " let statuses = client.statuses(\"user-id\", request)?;"] + #[doc = " # Ok(())"] + #[doc = " # }"] + #[doc = " ```"] + fn statuses<'a, 'b: 'a, S>(&'b self, id: &'b str, request: S) + -> Result> where S: Into>> { + let mut url = + { + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["", + "/api/v1/accounts/", + "/statuses"], + &match (&self.base, + &id) + { + (arg0, + arg1) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt), + ::core::fmt::ArgumentV1::new(arg1, + ::core::fmt::Display::fmt)], + })); + res + }; + if let Some(request) = request.into() { + url = + { + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["", + ""], + &match (&url, + &request.to_querystring()?) + { + (arg0, + arg1) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt), + ::core::fmt::ArgumentV1::new(arg1, + ::core::fmt::Display::fmt)], + })); + res + }; + } + let response = self.send(self.client.get(&url))?; + Page::new(self, response) + } + #[doc = + " Returns the client account\'s relationship to a list of other accounts."] + #[doc = " Such as whether they follow them or vice versa."] + fn relationships(&self, ids: &[&str]) -> Result> { + let mut url = self.route("/api/v1/accounts/relationships?"); + if ids.len() == 1 { + url += "id="; + url += &ids[0]; + } else { + for id in ids { url += "id[]="; url += &id; url += "&"; } + url.pop(); + } + let response = self.send(self.client.get(&url))?; + Page::new(self, response) + } + #[doc = " Add a push notifications subscription"] + fn add_push_subscription(&self, request: &AddPushRequest) + -> Result { + let request = request.build()?; + let response = + self.send(self.client.post(&self.route("/api/v1/push/subscription")).json(&request))?; + deserialise(response) + } + #[doc = + " Update the `data` portion of the push subscription associated with this"] + #[doc = " access token"] + fn update_push_data(&self, request: &UpdatePushRequest) + -> Result { + let request = request.build(); + let response = + self.send(self.client.put(&self.route("/api/v1/push/subscription")).json(&request))?; + deserialise(response) + } + #[doc = " Get all accounts that follow the authenticated user"] + fn follows_me(&self) -> Result> { + let me = self.verify_credentials()?; + Ok(self.followers(&me.id)?) + } + #[doc = " Get all accounts that the authenticated user follows"] + fn followed_by_me(&self) -> Result> { + let me = self.verify_credentials()?; + Ok(self.following(&me.id)?) + } +} +impl ops::Deref for Mastodon { + type Target = Data; + fn deref(&self) -> &Self::Target { &self.data } +} +struct MastodonBuilder { + client: Option, + data: Option, +} +impl MastodonBuilder { + pub fn new() -> Self { MastodonBuilder{client: None, data: None,} } + pub fn client(&mut self, client: Client) -> &mut Self { + self.client = Some(client); + self + } + pub fn data(&mut self, data: Data) -> &mut Self { + self.data = Some(data); + self + } + pub fn build(self) -> Result { + Ok(if let Some(data) = self.data { + Mastodon{client: self.client.unwrap_or_else(|| Client::new()), + data,} + } else { + return Err(Error::MissingField("missing field 'data'")); + }) + } +} +/// Client that can make unauthenticated calls to a mastodon instance +pub struct MastodonUnauth { + client: Client, + base: url::Url, +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for MastodonUnauth { + #[inline] + fn clone(&self) -> MastodonUnauth { + match *self { + MastodonUnauth { client: ref __self_0_0, base: ref __self_0_1 } => + MastodonUnauth{client: + ::core::clone::Clone::clone(&(*__self_0_0)), + base: + ::core::clone::Clone::clone(&(*__self_0_1)),}, + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for MastodonUnauth { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + MastodonUnauth { client: ref __self_0_0, base: ref __self_0_1 } => + { + let mut debug_trait_builder = + f.debug_struct("MastodonUnauth"); + let _ = debug_trait_builder.field("client", &&(*__self_0_0)); + let _ = debug_trait_builder.field("base", &&(*__self_0_1)); + debug_trait_builder.finish() + } + } + } +} +impl MastodonUnauth { + /// Create a new unauthenticated client + pub fn new(base: &str) -> Result { + let base = + if base.starts_with("https://") { + base.to_string() + } else { + { + let res = + ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&["https://"], + &match (&base,) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + })); + res + } + }; + Ok(MastodonUnauth{client: Client::new(), + base: url::Url::parse(&base)?,}) + } +} +impl MastodonUnauth { + fn route(&self, url: &str) -> Result { + Ok(self.base.join(url)?) + } + fn send(&self, req: RequestBuilder) -> Result { + let req = req.build()?; + Ok(self.client.execute(req)?) + } +} +impl MastodonUnauthenticated for MastodonUnauth { + /// GET /api/v1/statuses/:id + fn get_status(&self, id: &str) -> Result { + let route = self.route("/api/v1/statuses")?; + let route = route.join(id)?; + let response = self.send(self.client.get(route))?; + deserialise(response) + } + /// GET /api/v1/statuses/:id/context + fn get_context(&self, id: &str) -> Result { + let route = self.route("/api/v1/statuses")?; + let route = route.join(id)?; + let route = route.join("context")?; + let response = self.send(self.client.get(route))?; + deserialise(response) + } + /// GET /api/v1/statuses/:id/card + fn get_card(&self, id: &str) -> Result { + let route = self.route("/api/v1/statuses")?; + let route = route.join(id)?; + let route = route.join("card")?; + let response = self.send(self.client.get(route))?; + deserialise(response) + } +} +fn deserialise serde::Deserialize<'de>>(response: Response) + -> Result { + let mut reader = Tap::new(response); + match serde_json::from_reader(&mut reader) { + Ok(t) => { + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL && lvl <= ::log::max_level() + { + ::log::__private_api_log(::core::fmt::Arguments::new_v1(&[""], + &match (&String::from_utf8_lossy(&reader.bytes),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + }), + lvl, + &("elefren", "elefren", + "src/lib.rs", 845u32)); + } + }; + Ok(t) + } + Err(e) => { + { + let lvl = ::log::Level::Error; + if lvl <= ::log::STATIC_MAX_LEVEL && lvl <= ::log::max_level() + { + ::log::__private_api_log(::core::fmt::Arguments::new_v1(&[""], + &match (&String::from_utf8_lossy(&reader.bytes),) + { + (arg0,) + => + [::core::fmt::ArgumentV1::new(arg0, + ::core::fmt::Display::fmt)], + }), + lvl, + &("elefren", "elefren", + "src/lib.rs", 851u32)); + } + }; + if let Ok(error) = serde_json::from_slice(&reader.bytes) { + return Err(Error::Api(error)); + } + Err(e.into()) + } + } +} diff --git a/src/apps.rs b/src/apps.rs index 7032932..aa4899b 100644 --- a/src/apps.rs +++ b/src/apps.rs @@ -2,8 +2,8 @@ use std::borrow::Cow; use try_from::TryInto; -use errors::{Error, Result}; -use scopes::Scopes; +use crate::errors::{Error, Result}; +use crate::scopes::Scopes; /// Represents an application that can be registered with a mastodon instance #[derive(Clone, Debug, Default, Serialize, PartialEq)] diff --git a/src/entities/account.rs b/src/entities/account.rs index 499fb0a..e9c5e4e 100644 --- a/src/entities/account.rs +++ b/src/entities/account.rs @@ -2,7 +2,7 @@ use chrono::prelude::*; use serde::de::{self, Deserialize, Deserializer, Unexpected}; -use status_builder; +use crate::status_builder; use std::path::PathBuf; /// A struct representing an Account. diff --git a/src/entities/event.rs b/src/entities/event.rs index 101c677..9311f6a 100644 --- a/src/entities/event.rs +++ b/src/entities/event.rs @@ -1,4 +1,4 @@ -use entities::{notification::Notification, status::Status}; +use crate::entities::{notification::Notification, status::Status}; #[derive(Debug, Clone)] /// Events that come from the /streaming/user API call diff --git a/src/entities/itemsiter.rs b/src/entities/itemsiter.rs index e8b3e76..ece70de 100644 --- a/src/entities/itemsiter.rs +++ b/src/entities/itemsiter.rs @@ -1,5 +1,5 @@ -use http_send::HttpSend; -use page::Page; +use crate::http_send::HttpSend; +use crate::page::Page; use serde::Deserialize; /// Abstracts away the `next_page` logic into a single stream of items diff --git a/src/entities/status.rs b/src/entities/status.rs index 65c6df8..2cc596b 100644 --- a/src/entities/status.rs +++ b/src/entities/status.rs @@ -2,8 +2,8 @@ use super::prelude::*; use chrono::prelude::*; -use entities::card::Card; -use status_builder::Visibility; +use crate::entities::card::Card; +use crate::status_builder::Visibility; /// A status from the instance. #[derive(Debug, Clone, Deserialize, PartialEq)] diff --git a/src/errors.rs b/src/errors.rs index f4d62b4..f0d61c9 100644 --- a/src/errors.rs +++ b/src/errors.rs @@ -8,9 +8,9 @@ use serde_json::Error as SerdeError; use serde_qs::Error as SerdeQsError; use serde_urlencoded::ser::Error as UrlEncodedError; #[cfg(feature = "toml")] -use tomlcrate::de::Error as TomlDeError; +use crate::tomlcrate::de::Error as TomlDeError; #[cfg(feature = "toml")] -use tomlcrate::ser::Error as TomlSerError; +use crate::tomlcrate::ser::Error as TomlSerError; use url::ParseError as UrlError; use tungstenite::error::Error as WebSocketError; @@ -128,7 +128,7 @@ macro_rules! from { $(#[$met])* impl From<$typ> for Error { fn from(from: $typ) -> Self { - use Error::*; + use crate::Error::*; $variant(from) } } @@ -237,7 +237,7 @@ mod tests { #[cfg(feature = "toml")] #[test] fn from_toml_de_error() { - use tomlcrate; + use crate::tomlcrate; let err: TomlDeError = tomlcrate::from_str::<()>("not valid toml").unwrap_err(); let err: Error = Error::from(err); assert_is!(err, Error::TomlDe(..)); diff --git a/src/helpers/cli.rs b/src/helpers/cli.rs index a1321d5..eac3a39 100644 --- a/src/helpers/cli.rs +++ b/src/helpers/cli.rs @@ -1,9 +1,9 @@ use std::io::{self, BufRead, Write}; -use errors::Result; -use http_send::HttpSend; -use registration::Registered; -use Mastodon; +use crate::errors::Result; +use crate::http_send::HttpSend; +use crate::registration::Registered; +use crate::Mastodon; /// Finishes the authentication process for the given `Registered` object, /// using the command-line diff --git a/src/helpers/env.rs b/src/helpers/env.rs index 1f13acb..856d650 100644 --- a/src/helpers/env.rs +++ b/src/helpers/env.rs @@ -1,7 +1,7 @@ use envy; -use data::Data; -use Result; +use crate::data::Data; +use crate::Result; /// Attempts to deserialize a Data struct from the environment pub fn from_env() -> Result { diff --git a/src/helpers/json.rs b/src/helpers/json.rs index ab69890..e861585 100644 --- a/src/helpers/json.rs +++ b/src/helpers/json.rs @@ -6,8 +6,8 @@ use std::{ use serde_json; -use data::Data; -use Result; +use crate::data::Data; +use crate::Result; /// Attempts to deserialize a Data struct from a string pub fn from_str(s: &str) -> Result { diff --git a/src/helpers/toml.rs b/src/helpers/toml.rs index be17783..4d23057 100644 --- a/src/helpers/toml.rs +++ b/src/helpers/toml.rs @@ -4,10 +4,10 @@ use std::{ path::Path, }; -use tomlcrate; +use crate::tomlcrate; -use data::Data; -use Result; +use crate::data::Data; +use crate::Result; /// Attempts to deserialize a Data struct from a string pub fn from_str(s: &str) -> Result { diff --git a/src/http_send.rs b/src/http_send.rs index 9c161f8..77207da 100644 --- a/src/http_send.rs +++ b/src/http_send.rs @@ -1,6 +1,6 @@ use reqwest::{Client, Request, RequestBuilder, Response}; use std::fmt::Debug; -use Result; +use crate::Result; /// Abstracts away the process of turning an HTTP request into an HTTP response pub trait HttpSend: Clone + Debug { diff --git a/src/lib.rs b/src/lib.rs index 7dccb5f..5ea639c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -5,9 +5,9 @@ //! ```no_run //! # extern crate elefren; //! # fn main() { -//! # try().unwrap(); +//! # run().unwrap(); //! # } -//! # fn try() -> elefren::Result<()> { +//! # fn run() -> elefren::Result<()> { //! use elefren::{helpers::cli, prelude::*}; //! //! let registration = Registration::new("https://mastodon.social") @@ -114,23 +114,23 @@ use reqwest::{Client, RequestBuilder, Response}; use tap_reader::Tap; use tungstenite::client::AutoStream; -use entities::prelude::*; -use http_send::{HttpSend, HttpSender}; -use page::Page; +use crate::entities::prelude::*; +use crate::http_send::{HttpSend, HttpSender}; +use crate::page::Page; -pub use data::Data; -pub use errors::{ApiError, Error, Result}; +pub use crate::data::Data; +pub use crate::errors::{ApiError, Error, Result}; pub use isolang::Language; -pub use mastodon_client::{MastodonClient, MastodonUnauthenticated}; -pub use registration::Registration; -pub use requests::{ +pub use crate::mastodon_client::{MastodonClient, MastodonUnauthenticated}; +pub use crate::registration::Registration; +pub use crate::requests::{ AddFilterRequest, AddPushRequest, StatusesRequest, UpdateCredsRequest, UpdatePushRequest, }; -pub use status_builder::{NewStatus, StatusBuilder}; +pub use crate::status_builder::{NewStatus, StatusBuilder}; /// Registering your App pub mod apps; @@ -159,14 +159,14 @@ pub mod status_builder; mod macros; /// Automatically import the things you need pub mod prelude { - pub use scopes::Scopes; - pub use Data; - pub use Mastodon; - pub use MastodonClient; - pub use NewStatus; - pub use Registration; - pub use StatusBuilder; - pub use StatusesRequest; + pub use crate::scopes::Scopes; + pub use crate::Data; + pub use crate::Mastodon; + pub use crate::MastodonClient; + pub use crate::NewStatus; + pub use crate::Registration; + pub use crate::StatusBuilder; + pub use crate::StatusesRequest; } /// Your mastodon application client, handles all requests to and from Mastodon. diff --git a/src/mastodon_client.rs b/src/mastodon_client.rs index 6a63c7c..e338e96 100644 --- a/src/mastodon_client.rs +++ b/src/mastodon_client.rs @@ -1,17 +1,17 @@ use std::borrow::Cow; -use entities::prelude::*; -use errors::Result; -use http_send::{HttpSend, HttpSender}; -use page::Page; -use requests::{ +use crate::entities::prelude::*; +use crate::errors::Result; +use crate::http_send::{HttpSend, HttpSender}; +use crate::page::Page; +use crate::requests::{ AddFilterRequest, AddPushRequest, StatusesRequest, UpdateCredsRequest, UpdatePushRequest, }; -use status_builder::NewStatus; +use crate::status_builder::NewStatus; /// Represents the set of methods that a Mastodon Client can do, so that /// implementations might be swapped out for testing diff --git a/src/page.rs b/src/page.rs index 3a47ce6..06c76bd 100644 --- a/src/page.rs +++ b/src/page.rs @@ -1,11 +1,11 @@ use super::{deserialise, Mastodon, Result}; -use entities::itemsiter::ItemsIter; +use crate::entities::itemsiter::ItemsIter; use hyper_old_types::header::{parsing, Link, RelationType}; use reqwest::{header::LINK, Response}; use serde::Deserialize; use url::Url; -use http_send::HttpSend; +use crate::http_send::HttpSend; macro_rules! pages { ($($direction:ident: $fun:ident),*) => { diff --git a/src/registration.rs b/src/registration.rs index 7aba7c5..c6b8876 100644 --- a/src/registration.rs +++ b/src/registration.rs @@ -4,14 +4,14 @@ use reqwest::{Client, RequestBuilder, Response}; use try_from::TryInto; use url::percent_encoding::{utf8_percent_encode, DEFAULT_ENCODE_SET}; -use apps::{App, AppBuilder}; -use http_send::{HttpSend, HttpSender}; -use scopes::Scopes; -use Data; -use Error; -use Mastodon; -use MastodonBuilder; -use Result; +use crate::apps::{App, AppBuilder}; +use crate::http_send::{HttpSend, HttpSender}; +use crate::scopes::Scopes; +use crate::Data; +use crate::Error; +use crate::Mastodon; +use crate::MastodonBuilder; +use crate::Result; const DEFAULT_REDIRECT_URI: &'static str = "urn:ietf:wg:oauth:2.0:oob"; diff --git a/src/requests/filter.rs b/src/requests/filter.rs index 6f3c700..db619e4 100644 --- a/src/requests/filter.rs +++ b/src/requests/filter.rs @@ -1,4 +1,4 @@ -use entities::filter::FilterContext; +use crate::entities::filter::FilterContext; use std::time::Duration; /// Form used to create a filter diff --git a/src/requests/push.rs b/src/requests/push.rs index c609b07..28aa3c0 100644 --- a/src/requests/push.rs +++ b/src/requests/push.rs @@ -1,5 +1,5 @@ -use entities::push::{add_subscription, update_data}; -use errors::Result; +use crate::entities::push::{add_subscription, update_data}; +use crate::errors::Result; /// Container for the key & auth strings for an AddPushRequest /// @@ -169,7 +169,7 @@ impl AddPushRequest { } pub(crate) fn build(&self) -> Result { - use entities::push::{ + use crate::entities::push::{ add_subscription::{Data, Form, Keys, Subscription}, Alerts, }; @@ -326,7 +326,7 @@ impl UpdatePushRequest { } pub(crate) fn build(&self) -> update_data::Form { - use entities::push::{ + use crate::entities::push::{ update_data::{Data, Form}, Alerts, }; @@ -361,7 +361,7 @@ impl UpdatePushRequest { #[cfg(test)] mod tests { use super::*; - use entities::push::{add_subscription, update_data, Alerts}; + use crate::entities::push::{add_subscription, update_data, Alerts}; #[test] fn test_keys_new() { diff --git a/src/requests/statuses.rs b/src/requests/statuses.rs index 6e3da08..1f1e587 100644 --- a/src/requests/statuses.rs +++ b/src/requests/statuses.rs @@ -1,4 +1,4 @@ -use errors::Error; +use crate::errors::Error; use serde_qs; use std::{borrow::Cow, convert::Into}; diff --git a/src/requests/update_credentials.rs b/src/requests/update_credentials.rs index 7784cc3..4d1aff9 100644 --- a/src/requests/update_credentials.rs +++ b/src/requests/update_credentials.rs @@ -3,9 +3,9 @@ use std::{ path::{Path, PathBuf}, }; -use entities::account::{Credentials, MetadataField, UpdateSource}; -use errors::Result; -use status_builder; +use crate::entities::account::{Credentials, MetadataField, UpdateSource}; +use crate::errors::Result; +use crate::status_builder; /// Builder to pass to the Mastodon::update_credentials method /// @@ -202,8 +202,8 @@ impl UpdateCredsRequest { #[cfg(test)] mod tests { use super::*; - use entities::account::{Credentials, MetadataField, UpdateSource}; - use status_builder::Visibility; + use crate::entities::account::{Credentials, MetadataField, UpdateSource}; + use crate::status_builder::Visibility; #[test] fn test_update_creds_request_new() { diff --git a/src/scopes.rs b/src/scopes.rs index 2cab0d2..a857b95 100644 --- a/src/scopes.rs +++ b/src/scopes.rs @@ -8,7 +8,7 @@ use std::{ use serde::ser::{Serialize, Serializer}; -use errors::Error; +use crate::errors::Error; use serde::{Deserialize, Deserializer}; use serde::de::{self, Visitor};