Struct twitch_api::helix::streams::get_streams::GetStreamsRequest

#[non_exhaustive]
pub struct GetStreamsRequest<'a> {
    pub after: Option<Cow<'a, CursorRef>>,
    pub before: Option<Cow<'a, CursorRef>>,
    pub first: Option<usize>,
    pub game_id: Cow<'a, [&'a CategoryIdRef]>,
    pub language: Option<Cow<'a, str>>,
    pub user_id: Cow<'a, [&'a UserIdRef]>,
    pub user_login: Cow<'a, [&'a UserNameRef]>,
}

Available on crate feature helix only.

Query Parameters for Get Streams

get-streams

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

after: Option<Cow<'a, CursorRef>>

Cursor for forward pagination: tells the server where to start fetching the next set of results, in a multi-page response. The cursor value specified here is from the pagination response field of a prior query.

before: Option<Cow<'a, CursorRef>>

Cursor for backward pagination: tells the server where to start fetching the next set of results, in a multi-page response. The cursor value specified here is from the pagination response field of a prior query.

first: Option<usize>

Maximum number of objects to return. Maximum: 100. Default: 20.

game_id: Cow<'a, [&'a CategoryIdRef]>

Returns streams broadcasting a specified game ID. You can specify up to 10 IDs.

language: Option<Cow<'a, str>>

Stream language. You can specify up to 100 languages.

user_id: Cow<'a, [&'a UserIdRef]>

Returns streams broadcast by one or more specified user IDs. You can specify up to 100 IDs.

user_login: Cow<'a, [&'a UserNameRef]>

Returns streams broadcast by one or more specified user login names. You can specify up to 100 names.

Implementations

impl<'a> GetStreamsRequest<'a>

pub fn builder() -> GetStreamsRequestBuilder<'a, ((), (), (), (), (), (), ())>

Create a builder for building GetStreamsRequest. On the builder, call .after(...)(optional), .before(...)(optional), .first(...)(optional), .game_id(...)(optional), .language(...)(optional), .user_id(...)(optional), .user_login(...)(optional) to set the values of the fields. Finally, call .build() to create the instance of GetStreamsRequest.

impl<'a> GetStreamsRequest<'a>

pub fn user_ids(user_ids: impl Into<Cow<'a, [&'a UserIdRef]>>) -> Self

Return streams for specified user ids

pub fn user_logins(user_logins: impl Into<Cow<'a, [&'a UserNameRef]>>) -> Self

Return streams for specified users by nickname

Examples found in repository

examples/get_channel_status.rs (lines 36-38)

↕

async fn run() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
    let _ = dotenvy::dotenv();
    let mut args = std::env::args().skip(1);
    let client: HelixClient<reqwest::Client> = HelixClient::new();
    let token = UserToken::from_existing(
        &client,
        std::env::var("TWITCH_TOKEN")
            .ok()
            .or_else(|| args.next())
            .map(AccessToken::new)
            .expect("Please set env: TWITCH_TOKEN or pass token as first argument"),
        None,
        None,
    )
    .await
    .unwrap();

    let response = client
        .req_get(
            GetStreamsRequest::user_logins(
                &[types::UserNameRef::from_str(&args.next().unwrap())][..],
            ),
            &token,
        )
        .await
        .unwrap()
        .data;

    println!("Stream information:\n\t{response:?}");
    Ok(())
}

examples/client.rs (lines 44-48)

↕

async fn run() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
    let _ = dotenvy::dotenv();
    let mut args = std::env::args().skip(1);

    let foo_client = FooClient::default();

    let token = UserToken::from_existing(
        &foo_client.client,
        std::env::var("TWITCH_TOKEN")
            .ok()
            .or_else(|| args.next())
            .map(AccessToken::new)
            .expect("Please set env: TWITCH_TOKEN or pass token as first argument"),
        None,
        None,
    )
    .await?;

    foo_client.client.helix.clone_client();
    let response = foo_client
        .client
        .helix
        .req_get(
            GetStreamsRequest::user_logins(
                &[types::UserNameRef::from_str(
                    &args.next().expect("please provide an username"),
                )][..],
            ),
            &token,
        )
        .await?
        .data;
    println!("{response:?}");
    Ok(())
}

pub fn first(self, first: usize) -> Self

Set amount of results returned per page.

Trait Implementations

impl<'a> Clone for GetStreamsRequest<'a>

fn clone(&self) -> GetStreamsRequest<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for GetStreamsRequest<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for GetStreamsRequest<'_>

fn default() -> Self

Returns the “default value” for a type.

impl<'de: 'a, 'a> Deserialize<'de> for GetStreamsRequest<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Paginated for GetStreamsRequest<'_>

fn set_pagination(&mut self, cursor: Option<Cursor>)

Should returns the current pagination cursor.

impl<'a> PartialEq<GetStreamsRequest<'a>> for GetStreamsRequest<'a>

fn eq(&self, other: &GetStreamsRequest<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Request for GetStreamsRequest<'_>

type Response = Vec<Stream, Global>

Response type. twitch’s response will deserialize to this.

const PATH: &'static str = "streams"

The path to the endpoint relative to the helix root. eg. channels for Get Channel Information

const SCOPE: &'static [Scope] = _

Available on crate feature twitch_oauth2 only.

Scopes needed by this endpoint

const OPT_SCOPE: &'static [Scope] = _

Available on crate feature twitch_oauth2 only.

Optional scopes needed by this endpoint

fn query(&self) -> Result<String, SerializeError>

Defines layout of the url parameters.

fn get_uri(&self) -> Result<Uri, InvalidUri>

Returns full URI for the request, including query parameters.

fn get_bare_uri() -> Result<Uri, InvalidUri>

Returns bare URI for the request, NOT including query parameters.

impl RequestGet for GetStreamsRequest<'_>

fn create_request(
    &self,
    token: &str,
    client_id: &str
) -> Result<Request<Bytes>, CreateRequestError>

Create a http::Request from this Request in your client

fn parse_response<B: Into<Bytes>>(
    request: Option<Self>,
    uri: &Uri,
    response: Response<B>
) -> Result<Response<Self, <Self as Request>::Response>, HelixRequestGetError>where
    Self: Sized,

Parse response.

fn parse_inner_response(
    request: Option<Self>,
    uri: &Uri,
    response: &str,
    status: StatusCode
) -> Result<Response<Self, <Self as Request>::Response>, HelixRequestGetError>where
    Self: Sized,

Parse a response string into the response.

impl<'a> Serialize for GetStreamsRequest<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> StructuralPartialEq for GetStreamsRequest<'a>