merkledag

Documentation

Overview

package merkledag implements the ipfs Merkle DAG datastructures.

Index

• Variables
• func FetchGraph(ctx context.Context, root *Node, serv DAGService) chan struct{}
• type DAGService
  • func NewDAGService(bs *bserv.BlockService) DAGService
• type Link
  • func MakeLink(n *Node) (*Link, error)
  • func (l *Link) GetNode(serv DAGService) (*Node, error)
• type Node
  • func Decoded(encoded []byte) (*Node, error)
  • func (n *Node) AddNodeLink(name string, that *Node) error
  • func (n *Node) AddNodeLinkClean(name string, that *Node) error
  • func (n *Node) Copy() *Node
  • func (n *Node) Encoded(force bool) ([]byte, error)
  • func (n *Node) Key() (u.Key, error)
  • func (n *Node) Marshal() ([]byte, error)
  • func (n *Node) MarshalTo(encoded []byte) error
  • func (n *Node) Multihash() (mh.Multihash, error)
  • func (n *Node) RemoveNodeLink(name string) error
  • func (n *Node) Size() (uint64, error)
  • func (n *Node) Unmarshal(encoded []byte) error
• type NodeMap

Variables

var ErrNotFound = fmt.Errorf("merkledag: not found")

Functions

func FetchGraph

func FetchGraph(ctx context.Context, root *Node, serv DAGService) chan struct{}

FetchGraph asynchronously fetches all nodes that are children of the given node, and returns a channel that may be waited upon for the fetch to complete

Types

type DAGService

type DAGService interface {
	Add(*Node) (u.Key, error)
	AddRecursive(*Node) error
	Get(u.Key) (*Node, error)
	Remove(*Node) error
}

DAGService is an IPFS Merkle DAG service.

func NewDAGService

func NewDAGService(bs *bserv.BlockService) DAGService

type Link

type Link struct {
	// utf string name. should be unique per object
	Name string // utf8

	// cumulative size of target object
	Size uint64

	// multihash of the target object
	Hash mh.Multihash

	// a ptr to the actual node for graph manipulation
	Node *Node
}

Link represents an IPFS Merkle DAG Link between Nodes.

func MakeLink

func MakeLink(n *Node) (*Link, error)

MakeLink creates a link to the given node

func (*Link) GetNode

func (l *Link) GetNode(serv DAGService) (*Node, error)

GetNode returns the MDAG Node that this link points to

type Node

type Node struct {
	Links []*Link
	Data  []byte
	// contains filtered or unexported fields
}

Node represents a node in the IPFS Merkle DAG. nodes have opaque data and a set of navigable links.

func Decoded

func Decoded(encoded []byte) (*Node, error)

Decoded decodes raw data and returns a new Node instance.

func (*Node) AddNodeLink

func (n *Node) AddNodeLink(name string, that *Node) error

AddNodeLink adds a link to another node.

func (*Node) AddNodeLinkClean

func (n *Node) AddNodeLinkClean(name string, that *Node) error

AddNodeLink adds a link to another node. without keeping a reference to the child node

func (*Node) Copy

func (n *Node) Copy() *Node

Copy returns a copy of the node. NOTE: does not make copies of Node objects in the links.

func (*Node) Encoded

func (n *Node) Encoded(force bool) ([]byte, error)

Encoded returns the encoded raw data version of a Node instance. It may use a cached encoded version, unless the force flag is given.

func (*Node) Key

func (n *Node) Key() (u.Key, error)

Key returns the Multihash as a key, for maps.

func (*Node) Marshal

func (n *Node) Marshal() ([]byte, error)

Marshal encodes a *Node instance into a new byte slice. The conversion uses an intermediate PBNode.

func (*Node) MarshalTo

func (n *Node) MarshalTo(encoded []byte) error

MarshalTo encodes a *Node instance into a given byte slice. The conversion uses an intermediate PBNode.

func (*Node) Multihash

func (n *Node) Multihash() (mh.Multihash, error)

Multihash hashes the encoded data of this node.

func (*Node) RemoveNodeLink

func (n *Node) RemoveNodeLink(name string) error

Remove a link on this node by the given name

func (*Node) Size

func (n *Node) Size() (uint64, error)

Size returns the total size of the data addressed by node, including the total sizes of references.

func (*Node) Unmarshal

func (n *Node) Unmarshal(encoded []byte) error

Unmarshal decodes raw data into a *Node instance. The conversion uses an intermediate PBNode.

type NodeMap

type NodeMap map[u.Key]*Node

NodeMap maps u.Keys to Nodes. We cannot use []byte/Multihash for keys :( so have to convert Multihash bytes to string (u.Key)