Struct SelectOutfit 

pub struct SelectOutfit {
    pub choices: BTreeMap<String, String>,
}

select-outfit{choices=key:value;key:value} (required): resolves the named axes only, to the named values (by name or index), and leaves every other global axis unresolved, with the conditions and primitive conditions that depend on it reduced as ResolveState reduces them. It is what a recipe of chosen ids replays: a program (a website) picks some outfits and accessories from a catalog and the rest stays open. Everything else is as for resolve-state, whose report it gives (the members and primitives dropped, counted per axis and value), with the differences that a key naming no axis is an error naming the axes there are, and that an axis scoped to an entity and not named resolves by its default (an error when it has none) as it cannot stay.

Fields

choices: BTreeMap<String, String>

key -> value text, as given; never empty.

Trait Implementations

impl Clone for SelectOutfit

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 SelectOutfit

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

Formats the value using the given formatter.

impl Eq for SelectOutfit

impl PartialEq for SelectOutfit

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

Equality operator ==.

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

Inequality operator !=.

impl Pass for SelectOutfit

fn name(&self) -> &'static str

Stable name, used in pipelines and reports (load-meshes).

fn options(&self) -> Options

The options this instance was made with (printed into the pipeline).

fn requires(&self) -> &[&'static str]

Names that must be present before it runs.

fn removes(&self) -> &[&'static str]

Names it may take away (what it lowers).

fn modifies(&self) -> &[&'static str]

Names whose values it edits in place, and resources it writes (replaced, also by removing and inserting again, or borrowed with World::resource_mut). The pass manager checks the resources; an in-place edit of a component’s value on an entity that keeps it (get_mut, or World::insert over the value) is declared here and not checked: seeing it would take a controlled editing interface, later work. What the gap costs: a pass that edits a value in place without declaring it here is never named, in any build, and its edit can make what the declarations say about that name wrong (Pipeline::unfed, Pipeline::check); one that leaves an invalid value there is named at the pass in a build with the pass checks, and in a release build without them only by the verifier that runs before the writer, which names the entity but not the pass. Adding a name to an entity, taking one away and despawning are checked entity by entity against Pass::provides, Pass::removes and Pass::despawns_entities.

fn despawns_entities(&self) -> bool

Whether it despawns entities. If so, a component name it does not declare in Pass::removes may disappear when every entity that held the name before the pass was despawned by it (a dropped placement’s core.name, a discarded form’s dialect data); a name still held by a surviving entity before the pass must be declared as ever. Added names are checked as for every pass.

fn run(&self, w: &mut World, log: &mut PassLog) -> Result<(), String>

fn may_lack_inputs(&self) -> bool

Whether a run may skip it in a world (or a part) that holds none of its required names: a lowering whose input the world may simply not have (a part of only a light has no materials, a read region no lights) opts in; the step is recorded as skipped (StepReport::skipped). Required names are prerequisites, so this is false unless the pass says otherwise: an absent name may be a failed load or a wrong order, and a pass that summarizes, decides or plans never opts in.

fn settings(&self) -> &[Setting]

The run settings it reads, which the program states for the run on its manager (its thread count, crate::parallel::THREADS, PassManager::with_settings): checked with Pass::requires before it runs and refused where absent, never counted in whether it is skipped (Pass::may_lack_inputs), and stated in its step’s report.

fn provides(&self) -> &[&'static str]

Names it may add.

fn approximates(&self) -> &'static str

What it approximates, in words (empty when it is exact).

fn removes_by_log(&self) -> bool

Whether the components it removes are not all known in advance (a hook decides, as crate::Component::apply_linear does). If so, a component name that disappears is accepted when the pass recorded it in PassLog::removed as well as when it is declared in Pass::removes; a name that disappears unrecorded and undeclared is an error as ever, and a resource it removes must be declared as for any pass.

fn settles(&self) -> &[&'static str]

Names whose values it brings to their final form (a classifier: every surface classified). A later pass in a pipeline that provides one of them adds values that never went through this pass: unless a pass after it settles the name again, PassManager::run refuses such a pipeline before it runs (Error::SettledThenChanged). Modifying settled values later is allowed. A modifier must not add values without declaring them in Pass::provides; the target’s value rules check the result.

impl StructuralPartialEq for SelectOutfit