Struct hdk::hash_path::path::Path

#[repr(transparent)]
pub struct Path(_);

A Path is a vector of Component . It represents a single traversal of a tree structure down to some arbitrary point. The main intent is that we can recursively walk back up the tree, hashing, committing and linking each sub-path along the way until we reach the root. At this point it is possible to follow DHT links from the root back up the path. i.e. the ahead-of-time predictability of the hashes of a given path allows us to travel “up” the tree and the linking functionality of the holochain DHT allows us to travel “down” the tree after at least one DHT participant has followed the path “up”.

Implementations

impl Path

pub fn into_typed(self, link_type: impl Into<LinkType>) -> TypedPath

Attach a LinkType to this path so its type is known for create_link and get_links.

pub fn typed<TY, E>(self, link_type: TY) -> Result<TypedPath, WasmError> where
    LinkType: TryFrom<TY, Error = E>,
    WasmError: From<E>, 

Try attaching a LinkType to this path so its type is known for create_link and get_links.

pub fn path_entry_hash(&self) -> ExternResult<EntryHash>

What is the hash for the current Path ?

pub fn append_component(&mut self, component: Component)

Mutate this Path into a child of itself by appending a Component.

pub fn leaf(&self) -> Option<&Component>

Accessor for the last Component of this Path. This can be thought of as the leaf of the implied tree structure of which this Path is one branch of.

pub fn make_tag(&self) -> ExternResult<LinkTag>

Make the LinkTag for this Path.

pub fn is_root(&self) -> bool

Check if this Path is the root.

Trait Implementations

impl AsRef<Vec<Component, Global>> for Path

Access components vector.

fn as_ref(&self) -> &Vec<Component>

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Path

fn clone(&self) -> Path

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Path

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Path

fn default() -> Path

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Path

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl From<&'_ Anchor> for Path

Anchors are just a special case of path, so we can move from anchor to path losslessly. We simply format the anchor structure into a string that works with the path string handling.

fn from(anchor: &Anchor) -> Self

Converts to this type from the input type.

impl From<&'_ String> for Path

Alias From<&str>

fn from(s: &String) -> Self

Converts to this type from the input type.

impl From<&'_ str> for Path

Split a string path out into a vector of components. This allows us to construct pseudo-URI-path-things as strings. It is a simpler scheme than URLs and file paths. Leading and trailing slashes are ignored as are duplicate dots and the empty string leads to a path with zero length (no components).

e.g. all the following result in the same components as vec!["foo", "bar"] (as bytes)

• foo.bar
• foo.bar.
• .foo.bar
• .foo.bar.
• foo..bar

There is no normalisation of paths, e.g. to guarantee a specific root component exists, at this layer so there is a risk that there are hash collisions with other data on the DHT network if some disambiguation logic is not included in higher level abstractions.

This supports sharding strategies from a small inline DSL. Start each component with :# to get shards out of the string.

e.g.

• foo.barbaz => normal path as above [“foo”, “barbaz”]
• foo.1:3#barbazii => width 1, depth 3, [“foo”, “b”, “a”, “r”, “barbazii”]
• foo.2:3#barbazii => width 2, depth 3, [“foo”, “ba”, “rb”, “az”, “barbazii”]

Note that this all works because the components and sharding for strings maps to fixed-width utf32 bytes under the hood rather than variable width bytes.

fn from(s: &str) -> Self

Converts to this type from the input type.

impl From<(&'_ ShardStrategy, &'_ [u8])> for Path

Builds a path for a shard strategy and some binary bytes. This is the trivial case, we just split the bytes out one by one and make a path from it.

fn from((strategy, bytes): (&ShardStrategy, &[u8])) -> Path

Converts to this type from the input type.

impl From<(&'_ ShardStrategy, &'_ String)> for Path

&String wrapper mimicking &str for Path building.

fn from((strategy, s): (&ShardStrategy, &String)) -> Path

Converts to this type from the input type.

impl From<(&'_ ShardStrategy, &'_ Vec<u8, Global>)> for Path

Wrapper around &Vec to work the same as &u8.

fn from((strategy, bytes): (&ShardStrategy, &Vec<u8>)) -> Path

Converts to this type from the input type.

impl From<(&'_ ShardStrategy, &'_ str)> for Path

Create Path from String . To ensure that this works for all utf8, which can have anywhere from 1-4 bytes for a single character, we first represent each character as a utf32 so it gets padded out with 0 bytes. This means the width is 4x what it would be for raw bytes with the same strategy.

fn from((strategy, s): (&ShardStrategy, &str)) -> Path

Converts to this type from the input type.

impl From<(&'_ ShardStrategy, String)> for Path

fn from((strategy, s): (&ShardStrategy, String)) -> Path

Converts to this type from the input type.

impl From<(&'_ ShardStrategy, Vec<u8, Global>)> for Path

Wrapper around Vec to work the same as &u8.

fn from((strategy, bytes): (&ShardStrategy, Vec<u8>)) -> Path

Converts to this type from the input type.

impl From<Path> for Vec<Component>

Unwrap components vector.

fn from(path: Path) -> Self

Converts to this type from the input type.

impl From<String> for Path

Alias From<&str>

fn from(s: String) -> Self

Converts to this type from the input type.

impl From<TypedPath> for Path

fn from(p: TypedPath) -> Self

Converts to this type from the input type.

impl From<Vec<Component, Global>> for Path

Wrap components vector.

fn from(components: Vec<Component>) -> Self

Converts to this type from the input type.

impl PartialEq<Path> for Path

fn eq(&self, other: &Path) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Path) -> bool

This method tests for !=.

impl Serialize for Path

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl TryFrom<&'_ Path> for Anchor

Paths are more general than anchors so a path could be represented that is not a valid anchor. The obvious example would be a path of binary data that is not valid utf-8 strings or a path that is more than 2 levels deep.

type Error = WasmError

The type returned in the event of a conversion error.

fn try_from(path: &Path) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&'_ Path> for SerializedBytes

type Error = SerializedBytesError

The type returned in the event of a conversion error.

fn try_from(t: &Path) -> Result<SerializedBytes, SerializedBytesError>

Performs the conversion.

impl TryFrom<Path> for SerializedBytes

type Error = SerializedBytesError

The type returned in the event of a conversion error.

fn try_from(t: Path) -> Result<SerializedBytes, SerializedBytesError>

Performs the conversion.

impl TryFrom<SerializedBytes> for Path

type Error = SerializedBytesError

The type returned in the event of a conversion error.

fn try_from(sb: SerializedBytes) -> Result<Path, SerializedBytesError>

Performs the conversion.

impl StructuralPartialEq for Path