Enum Instruction

#[non_exhaustive]
pub enum Instruction<'a> {
    Add(AddInstruction<'a>),
    Arg(ArgInstruction<'a>),
    Cmd(CmdInstruction<'a>),
    Copy(CopyInstruction<'a>),
    Entrypoint(EntrypointInstruction<'a>),
    Env(EnvInstruction<'a>),
    Expose(ExposeInstruction<'a>),
    From(FromInstruction<'a>),
    Healthcheck(HealthcheckInstruction<'a>),
    Label(LabelInstruction<'a>),
    Maintainer(MaintainerInstruction<'a>),
    Onbuild(OnbuildInstruction<'a>),
    Run(RunInstruction<'a>),
    Shell(ShellInstruction<'a>),
    Stopsignal(StopsignalInstruction<'a>),
    User(UserInstruction<'a>),
    Volume(VolumeInstruction<'a>),
    Workdir(WorkdirInstruction<'a>),
}

An instruction.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Add(AddInstruction<'a>)

ADD instruction.

Arg(ArgInstruction<'a>)

ARG instruction.

Cmd(CmdInstruction<'a>)

CMD instruction.

Copy(CopyInstruction<'a>)

COPY instruction.

Entrypoint(EntrypointInstruction<'a>)

ENTRYPOINT instruction.

Env(EnvInstruction<'a>)

ENV instruction.

Expose(ExposeInstruction<'a>)

EXPOSE instruction.

From(FromInstruction<'a>)

FROM instruction.

Healthcheck(HealthcheckInstruction<'a>)

HEALTHCHECK instruction.

Label(LabelInstruction<'a>)

LABEL instruction.

Maintainer(MaintainerInstruction<'a>)

MAINTAINER instruction (deprecated).

Onbuild(OnbuildInstruction<'a>)

ONBUILD instruction.

Run(RunInstruction<'a>)

RUN instruction.

Shell(ShellInstruction<'a>)

SHELL instruction.

Stopsignal(StopsignalInstruction<'a>)

STOPSIGNAL instruction.

User(UserInstruction<'a>)

USER instruction.

Volume(VolumeInstruction<'a>)

VOLUME instruction.

Workdir(WorkdirInstruction<'a>)

WORKDIR instruction.

Trait Implementations

impl<'a> Debug for Instruction<'a>

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

Formats the value using the given formatter.

impl<'a> Serialize for Instruction<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.