Struct DDApi 

pub struct DDApi { /* private fields */ }

Implementations

impl DDApi

pub fn new() -> Self

Creates a new DDApi instance with default settings

Examples

use ddapi_rs::prelude::*;

let api = DDApi::new();

pub fn new_with_client(client: Client) -> Self

Creates a new DDApi instance with a custom HTTP client

This allows you to configure your own client with custom timeouts, headers, or other settings.

Arguments

• client - A pre-configured reqwest::Client instance

Examples

use ddapi_rs::prelude::*;
use reqwest::Client;

let client = Client::builder()
    .timeout(std::time::Duration::from_secs(10))
    .build()
    .unwrap();
let api = DDApi::new_with_client(client);

pub fn set_cache(&mut self, capacity: u64, time_to_live: Duration)

Configures caching for API responses

When the cache feature is enabled, this method allows you to set up an in-memory cache to reduce API calls and improve performance.

Arguments

• capacity - Maximum number of entries to store in the cache
• time_to_live - Time in seconds before cached entries expire

Examples

use ddapi_rs::prelude::*;
use std::time::Duration;

let mut api = DDApi::new();
api.set_cache(1000, Duration::from_mins(5)); // Cache 1000 items for 5 minutes

pub async fn _generator<T>(&self, url: &str) -> Result<T>

where T: DeserializeOwned + Send + Sync + 'static,

Executes an API request and deserializes the JSON response

This method handles API requests and automatically deserializes the JSON response into the specified type. The caching behavior is determined by the cache feature flag.

Type Parameters

• T - The type to deserialize the response into. Must implement DeserializeOwned + Send + Sync + 'static

Arguments

• url - The API endpoint URL to request

Returns

Returns

Result<T> containing the deserialized data on success, or an error on failure

pub async fn _generator_no_cache<T>(&self, url: &str) -> Result<T>

where T: DeserializeOwned,

Executes an API request without caching

Always fetches fresh data from the API, bypassing any cache.

Type Parameters

• T - The type to deserialize the response into

Arguments

• url - The API endpoint URL to request

Returns

Returns Result<T> with freshly fetched deserialized data

Trait Implementations

impl Clone for DDApi

fn clone(&self) -> DDApi

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl DDnetApi for DDApi

async fn master(&self) -> Result<Master>

Fetches server list from the default master server

Returns a list of game servers from the primary master server (master1.ddnet.org).

Examples

use ddapi_rs::prelude::*;

let api = DDApi::new();
let master = api.master().await?;
println!("Found {} servers", master.servers.len());

async fn skins(&self) -> Result<DDSkins>

Examples

use ddapi_rs::prelude::*;
use ddapi_rs::prelude::ddnet::*;

let api = DDApi::new();
let skins: DDSkins = api.skins().await?;
println!("Found {} available skins", skins.skins.len());
for skin in skins.skins {
    println!("Skin: {} by {}", skin.name, skin.creator);
}

async fn custom_master(&self, master: MasterServer) -> Result<Master>

Fetches server list from a specific master server

Allows selecting which master server to query. DDNet has multiple master servers for redundancy and load distribution.

Arguments

• master - The master server to query (MasterServer::One, MasterServer::Two, etc.)

Examples

use ddapi_rs::prelude::*;
use ddapi_rs::prelude::ddnet::*;

let api = DDApi::new();
// Use secondary master server as fallback
let master = api.custom_master(MasterServer::Two).await?;

async fn player(&self, player: &str) -> Result<Player>

Examples

use ddapi_rs::prelude::*;
use ddapi_rs::prelude::ddnet::*;

let api = DDApi::new();
let player: Player = api.player("nameless tee").await?;
println!("{}: {}", player.player, player.points.points.unwrap_or(0));

async fn query(&self, player: &str) -> Result<Vec<Query>>

Examples

use ddapi_rs::prelude::*;
use ddapi_rs::prelude::ddnet::*;

let api = DDApi::new();
let query: Vec<Query> = api.query("nameless tee").await?;
for player in &query {
    println!("{}: {}", player.name, player.points);
}

async fn query_map(&self, map: &str) -> Result<Vec<QueryMap>>

Examples

use ddapi_rs::prelude::*;
use ddapi_rs::prelude::ddnet::*;

let api = DDApi::new();
let query: Vec<QueryMap> = api.query_map("multi").await?;
for map in &query {
    println!("{}: {} | {}", map.name, map.mapper, map.r#type);
}

async fn query_mapper(&self, player: &str) -> Result<Vec<QueryMapper>>

Examples

use ddapi_rs::prelude::*;
use ddapi_rs::prelude::ddnet::*;

let api = DDApi::new();
let query: Vec<QueryMapper> = api.query_mapper("Ao").await?;
for player in &query {
    println!("{}: {}", player.mapper, player.num_maps);
}

async fn map(&self, map: &str) -> Result<Map>

Examples

use ddapi_rs::prelude::*;
use ddapi_rs::prelude::ddnet::*;

let api = DDApi::new();
let map: Map = api.map("Fox").await?;
println!("{}: {}", map.mapper, map.web_preview);

async fn releases_map(&self) -> Result<Vec<ReleasesMaps>>

Examples

use ddapi_rs::prelude::*;
use ddapi_rs::prelude::ddnet::*;

let api = DDApi::new();
let maps: Vec<ReleasesMaps> = api.releases_map().await?;
for map in &maps {
    println!("{}: {} | {}", map.name, map.mapper, map.r#type);
}

async fn status(&self) -> Result<Status>

Examples

use ddapi_rs::prelude::*;
use ddapi_rs::prelude::ddnet::*;

let api = DDApi::new();
let status: Status = api.status().await?;
for data in &status.servers {
    println!("{}: {} | {}", data.name, data.location, data.host);
}

async fn latest_finish(&self) -> Result<Vec<LatestFinishes>>

async fn latest_finish_with_latest( &self, latest: usize, ) -> Result<Vec<LatestFinishes>>

impl DDstats for DDApi

async fn s_player(&self, player: &str) -> Result<Player>

Examples

use ddapi_rs::prelude::*;
use ddapi_rs::prelude::ddstats::*;

let api = DDApi::new();
let player: Player = api.s_player("Aoe").await?;
println!("{}: {} | {}", player.profile.name, player.profile.points, player.profile.clan.unwrap_or(String::default()));

async fn s_map(&self, map: &str) -> Result<Map>

Examples

use ddapi_rs::prelude::*;
use ddapi_rs::prelude::ddstats::*;

let api = DDApi::new();
let map: Map = api.s_map("Fox").await?;
println!("{}: {} | {}", map.info.map.map, map.info.map.stars, map.info.finishes);

async fn s_maps(&self) -> Result<Vec<StatsMap>>

Examples

use ddapi_rs::prelude::*;
use ddapi_rs::prelude::ddstats::*;

let api = DDApi::new();
let maps: Vec<StatsMap> = api.s_maps().await?;
for map in &maps {
    println!("{}: {} | {}", map.map, map.stars, map.points);
}

async fn s_profile(&self, player: &str) -> Result<Profile>

Examples

use ddapi_rs::prelude::*;
use ddapi_rs::prelude::ddstats::*;

let api = DDApi::new();
let player: Profile = api.s_profile("ByFox").await?;
println!("{}: {}", player.name, player.clan.unwrap_or(String::default()));

impl Default for DDApi

fn default() -> DDApi

Returns the “default value” for a type.