Struct noodles_sam::record::Record
source · [−]pub struct Record { /* private fields */ }
Expand description
A SAM record.
A SAM record has 11 required fields:
- read name (
QNAME
), - flags (
FLAG
), - reference sequence name (
RNAME
), - position (
POS
), - mapping quality (
MAPQ
), - CIGAR string (
CIGAR
), - mate reference sequence name (
RNEXT
), - mate position (
PNEXT
), - template length (
TLEN
), - sequence (
SEQ
), and - quality scores (
QUAL
).
Additionally, optional data fields can be included with any record.
Implementations
sourceimpl Record
impl Record
sourcepub fn builder() -> Builder
pub fn builder() -> Builder
Returns a builder to create a record from each of its fields.
Examples
use noodles_sam::{self as sam, record::Flags};
let record = sam::Record::builder()
.set_read_name("r0".parse()?)
.set_flags(Flags::UNMAPPED)
.build()?;
assert_eq!(record.read_name().map(|name| name.as_str()), Some("r0"));
assert_eq!(record.flags(), Flags::UNMAPPED);
assert!(record.reference_sequence_name().is_none());
assert!(record.position().is_none());
sourcepub fn read_name(&self) -> Option<&ReadName>
pub fn read_name(&self) -> Option<&ReadName>
Returns the read name of this record.
This is also called the query name.
Examples
use noodles_sam as sam;
let record = sam::Record::default();
assert!(record.read_name().is_none());
let record = sam::Record::builder()
.set_read_name("r0".parse()?)
.build()?;
assert_eq!(record.read_name().map(|name| name.as_str()), Some("r0"));
sourcepub fn read_name_mut(&mut self) -> &mut Option<ReadName>
pub fn read_name_mut(&mut self) -> &mut Option<ReadName>
Returns a mutable reference to the read name.
This is also called the query name.
Examples
use noodles_sam as sam;
let mut record = sam::Record::default();
record.read_name_mut().insert("r0".parse()?);
assert_eq!(record.read_name().map(|name| name.as_str()), Some("r0"));
*record.read_name_mut() = None;
assert!(record.read_name().is_none());
sourcepub fn flags(&self) -> Flags
pub fn flags(&self) -> Flags
Returns the SAM flags of this record.
Examples
use noodles_sam::{self as sam, record::Flags};
let record = sam::Record::default();
assert_eq!(record.flags(), Flags::UNMAPPED);
assert_eq!(u16::from(record.flags()), 4);
let record = sam::Record::builder()
.set_flags(Flags::PAIRED | Flags::READ_1)
.build()?;
assert_eq!(record.flags(), Flags::PAIRED | Flags::READ_1);
sourcepub fn flags_mut(&mut self) -> &mut Flags
pub fn flags_mut(&mut self) -> &mut Flags
Returns a mutable reference to the SAM flags.
Examples
use noodles_sam::{self as sam, record::Flags};
let mut record = sam::Record::builder()
.set_flags(Flags::PAIRED | Flags::READ_1)
.build()?;
record.flags_mut().set(Flags::DUPLICATE, true);
assert_eq!(record.flags(), Flags::PAIRED | Flags::READ_1 | Flags::DUPLICATE);
record.flags_mut().set(Flags::PAIRED | Flags::QC_FAIL, false);
assert_eq!(record.flags(), Flags::READ_1 | Flags::DUPLICATE);
sourcepub fn reference_sequence_name(&self) -> Option<&ReferenceSequenceName>
pub fn reference_sequence_name(&self) -> Option<&ReferenceSequenceName>
Returns the reference sequence name of this record.
Examples
use noodles_sam as sam;
let record = sam::Record::default();
assert_eq!(record.reference_sequence_name(), None);
let record = sam::Record::builder()
.set_reference_sequence_name("sq0".parse()?)
.build()?;
assert_eq!(record.reference_sequence_name().map(|name| name.as_str()), Some("sq0"));
sourcepub fn reference_sequence_name_mut(
&mut self
) -> &mut Option<ReferenceSequenceName>
pub fn reference_sequence_name_mut(
&mut self
) -> &mut Option<ReferenceSequenceName>
Returns a mutable reference to the reference sequence name.
Examples
use noodles_sam as sam;
let mut record = sam::Record::default();
*record.reference_sequence_name_mut() = Some("sq0".parse()?);
assert_eq!(record.reference_sequence_name().map(|name| name.as_str()), Some("sq0"));
*record.reference_sequence_name_mut() = None;
assert!(record.reference_sequence_name().is_none());
sourcepub fn position(&self) -> Option<Position>
pub fn position(&self) -> Option<Position>
Returns the start position of this record.
This value is 1-based.
Examples
use noodles_sam::{self as sam, record::Position};
let record = sam::Record::default();
assert!(record.position().is_none());
let record = sam::Record::builder()
.set_position(Position::try_from(13)?)
.build()?;
assert_eq!(record.position().map(i32::from), Some(13));
sourcepub fn position_mut(&mut self) -> &mut Option<Position>
pub fn position_mut(&mut self) -> &mut Option<Position>
Returns a mutable reference to the start position.
This value is 1-based.
Examples
use noodles_sam::{self as sam, record::Position};
let mut record = sam::Record::default();
*record.position_mut() = Some(Position::try_from(13)?);
assert_eq!(record.position().map(i32::from), Some(13));
*record.position_mut() = None;
assert!(record.position().is_none());
sourcepub fn mapping_quality(&self) -> Option<MappingQuality>
pub fn mapping_quality(&self) -> Option<MappingQuality>
Returns the mapping quality of this record.
Mapping quality ranges from 0 to 254, inclusive.
Examples
use noodles_sam::{self as sam, record::MappingQuality};
let record = sam::Record::default();
assert!(record.mapping_quality().is_none());
let record = sam::Record::builder()
.set_mapping_quality(MappingQuality::try_from(8)?)
.build()?;
assert_eq!(record.mapping_quality().map(u8::from), Some(8));
sourcepub fn mapping_quality_mut(&mut self) -> &mut Option<MappingQuality>
pub fn mapping_quality_mut(&mut self) -> &mut Option<MappingQuality>
Returns a mutable reference to the mapping quality.
Examples
use noodles_sam::{self as sam, record::MappingQuality};
let mut record = sam::Record::default();
*record.mapping_quality_mut() = MappingQuality::try_from(8).map(Some)?;
assert_eq!(record.mapping_quality().map(u8::from), Some(8));
*record.mapping_quality_mut() = None;
assert!(record.mapping_quality().is_none());
sourcepub fn cigar(&self) -> &Cigar
pub fn cigar(&self) -> &Cigar
Returns the CIGAR operations that describe how the read as mapped.
Examples
use noodles_sam::{self as sam, record::cigar::{op, Op}};
let record = sam::Record::default();
assert!(record.cigar().is_empty());
assert_eq!(record.cigar().to_string(), "*");
let record = sam::Record::builder().set_cigar("34M2S".parse()?).build()?;
assert_eq!(record.cigar().to_string(), "34M2S");
let mut ops = record.cigar().iter();
assert_eq!(ops.next(), Some(&Op::new(op::Kind::Match, 34)));
assert_eq!(ops.next(), Some(&Op::new(op::Kind::SoftClip, 2)));
assert_eq!(ops.next(), None);
sourcepub fn cigar_mut(&mut self) -> &mut Cigar
pub fn cigar_mut(&mut self) -> &mut Cigar
Returns a mutable reference to the CIGAR operations.
Examples
use noodles_sam::{self as sam, record::{cigar::{op, Op}, Cigar}};
let mut record = sam::Record::default();
assert!(record.cigar().is_empty());
let cigar = Cigar::from(vec![
Op::new(op::Kind::Match, 36),
Op::new(op::Kind::SoftClip, 2),
]);
*record.cigar_mut() = cigar.clone();
assert_eq!(record.cigar(), &cigar);
sourcepub fn mate_reference_sequence_name(&self) -> Option<&ReferenceSequenceName>
pub fn mate_reference_sequence_name(&self) -> Option<&ReferenceSequenceName>
Returns the mate reference sequence name of this record.
Examples
use noodles_sam as sam;
let record = sam::Record::default();
assert!(record.mate_reference_sequence_name().is_none());
let record = sam::Record::builder()
.set_mate_reference_sequence_name("sq0".parse()?)
.build()?;
assert_eq!(
record.mate_reference_sequence_name().map(|name| name.as_str()),
Some("sq0")
);
sourcepub fn mate_reference_sequence_name_mut(
&mut self
) -> &mut Option<ReferenceSequenceName>
pub fn mate_reference_sequence_name_mut(
&mut self
) -> &mut Option<ReferenceSequenceName>
Returns a mutable reference to the mate reference sequence name.
Examples
use noodles_sam as sam;
let mut record = sam::Record::default();
*record.mate_reference_sequence_name_mut() = Some("sq0".parse()?);
assert_eq!(record.mate_reference_sequence_name().map(|name| name.as_str()), Some("sq0"));
*record.mate_reference_sequence_name_mut() = None;
assert!(record.mate_reference_sequence_name().is_none());
sourcepub fn mate_position(&self) -> Option<Position>
pub fn mate_position(&self) -> Option<Position>
Returns the start position of the mate of this record.
This value is 1-based.
Examples
use noodles_sam::{self as sam, record::Position};
let record = sam::Record::default();
assert!(record.mate_position().is_none());
let record = sam::Record::builder()
.set_mate_position(Position::try_from(21)?)
.build()?;
assert_eq!(record.mate_position().map(i32::from), Some(21));
sourcepub fn mate_position_mut(&mut self) -> &mut Option<Position>
pub fn mate_position_mut(&mut self) -> &mut Option<Position>
Returns a mutable reference to the start position of the mate.
This value is 1-based.
Examples
use noodles_sam::{self as sam, record::Position};
let mut record = sam::Record::default();
*record.mate_position_mut() = Some(Position::try_from(13)?);
assert_eq!(record.mate_position().map(i32::from), Some(13));
*record.mate_position_mut() = None;
assert!(record.mate_position().is_none());
sourcepub fn template_length(&self) -> i32
pub fn template_length(&self) -> i32
Returns the template length of this record.
Examples
use noodles_sam as sam;
let record = sam::Record::default();
assert_eq!(record.template_length(), 0);
let record = sam::Record::builder().set_template_length(101).build()?;
assert_eq!(record.template_length(), 101);
sourcepub fn template_length_mut(&mut self) -> &mut i32
pub fn template_length_mut(&mut self) -> &mut i32
Returns a mutable reference to the template length.
Examples
use noodles_sam::{self as sam, record::MappingQuality};
let mut record = sam::Record::default();
*record.template_length_mut() = 101;
assert_eq!(record.template_length(), 101);
sourcepub fn sequence(&self) -> &Sequence
pub fn sequence(&self) -> &Sequence
Returns the bases in the sequence of this record.
Examples
use noodles_sam::{self as sam, record::sequence::Base};
let record = sam::Record::default();
assert!(record.sequence().is_empty());
assert_eq!(record.sequence().to_string(), "*");
let record = sam::Record::builder()
.set_sequence("AT".parse()?)
.build()?;
assert_eq!(record.sequence().to_string(), "AT");
let mut bases = record.sequence().iter();
assert_eq!(bases.next(), Some(&Base::A));
assert_eq!(bases.next(), Some(&Base::T));
assert_eq!(bases.next(), None);
sourcepub fn sequence_mut(&mut self) -> &mut Sequence
pub fn sequence_mut(&mut self) -> &mut Sequence
Returns a mutable reference to the sequence.
Examples
use noodles_sam::{self as sam, record::{sequence, Sequence}};
let mut record = sam::Record::default();
assert!(record.sequence().is_empty());
let sequence: Sequence = "ACGT".parse()?;
*record.sequence_mut() = sequence.clone();
assert_eq!(record.sequence(), &sequence);
sourcepub fn quality_scores(&self) -> &QualityScores
pub fn quality_scores(&self) -> &QualityScores
Returns the quality score for each base in the sequence.
Examples
use noodles_sam::{self as sam, record::quality_scores::Score};
let record = sam::Record::default();
assert!(record.quality_scores().is_empty());
assert_eq!(record.quality_scores().to_string(), "*");
let record = sam::Record::builder()
.set_sequence("AC".parse()?)
.set_quality_scores("ND".parse()?)
.build()?;
assert_eq!(record.quality_scores().to_string(), "ND");
let mut scores = record.quality_scores().iter().copied().map(u8::from);
assert_eq!(scores.next(), Some(45));
assert_eq!(scores.next(), Some(35));
assert_eq!(scores.next(), None);
sourcepub fn quality_scores_mut(&mut self) -> &mut QualityScores
pub fn quality_scores_mut(&mut self) -> &mut QualityScores
Returns a mutable reference to the quality scores.
Examples
use noodles_sam::{self as sam, record::{quality_scores, QualityScores}};
let mut record = sam::Record::default();
assert!(record.quality_scores().is_empty());
let quality_scores: QualityScores = "NDLS".parse()?;
*record.quality_scores_mut() = quality_scores.clone();
assert_eq!(record.quality_scores(), &quality_scores);
sourcepub fn data(&self) -> &Data
pub fn data(&self) -> &Data
Returns the optional data fields for this record.
Examples
use noodles_sam::{self as sam, record::{data, Data}};
let record = sam::Record::default();
assert!(record.data().is_empty());
let data = Data::try_from(vec![data::Field::new(
data::field::Tag::AlignmentHitCount,
data::field::Value::Int(1),
)])?;
let record = sam::Record::builder().set_data(data).build()?;
assert_eq!(record.data().to_string(), "NH:i:1");
sourcepub fn data_mut(&mut self) -> &mut Data
pub fn data_mut(&mut self) -> &mut Data
Returns a mutable reference to the data fields for this record.
Examples
use noodles_sam::{self as sam, record::data};
let mut record = sam::Record::default();
assert!(record.data().is_empty());
let field = data::Field::new(
data::field::Tag::AlignmentHitCount,
data::field::Value::Int(1),
);
let data = record.data_mut();
data.insert(field.clone());
let data = record.data();
assert_eq!(data.len(), 1);
assert_eq!(data.get(field.tag()), Some(&field));
Trait Implementations
sourceimpl RecordExt for Record
impl RecordExt for Record
sourcefn reference_sequence<'rs>(
&self,
reference_sequences: &'rs ReferenceSequences
) -> Option<Result<&'rs ReferenceSequence>>
fn reference_sequence<'rs>(
&self,
reference_sequences: &'rs ReferenceSequences
) -> Option<Result<&'rs ReferenceSequence>>
Returns the associated reference sequence.
Examples
use noodles_sam::{self as sam, header::ReferenceSequences, RecordExt};
let record = sam::Record::default();
let reference_sequences = ReferenceSequences::default();
assert!(record.reference_sequence(&reference_sequences).is_none());
sourcefn alignment_start(&self) -> Option<Position>
fn alignment_start(&self) -> Option<Position>
Returns the start position.
Examples
use noodles_sam::{self as sam, RecordExt};
let record = sam::Record::default();
assert!(record.alignment_start().is_none());
sourcefn alignment_span(&self) -> Result<u32>
fn alignment_span(&self) -> Result<u32>
Calculates the alignment span over the reference sequence.
Examples
use noodles_sam::{self as sam, RecordExt};
let record = sam::Record::default();
assert_eq!(record.alignment_span()?, 0);
sourcefn mate_reference_sequence<'rs>(
&self,
reference_sequences: &'rs ReferenceSequences
) -> Option<Result<&'rs ReferenceSequence>>
fn mate_reference_sequence<'rs>(
&self,
reference_sequences: &'rs ReferenceSequences
) -> Option<Result<&'rs ReferenceSequence>>
Returns the associated reference sequence of the mate.
Examples
use noodles_sam::{self as sam, header::ReferenceSequences, RecordExt};
let record = sam::Record::default();
let reference_sequences = ReferenceSequences::default();
assert!(record.mate_reference_sequence(&reference_sequences).is_none());
impl StructuralPartialEq for Record
Auto Trait Implementations
impl RefUnwindSafe for Record
impl Send for Record
impl Sync for Record
impl Unpin for Record
impl UnwindSafe for Record
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more