Struct hcl::Block

pub struct Block {
    pub identifier: Identifier,
    pub labels: Vec<BlockLabel>,
    pub body: Body,
}

Represents an HCL block which consists of a block identifier, zero or more block labels and a block body.

In HCL syntax this is represented as:

block_identifier "block_label1" "block_label2" {
  body
}

Fields

identifier: Identifier

The block identifier.

labels: Vec<BlockLabel>

Zero or more block labels.

body: Body

Represents the Block’s body.

Implementations

impl Block

pub fn new<I>(ident: I) -> Blockwhere
    I: Into<Identifier>,

Creates a new empty Block.

pub fn builder<I>(identifier: I) -> BlockBuilderwhere
    I: Into<Identifier>,

Creates a new BlockBuilder to start building a new Block with the provided identifier.

pub fn identifier(&self) -> &str

Returns a reference to the block’s identifier.

pub fn labels(&self) -> &[BlockLabel]

Returns a reference to the block’s labels.

pub fn body(&self) -> &Body

Returns a reference to the block’s body.

Trait Implementations

impl Clone for Block

fn clone(&self) -> Block

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Block

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Block

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Evaluate for Block

type Output = Block

The type that is returned by evaluate on success.

fn evaluate(&self, ctx: &Context<'_>) -> EvalResult<Self::Output>

Recursively evaluates all HCL templates and expressions in the implementing type using the variables and functions declared in the Context.

impl Format for Block

fn format<W>(&self, fmt: &mut Formatter<'_, W>) -> Result<()>where
    W: Write,

Formats a HCL structure using a formatter and writes the result to the provided writer.

fn format_vec<W>(&self, fmt: &mut Formatter<'_, W>) -> Result<Vec<u8>>where
    W: Write + AsMut<Vec<u8>>,

Formats a HCL structure using a formatter and returns the result as a Vec<u8>.

fn format_string<W>(&self, fmt: &mut Formatter<'_, W>) -> Result<String>where
    W: Write + AsMut<Vec<u8>>,

Formats a HCL structure using a formatter and returns the result as a String.

impl<I, B> From<(I, B)> for Blockwhere
    I: Into<Identifier>,
    B: IntoIterator,
    B::Item: Into<Structure>,

fn from((ident, body): (I, B)) -> Block

Converts to this type from the input type.

impl<I, L, B> From<(I, L, B)> for Blockwhere
    I: Into<Identifier>,
    L: IntoIterator,
    L::Item: Into<BlockLabel>,
    B: IntoIterator,
    B::Item: Into<Structure>,

fn from((ident, labels, body): (I, L, B)) -> Block

Converts to this type from the input type.

impl From<Block> for Structure

fn from(block: Block) -> Structure

Converts to this type from the input type.

impl<'de> IntoDeserializer<'de, Error> for Block

type Deserializer = MapAccessDeserializer<BlockAccess>

The type of the deserializer being converted into.

fn into_deserializer(self) -> Self::Deserializer

Convert this value into a deserializer.

impl PartialEq<Block> for Block

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Block

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where
    S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Block

impl StructuralEq for Block

impl StructuralPartialEq for Block