object

Documentation

Index

• Constants
• func MakeFieldMaskReflection(mask FieldMask, pathParser func(raw string) (FieldPath, error)) preflect.Message
• type FieldMask
• type FieldPath
• type FieldPathArrayItemValue
  • func ParseFieldPathArrayItemValue(fp FieldPath, valueStr string) (FieldPathArrayItemValue, error)
• type FieldPathArrayOfValues
  • func ParseFieldPathArrayOfValues(fp FieldPath, valuesStr string) (FieldPathArrayOfValues, error)
• type FieldPathValue
  • func ParseFieldPathValue(fp FieldPath, valueStr string) (FieldPathValue, error)
• type GotenObjectExt
• type RawFieldPath
  • func ParseRawFieldPath(rawPath string) (RawFieldPath, error)
  • func (fp RawFieldPath) LastItem() string
  • func (fp RawFieldPath) String() string

Constants

const (
	PathsFieldName = "paths"
)

Functions

func MakeFieldMaskReflection

func MakeFieldMaskReflection(mask FieldMask, pathParser func(raw string) (FieldPath, error)) preflect.Message

Types

type FieldMask

type FieldMask interface {
	fmt.Stringer
	proto.Message

	// ToProtoFieldMask converts to google.protobuf.FieldMask
	ToProtoFieldMask() *fieldmaskpb.FieldMask

	// FromProtoFieldMask erases current contents and re-fills using
	// paths provided by google.protobuf.FieldMask
	FromProtoFieldMask(*fieldmaskpb.FieldMask) error

	// AppendRawPath appends new field path
	AppendRawPath(path FieldPath)

	// SubtractRaw creates new FieldMask by subtracting current
	// instance from the one given as argument.
	// Subtracting operation is using following rules:
	// * F1 {A, C} - F2 {A, B} = F3 {C} (A removes A)
	// * F1 {A} - F2 {A.B} = F3 {A.X1, ... A.Xn} (where X
	//   is any possible subpath of A that is not B).
	//   Exception to this rule are field paths containing
	//   map keys, where possible Xn combinations are
	//   open-ended. Sub-paths ending on map leaves are
	//   ignored in F2 (left side argument).
	// * F1 {A.B} - F2 {A} = F3 {} (if we remove A, we remove
	//   all sub-paths of A too).
	SubtractRaw(other FieldMask) FieldMask

	// GetRawPaths returns all current field paths
	GetRawPaths() []FieldPath

	// IsFull indicates if mask is full. Mask is considered as
	// full, if proto.Equal(a, mask.CloneRaw(a)) equals
	// true.
	IsFull() bool

	// SetRaw copies shallowly values pointed by internally hold
	// fields paths from source to the target.
	SetRaw(target, source GotenObjectExt)

	// ProjectRaw makes projection (shallow copy) of the given
	// resource for internal field paths only.
	// If the mask is nil, then same object is returned.
	ProjectRaw(source GotenObjectExt) GotenObjectExt

	// PathsCount returns number of field paths included
	PathsCount() int
}

FieldMask describes an interface Interface of goten field mask.

type FieldPath

type FieldPath interface {
	fmt.Stringer
	JSONString() string
	GetRaw(proto.Message) []interface{}
	GetSingleRaw(proto.Message) (interface{}, bool)
	GetDefault() interface{}
	ClearValueRaw(item proto.Message)
	WithRawIValue(value interface{}) FieldPathValue
	WithRawIArrayOfValues(values interface{}) FieldPathArrayOfValues
	WithRawIArrayItemValue(value interface{}) FieldPathArrayItemValue
	IsLeaf() bool
	SplitIntoTerminalIPaths() []FieldPath
}

type FieldPathArrayItemValue

type FieldPathArrayItemValue interface {
	FieldPath
	GetRawItemValue() interface{}
}

func ParseFieldPathArrayItemValue

func ParseFieldPathArrayItemValue(fp FieldPath, valueStr string) (FieldPathArrayItemValue, error)

type FieldPathArrayOfValues

type FieldPathArrayOfValues interface {
	FieldPath
	GetRawValues() []interface{}
}

func ParseFieldPathArrayOfValues

func ParseFieldPathArrayOfValues(fp FieldPath, valuesStr string) (FieldPathArrayOfValues, error)

type FieldPathValue

type FieldPathValue interface {
	FieldPath
	GetRawValue() interface{}
	SetToRaw(target proto.Message)
	CompareWithRaw(msg proto.Message) (cmp int, comparable bool)
}

func ParseFieldPathValue

func ParseFieldPathValue(fp FieldPath, valueStr string) (FieldPathValue, error)

type GotenObjectExt

type GotenObjectExt interface {
	fmt.Stringer
	proto.Message
	GotenObjectExt()

	// CloneRaw clones current object.
	CloneRaw() GotenObjectExt

	// MergeRaw merges provided source into current object.
	MergeRaw(GotenObjectExt)

	// MakeRawFullFieldMask returns full mask. Full field mask contains
	// paths of all fields without sub paths items,
	// as it is considered that field path already contains
	// sub paths.
	MakeRawFullFieldMask() FieldMask

	// MakeRawDiffFieldMask returns diff mask compared with given resource.
	// Panics, if other resource is not of same type.
	MakeRawDiffFieldMask(other GotenObjectExt) FieldMask
}

GotenObjectExt is implemented by a Go representation of a protobuf message for which protoc-goten-gen-object plugin was used. GotenObjectExt is basically an extension of a regular go-protobuf object containing many additional goten-specific features like type-safe embedded field paths, field masks, diff support, customized merge support etc. Those extensions are mandatory for request or resource objects, but can be turned off for most other types.

type RawFieldPath

type RawFieldPath []string

func ParseRawFieldPath

func ParseRawFieldPath(rawPath string) (RawFieldPath, error)

func (RawFieldPath) LastItem

func (fp RawFieldPath) LastItem() string

func (RawFieldPath) String

func (fp RawFieldPath) String() string