fast_vk 0.5.5

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
98
99
100
101
102
103

use crate::Error;
use serde::{Deserialize, Deserializer, Serialize};
use std::collections::HashMap;
use std::result::Result as StdResult;
use thiserror::Error as ThisError;

/// Struct only for parsing VK Result
#[derive(Debug, Deserialize, Serialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum VkResult<T> {
    Response(T),
    Error(VkError),
}

impl<T> Into<Result<T, VkError>> for VkResult<T> {
    fn into(self) -> StdResult<T, VkError> {
        match self {
            VkResult::Response(response) => StdResult::Ok(response),
            VkResult::Error(error) => StdResult::Err(error),
        }
    }
}

impl<T> Into<Result<T, Error>> for VkResult<T> {
    fn into(self) -> StdResult<T, Error> {
        match self {
            VkResult::Response(response) => StdResult::Ok(response),
            VkResult::Error(error) => StdResult::Err(Error::VK(error)),
        }
    }
}

impl<T: std::fmt::Display> std::fmt::Display for VkResult<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self {
            VkResult::Response(t) => write!(f, "Response: {t}"),
            VkResult::Error(error) => write!(f, "{error}"),
        }
    }
}

/// Represents any valid VK Error
#[derive(Debug, ThisError, Deserialize, Serialize, PartialEq, Eq, Clone)]
pub struct VkError {
    pub error_code: u16,
    pub error_msg: String,
    #[serde(default)]
    #[serde(deserialize_with = "params_from_pairs")]
    pub request_params: Option<HashMap<String, String>>,
}

impl std::fmt::Display for VkError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.request_params {
            Some(params) => {
                write!(
                    f,
                    "Error {}: {}\nRequest params: {:#?}",
                    self.error_code, self.error_msg, params
                )
            }
            None => {
                write!(f, "Error {}: {}", self.error_code, self.error_msg)
            }
        }
    }
}

/// Serializes [`HashMap`] from sequence of objects with fields key and value
/// 
/// For example, serializes this json
/// ```javascript
/// [
///     { "key": "meaning_of_life", "value": 42 },
///     { "key": "test", 1}
/// ]
/// ```
/// into `HashMap { "meaning_of_life": 42, "test": 1 }`
pub fn params_from_pairs<'de, D>(d: D) -> StdResult<Option<HashMap<String, String>>, D::Error>
where
    D: Deserializer<'de>,
{
    let s: Vec<Pair> = Deserialize::deserialize(d)?;

    if s.is_empty() {
        return Ok(None);
    }

    let mut map = HashMap::with_capacity(s.len());

    for Pair { key, value } in s {
        map.insert(key, value);
    }

    Ok(Some(map))
}

/// Represents any Request Param
#[derive(Debug, Deserialize, Serialize)]
struct Pair {
    key: String,
    value: String,
}