altv_internal_mvalue 16.4.3

An internal crate for alt:V module. Not intended for direct use.
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
104
105
106
107
108
109
110

use std::fmt::Display;

use altv_sdk::MValueType;
use serde::{de, ser};

pub type Result<T> = std::result::Result<T, Error>;

#[derive(Debug)]
pub enum Error {
  Message(String),
  SerializationFailed,
  DictKeySerializationFailed,
  BaseObjectSerializationFailed,
  Vector3SerializationFailed,
  Vector3DeserializationFailed,
  Vector2SerializationFailed,
  Vector2DeserializationFailed,
  RgbaSerializationFailed,
  RgbaDeserializationFailed,
  InvalidBaseObject,
  InvalidMValueType,
  DictKeyMustBeAString,
  BaseObjectImpossibleSerialization,
  Vector3ImpossibleSerialization,
  Vector2ImpossibleSerialization,
  F32ImpossibleSerialization,
  RgbaImpossibleSerialization,
  BytesDeserializationIsNotImplementedYet,
  ConstMValueSliceCanOnlyBeDeserializedAsTuple,
  EnumDeserializationExpectsList { but_received: MValueType },
  EnumDeserializationExpectsListWithTwoElements,
  EnumDeserializationExpectsListOrInt { but_received: MValueType },
}

const ENUM_DESERIALIZATION_INTERNAL_TYPE: &str =
  "MValue List: [variant_index (u32), variant_value (any)]";

impl ser::Error for Error {
  fn custom<T: Display>(msg: T) -> Self {
    Error::Message(msg.to_string())
  }
}

impl de::Error for Error {
  fn custom<T: Display>(msg: T) -> Self {
    Error::Message(msg.to_string())
  }
}

impl Display for Error {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    let mut dynamic_error = None;
    let info = match self {
      Error::Message(msg) => msg,
      Error::InvalidBaseObject => "Base object is destroyed and cannot be used anymore",
      Error::SerializationFailed => "Serialization failed for unknown reason",
      Error::BaseObjectImpossibleSerialization => "BaseObjectImpossibleSerialization",
      Error::BaseObjectSerializationFailed => "Base object serialization failed for unknown reason",
      Error::BytesDeserializationIsNotImplementedYet => {
        "Bytes deserialization is not implemented yet, use `altv::ByteBuf`"
      }
      Error::ConstMValueSliceCanOnlyBeDeserializedAsTuple => {
        "ConstMValue slice can only be deserialized as tuple"
      }
      Error::DictKeyMustBeAString => "Dict key must be a string",
      Error::DictKeySerializationFailed => "Dict key serialization failed for unknown reason",
      Error::InvalidMValueType => "InvalidMValueType",
      Error::F32ImpossibleSerialization => "F32ImpossibleSerialization",
      Error::RgbaDeserializationFailed => "Rgba deserialization failed for unknown reason",
      Error::RgbaImpossibleSerialization => "RgbaImpossibleSerialization",
      Error::RgbaSerializationFailed => "Rgba serialization failed for unknown reason",
      Error::Vector2DeserializationFailed => "Vector2 deserialization failed for unknown reason",
      Error::Vector2SerializationFailed => "Vector2 serialization failed for unknown reason",
      Error::Vector2ImpossibleSerialization => "Vector2ImpossibleSerialization",
      Error::Vector3DeserializationFailed => "Vector3 deserialization failed for unknown reason",
      Error::Vector3SerializationFailed => "Vector3 serialization failed for unknown reason",
      Error::Vector3ImpossibleSerialization => "Vector3ImpossibleSerialization",
      Error::EnumDeserializationExpectsList { but_received } => {
        let message = format!(
          "Enum deserialization expected {ENUM_DESERIALIZATION_INTERNAL_TYPE}\
                    , received: {but_received:?}"
        );

        // i'm sorry for this
        dynamic_error.replace(message);
        dynamic_error.as_ref().unwrap()
      }
      Error::EnumDeserializationExpectsListOrInt { but_received } => {
        let message = format!(
          "Enum deserialization expected {ENUM_DESERIALIZATION_INTERNAL_TYPE} \
                    or i32 (variant_index), received: {but_received:?}"
        );

        // i'm sorry for this
        dynamic_error.replace(message);
        dynamic_error.as_ref().unwrap()
      }
      Error::EnumDeserializationExpectsListWithTwoElements => {
        let message = format!("Enum deserialization expected {ENUM_DESERIALIZATION_INTERNAL_TYPE}");
        // i'm sorry for this
        dynamic_error.replace(message);
        dynamic_error.as_ref().unwrap()
      }
    };

    f.write_str(info)
  }
}

impl std::error::Error for Error {}