113 lines
2.5 KiB
Rust
113 lines
2.5 KiB
Rust
use std::collections::HashMap;
|
|
use std::thread::Thread;
|
|
|
|
use async_trait::async_trait;
|
|
use chrono::{DateTime, TimeZone, Utc};
|
|
|
|
use super::{Msg, MsgStore, Path, Tree};
|
|
|
|
#[derive(Clone)]
|
|
pub struct DummyMsg {
|
|
id: usize,
|
|
parent: Option<usize>,
|
|
time: DateTime<Utc>,
|
|
nick: String,
|
|
content: String,
|
|
}
|
|
|
|
impl DummyMsg {
|
|
pub fn new<S>(id: usize, nick: S, content: S) -> Self
|
|
where
|
|
S: Into<String>,
|
|
{
|
|
Self {
|
|
id,
|
|
parent: None,
|
|
time: Utc.timestamp(0, 0),
|
|
nick: nick.into(),
|
|
content: content.into(),
|
|
}
|
|
}
|
|
|
|
pub fn parent(mut self, parent: usize) -> Self {
|
|
self.parent = Some(parent);
|
|
self
|
|
}
|
|
}
|
|
|
|
impl Msg for DummyMsg {
|
|
type Id = usize;
|
|
|
|
fn id(&self) -> Self::Id {
|
|
self.id
|
|
}
|
|
|
|
fn parent(&self) -> Option<Self::Id> {
|
|
self.parent
|
|
}
|
|
|
|
fn time(&self) -> DateTime<Utc> {
|
|
self.time
|
|
}
|
|
|
|
fn nick(&self) -> String {
|
|
self.nick.clone()
|
|
}
|
|
|
|
fn content(&self) -> String {
|
|
self.content.clone()
|
|
}
|
|
}
|
|
|
|
pub struct DummyStore {
|
|
msgs: HashMap<usize, DummyMsg>,
|
|
children: HashMap<usize, Vec<usize>>,
|
|
}
|
|
|
|
impl DummyStore {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
msgs: HashMap::new(),
|
|
children: HashMap::new(),
|
|
}
|
|
}
|
|
|
|
pub fn msg(mut self, msg: DummyMsg) -> Self {
|
|
if let Some(parent) = msg.parent {
|
|
self.children.entry(parent).or_default().push(msg.id());
|
|
}
|
|
self.msgs.insert(msg.id(), msg);
|
|
self
|
|
}
|
|
|
|
fn collect_tree(&self, id: usize, result: &mut Vec<DummyMsg>) {
|
|
if let Some(msg) = self.msgs.get(&id) {
|
|
result.push(msg.clone());
|
|
if let Some(children) = self.children.get(&id) {
|
|
for child in children {
|
|
self.collect_tree(*child, result);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl MsgStore<DummyMsg> for DummyStore {
|
|
async fn path(&self, _room: &str, id: &usize) -> Path<usize> {
|
|
let mut id = *id;
|
|
let mut segments = vec![id];
|
|
while let Some(parent) = self.msgs.get(&id).and_then(|msg| msg.parent) {
|
|
segments.push(parent);
|
|
id = parent;
|
|
}
|
|
segments.reverse();
|
|
Path::new(segments)
|
|
}
|
|
|
|
async fn thread(&self, _room: &str, root: &usize) -> Tree<DummyMsg> {
|
|
let mut msgs = vec![];
|
|
self.collect_tree(*root, &mut msgs);
|
|
Tree::new(*root, msgs)
|
|
}
|
|
}
|