hydro_lang/location/cluster/
cluster_id.rs

1use std::fmt::{Debug, Display};
2use std::hash::Hash;
3use std::marker::PhantomData;
4
5use serde::{Deserialize, Serialize};
6
7#[repr(transparent)]
8pub struct ClusterId<C> {
9    pub raw_id: u32,
10    pub(crate) _phantom: PhantomData<C>,
11}
12
13impl<C> Debug for ClusterId<C> {
14    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15        write!(
16            f,
17            "ClusterId::<{}>({})",
18            std::any::type_name::<C>(),
19            self.raw_id
20        )
21    }
22}
23
24impl<C> Display for ClusterId<C> {
25    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
26        write!(
27            f,
28            "ClusterId::<{}>({})",
29            std::any::type_name::<C>(),
30            self.raw_id
31        )
32    }
33}
34
35impl<C> Clone for ClusterId<C> {
36    fn clone(&self) -> Self {
37        *self
38    }
39}
40
41impl<C> Copy for ClusterId<C> {}
42
43impl<C> Serialize for ClusterId<C> {
44    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
45    where
46        S: serde::ser::Serializer,
47    {
48        self.raw_id.serialize(serializer)
49    }
50}
51
52impl<'de, C> Deserialize<'de> for ClusterId<C> {
53    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
54    where
55        D: serde::de::Deserializer<'de>,
56    {
57        u32::deserialize(deserializer).map(|id| ClusterId {
58            raw_id: id,
59            _phantom: PhantomData,
60        })
61    }
62}
63
64impl<C> PartialEq for ClusterId<C> {
65    fn eq(&self, other: &Self) -> bool {
66        self.raw_id == other.raw_id
67    }
68}
69
70impl<C> Eq for ClusterId<C> {}
71
72impl<C> Hash for ClusterId<C> {
73    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
74        self.raw_id.hash(state)
75    }
76}
77
78impl<C> ClusterId<C> {
79    pub fn from_raw(id: u32) -> Self {
80        ClusterId {
81            raw_id: id,
82            _phantom: PhantomData,
83        }
84    }
85}