Struct Swap 

pub struct Swap {
    pub swap_record: Option<Option<String>>,
    pub swap_commit: Option<String>,
}

The compare-and-swap fields, as they arrive on the wire.

Both are CIDs naming a version to swap against, and both are now evaluated. Swap::resolve turns them into the preconditions the store and the registry check; a CID that does not decode is refused there, before anything is read, because it is a statement about the request rather than about the repository.

Fields

swap_record: Option<Option<String>>

Swap against the previous version of this record.

Nullable in the lexicon, so it is read as a double option: null asserts the record does not exist, and absent asserts nothing.

swap_commit: Option<String>

Swap against the repository’s current commit.

Implementations

impl Swap

pub fn resolve(&self) -> Result<Swap, ApiError>

The preconditions these fields ask for.

swapRecord: null is Precondition::Absent – the lexicon marks the field nullable and null asserts the record does not exist yet – and a CID is Precondition::Version. An absent field asserts nothing, which is what leaving it out means.

pub fn resolve_commit_only(&self, route: &str) -> Result<Swap, ApiError>

The same, for a route whose lexicon declares only swapCommit.

createRecord and applyWrites have no swapRecord field. A body carrying one is refused rather than ignored: a client that sent it believes its write is conditional, and neither route has one key to make it conditional on – applyWrites writes many records, and createRecord is already conditional on the key being free.

Trait Implementations

impl Clone for Swap

fn clone(&self) -> Swap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Swap

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

Formats the value using the given formatter.

impl Default for Swap

fn default() -> Swap

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Swap

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Swap

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Swap

impl StructuralPartialEq for Swap