diff --git a/gen/youtube3/src/cmn.rs b/gen/youtube3/src/cmn.rs index d55dbfa1df..360848056a 100644 --- a/gen/youtube3/src/cmn.rs +++ b/gen/youtube3/src/cmn.rs @@ -7,6 +7,9 @@ use std::marker::MarkerTrait; /// The hub allows to access all resource methods more easily. pub trait Hub: MarkerTrait {} +/// Identifies types for building methods of a particular type +pub trait MethodBuilder: MarkerTrait {} + /// Identifies types which can be inserted and deleted. /// Types with this trait are most commonly used by clients of this API. pub trait Resource: MarkerTrait {} diff --git a/gen/youtube3/src/lib.rs b/gen/youtube3/src/lib.rs index a4c27a1250..551d242c03 100644 --- a/gen/youtube3/src/lib.rs +++ b/gen/youtube3/src/lib.rs @@ -115,7 +115,7 @@ use std::marker::PhantomData; use std::borrow::BorrowMut; use std::cell::RefCell; -pub use cmn::{Hub, Resource, Part, ResponseResult, RequestResult, NestedType}; +pub use cmn::{Hub, MethodBuilder, Resource, Part, ResponseResult, RequestResult, NestedType}; // ######## // HUB ### @@ -173,6 +173,58 @@ impl<'a, C, NC, A> YouTube _m: PhantomData, } } + + pub fn activities(&'a self) -> ActivitiesMethodBuilder<'a, C, NC, A> { + ActivitiesMethodBuilder { hub: &self } + } + pub fn channelBanners(&'a self) -> ChannelBannersMethodBuilder<'a, C, NC, A> { + ChannelBannersMethodBuilder { hub: &self } + } + pub fn channelSections(&'a self) -> ChannelSectionsMethodBuilder<'a, C, NC, A> { + ChannelSectionsMethodBuilder { hub: &self } + } + pub fn channels(&'a self) -> ChannelsMethodBuilder<'a, C, NC, A> { + ChannelsMethodBuilder { hub: &self } + } + pub fn guideCategories(&'a self) -> GuideCategoriesMethodBuilder<'a, C, NC, A> { + GuideCategoriesMethodBuilder { hub: &self } + } + pub fn i18nLanguages(&'a self) -> I18nLanguagesMethodBuilder<'a, C, NC, A> { + I18nLanguagesMethodBuilder { hub: &self } + } + pub fn i18nRegions(&'a self) -> I18nRegionsMethodBuilder<'a, C, NC, A> { + I18nRegionsMethodBuilder { hub: &self } + } + pub fn liveBroadcasts(&'a self) -> LiveBroadcastsMethodBuilder<'a, C, NC, A> { + LiveBroadcastsMethodBuilder { hub: &self } + } + pub fn liveStreams(&'a self) -> LiveStreamsMethodBuilder<'a, C, NC, A> { + LiveStreamsMethodBuilder { hub: &self } + } + pub fn playlistItems(&'a self) -> PlaylistItemsMethodBuilder<'a, C, NC, A> { + PlaylistItemsMethodBuilder { hub: &self } + } + pub fn playlists(&'a self) -> PlaylistsMethodBuilder<'a, C, NC, A> { + PlaylistsMethodBuilder { hub: &self } + } + pub fn search(&'a self) -> SearchMethodBuilder<'a, C, NC, A> { + SearchMethodBuilder { hub: &self } + } + pub fn subscriptions(&'a self) -> SubscriptionsMethodBuilder<'a, C, NC, A> { + SubscriptionsMethodBuilder { hub: &self } + } + pub fn thumbnails(&'a self) -> ThumbnailsMethodBuilder<'a, C, NC, A> { + ThumbnailsMethodBuilder { hub: &self } + } + pub fn videoCategories(&'a self) -> VideoCategoriesMethodBuilder<'a, C, NC, A> { + VideoCategoriesMethodBuilder { hub: &self } + } + pub fn videos(&'a self) -> VideosMethodBuilder<'a, C, NC, A> { + VideosMethodBuilder { hub: &self } + } + pub fn watermarks(&'a self) -> WatermarksMethodBuilder<'a, C, NC, A> { + WatermarksMethodBuilder { hub: &self } + } } @@ -3036,3 +3088,757 @@ pub struct ChannelContentDetailsRelatedplaylists { impl NestedType for ChannelContentDetailsRelatedplaylists {} impl Part for ChannelContentDetailsRelatedplaylists {} + +// ################### +// MethodBuilders ### +// ################# + +/// A builder providing access to all methods supported on *i18nLanguage* resources. +/// It is usually not used directly, but through the `YouTube` hub. +/// +/// # Example +/// +/// Instantiate a resource builder +/// +/// ```test_harness,no_run +/// extern crate hyper; +/// extern crate "yup-oauth2" as oauth2; +/// extern crate "rustc-serialize" as rustc_serialize; +/// extern crate youtube3; +/// +/// # #[test] fn egal() { +/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// use std::default::Default; +/// +/// use youtube3::YouTube; +/// +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and `client_secret`, +/// // among other things. +/// let secret: ApplicationSecret = Default::default(); +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // unless you replace `None` with the desired Flow +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about what's going on +/// // You probably want to bring in your own `TokenStorage` to persist tokens and retrieve them from storage. +/// let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// hyper::Client::new(), +/// ::default(), None); +/// let mut hub = YouTube::new(hyper::Client::new(), auth); +/// // Usually you wouldn't stick this into a variable, but keep calling `MethodBuilders` +/// // like `list(...)` +/// let rb = hub.i18nLanguages(); +/// # } +/// ``` +pub struct I18nLanguagesMethodBuilder<'a, C, NC, A> + where NC: 'a, + C: 'a, + A: 'a, { + + hub: &'a YouTube +} + +impl<'a, C, NC, A> MethodBuilder for I18nLanguagesMethodBuilder<'a, C, NC, A> {} +/// A builder providing access to all methods supported on *channelBanner* resources. +/// It is usually not used directly, but through the `YouTube` hub. +/// +/// # Example +/// +/// Instantiate a resource builder +/// +/// ```test_harness,no_run +/// extern crate hyper; +/// extern crate "yup-oauth2" as oauth2; +/// extern crate "rustc-serialize" as rustc_serialize; +/// extern crate youtube3; +/// +/// # #[test] fn egal() { +/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// use std::default::Default; +/// +/// use youtube3::YouTube; +/// +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and `client_secret`, +/// // among other things. +/// let secret: ApplicationSecret = Default::default(); +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // unless you replace `None` with the desired Flow +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about what's going on +/// // You probably want to bring in your own `TokenStorage` to persist tokens and retrieve them from storage. +/// let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// hyper::Client::new(), +/// ::default(), None); +/// let mut hub = YouTube::new(hyper::Client::new(), auth); +/// // Usually you wouldn't stick this into a variable, but keep calling `MethodBuilders` +/// // like `insert(...)` +/// let rb = hub.channelBanners(); +/// # } +/// ``` +pub struct ChannelBannersMethodBuilder<'a, C, NC, A> + where NC: 'a, + C: 'a, + A: 'a, { + + hub: &'a YouTube +} + +impl<'a, C, NC, A> MethodBuilder for ChannelBannersMethodBuilder<'a, C, NC, A> {} +/// A builder providing access to all methods supported on *channelSection* resources. +/// It is usually not used directly, but through the `YouTube` hub. +/// +/// # Example +/// +/// Instantiate a resource builder +/// +/// ```test_harness,no_run +/// extern crate hyper; +/// extern crate "yup-oauth2" as oauth2; +/// extern crate "rustc-serialize" as rustc_serialize; +/// extern crate youtube3; +/// +/// # #[test] fn egal() { +/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// use std::default::Default; +/// +/// use youtube3::YouTube; +/// +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and `client_secret`, +/// // among other things. +/// let secret: ApplicationSecret = Default::default(); +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // unless you replace `None` with the desired Flow +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about what's going on +/// // You probably want to bring in your own `TokenStorage` to persist tokens and retrieve them from storage. +/// let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// hyper::Client::new(), +/// ::default(), None); +/// let mut hub = YouTube::new(hyper::Client::new(), auth); +/// // Usually you wouldn't stick this into a variable, but keep calling `MethodBuilders` +/// // like `delete(...)`, `insert(...)`, `list(...)` and `update(...)` +/// let rb = hub.channelSections(); +/// # } +/// ``` +pub struct ChannelSectionsMethodBuilder<'a, C, NC, A> + where NC: 'a, + C: 'a, + A: 'a, { + + hub: &'a YouTube +} + +impl<'a, C, NC, A> MethodBuilder for ChannelSectionsMethodBuilder<'a, C, NC, A> {} +/// A builder providing access to all methods supported on *guideCategorie* resources. +/// It is usually not used directly, but through the `YouTube` hub. +/// +/// # Example +/// +/// Instantiate a resource builder +/// +/// ```test_harness,no_run +/// extern crate hyper; +/// extern crate "yup-oauth2" as oauth2; +/// extern crate "rustc-serialize" as rustc_serialize; +/// extern crate youtube3; +/// +/// # #[test] fn egal() { +/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// use std::default::Default; +/// +/// use youtube3::YouTube; +/// +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and `client_secret`, +/// // among other things. +/// let secret: ApplicationSecret = Default::default(); +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // unless you replace `None` with the desired Flow +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about what's going on +/// // You probably want to bring in your own `TokenStorage` to persist tokens and retrieve them from storage. +/// let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// hyper::Client::new(), +/// ::default(), None); +/// let mut hub = YouTube::new(hyper::Client::new(), auth); +/// // Usually you wouldn't stick this into a variable, but keep calling `MethodBuilders` +/// // like `list(...)` +/// let rb = hub.guideCategories(); +/// # } +/// ``` +pub struct GuideCategoriesMethodBuilder<'a, C, NC, A> + where NC: 'a, + C: 'a, + A: 'a, { + + hub: &'a YouTube +} + +impl<'a, C, NC, A> MethodBuilder for GuideCategoriesMethodBuilder<'a, C, NC, A> {} +/// A builder providing access to all methods supported on *playlist* resources. +/// It is usually not used directly, but through the `YouTube` hub. +/// +/// # Example +/// +/// Instantiate a resource builder +/// +/// ```test_harness,no_run +/// extern crate hyper; +/// extern crate "yup-oauth2" as oauth2; +/// extern crate "rustc-serialize" as rustc_serialize; +/// extern crate youtube3; +/// +/// # #[test] fn egal() { +/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// use std::default::Default; +/// +/// use youtube3::YouTube; +/// +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and `client_secret`, +/// // among other things. +/// let secret: ApplicationSecret = Default::default(); +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // unless you replace `None` with the desired Flow +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about what's going on +/// // You probably want to bring in your own `TokenStorage` to persist tokens and retrieve them from storage. +/// let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// hyper::Client::new(), +/// ::default(), None); +/// let mut hub = YouTube::new(hyper::Client::new(), auth); +/// // Usually you wouldn't stick this into a variable, but keep calling `MethodBuilders` +/// // like `delete(...)`, `insert(...)`, `list(...)` and `update(...)` +/// let rb = hub.playlists(); +/// # } +/// ``` +pub struct PlaylistsMethodBuilder<'a, C, NC, A> + where NC: 'a, + C: 'a, + A: 'a, { + + hub: &'a YouTube +} + +impl<'a, C, NC, A> MethodBuilder for PlaylistsMethodBuilder<'a, C, NC, A> {} +/// A builder providing access to all methods supported on *thumbnail* resources. +/// It is usually not used directly, but through the `YouTube` hub. +/// +/// # Example +/// +/// Instantiate a resource builder +/// +/// ```test_harness,no_run +/// extern crate hyper; +/// extern crate "yup-oauth2" as oauth2; +/// extern crate "rustc-serialize" as rustc_serialize; +/// extern crate youtube3; +/// +/// # #[test] fn egal() { +/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// use std::default::Default; +/// +/// use youtube3::YouTube; +/// +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and `client_secret`, +/// // among other things. +/// let secret: ApplicationSecret = Default::default(); +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // unless you replace `None` with the desired Flow +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about what's going on +/// // You probably want to bring in your own `TokenStorage` to persist tokens and retrieve them from storage. +/// let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// hyper::Client::new(), +/// ::default(), None); +/// let mut hub = YouTube::new(hyper::Client::new(), auth); +/// // Usually you wouldn't stick this into a variable, but keep calling `MethodBuilders` +/// // like `set(...)` +/// let rb = hub.thumbnails(); +/// # } +/// ``` +pub struct ThumbnailsMethodBuilder<'a, C, NC, A> + where NC: 'a, + C: 'a, + A: 'a, { + + hub: &'a YouTube +} + +impl<'a, C, NC, A> MethodBuilder for ThumbnailsMethodBuilder<'a, C, NC, A> {} +/// A builder providing access to all methods supported on *video* resources. +/// It is usually not used directly, but through the `YouTube` hub. +/// +/// # Example +/// +/// Instantiate a resource builder +/// +/// ```test_harness,no_run +/// extern crate hyper; +/// extern crate "yup-oauth2" as oauth2; +/// extern crate "rustc-serialize" as rustc_serialize; +/// extern crate youtube3; +/// +/// # #[test] fn egal() { +/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// use std::default::Default; +/// +/// use youtube3::YouTube; +/// +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and `client_secret`, +/// // among other things. +/// let secret: ApplicationSecret = Default::default(); +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // unless you replace `None` with the desired Flow +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about what's going on +/// // You probably want to bring in your own `TokenStorage` to persist tokens and retrieve them from storage. +/// let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// hyper::Client::new(), +/// ::default(), None); +/// let mut hub = YouTube::new(hyper::Client::new(), auth); +/// // Usually you wouldn't stick this into a variable, but keep calling `MethodBuilders` +/// // like `delete(...)`, `getRating(...)`, `insert(...)`, `list(...)`, `rate(...)` and `update(...)` +/// let rb = hub.videos(); +/// # } +/// ``` +pub struct VideosMethodBuilder<'a, C, NC, A> + where NC: 'a, + C: 'a, + A: 'a, { + + hub: &'a YouTube +} + +impl<'a, C, NC, A> MethodBuilder for VideosMethodBuilder<'a, C, NC, A> {} +/// A builder providing access to all methods supported on *subscription* resources. +/// It is usually not used directly, but through the `YouTube` hub. +/// +/// # Example +/// +/// Instantiate a resource builder +/// +/// ```test_harness,no_run +/// extern crate hyper; +/// extern crate "yup-oauth2" as oauth2; +/// extern crate "rustc-serialize" as rustc_serialize; +/// extern crate youtube3; +/// +/// # #[test] fn egal() { +/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// use std::default::Default; +/// +/// use youtube3::YouTube; +/// +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and `client_secret`, +/// // among other things. +/// let secret: ApplicationSecret = Default::default(); +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // unless you replace `None` with the desired Flow +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about what's going on +/// // You probably want to bring in your own `TokenStorage` to persist tokens and retrieve them from storage. +/// let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// hyper::Client::new(), +/// ::default(), None); +/// let mut hub = YouTube::new(hyper::Client::new(), auth); +/// // Usually you wouldn't stick this into a variable, but keep calling `MethodBuilders` +/// // like `delete(...)`, `insert(...)` and `list(...)` +/// let rb = hub.subscriptions(); +/// # } +/// ``` +pub struct SubscriptionsMethodBuilder<'a, C, NC, A> + where NC: 'a, + C: 'a, + A: 'a, { + + hub: &'a YouTube +} + +impl<'a, C, NC, A> MethodBuilder for SubscriptionsMethodBuilder<'a, C, NC, A> {} +/// A builder providing access to all methods supported on *search* resources. +/// It is usually not used directly, but through the `YouTube` hub. +/// +/// # Example +/// +/// Instantiate a resource builder +/// +/// ```test_harness,no_run +/// extern crate hyper; +/// extern crate "yup-oauth2" as oauth2; +/// extern crate "rustc-serialize" as rustc_serialize; +/// extern crate youtube3; +/// +/// # #[test] fn egal() { +/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// use std::default::Default; +/// +/// use youtube3::YouTube; +/// +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and `client_secret`, +/// // among other things. +/// let secret: ApplicationSecret = Default::default(); +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // unless you replace `None` with the desired Flow +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about what's going on +/// // You probably want to bring in your own `TokenStorage` to persist tokens and retrieve them from storage. +/// let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// hyper::Client::new(), +/// ::default(), None); +/// let mut hub = YouTube::new(hyper::Client::new(), auth); +/// // Usually you wouldn't stick this into a variable, but keep calling `MethodBuilders` +/// // like `list(...)` +/// let rb = hub.search(); +/// # } +/// ``` +pub struct SearchMethodBuilder<'a, C, NC, A> + where NC: 'a, + C: 'a, + A: 'a, { + + hub: &'a YouTube +} + +impl<'a, C, NC, A> MethodBuilder for SearchMethodBuilder<'a, C, NC, A> {} +/// A builder providing access to all methods supported on *i18nRegion* resources. +/// It is usually not used directly, but through the `YouTube` hub. +/// +/// # Example +/// +/// Instantiate a resource builder +/// +/// ```test_harness,no_run +/// extern crate hyper; +/// extern crate "yup-oauth2" as oauth2; +/// extern crate "rustc-serialize" as rustc_serialize; +/// extern crate youtube3; +/// +/// # #[test] fn egal() { +/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// use std::default::Default; +/// +/// use youtube3::YouTube; +/// +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and `client_secret`, +/// // among other things. +/// let secret: ApplicationSecret = Default::default(); +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // unless you replace `None` with the desired Flow +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about what's going on +/// // You probably want to bring in your own `TokenStorage` to persist tokens and retrieve them from storage. +/// let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// hyper::Client::new(), +/// ::default(), None); +/// let mut hub = YouTube::new(hyper::Client::new(), auth); +/// // Usually you wouldn't stick this into a variable, but keep calling `MethodBuilders` +/// // like `list(...)` +/// let rb = hub.i18nRegions(); +/// # } +/// ``` +pub struct I18nRegionsMethodBuilder<'a, C, NC, A> + where NC: 'a, + C: 'a, + A: 'a, { + + hub: &'a YouTube +} + +impl<'a, C, NC, A> MethodBuilder for I18nRegionsMethodBuilder<'a, C, NC, A> {} +/// A builder providing access to all methods supported on *liveStream* resources. +/// It is usually not used directly, but through the `YouTube` hub. +/// +/// # Example +/// +/// Instantiate a resource builder +/// +/// ```test_harness,no_run +/// extern crate hyper; +/// extern crate "yup-oauth2" as oauth2; +/// extern crate "rustc-serialize" as rustc_serialize; +/// extern crate youtube3; +/// +/// # #[test] fn egal() { +/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// use std::default::Default; +/// +/// use youtube3::YouTube; +/// +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and `client_secret`, +/// // among other things. +/// let secret: ApplicationSecret = Default::default(); +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // unless you replace `None` with the desired Flow +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about what's going on +/// // You probably want to bring in your own `TokenStorage` to persist tokens and retrieve them from storage. +/// let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// hyper::Client::new(), +/// ::default(), None); +/// let mut hub = YouTube::new(hyper::Client::new(), auth); +/// // Usually you wouldn't stick this into a variable, but keep calling `MethodBuilders` +/// // like `delete(...)`, `insert(...)`, `list(...)` and `update(...)` +/// let rb = hub.liveStreams(); +/// # } +/// ``` +pub struct LiveStreamsMethodBuilder<'a, C, NC, A> + where NC: 'a, + C: 'a, + A: 'a, { + + hub: &'a YouTube +} + +impl<'a, C, NC, A> MethodBuilder for LiveStreamsMethodBuilder<'a, C, NC, A> {} +/// A builder providing access to all methods supported on *channel* resources. +/// It is usually not used directly, but through the `YouTube` hub. +/// +/// # Example +/// +/// Instantiate a resource builder +/// +/// ```test_harness,no_run +/// extern crate hyper; +/// extern crate "yup-oauth2" as oauth2; +/// extern crate "rustc-serialize" as rustc_serialize; +/// extern crate youtube3; +/// +/// # #[test] fn egal() { +/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// use std::default::Default; +/// +/// use youtube3::YouTube; +/// +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and `client_secret`, +/// // among other things. +/// let secret: ApplicationSecret = Default::default(); +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // unless you replace `None` with the desired Flow +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about what's going on +/// // You probably want to bring in your own `TokenStorage` to persist tokens and retrieve them from storage. +/// let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// hyper::Client::new(), +/// ::default(), None); +/// let mut hub = YouTube::new(hyper::Client::new(), auth); +/// // Usually you wouldn't stick this into a variable, but keep calling `MethodBuilders` +/// // like `list(...)` and `update(...)` +/// let rb = hub.channels(); +/// # } +/// ``` +pub struct ChannelsMethodBuilder<'a, C, NC, A> + where NC: 'a, + C: 'a, + A: 'a, { + + hub: &'a YouTube +} + +impl<'a, C, NC, A> MethodBuilder for ChannelsMethodBuilder<'a, C, NC, A> {} +/// A builder providing access to all methods supported on *playlistItem* resources. +/// It is usually not used directly, but through the `YouTube` hub. +/// +/// # Example +/// +/// Instantiate a resource builder +/// +/// ```test_harness,no_run +/// extern crate hyper; +/// extern crate "yup-oauth2" as oauth2; +/// extern crate "rustc-serialize" as rustc_serialize; +/// extern crate youtube3; +/// +/// # #[test] fn egal() { +/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// use std::default::Default; +/// +/// use youtube3::YouTube; +/// +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and `client_secret`, +/// // among other things. +/// let secret: ApplicationSecret = Default::default(); +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // unless you replace `None` with the desired Flow +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about what's going on +/// // You probably want to bring in your own `TokenStorage` to persist tokens and retrieve them from storage. +/// let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// hyper::Client::new(), +/// ::default(), None); +/// let mut hub = YouTube::new(hyper::Client::new(), auth); +/// // Usually you wouldn't stick this into a variable, but keep calling `MethodBuilders` +/// // like `delete(...)`, `insert(...)`, `list(...)` and `update(...)` +/// let rb = hub.playlistItems(); +/// # } +/// ``` +pub struct PlaylistItemsMethodBuilder<'a, C, NC, A> + where NC: 'a, + C: 'a, + A: 'a, { + + hub: &'a YouTube +} + +impl<'a, C, NC, A> MethodBuilder for PlaylistItemsMethodBuilder<'a, C, NC, A> {} +/// A builder providing access to all methods supported on *watermark* resources. +/// It is usually not used directly, but through the `YouTube` hub. +/// +/// # Example +/// +/// Instantiate a resource builder +/// +/// ```test_harness,no_run +/// extern crate hyper; +/// extern crate "yup-oauth2" as oauth2; +/// extern crate "rustc-serialize" as rustc_serialize; +/// extern crate youtube3; +/// +/// # #[test] fn egal() { +/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// use std::default::Default; +/// +/// use youtube3::YouTube; +/// +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and `client_secret`, +/// // among other things. +/// let secret: ApplicationSecret = Default::default(); +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // unless you replace `None` with the desired Flow +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about what's going on +/// // You probably want to bring in your own `TokenStorage` to persist tokens and retrieve them from storage. +/// let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// hyper::Client::new(), +/// ::default(), None); +/// let mut hub = YouTube::new(hyper::Client::new(), auth); +/// // Usually you wouldn't stick this into a variable, but keep calling `MethodBuilders` +/// // like `set(...)` and `unset(...)` +/// let rb = hub.watermarks(); +/// # } +/// ``` +pub struct WatermarksMethodBuilder<'a, C, NC, A> + where NC: 'a, + C: 'a, + A: 'a, { + + hub: &'a YouTube +} + +impl<'a, C, NC, A> MethodBuilder for WatermarksMethodBuilder<'a, C, NC, A> {} +/// A builder providing access to all methods supported on *liveBroadcast* resources. +/// It is usually not used directly, but through the `YouTube` hub. +/// +/// # Example +/// +/// Instantiate a resource builder +/// +/// ```test_harness,no_run +/// extern crate hyper; +/// extern crate "yup-oauth2" as oauth2; +/// extern crate "rustc-serialize" as rustc_serialize; +/// extern crate youtube3; +/// +/// # #[test] fn egal() { +/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// use std::default::Default; +/// +/// use youtube3::YouTube; +/// +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and `client_secret`, +/// // among other things. +/// let secret: ApplicationSecret = Default::default(); +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // unless you replace `None` with the desired Flow +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about what's going on +/// // You probably want to bring in your own `TokenStorage` to persist tokens and retrieve them from storage. +/// let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// hyper::Client::new(), +/// ::default(), None); +/// let mut hub = YouTube::new(hyper::Client::new(), auth); +/// // Usually you wouldn't stick this into a variable, but keep calling `MethodBuilders` +/// // like `bind(...)`, `control(...)`, `delete(...)`, `insert(...)`, `list(...)`, `transition(...)` and `update(...)` +/// let rb = hub.liveBroadcasts(); +/// # } +/// ``` +pub struct LiveBroadcastsMethodBuilder<'a, C, NC, A> + where NC: 'a, + C: 'a, + A: 'a, { + + hub: &'a YouTube +} + +impl<'a, C, NC, A> MethodBuilder for LiveBroadcastsMethodBuilder<'a, C, NC, A> {} +/// A builder providing access to all methods supported on *videoCategorie* resources. +/// It is usually not used directly, but through the `YouTube` hub. +/// +/// # Example +/// +/// Instantiate a resource builder +/// +/// ```test_harness,no_run +/// extern crate hyper; +/// extern crate "yup-oauth2" as oauth2; +/// extern crate "rustc-serialize" as rustc_serialize; +/// extern crate youtube3; +/// +/// # #[test] fn egal() { +/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// use std::default::Default; +/// +/// use youtube3::YouTube; +/// +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and `client_secret`, +/// // among other things. +/// let secret: ApplicationSecret = Default::default(); +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // unless you replace `None` with the desired Flow +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about what's going on +/// // You probably want to bring in your own `TokenStorage` to persist tokens and retrieve them from storage. +/// let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// hyper::Client::new(), +/// ::default(), None); +/// let mut hub = YouTube::new(hyper::Client::new(), auth); +/// // Usually you wouldn't stick this into a variable, but keep calling `MethodBuilders` +/// // like `list(...)` +/// let rb = hub.videoCategories(); +/// # } +/// ``` +pub struct VideoCategoriesMethodBuilder<'a, C, NC, A> + where NC: 'a, + C: 'a, + A: 'a, { + + hub: &'a YouTube +} + +impl<'a, C, NC, A> MethodBuilder for VideoCategoriesMethodBuilder<'a, C, NC, A> {} +/// A builder providing access to all methods supported on *activitie* resources. +/// It is usually not used directly, but through the `YouTube` hub. +/// +/// # Example +/// +/// Instantiate a resource builder +/// +/// ```test_harness,no_run +/// extern crate hyper; +/// extern crate "yup-oauth2" as oauth2; +/// extern crate "rustc-serialize" as rustc_serialize; +/// extern crate youtube3; +/// +/// # #[test] fn egal() { +/// use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage}; +/// use std::default::Default; +/// +/// use youtube3::YouTube; +/// +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and `client_secret`, +/// // among other things. +/// let secret: ApplicationSecret = Default::default(); +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // unless you replace `None` with the desired Flow +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about what's going on +/// // You probably want to bring in your own `TokenStorage` to persist tokens and retrieve them from storage. +/// let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate, +/// hyper::Client::new(), +/// ::default(), None); +/// let mut hub = YouTube::new(hyper::Client::new(), auth); +/// // Usually you wouldn't stick this into a variable, but keep calling `MethodBuilders` +/// // like `insert(...)` and `list(...)` +/// let rb = hub.activities(); +/// # } +/// ``` +pub struct ActivitiesMethodBuilder<'a, C, NC, A> + where NC: 'a, + C: 'a, + A: 'a, { + + hub: &'a YouTube +} + +impl<'a, C, NC, A> MethodBuilder for ActivitiesMethodBuilder<'a, C, NC, A> {} + diff --git a/src/mako/lib.rs.mako b/src/mako/lib.rs.mako index 69ca9fd4f0..d52015abd4 100644 --- a/src/mako/lib.rs.mako +++ b/src/mako/lib.rs.mako @@ -1,12 +1,13 @@ <% from util import (iter_nested_types, new_context, rust_comment, rust_doc_comment, rust_module_doc_comment, rust_doc_test_norun, canonical_type_name, - rust_test_fn_invisible) + mb_type, singular, rust_test_fn_invisible, put_and) nested_schemas = list(iter_nested_types(schemas)) c = new_context(resources) hub_type = canonical_type_name(canonicalName) + %>\ <%namespace name="lib" file="lib/lib.mako"/>\ <%namespace name="mutil" file="lib/util.mako"/>\ @@ -32,7 +33,7 @@ use std::marker::PhantomData; use std::borrow::BorrowMut; use std::cell::RefCell; -pub use cmn::{Hub, Resource, Part, ResponseResult, RequestResult, NestedType}; +pub use cmn::{Hub, MethodBuilder, Resource, Part, ResponseResult, RequestResult, NestedType}; // ######## // HUB ### @@ -45,7 +46,7 @@ pub use cmn::{Hub, Resource, Part, ResponseResult, RequestResult, NestedType}; /// Instantiate a new hub /// <%block filter="rust_doc_comment">\ -${lib.hub_usage_example()}\ +<%lib:hub_usage_example/>\ pub struct ${hub_type} { client: RefCell, @@ -67,6 +68,12 @@ impl<'a, C, NC, A> ${hub_type} _m: PhantomData, } } + + % for resource in sorted(c.rta_map.keys()): + pub fn ${resource}(&'a self) -> ${mb_type(resource)}<'a, C, NC, A> { + ${mb_type(resource)} { hub: &self } + } + % endfor } @@ -84,4 +91,39 @@ ${schema.new(s, c)} ## We have to find them and process them as normal types % for s in nested_schemas: ${schema.new(s, c)} -% endfor \ No newline at end of file +% endfor + +// ################### +// MethodBuilders ### +// ################# + +% for resource, methods in c.rta_map.iteritems(): +/// A builder providing access to all methods supported on *${singular(resource)}* resources. +/// It is usually not used directly, but through the `${hub_type}` hub. +/// +/// # Example +/// +/// Instantiate a resource builder +/// +<%block filter="rust_doc_test_norun, rust_doc_comment">\ +${mutil.test_prelude()}\ + +<%block filter="rust_test_fn_invisible">\ +${lib.test_hub(canonical_type_name(canonicalName))}\ + +// Usually you wouldn't stick this into a variable, but keep calling `MethodBuilders` +// like ${put_and(sorted('`%s(...)`' % f for f in methods))} +let rb = hub.${resource}(); + + +pub struct ${mb_type(resource)}<'a, C, NC, A> + where NC: 'a, + C: 'a, + A: 'a, { + + hub: &'a ${hub_type} +} + +impl<'a, C, NC, A> MethodBuilder for ${mb_type(resource)}<'a, C, NC, A> {} +% endfor + diff --git a/src/mako/lib/lib.mako b/src/mako/lib/lib.mako index c95b994ba9..ed770a917c 100644 --- a/src/mako/lib/lib.mako +++ b/src/mako/lib/lib.mako @@ -12,19 +12,13 @@ # fr == fattest resource, the fatter, the more important, right ? fr = None fr = sorted(schemas.values(), key=lambda s: (len(c.sta_map.get(s.id, [])), len(s.get('properties', []))), reverse=True)[0] - - # resouce -> [activity, ...] - amap = dict() - for an in c.fqan_map: - resource, activity = activity_split(an) - amap.setdefault(resource, list()).append(activity) %>\ # Features Handle the following *Resources* with ease ... -% for r in sorted(amap.keys()): -* ${split_camelcase_s(r)} (${put_and(md_italic(sorted(amap[r])))}) +% for r in sorted(c.rta_map.keys()): +* ${split_camelcase_s(r)} (${put_and(md_italic(sorted(c.rta_map[r])))}) % endfor # Structure of this Library diff --git a/src/mako/lib/schema.mako b/src/mako/lib/schema.mako index f442fba9b1..df4e12677f 100644 --- a/src/mako/lib/schema.mako +++ b/src/mako/lib/schema.mako @@ -1,4 +1,6 @@ -<%! from util import (schema_markers, rust_doc_comment, mangle_ident, to_rust_type, put_and, IO_TYPES, activity_split) %>\ +<%! from util import (schema_markers, rust_doc_comment, mangle_ident, to_rust_type, put_and, + IO_TYPES, activity_split, enclose_in) +%>\ ## Create new schema with everything. ## 's' contains the schema structure from json to build <%def name="new(s, c)">\ @@ -34,8 +36,7 @@ ${s.get('description', 'There is no detailed description.')} # Activities This type is used in activities, which are methods you may call on this type or where this type is involved in. -The list links the activity name, along with information about where it is used (one of ${put_and(list('*%s*' % t - for t in IO_TYPES))}). +The list links the activity name, along with information about where it is used (one of ${put_and(enclose_in('*', IO_TYPES))}). ${''.join("* %s (%s)\n" % (activity_split(a)[1], iot and '|'.join(iot) or 'none') for a, iot in c.sta_map[s.id].iteritems())} diff --git a/src/mako/lib/util.py b/src/mako/lib/util.py index e941030338..beafb30f01 100644 --- a/src/mako/lib/util.py +++ b/src/mako/lib/util.py @@ -101,8 +101,17 @@ def put_and(l): return l[0] return ', '.join(l[:-1]) + ' and ' + l[-1] +# ['foo', ...] with e == '*' -> ['*foo*', ...] +def enclose_in(e, l): + return ['%s%s%s' % (e, s, e) for s in l] + def md_italic(l): - return ['*%s*' % s for s in l] + return enclose_in('*', l) + +def singular(s): + if s[-1] == 's': + return s[:-1] + return s def split_camelcase_s(s): s1 = re.sub('(.)([A-Z][a-z]+)', r'\1 \2', s) @@ -226,44 +235,6 @@ def schema_markers(s, c): # ------------------------- ## @name Activity Utilities # @{ - -# Returns (A, B) where -# A: { SchemaTypeName -> { fqan -> ['request'|'response', ...]} -# B: { fqan -> activity_method_data } -# fqan = fully qualified activity name -def build_activity_mappings(activities): - res = dict() - fqan = dict() - for an, a in activities.iteritems(): - if 'methods' not in a: - continue - for mn, m in a.methods.iteritems(): - assert m.id not in fqan - fqan[m.id] = m - for in_out_type_name in IO_TYPES: - t = m.get(in_out_type_name, None) - if t is None: - continue - tn = to_rust_type(None, None, t, allow_optionals=False) - info = res.setdefault(tn, dict()) - io_info = info.setdefault(m.id, []) - io_info.append(in_out_type_name) - # end for each io type - - # handle delete/getrating/(possibly others) - # delete: has no response or request - # getrating: response is a 'SomethingResult', which is still related to activities name - # the latter is used to deduce the resource name - an, _ = activity_split(m.id) - tn = activity_name_to_type_name(an) - info = res.setdefault(tn, dict()) - if m.id not in info: - info.setdefault(m.id, []) - # end handle other cases - # end for each method - # end for each activity - return res, fqan - # return (name, method) def activity_split(fqan): t = fqan.split('.') @@ -281,12 +252,54 @@ def iter_acitivities(c): ## -- End Activity Utilities -- @} -Context = collections.namedtuple('Context', ['sta_map', 'fqan_map']) +Context = collections.namedtuple('Context', ['sta_map', 'fqan_map', 'rta_map']) # return a newly build context from the given data def new_context(resources): + # Returns (A, B) where + # A: { SchemaTypeName -> { fqan -> ['request'|'response', ...]} + # B: { fqan -> activity_method_data } + # fqan = fully qualified activity name + def build_activity_mappings(activities): + res = dict() + fqan = dict() + for an, a in activities.iteritems(): + if 'methods' not in a: + continue + for mn, m in a.methods.iteritems(): + assert m.id not in fqan + fqan[m.id] = m + for in_out_type_name in IO_TYPES: + t = m.get(in_out_type_name, None) + if t is None: + continue + tn = to_rust_type(None, None, t, allow_optionals=False) + info = res.setdefault(tn, dict()) + io_info = info.setdefault(m.id, []) + io_info.append(in_out_type_name) + # end for each io type + + # handle delete/getrating/(possibly others) + # delete: has no response or request + # getrating: response is a 'SomethingResult', which is still related to activities name + # the latter is used to deduce the resource name + an, _ = activity_split(m.id) + tn = activity_name_to_type_name(an) + info = res.setdefault(tn, dict()) + if m.id not in info: + info.setdefault(m.id, []) + # end handle other cases + # end for each method + # end for each activity + return res, fqan + # end utility + sta_map, fqan_map = build_activity_mappings(resources) - return Context(sta_map, fqan_map) + rta_map = dict() + for an in fqan_map: + resource, activity = activity_split(an) + rta_map.setdefault(resource, list()).append(activity) + return Context(sta_map, fqan_map, rta_map) # Expects v to be 'v\d+', throws otherwise def to_api_version(v): @@ -296,3 +309,7 @@ def to_api_version(v): # build a full library name (non-canonical) def library_name(name, version): return name + to_api_version(version) + +# return type name of a resource builder, from a resource name +def mb_type(r): + return "%sMethodBuilder" % canonical_type_name(r) diff --git a/src/rust/cmn.rs b/src/rust/cmn.rs index 928c549f0b..ec1f1d14fe 100644 --- a/src/rust/cmn.rs +++ b/src/rust/cmn.rs @@ -5,6 +5,9 @@ use std::marker::MarkerTrait; /// The hub allows to access all resource methods more easily. pub trait Hub: MarkerTrait {} +/// Identifies types for building methods of a particular type +pub trait MethodBuilder: MarkerTrait {} + /// Identifies types which can be inserted and deleted. /// Types with this trait are most commonly used by clients of this API. pub trait Resource: MarkerTrait {} diff --git a/src/rust/dev/mod.rs b/src/rust/dev/mod.rs index 40cfd55365..a286393e59 100644 --- a/src/rust/dev/mod.rs +++ b/src/rust/dev/mod.rs @@ -43,7 +43,7 @@ impl<'a, C, NC, A> YouTube } pub fn videos(&'a self) -> videos::Service<'a, C, NC, A> { - videos::Service::new(&self.client, &self.auth) + videos::Service::new(&self) } } diff --git a/src/rust/dev/videos/service.rs b/src/rust/dev/videos/service.rs index 5893beb5a2..176e6b7086 100644 --- a/src/rust/dev/videos/service.rs +++ b/src/rust/dev/videos/service.rs @@ -7,6 +7,8 @@ use rustc_serialize; use hyper; use oauth2; +use super::super::YouTube; + /// Reresents all aspects of a youtube video resource. May only be partially /// available #[derive(RustcEncodable, RustcDecodable, Default, Clone)] @@ -75,10 +77,7 @@ pub struct Service<'a, C, NC, A> C: 'a, A: 'a, { - client: &'a RefCell, - auth: &'a RefCell, - - _m: PhantomData + hub: &'a YouTube } impl<'a, C, NC, A> Service<'a, C, NC, A> @@ -86,21 +85,15 @@ impl<'a, C, NC, A> Service<'a, C, NC, A> C: BorrowMut> + 'a, A: oauth2::GetToken + 'a { - pub fn new(client: &'a RefCell, authenticator: &'a RefCell) -> Service<'a, C, NC, A> { - Service { - client: client, - auth: authenticator, - _m: PhantomData, - } + pub fn new(hub: &'a YouTube) -> Service<'a, C, NC, A> { + Service { hub: hub } } pub fn insert(&self, parts: &str, video: &Video) -> VideosInsertBuilder<'a, C, NC, A> { VideosInsertBuilder { - client: self.client, - auth: self.auth, + hub: self.hub, video: video.clone(), parts: parts.to_string(), - _m: PhantomData, } } } @@ -110,12 +103,9 @@ pub struct VideosInsertBuilder<'a, C, NC, A> C: 'a, A: 'a { - client: &'a RefCell, - auth: &'a RefCell, + hub: &'a YouTube, video: Video, parts: String, - - _m: PhantomData }