crossref

type BulkBuilder ¶ added in v1.18.1

type BulkBuilder struct {
	byteops.ReadWriter
	// contains filtered or unexported fields
}

BulkBuilder is a low-alloc tool to build many beacon strings (as []byte). It is optimized to allocate just once as opposed to once per ID. This makes it considerably faster when generating 100s of thousand of beacons strings. The main intended use case for this is building propValuePairs in ref-filters.

The BulkBuilder makes some estimations for how much memory will be necessary based on expected input params. If those requirements get exceeded, it will still be safe to use, but will fallback to allocating dynamically.

func NewBulkBuilderWithEstimates(expectedCount int, exampleClassName string,
	overheadRatio float64,
) *BulkBuilder

func (bb *BulkBuilder) ClassAndID(className string,
	id strfmt.UUID,
) []byte

func (bb *BulkBuilder) LegacyIDOnly(id strfmt.UUID) []byte

type Ref ¶

type Ref struct {
	Local    bool        `json:"local"`
	PeerName string      `json:"peerName"`
	TargetID strfmt.UUID `json:"targetID"`
	Class    string      `json:"className"`
}

Ref is an abstraction of the cross-refs which are specified in a URI format in the API. When this type is used it is safe to assume that a Ref is semantically valid. This guarantee would not be possible on the URI format, as the URI can be well-formed, but not contain the data we expect in it. Do not use directly, such as crossref.Ref{}, as you won't have any guarantees in this case. Always use one of the parsing options or New()

func New(peerName string, class string, target strfmt.UUID) *Ref

func NewLocalhost(class string, target strfmt.UUID) *Ref

func Parse(uriString string) (*Ref, error)

func ParseSingleRef(singleRef *models.SingleRef) (*Ref, error)

func (r *Ref) SingleRef() *models.SingleRef

func (r *Ref) String() string

type RefSource ¶

type RefSource struct {
	Local    bool                `json:"local"`
	PeerName string              `json:"peerName"`
	Property schema.PropertyName `json:"property"`
	Class    schema.ClassName    `json:"class"`
	TargetID strfmt.UUID         `json:"targetID"`
}

RefSource is an abstraction of the source of a cross-ref. The opposite would be Ref which represents the target instead. A RefSource is specified in a URI format in the API. When this type is used it is safe to assume that a Ref is semantically valid. This guarantee would not be possible on the URI format, as the URI can be well-formed, but not contain the data we expect in it. Do not use directly, such as crossref.RefSource{}, as you won't have any guarantees in this case. Always use one of the parsing options or New()

func NewSource(className schema.ClassName,
	property schema.PropertyName, id strfmt.UUID,
) *RefSource

func ParseSource(uriString string) (*RefSource, error)

func (r *RefSource) String() string