assert

Documentation

Index

• Constants
• Variables
• func EqualsCaveatsType() ipldschema.Type
• func InclusionCaveatsType() ipldschema.Type
• func IndexCaveatsType() ipldschema.Type
• func LocationCaveatsType() ipldschema.Type
• func PartitionCaveatsType() ipldschema.Type
• func RelationCaveatsType() ipldschema.Type
• type EqualsCaveats
  • func (ec EqualsCaveats) ToIPLD() (datamodel.Node, error)
• type InclusionCaveats
  • func (ic InclusionCaveats) ToIPLD() (datamodel.Node, error)
• type IndexCaveats
  • func (ic IndexCaveats) ToIPLD() (datamodel.Node, error)
• type LegacyLocationCaveats
• type LocationCaveats
  • func (lc LocationCaveats) ToIPLD() (datamodel.Node, error)
• type PartitionCaveats
  • func (pc PartitionCaveats) ToIPLD() (datamodel.Node, error)
• type Range
• type RelationCaveats
  • func (rc RelationCaveats) ToIPLD() (datamodel.Node, error)
• type RelationPart
• type RelationPartInclusion

Constants

const EqualsAbility = "assert/equals"

const InclusionAbility = "assert/inclusion"

const IndexAbility = "assert/index"

const LocationAbility = "assert/location"

const PartitionAbility = "assert/partition"

const RelationAbility = "assert/relation"

Variables

var Equals = validator.NewCapability(
	EqualsAbility,
	schema.DIDString(),
	EqualsCaveatsReader,
	nil,
)

var EqualsCaveatsReader = schema.Struct[EqualsCaveats](EqualsCaveatsType(), nil, types.Converters...)

var Inclusion = validator.NewCapability(InclusionAbility, schema.DIDString(),
	InclusionCaveatsReader, nil)

var InclusionCaveatsReader = schema.Struct[InclusionCaveats](InclusionCaveatsType(), nil, types.Converters...)

var Index = validator.NewCapability(IndexAbility, schema.DIDString(), IndexCaveatsReader, nil)

var IndexCaveatsReader = schema.Struct[IndexCaveats](IndexCaveatsType(), nil, types.Converters...)

var Location = validator.NewCapability(LocationAbility, schema.DIDString(), LocationCaveatsReader, nil)

var LocationCaveatsReader = schema.Mapped(schema.Struct[LegacyLocationCaveats](LocationCaveatsType(), nil, types.Converters...),
	func(llc LegacyLocationCaveats) (LocationCaveats, failure.Failure) {
		space := did.Undef
		if llc.Space != nil {
			space = *llc.Space
		}
		return LocationCaveats{llc.Content, llc.Location, llc.Range, space}, nil
	})

var Partition = validator.NewCapability(
	PartitionAbility,
	schema.DIDString(),
	PartitionCaveatsReader, nil)

var PartitionCaveatsReader = schema.Struct[PartitionCaveats](PartitionCaveatsType(), nil, types.Converters...)

var Relation = validator.NewCapability(
	RelationAbility,
	schema.DIDString(),
	RelationCaveatsReader,
	nil,
)

var RelationCaveatsReader = schema.Struct[RelationCaveats](RelationCaveatsType(), nil, types.Converters...)

Functions

func EqualsCaveatsType

func EqualsCaveatsType() ipldschema.Type

func InclusionCaveatsType

func InclusionCaveatsType() ipldschema.Type

func IndexCaveatsType

func IndexCaveatsType() ipldschema.Type

func LocationCaveatsType

func LocationCaveatsType() ipldschema.Type

func PartitionCaveatsType

func PartitionCaveatsType() ipldschema.Type

func RelationCaveatsType

func RelationCaveatsType() ipldschema.Type

Types

type EqualsCaveats

type EqualsCaveats struct {
	Content types.HasMultihash
	Equals  ipld.Link
}

func (EqualsCaveats) ToIPLD

func (ec EqualsCaveats) ToIPLD() (datamodel.Node, error)

type InclusionCaveats

type InclusionCaveats struct {
	Content  types.HasMultihash
	Includes ipld.Link
	Proof    *ipld.Link
}

func (InclusionCaveats) ToIPLD

func (ic InclusionCaveats) ToIPLD() (datamodel.Node, error)

type IndexCaveats

type IndexCaveats struct {
	Content ipld.Link
	Index   ipld.Link
}

func (IndexCaveats) ToIPLD

func (ic IndexCaveats) ToIPLD() (datamodel.Node, error)

type LegacyLocationCaveats

type LegacyLocationCaveats struct {
	Content  types.HasMultihash
	Location []url.URL
	Range    *Range
	Space    *did.DID
}

Space field used to be optional, so we maintain compatibility

type LocationCaveats

type LocationCaveats struct {
	Content  types.HasMultihash
	Location []url.URL
	Range    *Range
	Space    did.DID
}

func (LocationCaveats) ToIPLD

func (lc LocationCaveats) ToIPLD() (datamodel.Node, error)

type PartitionCaveats

type PartitionCaveats struct {
	Content types.HasMultihash
	Blocks  *ipld.Link
	Parts   []ipld.Link
}

func (PartitionCaveats) ToIPLD

func (pc PartitionCaveats) ToIPLD() (datamodel.Node, error)

type Range

type Range struct {
	Offset uint64
	Length *uint64
}

type RelationCaveats

type RelationCaveats struct {
	Content  types.HasMultihash
	Children []ipld.Link
	Parts    []RelationPart
}

func (RelationCaveats) ToIPLD

func (rc RelationCaveats) ToIPLD() (datamodel.Node, error)

type RelationPart

type RelationPart struct {
	Content  ipld.Link
	Includes *RelationPartInclusion
}

type RelationPartInclusion

type RelationPartInclusion struct {
	Content ipld.Link
	Parts   *[]ipld.Link
}