kubernetes/vendor/github.com/godbus/dbus/v5/sig.go

var sigToType …

type Signature …

// SignatureOf returns the concatenation of all the signatures of the given
// values. It panics if one of them is not representable in D-Bus.
func SignatureOf(vs ...interface{ … }

// SignatureOfType returns the signature of the given type. It panics if the
// type is not representable in D-Bus.
func SignatureOfType(t reflect.Type) Signature { … }

// getSignature returns the signature of the given type and panics on unknown types.
func getSignature(t reflect.Type, depth *depthCounter) (sig string) { … }

// ParseSignature returns the signature represented by this string, or a
// SignatureError if the string is not a valid signature.
func ParseSignature(s string) (sig Signature, err error) { … }

// ParseSignatureMust behaves like ParseSignature, except that it panics if s
// is not valid.
func ParseSignatureMust(s string) Signature { … }

// Empty returns whether the signature is the empty signature.
func (s Signature) Empty() bool { … }

// Single returns whether the signature represents a single, complete type.
func (s Signature) Single() bool { … }

// String returns the signature's string representation.
func (s Signature) String() string { … }

type SignatureError …

func (e SignatureError) Error() string { … }

type depthCounter …

func (cnt *depthCounter) Valid() bool { … }

func (cnt depthCounter) EnterArray() *depthCounter { … }

func (cnt depthCounter) EnterStruct() *depthCounter { … }

func (cnt depthCounter) EnterDictEntry() *depthCounter { … }

// Try to read a single type from this string. If it was successful, err is nil
// and rem is the remaining unparsed part. Otherwise, err is a non-nil
// SignatureError and rem is "". depth is the current recursion depth which may
// not be greater than 64 and should be given as 0 on the first call.
func validSingle(s string, depth *depthCounter) (err error, rem string) { … }

func findMatching(s string, left, right rune) int { … }

// typeFor returns the type of the given signature. It ignores any left over
// characters and panics if s doesn't start with a valid type signature.
func typeFor(s string) (t reflect.Type) { … }