BitBox02硬件钱包 固件代码_C语言_代码_下载

 [](https://docs.rs/prost/) [](https://crates.io/crates/prost) [](https://deps.rs/repo/github/tokio-rs/prost) # *PROST!* `prost` is a [Protocol Buffers](https://developers.google.com/protocol-buffers/) implementation for the [Rust Language](https://www.rust-lang.org/). `prost` generates simple, idiomatic Rust code from `proto2` and `proto3` files. Compared to other Protocol Buffers implementations, `prost` * Generates simple, idiomatic, and readable Rust types by taking advantage of Rust `derive` attributes. * Retains comments from `.proto` files in generated Rust code. * Allows existing Rust types (not generated from a `.proto`) to be serialized and deserialized by adding attributes. * Uses the [`bytes::{Buf, BufMut}`](https://github.com/carllerche/bytes) abstractions for serialization instead of `std::io::{Read, Write}`. * Respects the Protobuf `package` specifier when organizing generated code into Rust modules. * Preserves unknown enum values during deserialization. * Does not include support for runtime reflection or message descriptors. ## Using `prost` in a Cargo Project First, add `prost` and its public dependencies to your `Cargo.toml`: ``` [dependencies] prost = "0.10" # Only necessary if using Protobuf well-known types: prost-types = "0.10" ``` The recommended way to add `.proto` compilation to a Cargo project is to use the `prost-build` library. See the [`prost-build` documentation](prost-build) for more details and examples. See the [snazzy repository](https://github.com/danburkert/snazzy) for a simple start-to-finish example. ## Generated Code `prost` generates Rust code from source `.proto` files using the `proto2` or `proto3` syntax. `prost`'s goal is to make the generated code as simple as possible. ### `protoc` It's recommended to install `protoc` locally in your path to improve build times. Prost uses `protoc` to parse protobuf files and will attempt to compile protobuf from source requiring a C++ toolchain. For more info checkout the [`prost-build`](prost-build) docs. ### Packages Prost can now generate code for `.proto` files that don't have a package spec. `prost` will translate the Protobuf package into a Rust module. For example, given the `package` specifier: [package]: https://developers.google.com/protocol-buffers/docs/proto#packages ```proto package foo.bar; ``` All Rust types generated from the file will be in the `foo::bar` module. ### Messages Given a simple message declaration: ```proto // Sample message. message Foo { } ``` `prost` will generate the following Rust struct: ```rust /// Sample message. #[derive(Clone, Debug, PartialEq, Message)] pub struct Foo { } ``` ### Fields Fields in Protobuf messages are translated into Rust as public struct fields of the corresponding type. #### Scalar Values Scalar value types are converted as follows: | Protobuf Type | Rust Type | | --- | --- | | `double` | `f64` | | `float` | `f32` | | `int32` | `i32` | | `int64` | `i64` | | `uint32` | `u32` | | `uint64` | `u64` | | `sint32` | `i32` | | `sint64` | `i64` | | `fixed32` | `u32` | | `fixed64` | `u64` | | `sfixed32` | `i32` | | `sfixed64` | `i64` | | `bool` | `bool` | | `string` | `String` | | `bytes` | `Vec<u8>` | #### Enumerations All `.proto` enumeration types convert to the Rust `i32` type. Additionally, each enumeration type gets a corresponding Rust `enum` type. For example, this `proto` enum: ```proto enum PhoneType { MOBILE = 0; HOME = 1; WORK = 2; } ``` gets this corresponding Rust enum [1]: ```rust pub enum PhoneType { Mobile = 0, Home = 1, Work = 2, } ``` You can convert a `PhoneType` value to an `i32` by doing: ```rust PhoneType::Mobile as i32 ``` The `#[derive(::prost::Enumeration)]` annotation added to the generated `PhoneType` adds these associated functions to the type: ```rust impl PhoneType { pub fn is_valid(value: i32) -> bool { ... } pub fn from_i32(value: i32) -> Option<PhoneType> { ... } } ``` so you can convert an `i32` to its corresponding `PhoneType` value by doing, for example: ```rust let phone_type = 2i32; match PhoneType::from_i32(phone_type) { Some(PhoneType::Mobile) => ..., Some(PhoneType::Home) => ..., Some(PhoneType::Work) => ..., None => ..., } ``` Additionally, wherever a `proto` enum is used as a field in a `Message`, the message will have 'accessor' methods to get/set the value of the field as the Rust enum type. For instance, this proto `PhoneNumber` message that has a field named `type` of type `PhoneType`: ```proto message PhoneNumber { string number = 1; PhoneType type = 2; } ``` will become the following Rust type [1] with methods `type` and `set_type`: ```rust pub struct PhoneNumber { pub number: String, pub r#type: i32, // the `r#` is needed because `type` is a Rust keyword } impl PhoneNumber { pub fn r#type(&self) -> PhoneType { ... } pub fn set_type(&mut self, value: PhoneType) { ... } } ``` Note that the getter methods will return the Rust enum's default value if the field has an invalid `i32` value. The `enum` type isn't used directly as a field, because the Protobuf spec mandates that enumerations values are 'open', and decoding unrecognized enumeration values must be possible. [1] Annotations have been elided for clarity. See below for a full example. #### Field Modifiers Protobuf scalar value and enumeration message fields can have a modifier depending on the Protobuf version. Modifiers change the corresponding type of the Rust field: | `.proto` Version | Modifier | Rust Type | | --- | --- | --- | | `proto2` | `optional` | `Option<T>` | | `proto2` | `required` | `T` | | `proto3` | default | `T` for scalar types, `Option<T>` otherwise | | `proto3` | `optional` | `Option<T>` | | `proto2`/`proto3` | `repeated` | `Vec<T>` | Note that in `proto3` the default representation for all user-defined message types is `Option<T>`, and for scalar types just `T` (during decoding, a missing value is populated by `T::default()`). If you need a witness of the presence of a scalar type `T`, use the `optional` modifier to enforce an `Option<T>` representation in the generated Rust struct. #### Map Fields Map fields are converted to a Rust `HashMap` with key and value type converted from the Protobuf key and value types. #### Message Fields Message fields are converted to the corresponding struct type. The table of field modifiers above applies to message fields, except that `proto3` message fields without a modifier (the default) will be wrapped in an `Option`. Typically message fields are unboxed. `prost` will automatically box a message field if the field type and the parent type are recursively nested in order to avoid an infinite sized struct. #### Oneof Fields Oneof fields convert to a Rust enum. Protobuf `oneof`s types are not named, so `prost` uses the name of the `oneof` field for the resulting Rust enum, and defines the enum in a module under the struct. For example, a `proto3` message such as: ```proto message Foo { oneof widget { int32 quux = 1; string bar = 2; } } ``` generates the following Rust[1]: ```rust pub struct Foo { pub widget: Option<foo::Widget>, } pub mod foo { pub enum Widget { Quux(i32), Bar(String), } } ``` `oneof` fields are always wrapped in an `Option`. [1] Annotations have been elided for clarity. See below for a full example. ### Services `prost-build` allows a custom code-generator to be used for processing `service` definitions. This can be used to output Rust traits according to an application's specific needs. ### Generated Code Example Example `.proto` file: ```proto syntax = "proto3"; package tutorial; message Pe