open-timeline-core 0.1.0

OpenTimeline core
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

// SPDX-License-Identifier: MIT

//!
//! The OpenTimeline timeline view type
//!

use crate::{HasIdAndName, Name, OpenTimelineId, ReducedEntities, ReducedTimelines};
use bool_tag_expr::{BoolTagExpr, Tags};
use serde::{Deserialize, Serialize};

/// Represents the information needed for creating and updating a timeline
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct TimelineEdit {
    /// The timeline's ID
    id: Option<OpenTimelineId>,

    /// The timeline's name
    name: Name,

    /// The timeline's direct `Entity`s
    bool_expr: Option<BoolTagExpr>,

    /// The timeline's direct `Entity`s
    entities: Option<ReducedEntities>,

    /// The timeline's direct subtimelines
    subtimelines: Option<ReducedTimelines>,

    /// The timeline's tags
    tags: Option<Tags>,
}

impl TimelineEdit {
    /// Create a new [`TimelineEdit`]
    pub fn from(
        id: Option<OpenTimelineId>,
        name: Name,
        bool_expr: Option<BoolTagExpr>,
        entities: Option<ReducedEntities>,
        subtimelines: Option<ReducedTimelines>,
        tags: Option<Tags>,
    ) -> Result<TimelineEdit, ()> {
        let mut timeline = TimelineEdit {
            id,
            name,
            bool_expr,
            entities: None,
            subtimelines: None,
            tags: None,
        };

        // TODO: some validation?
        timeline.entities = entities;
        timeline.subtimelines = subtimelines;
        timeline.tags = tags;
        Ok(timeline)
    }

    /// Clear the timeline's ID
    pub fn clear_id(&mut self) {
        self.id = None;
    }

    /// Clear the timeline's boolean tag expr
    pub fn clear_bool_expr(&mut self) {
        self.bool_expr = None;
    }

    /// Clear the timeline's entities
    pub fn clear_entities(&mut self) {
        self.entities = None;
    }

    /// Clear the timeline's subtimelines
    pub fn clear_subtimelines(&mut self) {
        self.subtimelines = None;
    }

    /// Clear the timeline's tags
    pub fn clear_tags(&mut self) {
        self.tags = None;
    }

    /// Borrow the timeline's boolean tag expr
    pub fn bool_expr(&self) -> &Option<BoolTagExpr> {
        &self.bool_expr
    }

    /// Borrow the timeline's entities
    pub fn entities(&self) -> &Option<ReducedEntities> {
        &self.entities
    }

    /// Borrow the timeline's subtimelines
    pub fn subtimelines(&self) -> &Option<ReducedTimelines> {
        &self.subtimelines
    }

    /// Borrow the timeline's tags
    pub fn tags(&self) -> &Option<Tags> {
        &self.tags
    }
}

impl HasIdAndName for TimelineEdit {
    fn id(&self) -> Option<OpenTimelineId> {
        self.id
    }

    fn set_id(&mut self, id: OpenTimelineId) {
        self.id = Some(id)
    }

    fn name(&self) -> &Name {
        &self.name
    }

    fn set_name(&mut self, name: Name) {
        self.name = name
    }
}