basalt-bedrock 1.0.0

Definitions for Basalt competition packets
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
111
112
113
114
115
116
117

use std::{
    marker::PhantomData,
    ops::{Deref, DerefMut},
    path::PathBuf,
    str::FromStr,
};

use miette::NamedSource;
use serde::{de::DeserializeOwned, Deserialize, Serialize};

use crate::ConfigReadError;

#[derive(Serialize, Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash, Default)]
#[non_exhaustive]
pub struct Deser;
#[derive(Serialize, Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash, Default)]
#[non_exhaustive]
pub struct Raw;

#[derive(Serialize, Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash, Default)]
pub struct RawOrImport<T, Mode = Deser>(T, PhantomData<Mode>)
where
    Mode: Sized;

impl<'de, T> Deserialize<'de> for RawOrImport<T, Deser>
where
    T: DeserializeOwned,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        // TODO:
        // These gems are stolen from the generated output of `#[derive(Deserialize)]`
        // This is obviously not ideal (literally using `__private`) so we should look at how to
        // properly do this in the future.
        let content = serde::__private::de::Content::deserialize(deserializer)?;
        let de = serde::__private::de::ContentRefDeserializer::<D::Error>::new(&content);

        if let Ok(import) = Import::deserialize(de) {
            // TODO: Figure out how to make the path relative to the toml file rather than the
            // runtime
            // TODO: This sync code makes me want to die
            let content =
                std::fs::read_to_string(&import.import).map_err(serde::de::Error::custom)?;

            let x: T = toml_edit::de::from_str(&content)
                .map_err(|e| {
                    ConfigReadError::malformed(
                        NamedSource::new(import.import.display().to_string(), content),
                        e,
                    )
                })
                .map_err(serde::de::Error::custom)?;
            return Ok(Self(x, PhantomData));
        }
        Ok(Self(T::deserialize(de)?, PhantomData))
    }
}

impl<'de, S> Deserialize<'de> for RawOrImport<S, Raw>
where
    S: FromStr + Deserialize<'de>,
    S::Err: std::fmt::Display,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        // TODO:
        // These gems are stolen from the generated output of `#[derive(Deserialize)]`
        // This is obviously not ideal (literally using `__private`) so we should look at how to
        // properly do this in the future.
        let content = serde::__private::de::Content::deserialize(deserializer)?;
        let de = serde::__private::de::ContentRefDeserializer::<D::Error>::new(&content);

        if let Ok(import) = Import::deserialize(de) {
            // TODO: Figure out how to make the path relative to the toml file rather than the
            // runtime
            // TODO: This sync code makes me want to die
            let content =
                std::fs::read_to_string(&import.import).map_err(serde::de::Error::custom)?;

            return Ok(Self(
                content.parse().map_err(serde::de::Error::custom)?,
                PhantomData,
            ));
        }
        Ok(Self(S::deserialize(de)?, PhantomData))
    }
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash)]
#[serde(deny_unknown_fields)]
struct Import {
    import: PathBuf,
}

impl<T, Mode> Deref for RawOrImport<T, Mode> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<T, Mode> DerefMut for RawOrImport<T, Mode> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl<T, Mode> From<T> for RawOrImport<T, Mode> {
    fn from(value: T) -> Self {
        Self(value, PhantomData)
    }
}