5 releases
Uses old Rust 2015
0.1.4 | Feb 7, 2017 |
---|---|
0.1.3 | Jan 5, 2017 |
0.1.2 | May 4, 2016 |
0.1.1 | Apr 9, 2016 |
0.1.0 | Mar 31, 2016 |
#1 in #i8
26 downloads per month
Used in 2 crates
41KB
1K
SLoC
td_rp
tickbh rust bin protocol
suport type
base type is contain "u8", "i8", "u16", "i16", "u32", "i32", "float", "string", "raw", "map"
array type is contain "u8[]", "i8[]", "u16[]", "i16[]", "u32[]", "i32[]", "float[]", "string[]", "raw[]", "map[]"
data detail
data will be format like as Id, Type, Data store by little endian, Id is 2bytes, Type is 2bytes
- "u8", "i8" -- 1bytes
- "u16", "i16" -- 2bytes
- "u32", "i32", "float" -- 4bytes, float decode with i32 div 1000
- "string", "raw" -- 2bytes len, len bytes datas
- map -- key always encode string, contains id, type, value is base value, end will key type is nil
- array -- write base data, stop with id = 0, type = 0
example data u8
extern crate td_proto_rust;
use td_rp::{Value, Config, Buffer};
fn test_head_field(buffer : &mut Buffer, index : u16, t : u16) {
// first index bytes
let data: &mut [u8; 2] = &mut [0, 0];
let size = buffer.read(data).unwrap();
assert_eq!(size, 2);
let val = u16::from_le(unsafe { mem::transmute::<[u8;2], u16>(*data) });
assert_eq!(val, index);
// first type bytes
let size = buffer.read(data).unwrap();
assert_eq!(size, 2);
let val = u16::from_le(unsafe { mem::transmute::<[u8;2], u16>(*data) });
assert_eq!(val, t);
}
fn test_encode_u8() {
let config = Config::new_empty();
let mut buffer = Buffer::new();
let value = Value::from(1 as u8);
td_rp::encode_field(&mut buffer, &config, &value).unwrap();
td_rp::encode_field(&mut buffer, &config, &value).unwrap();
// first read field
test_head_field(&mut buffer, 0, td_rp::TYPE_U8);
// after index type is data
let data: &mut [u8; 2] = &mut [0, 0];
let size = buffer.read(data).unwrap();
assert_eq!(size, 2);
assert_eq!(data[0], 1);
assert_eq!(data[1], 0);
// second read field
let read = td_rp::decode_field(&mut buffer, &config).unwrap();
match read {
Value::U8(val) => assert_eq!(val, 1),
_ => unreachable!("it will not read"),
}
let size = buffer.read(data).unwrap();
assert_eq!(size, 0);
}
the bytes is
[0, 0, 1, 0, 1] -- [0, 0] is id = 0, [1, 0] is type = 1 is TYPE_U8, [1] is data is 1u8
example proto
extern crate td_proto_rust;
use td_rp::{Value, Config, Buffer};
fn test_base_proto() {
let config = td_rp::Config::new(" { \"name\" : { \"index\" : 1, \"pattern\" : \"string\" }, \
\"index\" : { \"index\" : 2, \"pattern\" : \"u16\" }, \
\"sub_name\" : { \"index\" : 3, \"pattern\" :\"string\" } }",
"{\"cmd_test_op\" : { \"index\" : 1, \"args\" : [ \"map\" ] }}");
let config = config.unwrap();
let mut hash_value = HashMap::<String, Value>::new();
hash_value.insert("name".to_string(), Value::from("I'm a chinese people".to_string()));
hash_value.insert("sub_name".to_string(), Value::from("tickdream".to_string()));
hash_value.insert("index".to_string(), Value::from(1 as u16));
{
let mut buffer = td_rp::encode_proto(&config, &"cmd_test_op".to_string(), vec![Value::from(hash_value.clone())]).unwrap();
// just read field
let read = td_rp::decode_proto(&mut buffer, &config).unwrap();
match read {
(name, val) => {
assert_eq!(name, "cmd_test_op".to_string());
assert_eq!(val[0], Value::from(hash_value));
}
}
}
}
it will encode Vec accords to proto name like as "cmd_test_op" define args is [map]
compatible
it will ensure data decoded maximum
- old protocol can decode the new protocol if new protocol not change the old field info, but it will miss some info
- new protocol can decode the old protocol all datas
Dependencies
~225KB