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
|
// Copyright 2015 Till Höppner
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//! Common structures to represent the actual log data in memory.
//! These will be used by all formats for encoding and decoding.
use std::borrow::Cow;
use chrono::naive::time::NaiveTime;
use chrono::offset::fixed::FixedOffset;
use chrono::offset::TimeZone;
/// A whole log, in memory. This structure does not specify its
/// use. It may represent a private query, or the log of a channel.
pub struct Log<'a> {
pub entries: Vec<Event<'a>>
}
/// Different log formats carry different amounts of information. Some might
/// hold enough information to calculate precise timestamps, others might
/// only suffice for the time of day.
#[derive(Clone, Debug, PartialEq, Hash, RustcEncodable, RustcDecodable)]
pub enum Time {
Unknown,
Hms(u8, u8, u8),
Timestamp(i64)
}
impl Time {
pub fn from_format(tz: &FixedOffset, s: &str, f: &str) -> Time {
tz.datetime_from_str(s, f)
.map(|d| d.timestamp())
.map(Time::Timestamp)
.unwrap_or(Time::Unknown)
}
pub fn with_format(&self, tz: &FixedOffset, f: &str) -> String {
match self {
&Time::Unknown => panic!("Time data for this event is not present"),
&Time::Hms(h, m, s) => format!("{}",
NaiveTime::from_hms(h as u32, m as u32, s as u32).format(f)),
&Time::Timestamp(t) => format!("{}", tz.timestamp(t, 0).format(f))
}
}
}
#[derive(Clone, Debug, PartialEq, Hash, RustcEncodable, RustcDecodable)]
pub struct Event<'a> {
pub ty: Type<'a>,
pub time: Time,
pub channel: Option<Cow<'a, str>>
}
/// All representable events, such as messages, quits, joins
/// and topic changes.
#[derive(Clone, Debug, Hash, PartialEq, RustcEncodable, RustcDecodable)]
pub enum Type<'a> {
Connect,
Disconnect,
Msg {
from: Cow<'a, str>,
content: Cow<'a, str>,
},
Action {
from: Cow<'a, str>,
content: Cow<'a, str>,
},
Join {
nick: Cow<'a, str>,
mask: Option<Cow<'a, str>>,
},
Part {
nick: Cow<'a, str>,
mask: Option<Cow<'a, str>>,
reason: Option<Cow<'a, str>>,
},
Quit {
nick: Cow<'a, str>,
mask: Option<Cow<'a, str>>,
reason: Option<Cow<'a, str>>,
},
Nick {
old_nick: Cow<'a, str>,
new_nick: Cow<'a, str>,
},
Notice {
from: Cow<'a, str>,
content: Cow<'a, str>,
},
Kick {
kicked_nick: Cow<'a, str>,
kicking_nick: Option<Cow<'a, str>>,
kick_message: Option<Cow<'a, str>>,
},
Topic {
topic: Cow<'a, str>,
},
TopicChange {
nick: Option<Cow<'a, str>>,
new_topic: Cow<'a, str>,
},
Mode {
nick: Option<Cow<'a, str>>,
mode: Cow<'a, str>,
masks: Cow<'a, str>
}
}
|