Struct rustyms::LinearPeptide

pub struct LinearPeptide {
    pub labile: Vec<Modification>,
    pub n_term: Option<Modification>,
    pub c_term: Option<Modification>,
    pub sequence: Vec<SequenceElement>,
    pub ambiguous_modifications: Vec<Vec<usize>>,
    pub charge_carriers: Option<MolecularCharge>,
    /* private fields */
}

A peptide with all data as provided by pro forma. Preferably generated by using the crate::ComplexPeptide::pro_forma function.

Fields

labile: Vec<Modification>

Labile modifications, which will not be found in the actual spectrum.

n_term: Option<Modification>

N terminal modification

c_term: Option<Modification>

C terminal modification

sequence: Vec<SequenceElement>

The sequence of this peptide (includes local modifications)

ambiguous_modifications: Vec<Vec<usize>>

For each ambiguous modification list all possible positions it can be placed on. Indexed by the ambiguous modification id.

charge_carriers: Option<MolecularCharge>

The adduct ions, if specified

Implementations

impl LinearPeptide

Builder style methods to create a LinearPeptide

pub fn new(sequence: impl IntoIterator<Item = SequenceElement>) -> Self

Create a new LinearPeptide, if you want an empty peptide look at LinearPeptide::default. Potentially the .collect() or .into() methods can be useful as well.

pub fn global( self, global: impl IntoIterator<Item = (Element, Option<u16>)> ) -> Option<Self>

Add global isotope modifications, if any is invalid it returns None

pub fn labile(self, labile: impl IntoIterator<Item = Modification>) -> Self

Add labile modifications

pub fn n_term(self, term: Option<Modification>) -> Self

Add the N terminal modification

pub fn c_term(self, term: Option<Modification>) -> Self

Add the C terminal modification

pub fn charge_carriers(self, charge: Option<MolecularCharge>) -> Self

Add the charge carriers

impl LinearPeptide

pub fn pro_forma(value: &str) -> Result<Self, CustomError>

Convenience wrapper to parse a linear peptide in pro forma notation, to handle all possible pro forma sequences look at ComplexPeptide::pro_forma.

Errors

It gives an error when the peptide is not correctly formatted. (Also see the ComplexPeptide main function for this.) It additionally gives an error if the peptide specified was multimeric (see ComplexPeptide::singular).

pub fn sloppy_pro_forma( line: &str, location: Range<usize> ) -> Result<Self, CustomError>

Read sloppy pro forma like sequences. Defined by the use of square or round braces to indicate modifications and missing any particular method of defining the N or C terminal modifications. Additionally any underscores will be ignored both on the ends and inside the sequence.

All modifications follow the same definitions as the strict pro forma syntax, if it cannot be parsed as a strict pro forma modification it falls back to Modification::sloppy_modification.

Errors

If it does not fit the above description.

pub fn len(&self) -> usize

Get the number of amino acids making up this peptide

pub fn is_empty(&self) -> bool

Check if there are any amino acids in this peptide

pub fn get_n_term(&self) -> MolecularFormula

The mass of the N terminal modifications. The global isotope modifications are NOT applied.

pub fn get_c_term(&self) -> MolecularFormula

The mass of the C terminal modifications. The global isotope modifications are NOT applied.

pub fn get_global(&self) -> &[(Element, Option<u16>)]

Get the global isotope modifications

pub fn reverse(&self) -> Self

Get the reverse of this peptide

pub fn assume_simple(&self)

Assume that the underlying peptide does not use fancy parts of the Pro Forma spec. This is the common lower bound for support in all functions of rustyms. If you want to be even more strict on the kind of peptides you want to take take a look at Self::assume_very_simple.

Panics

When any of these functions are used:

• Labile modifications
• Global isotope modifications
• Charge carriers, use of charged ions apart from protons
• or when the sequence is empty.

pub fn assume_very_simple(&self)

Assume that the underlying peptide does not use fancy parts of the Pro Forma spec.

Panics

When any of these functions are used:

• Ambiguous modifications
• Labile modifications
• Global isotope modifications
• Ambiguous amino acids (B/Z)
• Ambiguous amino acid sequence (?AA)
• Charge carriers, use of charged ions apart from protons
• or when the sequence is empty.

pub fn bare_formulas(&self) -> Multi<MolecularFormula>

Gives all the formulas for the whole peptide with no C and N terminal modifications. With the global isotope modifications applied.

pub fn generate_theoretical_fragments( &self, max_charge: Charge, model: &Model ) -> Vec<Fragment>

Generate the theoretical fragments for this peptide, with the given maximal charge of the fragments, and the given model. With the global isotope modifications applied.

Panics

If max_charge outside the range 1..=u64::MAX.

pub fn sub_peptide(&self, index: impl RangeBounds<usize>) -> Self

Get a region of this peptide as a new peptide (with all terminal/global/ambiguous modifications).

pub fn digest( &self, protease: &Protease, max_missed_cleavages: usize ) -> Vec<Self>

Digest this sequence with the given protease and the given maximal number of missed cleavages.

Trait Implementations

impl Clone for LinearPeptide

fn clone(&self) -> LinearPeptide

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LinearPeptide

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

Formats the value using the given formatter.

impl Default for LinearPeptide

fn default() -> LinearPeptide

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LinearPeptide

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for LinearPeptide

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

Formats the value using the given formatter.

impl<Collection, Item> From<Collection> for LinearPeptide

where Collection: IntoIterator<Item = Item>, Item: Into<SequenceElement>,

fn from(value: Collection) -> Self

Converts to this type from the input type.

impl<Item> FromIterator<Item> for LinearPeptide

where Item: Into<SequenceElement>,

fn from_iter<T: IntoIterator<Item = Item>>(iter: T) -> Self

Creates a value from an iterator.

impl Hash for LinearPeptide

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<I: SliceIndex<[SequenceElement]>> Index<I> for LinearPeptide

type Output = <I as SliceIndex<[SequenceElement]>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl MultiChemical for LinearPeptide

fn formulas(&self) -> Multi<MolecularFormula>

Gives the formulas for the whole peptide. With the global isotope modifications applied. (Any B/Z will result in multiple possible formulas.)

fn charge(&self) -> Option<i16>

Get the charge of this chemical, it returns None if no charge is defined.

impl Ord for LinearPeptide

fn cmp(&self, other: &LinearPeptide) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for LinearPeptide

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for LinearPeptide

fn partial_cmp(&self, other: &LinearPeptide) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for LinearPeptide

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 LinearPeptide

impl StructuralPartialEq for LinearPeptide