Struct BasicCSVData 

#[non_exhaustive]
pub struct BasicCSVData {
    pub scan_index: usize,
    pub sequence: CompoundPeptidoformIon,
    pub raw_file: PathBuf,
    pub z: Charge,
    pub mode: Option<String>,
    pub version: BasicCSVVersion,
    /* private fields */
}

The data for individual entries in BasicCSV 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.

scan_index: usize

sequence: CompoundPeptidoformIon

raw_file: PathBuf

z: Charge

mode: Option<String>

version: BasicCSVVersion

The version used to read in the data

Implementations

impl BasicCSVData

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 BasicCSVData

fn clone(&self) -> BasicCSVData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BasicCSVData

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

Formats the value using the given formatter.

impl Default for BasicCSVData

fn default() -> BasicCSVData

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BasicCSVData

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

fn from(value: BasicCSVData) -> Self

Converts to this type from the input type.

impl IdentifiedPeptidoformSource for BasicCSVData

type Source = CsvLine

The source data where the peptides are parsed form

type Format = BasicCSVFormat

The format type

type Complexity = Linked

The complexity marker type

type PeptidoformAvailability = PeptidoformPresent

The peptidoform availability marker type

type Version = BasicCSVVersion

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: &BasicCSVFormat, ontologies: &Ontologies, keep_all_columns: bool, ) -> Result<Self, BoxedError<'static, BasicKind>>

Parse a single identified peptide with the given format

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

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

Allow post processing of the peptide

impl MetaData for BasicCSVData

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 BasicCSVData

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

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 BasicCSVData