Struct State 

pub struct State {

    pub on: Option<bool>,
    pub given: String,
    pub asked: i64,
    pub send: Option<bool>,
    pub folder: String,
    pub account: String,
    pub url: String,
    pub confirmed: i64,
    pub sealed: i64,
    pub looked: i64,
    pub last: i64,
    pub tried: i64,
    pub said: String,
    pub left: BTreeMap<String, u64>,
    pub own_entry: Option<(u64, i64)>,
    pub mode: String,
    pub place: String,
    pub pushed: i64,
    pub files: BTreeMap<String, Fetched>,
    pub folders: BTreeMap<String, Looked>,
    pub sent: BTreeMap<String, Sent>,
}

What the backup knows, kept privately beside the sharing’s memory (remote.toml), never shared. on, given and asked are yours, written only through State::choose; the rest is the backup’s.

Fields

on: Option<bool>

Switched on or off here; unsaid, on.

given: String

The folder’s place on the server, given by hand: a path in an account’s files (“Documents/Sioul”), or an address; “” to look by itself.

asked: i64

When you asked to look again (Unix seconds).

send: Option<bool>

This device’s own files sent there too, beside the sync app (send): as switched here, else on wherever the backup is.

folder: String

The sharing folder here it backs.

account: String

The account whose server holds it, by its id, and the folder there (an address ending with “/”).

url: String

confirmed: i64

Since when the server’s seal is found to be this folder’s (Unix seconds); 0: not confirmed.

sealed: i64

When the server’s seal was last read and found the same (Unix seconds).

looked: i64

When the folder was last looked for (Unix seconds).

last: i64

When a pull last went through, and was last tried (Unix seconds).

tried: i64

said: String

Why nothing is fetched, or the last pull failed, in a code (“not-found:murena.io”, “network:murena.io”); “” when all is well.

left: BTreeMap<String, u64>

The other devices’ records on the server past what a pull brings (LARGEST), longer there than here, by name, as the last look through the folder found them: only the sync app brings them, and the pull alone is not trusted meanwhile (pulls_well).

own_entry: Option<(u64, i64)>

This device’s entry on the server (devices/<id>.device) as a pull last listed it: its size, and when (Unix seconds). Of another size than this device last sent, listed after that send, it is an older copy put back there: looked at again by the next send, and sent over it (send).

mode: String

MIRROR when Sioul keeps the folder in step itself, no sync app: the folder here is its own copy (mirror_of), the server’s is the one the devices share; “” beside a sync app’s folder.

place: String

The folder’s place in the account’s files, as given (“Documents/Sioul”): to say where.

pushed: i64

When this device’s own files last went up (MIRROR, Unix seconds).

files: BTreeMap<String, Fetched>

The server’s files as last fetched, or found here already, by their path in the folder.

folders: BTreeMap<String, Looked>

The server’s folders as last looked through, by their path (“” the folder itself, “devices/”).

sent: BTreeMap<String, Sent>

This device’s own files as they last went up (MIRROR), by their path in the folder.

Implementations

impl State

pub fn load(memory: &Path) -> State

fn write(&self, memory: &Path) -> Result<(), String>

fn save(&self, memory: &Path) -> Result<(), String>

Written as the backup’s work left it, under its lock: what you chose meanwhile (on, given, asked) kept as the file has it.

fn save_pulled( &self, memory: &Path, ended: i64, loaded_left: &BTreeMap<String, u64>, ) -> Result<(), String>

What a pull found, written over the state as it is now, under its lock: two processes pull (the window’s or an alarm’s, and the background step’s), and neither undoes the other. The pull begun later says when a pull was tried and how it went; the latest that went through is kept; what was fetched and looked through, each file’s and folder’s latest; what is left to the sync app (left): as it is now, with what this pull found left added (new, or at another size) and what it found brought taken out, from what it knew when it began (loaded_left): another pull’s finding meanwhile is never erased, only a look that finds it brought clears it; the rest (your choices, the place) as it is now. A place changed meanwhile (found elsewhere): what this pull found is not that place’s, left out. ended: this pull’s last moment by the clock it began by (Unix seconds); one said begun after that began after this pull ended, which no pull of the other process can: the clock was set back since, and this pull is the later.

pub fn choose( memory: &Path, change: impl FnOnce(&mut State), ) -> Result<State, String>

What you choose (the switch, the place given by hand), changed under its lock.

pub fn confirmed_for(&self, folder: &Path) -> bool

Its server’s seal was found to be this folder’s.

pub fn fetching(&self) -> bool

Fetching: as switched here, else on.

pub fn pulls_well(&self, folder: &Path) -> bool

Pulling from the server works for folder beside a sync app: switched on, the folder confirmed there, a pull gone through and the last one too (said empty). A phone’s background step then reads the other devices’ news from its pull alone, the sync app neither asked to look nor waited for (docs/android.md, “In the background”); otherwise, as before: the sync app asked, and given twenty seconds.

pub fn went_through_since(&self, folder: &Path, since: i64, now: i64) -> bool

A pull begun at or after since and not after now (Unix seconds) went through, with nothing left on the server that only the sync app brings: what a dose’s or a waking’s alarm trusts alone (alarm_news). A pull said begun after now is one from before the clock was set back: not since, pulled again.

pub fn sending(&self) -> bool

Sending this device’s own files there too (send): with the backup on, as switched here, else on.

pub fn host(&self) -> String

The server, by its name: “murena.io”.

pub fn look_due(&self, folder: &Path, now: i64) -> bool

Whether to look for the folder now: asked to (a place given by hand, the switch turned on), another folder shared here, or not confirmed and never looked for, or looked for LOOK_AGAIN ago.

Trait Implementations

impl Clone for State

fn clone(&self) -> State

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for State

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

Formats the value using the given formatter.

impl Default for State

fn default() -> State

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for State

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for State

impl PartialEq for State

fn eq(&self, other: &State) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for State

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for State