Struct KvSetRequest 

pub struct KvSetRequest { /* private fields */ }

Fluent builder for Kv::set. Supply a value with one of .bytes (raw), .json / .msgpack (built-in codecs), or .encode_with::<C> (any codec - Avro, Protobuf, CBOR, Arrow, your own), optionally an expiry, then .send().await. Values are stored as opaque bytes, and the codec is the caller’s choice.

Implementations

impl KvSetRequest

pub fn bytes(self, payload: impl AsRef<[u8]>) -> Self

Store raw bytes as the value (anything byte-like: Vec<u8>, &[u8], &str, …). Use this for an already-encoded body (Avro / Protobuf / Arrow / your own framing).

pub fn encode_with<C, T>(self, value: &T) -> Result<Self, LaserError>

where C: Codec<T>, T: ?Sized,

Encode value with any Codec and store the bytes. The generic path: .json and .msgpack are one-line sugar over it.

pub fn json<T: Serialize + ?Sized>(self, value: &T) -> Result<Self, LaserError>

JSON-encode value and store the bytes. Sugar for .encode_with::<Json, _>.

pub fn msgpack<T: Serialize + ?Sized>( self, value: &T, ) -> Result<Self, LaserError>

MessagePack-encode value and store the bytes. Sugar for .encode_with::<Msgpack, _>, more compact than JSON for binary state.

pub fn ttl(self, ttl: Duration) -> Self

Expire the entry ttl from now. Overrides any prior expires_at.

pub fn expires_at(self, epoch_micros: u64) -> Self

Expire the entry at an absolute epoch-microseconds timestamp.

pub fn expect_version(self, version: u64) -> Self

Make this a compare-and-swap that applies only if the key currently holds version (the KvEntry::version from a prior read). Finish with commit. Lock-free optimistic concurrency: read the version, compute the new value, commit, and retry on a conflict.

let entry = kv.get_entry("counter").await?.expect("seeded");
let prev: u64 = String::from_utf8_lossy(&entry.value).parse().unwrap_or(0);
let next = kv.set("counter").json(&(prev + 1))?.expect_version(entry.version).commit().await?;

pub fn expect_absent(self) -> Self

Make this a compare-and-swap that applies only if the key does not yet exist (a create-if-absent). Finish with commit. A racing writer that got there first surfaces as a conflict.

pub async fn commit(self) -> Result<u64, LaserError>

Apply a compare-and-swap write set up by expect_version or expect_absent, returning the entry’s new version. The precondition miss is a typed KvError::VersionConflict carrying the current version, so the caller can re-read and retry. Returns LaserError::Invalid if no precondition was set (use send for an unconditional write), and LaserError::Unsupported when the deployment does not advertise the kv_cas capability.

pub async fn send(self) -> Result<(), LaserError>

Apply the unconditional write. Returns LaserError::Invalid when a precondition was set with expect_version or expect_absent: finish those with commit, so a precondition is never dropped.