Struct RailLayout 

pub struct RailLayout {
    pub v: u32,
    pub nodes: Vec<RailNode>,
}

The stored arrangement.

Fields

v: u32

nodes: Vec<RailNode>

Implementations

impl RailLayout

pub fn from_json(s: &str) -> Self

Tolerant parse, node by node: a malformed or future node is skipped rather than costing the whole arrangement. One bad entry must not wedge a rail the user can otherwise still use.

pub fn to_json(&self) -> String

pub fn is_editable(&self) -> bool

Whether this build may rewrite the document. A newer version can hold node types this one drops on parse, so editing would publish a lossy copy over the device that understands it.

pub fn flatten(&self) -> Vec<String>

Every community key in visual order, folders flattened in place.

pub fn contains(&self, key: &str) -> bool

pub fn normalize(&mut self)

One key appears once, a folder id appears once, and a folder holding a single community becomes that community again — a folder of one is a box with nothing to group, and dragging the second-to-last member out is how you say you are done with it.

pub fn merged_with(&self, live_keys: &[String]) -> RailLayout

The arrangement as it should paint: the stored one, plus any community the user has joined but never arranged, appended in the order the caller discovered them.

Nothing is written here. A user who has never dragged anything stores no document at all, and their rail still orders itself.

pub fn remove_key(&mut self, key: &str)

Drop a community from the arrangement for good.

Destructive on purpose, unlike the render-time skip: the layout keeps keys it cannot resolve forever, so without this a user who left a community and rejoined it later would find it back inside its old folder.

pub fn apply_drop( &mut self, source: &RailDrag, target: &RailDrop, new_folder_id: &str, ) -> Result<(), String>

Apply a completed drag. new_folder_id supplies the id for a folder born from a combine drop, taken as a parameter so the whole thing stays pure and testable.

pub fn rename_folder( &mut self, folder_id: &str, name: &str, ) -> Result<(), String>

Name a folder. An empty name is allowed and means “unnamed” — the rail shows the avatars alone, exactly as it does before anyone names one.

pub fn set_folder_hue( &mut self, folder_id: &str, hue: Option<u16>, ) -> Result<(), String>

Colour a folder, or clear it back to the default grey with None.

pub fn dissolve_folder(&mut self, folder_id: &str) -> Result<(), String>

Unpack a folder, leaving its communities loose and in place.

pub fn assign_folder_ids(&mut self, next_id: impl FnMut() -> String)

Give every folder born without one a stable id. Ids are minted by the caller so the pure ops stay free of randomness.

Trait Implementations

impl Clone for RailLayout

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RailLayout

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

Formats the value using the given formatter.

impl Default for RailLayout

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RailLayout

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for RailLayout

impl PartialEq for RailLayout

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for RailLayout

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 RailLayout