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
111
112
113
114
115
116
117
118
119
120

use alloc::sync::Arc;

use crate::{utilities::mutex::Mutex, BLEDescriptor};

#[repr(u8)]
pub enum BLE2904Format {
  BOOLEAN = 1,
  UINT2 = 2,
  UINT4 = 3,
  UINT8 = 4,
  UINT12 = 5,
  UINT16 = 6,
  UINT24 = 7,
  UINT32 = 8,
  UINT48 = 9,
  UINT64 = 10,
  UINT128 = 11,
  SINT8 = 12,
  SINT12 = 13,
  SINT16 = 14,
  SINT24 = 15,
  SINT32 = 16,
  SINT48 = 17,
  SINT64 = 18,
  SINT128 = 19,
  FLOAT32 = 20,
  FLOAT64 = 21,
  SFLOAT16 = 22,
  SFLOAT32 = 23,
  IEEE20601 = 24,
  UTF8 = 25,
  UTF16 = 26,
  OPAQUE = 27,
}

#[repr(packed)]
struct Data {
  format: BLE2904Format,
  exponent: u8,
  unit: u16,
  namespace: u8,
  description: u16,
}

pub struct BLE2904 {
  descriptor: Arc<Mutex<BLEDescriptor>>,
}

impl BLE2904 {
  pub(super) fn new(descriptor: Arc<Mutex<BLEDescriptor>>) -> Self {
    descriptor.lock().set_from(&Data {
      format: BLE2904Format::OPAQUE,
      exponent: 0,
      unit: 0,
      namespace: 1,
      description: 0,
    });

    Self { descriptor }
  }

  pub fn format(&mut self, value: BLE2904Format) -> &mut Self {
    self
      .descriptor
      .lock()
      .value_mut()
      .as_mut::<Data>()
      .unwrap()
      .format = value;

    self
  }

  pub fn exponent(&mut self, value: u8) -> &mut Self {
    self
      .descriptor
      .lock()
      .value_mut()
      .as_mut::<Data>()
      .unwrap()
      .exponent = value;

    self
  }

  pub fn unit(&mut self, value: u16) -> &mut Self {
    self
      .descriptor
      .lock()
      .value_mut()
      .as_mut::<Data>()
      .unwrap()
      .unit = value;

    self
  }

  pub fn namespace(&mut self, value: u8) -> &mut Self {
    self
      .descriptor
      .lock()
      .value_mut()
      .as_mut::<Data>()
      .unwrap()
      .namespace = value;

    self
  }
  pub fn description(&mut self, value: u16) -> &mut Self {
    self
      .descriptor
      .lock()
      .value_mut()
      .as_mut::<Data>()
      .unwrap()
      .description = value;

    self
  }
}