interface-go-ipfs-core: github.com/ipfs/interface-go-ipfs-core/path Index | Files

package path

import "github.com/ipfs/interface-go-ipfs-core/path"

Index

Package Files

path.go

type Path Uses

type Path interface {
    // String returns the path as a string.
    String() string

    // Namespace returns the first component of the path.
    //
    // For example path "/ipfs/QmHash", calling Namespace() will return "ipfs"
    //
    // Calling this method on invalid paths (IsValid() != nil) will result in
    // empty string
    Namespace() string

    // Mutable returns false if the data pointed to by this path in guaranteed
    // to not change.
    //
    // Note that resolved mutable path can be immutable.
    Mutable() bool

    // IsValid checks if this path is a valid ipfs Path, returning nil iff it is
    // valid
    IsValid() error
}

Path is a generic wrapper for paths used in the API. A path can be resolved to a CID using one of Resolve functions in the API.

Paths must be prefixed with a valid prefix:

* /ipfs - Immutable unixfs path (files) * /ipld - Immutable ipld path (data) * /ipns - Mutable names. Usually resolves to one of the immutable paths TODO: /local (MFS)

func Join Uses

func Join(base Path, a ...string) Path

Join appends provided segments to the base path

func New Uses

func New(p string) Path

New parses string path to a Path

type Resolved Uses

type Resolved interface {
    // Cid returns the CID of the node referenced by the path. Remainder of the
    // path is guaranteed to be within the node.
    //
    // Examples:
    // If you have 3 linked objects: QmRoot -> A -> B:
    //
    // cidB := {"foo": {"bar": 42 }}
    // cidA := {"B": {"/": cidB }}
    // cidRoot := {"A": {"/": cidA }}
    //
    // And resolve paths:
    //
    // * "/ipfs/${cidRoot}"
    //   * Calling Cid() will return `cidRoot`
    //   * Calling Root() will return `cidRoot`
    //   * Calling Remainder() will return ``
    //
    // * "/ipfs/${cidRoot}/A"
    //   * Calling Cid() will return `cidA`
    //   * Calling Root() will return `cidRoot`
    //   * Calling Remainder() will return ``
    //
    // * "/ipfs/${cidRoot}/A/B/foo"
    //   * Calling Cid() will return `cidB`
    //   * Calling Root() will return `cidRoot`
    //   * Calling Remainder() will return `foo`
    //
    // * "/ipfs/${cidRoot}/A/B/foo/bar"
    //   * Calling Cid() will return `cidB`
    //   * Calling Root() will return `cidRoot`
    //   * Calling Remainder() will return `foo/bar`
    Cid() cid.Cid

    // Root returns the CID of the root object of the path
    //
    // Example:
    // If you have 3 linked objects: QmRoot -> A -> B, and resolve path
    // "/ipfs/QmRoot/A/B", the Root method will return the CID of object QmRoot
    //
    // For more examples see the documentation of Cid() method
    Root() cid.Cid

    // Remainder returns unresolved part of the path
    //
    // Example:
    // If you have 2 linked objects: QmRoot -> A, where A is a CBOR node
    // containing the following data:
    //
    // {"foo": {"bar": 42 }}
    //
    // When resolving "/ipld/QmRoot/A/foo/bar", Remainder will return "foo/bar"
    //
    // For more examples see the documentation of Cid() method
    Remainder() string

    Path
}

Resolved is a path which was resolved to the last resolvable node. ResolvedPaths are guaranteed to return nil from `IsValid`

func IpfsPath Uses

func IpfsPath(c cid.Cid) Resolved

IpfsPath creates new /ipfs path from the provided CID

func IpldPath Uses

func IpldPath(c cid.Cid) Resolved

IpldPath creates new /ipld path from the provided CID

func NewResolvedPath Uses

func NewResolvedPath(ipath ipfspath.Path, c cid.Cid, root cid.Cid, remainder string) Resolved

NewResolvedPath creates new Resolved path. This function performs no checks and is intended to be used by resolver implementations. Incorrect inputs may cause panics. Handle with care.

Package path imports 3 packages (graph) and is imported by 58 packages. Updated 2019-06-13. Refresh now. Tools for package owners.