am-api 1.1.0

A library for interfacing with the Apple Music API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

//! Request builder that supports relations

use crate::request::context::RequestContext;
use std::collections::{HashMap, HashSet};
use std::fmt::Display;
use std::hash::Hash;

/// A trait for getting information about a relationship type
pub trait RelationshipTrait: Display {
    /// Get relation object name
    fn get_object(&self) -> &'static str;
}

/// Relationship key
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub(crate) struct RelationshipKey {
    object: &'static str,
    lazy: bool,
}

/// Relationship storage type
#[derive(Default)]
pub struct RelationshipStorage {
    storage: HashMap<RelationshipKey, HashSet<String>>,
}

impl RelationshipStorage {
    /// Add a relationship to this storage
    pub fn add_relationship(&mut self, relationship: impl RelationshipTrait) {
        self.storage
            .entry(RelationshipKey {
                object: relationship.get_object(),
                lazy: false,
            })
            .or_default()
            .insert(relationship.to_string());
    }

    /// Add a lazy relationship to this storage
    pub fn add_relationship_lazy(&mut self, relationship: impl RelationshipTrait) {
        self.storage
            .entry(RelationshipKey {
                object: relationship.get_object(),
                lazy: true,
            })
            .or_default()
            .insert(relationship.to_string());
    }

    /// Build relationship query parameters draining this storage
    pub fn build_query_drain(&mut self, request_context: &mut RequestContext) {
        for (relationship, include) in self.storage.drain() {
            let key = match relationship.lazy {
                true => format!("relate[{}]", relationship.object),
                false => format!("include[{}]", relationship.object),
            };

            let include = include.into_iter().collect::<Vec<_>>().join(",");

            request_context.query.push((key, include));
        }
    }
}