types

Documentation

Index

• Variables
• func DigestType() ipldschema.Type
• func HeadersType() ipldschema.Type
• type DigestModel
• type HasMultihash
  • func Digest(d DigestModel) (HasMultihash, failure.Failure)
  • func FromHash(mh mh.Multihash) HasMultihash
  • func Link(l datamodel.Link) (HasMultihash, failure.Failure)
• type HeadersModel

Variables

var Converters = []bindnode.Option{MultiaddrConverter, HasMultihashConverter, DIDConverter, URLConverter, HTTPHeaderConverter, Version1LinkConverter, PieceLinkConverter, MerkleNodeConverter}

var DIDConverter = options.NamedBytesConverter("DID", func(bytes []byte) (did.DID, error) {
	if len(bytes) == 0 {
		return did.Undef, nil
	}
	return did.Decode(bytes)
}, func(did did.DID) ([]byte, error) { return did.Bytes(), nil })

var ErrWrongLength = errors.New("length must be 32")

var HTTPHeaderConverter = options.NamedAnyConverter("HTTPHeaders", nodeToHeader, headerToNode)

var HasMultihashConverter = options.NamedAnyConverter("HasMultihash", func(nd datamodel.Node) (HasMultihash, error) {
	return linkOrDigest.Read(nd)
}, func(h HasMultihash) (datamodel.Node, error) {
	return h.ToIPLD()
})

var MerkleNodeConverter = options.NamedBytesConverter("Node", func(b []byte) (merkletree.Node, error) {
	if len(b) != len(merkletree.Node{}) {
		return merkletree.Node{}, ErrWrongLength
	}
	return *(*merkletree.Node)(b), nil
}, func(n merkletree.Node) ([]byte, error) {
	return n[:], nil
})

var MultiaddrConverter = options.NamedBytesConverter("Multiaddr", multiaddr.NewMultiaddrBytes, func(m multiaddr.Multiaddr) ([]byte, error) {
	return m.Bytes(), nil
})

var PieceLinkConverter = options.NamedLinkConverter("PieceLink", func(c cid.Cid) (piece.PieceLink, error) {
	return piece.FromLink(cidlink.Link{Cid: c})
}, func(p piece.PieceLink) (cid.Cid, error) {
	return p.Link().(cidlink.Link).Cid, nil
})

var URLConverter = options.NamedStringConverter("URL",
	func(s string) (url.URL, error) { return schema.URI().Read(s) },
	func(url url.URL) (string, error) { return url.String(), nil })

var Version1LinkConverter = options.NamedLinkConverter("V1Link", func(c cid.Cid) (ipld.Link, error) {
	return schema.Link(schema.WithVersion(1)).Read(cidlink.Link{Cid: c})
}, func(link ipld.Link) (cid.Cid, error) {
	cl, ok := link.(cidlink.Link)
	if !ok {
		return cid.Undef, errors.New("unsupported link type")
	}
	return cl.Cid, nil
})

Functions

func DigestType

func DigestType() ipldschema.Type

func HeadersType

func HeadersType() ipldschema.Type

Types

type DigestModel

type DigestModel struct {
	Digest []byte
}

type HasMultihash

type HasMultihash interface {
	ToIPLD() (datamodel.Node, error)
	Hash() mh.Multihash
	// contains filtered or unexported methods
}

func Digest

func Digest(d DigestModel) (HasMultihash, failure.Failure)

func FromHash

func FromHash(mh mh.Multihash) HasMultihash

func Link

func Link(l datamodel.Link) (HasMultihash, failure.Failure)

type HeadersModel

type HeadersModel struct {
	Keys   []string
	Values map[string]string
}