Struct PLinkData 

#[non_exhaustive]
pub struct PLinkData {

    pub order: usize,
    pub title: String,
    pub z: Charge,
    pub mass: Mass,
    pub theoretical_mass: Mass,
    pub peptide_type: PLinkPeptideType,
    pub peptidoform: PeptidoformIon,
    pub ptm: Vec<(SimpleModification, u16)>,
    pub refined_score: f64,
    pub svm_score: f64,
    pub score: f64,
    pub e_value: f64,
    pub is_decoy: bool,
    pub q_value: f64,
    pub proteins: Vec<(FastaIdentifier<String>, Option<u16>, Option<FastaIdentifier<String>>, Option<u16>)>,
    pub is_different_protein: bool,
    pub raw_file_id: usize,
    pub is_complex_satisfied: bool,
    pub is_filter_in: bool,
    pub scan_number: Option<usize>,
    pub raw_file: Option<PathBuf>,
    pub version: PLinkVersion,
    /* private fields */
}

The data for individual entries in PLink files.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

order: usize

title: String

z: Charge

mass: Mass

MH+ mass

theoretical_mass: Mass

MH+ mass

peptide_type: PLinkPeptideType

peptidoform: PeptidoformIon

ptm: Vec<(SimpleModification, u16)>

All modifications with their attachment, and their index (into the full peptidoform, so anything bigger than the first peptide matches in the second)

refined_score: f64

svm_score: f64

score: f64

e_value: f64

is_decoy: bool

Whether this peptide is a target (false) or decoy (true) peptide

q_value: f64

proteins: Vec<(FastaIdentifier<String>, Option<u16>, Option<FastaIdentifier<String>>, Option<u16>)>

The proteins, per protein the first protein, location, second protein, and location

is_different_protein: bool

If true this indicates that this cross-link binds two different proteins

raw_file_id: usize

is_complex_satisfied: bool

is_filter_in: bool

Whether this fits within the normal filters applied within pLink

scan_number: Option<usize>

raw_file: Option<PathBuf>

version: PLinkVersion

The version used to read in the data

Implementations

impl PLinkData

pub fn full_csv_line(&self) -> Option<&[(Arc<String>, String)]>

Get all original columns from the CSV file, only available if the file was opened with the option keep_all_columns turned on.

Trait Implementations

impl Clone for PLinkData

fn clone(&self) -> PLinkData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PLinkData

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

Formats the value using the given formatter.

impl Default for PLinkData

fn default() -> PLinkData

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PLinkData

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<PLinkData> for IdentifiedPeptidoform<Linked, PeptidoformPresent>

fn from(value: PLinkData) -> Self

Converts to this type from the input type.

impl IdentifiedPeptidoformSource for PLinkData

type Source = CsvLine

The source data where the peptides are parsed form

type Format = PLinkFormat

The format type

type Complexity = Linked

The complexity marker type

type PeptidoformAvailability = PeptidoformPresent

The peptidoform availability marker type

type Version = PLinkVersion

The version type

fn parse( source: &Self::Source, ontologies: &Ontologies, keep_all_columns: bool, ) -> Result<(Self, &'static Self::Format), BoxedError<'static, BasicKind>>

Parse a single identified peptide from its source and return the detected format

fn parse_file( path: impl AsRef<Path>, ontologies: &Ontologies, keep_all_columns: bool, version: Option<Self::Version>, ) -> Result<BoxedIdentifiedPeptideIter<'_, Self>, BoxedError<'static, BasicKind>>

Parse a file with identified peptides.

fn parse_reader<'a>( reader: impl Read + 'a, ontologies: &'a Ontologies, keep_all_columns: bool, version: Option<Self::Version>, ) -> Result<BoxedIdentifiedPeptideIter<'a, Self>, BoxedError<'static, BasicKind>>

Parse a reader with identified peptides.

fn parse_specific( source: &Self::Source, format: &PLinkFormat, ontologies: &Ontologies, keep_all_columns: bool, ) -> Result<Self, BoxedError<'static, BasicKind>>

Parse a single identified peptide with the given format

fn post_process( source: &CsvLine, parsed: Self, ontologies: &Ontologies, ) -> Result<Self, BoxedError<'static, BasicKind>>

Allow post processing of the peptide

fn parse_many<I: Iterator<Item = Result<Self::Source, BoxedError<'static, BasicKind>>>>( iter: I, ontologies: &Ontologies, keep_all_columns: bool, format: Option<Self::Format>, ) -> IdentifiedPeptidoformIter<'_, Self, I>

Parse a source of multiple peptides using the given format or automatically determining the format to use by the first item

impl MetaData for PLinkData

fn compound_peptidoform_ion(&self) -> Option<Cow<'_, CompoundPeptidoformIon>>

Get the compound peptidoform ion, if present

fn format(&self) -> KnownFileFormat

Get the format and version for this peptidoform

fn id(&self) -> String

Get the PSM identifier

fn confidence(&self) -> Option<f64>

Get the confidence, a score between -1 and 1 describing the confidence in the entire PSM

fn local_confidence(&self) -> Option<Cow<'_, [f64]>>

Get the local confidence, a score between -1 and 1 for each amino acid in the peptide

fn original_confidence(&self) -> Option<f64>

Get the original confidence

fn original_local_confidence(&self) -> Option<&[f64]>

Get the original local confidence, a score for each amino acid in the peptide

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

The charge of the precursor/PSM, if known

fn mode(&self) -> Option<Cow<'_, str>>

Which fragmentation mode was used, if known

fn retention_time(&self) -> Option<Time>

The retention time, if known

fn scans(&self) -> SpectrumIds

The scans per rawfile that are at the basis for this identified peptide

fn experimental_mz(&self) -> Option<MassOverCharge>

Get the mz as experimentally determined

fn experimental_mass(&self) -> Option<Mass>

Get the mass as experimentally determined

fn protein_names(&self) -> Option<Cow<'_, [FastaIdentifier<String>]>>

Get the protein names if this was database matched data

fn protein_id(&self) -> Option<usize>

Get the protein id if this was database matched data

fn protein_location(&self) -> Option<Range<u16>>

Get the protein location if this was database matched data

fn flanking_sequences(&self) -> (&FlankingSequence, &FlankingSequence)

Get the flanking sequences on the N and C terminal side. The reported sequences are both in N to C direction.

fn database(&self) -> Option<(&str, Option<&str>)>

The database that was used for matching optionally with the version of the database

fn fragmentation_model(&self) -> Option<BuiltInFragmentationModel>

Which built-in fragmentation model this fragmentation mode matches to. The default implementation matches on the textual output of MetaData::mode. If needed a custom implementation can be made.

fn ppm_error(&self) -> Option<Ratio>

Get the absolute ppm error between the experimental and theoretical precursor mass, if there are multiple masses possible returns the smallest ppm

fn mass_error(&self) -> Option<Mass>

Get the absolute mass error between the experimental and theoretical precursor mass, if there are multiple masses possible returns the smallest difference

fn annotated_spectrum(&self) -> Option<Cow<'_, AnnotatedSpectrum>>

Get the annotated spectrum if this is encoded in the format

fn has_annotated_spectrum(&self) -> bool

Check if this spectrum has an annotated spectrum available. This can be overwritten to built a faster implementation if creating the spectrum needs to happen at runtime.

impl PartialEq for PLinkData

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for PLinkData