emmylua_code_analysis/vfs/
file_id.rs

1use std::cmp;
2
3use serde::{Deserialize, Deserializer, Serialize, Serializer};
4
5#[derive(Eq, PartialEq, Hash, Debug, Clone, Copy, PartialOrd)]
6pub struct FileId {
7    pub id: u32,
8}
9
10impl Serialize for FileId {
11    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
12    where
13        S: Serializer,
14    {
15        serializer.serialize_u32(self.id)
16    }
17}
18
19impl<'de> Deserialize<'de> for FileId {
20    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
21    where
22        D: Deserializer<'de>,
23    {
24        let id = u32::deserialize(deserializer)?;
25        Ok(FileId { id })
26    }
27}
28
29impl FileId {
30    pub fn new() -> Self {
31        FileId { id: 0 }
32    }
33
34    pub const VIRTUAL: FileId = FileId { id: u32::MAX };
35}
36
37impl cmp::Ord for FileId {
38    fn cmp(&self, other: &Self) -> cmp::Ordering {
39        self.id.cmp(&other.id)
40    }
41}
42
43#[derive(Debug, Clone, Hash, PartialEq, Eq)]
44pub struct InFiled<N> {
45    pub file_id: FileId,
46    pub value: N,
47}
48
49impl<N> InFiled<N> {
50    pub fn new(file_id: FileId, value: N) -> Self {
51        InFiled { file_id, value }
52    }
53}
54
55#[cfg(test)]
56mod tests {
57    use super::*;
58    use serde_json;
59
60    #[test]
61    fn test_file_id_serialization() {
62        let file_id = FileId { id: 42 };
63        let serialized = serde_json::to_string(&file_id).unwrap();
64        // u32 is serialized as a number, so the JSON representation is "42"
65        assert_eq!(serialized, "42");
66        let deserialized: FileId = serde_json::from_str(&serialized).unwrap();
67        assert_eq!(deserialized, file_id);
68    }
69
70    #[test]
71    fn test_file_id_new_and_virtual() {
72        let new_file_id = FileId::new();
73        assert_eq!(new_file_id.id, 0);
74
75        let virtual_id = FileId::VIRTUAL;
76        assert_eq!(virtual_id.id, u32::MAX);
77    }
78
79    #[test]
80    fn test_infiled_new() {
81        let file_id = FileId { id: 10 };
82        let infiled = InFiled::new(file_id, "test_value");
83        assert_eq!(infiled.file_id, file_id);
84        assert_eq!(infiled.value, "test_value");
85    }
86
87    #[test]
88    fn test_file_id_deserialization_error() {
89        // Provide an invalid JSON value for FileId to trigger an error.
90        let json_invalid = "[42]";
91        let result: Result<FileId, _> = serde_json::from_str(json_invalid);
92        assert!(result.is_err());
93    }
94}