somedoc 0.2.10

A very simple document model and markup generator.
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
122
123
124
125
126
127
128
129
130
131
132

use crate::error;
use crate::model::block::{BlockContent, Label};
use crate::model::inline::{HasInlineContent, InlineContent};
use crate::model::{block::HasLabel, HasInnerContent};
#[cfg(feature = "fmt_json")]
use serde::{Deserialize, Serialize};

// ------------------------------------------------------------------------------------------------
// Public Types
// ------------------------------------------------------------------------------------------------

///
/// A list of terms and definitions, this may be used for terminology, glossaries, or acronym
/// expansion.
///
/// Notes
///
/// 1. While some markup languages support a single definition for multiple terms, or multiple
///    definitions for the same term, `DefinitionList` only supports a one-to-one relationship.
/// 1. A `DefinitionList` is also not hierarchical, definition lists only contain definitions.
/// 1. A `Definition` consists of a string term and a `DefinitionPart` that is an inline content
///    container.
///
#[derive(Clone, Debug)]
#[cfg_attr(feature = "fmt_json", derive(Serialize, Deserialize))]
pub struct DefinitionList {
    #[cfg_attr(feature = "fmt_json", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "fmt_json", serde(default))]
    label: Option<Label>,
    inner: Vec<Definition>,
}

///
/// A single definition within the list.
///
#[derive(Clone, Debug)]
#[cfg_attr(feature = "fmt_json", derive(Serialize, Deserialize))]
pub struct Definition {
    #[cfg_attr(feature = "fmt_json", serde(skip_serializing_if = "Option::is_none"))]
    #[cfg_attr(feature = "fmt_json", serde(default))]
    label: Option<Label>,
    term: String,
    text: DefinitionPart,
}

///
/// The `Definition` text, it's inner content list of `InlineContent` values.
///
#[derive(Clone, Debug)]
#[cfg_attr(feature = "fmt_json", derive(Serialize, Deserialize))]
pub struct DefinitionPart {
    inner: Vec<InlineContent>,
}

// ------------------------------------------------------------------------------------------------
// Implementations
// ------------------------------------------------------------------------------------------------

impl Default for DefinitionList {
    fn default() -> Self {
        Self {
            label: None,
            inner: Default::default(),
        }
    }
}

label_impl!(DefinitionList);

block_impls!(DefinitionList);

impl DefinitionList {
    /// Return `true` if this list contains any definitions, else `false`.
    pub fn has_inner(&self) -> bool {
        !self.inner.is_empty()
    }

    /// Return the list of definitions in this list.
    pub fn inner(&self) -> &Vec<Definition> {
        &self.inner
    }

    // --------------------------------------------------------------------------------------------

    /// Add a new definition to this list.
    pub fn add_definition(&mut self, item: Definition) -> &mut Self {
        self.inner.push(item);
        self
    }

    /// Add a new definition to this list.
    pub fn add_definition_from(&mut self, term: &str, text: DefinitionPart) -> &mut Self {
        self.add_definition(Definition::new(term, text))
    }
}

// ------------------------------------------------------------------------------------------------

label_impl!(Definition);

impl Definition {
    /// Create a new definition, a term and its corresponding text.
    pub fn new(term: &str, text: DefinitionPart) -> Self {
        Self {
            label: None,
            term: term.to_string(),
            text,
        }
    }

    /// Return the term part of this definition.
    pub fn term(&self) -> &String {
        &self.term
    }

    /// Return the text part of this definition.
    pub fn text(&self) -> &DefinitionPart {
        &self.text
    }
}

// ------------------------------------------------------------------------------------------------

impl Default for DefinitionPart {
    fn default() -> Self {
        Self {
            inner: Default::default(),
        }
    }
}

has_inline_impls!(DefinitionPart);