sd-journal 0.1.0

A wrapper for sd-journal implemented in libsystemd.
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

// sd-journal: rust wrapper on sd-journal implemented in libsystemd
// Copyright (C) 2020 Christian Klaue ente@ck76.de
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.
use super::*;

/// Iterator over entries in the journal
pub struct CursorIterator<'a> {
    pub(crate) journal: &'a Journal
}

/// Iterator over entries in the journal in reverse order
pub struct CursorReverseIterator<'a> {
    pub(crate) journal: &'a Journal
}

/// Iterator over the fields of a journal entry record
pub struct Fields<'a> {
    pub(crate) journal: &'a Journal
}

/// Iterator over the field names of the journal
pub struct FieldNames<'a> {
    pub(crate) journal: &'a Journal
}

/// Iterator over unique values assigned to a field in the journal
pub struct UniqueValues<'a> {
    pub(crate) journal: &'a Journal
}

impl<'a> Iterator for CursorIterator<'a> {
    type Item = Result<Cursor<'a>, Error>;

    fn next(&mut self) -> Option<Self::Item> {
        match self.journal.next() {
            Ok(CursorMovement::EoF) => None,
            Ok(CursorMovement::Done) => Some(Ok(Cursor { journal: self.journal })),
            Ok(CursorMovement::Limited(_)) => Some(Ok(Cursor { journal: self.journal })),
            Err(e) => Some(Err(e))
        }
    }
}

impl<'a> Iterator for CursorReverseIterator<'a> {
    type Item = Result<Cursor<'a>, Error>;

    fn next(&mut self) -> Option<Self::Item> {
        match self.journal.previous() {
            Ok(CursorMovement::EoF) => None,
            Ok(CursorMovement::Done) => Some(Ok(Cursor { journal: self.journal })),
            Ok(CursorMovement::Limited(_)) => Some(Ok(Cursor { journal: self.journal })),
            Err(e) => Some(Err(e))
        }
    }
}

impl<'a> IntoIterator for &'a Journal {
    type IntoIter = CursorIterator<'a>;
    type Item = Result<Cursor<'a>, Error>;

    fn into_iter(self) -> Self::IntoIter {
        CursorIterator { journal: self }
    }
}

impl<'a> IntoIterator for Cursor<'a> {
    type IntoIter = Fields<'a>;
    type Item = Result<(String, String), Error>;

    fn into_iter(self) -> Self::IntoIter {
        Fields { journal: self.journal }
    }
}

impl<'a> Iterator for Fields<'a> {
    type Item = Result<(String, String), Error>;

    fn next(&mut self) -> Option<Self::Item> {
        match self.journal.enumerate_fields() {
            Ok(Enumeration::EoF) => None,
            Ok(Enumeration::Value(v)) => Some(Ok(v)),
            Err(e) => Some(Err(e))
        }
    }
}

impl<'a> Iterator for UniqueValues<'a> {
    type Item = Result<String, Error>;

    fn next(&mut self) -> Option<Self::Item> {
        match self.journal.enumerate_unique_values() {
            Ok(Enumeration::EoF) => None,
            Ok(Enumeration::Value(value)) => Some(Ok(value)),
            Err(e) => Some(Err(e))
        }
    }
}

impl<'a> Iterator for FieldNames<'a> {
    type Item = Result<String, Error>;

    fn next(&mut self) -> Option<Self::Item> {
        match self.journal.enumerate_field_names() {
            Ok(Enumeration::EoF) => None,
            Ok(Enumeration::Value(v)) => Some(Ok(v)),
            Err(e) => Some(Err(e))
        }
    }
}