Struct Build

pub struct Build<'a> {
    pub outputs: Vec<Value<'a>>,
    pub implicit_outputs: Vec<Value<'a>>,
    pub rule: Identifier<'a>,
    pub inputs: Vec<Value<'a>>,
    pub implicit_inputs: Vec<Value<'a>>,
    pub order_only_inputs: Vec<Value<'a>>,
    pub bindings: Vec<Binding<'a>>,
}

Build instruction.

The build instructions describe commands that have to be executed in order to produce the outputs. They are called “edges” in ninja jargon while the inputs and outputs are called “nodes”.

Example:

build foo.o : c foo.c || generated_header.h
  cflags = -DHAVE_BAR=1

Fields

outputs: Vec<Value<'a>>

Outputs.

This is what the build instruction produces. There can be many outputs but having at least one is mandatory. These are populated into the implicit $out variable by ninja.

implicit_outputs: Vec<Value<'a>>

Implicit outputs.

Also produced by the build instruction. The difference to the outputs is that they are optional and are not populated into the $out variable by ninja.

rule: Identifier<'a>

Rule name.

The name of the rule that is used to generate the command to execute to generate an output.

inputs: Vec<Value<'a>>

Inputs.

These are used to produce the outputs. During rebuilding when any of these are considered out-of-date the outputs will have to rebuild. They are populated into the $in variable by ninja.

implicit_inputs: Vec<Value<'a>>

Implicit inputs.

Similar to inputs but not populated into the $in variable by ninja.

order_only_inputs: Vec<Value<'a>>

Order-only inputs.

These are inputs that have to exist for this build instruction to run. They are not checked for being up-to-date when rebuilding.

bindings: Vec<Binding<'a>>

Variable assignments.

These can be used to customize the commands set forth by the rule.

Trait Implementations

impl<'a> Clone for Build<'a>

fn clone(&self) -> Build<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Build<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Build<'a>

fn eq(&self, other: &Build<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for Build<'a>

impl<'a> StructuralPartialEq for Build<'a>