kubernetes/vendor/google.golang.org/protobuf/types/dynamicpb/dynamic.go

type enum

func (e enum) Descriptor() protoreflect.EnumDescriptor {}

func (e enum) Type() protoreflect.EnumType             {}

func (e enum) Number() protoreflect.EnumNumber         {}

type enumType

// NewEnumType creates a new EnumType with the provided descriptor.
//
// EnumTypes created by this package are equal if their descriptors are equal.
// That is, if ed1 == ed2, then NewEnumType(ed1) == NewEnumType(ed2).
//
// Enum values created by the EnumType are equal if their numbers are equal.
func NewEnumType(desc protoreflect.EnumDescriptor) protoreflect.EnumType {}

func (et enumType) New(n protoreflect.EnumNumber) protoreflect.Enum {}

func (et enumType) Descriptor() protoreflect.EnumDescriptor         {}

type extensionType

type Message

var _

var _

var _

// NewMessage creates a new message with the provided descriptor.
func NewMessage(desc protoreflect.MessageDescriptor) *Message {}

// ProtoMessage implements the legacy message interface.
func (m *Message) ProtoMessage() {}

// ProtoReflect implements the [protoreflect.ProtoMessage] interface.
func (m *Message) ProtoReflect() protoreflect.Message {}

// String returns a string representation of a message.
func (m *Message) String() string {}

// Reset clears the message to be empty, but preserves the dynamic message type.
func (m *Message) Reset() {}

// Descriptor returns the message descriptor.
func (m *Message) Descriptor() protoreflect.MessageDescriptor {}

// Type returns the message type.
func (m *Message) Type() protoreflect.MessageType {}

// New returns a newly allocated empty message with the same descriptor.
// See [protoreflect.Message] for details.
func (m *Message) New() protoreflect.Message {}

// Interface returns the message.
// See [protoreflect.Message] for details.
func (m *Message) Interface() protoreflect.ProtoMessage {}

// ProtoMethods is an internal detail of the [protoreflect.Message] interface.
// Users should never call this directly.
func (m *Message) ProtoMethods() *protoiface.Methods {}

// Range visits every populated field in undefined order.
// See [protoreflect.Message] for details.
func (m *Message) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {}

// Has reports whether a field is populated.
// See [protoreflect.Message] for details.
func (m *Message) Has(fd protoreflect.FieldDescriptor) bool {}

// Clear clears a field.
// See [protoreflect.Message] for details.
func (m *Message) Clear(fd protoreflect.FieldDescriptor) {}

// Get returns the value of a field.
// See [protoreflect.Message] for details.
func (m *Message) Get(fd protoreflect.FieldDescriptor) protoreflect.Value {}

// Mutable returns a mutable reference to a repeated, map, or message field.
// See [protoreflect.Message] for details.
func (m *Message) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {}

// Set stores a value in a field.
// See [protoreflect.Message] for details.
func (m *Message) Set(fd protoreflect.FieldDescriptor, v protoreflect.Value) {}

func (m *Message) clearOtherOneofFields(fd protoreflect.FieldDescriptor) {}

// NewField returns a new value for assignable to the field of a given descriptor.
// See [protoreflect.Message] for details.
func (m *Message) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {}

// WhichOneof reports which field in a oneof is populated, returning nil if none are populated.
// See [protoreflect.Message] for details.
func (m *Message) WhichOneof(od protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {}

// GetUnknown returns the raw unknown fields.
// See [protoreflect.Message] for details.
func (m *Message) GetUnknown() protoreflect.RawFields {}

// SetUnknown sets the raw unknown fields.
// See [protoreflect.Message] for details.
func (m *Message) SetUnknown(r protoreflect.RawFields) {}

// IsValid reports whether the message is valid.
// See [protoreflect.Message] for details.
func (m *Message) IsValid() bool {}

func (m *Message) checkField(fd protoreflect.FieldDescriptor) {}

type messageType

// NewMessageType creates a new MessageType with the provided descriptor.
//
// MessageTypes created by this package are equal if their descriptors are equal.
// That is, if md1 == md2, then NewMessageType(md1) == NewMessageType(md2).
func NewMessageType(desc protoreflect.MessageDescriptor) protoreflect.MessageType {}

func (mt messageType) New() protoreflect.Message                  {}

func (mt messageType) Zero() protoreflect.Message                 {}

func (mt messageType) Descriptor() protoreflect.MessageDescriptor {}

func (mt messageType) Enum(i int) protoreflect.EnumType {}

func (mt messageType) Message(i int) protoreflect.MessageType {}

type emptyList

func (x emptyList) Len() int                     {}

func (x emptyList) Get(n int) protoreflect.Value {}

func (x emptyList) Set(n int, v protoreflect.Value) {}

func (x emptyList) Append(v protoreflect.Value) {}

func (x emptyList) AppendMutable() protoreflect.Value {}

func (x emptyList) Truncate(n int)                 {}

func (x emptyList) NewElement() protoreflect.Value {}

func (x emptyList) IsValid() bool                  {}

type dynamicList

func (x *dynamicList) Len() int {}

func (x *dynamicList) Get(n int) protoreflect.Value {}

func (x *dynamicList) Set(n int, v protoreflect.Value) {}

func (x *dynamicList) Append(v protoreflect.Value) {}

func (x *dynamicList) AppendMutable() protoreflect.Value {}

func (x *dynamicList) Truncate(n int) {}

func (x *dynamicList) NewElement() protoreflect.Value {}

func (x *dynamicList) IsValid() bool {}

type dynamicMap

func (x *dynamicMap) Get(k protoreflect.MapKey) protoreflect.Value {}

func (x *dynamicMap) Set(k protoreflect.MapKey, v protoreflect.Value) {}

func (x *dynamicMap) Has(k protoreflect.MapKey) bool {}

func (x *dynamicMap) Clear(k protoreflect.MapKey)    {}

func (x *dynamicMap) Mutable(k protoreflect.MapKey) protoreflect.Value {}

func (x *dynamicMap) Len() int {}

func (x *dynamicMap) NewValue() protoreflect.Value {}

func (x *dynamicMap) IsValid() bool {}

func (x *dynamicMap) Range(f func(protoreflect.MapKey, protoreflect.Value) bool) {}

func isSet(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {}

func typecheck(fd protoreflect.FieldDescriptor, v protoreflect.Value) {}

func typeIsValid(fd protoreflect.FieldDescriptor, v protoreflect.Value) error {}

func typecheckSingular(fd protoreflect.FieldDescriptor, v protoreflect.Value) {}

func singularTypeIsValid(fd protoreflect.FieldDescriptor, v protoreflect.Value) error {}

func newListEntry(fd protoreflect.FieldDescriptor) protoreflect.Value {}

// NewExtensionType creates a new ExtensionType with the provided descriptor.
//
// Dynamic ExtensionTypes with the same descriptor compare as equal. That is,
// if xd1 == xd2, then NewExtensionType(xd1) == NewExtensionType(xd2).
//
// The InterfaceOf and ValueOf methods of the extension type are defined as:
//
//	func (xt extensionType) ValueOf(iv any) protoreflect.Value {
//		return protoreflect.ValueOf(iv)
//	}
//
//	func (xt extensionType) InterfaceOf(v protoreflect.Value) any {
//		return v.Interface()
//	}
//
// The Go type used by the proto.GetExtension and proto.SetExtension functions
// is determined by these methods, and is therefore equivalent to the Go type
// used to represent a protoreflect.Value. See the protoreflect.Value
// documentation for more details.
func NewExtensionType(desc protoreflect.ExtensionDescriptor) protoreflect.ExtensionType {}

func (xt extensionType) New() protoreflect.Value {}

func (xt extensionType) Zero() protoreflect.Value {}

func (xt extensionType) TypeDescriptor() protoreflect.ExtensionTypeDescriptor {}

func (xt extensionType) ValueOf(iv any) protoreflect.Value {}

func (xt extensionType) InterfaceOf(v protoreflect.Value) any {}

func (xt extensionType) IsValidInterface(iv any) bool {}

func (xt extensionType) IsValidValue(v protoreflect.Value) bool {}

type extensionTypeDescriptor

func (xt extensionTypeDescriptor) Type() protoreflect.ExtensionType {}

func (xt extensionTypeDescriptor) Descriptor() protoreflect.ExtensionDescriptor {}