Struct Target 

pub struct Target {
    pub name: String,
    /* private fields */
}

A writer’s declaration of what it accepts.

Fields

name: String

Implementations

impl Target

pub fn new(name: impl Into<String>) -> Self

pub fn rule(self, name: &str, legality: Legality) -> Self

pub fn legal(self, name: &str) -> Self

pub fn illegal(self, name: &str) -> Self

pub fn dynamic( self, name: &str, check: impl Fn(&World, Entity) -> bool + Send + Sync + 'static, ) -> Self

pub fn covered( self, name: &str, what: &str, check: fn(&World, Entity) -> bool, ) -> Self

A name the writer writes through another component: legal on the entities check accepts, what naming the cover ("covered by <dialect>.light"); the rest are reported as <name> not <what> (Legality::Covered).

pub fn dynamic_typed<T: Component>( self, check: impl Fn(&T) -> bool + Send + Sync + 'static, ) -> Self

The legal checks of a typed component: legal when check accepts the value.

pub fn check<T: Component>( self, what: &str, check: impl Fn(&T) -> bool + Send + Sync + 'static, ) -> Self

A named value rule on a typed component: as Target::dynamic_typed, with what naming the rule in errors (“every placement regular”).

pub fn check_resource<R: Resource>( self, what: &str, check: impl Fn(&R) -> bool + Send + Sync + 'static, ) -> Self

A named value rule on a resource: the target refuses the world while the resource is there and check refuses it ("every surface classified"). A pass of the stated pipeline that modifies or removes the resource fixes it.

pub fn rule_words(&self, name: &str) -> Option<&str>

The words naming the value rule on name (a component’s Target::check, a covered name’s cover (Target::covered) or a resource’s Target::check_resource), if it has a named one.

pub fn refused_resources(&self, w: &World) -> Vec<&str>

The resources of w whose value rule refuses them, by name.

pub fn legality(&self, name: &str) -> Option<&Legality>

pub fn rules(&self) -> Vec<(&str, Rule)>

Every name the target states a rule for, with the rule’s kind (its checks left out): what a coverage report lists of the writer.

pub fn checked_resources(&self) -> Vec<&str>

The resources it checks the values of (Target::check_resource), by name.

pub fn check_prepared(&self, w: &World) -> Prepared

Check a prepared world against the target without changing it: what the writer won’t write (an illegal or an unlisted name, and a covered name’s uncovered entities: Prepared::unsupported, entity counts by name; a resource it neither lists nor rules on: Prepared::unsupported_resources; the conversion’s own resources, crate::convert::OPERATIONAL_RESOURCES, aside), and values of names it writes that its value rule refuses (Prepared::invalid, by name with the rule’s words) or resources it refuses (Prepared::invalid_resources). A resource is listed like a component (Target::legal, Target::illegal).

pub fn illegal_entities(&self, w: &World, name: &str, mode: Mode) -> Vec<Entity>

Entities whose name component the target does not accept as it is (all of them for an illegal name).

Trait Implementations

impl Clone for Target

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 Target

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

Formats the value using the given formatter.