sddl 0.1.9

a library to parse and analyse SDDL Strings
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

use binrw::{BinRead, BinReaderExt, BinWrite, BinWriterExt};
use enumflags2::{bitflags, BitFlags};
use serde::Serialize;

use crate::*;
#[bitflags]
#[derive(Eq, PartialEq, Clone, Copy, Debug, Serialize)]
#[repr(u32)]
#[allow(non_camel_case_types)]
pub enum Flag {
    ACE_OBJECT_TYPE_PRESENT = 0x00000001,
    ACE_INHERITED_OBJECT_TYPE_PRESENT = 0x00000002,
}

#[derive(Eq, PartialEq, Clone, Copy, Debug, Serialize)]
pub struct Flags(BitFlags<Flag, u32>);

impl Flags {
    pub const EMPTY: Flags = Self(BitFlags::<Flag, u32>::EMPTY);
}

impl From<BitFlags<Flag, u32>> for Flags {
    fn from(value: BitFlags<Flag, u32>) -> Self {
        Self(value)
    }
}

impl AsRef<BitFlags<Flag, u32>> for Flags {
    fn as_ref(&self) -> &BitFlags<Flag, u32> {
        &self.0
    }
}

impl RawSize for Flags {
    fn raw_size(&self) -> u16 {
        std::mem::size_of::<Flags>() as u16
    }
}

impl BinRead for Flags {
    type Args<'a> = ();

    fn read_options<R: std::io::Read + std::io::Seek>(
        reader: &mut R,
        endian: binrw::Endian,
        args: Self::Args<'_>,
    ) -> binrw::BinResult<Self> {
        let raw_value: u32 = reader.read_type_args(endian, args)?;
        Ok(Self(BitFlags::<Flag, u32>::from_bits(raw_value).unwrap()))
    }
}

impl BinWrite for Flags {
    type Args<'a> = ();

    fn write_options<W: std::io::Write + std::io::Seek>(
        &self,
        writer: &mut W,
        endian: binrw::Endian,
        args: Self::Args<'_>,
    ) -> binrw::BinResult<()> {
        let raw_value = self.0.bits();
        writer.write_type_args(&raw_value, endian, args)
    }
}