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 id::ID;
use qdf::state::State;

#[derive(Debug, Clone)]
pub enum LevelData {
    SubLevels(Vec<ID>),
    Field(ID),
}

impl LevelData {
    #[inline]
    pub fn is_sublevels(&self) -> bool {
        match self {
            LevelData::SubLevels(_) => true,
            _ => false,
        }
    }

    #[inline]
    pub fn is_field(&self) -> bool {
        match self {
            LevelData::Field(_) => true,
            _ => false,
        }
    }

    #[inline]
    pub fn as_sublevels(&self) -> &[ID] {
        if let LevelData::SubLevels(sublevels) = self {
            sublevels
        } else {
            panic!("LevelData does not contains sublevels: {:?}", self);
        }
    }

    #[inline]
    pub fn as_field(&self) -> ID {
        if let LevelData::Field(id) = self {
            *id
        } else {
            panic!("LevelData does not contains field: {:?}", self);
        }
    }
}

#[derive(Debug, Clone)]
pub struct Level<S>
where
    S: State,
{
    id: ID,
    parent: Option<ID>,
    level: usize,
    index: usize,
    state: S,
    data: LevelData,
}

impl<S> Level<S> where S: State {
    #[inline]
    pub(crate) fn new(
        id: ID,
        parent: Option<ID>,
        level: usize,
        index: usize,
        state: S,
    ) -> Self {
        Self {
            id,
            parent,
            level,
            index,
            state,
            data: LevelData::SubLevels(vec![]),
        }
    }

    #[inline]
    pub fn id(&self) -> ID {
        self.id
    }

    #[inline]
    pub fn parent(&self) -> Option<ID> {
        self.parent
    }

    #[inline]
    pub fn level(&self) -> usize {
        self.level
    }

    #[inline]
    pub fn index(&self) -> usize {
        self.index
    }

    #[inline]
    pub fn state(&self) -> &S {
        &self.state
    }

    #[inline]
    pub fn data(&self) -> &LevelData {
        &self.data
    }

    #[inline]
    pub(crate) fn apply_state(&mut self, state: S) {
        self.state = state;
    }

    #[inline]
    pub(crate) fn apply_data(&mut self, data: LevelData) {
        self.data = data;
    }
}