Struct AnyView 

pub struct AnyView<'a> {
    pub type_url: &'a str,
    pub value: &'a [u8],
    pub __buffa_unknown_fields: UnknownFieldsView<'a>,
}

Any contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message.

Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.

Example 1: Pack and unpack a message in C++.

Foo foo = ...;
Any any;
any.PackFrom(foo);
...
if (any.UnpackTo(&foo)) {
  ...
}

Example 2: Pack and unpack a message in Java.

Foo foo = ...;
Any any = Any.pack(foo);
...
if (any.is(Foo.class)) {
  foo = any.unpack(Foo.class);
}
// or ...
if (any.isSameTypeAs(Foo.getDefaultInstance())) {
  foo = any.unpack(Foo.getDefaultInstance());
}

Example 3: Pack and unpack a message in Python.

foo = Foo(...)
any = Any()
any.Pack(foo)
...
if any.Is(Foo.DESCRIPTOR):
  any.Unpack(foo)
  ...

Example 4: Pack and unpack a message in Go

 foo := &pb.Foo{...}
 any, err := anypb.New(foo)
 if err != nil {
   ...
 }
 ...
 foo := &pb.Foo{}
 if err := any.UnmarshalTo(foo); err != nil {
   ...
 }

The pack methods provided by protobuf library will by default use ‘type.googleapis.com/full.type.name’ as the type URL and the unpack methods only use the fully qualified type name after the last ‘/’ in the type URL, for example “foo.bar.com/x/y.z” will yield type name “y.z”.

JSON

The JSON representation of an Any value uses the regular representation of the deserialized, embedded message, with an additional field @type which contains the type URL. Example:

package google.profile;
message Person {
  string first_name = 1;
  string last_name = 2;
}

{
  "@type": "type.googleapis.com/google.profile.Person",
  "firstName": <string>,
  "lastName": <string>
}

If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field value which holds the custom JSON in addition to the @type field. Example (for message google.protobuf.Duration):

{
  "@type": "type.googleapis.com/google.protobuf.Duration",
  "value": "1.212s"
}

Fields

type_url: &'a str

A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one “/” character. The last segment of the URL’s path must represent the fully qualified name of the type (as in path/google.protobuf.Duration). The name should be in a canonical form (e.g., leading “.” is not accepted).

In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme http, https, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows:

• If no scheme is provided, https is assumed.
• An HTTP GET on the URL must yield a google.protobuf.Type value in binary format, or produce an error.
• Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.)

Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. As of May 2023, there are no widely used type server implementations and no plans to implement one.

Schemes other than http, https (or the empty scheme) might be used with implementation specific semantics.

Field 1: type_url

value: &'a [u8]

Must be a valid serialized protocol buffer of the above specified type.

Field 2: value

__buffa_unknown_fields: UnknownFieldsView<'a>

Trait Implementations

impl<'a> Clone for AnyView<'a>

fn clone(&self) -> AnyView<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for AnyView<'a>

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

Formats the value using the given formatter.

impl<'a> Default for AnyView<'a>

fn default() -> AnyView<'a>

Returns the “default value” for a type.

impl<'v> DefaultViewInstance for AnyView<'v>

fn default_view_instance<'a>() -> &'a Self

where Self: 'a,

Return a reference to the single default view instance.

impl<'a> MessageName for AnyView<'a>

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

The protobuf package the message is declared in.

const NAME: &'static str = "Any"

The unqualified message name, with . between nesting levels.

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

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

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

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

impl<'a> MessageView<'a> for AnyView<'a>

type Owned = Any

The corresponding owned message type.

fn decode_view(buf: &'a [u8]) -> Result<Self, DecodeError>

Decode a view from a buffer, borrowing string/bytes fields directly.

fn decode_view_with_ctx( buf: &'a [u8], ctx: DecodeContext<'_>, ) -> Result<Self, DecodeError>

Decode a view under custom decode limits.

fn merge_view_field( &mut self, tag: Tag, cur: &'a [u8], before_tag: &'a [u8], ctx: DecodeContext<'_>, ) -> Result<&'a [u8], DecodeError>

Decode one field’s payload into this view (generated per message).

fn to_owned_message(&self) -> Result<Any, DecodeError>

Convert this view to the owned message type.

fn to_owned_from_source( &self, __buffa_src: Option<&Bytes>, ) -> Result<Any, DecodeError>

Convert this view to the owned message type, optionally slicing bytes::Bytes-typed fields from source instead of copying.

fn decode_view_ctx( buf: &'a [u8], ctx: DecodeContext<'_>, ) -> Result<Self, DecodeError>

where Self: Default,

Decode a view under an explicit DecodeContext (remaining recursion depth, unknown-field allowance, and element-memory budget), driving the provided tag loop over merge_view_field.

fn merge_into_view( &mut self, buf: &'a [u8], ctx: DecodeContext<'_>, ) -> Result<(), DecodeError>

Merge fields from buf into this view (proto merge semantics): repeated fields append, singular fields last-wins, singular message fields merge recursively.

impl<'a> ReflectElement for AnyView<'a>

Available on crate feature reflect only.

fn as_value_ref(&self) -> ValueRef<'_>

Borrow this element as a ValueRef.

impl<'a> ReflectMessage for AnyView<'a>

Available on crate feature reflect only.

fn message_descriptor(&self) -> &MessageDescriptor

The descriptor for this message type.

fn pool(&self) -> &Arc<DescriptorPool>

The pool the descriptor lives in. Use this to dereference MessageIndex / EnumIndex from FieldKind, or Arc::clone it to construct sibling DynamicMessages while navigating nested fields.

fn get(&self, field: &FieldDescriptor) -> ValueRef<'_>

Get a field’s value.

fn has(&self, field: &FieldDescriptor) -> bool

Whether a field is present.

fn for_each_set(&self, f: &mut dyn FnMut(&FieldDescriptor, ValueRef<'_>))

Visit every set field.

fn to_dynamic(&self) -> DynamicMessage

Snapshot this message as an owned DynamicMessage.

fn unknown_fields(&self) -> &UnknownFields

The fields preserved from decode that the message’s descriptor does not recognize.

fn which_oneof(&self, oneof: &OneofDescriptor) -> Option<&FieldDescriptor>

Which member of oneof is set, if any.

impl Serialize for AnyView<'_>

Available on crate feature json only.

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serializes by converting to the owned WKT and delegating to its proto3-JSON Serialize impl. Allocates the owned form for this field only; the parent message stays zero-copy.

impl<'a> ViewEncode<'a> for AnyView<'a>

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

Compute the encoded byte size of this view, recording nested sub-message sizes in cache for write_to to consume.

fn write_to(&self, _cache: &mut SizeCache, buf: &mut impl EncodeSink)

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

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

Compute size, then write. Primary view-encode entry point.

fn try_encode(&self, buf: &mut impl EncodeSink) -> Result<(), EncodeError>

Encode, returning an error instead of panicking if the encoded size exceeds the 2 GiB protobuf limit (MAX_MESSAGE_BYTES).

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

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

fn try_encode_with_cache( &self, cache: &mut SizeCache, buf: &mut impl EncodeSink, ) -> Result<(), EncodeError>

Encode with a caller-supplied SizeCache, returning an error instead of panicking if the encoded size exceeds the 2 GiB protobuf limit (MAX_MESSAGE_BYTES). Clears the cache first.

fn try_encode_bounded( &self, max_bytes: u32, buf: &mut impl EncodeSink, ) -> Result<u32, EncodeError>

Encode this view into buf only if its encoded size fits within max_bytes, using a single size pass that is then reused for the write.

fn try_encode_bounded_with_cache( &self, max_bytes: u32, cache: &mut SizeCache, buf: &mut impl EncodeSink, ) -> Result<u32, EncodeError>

Like try_encode_bounded but reuses an existing SizeCache, clearing it first.

fn encoded_len(&self) -> u32

Compute the encoded byte size of this view.

fn try_encoded_len(&self) -> Result<u32, EncodeError>

Compute the encoded byte size, returning an error instead of panicking if it exceeds the 2 GiB protobuf limit (MAX_MESSAGE_BYTES).

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

Encode this view as a length-delimited byte sequence.

fn try_encode_length_delimited( &self, buf: &mut impl EncodeSink, ) -> Result<(), EncodeError>

Encode as a length-delimited byte sequence, returning an error instead of panicking if the encoded size exceeds the 2 GiB protobuf limit (MAX_MESSAGE_BYTES).

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

Encode this view to a new Vec<u8>.

fn try_encode_to_vec(&self) -> Result<Vec<u8>, EncodeError>

Encode to a new Vec<u8>, returning an error instead of panicking if the encoded size exceeds the 2 GiB protobuf limit (MAX_MESSAGE_BYTES).

fn encode_to_bytes(&self) -> Bytes

Encode this view to a new bytes::Bytes.

fn try_encode_to_bytes(&self) -> Result<Bytes, EncodeError>

Encode to a new bytes::Bytes, returning an error instead of panicking if the encoded size exceeds the 2 GiB protobuf limit (MAX_MESSAGE_BYTES).

impl ViewReborrow for AnyView<'static>

type Reborrowed<'b> = AnyView<'b>

The same view type with its lifetime shortened to 'b.

fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b>

Coerce &'b Self (= &'b FooView<'static>) to &'b Self::Reborrowed<'b> (= &'b FooView<'b>). The canonical body is just this; the compiler accepts it via standard lifetime variance for covariant view types.