vkclient 6.0.0

Vk Api client implementation
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

use crate::inner::VkApiInner;
use crate::structs::Version;
use crate::vkapi::{Compression, Encoding, VkApi};

/// API Client builder struct.
/// Use `VkApi::from` or `into` to make `VkApi` struct.
#[derive(Clone, Debug)]
pub struct VkApiBuilder {
    inner: VkApiInner,
}

impl VkApiBuilder {
    /// Creates the builder from an access key with default values.
    pub fn new(access_token: String) -> Self {
        cfg_if::cfg_if! {
            if #[cfg(feature = "compression_zstd")] {
                let encoding = Compression::Zstd;
            } else if #[cfg(feature = "compression_gzip")] {
                let encoding = Compression::Gzip;
            } else {
                let encoding = Compression::None;
            }
        }
        cfg_if::cfg_if! {
            if #[cfg(feature = "encode_msgpack")] {
                let format = Encoding::Msgpack;
            } else if #[cfg(feature = "encode_json")] {
                let format = Encoding::Json;
            } else {
                let format = Encoding::None;
            }
        }

        Self {
            inner: VkApiInner {
                access_token,
                version: Version::default(),
                domain: "api.vk.ru".to_owned(),
                format,
                encoding,
            },
        }
    }

    /// Pass new access token to builder
    #[must_use]
    pub fn with_access_token(mut self, access_token: String) -> Self {
        self.inner.access_token = access_token;
        self
    }

    /// Pass new version to builder. Default is 5.131
    #[must_use]
    pub const fn with_version(mut self, version: Version) -> Self {
        self.inner.version = version;
        self
    }

    /// Pass new API domain to builder. The default is api.vk.ru
    #[must_use]
    pub fn with_domain(mut self, domain: String) -> Self {
        self.inner.domain = domain;
        self
    }

    /// Pass new compression to builder. The default is `Compression::Zstd`
    #[must_use]
    pub const fn with_compression(mut self, compression: Compression) -> Self {
        self.inner.encoding = compression;
        self
    }

    /// Pass new encoding to the builder. The default is `Encoding::Msgpack`
    #[must_use]
    pub const fn with_encoding(mut self, encoding: Encoding) -> Self {
        self.inner.format = encoding;
        self
    }
}

impl From<VkApiBuilder> for VkApi {
    fn from(builder: VkApiBuilder) -> Self {
        Self::from_inner(builder.inner)
    }
}