Struct RleBuilder

pub struct RleBuilder<Name = RleBuilderNoName, Created = RleBuilderNoCreated, Comment = RleBuilderNoComment, Rule = RleBuilderNoRule>
where
    Name: RleBuilderName,
    Created: RleBuilderCreated,
    Comment: RleBuilderComment,
    Rule: RleBuilderRule,
{ /* private fields */ }

A builder of Rle.

Examples

Creates a builder via collect() with live cell positions, set a name via name(), then builds Rle via build():

use life_backend::format::RleBuilder;
use life_backend::Position;
let pattern = [Position(1, 0), Position(2, 0), Position(0, 1), Position(1, 1), Position(1, 2)];
let target = pattern.iter().collect::<RleBuilder>().name("R-pentomino").build()?;
let expected = "\
    #N R-pentomino\n\
    x = 3, y = 3, rule = B3/S23\n\
    b2o$2o$bo!\n\
";
assert_eq!(format!("{target}"), expected);

Creates an empty builder via new(), set a name via name(), injects live cell positions via extend(), then builds Rle via build():

use life_backend::format::RleBuilder;
use life_backend::Position;
let pattern = [Position(1, 0), Position(2, 0), Position(0, 1), Position(1, 1), Position(1, 2)];
let mut builder = RleBuilder::new().name("R-pentomino");
builder.extend(pattern.iter());
let target = builder.build()?;
let expected = "\
    #N R-pentomino\n\
    x = 3, y = 3, rule = B3/S23\n\
    b2o$2o$bo!\n\
";
assert_eq!(format!("{target}"), expected);

Implementations

impl RleBuilder<RleBuilderNoName, RleBuilderNoCreated, RleBuilderNoComment, RleBuilderNoRule>

pub fn new() -> Self

Creates a builder that contains no live cells.

Examples

use life_backend::format::RleBuilder;
let builder = RleBuilder::new();

impl<Name, Created, Comment, RuleSpec> RleBuilder<Name, Created, Comment, RuleSpec>

where Name: RleBuilderName, Created: RleBuilderCreated, Comment: RleBuilderComment, RuleSpec: RleBuilderRule,

pub fn build(self) -> Result<Rle>

Builds the Rle value.

Examples

use life_backend::format::RleBuilder;
use life_backend::Position;
let pattern = [Position(1, 0), Position(0, 1)];
let builder: RleBuilder = pattern.iter().collect();
let target = builder.build()?;

impl<Created, Comment, Rule> RleBuilder<RleBuilderNoName, Created, Comment, Rule>

where Created: RleBuilderCreated, Comment: RleBuilderComment, Rule: RleBuilderRule,

pub fn name( self, str: &str, ) -> RleBuilder<RleBuilderWithName, Created, Comment, Rule>

Set the name.

Examples

use life_backend::format::RleBuilder;
use life_backend::Position;
let pattern = [Position(1, 0), Position(0, 1)];
let target = pattern
    .iter()
    .collect::<RleBuilder>()
    .name("foo")
    .build()?;
assert_eq!(target.comments().len(), 1);
assert_eq!(target.comments()[0], "#N foo".to_string());

Errors

Code that calls name() twice or more will fail at compile time. For example:

use life_backend::format::RleBuilder;
use life_backend::Position;
let pattern = [Position(1, 0), Position(0, 1)];
let target = pattern
    .iter()
    .collect::<RleBuilder>()
    .name("foo")
    .name("bar") // Compile error
    .build()?;

build() returns an error if the string passed by name() includes multiple lines. For example:

use life_backend::format::RleBuilder;
use life_backend::Position;
let pattern = [Position(1, 0), Position(0, 1)];
let target = pattern
    .iter()
    .collect::<RleBuilder>()
    .name("foo\nbar")
    .build()?; // Should fail

impl<Name, Comment, Rule> RleBuilder<Name, RleBuilderNoCreated, Comment, Rule>

where Name: RleBuilderName, Comment: RleBuilderComment, Rule: RleBuilderRule,

pub fn created( self, str: &str, ) -> RleBuilder<Name, RleBuilderWithCreated, Comment, Rule>

Set the information when and by whom the pattern was created. If the argument includes newlines, the instance of Rle built by build() includes multiple comment lines.

Examples

use life_backend::format::RleBuilder;
use life_backend::Position;
let pattern = [Position(1, 0), Position(0, 1)];
let target = pattern
    .iter()
    .collect::<RleBuilder>()
    .created("foo")
    .build()?;
assert_eq!(target.comments().len(), 1);
assert_eq!(target.comments()[0], "#O foo".to_string());

Errors

Code that calls created() twice or more will fail at compile time. For example:

use life_backend::format::RleBuilder;
use life_backend::Position;
let pattern = [Position(1, 0), Position(0, 1)];
let target = pattern
    .iter()
    .collect::<RleBuilder>()
    .created("foo")
    .created("bar") // Compile error
    .build()?;

impl<Name, Created, Rule> RleBuilder<Name, Created, RleBuilderNoComment, Rule>

where Name: RleBuilderName, Created: RleBuilderCreated, Rule: RleBuilderRule,

pub fn comment( self, str: &str, ) -> RleBuilder<Name, Created, RleBuilderWithComment, Rule>

Set the comment. If the argument includes newlines, the instance of Rle built by build() includes multiple comment lines.

Examples

use life_backend::format::RleBuilder;
use life_backend::Position;
let pattern = [Position(1, 0), Position(0, 1)];
let target = pattern
    .iter()
    .collect::<RleBuilder>()
    .comment("comment0\ncomment1")
    .build()?;
assert_eq!(target.comments().len(), 2);
assert_eq!(target.comments()[0], "#C comment0".to_string());
assert_eq!(target.comments()[1], "#C comment1".to_string());

Errors

Code that calls comment() twice or more will fail at compile time. For example:

use life_backend::format::RleBuilder;
use life_backend::Position;
let pattern = [Position(1, 0), Position(0, 1)];
let target = pattern
    .iter()
    .collect::<RleBuilder>()
    .comment("comment0")
    .comment("comment1")
    .build()?; // Compile error

impl<Name, Created, Comment> RleBuilder<Name, Created, Comment, RleBuilderNoRule>

where Name: RleBuilderName, Created: RleBuilderCreated, Comment: RleBuilderComment,

pub fn rule( self, rule: Rule, ) -> RleBuilder<Name, Created, Comment, RleBuilderWithRule>

Set the rule.

Examples

use life_backend::format::RleBuilder;
use life_backend::{Position, Rule};
let pattern = [Position(1, 0), Position(0, 1)];
let target = pattern
    .iter()
    .collect::<RleBuilder>()
    .rule(Rule::conways_life())
    .build()?;
assert_eq!(*target.rule(), Rule::conways_life());

Errors

Code that calls rule() twice or more will fail at compile time. For example:

use life_backend::format::RleBuilder;
use life_backend::{Position, Rule};
let pattern = [Position(1, 0), Position(0, 1)];
let target = pattern
    .iter()
    .collect::<RleBuilder>()
    .rule(Rule::conways_life())
    .rule(Rule::conways_life()) // Compile error
    .build()?;

Trait Implementations

impl<Name, Created, Comment, Rule> Clone for RleBuilder<Name, Created, Comment, Rule>

where Name: RleBuilderName + Clone, Created: RleBuilderCreated + Clone, Comment: RleBuilderComment + Clone, Rule: RleBuilderRule + Clone,

fn clone(&self) -> RleBuilder<Name, Created, Comment, Rule>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Name, Created, Comment, Rule> Debug for RleBuilder<Name, Created, Comment, Rule>

where Name: RleBuilderName + Debug, Created: RleBuilderCreated + Debug, Comment: RleBuilderComment + Debug, Rule: RleBuilderRule + Debug,

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

Formats the value using the given formatter.

impl Default for RleBuilder<RleBuilderNoName, RleBuilderNoCreated, RleBuilderNoComment, RleBuilderNoRule>

fn default() -> Self

Returns the default value of the type, same as the return value of new().

impl<'a, Name, Created, Comment, RuleSpec> Extend<&'a Position<usize>> for RleBuilder<Name, Created, Comment, RuleSpec>

where Name: RleBuilderName, Created: RleBuilderCreated, Comment: RleBuilderComment, RuleSpec: RleBuilderRule,

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = &'a Position<usize>>,

Extends the builder with the contents of the specified non-owning iterator over the series of &Position<usize>. Each item in the series represents an immutable reference of a live cell position.

Examples

use life_backend::format::RleBuilder;
use life_backend::Position;
let pattern = [Position(1, 0), Position(0, 1)];
let iter = pattern.iter();
let mut builder = RleBuilder::new();
builder.extend(iter);

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<Name, Created, Comment, RuleSpec> Extend<Position<usize>> for RleBuilder<Name, Created, Comment, RuleSpec>

where Name: RleBuilderName, Created: RleBuilderCreated, Comment: RleBuilderComment, RuleSpec: RleBuilderRule,

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = Position<usize>>,

Extends the builder with the contents of the specified owning iterator over the series of Position<usize>. Each item in the series represents a moved live cell position.

Examples

use life_backend::format::RleBuilder;
use life_backend::Position;
let pattern = [Position(1, 0), Position(0, 1)];
let iter = pattern.into_iter();
let mut builder = RleBuilder::new();
builder.extend(iter);

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<'a> FromIterator<&'a Position<usize>> for RleBuilder<RleBuilderNoName, RleBuilderNoCreated, RleBuilderNoComment, RleBuilderNoRule>

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

where T: IntoIterator<Item = &'a Position<usize>>,

Creates a value from a non-owning iterator over a series of &Position<usize>. Each item in the series represents an immutable reference of a live cell position.

Examples

use life_backend::format::RleBuilder;
use life_backend::Position;
let pattern = [Position(1, 0), Position(0, 1)];
let iter = pattern.iter();
let builder: RleBuilder = iter.collect();

impl FromIterator<Position<usize>> for RleBuilder<RleBuilderNoName, RleBuilderNoCreated, RleBuilderNoComment, RleBuilderNoRule>

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

where T: IntoIterator<Item = Position<usize>>,

Creates a value from an owning iterator over a series of Position<usize>. Each item in the series represents a moved live cell position.

Examples

use life_backend::format::RleBuilder;
use life_backend::Position;
let pattern = [Position(1, 0), Position(0, 1)];
let iter = pattern.into_iter();
let builder: RleBuilder = iter.collect();