solverforge-solver 0.18.0

Solver engine for SolverForge
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

//! Frozen ownership state for shared list cursors.
//!
//! Raw owner-hook interpretation remains exclusively in list_placement.  This
//! type stores its already-resolved result so candidate pulls cannot re-enter a
//! callback or change their order.

use crate::list_placement::{OwnerRestriction, SelectedOwnerRestrictions};

#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) enum SelectedListOwners {
    Absent,
    FixedToCurrent,
    Mixed(Vec<Vec<OwnerRestriction>>),
}

impl SelectedListOwners {
    pub(crate) fn from_selected_restrictions(
        restrictions: Option<SelectedOwnerRestrictions>,
    ) -> Self {
        match restrictions {
            None => Self::Absent,
            Some(SelectedOwnerRestrictions::FixedToCurrent) => Self::FixedToCurrent,
            Some(SelectedOwnerRestrictions::Mixed(owners)) => Self::Mixed(owners),
        }
    }

    pub(crate) fn is_fixed_to_current(&self) -> bool {
        matches!(self, Self::FixedToCurrent)
    }

    pub(crate) fn is_present(&self) -> bool {
        !matches!(self, Self::Absent)
    }

    pub(crate) fn has_matrix(&self) -> bool {
        matches!(self, Self::Mixed(_))
    }

    pub(crate) fn allows(
        &self,
        selected_entity_index: usize,
        position: usize,
        destination_entity: usize,
    ) -> bool {
        match self {
            Self::Absent | Self::FixedToCurrent => true,
            Self::Mixed(owners) => owners
                .get(selected_entity_index)
                .and_then(|route| route.get(position))
                .copied()
                .is_some_and(|restriction| restriction.allows(destination_entity)),
        }
    }

    pub(crate) fn restriction_at(
        &self,
        selected_entity_index: usize,
        position: usize,
    ) -> Option<OwnerRestriction> {
        match self {
            Self::Mixed(owners) => owners
                .get(selected_entity_index)
                .and_then(|route| route.get(position))
                .copied(),
            Self::Absent | Self::FixedToCurrent => None,
        }
    }

    pub(crate) fn segment_allows(
        &self,
        selected_entity_index: usize,
        start: usize,
        end: usize,
        destination_entity: usize,
    ) -> bool {
        match self {
            Self::Absent | Self::FixedToCurrent => true,
            Self::Mixed(owners) => owners.get(selected_entity_index).is_some_and(|route| {
                (start..end).all(|position| {
                    route
                        .get(position)
                        .copied()
                        .is_some_and(|restriction| restriction.allows(destination_entity))
                })
            }),
        }
    }
}