Struct Progress 

pub struct Progress {
    pub device_id: String,
    pub device: String,
    pub percentage: f32,
    pub progress: String,
    pub timestamp: u64,
}

Reading progress information for a document.

This struct contains all the information about a user’s reading progress in a specific document, including device information and the current position.

Example

use korrosync::model::Progress;

let progress = Progress {
    device_id: "device-123".to_string(),
    device: "Kindle Paperwhite".to_string(),
    percentage: 67.5,
    progress: "Page 135 of 200".to_string(),
    timestamp: 1609459200000,
};

Fields

device_id: String

Unique identifier for the device reporting progress

device: String

Human-readable device name

percentage: f32

Reading progress as a percentage

progress: String

Textual representation of progress

timestamp: u64

Unix timestamp in milliseconds when progress was last updated

Trait Implementations

impl Archive for Progress

where String: Archive, f32: Archive, u64: Archive,

const COPY_OPTIMIZATION: CopyOptimization<Self>

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

type Archived = ArchivedProgress

The archived representation of this type.

type Resolver = ProgressResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for Progress

fn clone(&self) -> Progress

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Progress

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

Formats the value using the given formatter.

impl Default for Progress

fn default() -> Progress

Returns the “default value” for a type.

impl<__D: Fallible + ?Sized> Deserialize<Progress, __D> for Archived<Progress>

where String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, f32: Archive, <f32 as Archive>::Archived: Deserialize<f32, __D>, u64: Archive, <u64 as Archive>::Archived: Deserialize<u64, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Progress, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl<__S: Fallible + ?Sized> Serialize<__S> for Progress

where String: Serialize<__S>, f32: Serialize<__S>, u64: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.