Struct Link 

#[repr(transparent)]
pub struct Link<T>
where
    T: Clone,
{
    pub cid: Cid,
    /* private fields */
}

A Link is a Cid with a type attached. The type represents the data that the Cid refers to. This is a helpful construct to use to ensure that data structures whose fields or elements may be Cids can still retain strong typing. A Link transparently represents its inner Cid, so a data structure that uses Links can safely be interpretted in terms of Cids, and vice-versa.

Fields

cid: Cid

The wrapped Cid of this Link

Implementations

impl<T> Link<T>

where T: Clone,

pub fn new(cid: Cid) -> Self

Wrap a given Cid in a typed Link

impl<T> Link<T>

where T: Serialize + DeserializeOwned + Clone + ConditionalSend,

pub async fn load_from<S: BlockStore>(&self, store: &S) -> Result<T>

Given a BlockStore, attempt to load a value for the Cid of this Link. The loaded block will be interpretted as the type that is attached to the Cid by this Link, and then returned.

Methods from Deref<Target = Cid>

pub fn version(&self) -> Version

Returns the cid version.

pub fn codec(&self) -> u64

Returns the cid codec.

pub fn hash(&self) -> &Multihash<S>

Returns the cid multihash.

pub fn write_bytes<W>(&self, w: W) -> Result<usize, Error>

where W: Write,

Writes the bytes to a byte stream, returns the number of bytes written.

pub fn encoded_len(&self) -> usize

Returns the length in bytes needed to encode this cid into bytes.

pub fn to_bytes(&self) -> Vec<u8>

Returns the encoded bytes of the Cid.

pub fn to_string_of_base(&self, base: Base) -> Result<String, Error>

Convert CID into a multibase encoded string

Example

use cid::Cid;
use multibase::Base;
use multihash::{Code, MultihashDigest};

const RAW: u64 = 0x55;

let cid = Cid::new_v1(RAW, Code::Sha2_256.digest(b"foo"));
let encoded = cid.to_string_of_base(Base::Base64).unwrap();
assert_eq!(encoded, "mAVUSICwmtGto/8aP+ZtFPB0wQTQTQi1wZIO/oPmKXohiZueu");

Trait Implementations

impl<T> AsRef<Cid<64>> for Link<T>

where T: Clone,

fn as_ref(&self) -> &Cid

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

impl<T> Clone for Link<T>

where T: Clone + Clone,

fn clone(&self) -> Link<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Link<T>

where T: Clone,

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

Formats the value using the given formatter.

impl<C: Codec, T> Decode<C> for Link<T>

where Cid: Decode<C>, T: Clone,

fn decode<R: Read + Seek>(c: C, r: &mut R) -> Result<Self>

Decode from an impl Read.

impl<T> Deref for Link<T>

where T: Clone,

type Target = Cid<64>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de, T> Deserialize<'de> for Link<T>

where T: Clone,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Display for Link<T>

where T: Clone,

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

Formats the value using the given formatter.

impl<C: Codec, T> Encode<C> for Link<T>

where Cid: Encode<C>, T: Clone,

fn encode<W: Write>(&self, c: C, w: &mut W) -> Result<()>

Encodes into a impl Write.

impl<T> From<&Cid<64>> for Link<T>

where T: Clone,

fn from(cid: &Cid) -> Self

Converts to this type from the input type.

impl<T> From<Cid<64>> for Link<T>

where T: Clone,

fn from(cid: Cid) -> Self

Converts to this type from the input type.

impl<T> From<Link<T>> for Cid

where T: Clone,

fn from(link: Link<T>) -> Self

Converts to this type from the input type.

impl<T> From<Link<T>> for String

where T: Clone,

fn from(value: Link<T>) -> Self

Converts to this type from the input type.

impl<T> FromStr for Link<T>

where T: Clone,

type Err = <Cid<64> as FromStr>::Err

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<T> Hash for Link<T>

where T: Clone,

fn hash<H: Hasher>(&self, hasher: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Hash for Link<T>

where T: Clone,

fn hash<H: Hasher>(&self, state: &mut H)

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

impl<T> Ord for Link<T>

where T: Clone + Ord,

fn cmp(&self, other: &Link<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T> PartialEq for Link<T>

where T: Clone,

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> PartialOrd for Link<T>

where T: Clone + PartialOrd,

fn partial_cmp(&self, other: &Link<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Serialize for Link<T>

where T: Clone,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> TryBundle for Link<T>

where T: TryBundle + Clone,

fn extend_bundle<'life0, 'life1, 'life2, 'async_trait, S>( &'life0 self, bundle: &'life1 mut Bundle, store: &'life2 S, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where S: 'async_trait + BlockStore, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn extend_bundle_with_cid<'life0, 'life1, 'life2, 'async_trait, S>( cid: &'life0 Cid, bundle: &'life1 mut Bundle, store: &'life2 S, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where S: 'async_trait + BlockStore, Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn bundle<'life0, 'life1, 'async_trait, S>( &'life0 self, store: &'life1 S, ) -> Pin<Box<dyn Future<Output = Result<Bundle>> + Send + 'async_trait>>

where S: 'async_trait + BlockStore, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn bundle_with_cid<'life0, 'life1, 'async_trait, S>( cid: &'life0 Cid, store: &'life1 S, ) -> Pin<Box<dyn Future<Output = Result<Bundle>> + Send + 'async_trait>>

where S: 'async_trait + BlockStore, Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<T> Copy for Link<T>

where T: Clone,

impl<T> Eq for Link<T>

where T: Clone,