Struct Lineups 

pub struct Lineups {
    pub editor: Option<Editor>,
    pub chosen: Option<String>,
}

The lineups dialog, while it is open.

Fields

editor: Option<Editor>

The lineup being written, or nothing while the list of them stands in its place.

chosen: Option<String>

The lineup the person is looking at, named rather than numbered: a lineup saved or deleted under the person must not move the list out from under their hand.

Implementations

impl Lineups

pub fn new() -> Self

The dialog as it opens: the list, with nothing chosen and nothing being written.

pub fn editing(&self, name: &str) -> bool

Whether a lineup called name is the one being written, which is what decides whether the name is free.

pub fn filter(&self) -> &str

What has been written above the list of the provider’s models.

pub fn steps(&self) -> &[String]

The steps of the lineup being written, in the order they are tried.

pub fn step(&self) -> usize

The step the person is looking at, while a lineup is being written.

pub fn refusal(&self) -> Option<&Refusal>

What stopped the lineup being saved last time, as the view turns it into words.

pub fn shown<'a>(&self, entry: &'a ProviderEntry) -> Vec<&'a Model>

The provider’s models the filter keeps, in the provider’s own order.

A service such as OpenRouter offers hundreds of models and a dialog holds a handful, so the list shows what is asked for. What the filter hides is not thrown away: a step already in the lineup stays in it, and the line under the name says so.

pub fn paid<'a>(&self, entry: &'a ProviderEntry) -> Vec<&'a str>

The steps that cost money, said as Lineup::paid would say it for a saved one: the person hears it while they are choosing the order rather than from a bill afterwards. There is no lineup yet to ask, so the steps are read off the editor.

pub fn open(&mut self, entry: &ProviderEntry)

The first lineup of entry, so that Edit and Delete act on something the moment the dialog opens rather than waiting for a row to be pointed at.

pub fn kept(&mut self, names: &[String])

Puts the choice on a lineup that is still there after the one under the hand is gone, and on the first of what is left when the one under the hand is the one that went. The names are the list as it is now, read after the deletion rather than before it.

pub fn choose(&mut self, name: &str)

The lineup called name is the one the person is looking at.

pub fn new_lineup(&mut self)

Starts a lineup that is not there yet. Nothing of another is carried into it: its steps are its own.

pub fn edit(&mut self, lineup: &Lineup)

Starts the lineup lineup for changing, with its own name and steps in the fields.

pub fn name(&mut self, text: String)

The name as it has been typed. A form does not complain about a field nobody has finished, so what was said before is taken back as soon as it is written in.

pub fn filter_for(&mut self, text: String)

What has been written above the list of the provider’s models.

pub fn look_at(&mut self, id: &str)

The model the person is looking at in the list of the provider’s models.

pub fn add(&mut self, id: &str)

Puts the model id at the end of the lineup.

The same model twice would send the same request to it twice and fall back to it twice, so a step already in the lineup is not put in again: the list of steps, right under the one that was pressed, is where that is visible.

pub fn pick_step(&mut self, index: usize)

The step the person is looking at in the lineup.

pub fn up(&mut self)

Moves the chosen step one place earlier. The first step has nowhere earlier to go, and a request that failed on it is what the order is for.

pub fn down(&mut self)

Moves the chosen step one place later. The last step has nowhere later to go.

pub fn remove(&mut self)

Takes the chosen step out of the lineup.

pub fn build(&self, taken: impl Fn(&str) -> bool) -> Result<Lineup, Refusal>

The lineup the editor describes, or the first reason it is not one.

taken says whether a lineup of this name is already there, which only the file knows.

Errors

Refusal says what stopped it, in the words the view shows beside the name field.

pub fn saved(&mut self, name: &str)

Puts the saved lineup back on the list and leaves the editor, which is what a save means everywhere else on this page: what was asked to be kept is now what is shown.

pub fn cancelled(&mut self)

Leaves the lineup being written, keeping nothing of it. A lineup reaches the file when it is saved, so one left half-made is not left behind in the file either.

Trait Implementations

impl Clone for Lineups

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 Lineups

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

Formats the value using the given formatter.

impl Default for Lineups

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Lineups

impl PartialEq for Lineups

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Lineups