Struct FieldOptions 

pub struct FieldOptions {

    pub ctype: Option<CType>,
    pub packed: Option<bool>,
    pub jstype: Option<JSType>,
    pub lazy: Option<bool>,
    pub unverified_lazy: Option<bool>,
    pub deprecated: Option<bool>,
    pub weak: Option<bool>,
    pub debug_redact: Option<bool>,
    pub retention: Option<OptionRetention>,
    pub targets: Vec<OptionTargetType>,
    pub edition_defaults: Vec<EditionDefault>,
    pub features: MessageField<FeatureSet>,
    pub feature_support: MessageField<FeatureSupport>,
    pub uninterpreted_option: Vec<UninterpretedOption>,
    /* private fields */
}

Fields

ctype: Option<CType>

NOTE: ctype is deprecated. Use features.(pb.cpp).string_type instead. The ctype option instructs the C++ code generator to use a different representation of the field than it normally would. See the specific options below. This option is only implemented to support use of [ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of type “bytes” in the open source release. TODO: make ctype actually deprecated.

Field 1: ctype

packed: Option<bool>

The packed option can be enabled for repeated primitive fields to enable a more efficient representation on the wire. Rather than repeatedly writing the tag and type for each element, the entire array is encoded as a single length-delimited blob. In proto3, only explicit setting it to false will avoid using packed encoding. This option is prohibited in Editions, but the repeated_field_encoding feature can be used to control the behavior.

Field 2: packed

jstype: Option<JSType>

The jstype option determines the JavaScript type used for values of the field. The option is permitted only for 64 bit integral and fixed types (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING is represented as JavaScript string, which avoids loss of precision that can happen when a large value is converted to a floating point JavaScript. Specifying JS_NUMBER for the jstype causes the generated JavaScript code to use the JavaScript “number” type. The behavior of the default option JS_NORMAL is implementation dependent.

This option is an enum to permit additional types to be added, e.g. goog.math.Integer.

Field 6: jstype

lazy: Option<bool>

Should this field be parsed lazily? Lazy applies only to message-type fields. It means that when the outer message is initially parsed, the inner message’s contents will not be parsed but instead stored in encoded form. The inner message will actually be parsed when it is first accessed.

This is only a hint. Implementations are free to choose whether to use eager or lazy parsing regardless of the value of this option. However, setting this option true suggests that the protocol author believes that using lazy parsing on this field is worth the additional bookkeeping overhead typically needed to implement it.

This option does not affect the public interface of any generated code; all method signatures remain the same. Furthermore, thread-safety of the interface is not affected by this option; const methods remain safe to call from multiple threads concurrently, while non-const methods continue to require exclusive access.

Note that lazy message fields are still eagerly verified to check ill-formed wireformat or missing required fields. Calling IsInitialized() on the outer message would fail if the inner message has missing required fields. Failed verification would result in parsing failure (except when uninitialized messages are acceptable).

Field 5: lazy

unverified_lazy: Option<bool>

unverified_lazy does no correctness checks on the byte stream. This should only be used where lazy with verification is prohibitive for performance reasons.

Field 15: unverified_lazy

deprecated: Option<bool>

Is this field deprecated? Depending on the target platform, this can emit Deprecated annotations for accessors, or it will be completely ignored; in the very least, this is a formalization for deprecating fields.

Field 3: deprecated

weak: Option<bool>

DEPRECATED. DO NOT USE! For Google-internal migration only. Do not use.

Field 10: weak

debug_redact: Option<bool>

Indicate that the field value should not be printed out when using debug formats, e.g. when the field contains sensitive credentials.

Field 16: debug_redact

retention: Option<OptionRetention>

Field 17: retention

targets: Vec<OptionTargetType>

Field 19: targets

edition_defaults: Vec<EditionDefault>

Field 20: edition_defaults

features: MessageField<FeatureSet>

Any features defined in the specific edition. WARNING: This field should only be used by protobuf plugins or special cases like the proto compiler. Other uses are discouraged and developers should rely on the protoreflect APIs for their client language.

Field 21: features

feature_support: MessageField<FeatureSupport>

Field 22: feature_support

uninterpreted_option: Vec<UninterpretedOption>

The parser stores options it doesn’t recognize here. See above.

Field 999: uninterpreted_option

Implementations

impl FieldOptions

pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FieldOptions"

Protobuf type URL for this message, for use with Any::pack and Any::unpack_if.

Format: type.googleapis.com/<fully.qualified.TypeName>

impl FieldOptions

pub fn with_ctype(self, value: impl Into<CType>) -> Self

Sets Self::ctype to Some(value), consuming and returning self.

pub fn with_packed(self, value: bool) -> Self

Sets Self::packed to Some(value), consuming and returning self.

pub fn with_jstype(self, value: impl Into<JSType>) -> Self

Sets Self::jstype to Some(value), consuming and returning self.

pub fn with_lazy(self, value: bool) -> Self

Sets Self::lazy to Some(value), consuming and returning self.

pub fn with_unverified_lazy(self, value: bool) -> Self

Sets Self::unverified_lazy to Some(value), consuming and returning self.

pub fn with_deprecated(self, value: bool) -> Self

Sets Self::deprecated to Some(value), consuming and returning self.

pub fn with_weak(self, value: bool) -> Self

Sets Self::weak to Some(value), consuming and returning self.

pub fn with_debug_redact(self, value: bool) -> Self

Sets Self::debug_redact to Some(value), consuming and returning self.

pub fn with_retention(self, value: impl Into<OptionRetention>) -> Self

Sets Self::retention to Some(value), consuming and returning self.

Trait Implementations

impl Clone for FieldOptions

fn clone(&self) -> FieldOptions

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FieldOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for FieldOptions

fn default() -> FieldOptions

Returns the “default value” for a type.

impl DefaultInstance for FieldOptions

fn default_instance() -> &'static Self

Return a reference to the single default instance of this type.

impl ExtensionSet for FieldOptions

const PROTO_FQN: &'static str = "google.protobuf.FieldOptions"

Fully-qualified proto type name of this message (no leading dot), e.g. "google.protobuf.FieldOptions".

fn unknown_fields(&self) -> &UnknownFields

Immutable access to the extendee’s unknown-field storage.

fn unknown_fields_mut(&mut self) -> &mut UnknownFields

Mutable access to the extendee’s unknown-field storage.

fn extension<C>(&self, ext: &Extension<C>) -> <C as ExtensionCodec>::Output

where C: ExtensionCodec,

Read an extension value.

fn set_extension<C>( &mut self, ext: &Extension<C>, value: <C as ExtensionCodec>::Value, )

where C: ExtensionCodec,

Write an extension value, replacing any prior occurrences.

fn has_extension<C>(&self, ext: &Extension<C>) -> bool

where C: ExtensionCodec,

Returns true if any record at the extension’s field number is present.

fn clear_extension<C>(&mut self, ext: &Extension<C>)

where C: ExtensionCodec,

Remove all records at the extension’s field number.

fn extension_or_default<C>( &self, ext: &Extension<C>, ) -> <C as ExtensionCodec>::Value

where C: ExtensionCodec<Output = Option<<C as ExtensionCodec>::Value>>, <C as ExtensionCodec>::Value: Default,

Read a singular extension value, returning the proto2 [default = ...] value if absent, or the type’s Default if no proto default was declared.

impl Message for FieldOptions

fn compute_size(&self, __cache: &mut SizeCache) -> u32

Returns the total encoded size in bytes.

The result is a u32; the protobuf specification requires all messages to fit within 2 GiB (2,147,483,647 bytes), so a compliant message will never overflow this type.

fn write_to(&self, __cache: &mut SizeCache, buf: &mut impl BufMut)

Write this message’s encoded bytes to a buffer, consuming nested-message sizes from cache (populated by a prior compute_size call on the same cache).

fn merge_field( &mut self, tag: Tag, buf: &mut impl Buf, depth: u32, ) -> Result<(), DecodeError>

Processes a single already-decoded tag and its associated field data from buf.

fn clear(&mut self)

Clear all fields to their default values.

fn encode(&self, buf: &mut impl BufMut)

Compute size, then write. This is the primary encoding API.

fn encode_with_cache(&self, cache: &mut SizeCache, buf: &mut impl BufMut)

Encode using a caller-supplied SizeCache, for reuse across many encodes in a hot loop. Clears the cache first.

fn encoded_len(&self) -> u32

Compute the encoded byte size of this message.

fn encode_length_delimited(&self, buf: &mut impl BufMut)

Encode this message as a length-delimited byte sequence.

fn encode_to_vec(&self) -> Vec<u8>

Encode this message to a new Vec<u8>.

fn encode_to_bytes(&self) -> Bytes

Encode this message to a new bytes::Bytes.

fn decode(buf: &mut impl Buf) -> Result<Self, DecodeError>

where Self: Sized,

Decode a message from a buffer.

fn decode_from_slice(data: &[u8]) -> Result<Self, DecodeError>

where Self: Sized,

Decode a message from a byte slice.

fn decode_length_delimited(buf: &mut impl Buf) -> Result<Self, DecodeError>

where Self: Sized,

Decode a length-delimited message from a buffer.

fn merge_to_limit( &mut self, buf: &mut impl Buf, depth: u32, limit: usize, ) -> Result<(), DecodeError>

Merge fields from a buffer until buf.remaining() reaches limit.

fn merge_group( &mut self, buf: &mut impl Buf, depth: u32, field_number: u32, ) -> Result<(), DecodeError>

Merges a group-encoded message from buf, reading fields until an EndGroup tag with the given field_number is encountered.

fn merge(&mut self, buf: &mut impl Buf, depth: u32) -> Result<(), DecodeError>

Merge fields from a buffer into this message.

fn merge_from_slice(&mut self, data: &[u8]) -> Result<(), DecodeError>

Merge fields from a byte slice into this message.

fn merge_length_delimited( &mut self, buf: &mut impl Buf, depth: u32, ) -> Result<(), DecodeError>

Merge fields from a length-delimited sub-message payload into this message.

impl MessageName for FieldOptions

const PACKAGE: &'static str = "google.protobuf"

The protobuf package the message is declared in.

const NAME: &'static str = "FieldOptions"

The unqualified message name, with . between nesting levels.

const FULL_NAME: &'static str = "google.protobuf.FieldOptions"

The fully-qualified protobuf type name with no leading dot.

const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FieldOptions"

The google.protobuf.Any.type_url form for this message.

impl PartialEq for FieldOptions

fn eq(&self, other: &FieldOptions) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for FieldOptions