Struct Identity 

pub struct Identity {
    pub id: RepoId,
    pub current: Oid,
    pub root: Oid,
    pub heads: BTreeMap<Did, Oid>,
    /* private fields */
}

An evolving identity document.

Fields

id: RepoId

The canonical identifier for this identity. This is the object id of the initial document blob.

current: Oid

The current revision of the document. Equal to the head of the identity branch.

root: Oid

The initial revision of the document.

heads: BTreeMap<Did, Oid>

The latest revision that each delegate has accepted. Delegates can only accept one revision at a time.

Implementations

impl Identity

pub fn new(revision: Revision) -> Identity

pub fn initialize<'a, 'b, Repo, Signer>( doc: &Doc, store: &'a Repo, signer: &'b Signer, ) -> Result<IdentityMut<'a, 'b, Repo, Signer>, Error>

where Repo: WriteRepository + Store<Namespace = PublicKey>, Signer: Keypair<VerifyingKey = PublicKey> + Signer<Signature> + Signer<ExtendedSignature> + Verifier<Signature>,

pub fn get<Repo>(object: &ObjectId, repo: &Repo) -> Result<Identity, Error>

where Repo: ReadRepository + Store,

pub fn get_mut<'a, 'b, Repo, Signer>( id: &ObjectId, repo: &'a Repo, signer: &'b Signer, ) -> Result<IdentityMut<'a, 'b, Repo, Signer>, Error>

where Repo: WriteRepository + Store<Namespace = PublicKey>, Signer: Signer<Signature>,

Get a proposal mutably.

pub fn load<R>(repo: &R) -> Result<Identity, RepositoryError>

where R: ReadRepository + Store,

pub fn load_mut<'a, 'b, Repo, Signer>( repo: &'a Repo, signer: &'b Signer, ) -> Result<IdentityMut<'a, 'b, Repo, Signer>, RepositoryError>

where Repo: WriteRepository + Store<Namespace = PublicKey>, Signer: Signer<Signature>,

impl Identity

pub fn id(&self) -> RepoId

The repository identifier.

pub fn doc(&self) -> &Doc

The current document.

pub fn current(&self) -> &Revision

The current revision.

pub fn root(&self) -> &Revision

The initial revision of this identity.

pub fn head(&self) -> Oid

The head of the identity branch. This points to a commit that contains the current document blob.

pub fn revision(&self, revision: &Oid) -> Option<&Revision>

A specific Revision, that may be redacted.

pub fn revisions(&self) -> impl DoubleEndedIterator

All the Revisions that have not been redacted.

pub fn latest_by(&self, who: &Did) -> Option<&Revision>

Methods from Deref<Target = Revision>

pub fn signatures(&self) -> impl Iterator<Item = (&PublicKey, Signature)>

pub fn is_accepted(&self) -> bool

pub fn is_active(&self) -> bool

pub fn verdicts(&self) -> impl Iterator<Item = (&PublicKey, &Verdict)>

pub fn accepted(&self) -> impl Iterator<Item = Did>

pub fn rejected(&self) -> impl Iterator<Item = Did>

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

where G: Signer<Signature>,

Methods from Deref<Target = Doc>

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 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 Clone for Identity

fn clone(&self) -> Identity

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Cob for Identity

type Action = Action

The underlying action composing each operation.

type Error = ApplyError

Error returned by apply function.

fn from_root<R>( op: Op<Action>, repo: &R, ) -> Result<Identity, <Identity as Cob>::Error>

where R: ReadRepository,

Initialize a collaborative object from a root operation.

fn op<'a, R, I>( &mut self, op: Op<Action>, concurrent: I, repo: &R, ) -> Result<(), ApplyError>

where R: ReadRepository, I: IntoIterator<Item = &'a Entry<Oid, Oid, ExtendedSignature>>,

Apply an operation to the state.

impl CobWithType for Identity

fn type_name() -> &'static TypeName

The type name of the collaborative object type which backs this implementation.

impl Debug for Identity

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

Formats the value using the given formatter.

impl Deref for Identity

type Target = Revision

The resulting type after dereferencing.

fn deref(&self) -> &<Identity as Deref>::Target

Dereferences the value.

impl<R> Evaluate<R> for Identity

where R: ReadRepository,

type Error = Error

fn init( entry: &Entry<Oid, Oid, ExtendedSignature>, repo: &R, ) -> Result<Identity, <Identity as Evaluate<R>>::Error>

Initialize the object with the first (root) history entry.

fn apply<'a, I>( &mut self, entry: &Entry<Oid, Oid, ExtendedSignature>, concurrent: I, repo: &R, ) -> Result<(), <Identity as Evaluate<R>>::Error>

where I: Iterator<Item = (&'a Oid, &'a Entry<Oid, Oid, ExtendedSignature>)>,

Apply a history entry to the evaluated state.

impl PartialEq for Identity

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

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 Eq for Identity

impl StructuralPartialEq for Identity