sl-types 0.8.0

Some basic types for Second Life related tools
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

//! Parcel value types: access-list flags and object-return classifications.

use crate::serde_helpers::impl_bitfield_serde;

/// The per-entry classification flags on a parcel access (allow) or ban list.
///
/// A bitfield carried by every entry of a parcel access-list reply (alongside
/// the whole-list scope). On Second Life an entry can be flagged as an
/// experience allow/block in addition to the plain access/ban list it belongs
/// to; OpenSim sets the per-entry flags equal to the list's scope. Combine the
/// constants with [`ParcelAccessFlags::union`].
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[expect(
    clippy::module_name_repetitions,
    reason = "the type is going to be used outside this module"
)]
pub struct ParcelAccessFlags(pub u32);

impl ParcelAccessFlags {
    /// No flags set.
    pub const NONE: Self = Self(0);
    /// The entry is on the access (allow) list (`AL_ACCESS`, `1 << 0`).
    pub const ACCESS: Self = Self(1 << 0);
    /// The entry is on the ban list (`AL_BAN`, `1 << 1`).
    pub const BAN: Self = Self(1 << 1);
    /// The entry allows an experience (`AL_ALLOW_EXPERIENCE`, `1 << 3`).
    pub const ALLOW_EXPERIENCE: Self = Self(1 << 3);
    /// The entry blocks an experience (`AL_BLOCK_EXPERIENCE`, `1 << 4`).
    pub const BLOCK_EXPERIENCE: Self = Self(1 << 4);

    /// Combines two sets of access flags.
    #[must_use]
    pub const fn union(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }

    /// Whether every bit of `other` is set in `self`.
    #[must_use]
    pub const fn contains(self, other: Self) -> bool {
        self.0 & other.0 == other.0
    }

    /// Whether no flags are set.
    #[must_use]
    pub const fn is_empty(self) -> bool {
        self.0 == 0
    }
}

impl_bitfield_serde!(
    ParcelAccessFlags,
    u32,
    "ACCESS" => ParcelAccessFlags::ACCESS.0,
    "BAN" => ParcelAccessFlags::BAN.0,
    "ALLOW_EXPERIENCE" => ParcelAccessFlags::ALLOW_EXPERIENCE.0,
    "BLOCK_EXPERIENCE" => ParcelAccessFlags::BLOCK_EXPERIENCE.0,
);

/// The kinds of objects to return or select on a parcel, as the `ReturnType` of
/// a parcel object-return or object-select request. A bitfield: combine the
/// constants with [`ParcelReturnType::union`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[expect(
    clippy::module_name_repetitions,
    reason = "the type is going to be used outside this module"
)]
pub struct ParcelReturnType(pub u32);

impl ParcelReturnType {
    /// No objects (`RT_NONE`).
    pub const NONE: Self = Self(1 << 0);
    /// Objects owned by the parcel's owner (`RT_OWNER`).
    pub const OWNER: Self = Self(1 << 1);
    /// Objects set to the parcel's group (`RT_GROUP`).
    pub const GROUP: Self = Self(1 << 2);
    /// Objects owned by anyone else (`RT_OTHER`).
    pub const OTHER: Self = Self(1 << 3);
    /// Only the objects in the supplied id list (`RT_LIST`).
    pub const LIST: Self = Self(1 << 4);
    /// Objects that are for sale (`RT_SELL`).
    pub const SELL: Self = Self(1 << 5);

    /// Combines two sets of return-type bits.
    #[must_use]
    pub const fn union(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl_bitfield_serde!(
    ParcelReturnType,
    u32,
    "NONE" => ParcelReturnType::NONE.0,
    "OWNER" => ParcelReturnType::OWNER.0,
    "GROUP" => ParcelReturnType::GROUP.0,
    "OTHER" => ParcelReturnType::OTHER.0,
    "LIST" => ParcelReturnType::LIST.0,
    "SELL" => ParcelReturnType::SELL.0,
);