package prototext

Import Path
	google.golang.org/protobuf/encoding/prototext (on go.dev)

Dependency Relation
	imports 16 packages, and imported by 2 packages

Involved Source Files

	      decode.go
	   d➜ doc.go
		Package prototext marshals and unmarshals protocol buffer messages as the
		textproto format.

	      encode.go
Package-Level Type Names (total 4, in which 2 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type MarshalOptions (struct)
		MarshalOptions is a configurable text format marshaler.

		Fields (total 8, in which 7 are exported)
			AllowPartial bool
				AllowPartial allows messages that have missing required fields to marshal
				without returning an error. If AllowPartial is false (the default),
				Marshal will return error if there are any missing required fields.

			EmitASCII bool
				EmitASCII specifies whether to format strings and bytes as ASCII only
				as opposed to using UTF-8 encoding when possible.

			EmitUnknown bool
				EmitUnknown specifies whether to emit unknown fields in the output.
				If specified, the unmarshaler may be unable to parse the output.
				The default is to exclude unknown fields.

			Indent string
				Indent specifies the set of indentation characters to use in a multiline
				formatted output such that every entry is preceded by Indent and
				terminated by a newline. If non-empty, then Multiline is treated as true.
				Indent can only be composed of space or tab characters.

			Multiline bool
				Multiline specifies whether the marshaler should format the output in
				indented-form with every textual element on a new line.
				If Indent is an empty string, then an arbitrary indent is chosen.

			NoUnkeyedLiterals pragma.NoUnkeyedLiterals
			Resolver interface{protoregistry.ExtensionTypeResolver; protoregistry.MessageTypeResolver}
				Resolver is used for looking up types when expanding google.protobuf.Any
				messages. If nil, this defaults to using protoregistry.GlobalTypes.

			/* one unexported ... *//* one unexported: */
			allowInvalidUTF8 bool
				allowInvalidUTF8 specifies whether to permit the encoding of strings
				with invalid UTF-8. This is unexported as it is intended to only
				be specified by the Format method.

		Methods (total 3, in which 2 are exported)
			( T) Format(m proto.Message) string
				Format formats the message as a string.
				This method is only intended for human consumption and ignores errors.
				Do not depend on the output being stable. It may change over time across
				different versions of the program.

			( T) Marshal(m proto.Message) ([]byte, error)
				Marshal writes the given proto.Message in textproto format using options in
				MarshalOptions object. Do not depend on the output being stable. It may
				change over time across different versions of the program.

			/* one unexported ... *//* one unexported: */
			( T) marshal(m proto.Message) ([]byte, error)
				marshal is a centralized function that all marshal operations go through.
				For profiling purposes, avoid changing the name of this function or
				introducing other code paths for marshal that do not go through this.


	 type UnmarshalOptions (struct)
		UnmarshalOptions is a configurable textproto format unmarshaler.

		Fields (total 4, all are exported)
			AllowPartial bool
				AllowPartial accepts input for messages that will result in missing
				required fields. If AllowPartial is false (the default), Unmarshal will
				return error if there are any missing required fields.

			DiscardUnknown bool
				DiscardUnknown specifies whether to ignore unknown fields when parsing.
				An unknown field is any field whose field name or field number does not
				resolve to any known or extension field in the message.
				By default, unmarshal rejects unknown fields as an error.

			NoUnkeyedLiterals pragma.NoUnkeyedLiterals
			Resolver interface{protoregistry.MessageTypeResolver; protoregistry.ExtensionTypeResolver}
				Resolver is used for looking up types when unmarshaling
				google.protobuf.Any messages or extension fields.
				If nil, this defaults to using protoregistry.GlobalTypes.

		Methods (total 2, in which 1 are exported)
			( T) Unmarshal(b []byte, m proto.Message) error
				Unmarshal reads the given []byte and populates the given proto.Message
				using options in the UnmarshalOptions object.
				The provided message must be mutable (e.g., a non-nil pointer to a message).

			/* one unexported ... *//* one unexported: */
			( T) unmarshal(b []byte, m proto.Message) error
				unmarshal is a centralized function that all unmarshal operations go through.
				For profiling purposes, avoid changing the name of this function or
				introducing other code paths for unmarshal that do not go through this.


	/* 2 unexporteds ... *//* 2 unexporteds: */
	 type decoder (struct)

		Fields (total 8, in which 1 are exported)
			Decoder *text.Decoder
			/* 7 unexporteds ... *//* 7 unexporteds: */
			Decoder.in []byte
				in contains the unconsumed input.

			Decoder.lastCall text.call
				lastCall is last method called, either readCall or peekCall.
				Initial value is readCall.

			Decoder.lastErr error
				lastErr contains the last read error.

			Decoder.lastToken text.Token
				lastToken contains the last read token.

			Decoder.openStack []byte
				openStack is a stack containing the byte characters for MessageOpen and
				ListOpen kinds. The top of stack represents the message or the list that
				the current token is nested in. An empty stack means the current token is
				at the top level message. The characters '{' and '<' both represent the
				MessageOpen kind.

			Decoder.orig []byte
				orig is used in reporting line and column.

			opts UnmarshalOptions
		Methods (total 31, in which 3 are exported)
			( T) Peek() (text.Token, error)
				Peek looks ahead and returns the next token and error without advancing a read.

			( T) Position(idx int) (line int, column int)
				Position returns line and column number of given index of the original input.
				It will panic if index is out of range.

			( T) Read() (text.Token, error)
				Read returns the next token.
				It will return an error if there is no valid token.

			/* 28 unexporteds ... *//* 28 unexporteds: */
			( T) consume(n int)
				consume consumes n bytes of input and any subsequent whitespace or comments.

			( T) consumeToken(kind text.Kind, size int, attrs uint8) text.Token
				consumeToken constructs a Token for given Kind from d.in and consumes given
				size-length from it.

			( T) currentOpenKind() (text.Kind, byte)
				currentOpenKind indicates whether current position is inside a message, list
				or top-level message by returning MessageOpen, ListOpen or bof respectively.
				If the returned kind is either a MessageOpen or ListOpen, it also returns the
				corresponding closing character.

			( T) newError(pos int, f string, x ...interface{}) error
				newError returns an error object with position info.

			( T) newSyntaxError(f string, x ...interface{}) error
				newSyntaxError returns a syntax error with line and column information for
				current position.

			( T) parseFieldName() (tok text.Token, err error)
				parseFieldName parses field name and separator.

			( T) parseLiteralValue() (text.Token, bool)
				parseLiteralValue parses a literal value. A literal value is used for
				bools, special floats and enums. This function simply identifies that the
				field value is a literal.

			( T) parseNext(lastKind text.Kind) (text.Token, error)
				parseNext parses the next Token based on given last kind.

			( T) parseNumberValue() (text.Token, bool)
				parseNumberValue parses a number from the input and returns a Token object.

			( T) parseScalar() (text.Token, error)
				parseScalar parses for a string, literal or number value.

			( T) parseString() (string, error)
				parseString parses a string value enclosed in " or '.

			( T) parseStringValue() (text.Token, error)
				parseStringValue parses string field token.
				This differs from parseString since the text format allows
				multiple back-to-back string literals where they are semantically treated
				as a single large string with all values concatenated.

				E.g., `"foo" "bar" "baz"` => "foobarbaz"

			( T) parseTypeName() (text.Token, error)
				parseTypeName parses Any type URL or extension field name. The name is
				enclosed in [ and ] characters. The C++ parser does not handle many legal URL
				strings. This implementation is more liberal and allows for the pattern
				^[-_a-zA-Z0-9]+([./][-_a-zA-Z0-9]+)*`). Whitespaces and comments are allowed
				in between [ ], '.', '/' and the sub names.

			( T) popOpenStack()
			( T) pushOpenStack(ch byte)
			( T) skipMessageValue() error
				skipMessageValue makes the decoder parse and skip over all fields in a
				message. It assumes that the previous read type is MessageOpen.

			( T) skipValue() error
				skipValue makes the decoder parse a field value in order to advance the read
				to the next field. It relies on Read returning an error if the types are not
				in valid sequence.

			( T) syntaxError(pos int, f string, x ...interface{}) error
				syntaxError returns a syntax error for given position.

			( T) tryConsumeChar(c byte) bool
			( T) unexpectedTokenError(tok text.Token) error
				unexpectedTokenError returns a syntax error for the given unexpected token.

			( T) unmarshalAny(m pref.Message, checkDelims bool) error
				unmarshalAny unmarshals an Any textproto. It can either be in expanded form
				or non-expanded form.

			( T) unmarshalExpandedAny(typeURL string, pos int) ([]byte, error)
			( T) unmarshalList(fd pref.FieldDescriptor, list pref.List) error
				unmarshalList unmarshals into given protoreflect.List. A list value can
				either be in [] syntax or simply just a single scalar/message value.

			( T) unmarshalMap(fd pref.FieldDescriptor, mmap pref.Map) error
				unmarshalMap unmarshals into given protoreflect.Map. A map value is a
				textproto message containing {key: <kvalue>, value: <mvalue>}.

			( T) unmarshalMapEntry(fd pref.FieldDescriptor, mmap pref.Map, unmarshalMapValue func() (pref.Value, error)) error
				unmarshalMap unmarshals into given protoreflect.Map. A map value is a
				textproto message containing {key: <kvalue>, value: <mvalue>}.

			( T) unmarshalMessage(m pref.Message, checkDelims bool) error
				unmarshalMessage unmarshals into the given protoreflect.Message.

			( T) unmarshalScalar(fd pref.FieldDescriptor) (pref.Value, error)
				unmarshalScalar unmarshals a scalar/enum protoreflect.Value specified by the
				given FieldDescriptor.

			( T) unmarshalSingular(fd pref.FieldDescriptor, m pref.Message) error
				unmarshalSingular unmarshals a non-repeated field value specified by the
				given FieldDescriptor.


	 type encoder (struct)

		Fields (total 9, in which 1 are exported)
			Encoder *text.Encoder
			/* 8 unexporteds ... *//* 8 unexporteds: */
			Encoder.delims [2]byte
			Encoder.encoderState text.encoderState
			Encoder.encoderState.indents []byte
			Encoder.encoderState.lastType text.encType
			Encoder.encoderState.out []byte
			Encoder.indent string
			Encoder.outputASCII bool
			opts MarshalOptions
		Methods (total 20, in which 12 are exported)
			( T) Bytes() []byte
				Bytes returns the content of the written bytes.

			( T) EndMessage()
				EndMessage writes out the '}' or '>' symbol.

			( T) Reset(es text.encoderState)
				Reset resets the Encoder to the given encoderState from a Snapshot.

			( T) Snapshot() text.encoderState
				Snapshot returns the current snapshot for use in Reset.

			( T) StartMessage()
				StartMessage writes out the '{' or '<' symbol.

			( T) WriteBool(b bool)
				WriteBool writes out the given boolean value.

			( T) WriteFloat(n float64, bitSize int)
				WriteFloat writes out the given float value for given bitSize.

			( T) WriteInt(n int64)
				WriteInt writes out the given signed integer value.

			( T) WriteLiteral(s string)
				WriteLiteral writes out the given string as a literal value without quotes.
				This is used for writing enum literal strings.

			( T) WriteName(s string)
				WriteName writes out the field name and the separator ':'.

			( T) WriteString(s string)
				WriteString writes out the given string value.

			( T) WriteUint(n uint64)
				WriteUint writes out the given unsigned integer value.

			/* 8 unexporteds ... *//* 8 unexporteds: */
			( T) marshalAny(any pref.Message) bool
				marshalAny marshals the given google.protobuf.Any message in expanded form.
				It returns true if it was able to marshal, else false.

			( T) marshalField(name string, val pref.Value, fd pref.FieldDescriptor) error
				marshalField marshals the given field with protoreflect.Value.

			( T) marshalList(name string, list pref.List, fd pref.FieldDescriptor) error
				marshalList marshals the given protoreflect.List as multiple name-value fields.

			( T) marshalMap(name string, mmap pref.Map, fd pref.FieldDescriptor) error
				marshalMap marshals the given protoreflect.Map as multiple name-value fields.

			( T) marshalMessage(m pref.Message, inclDelims bool) error
				marshalMessage marshals the given protoreflect.Message.

			( T) marshalSingular(val pref.Value, fd pref.FieldDescriptor) error
				marshalSingular marshals the given non-repeated field value. This includes
				all scalar types, enums, messages, and groups.

			( T) marshalUnknown(b []byte)
				marshalUnknown parses the given []byte and marshals fields out.
				This function assumes proper encoding in the given []byte.

			( T) prepareNext(next text.encType)
				prepareNext adds possible space and indentation for the next value based
				on last encType and indent option. It also updates e.lastType to next.



Package-Level Functions (total 3, all are exported)

	 func Format(m proto.Message) string
		Format formats the message as a multiline string.
		This function is only intended for human consumption and ignores errors.
		Do not depend on the output being stable. It may change over time across
		different versions of the program.

	 func Marshal(m proto.Message) ([]byte, error)
		Marshal writes the given proto.Message in textproto format using default
		options. Do not depend on the output being stable. It may change over time
		across different versions of the program.

	 func Unmarshal(b []byte, m proto.Message) error
		Unmarshal reads the given []byte into the given proto.Message.
		The provided message must be mutable (e.g., a non-nil pointer to a message).


Package-Level Constants (only one, which is unexported)

	/* one unexported ... *//* one unexported: */
	const defaultIndent = "  "

The pages are generated with Golds v0.3.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.