Struct Body

pub struct Body(pub Vec<Structure>);

Represents an HCL config file body.

A Body consists of zero or more Attribute and Block HCL structures.

Tuple Fields

0: Vec<Structure>

Implementations

impl Body

pub fn into_inner(self) -> Vec<Structure>

Consumes self and returns the wrapped Vec<Structure>.

pub fn builder() -> BodyBuilder

Creates a new BodyBuilder to start building a new Body.

pub fn iter(&self) -> Iter<'_>

An iterator visiting all structures within the Body. The iterator element type is &'a Structure.

Examples

use hcl::{Attribute, Body};

let body = Body::from([
    Attribute::new("a", 1),
    Attribute::new("b", 2),
    Attribute::new("c", 3),
]);

for structure in body.iter() {
    println!("{structure:?}");
}

pub fn iter_mut(&mut self) -> IterMut<'_>

An iterator visiting all structures within the Body. The iterator element type is &'a mut Structure.

Examples

use hcl::{Attribute, Block, Body, Identifier, Structure};

let mut body = Body::from([
    Structure::Attribute(Attribute::new("a", 1)),
    Structure::Block(Block::new("b")),
    Structure::Attribute(Attribute::new("c", 3)),
]);

// Update all attribute keys and block identifiers
for structure in body.iter_mut() {
    match structure {
        Structure::Attribute(attr) => {
            attr.key = Identifier::new(format!("attr_{}", attr.key)).unwrap();
        }
        Structure::Block(block) => {
            block.identifier = Identifier::new(format!("block_{}", block.identifier)).unwrap();
        }
    }
}

assert_eq!(body.into_inner(), [
    Structure::Attribute(Attribute::new("attr_a", 1)),
    Structure::Block(Block::new("block_b")),
    Structure::Attribute(Attribute::new("attr_c", 3)),
]);

pub fn attributes(&self) -> Attributes<'_>

An iterator visiting all attributes within the Body. The iterator element type is &'a Attribute.

Examples

use hcl::{Attribute, Block, Body, Structure};

let body = Body::from([
    Structure::Attribute(Attribute::new("a", 1)),
    Structure::Block(Block::new("b")),
    Structure::Attribute(Attribute::new("c", 3)),
]);

let vec: Vec<&Attribute> = body.attributes().collect();
assert_eq!(vec, [&Attribute::new("a", 1), &Attribute::new("c", 3)]);

pub fn attributes_mut(&mut self) -> AttributesMut<'_>

An iterator visiting all attributes within the Body. The iterator element type is &'a mut Attribute.

Examples

use hcl::{Attribute, Block, Body, Identifier, Structure};

let mut body = Body::from([
    Structure::Attribute(Attribute::new("a", 1)),
    Structure::Block(Block::new("b")),
    Structure::Attribute(Attribute::new("c", 3)),
]);

// Update all attribute keys
for attr in body.attributes_mut() {
    attr.key = Identifier::new(format!("attr_{}", attr.key)).unwrap();
}

assert_eq!(body.into_inner(), [
    Structure::Attribute(Attribute::new("attr_a", 1)),
    Structure::Block(Block::new("b")),
    Structure::Attribute(Attribute::new("attr_c", 3)),
]);

pub fn into_attributes(self) -> IntoAttributes

Creates a consuming iterator visiting all attributes within the Body. The object cannot be used after calling this. The iterator element type is Attribute.

Examples

use hcl::{Attribute, Block, Body, Structure};

let body = Body::from([
    Structure::Attribute(Attribute::new("a", 1)),
    Structure::Block(Block::new("b")),
    Structure::Attribute(Attribute::new("c", 3)),
]);

let vec: Vec<Attribute> = body.into_attributes().collect();
assert_eq!(vec, [Attribute::new("a", 1), Attribute::new("c", 3)]);

pub fn blocks(&self) -> Blocks<'_>

An iterator visiting all blocks within the Body. The iterator element type is &'a Block.

Examples

use hcl::{Attribute, Block, Body, Structure};

let body = Body::from([
    Structure::Attribute(Attribute::new("a", 1)),
    Structure::Block(Block::new("b")),
    Structure::Attribute(Attribute::new("c", 3)),
]);

let vec: Vec<&Block> = body.blocks().collect();
assert_eq!(vec, [&Block::new("b")]);

pub fn blocks_mut(&mut self) -> BlocksMut<'_>

An iterator visiting all blocks within the Body. The iterator element type is &'a mut Block.

Examples

use hcl::{Attribute, Block, Body, Identifier, Structure};

let mut body = Body::from([
    Structure::Attribute(Attribute::new("a", 1)),
    Structure::Block(Block::new("b")),
    Structure::Attribute(Attribute::new("c", 3)),
]);

// Update all block identifiers
for block in body.blocks_mut() {
    block.identifier = Identifier::new(format!("block_{}", block.identifier)).unwrap();
}

assert_eq!(body.into_inner(), [
    Structure::Attribute(Attribute::new("a", 1)),
    Structure::Block(Block::new("block_b")),
    Structure::Attribute(Attribute::new("c", 3)),
]);

pub fn into_blocks(self) -> IntoBlocks

Creates a consuming iterator visiting all blocks within the Body. The object cannot be used after calling this. The iterator element type is Block.

Examples

use hcl::{Attribute, Block, Body, Structure};

let body = Body::from([
    Structure::Attribute(Attribute::new("a", 1)),
    Structure::Block(Block::new("b")),
    Structure::Attribute(Attribute::new("c", 3)),
]);

let vec: Vec<Block> = body.into_blocks().collect();
assert_eq!(vec, [Block::new("b")]);

Trait Implementations

impl Clone for Body

fn clone(&self) -> Body

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Body

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

Formats the value using the given formatter.

impl Default for Body

fn default() -> Body

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Body

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Evaluate for Body

type Output = Body

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.

fn evaluate_in_place(&mut self, ctx: &Context<'_>) -> EvalResult<(), Errors>

Recursively tries to evaluate all nested expressions in place.

impl<T> Extend<T> for Body

where T: Into<Structure>,

fn extend<I>(&mut self, iterable: I)

where I: IntoIterator<Item = T>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl Format for Body

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<T> From<&[T]> for Body

where T: Clone + Into<Structure>,

fn from(slice: &[T]) -> Self

Converts to this type from the input type.

impl<T> From<&mut [T]> for Body

where T: Clone + Into<Structure>,

fn from(slice: &mut [T]) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<[T; N]> for Body

where T: Into<Structure>,

fn from(arr: [T; N]) -> Self

Converts to this type from the input type.

impl From<Body> for Body

fn from(value: Body) -> Self

Converts to this type from the input type.

impl From<Body> for Body

fn from(value: Body) -> Self

Converts to this type from the input type.

impl<T> From<T> for Body

where T: Into<Structure>,

fn from(value: T) -> Body

Converts to this type from the input type.

impl<T> From<Vec<T>> for Body

where T: Into<Structure>,

fn from(vec: Vec<T>) -> Self

Converts to this type from the input type.

impl<T> FromIterator<T> for Body

where T: Into<Structure>,

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = T>,

Creates a value from an iterator.

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

type Deserializer = NewtypeStructDeserializer<Vec<Structure>>

The type of the deserializer being converted into.

fn into_deserializer(self) -> Self::Deserializer

Convert this value into a deserializer.

impl<'a> IntoIterator for &'a Body

type Item = &'a Structure

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a mut Body

type Item = &'a mut Structure

The type of the elements being iterated over.

type IntoIter = IterMut<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoIterator for Body

type Item = Structure

The type of the elements being iterated over.

type IntoIter = IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for Body

fn eq(&self, other: &Body) -> 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 Serialize for Body

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 Body

impl StructuralPartialEq for Body