iztro 0.4.0

Strongly typed Zi Wei Dou Shu chart generation aligned with iztro.
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

use crate::core::{Brightness, Mutagen, PalaceName, Scope, StarCategory, StarKind, StarName};
use crate::features::domains::Domain;
use serde::{Deserialize, Serialize};

/// Factual feature derived from a star placement.
///
/// This preserves the deterministic placement facts (palace, star, fine star
/// type, brightness, birth-year mutagen, scope) for every placed star. The
/// semantic [`Domain`] of the containing palace is optional metadata: it is
/// present only when the palace maps to a supported domain and is `None`
/// otherwise. It performs no interpretation.
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct StarFeature {
    palace: PalaceName,
    star: StarName,
    kind: StarKind,
    brightness: Brightness,
    mutagen: Option<Mutagen>,
    scope: Scope,
    domain: Option<Domain>,
}

impl StarFeature {
    /// Creates a star feature from placement facts and an optional semantic domain.
    pub const fn new(
        palace: PalaceName,
        star: StarName,
        kind: StarKind,
        brightness: Brightness,
        mutagen: Option<Mutagen>,
        scope: Scope,
        domain: Option<Domain>,
    ) -> Self {
        Self {
            palace,
            star,
            kind,
            brightness,
            mutagen,
            scope,
            domain,
        }
    }

    /// Returns the source palace.
    pub const fn palace(&self) -> PalaceName {
        self.palace
    }

    /// Returns the source star.
    pub const fn star(&self) -> StarName {
        self.star
    }

    /// Returns the iztro-compatible fine star type.
    pub const fn kind(&self) -> StarKind {
        self.kind
    }

    /// Returns the coarse palace grouping derived from the fine star type.
    pub const fn category(&self) -> StarCategory {
        self.kind.category()
    }

    /// Returns the star brightness.
    pub const fn brightness(&self) -> Brightness {
        self.brightness
    }

    /// Returns the optional birth-year mutagen attached to this placement.
    pub const fn mutagen(&self) -> Option<Mutagen> {
        self.mutagen
    }

    /// Returns the scope of the underlying placement.
    pub const fn scope(&self) -> Scope {
        self.scope
    }

    /// Returns the semantic domain of the palace this star occupies, if supported.
    pub const fn domain(&self) -> Option<Domain> {
        self.domain
    }
}