aterm 0.13.0

Implementation of the Annotated Terms data structure
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

use interface;
use interface::Term;
use print::ATermWrite;

use std::fmt;
use std::rc::Rc;
use std::marker::PhantomData;

pub mod shared;

#[derive(Debug, PartialEq, Eq, Clone, Hash)]
pub struct ATerm<B>(interface::ATermInner<Rc<ATerm<B>>, B>);

impl<B> ATerm<B> {
    pub fn no_annos(term: Term<Rc<ATerm<B>>, B>) -> Self {
        ATerm(interface::ATermInner::no_annos(term))
    }

    pub fn with_annos<A>(term: Term<Rc<ATerm<B>>, B>, annos: A) -> Self
        where A: IntoIterator<Item = Rc<ATerm<B>>>
    {
        ATerm(interface::ATermInner::with_annos(term, annos))
    }
}

impl<B> interface::ATerm for ATerm<B> {
    type Rec = Rc<ATerm<B>>;
    type Blob = B;

    #[inline]
    fn into_inner(self) -> interface::ATermInner<Rc<ATerm<B>>, B> {
        self.0
    }
    #[inline]
    fn as_inner(&self) -> &interface::ATermInner<Rc<ATerm<B>>, B> {
        &self.0
    }
}

impl<B> fmt::Display for ATerm<B>
    where B: ATermWrite
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.to_ascii(f)
    }
}

impl<'a, B: 'a + ATermWrite> ATermWrite for ATerm<B> {
    #[inline]
    fn to_ascii<W: fmt::Write>(&self, writer: &mut W) -> fmt::Result {
        self.0.to_ascii(writer)
    }

    #[inline]
    fn to_taf<W: fmt::Write>(&self, writer: &mut W) -> fmt::Result {
        self.0.to_taf(writer)
    }

    #[inline]
    fn to_baf<W: fmt::Write>(&self, writer: &mut W) -> fmt::Result {
        self.0.to_baf(writer)
    }

    #[inline]
    fn to_saf<W: fmt::Write>(&self, writer: &mut W) -> fmt::Result {
        self.0.to_saf(writer)
    }
}

#[derive(Default, Debug)]
pub struct ATermFactory<B> {
    _nothing: PhantomData<ATerm<B>>,
}

impl<B> ATermFactory<B> {
    pub fn new() -> Self {
        ATermFactory { _nothing: PhantomData }
    }
}

impl<B: Clone> interface::ATermFactory<B> for ATermFactory<B> {
    type ATerm = ATerm<B>;
    type ATermRef = Rc<ATerm<B>>;

    fn no_annos(&self, term: Term<Rc<ATerm<B>>, B>) -> Self::ATermRef {
        Rc::new(ATerm::no_annos(term))
    }

    fn with_annos<A>(&self, term: Term<Rc<ATerm<B>>, B>, annos: A) -> Self::ATermRef
        where A: IntoIterator<Item = Self::ATermRef>
    {
        Rc::new(ATerm::with_annos(term, annos))
    }
}