Struct noodles_vcf::record::Record

pub struct Record { /* private fields */ }

A VCF record.

A VCF record has 8 required fields: chromosome (CHROM), position (POS), IDs (ID), reference bases (REF), alternate bases (ALT), quality score (QUAL), filters (FILTER), and information (INFO).

Additionally, each record can have genotype information. This adds the extra FORMAT field and a number of genotype fields.

Implementations

impl Record

pub fn try_from_str(s: &str, header: &Header) -> Result<Self, ParseError>

Parses a raw VCF record.

pub fn builder() -> Builder

Returns a builder to create a record from each of its fields.

Examples

use noodles_vcf as vcf;
let builder = vcf::Record::builder();

pub fn chromosome(&self) -> &Chromosome

Returns the chromosome of the record.

The chromosome is either a reference sequence name or a symbol (<identifier>).

This is a required field and guaranteed to be set.

Examples

use noodles_vcf::{self as vcf, record::{Chromosome, Position}};

let record = vcf::Record::builder()
    .set_chromosome("sq0".parse()?)
    .set_position(Position::from(1))
    .set_reference_bases("A".parse()?)
    .build()?;

assert_eq!(record.chromosome(), &Chromosome::Name(String::from("sq0")));

pub fn chromosome_mut(&mut self) -> &mut Chromosome

Returns a mutable reference to the chromosome.

Examples

use noodles_vcf::{self as vcf, record::{Chromosome, Position}};

let mut record = vcf::Record::builder()
    .set_chromosome("sq0".parse()?)
    .set_position(Position::from(1))
    .set_reference_bases("A".parse()?)
    .build()?;

*record.chromosome_mut() = "sq1".parse()?;

assert_eq!(record.chromosome().to_string(), "sq1");

pub fn position(&self) -> Position

Returns the start position of the reference bases or indicates a telomeric breakend.

This field is overloaded. If the record represents a telomere, the telomeric breakends are set to 0 and n + 1, where n is the length of the chromosome. Otherwise, it is a 1-based start position of the reference bases.

This is a required field. It is guaranteed to be set and >= 0.

Examples

use noodles_vcf::{self as vcf, record::Position};

let record = vcf::Record::builder()
    .set_chromosome("sq0".parse()?)
    .set_position(Position::from(8))
    .set_reference_bases("A".parse()?)
    .build()?;

assert_eq!(usize::from(record.position()), 8);

pub fn position_mut(&mut self) -> &mut Position

Returns a mutable reference to the start position of the reference bases.

This field is overloaded. If the record represents a telomere, the telomeric breakends are set to 0 and n + 1, where n is the length of the chromosome. Otherwise, it is a 1-based start position of the reference bases.

Examples

use noodles_vcf::{self as vcf, record::Position};

let mut record = vcf::Record::builder()
    .set_chromosome("sq0".parse()?)
    .set_position(Position::from(8))
    .set_reference_bases("A".parse()?)
    .build()?;

*record.position_mut() = Position::from(13);

assert_eq!(usize::from(record.position()), 13);

pub fn ids(&self) -> &Ids

Returns a list of IDs of the record.

Examples

use noodles_vcf::{self as vcf, record::Position};

let record = vcf::Record::builder()
    .set_chromosome("sq0".parse()?)
    .set_position(Position::from(1))
    .set_ids("nd0".parse()?)
    .set_reference_bases("A".parse()?)
    .build()?;

assert_eq!(*record.ids(), "nd0".parse()?);

pub fn ids_mut(&mut self) -> &mut Ids

Returns a mutable reference to the IDs.

Examples

use noodles_vcf::{self as vcf, record::{Ids, Position}};

let mut record = vcf::Record::builder()
    .set_chromosome("sq0".parse()?)
    .set_position(Position::from(1))
    .set_reference_bases("A".parse()?)
    .build()?;

let ids: Ids = "nd0".parse()?;
*record.ids_mut() = ids.clone();

assert_eq!(record.ids(), &ids);

pub fn reference_bases(&self) -> &ReferenceBases

Returns the reference bases of the record.

This is a required field and guaranteed to be nonempty.

Examples

use noodles_vcf::{
    self as vcf,
    record::{reference_bases::Base, Position, ReferenceBases},
};

let record = vcf::Record::builder()
    .set_chromosome("sq0".parse()?)
    .set_position(Position::from(1))
    .set_reference_bases("A".parse()?)
    .build()?;

assert_eq!(
    record.reference_bases(),
    &ReferenceBases::try_from(vec![Base::A])?,
);

pub fn reference_bases_mut(&mut self) -> &mut ReferenceBases

Returns a mutable reference to the reference bases of the record.

This is a required field and guaranteed to be nonempty.

Examples

use noodles_vcf::{
    self as vcf,
    record::{reference_bases::Base, Position, ReferenceBases},
};

let mut record = vcf::Record::builder()
    .set_chromosome("sq0".parse()?)
    .set_position(Position::from(1))
    .set_reference_bases("A".parse()?)
    .build()?;

*record.reference_bases_mut() = "T".parse()?;

assert_eq!(
    record.reference_bases(),
    &ReferenceBases::try_from(vec![Base::T])?,
);

pub fn alternate_bases(&self) -> &AlternateBases

Returns the alternate bases of the record.

Examples

use noodles_vcf::{
    self as vcf,
    record::{alternate_bases::Allele, reference_bases::Base, AlternateBases, Position},
};

let record = vcf::Record::builder()
    .set_chromosome("sq0".parse()?)
    .set_position(Position::from(1))
    .set_reference_bases("A".parse()?)
    .set_alternate_bases("C".parse()?)
    .build()?;

assert_eq!(
    record.alternate_bases(),
    &AlternateBases::from(vec![Allele::Bases(vec![Base::C])]),
);

pub fn alternate_bases_mut(&mut self) -> &mut AlternateBases

Returns a mutable reference to the alternate bases of the record.

Examples

use noodles_vcf::{
    self as vcf,
    record::{alternate_bases::Allele, reference_bases::Base, AlternateBases, Position},
};

let mut record = vcf::Record::builder()
    .set_chromosome("sq0".parse()?)
    .set_position(Position::from(1))
    .set_reference_bases("A".parse()?)
    .build()?;

*record.alternate_bases_mut() = "C".parse()?;

assert_eq!(
    record.alternate_bases(),
    &AlternateBases::from(vec![Allele::Bases(vec![Base::C])]),
);

pub fn quality_score(&self) -> Option<QualityScore>

Returns the quality score of the record.

The quality score is a Phred quality score.

Examples

use noodles_vcf::{self as vcf, record::{Position, QualityScore}};

let record = vcf::Record::builder()
    .set_chromosome("sq0".parse()?)
    .set_position(Position::from(1))
    .set_reference_bases("A".parse()?)
    .set_quality_score(QualityScore::try_from(13.0)?)
    .build()?;

assert_eq!(record.quality_score().map(f32::from), Some(13.0));

pub fn quality_score_mut(&mut self) -> &mut Option<QualityScore>

Returns a mutable reference to the quality score.

Examples

use noodles_vcf::{self as vcf, record::{Position, QualityScore}};

let mut record = vcf::Record::builder()
    .set_chromosome("sq0".parse()?)
    .set_position(Position::from(1))
    .set_reference_bases("A".parse()?)
    .build()?;

*record.quality_score_mut() = QualityScore::try_from(13.0).map(Some)?;

assert_eq!(record.quality_score().map(f32::from), Some(13.0));

pub fn filters(&self) -> Option<&Filters>

Returns the filters of the record.

The filters can either be pass (PASS), a list of filter names that caused the record to fail, (e.g., q10), or missing (.).

Examples

use noodles_vcf::{self as vcf, record::{Filters, Position}};

let record = vcf::Record::builder()
    .set_chromosome("sq0".parse()?)
    .set_position(Position::from(1))
    .set_reference_bases("A".parse()?)
    .set_filters(Filters::Pass)
    .build()?;

assert_eq!(record.filters(), Some(&Filters::Pass));

pub fn filters_mut(&mut self) -> &mut Option<Filters>

Returns a mutable reference to the filters.

Examples

use noodles_vcf::{self as vcf, record::{Filters, Position}};

let mut record = vcf::Record::builder()
    .set_chromosome("sq0".parse()?)
    .set_position(Position::from(1))
    .set_reference_bases("A".parse()?)
    .build()?;

*record.filters_mut() = Some(Filters::Pass);

assert_eq!(record.filters(), Some(&Filters::Pass));

pub fn info(&self) -> &Info

Returns the addition information of the record.

Examples

use noodles_vcf::{
    self as vcf,
    header::info::Key,
    record::{info::{field::Value, Field}, Info, Position},
};

let record = vcf::Record::builder()
    .set_chromosome("sq0".parse()?)
    .set_position(Position::from(1))
    .set_reference_bases("A".parse()?)
    .set_alternate_bases("C".parse()?)
    .set_info("NS=3;AF=0.5".parse()?)
    .build()?;

let expected = Info::try_from(vec![
    Field::new(Key::SamplesWithDataCount, Some(Value::Integer(3))),
    Field::new(Key::AlleleFrequencies, Some(Value::FloatArray(vec![Some(0.5)]))),
])?;

assert_eq!(record.info(), &expected);

pub fn info_mut(&mut self) -> &mut Info

Returns a mutable reference to the additional info fields.

Examples

use noodles_vcf::{
    self as vcf,
    header::info::Key,
    record::{info::{field::Value, Field}, Info, Position},
};

let mut record = vcf::Record::builder()
    .set_chromosome("sq0".parse()?)
    .set_position(Position::from(1))
    .set_reference_bases("A".parse()?)
    .set_alternate_bases("C".parse()?)
    .set_info("NS=3;AF=0.5".parse()?)
    .build()?;

let dp = Field::new(Key::TotalDepth, Some(Value::Integer(13)));
record.info_mut().insert(dp.clone());

let expected = Info::try_from(vec![
    Field::new(Key::SamplesWithDataCount, Some(Value::Integer(3))),
    Field::new(Key::AlleleFrequencies, Some(Value::FloatArray(vec![Some(0.5)]))),
    dp,
])?;

assert_eq!(record.info(), &expected);

pub fn format(&self) -> &Keys

Returns the format of the genotypes of the record.

Examples

use noodles_vcf::{
    self as vcf,
    header::{format::Key, Format},
    record::{genotypes::{Genotype, Keys}, Genotypes, Position},
};

let header = vcf::Header::builder()
    .add_format(Format::from(Key::Genotype))
    .add_format(Format::from(Key::ConditionalGenotypeQuality))
    .build();

let keys = "GT:GQ".parse()?;
let genotypes = vec![Genotype::parse("0|0:13", header.formats(), &keys)?];

let record = vcf::Record::builder()
    .set_chromosome("sq0".parse()?)
    .set_position(Position::from(1))
    .set_reference_bases("A".parse()?)
    .set_genotypes(Genotypes::new(keys, genotypes))
    .build()?;

assert_eq!(record.format(), &Keys::try_from(vec![
    Key::Genotype,
    Key::ConditionalGenotypeQuality,
])?);

pub fn genotypes(&self) -> &Genotypes

Returns the genotypes of the record.

Examples

use noodles_vcf::{
    self as vcf,
    header::format::Key,
    record::{
        genotypes::{genotype::{field::Value, Field}, Genotype, Genotypes},
        Position,
    },
};

let keys = "GT:GQ".parse()?;
let genotypes = Genotypes::new(
    keys,
    vec![Genotype::try_from(vec![
        Field::new(Key::Genotype, Some(Value::String(String::from("0|0")))),
        Field::new(Key::ConditionalGenotypeQuality, Some(Value::Integer(13))),
    ])?],
);

let record = vcf::Record::builder()
    .set_chromosome("sq0".parse()?)
    .set_position(Position::from(1))
    .set_reference_bases("A".parse()?)
    .set_genotypes(genotypes.clone())
    .build()?;


assert_eq!(record.genotypes(), &genotypes);

pub fn genotypes_mut(&mut self) -> &mut Genotypes

Returns a mutable reference to the genotypes of the record.

Examples

use noodles_vcf::{
    self as vcf,
    header::format::Key,
    record::{
        genotypes::{genotype::{field::Value, Field}, Genotype, Genotypes},
        Position,
    },
};

let mut record = vcf::Record::builder()
    .set_chromosome("sq0".parse()?)
    .set_position(Position::from(1))
    .set_reference_bases("A".parse()?)
    .build()?;

let keys = "GT:GQ".parse()?;
let genotypes = Genotypes::new(
    keys,
    vec![Genotype::try_from(vec![
        Field::new(Key::Genotype, Some(Value::String(String::from("0|0")))),
        Field::new(Key::ConditionalGenotypeQuality, Some(Value::Integer(13))),
    ])?],
);

*record.genotypes_mut() = genotypes.clone();

assert_eq!(record.genotypes(), &genotypes);

impl Record

pub fn end(&self) -> Result<Position, EndError>

Returns or calculates the end position on the reference sequence.

If available, this returns the value of the END INFO field. Otherwise, it is calculated using the start position and reference bases length.

The end position is 1-based, inclusive.

Examples

From the END INFO field value

use noodles_vcf::{self as vcf, record::{Chromosome, Position}};

let record = vcf::Record::builder()
    .set_chromosome("sq0".parse()?)
    .set_position(Position::from(1))
    .set_reference_bases("ACGT".parse()?)
    .set_info("END=8".parse()?)
    .build()?;

assert_eq!(record.end(), Ok(Position::from(8)));

Calculated using the start position and reference bases length

use noodles_vcf::{self as vcf, record::{Chromosome, Position}};

let record = vcf::Record::builder()
    .set_chromosome("sq0".parse()?)
    .set_position(Position::from(1))
    .set_reference_bases("ACGT".parse()?)
    .build()?;

assert_eq!(record.end(), Ok(Position::from(4)));

Trait Implementations

impl Clone for Record

fn clone(&self) -> Record

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Record

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

Formats the value using the given formatter.

impl Display for Record

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

Formats the value using the given formatter.

impl FromStr for Record

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq<Record> for Record

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

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

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

This method tests for !=.

impl StructuralPartialEq for Record