Lib.rs

为什么？

我们喜欢CBOR的原因如下

1. 它是IETF标准
2. 它是自描述的
3. 它足够紧凑
4. 它非常丰富，包括令人难以置信的事物
5. 它在大多数语言中都有实现

我们在CBOR中缺少的

1. 没有模式定义，即无法检查系统间的互操作性
2. 传输/存储大量对象很昂贵，因为每个对象都会对键进行编码
3. 没有将“对象”（即映射或字典）转换为原生类型对象的标准化方法

比较

本节大致比较了类似的项目，以了解“为什么？”部分中的论点。单个论点可能不是非常有说服力，但总体上是合理的。

Probor 与 Capnproto 的比较

Capnproto 有一个丑陋且复杂的序列化格式，它可以将值直接映射到内存中而不进行解码。但它的实现比我们目标更复杂。我们还希望有紧凑的编码，这是 Capnproto 拥有的，但它是建立在已经难以理解的编码之上的，使事情更加复杂。

像其他一样，Capnproto 也依赖于代码生成，解码后的结果是丑陋的协议对象，但我们希望使用原生类型。

类似物

例如，这里有一个模式

struct SearchResults {
    total_results @0 :int
    results @1 :array Page
}
struct Page {
    url @0 :text,
    title @1 :text,
    snippet @2 :optional text,
}

注意以下事项

• 我们使用泛型类型名称，如 int（整数），而不是固定宽度（参见常见问题解答）
• 我们给每个字段一个编号，它们与用于其他 IDL（如 protobuf、thrift 或 capnproto）的编号类似

使用 probor 序列化的结构将看起来像（以 JSON 显示清晰度，实际上如果您解码 CBOR 并用 JSON 编码，您将看到确切的数据）

[1100, [
     ["http://example.com", "Example Com"],
     ["http://example.org", "Example Org", "Example organization"]]]

显然，当解包时，它看起来更像是（在 JavaScript 中）

new SearchResults({"total_results": 1100,
                   "results": [new Page({"url": "http://example.com",
                                         "title": "Example Com"}),
                               new Page({"url": "http://example.org",
                                         "title": "Example Org",
                                         "snippet": "Example organization"})]}

实际上，对象可以像这样序列化

{"total_results": 1100,
 "results": [{"url": "http://example.com",
              "title": "Example Com"},
             {"url": "http://example.org",
              "title": "Example Org",
              "snippet": "Example organization"}]}

这也会是一个完全有效的序列化表示。也就是说，您可以通过名称和数字存储字段。这在处理临时请求或您愿意从前端接收非紧凑数据，然后以更紧凑的格式验证和推送数据进行存储时，偶尔会很有用。

在Python中序列化看起来像这样

from probor import struct

class Page(object):

    def __init__(self, url, title, snippet=None):
        # .. your constructor .. omitted for brevity

    probor_protocol = struct(
        required={(0, "url"): str, (1, "title"): str},
        optional={(2, "snippet"): str})

class SearchResults(object):
    def __init__(self, total_resutls, results):
        # .. your constructor .. omitted for brevity

    probor_protocol = struct(
        required={(0, "total_results"): int, (1, "results"): Page})

待办事项：语法是否丑陋？应该更强制吗？使用了setstate/getstate吗？

类似地，在Rust中它看起来像这样

#[macro_use] extern crate probor;

use probor::{Encoder, Encodable};
use probor::{Decoder, Config, decode};
use std::io::Cursor;

probor_struct!(
#[derive(PartialEq, Eq, Debug)]
struct Page {
    url: String => (#0),
    title: String => (#1),
    snippet: Option<String> => (#2 optional),
});

probor_struct!(
#[derive(PartialEq, Eq, Debug)]
struct SearchResults {
    total_results: u64 => (#0),
    results: Vec<Page> => (#1),
});


fn main() {
    let buf = Vec::new();
    let mut enc = Encoder::new(buf);
    SearchResults {
        total_results: 112,
        results: vec![Page {
            url: "http://url1.example.com".to_string(),
            title: "One example".to_string(),
            snippet: None,
        }, Page {
            url: "http://url2.example.com".to_string(),
            title: "Two example".to_string(),
            snippet: Some("Example Two".to_string()),
        }],
    }.encode(&mut enc).unwrap();
    let sr: SearchResults = decode(
        &mut Decoder::new(Config::default(), Cursor::new(enc.into_writer())))
        .unwrap();
    println!("Results {:?}", sr);
}

Rust的例子略长，但对于Rust来说是可以忍受的。它很大程度上基于宏，这可能看起来与代码生成相似。然而，我们发现它更好，因为您至少可以控制以下事物

1. 使用的特定类型（例如，u64用于int）
2. 结构定义（可以使用包括derive和repr在内的元属性，并可以使用struct T(X, Y))
3. 对象是如何创建的（例如，使用VecDeque或BTreeMap而不是默认的Vec和HashMap)
4. 如何处理缺失的字段（例如，您可以为缺失的字段提供默认值，而不是使用Option<T>)
5. 您还可以包含特定于应用程序的验证代码

最终，使用少量辅助宏显式编写解析器看起来比将所有数据作为元信息添加到模式文件中要好得多。

类型系统

enum HtmlElement {
    Tag(String, Vec<HtmlElement>),
    Text(String),
}

from probor import enum

class HtmlElement:
    """Base class"""

class Tag(HtmlElement):
    def __init__(self, tag_name, children):
        # .. snip ..

    probor_protocol = ...

class Text(HtmlElement):

    def __init__(self, text)
        self.text = text

    probor_protocol = ...

HtmlElement.probor_protocol = enum({
    (0, 'Tag'): Tag,
    (1, 'Text'): Text,
})

前向/后向兼容性

与protobuf相比，probor序列化器始终将所有字段视为可选的。必需字段仅在IDL中，因此如果您的未来类型足够智能，可以

后向兼容性与protobuf非常相似。

待定：后向兼容性的确切规则

待定：前向兼容性的确切规则

待定：将结构转换为具有兼容性的代数类型

常见问题解答