fastobo 0.15.5

Faultless AST for Open Biomedical Ontologies.
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

use std::fmt::Display;
use std::fmt::Formatter;
use std::fmt::Result as FmtResult;
use std::fmt::Write;

use fastobo_derive_internal::FromStr;

use crate::ast::*;
use crate::error::SyntaxError;
use crate::parser::Cache;
use crate::parser::FromPair;
use crate::syntax::pest::iterators::Pair;
use crate::syntax::Rule;

/// An entity textual definition, with optional cross-references supporting it.
#[derive(Clone, Debug, Eq, Hash, FromStr, Ord, PartialEq, PartialOrd)]
pub struct Definition {
    text: QuotedString,
    xrefs: XrefList,
}

impl Definition {
    pub fn new<T>(text: T) -> Self
    where
        T: Into<QuotedString>,
    {
        Self::with_xrefs(text, XrefList::default())
    }

    pub fn with_xrefs<T, L>(text: T, xrefs: L) -> Self
    where
        T: Into<QuotedString>,
        L: Into<XrefList>,
    {
        Self {
            text: text.into(),
            xrefs: xrefs.into(),
        }
    }

    pub fn text(&self) -> &QuotedString {
        &self.text
    }

    pub fn text_mut(&mut self) -> &mut QuotedString {
        &mut self.text
    }

    pub fn xrefs(&self) -> &XrefList {
        &self.xrefs
    }

    pub fn xrefs_mut(&mut self) -> &mut XrefList {
        &mut self.xrefs
    }
}

impl Display for Definition {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        self.text
            .fmt(f)
            .and_then(|_| f.write_char(' '))
            .and_then(|_| self.xrefs.fmt(f))
    }
}

impl From<Definition> for QuotedString {
    fn from(d: Definition) -> Self {
        d.text
    }
}

impl From<QuotedString> for Definition {
    fn from(s: QuotedString) -> Self {
        Self::new(s)
    }
}

impl<'i> FromPair<'i> for Definition {
    const RULE: Rule = Rule::Definition;
    unsafe fn from_pair_unchecked(
        pair: Pair<'i, Rule>,
        cache: &Cache,
    ) -> Result<Self, SyntaxError> {
        let mut inner = pair.into_inner();
        let text = QuotedString::from_pair_unchecked(inner.next().unwrap(), cache)?;
        let xrefs = XrefList::from_pair_unchecked(inner.next().unwrap(), cache)?;
        Ok(Self::with_xrefs(text, xrefs))
    }
}