100 lines
2.6 KiB
Rust
100 lines
2.6 KiB
Rust
use server_framework::{Decode, Encode};
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum LogLevel {
|
|
Error,
|
|
Warn,
|
|
Info,
|
|
Debug,
|
|
}
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
pub enum LogRequest {
|
|
Write { level: LogLevel, tag: u16, payload: usize },
|
|
GetCount,
|
|
GetEntry { index: usize },
|
|
}
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
pub enum LogResponse {
|
|
Ok,
|
|
Count(usize),
|
|
Entry { level: LogLevel, tag: u16, payload: usize },
|
|
NotFound,
|
|
}
|
|
|
|
fn encode_level(level: LogLevel) -> usize {
|
|
match level {
|
|
LogLevel::Error => 0,
|
|
LogLevel::Warn => 1,
|
|
LogLevel::Info => 2,
|
|
LogLevel::Debug => 3,
|
|
}
|
|
}
|
|
|
|
fn decode_level(v: usize) -> Option<LogLevel> {
|
|
match v {
|
|
0 => Some(LogLevel::Error),
|
|
1 => Some(LogLevel::Warn),
|
|
2 => Some(LogLevel::Info),
|
|
3 => Some(LogLevel::Debug),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
impl Encode for LogRequest {
|
|
fn encode(&self) -> [usize; 4] {
|
|
match self {
|
|
LogRequest::Write { level, tag, payload } => {
|
|
[0, encode_level(*level) | ((*tag as usize) << 8), *payload, 0]
|
|
}
|
|
LogRequest::GetCount => [1, 0, 0, 0],
|
|
LogRequest::GetEntry { index } => [2, *index, 0, 0],
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Decode for LogRequest {
|
|
fn decode(words: [usize; 4]) -> Option<Self> {
|
|
match words[0] {
|
|
0 => {
|
|
let level = decode_level(words[1] & 0xFF)?;
|
|
let tag = ((words[1] >> 8) & 0xFFFF) as u16;
|
|
Some(LogRequest::Write { level, tag, payload: words[2] })
|
|
}
|
|
1 => Some(LogRequest::GetCount),
|
|
2 => Some(LogRequest::GetEntry { index: words[1] }),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Encode for LogResponse {
|
|
fn encode(&self) -> [usize; 4] {
|
|
match self {
|
|
LogResponse::Ok => [0, 0, 0, 0],
|
|
LogResponse::Count(n) => [1, *n, 0, 0],
|
|
LogResponse::Entry { level, tag, payload } => {
|
|
[2, encode_level(*level) | ((*tag as usize) << 8), *payload, 0]
|
|
}
|
|
LogResponse::NotFound => [3, 0, 0, 0],
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Decode for LogResponse {
|
|
fn decode(words: [usize; 4]) -> Option<Self> {
|
|
match words[0] {
|
|
0 => Some(LogResponse::Ok),
|
|
1 => Some(LogResponse::Count(words[1])),
|
|
2 => {
|
|
let level = decode_level(words[1] & 0xFF)?;
|
|
let tag = ((words[1] >> 8) & 0xFFFF) as u16;
|
|
Some(LogResponse::Entry { level, tag, payload: words[2] })
|
|
}
|
|
3 => Some(LogResponse::NotFound),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|