README
¶
This package is deprecated!
See instead:
- Content ID / CID: https://github.com/ipfs/go-cid
- Node interface for IPLD: https://github.com/ipfs/go-ipld-format
- CBOR IPLD Node: https://github.com/ipfs/go-ipld-cbor
- Git IPLD Node: https://github.com/ipfs/go-ipld-git
- Ethereum IPLD Node: https://github.com/ipfs/go-ipld-eth
- Bitcoin IPLD Node: https://github.com/ipfs/go-ipld-btc
- Zcash IPLD Node: https://github.com/ipfs/go-ipld-zcash
go-ipld
The Go implementation of IPLD
This is the Go implementation of the IPLD spec.
WIP
Install
TODO
Usage
TODO
Contribute
Feel free to join in. All welcome. Open an issue!
This repository falls under the IPFS Code of Conduct.
Want to hack on IPFS?
License
MIT
Documentation
¶
Index ¶
- Constants
- Variables
- func EscapePathComponent(comp string) string
- func GetPath(root interface{}, path_ string) interface{}
- func GetPathCmp(root interface{}, npath []string) interface{}
- func IsLink(v interface{}) bool
- func Links(n Node) map[string]Link
- func TransformFrom(root Node, startFrom []string, transformFn TransformFunc) (interface{}, error)
- func UnescapePathComponent(comp string) string
- func Walk(root Node, walkFn WalkFunc) error
- func WalkFrom(root Node, startFrom string, walkFn WalkFunc) error
- type Link
- type Node
- type TransformFunc
- type WalkFunc
Constants ¶
const ( IDKey = "@id" // the id of the object (JSON-LD) TypeKey = "@type" // the type of the object (JSON-LD) ValueKey = "@value" // the value of the object (JSON-LD) CtxKey = "@context" // the JSON-LD style context CodecKey = "@codec" // used to determine which multicodec to use LinkKey = "mlink" // key for merkle-links )
These are the constants used in the format.
Variables ¶
var SkipNode = errors.New("skip node from Walk")
SkipNode is a special value used with Walk and WalkFunc. If a WalkFunc returns SkipNode, the walk skips the curr node and its children. It behaves like file/filepath.SkipDir
Functions ¶
func EscapePathComponent ¶
Escape path component. The special characters ("@" and "\") are escaped to allow mixing the path component with directives (starting with "@") in IPLD data structure.
func GetPath ¶
func GetPath(root interface{}, path_ string) interface{}
GetPath gets a descendant of root, at npath. GetPath uses the UNIX path abstraction: components of a path are delimited with "/". The path MUST start with "/".
func GetPathCmp ¶
func GetPathCmp(root interface{}, npath []string) interface{}
GetPathCmp gets a descendant of root, at npath.
func IsLink ¶
func IsLink(v interface{}) bool
checks whether a value is a link. for now we assume that all links follow:
{ "mlink": "<multihash>" }
func Links ¶
Links walks given node and returns all links found, in a flattened map. the map keys use path notation, made up of the intervening keys. For example:
{
"foo": {
"quux": { @type: mlink, @value: Qmaaaa... },
},
"bar": {
"baz": { @type: mlink, @value: Qmbbbb... },
},
}
would produce links:
{
"foo/quux": { @type: mlink, @value: Qmaaaa... },
"bar/baz": { @type: mlink, @value: Qmbbbb... },
}
WARNING: your nodes should not use `/` as key names. it will confuse link parsers. thus, if we find any map keys with slash in them, we simply ignore them.
func TransformFrom ¶
func TransformFrom(root Node, startFrom []string, transformFn TransformFunc) (interface{}, error)
TransformFrom is just like Transform, but starts the Walk at given startFrom sub-node.
func UnescapePathComponent ¶
Unescape path component from the IPLD data structure. Special characters are unescaped. See also EscapePathComponent function.
func Walk ¶
Walk traverses the given root node and all its children, calling WalkFunc with every Node visited, including root. All errors that arise while visiting nodes are passed to given WalkFunc. The order in which children are visited is not deterministic. Walk traverses sequences as well, which is to mean the nodes below will be visted as "foo/0", "foo/1", and "foo/3":
{ "foo": [
{"a":"aaa"}, // visited as foo/0
{"b":"bbb"}, // visited as foo/1
{"c":"ccc"}, // visited as foo/2
]}
Note Walk is purely local and does not traverse Links. For a version of Walk that does traverse links, see the ipld/traverse package.
Types ¶
type Link ¶
type Link Node
Link is a merkle-link to a target Node. The Link object is represented by a JSON-LD style map:
{ "@type": "mlink", "@value": <multihash>, ... }
Links support adding other data, which will be serialized and de-serialized along with the link. This allows users to set other properties on links:
{
"@type": "mlink",
"@value": <multihash>,
"unixType": "dir",
"unixMode": "0777",
}
looking at a whole filesystem node, we might see something like:
{
"@context": "/ipfs/Qmf1ec6n9f8kW8JTLjqaZceJVpDpZD4L3aPoJFvssBE7Eb/merkleweb",
"foo": {
"@type": "mlink",
"@value": <multihash>,
"unixType": "dir",
"unixMode": "0777",
},
"bar": {
"@type": "mlink",
"@value": <multihash>,
"unixType": "file",
"unixMode": "0755",
}
}
func LinkCast ¶
returns the link value of an object. for now we assume that all links follow:
{ "mlink": "<multihash>" }
func (Link) Equal ¶
Equal returns whether two Link objects are equal. It uses reflect.DeepEqual, so beware compating large structures.
type Node ¶
type Node map[string]interface{}
Node is an IPLD node. effectively, it is equivalent to a JSON-LD object. (which is {,de}serialized to CBOR or JSON) which derives from a base schema, the IPLD schema (@context). This allows keys to specify:
"myfield": { "@value": "Qmabcbcbdba", "@type": "mlink" }
"mlink" signals that "@value" is taken to be a merkle-link, which IPFS handles specially.
func Transform ¶
func Transform(root Node, transformFn TransformFunc) (Node, error)
Transform traverses the given root node and all its children, calling TransformFunc with every Node visited, including root. All errors that arise while visiting nodes are passed to given TransformFunc. The traversing algorithm is the same as the Walk function.
Transform returns a node constructed from the different nodes returned by TransformFunc.
func (Node) Context ¶
func (d Node) Context() interface{}
Context is a convenience method to retrieve the JSON-LD-style context. It may be a string (link to context), a []interface (multiple contexts), or a Node (an inline context)
func (Node) Get ¶
Get retrieves a property of the node. it uses unix path notation, splitting on "/".
type TransformFunc ¶
TransformFunc is the type of the function called for each node visited by Transform. The root argument is the node from which the Transform began. The curr argument is the currently visited node. The path argument is the traversal path, from root to curr.
If there was a problem walking to curr, the err argument will describe the problem and the function can decide how to handle the error (and Transform _will not_ descend into any of the children of curr).
TransformFunc may return a node, in which case the returned node will be used for further traversal instead of the curr node.
TransformFunc may return an error. If the error is the special SkipNode error, the children of curr are skipped. All other errors halt processing early.
type WalkFunc ¶
WalkFunc is the type of the function called for each node visited by Walk. The root argument is the node from which the Walk began. The curr argument is the currently visited node. The path argument is the traversal path, from root to curr.
If there was a problem walking to curr, the err argument will describe the problem and the function can decide how to handle the error (and Walk _will not_ descend into any of the children of curr).
WalkFunc may return an error. If the error is the special SkipNode error, the children of curr are skipped. All other errors halt processing early. In this respect, it behaves just like file/filepath.WalkFunc
Source Files
Directories