Struct Client

pub struct Client<C: Cache + Send + Sync + 'static, R: RateLimiter + Send + Sync + 'static, Conn: Connect + Clone + Send + Sync + 'static, const AUTHENTICATED: bool> {
    pub host: String,
    pub language: Language,
    /* private fields */
}

Fields

host: String

language: Language

Implementations

impl Client<NoopCache, NoopRateLimiter, HttpsConnector<HttpConnector>, false>

pub fn empty() -> Self

creates a new gw2 api client

Warning

this is not the same as Client::default! This initializes a client without any caching or rate limiting. If you want to use a default cache and rate limiter, use Client::default.

impl<C: Cache + Send + Sync + 'static, R: RateLimiter + Send + Sync + 'static, Conn: Connect + Clone + Send + Sync + 'static, const AUTHENTICATED: bool> Client<C, R, Conn, AUTHENTICATED>

constructing client

pub fn host( self, host: impl Into<String>, ) -> Client<C, R, HttpsConnector<HttpConnector>, AUTHENTICATED>

sets the host name

default is https://api.guildwars2.com (no trailing slash) for non https hosts use Client::host_http

pub fn host_http( self, host: impl Into<String>, ) -> Client<C, R, HttpConnector, AUTHENTICATED>

sets the non https host name

for https hosts use Client::host

pub fn language(self, language: impl Into<Language>) -> Self

sets the language

pub fn api_key(self, key: impl Into<String>) -> Client<C, R, Conn, true>

sets a new api key

pub fn identifier(self, id: impl Into<String>) -> Self

sets a new identifier

Identifiers are used to identify authentications in the cache. Defaults to the api key

Example

use gw2lib::{Client, Requester};
use gw2lib_model::authenticated::{
    account::Account,
    characters::{Character, CharacterId},
};

let client = Client::default().api_key("<subtoken>");
let account: Account = client.get().unwrap();
let client = client.identifier(&account.id);

// make a request
let characters: Vec<CharacterId> = client.ids::<Character, CharacterId>().unwrap();

let client = Client::default().api_key("<different subtoken>");
let client = client.identifier(account.id);

// cache hit
let characters: Vec<CharacterId> = client.ids::<Character, CharacterId>().unwrap();

pub fn cache<NC: Cache + Send + Sync + 'static>( self, cache: Arc<NC>, ) -> Client<NC, R, Conn, AUTHENTICATED>

sets the cache

Example

use gw2lib::cache::InMemoryCache;
use gw2lib::Client;
use std::sync::{Arc, Mutex};

let cache = Arc::new(InMemoryCache::default());
let client = Client::empty().cache(cache);

pub fn rate_limiter<NR: RateLimiter + Send + Sync + 'static>( self, rate_limiter: NR, ) -> Client<C, NR, Conn, AUTHENTICATED>

allows you to set the rate limiter, for example for sharing it between multiple clients ## Example

use std::sync::Arc;
use gw2lib::cache::InMemoryCache;
use gw2lib::Client;
use gw2lib::rate_limit::BucketRateLimiter;

let client = Client::empty().cache(Arc::new(InMemoryCache::default()));
let rate_limiter = Arc::new(BucketRateLimiter::default());
let client = client.rate_limiter(rate_limiter.clone());
let new_client = Client::default().rate_limiter(rate_limiter.clone());

Trait Implementations

impl<C: Cache + Send + Sync + 'static, R: RateLimiter + Clone + Send + Sync + 'static, Conn: Connect + Clone + Send + Sync + 'static, const AUTHENTICATED: bool> Clone for Client<C, R, Conn, AUTHENTICATED>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for Client<InMemoryCache, BucketRateLimiter, HttpsConnector<HttpConnector>, false>

fn default() -> Self

Returns the “default value” for a type.

impl<C: Cache + Send + Sync + 'static, R: RateLimiter + Send + Sync + 'static, Conn: Connect + Clone + Send + Sync + 'static, const AUTHENTICATED: bool> Requester<AUTHENTICATED, false> for Client<C, R, Conn, AUTHENTICATED>

type Caching = C

type Connector = Conn

type RateLimiting = R

fn cached( &self, cache_duration: Duration, ) -> CachedRequest<'_, Self::Caching, Self::RateLimiting, Self::Connector, AUTHENTICATED, FORCE>

overwrites the cache duration for all requests returned from this function ## Example

fn forced( &self, ) -> CachedRequest<'_, Self::Caching, Self::RateLimiting, Self::Connector, AUTHENTICATED, true>

forces a fresh copy from the api

fn get<'life0, 'async_trait, T>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<T, EndpointError>> + Send + 'async_trait>>

where T: 'async_trait + DeserializeOwned + Serialize + Clone + Send + Sync + FixedEndpoint + 'static, Self: 'async_trait, 'life0: 'async_trait,

call the fixed endpoint

fn single<'life0, 'async_trait, T, I>( &'life0 self, id: impl 'async_trait + Into<I> + Send, ) -> Pin<Box<dyn Future<Output = Result<T, EndpointError>> + Send + 'async_trait>>

where T: 'async_trait + DeserializeOwned + Serialize + Clone + Send + Sync + EndpointWithId<IdType = I> + 'static, I: 'async_trait + Display + DeserializeOwned + Hash + Send + Sync + Clone + 'static, Self: 'async_trait, 'life0: 'async_trait,

request a single item

fn try_get<'life0, 'life1, 'async_trait, T, I>( &'life0 self, id: impl 'async_trait + Into<&'life1 I> + Send, ) -> Pin<Box<dyn Future<Output = Option<T>> + Send + 'async_trait>>

where T: 'async_trait + DeserializeOwned + Serialize + Clone + Endpoint + Send + Sync + 'static, I: 'async_trait + DeserializeOwned + Display + Hash + Clone + Sync + 'static, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

retrieves an item from cache

fn ids<'life0, 'async_trait, T, I>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<I>, EndpointError>> + Send + 'async_trait>>

where T: 'async_trait + DeserializeOwned + Serialize + EndpointWithId<IdType = I> + Clone + Send + Sync + 'static, I: 'async_trait + Display + DeserializeOwned + Serialize + Hash + Clone + Send + Sync + 'static, Self: 'async_trait, 'life0: 'async_trait,

request all available ids

fn many<'life0, 'async_trait, T, I>( &'life0 self, ids: Vec<impl 'async_trait + Into<I> + Send>, ) -> Pin<Box<dyn Future<Output = Result<Vec<T>, EndpointError>> + Send + 'async_trait>>

where T: 'async_trait + DeserializeOwned + Serialize + EndpointWithId<IdType = I> + BulkEndpoint + Clone + Send + Sync + 'static, I: 'async_trait + Display + DeserializeOwned + Hash + Clone + Eq + Send + Sync + 'static, Self: 'async_trait, 'life0: 'async_trait,

request multiple ids at once

fn page<'life0, 'life1, 'async_trait, T>( &'life0 self, page: usize, page_size: u8, result: &'life1 mut Vec<T>, ) -> Pin<Box<dyn Future<Output = Result<usize, EndpointError>> + Send + 'async_trait>>

where T: 'async_trait + DeserializeOwned + PagedEndpoint + Clone + Send + Sync + 'static, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

requests a page of items and returns the number of total items across all pages

fn all<'life0, 'async_trait, T, I>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<T>, EndpointError>> + Send + 'async_trait>>

where T: 'async_trait + DeserializeOwned + Serialize + EndpointWithId<IdType = I> + BulkEndpoint + Clone + Send + Sync + 'static, I: 'async_trait + Display + DeserializeOwned + Serialize + Hash + Clone + Send + Sync + Eq + 'static, Self: 'async_trait, 'life0: 'async_trait,

requests all items using the most efficient method available

fn get_all_by_ids_all<'life0, 'async_trait, T, I>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<T>, EndpointError>> + Send + 'async_trait>>

where T: 'async_trait + DeserializeOwned + Serialize + EndpointWithId<IdType = I> + BulkEndpoint + Clone + Send + Sync + 'static, I: 'async_trait + Display + DeserializeOwned + Hash + Clone + Sync + 'static, Self: 'async_trait, 'life0: 'async_trait,

Gets all items by querying ids=all

fn get_all_by_paging<'life0, 'async_trait, T>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<T>, EndpointError>> + Send + 'async_trait>>

where T: 'async_trait + DeserializeOwned + PagedEndpoint + Clone + Send + Sync + 'static, Self: 'async_trait, 'life0: 'async_trait,

Gets all items by querying all pages

fn get_all_by_requesting_ids<'life0, 'async_trait, T, I>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<T>, EndpointError>> + Send + 'async_trait>>

where T: 'async_trait + DeserializeOwned + Serialize + EndpointWithId<IdType = I> + BulkEndpoint + Clone + Send + Sync + 'static, I: 'async_trait + Display + DeserializeOwned + Serialize + Hash + Clone + Send + Sync + Eq + 'static, Self: 'async_trait, 'life0: 'async_trait,

Gets all items by querying all ids