2 releases
0.1.1 | Oct 7, 2022 |
---|---|
0.1.0 | May 9, 2022 |
#201 in #serialize-deserialize
143 downloads per month
Used in 2 crates
(via dlhn)
35KB
830 lines
DLHN
DLHN is a blazing fast and small data serialization format.
Specification
Overview
DLHN ( Pronounced the same as "Dullahan" ) is a language and platform neutral binary serialization format that is inspired by JSON, CSV, MessagePack, and Protocol Buffers. It is designed for blazing fast serialization and deserialization with the smallest possible data size without the need for schema file. However, we are also considering supporting schema file in the future.
QuickStart
[dependencies]
dlhn = "0.1"
Serialize and deserialize body
use dlhn::{Deserializer, Serializer};
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct Test {
a: bool,
b: u8,
c: String,
}
fn main() {
let body = Test {
a: true,
b: 123,
c: "test".to_string(),
};
// Serialize body
let mut output = Vec::new();
let mut serializer = Serializer::new(&mut output);
body.serialize(&mut serializer).unwrap();
// Deserialize body
let mut reader = output.as_slice();
let mut deserializer = Deserializer::new(&mut reader);
let deserialized_body = Test::deserialize(&mut deserializer).unwrap();
assert_eq!(body, deserialized_body);
}
Serialize and deserialize header
use dlhn::{DeserializeHeader, SerializeHeader, Header};
#[derive(SerializeHeader)]
struct Test {
a: bool,
b: u8,
c: String,
}
fn main() {
let mut output = Vec::new();
// Serialize header
Test::serialize_header(&mut output).unwrap();
assert_eq!(
output,
[
21, // Tuple code
3, // Tuple size
2, // Boolean code
3, // UInt8 code
18, // String code
]
);
// Deserialize header
let deserialized_header = output.as_slice().deserialize_header().unwrap();
assert_eq!(
deserialized_header,
Header::Tuple(vec![Header::Boolean, Header::UInt8, Header::String])
);
}
Stream version serialize and deserialize bodies
use dlhn::{de::Error, Deserializer, Serializer};
use serde::{Deserialize, Serialize};
fn main() {
let mut output = Vec::new();
// Serialize body
let mut serializer = Serializer::new(&mut output);
true.serialize(&mut serializer).unwrap();
false.serialize(&mut serializer).unwrap();
assert_eq!(output, [1, 0]);
// Deserialize body
let mut reader = output.as_slice();
let mut deserializer = Deserializer::new(&mut reader);
assert_eq!(bool::deserialize(&mut deserializer), Ok(true));
assert_eq!(bool::deserialize(&mut deserializer), Ok(false));
assert_eq!(bool::deserialize(&mut deserializer), Err(Error::Read));
}
Copyright
Copyright 2020-2022 Shogo Otake
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.
Dependencies
~1.5MB
~36K SLoC