Struct Template 

pub struct Template {
    pub name: String,
    /* private fields */
}

Describes the atom inventory and connectivity for a residue or ligand template.

Templates originate from the embedded parameter database and encapsulate the minimal information needed to validate coordinate files, seed missing atoms, or emit force-field compatible topologies.

Fields

name: String

External identifier such as a three-letter residue code.

Implementations

impl Template

pub fn new<S: Into<String>>( name: S, atom_names: Vec<String>, bonds: Vec<(String, String, BondOrder)>, ) -> Self

Constructs a template from explicit atom and bond data.

The constructor enforces (in debug builds) that every bond references atoms present in the provided atom_names list, preventing malformed templates from entering the store.

Arguments

• name - Short identifier for the template (e.g., three-letter code).
• atom_names - Complete list of atom names belonging to the template.
• bonds - Connectivity tuples describing bonded atom pairs and their BondOrder.

Returns

A fully owned Template instance containing the supplied data.

Panics

Panics in debug builds if any bond references an atom not listed in atom_names.

Examples

use bio_forge::{BondOrder, Template};

let atoms = vec!["O".into(), "H1".into(), "H2".into()];
let bonds = vec![
    ("O".into(), "H1".into(), BondOrder::Single),
    ("O".into(), "H2".into(), BondOrder::Single),
];
let template = Template::new("HOH", atoms, bonds);

assert_eq!(template.atom_count(), 3);
assert_eq!(template.bond_count(), 2);

pub fn has_bond(&self, name1: &str, name2: &str) -> bool

Reports whether the template defines a bond between the provided atom names.

Lookup is order-independent, allowing callers to check connectivity without sorting the names first.

Arguments

• name1 - Name of the first atom.
• name2 - Name of the second atom.

Returns

true if a bond exists between the atoms, otherwise false.

Examples

use bio_forge::{BondOrder, Template};

let atoms = vec!["C1".into(), "C2".into()];
let bonds = vec![("C1".into(), "C2".into(), BondOrder::Single)];
let template = Template::new("ETH", atoms, bonds);

assert!(template.has_bond("C1", "C2"));
assert!(template.has_bond("C2", "C1"));
assert!(!template.has_bond("C1", "H1"));

pub fn has_atom(&self, name: &str) -> bool

Checks whether an atom name is present in the template definition.

Arguments

• name - Atom name to search for.

Returns

true if the atom exists in atom_names.

Examples

use bio_forge::{BondOrder, Template};

let atoms = vec!["N".into(), "CA".into(), "C".into()];
let template = Template::new("GLY", atoms, Vec::new());

assert!(template.has_atom("CA"));
assert!(!template.has_atom("OXT"));

pub fn atom_names(&self) -> &[String]

Returns the ordered slice of atom names defined for the template.

Returns

Borrowed slice referencing the internal atom list.

Examples

use bio_forge::{BondOrder, Template};

let atoms = vec!["P".into(), "O5'".into()];
let template = Template::new("PO4", atoms.clone(), Vec::new());

assert_eq!(template.atom_names(), atoms.as_slice());

pub fn bonds(&self) -> &[(String, String, BondOrder)]

Returns the list of bond definitions stored within the template.

Returns

Borrowed slice of (atom_a, atom_b, BondOrder) tuples.

Examples

use bio_forge::{BondOrder, Template};

let atoms = vec!["C1".into(), "O1".into()];
let bonds = vec![("C1".into(), "O1".into(), BondOrder::Double)];
let template = Template::new("CO", atoms, bonds.clone());

assert_eq!(template.bonds(), bonds.as_slice());

pub fn atom_count(&self) -> usize

Counts atoms described by the template.

Returns

Number of atom entries in atom_names.

Examples

use bio_forge::{BondOrder, Template};

let template = Template::new("ION", vec!["K".into()], Vec::new());
assert_eq!(template.atom_count(), 1);

pub fn bond_count(&self) -> usize

Counts bonds described by the template.

Returns

Number of bond tuples stored in bonds.

Examples

use bio_forge::{BondOrder, Template};

let atoms = vec!["C".into(), "O".into()];
let bonds = vec![("C".into(), "O".into(), BondOrder::Double)];
let template = Template::new("CO", atoms, bonds);

assert_eq!(template.bond_count(), 1);

Trait Implementations

impl Clone for Template

fn clone(&self) -> Template

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Template

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

Formats the value using the given formatter.

impl Display for Template

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

Formats the value using the given formatter.

impl Eq for Template

impl PartialEq for Template

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