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

use std::fmt::Debug;

use crate::{
  from_mvalue,
  types::{RawConstMValue, RawMutMValue},
  Error, Result,
  helpers::sdk_type_to_rust,
};

use altv_sdk::{ffi as sdk, MValueType};
use autocxx::prelude::*;
use serde::de::DeserializeOwned;

pub struct MutMValue(RawMutMValue);

impl MutMValue {
  pub fn new(ptr: RawMutMValue) -> Self {
    Self(ptr)
  }

  pub fn get(&self) -> &RawMutMValue {
    &self.0
  }

  pub fn as_mut(&mut self) -> std::pin::Pin<&mut sdk::MValueMutWrapper> {
    self.0.as_mut().unwrap()
  }

  pub fn into_const(self) -> ConstMValue {
    ConstMValue::new(
      unsafe { sdk::convert_mvalue_mut_wrapper_to_const(self.0) }.within_unique_ptr(),
    )
  }

  pub fn into_raw(self) -> RawMutMValue {
    self.0
  }
}

impl Clone for MutMValue {
  fn clone(&self) -> Self {
    Self::new(unsafe { sdk::copy_mut_mvalue(self.0.as_ref().unwrap()) }.within_unique_ptr())
  }
}

impl Debug for MutMValue {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    write!(f, "MutMValue {{ ... }}")
  }
}

pub struct ConstMValue(RawConstMValue);

impl ConstMValue {
  pub fn new(ptr: RawConstMValue) -> Self {
    Self(ptr)
  }

  pub fn get(&self) -> &RawConstMValue {
    &self.0
  }

  pub fn deserialize<V: DeserializeOwned>(&self) -> Result<V> {
    from_mvalue(self)
  }

  pub fn sdk_mvalue_type(&self) -> Result<MValueType> {
    let raw = unsafe { sdk::read_mvalue_type(self.get()) };
    MValueType::try_from(raw).map_err(|_| Error::InvalidMValueType)
  }
}

impl Debug for ConstMValue {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    let debug_type = if let Ok(sdk_type) = self.sdk_mvalue_type() {
      sdk_type_to_rust(sdk_type)
    } else {
      "unknown"
    };

    write!(f, "ConstMValue {{ {debug_type} }}")
  }
}

impl From<&sdk::ConstMValueWrapper> for ConstMValue {
  fn from(value: &sdk::ConstMValueWrapper) -> Self {
    Self::new(unsafe { sdk::copy_const_mvalue(value) }.within_unique_ptr())
  }
}

impl Clone for ConstMValue {
  fn clone(&self) -> Self {
    Self::new(unsafe { sdk::copy_const_mvalue(self.0.as_ref().unwrap()) }.within_unique_ptr())
  }
}