Struct Cid 

pub struct Cid {
    bytes: Vec<u8>,
    codec: u64,
}

A content identifier, held as the bytes it hashes and prints from.

The binary form is the canonical one and the string is derived from it, not the other way around: a CID that came in as a string and goes out as one goes out identical, because there is only one string for these bytes.

Fields

bytes: Vec<u8>

Version, codec and multihash, concatenated — the multibase payload.

codec: u64

The codec, parsed out so a caller can ask without re-reading varints.

Implementations

impl Cid

pub fn of_dag_cbor(block: &[u8]) -> Self

The CID of a DAG-CBOR block: sha-256 over exactly these bytes.

This is the whole reason the encoder has to be canonical. The identity of a record is the hash of its encoding, so two encoders that disagree about map order or integer width give the same record two identities, and every other implementation would be right to say ours is the wrong one.

pub fn of_raw(block: &[u8]) -> Self

The CID of a raw block, which is what a blob is referenced by.

fn of_block(codec: u64, block: &[u8]) -> Self

Builds a CID over block under codec.

pub fn parse(text: &str) -> Result<Self, CidError>

Parses the string form: b followed by lowercase base32.

use didbot_data::Cid;
let cid = Cid::parse("bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a").unwrap();
assert_eq!(cid.to_string(), "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a");
assert!(Cid::parse("QmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR").is_err());

pub fn from_bytes(bytes: &[u8]) -> Result<Self, CidError>

Parses the binary form, which is what a DAG-CBOR link tag carries.

pub fn read(input: &mut &[u8]) -> Result<Self, CidError>

Reads a CID off the front of a byte stream, leaving the rest.

A CID is self-delimiting — the multihash declares its own digest length — which is what lets a CAR file put one immediately before a block with no length prefix between them. Cid::from_bytes is the whole-slice form and refuses a trailing byte; this one is the streaming form and hands the trailing bytes back.

use didbot_data::Cid;

let cid = Cid::of_raw(b"a block");
let mut framed = cid.as_bytes().to_vec();
framed.extend_from_slice(b"a block");
let mut rest = framed.as_slice();
assert_eq!(Cid::read(&mut rest).unwrap(), cid);
assert_eq!(rest, b"a block");

pub fn of_block_under(codec: u64, block: &[u8]) -> Self

The CID these bytes have under codec, which is how a reader checks that a block is the one it was handed under a name.

The codec comes from the name being checked rather than from the caller’s expectation: a block is either the bytes its CID says it is or it is not, and which codec that CID declares is part of the claim.

pub fn as_bytes(&self) -> &[u8]

The binary form: version, codec and multihash, with no multibase prefix.

pub fn codec(&self) -> u64

Which of the two permitted codecs this CID names.

Trait Implementations

impl Clone for Cid

fn clone(&self) -> Cid

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Cid

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

Formats the value using the given formatter.

impl Display for Cid

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

Formats the value using the given formatter.

impl Hash for Cid

fn hash<__H: Hasher>(&self, state: &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 Ord for Cid

fn cmp(&self, other: &Cid) -> 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 PartialEq for Cid

fn eq(&self, other: &Cid) -> 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 PartialOrd for Cid

fn partial_cmp(&self, other: &Cid) -> 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 Eq for Cid

impl StructuralPartialEq for Cid