Struct Doc 

pub struct Doc { /* private fields */ }

Doc is a valid identity document.

To ensure that only valid documents are used, this type is restricted to be read-only. For mutating the document use Doc::edit.

A valid Doc can be constructed in four ways:

1. Doc::initial: a safe way to construct the initial document for an identity.
2. RawDoc::verified: validates a RawDoc’s fields and converts it into a Doc
3. Deserialize: will deserialize a Doc by first deserializing a RawDoc and use RawDoc::verified to construct the Doc.
4. Doc::from_blob: construct a Doc from a Git blob by deserializing its contents.

Implementations

impl Doc

pub fn initial(project: Project, delegate: Did, visibility: Visibility) -> Doc

Construct the initial Doc for an identity.

It will begin with the provided project in the Doc::payload, the delegate as the sole delegate, a threshold of 1, and the given visibility.

pub fn from_blob(blob: &Blob<'_>) -> Result<Doc, DocError>

Construct a Doc contained in the provided Git blob.

pub fn edit(self) -> RawDoc

Convert the Doc into a RawDoc for changing the field values and re-verifying.

pub fn with_edits<F>(self, f: F) -> Result<Doc, DocError>

where F: FnOnce(&mut RawDoc),

Using the current state of the Doc, perform any edits on the RawDoc form and verify the changes.

pub fn version(&self) -> &Version

Get the version of the document.

pub fn payload(&self) -> &BTreeMap<PayloadId, Payload>

Return the associated payloads for this Doc.

pub fn project(&self) -> Result<Project, PayloadError>

Get the project payload, if it exists and is valid, out of this document.

pub fn default_branch(&self) -> Result<Qualified<'_>, DefaultBranchError>

Gets the qualified reference name of the default branch, according to payloads xyz.radicle.project and xyz.radicle.crefs in this document.

pub fn canonical_refs(&self) -> Result<CanonicalRefs, CanonicalRefsError>

Construct the canonical references for this document.

Uses the xyz.radicle.crefs payload (if present) and the xyz.radicle.project payload to determine the HEAD symbolic reference and its associated rule.

There are three cases, depending on whether HEAD is already defined in the crefs payload and whether a project payload exists:

1. Explicit HEAD + project: HEAD must agree with Project::default_branch_qualified, and the matching rule must use delegates with the document’s threshold.
2. Explicit HEAD, no project: The matching rule must use delegates with the document’s threshold.
3. No HEAD: A rule and HEAD symbolic reference are synthesized from the project payload (which must exist).

In all cases the result must pass RawCanonicalRefs::try_into_canonical_refs validation. If a rule for HEAD’s target is missing, it will be caught as a dangling reference there.

pub fn visibility(&self) -> &Visibility

Return the associated Visibility of this document.

pub fn is_public(&self) -> bool

Check whether the visibility of the document is public.

pub fn is_private(&self) -> bool

Check whether the visibility of the document is private.

pub fn threshold(&self) -> usize

Return the associated threshold of this document.

pub fn threshold_nonzero(&self) -> &NonZero<usize>

Return the associated threshold of this document in its non-zero format.

pub fn delegates(&self) -> &Delegates

Return the associated delegates of this document.

pub fn is_delegate(&self, did: &Did) -> bool

Check if the did is part of the Doc::delegates set.

pub fn is_visible_to(&self, did: &Did) -> bool

Check whether this document and the associated repository is visible to the given peer.

pub fn verify_signature( &self, key: &PublicKey, signature: &Signature, blob: Oid, ) -> Result<(), PublicKey>

Validate signature using this document’s delegates, against a given document blob.

pub fn is_majority(&self, votes: usize) -> bool

Check the provided votes passes the Doc::majority.

pub fn majority(&self) -> usize

Return the majority number based on the size of the delegates set.

pub fn encode(&self) -> Result<(Oid, Vec<u8>), DocError>

Encode the Doc as canonical JSON, returning the set of bytes and its corresponding Git Oid.

pub fn sign<G>(&self, signer: &G) -> Result<(Oid, Vec<u8>, Signature), DocError>

where G: Signer<Signature>,

Doc::encode and sign the Doc, returning the set of bytes, its corresponding Git Oid and the Signature over the Oid.

pub fn signature_of<G>(&self, signer: &G) -> Result<Signature, DocError>

where G: Signer<Signature>,

Similar to Doc::sign, but only returning the Signature.

pub fn load_at<R>(commit: Oid, repo: &R) -> Result<DocAt, DocError>

where R: ReadRepository,

Load the DocAt found at the given commit. The DocAt will contain the corresponding Doc.

pub fn init<G>( &self, repo: &Repository, signer: &Device<G>, ) -> Result<Oid, RepositoryError>

where G: Signer<Signature>,

Initialize an identity::Identity with this Doc as the associated document.

Trait Implementations

impl AsRef<Doc> for DocAt

fn as_ref(&self) -> &Doc

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

impl Clone for Doc

fn clone(&self) -> Doc

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Doc

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Doc

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<DocAt> for Doc

fn from(value: DocAt) -> Doc

Converts to this type from the input type.

impl GetPayload for Doc

fn get_payload(&self, id: &PayloadId) -> Option<&Payload>

impl GetRawCanonicalRefs for Doc

fn raw_canonical_refs( &self, ) -> Result<Option<RawCanonicalRefs>, RawCanonicalRefsError>

Retrieve the RawCanonicalRefs by deserializing from the payload (if present).

impl PartialEq for Doc

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<RawDoc> for Doc

type Error = DocError

The type returned in the event of a conversion error.

fn try_from(doc: RawDoc) -> Result<Doc, <Doc as TryFrom<RawDoc>>::Error>

Performs the conversion.

impl Eq for Doc

impl StructuralPartialEq for Doc