Documentation

Overview

    Package protoiface contains types referenced or implemented by messages.

    WARNING: This package should only be imported by message implementations. The functionality found in this package should be accessed through higher-level abstractions provided by the proto package.

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type CheckInitializedInput

    type CheckInitializedInput = struct {
    	pragma.NoUnkeyedLiterals
    
    	Message protoreflect.Message
    }

      CheckInitializedInput is input to the CheckInitialized method.

      type CheckInitializedOutput

      type CheckInitializedOutput = struct {
      	pragma.NoUnkeyedLiterals
      }

        CheckInitializedOutput is output from the CheckInitialized method.

        type ExtensionRangeV1

        type ExtensionRangeV1 struct {
        	Start, End int32 // both inclusive
        }

        type MarshalInput

        type MarshalInput = struct {
        	pragma.NoUnkeyedLiterals
        
        	Message protoreflect.Message
        	Buf     []byte // output is appended to this buffer
        	Flags   MarshalInputFlags
        }

          MarshalInput is input to the Marshal method.

          type MarshalInputFlags

          type MarshalInputFlags = uint8

            MarshalInputFlags configure the marshaler. Most flags correspond to fields in proto.MarshalOptions.

            const (
            	MarshalDeterministic MarshalInputFlags = 1 << iota
            	MarshalUseCachedSize
            )

            type MarshalOutput

            type MarshalOutput = struct {
            	pragma.NoUnkeyedLiterals
            
            	Buf []byte // contains marshaled message
            }

              MarshalOutput is output from the Marshal method.

              type MergeInput

              type MergeInput = struct {
              	pragma.NoUnkeyedLiterals
              
              	Source      protoreflect.Message
              	Destination protoreflect.Message
              }

                MergeInput is input to the Merge method.

                type MergeOutput

                type MergeOutput = struct {
                	pragma.NoUnkeyedLiterals
                
                	Flags MergeOutputFlags
                }

                  MergeOutput is output from the Merge method.

                  type MergeOutputFlags

                  type MergeOutputFlags = uint8

                    MergeOutputFlags are output from the Merge method.

                    const (
                    	// MergeComplete reports whether the merge was performed.
                    	// If unset, the merger must have made no changes to the destination.
                    	MergeComplete MergeOutputFlags = 1 << iota
                    )

                    type MessageV1

                    type MessageV1 interface {
                    	Reset()
                    	String() string
                    	ProtoMessage()
                    }

                    type Methods

                    type Methods = struct {
                    	pragma.NoUnkeyedLiterals
                    
                    	// Flags indicate support for optional features.
                    	Flags SupportFlags
                    
                    	// Size returns the size in bytes of the wire-format encoding of a message.
                    	// Marshal must be provided if a custom Size is provided.
                    	Size func(SizeInput) SizeOutput
                    
                    	// Marshal formats a message in the wire-format encoding to the provided buffer.
                    	// Size should be provided if a custom Marshal is provided.
                    	// It must not return an error for a partial message.
                    	Marshal func(MarshalInput) (MarshalOutput, error)
                    
                    	// Unmarshal parses the wire-format encoding and merges the result into a message.
                    	// It must not reset the target message or return an error for a partial message.
                    	Unmarshal func(UnmarshalInput) (UnmarshalOutput, error)
                    
                    	// Merge merges the contents of a source message into a destination message.
                    	Merge func(MergeInput) MergeOutput
                    
                    	// CheckInitialized returns an error if any required fields in the message are not set.
                    	CheckInitialized func(CheckInitializedInput) (CheckInitializedOutput, error)
                    }

                      Methods is a set of optional fast-path implementations of various operations.

                      type SizeInput

                      type SizeInput = struct {
                      	pragma.NoUnkeyedLiterals
                      
                      	Message protoreflect.Message
                      	Flags   MarshalInputFlags
                      }

                        SizeInput is input to the Size method.

                        type SizeOutput

                        type SizeOutput = struct {
                        	pragma.NoUnkeyedLiterals
                        
                        	Size int
                        }

                          SizeOutput is output from the Size method.

                          type SupportFlags

                          type SupportFlags = uint64

                            SupportFlags indicate support for optional features.

                            const (
                            	// SupportMarshalDeterministic reports whether MarshalOptions.Deterministic is supported.
                            	SupportMarshalDeterministic SupportFlags = 1 << iota
                            
                            	// SupportUnmarshalDiscardUnknown reports whether UnmarshalOptions.DiscardUnknown is supported.
                            	SupportUnmarshalDiscardUnknown
                            )

                            type UnmarshalInput

                            type UnmarshalInput = struct {
                            	pragma.NoUnkeyedLiterals
                            
                            	Message  protoreflect.Message
                            	Buf      []byte // input buffer
                            	Flags    UnmarshalInputFlags
                            	Resolver interface {
                            		FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error)
                            		FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error)
                            	}
                            }

                              UnmarshalInput is input to the Unmarshal method.

                              type UnmarshalInputFlags

                              type UnmarshalInputFlags = uint8

                                UnmarshalInputFlags configure the unmarshaler. Most flags correspond to fields in proto.UnmarshalOptions.

                                const (
                                	UnmarshalDiscardUnknown UnmarshalInputFlags = 1 << iota
                                )

                                type UnmarshalOutput

                                type UnmarshalOutput = struct {
                                	pragma.NoUnkeyedLiterals
                                
                                	Flags UnmarshalOutputFlags
                                }

                                  UnmarshalOutput is output from the Unmarshal method.

                                  type UnmarshalOutputFlags

                                  type UnmarshalOutputFlags = uint8

                                    UnmarshalOutputFlags are output from the Unmarshal method.

                                    const (
                                    	// UnmarshalInitialized may be set on return if all required fields are known to be set.
                                    	// If unset, then it does not necessarily indicate that the message is uninitialized,
                                    	// only that its status could not be confirmed.
                                    	UnmarshalInitialized UnmarshalOutputFlags = 1 << iota
                                    )