vk_executive 0.8.4

Relatively low-level VK API library designed for millions requests per second
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

mod builder;
pub use builder::{BuildError, Builder};
use hyper::body::Body;
use std::time::Duration;

use http::request::Request;
use tower::Service;
use crate::client::HyperClient;

#[derive(Debug)]
pub struct Config<C = HyperClient>
where
    C: Service<Request<Body>>,
{
    pub token: String,
    pub http_client: C,
    pub api_url: String,
    pub api_version: String,
    pub time_between_requests: Duration,
}

impl<C> PartialEq for Config<C>
where
    C: Service<Request<Body>>,
{
    fn eq(&self, other: &Self) -> bool {
        self.token == other.token
            && self.api_url == other.api_url
            && self.api_version == other.api_version
            && self.time_between_requests == other.time_between_requests
    }
}

impl Default for Config<HyperClient> {
    fn default() -> Self {
        Self::builder().build().unwrap()
    }
}

impl Config<HyperClient> {
    /// Constructs a new [`Config`]
    pub fn new() -> Self {
        Self::default()
    }

    /// Creates a [`Builder`] to configure a [`Config`]
    pub fn builder() -> Builder<HyperClient> {
        Builder::new()
    }

    /// Constructs vector of `Configs` from any [`Iterator`] of tokens
    ///
    /// Example:
    /// ```rust
    /// use vk_executive::Config;
    ///
    /// let configs = Config::from_tokens(["123456789", "1111"].into_iter()).unwrap();
    ///
    /// assert_eq!(
    ///     configs,
    ///     vec![
    ///         Config::builder().token("123456789".to_string()).build().unwrap(),
    ///         Config::builder().token("1111".to_string()).build().unwrap()
    ///     ]
    /// )
    /// ```
    pub fn from_tokens<Tokens, Token>(tokens: Tokens) -> Result<Vec<Self>, BuildError>
    where
        Tokens: Iterator<Item = Token>,
        Token: ToString,
    {
        Self::from_tokens_by_prototype(tokens, &Builder::new())
    }

}

impl<C> Config<C>
where
    C: Service<Request<Body>> + Clone,
{
    pub fn from_tokens_by_prototype<Tokens, Token>(
        tokens: Tokens,
        prototype: &Builder<C>,
    ) -> Result<Vec<Self>, BuildError>
    where
        Tokens: Iterator<Item = Token>,
        Token: ToString,
    {
        let mut configs = Vec::new();

        for token in tokens {
            configs.push(prototype.clone().token(token).build()?);
        }

        Ok(configs)
    }
}