275 lines
8.0 KiB
Rust
275 lines
8.0 KiB
Rust
use dever_runtime::wire::{
|
|
self,
|
|
serde::{self, Deserialize, Serialize},
|
|
};
|
|
|
|
struct Object<Value>(Value);
|
|
|
|
impl<'input, Value: Deserialize<'input>> Deserialize<'input> for Object<Value> {
|
|
fn deserialize<Decoder: serde::Deserializer<'input>>(
|
|
decoder: Decoder,
|
|
) -> Result<Self, Decoder::Error> {
|
|
wire::object(decoder).map(Self)
|
|
}
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(crate = "dever_runtime::wire::serde", deny_unknown_fields)]
|
|
struct Greeting {
|
|
name: String,
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(crate = "dever_runtime::wire::serde", deny_unknown_fields)]
|
|
struct Integer {
|
|
value: i64,
|
|
}
|
|
|
|
#[derive(Deserialize, Serialize)]
|
|
#[serde(crate = "dever_runtime::wire::serde", deny_unknown_fields)]
|
|
struct Profile {
|
|
id: Id,
|
|
name: String,
|
|
scores: Vec<i64>,
|
|
ratio: Option<f64>,
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(crate = "dever_runtime::wire::serde", deny_unknown_fields)]
|
|
struct Echo {
|
|
value: Object<Profile>,
|
|
}
|
|
|
|
fn fault(_: String) -> Fault {
|
|
&FaultInfo {
|
|
message: "command failure",
|
|
source: "reference.dever",
|
|
line: 1,
|
|
column: 1,
|
|
}
|
|
}
|
|
|
|
fn greeting_generated(values: &[&str]) -> Result<String, Fault> {
|
|
GENERATED_GREETING(values.first().copied().unwrap_or(r#"{"name":""}"#)).map_err(fault)
|
|
}
|
|
|
|
fn greeting_reference(values: &[&str]) -> Result<String, Fault> {
|
|
let input: Object<Greeting> =
|
|
wire::decode(values.first().copied().unwrap_or(r#"{"name":""}"#)).map_err(fault)?;
|
|
let mut result = String::with_capacity(input.0.name.len() + 9);
|
|
result.push_str("[Hello, ");
|
|
result.push_str(&input.0.name);
|
|
result.push(']');
|
|
wire::response(&result).map_err(fault)
|
|
}
|
|
|
|
fn echo_generated(values: &[&str]) -> Result<String, Fault> {
|
|
GENERATED_ECHO(
|
|
values
|
|
.first()
|
|
.copied()
|
|
.unwrap_or(r#"{"value":{"id":"","name":"","scores":[]}}"#),
|
|
)
|
|
.map_err(fault)
|
|
}
|
|
|
|
fn echo_reference(values: &[&str]) -> Result<String, Fault> {
|
|
let input: Object<Echo> = wire::decode(
|
|
values
|
|
.first()
|
|
.copied()
|
|
.unwrap_or(r#"{"value":{"id":"","name":"","scores":[]}}"#),
|
|
)
|
|
.map_err(fault)?;
|
|
let result = input.0.value.0;
|
|
if result.ratio.is_some_and(|value| !value.is_finite()) {
|
|
return Err(fault("non-finite Float".into()));
|
|
}
|
|
wire::response(&result).map_err(fault)
|
|
}
|
|
|
|
fn double_generated(values: &[&str]) -> Result<String, Fault> {
|
|
GENERATED_DOUBLE(values.first().copied().unwrap_or(r#"{"value":0}"#)).map_err(fault)
|
|
}
|
|
|
|
fn double_reference(values: &[&str]) -> Result<String, Fault> {
|
|
let input: Object<Integer> =
|
|
wire::decode(values.first().copied().unwrap_or(r#"{"value":0}"#)).map_err(fault)?;
|
|
let result = input
|
|
.0
|
|
.value
|
|
.checked_mul(2)
|
|
.ok_or_else(|| fault("overflow".into()))?;
|
|
wire::response(&result).map_err(fault)
|
|
}
|
|
|
|
// 独立对照只处理这里的固定标量 record；结构预算由这两个协议本身保证。
|
|
// 不调用 Dever 的 object/decode/response，也不替换原来的共享运行库对照。
|
|
fn rust_input<Value: serde::de::DeserializeOwned>(input: &str) -> Result<Value, Fault> {
|
|
if input.len() > 16 * 1024 * 1024 {
|
|
return Err(fault("input limit".into()));
|
|
}
|
|
struct Record<Value>(std::marker::PhantomData<Value>);
|
|
impl<'input, Value: Deserialize<'input>> serde::de::Visitor<'input> for Record<Value> {
|
|
type Value = Value;
|
|
fn expecting(&self, output: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
output.write_str("an object")
|
|
}
|
|
fn visit_map<Access: serde::de::MapAccess<'input>>(
|
|
self,
|
|
access: Access,
|
|
) -> Result<Value, Access::Error> {
|
|
Value::deserialize(serde::de::value::MapAccessDeserializer::new(access))
|
|
}
|
|
}
|
|
let mut decoder = serde_json::Deserializer::from_str(input);
|
|
let value =
|
|
serde::Deserializer::deserialize_map(&mut decoder, Record(std::marker::PhantomData))
|
|
.map_err(|error| fault(error.to_string()))?;
|
|
decoder.end().map_err(|error| fault(error.to_string()))?;
|
|
Ok(value)
|
|
}
|
|
|
|
fn rust_response<Value: Serialize>(data: Value) -> Result<String, Fault> {
|
|
#[derive(Serialize)]
|
|
#[serde(crate = "dever_runtime::wire::serde")]
|
|
struct Response<Value> {
|
|
code: u16,
|
|
message: &'static str,
|
|
data: Value,
|
|
}
|
|
struct Buffer(Vec<u8>);
|
|
impl std::io::Write for Buffer {
|
|
fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
|
|
if bytes.len() > 16 * 1024 * 1024 - self.0.len() {
|
|
return Err(std::io::Error::other("output limit"));
|
|
}
|
|
self.0.extend_from_slice(bytes);
|
|
Ok(bytes.len())
|
|
}
|
|
fn flush(&mut self) -> std::io::Result<()> {
|
|
Ok(())
|
|
}
|
|
}
|
|
// 与 serde_json::to_vec 相同；独立 Rust 参照也避免短输出反复扩容。
|
|
let mut output = Buffer(Vec::with_capacity(128));
|
|
serde_json::to_writer(
|
|
&mut output,
|
|
&Response {
|
|
code: 0,
|
|
message: "ok",
|
|
data,
|
|
},
|
|
)
|
|
.map_err(|error| fault(error.to_string()))?;
|
|
Ok(String::from_utf8(output.0).unwrap())
|
|
}
|
|
|
|
fn greeting_rust(values: &[&str]) -> Result<String, Fault> {
|
|
let input: Greeting = rust_input(values.first().copied().unwrap_or(r#"{"name":""}"#))?;
|
|
let mut result = String::with_capacity(input.name.len() + 9);
|
|
result.push_str("[Hello, ");
|
|
result.push_str(&input.name);
|
|
result.push(']');
|
|
rust_response(result)
|
|
}
|
|
|
|
fn double_rust(values: &[&str]) -> Result<String, Fault> {
|
|
let input: Integer = rust_input(values.first().copied().unwrap_or(r#"{"value":0}"#))?;
|
|
rust_response(
|
|
input
|
|
.value
|
|
.checked_mul(2)
|
|
.ok_or_else(|| fault("overflow".into()))?,
|
|
)
|
|
}
|
|
|
|
fn main() {
|
|
for input in [
|
|
r#"{"value":9223372036854775807}"#,
|
|
r#"{"value":1,"value":2}"#,
|
|
"[1]",
|
|
"{}",
|
|
] {
|
|
assert_eq!(
|
|
double_generated(&[input]).is_err(),
|
|
double_reference(&[input]).is_err()
|
|
);
|
|
assert_eq!(
|
|
double_generated(&[input]).is_err(),
|
|
double_rust(&[input]).is_err()
|
|
);
|
|
}
|
|
for input in [
|
|
r#"{"value":["a","b",[],null]}"#,
|
|
r#"{"value":{"id":"a","name":"b","scores":[],"extra":1}}"#,
|
|
] {
|
|
assert_eq!(
|
|
echo_generated(&[input]).is_err(),
|
|
echo_reference(&[input]).is_err()
|
|
);
|
|
}
|
|
let long_name = "雪".repeat(2048);
|
|
let long_greeting = format!("{{\"name\":\"{long_name}\"}}");
|
|
let echo = format!(
|
|
"{{\"value\":{{\"id\":\"a\",\"name\":\"{long_name}\",\"scores\":[1,2,3],\"ratio\":0.5}}}}"
|
|
);
|
|
println!("case,sample,implementation,elapsed_ns,checksum");
|
|
compare(
|
|
"command_greet_short",
|
|
&[r#"{"name":"Dever"}"#],
|
|
50000,
|
|
greeting_generated,
|
|
greeting_reference,
|
|
|value| value.len() as u64,
|
|
);
|
|
compare(
|
|
"command_greet_long",
|
|
&[long_greeting.as_str()],
|
|
3000,
|
|
greeting_generated,
|
|
greeting_reference,
|
|
|value| value.len() as u64,
|
|
);
|
|
compare(
|
|
"command_echo",
|
|
&[echo.as_str()],
|
|
3000,
|
|
echo_generated,
|
|
echo_reference,
|
|
|value| value.len() as u64,
|
|
);
|
|
compare(
|
|
"command_double",
|
|
&[r#"{"value":21}"#],
|
|
50000,
|
|
double_generated,
|
|
double_reference,
|
|
|value| value.len() as u64,
|
|
);
|
|
compare(
|
|
"command_greet_short_independent",
|
|
&[r#"{"name":"Dever"}"#],
|
|
50000,
|
|
greeting_generated,
|
|
greeting_rust,
|
|
|value| value.len() as u64,
|
|
);
|
|
compare(
|
|
"command_greet_long_independent",
|
|
&[long_greeting.as_str()],
|
|
3000,
|
|
greeting_generated,
|
|
greeting_rust,
|
|
|value| value.len() as u64,
|
|
);
|
|
compare(
|
|
"command_double_independent",
|
|
&[r#"{"value":21}"#],
|
|
50000,
|
|
double_generated,
|
|
double_rust,
|
|
|value| value.len() as u64,
|
|
);
|
|
}
|