Struct rust_sbml::Model

pub struct Model {
    pub id: Option<String>,
    pub metaid: Option<String>,
    pub name: Option<String>,
    pub model_units: ModelUnits,
    pub initial_assignments: HashMap<String, InitialAssignment>,
    pub parameters: HashMap<String, Parameter>,
    pub species: HashMap<String, Species>,
    pub reactions: HashMap<String, Reaction>,
    pub compartments: HashMap<String, Compartment>,
    pub unit_definitions: HashMap<String, HashMap<UnitSIdRef, Unit>>,
    pub constraints: Vec<Constraint>,
    pub objectives: Option<Vec<String>>,
}

Abstraction over the SBML specification. It traverses each top-level listOF_ and provides HashMaps<id, object> instead. In addition the model units are gathered in an ModelUnits struct.

Example

use rust_sbml::Model;
use std::fs;

let ecoli = fs::read_to_string("examples/EcoliCore.xml").unwrap();
let document = Model::parse(&ecoli).unwrap();
println!("{:?}", document.objectives);
assert_eq!(
    document
        .objectives
        .unwrap()
        .iter()
        .map(|reac_id| reac_id.to_owned())
        .next(),
    Some("R_BIOMASS_Ecoli_core_w_GAM".to_string())
);

Fields

id: Option<String>

metaid: Option<String>

name: Option<String>

model_units: ModelUnits

initial_assignments: HashMap<String, InitialAssignment>

parameters: HashMap<String, Parameter>

species: HashMap<String, Species>

reactions: HashMap<String, Reaction>

compartments: HashMap<String, Compartment>

unit_definitions: HashMap<String, HashMap<UnitSIdRef, Unit>>

constraints: Vec<Constraint>

objectives: Option<Vec<String>>

Implementations

impl Model

pub fn get_list_of_compartments(&self) -> Vec<&Compartment>

Emulating the API of libSBML

Example

use rust_sbml::Model;
use std::fs;

let ecoli = fs::read_to_string("examples/EcoliCore.xml").unwrap();
let document = Model::parse(&ecoli).unwrap();
println!("{:?}", document.get_list_of_compartments())

pub fn get_list_of_species(&self) -> Vec<&Species>

Emulating the API of libSBML

Example

use rust_sbml::Model;
use std::fs;

let ecoli = fs::read_to_string("examples/EcoliCore.xml").unwrap();
let document = Model::parse(&ecoli).unwrap();
println!("{:?}", document.get_list_of_species())

pub fn get_list_of_reactions(&self) -> Vec<&Reaction>

Emulating the API of libSBML

Example

use rust_sbml::Model;
use std::fs;

let ecoli = fs::read_to_string("examples/EcoliCore.xml").unwrap();
let document = Model::parse(&ecoli).unwrap();
println!("{:?}", document.get_list_of_reactions())

pub fn parse(doc: &str) -> Result<Self, Box<dyn Error>>

Use ModelRaw to parse the SBML document and then format it into Model.

Trait Implementations

impl Debug for Model

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

Formats the value using the given formatter.

impl Default for Model

fn default() -> Model

Returns the “default value” for a type.

impl<'a> ExtractExt<'a> for &'a Model

type Target = PyRef<'a, Model>

impl<'a> ExtractExt<'a> for &'a mut Model

type Target = PyRefMut<'a, Model>

impl HasMethodsInventory for Model

type Methods = Pyo3MethodsInventoryForModel

impl IntoPy<Py<PyAny>> for Model

fn into_py(self, py: Python<'_>) -> PyObject

Performs the conversion.

impl PartialEq<Model> for Model

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

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

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

This method tests for !=.

impl PyClass for Model

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

impl PyClassAlloc for Model

pub unsafe fn new(
    py: Python<'_>,
    subtype: *mut PyTypeObject
) -> *mut Self::Layout

Allocate the actual field for #[pyclass].

pub unsafe fn dealloc(py: Python<'_>, self_: *mut Self::Layout)

Deallocate #[pyclass] on the Python heap.

impl PyClassSend for Model

type ThreadChecker = ThreadCheckerStub<Model>

impl PyProtoMethods for Model

fn for_each_proto_slot<Visitor: FnMut(PyType_Slot)>(visitor: Visitor)

fn get_buffer() -> Option<&'static PyBufferProcs>

impl PyTypeInfo for Model

type Type = Model

Type of objects to store in PyObject struct

type BaseType = PyAny

Base class

type Layout = PyCell<Self>

Layout

type BaseLayout = PyCellBase<PyAny>

Layout of Basetype.

type Initializer = PyClassInitializer<Self>

Initializer for layout

type AsRefTarget = PyCell<Self>

Utility type to make Py::as_ref work

const NAME: &'static str

Class name

const MODULE: Option<&'static str>

Module name, if any

const DESCRIPTION: &'static str

Class doc string

const FLAGS: usize

Type flags (ie PY_TYPE_FLAG_GC, PY_TYPE_FLAG_WEAKREF)

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

PyTypeObject instance for this type.

pub fn is_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type or a subclass of this type.

pub fn is_exact_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type.

impl StructuralPartialEq for Model