CA rules parsers

中文

Parsing rule strings of life-like and other cellular automata.

Currently the following rules are supported:

• Totalistic Life-like, e.g., B3/S23.
• Isotropic non-totalistic Life-like, e.g., B2ci3ai4c8/S02ae3eijkq4iz5ar6i7e.
• Totalistic Hexagonal, e.g., B2/S34H.
• Isotropic non-totalistic Hexagonal, e.g., B2o3-o4m/S12m3o4m5H.
• von Neumann neighbourhood, e.g., B2/S013V.
• The corresponding Generations rules of the above rules, e.g., 3457/357/5.

For non-Generations rules, both B/S notation (B3/S23) and S/B notation (23/3) are supported.

For Generations rules, three different notations are supported:

• B/S notation (B357/S3457/C5)
• The notation used by Golly (3457/357/5)
• The notation used by Catagolue (g5b357s3457)

Please see Life Wiki for detailed definitions and notations of these rule strings.

Example:

```rust use ca_rules::{neighborhood, ParseBSRules};

// First you need to define a struct for your rule:

[derive(Debug, Eq, PartialEq)]

struct Rule { b: Vec, s: Vec, }

// Implement the ParseBSRules trait for your rule: impl ParseBSRules for Rule { // Specify the neighborhood type: type Neighborhood = neighborhood::Lifelike;

// Implement a function to construct the rule from b and s data:
fn from_bs(b: Vec<u8>, s: Vec<u8>) -> Self {
    Rule { b, s }
}

}

// Then you can parse a rule string: let life = Rule::parserule(&"B3/S23").unwrap(); asserteq!( life, Rule { b: vec![3], s: vec![2, 3], } ) ```