Struct Map

pub struct Map<I>
where
    I: Inner,
{ /* private fields */ }

A VCF header map value.

Implementations

impl Map<AlternativeAllele>

pub fn new<D>(description: D) -> Self

where D: Into<String>,

Creates a VCF header alternative allele map value.

Examples

use noodles_vcf::header::record::value::{map::AlternativeAllele, Map};
let map = Map::<AlternativeAllele>::new("Deletion");

impl Map<Contig>

pub fn new() -> Self

Creates a VCF header contig map value.

Examples

use noodles_vcf::header::record::value::{map::Contig, Map};
let map = Map::<Contig>::new();

pub fn length(&self) -> Option<usize>

Returns the length.

Examples

use noodles_vcf::header::record::value::{map::Contig, Map};
let map = Map::<Contig>::new();
assert!(map.length().is_none());

pub fn length_mut(&mut self) -> &mut Option<usize>

Returns a mutable reference to the length.

Examples

use noodles_vcf::header::record::value::{map::Contig, Map};

let mut map = Map::<Contig>::new();
assert!(map.length().is_none());

*map.length_mut() = Some(8);
assert_eq!(map.length(), Some(8));

pub fn md5(&self) -> Option<&str>

Returns the MD5 hexdigest.

Examples

use noodles_vcf::header::record::value::{map::Contig, Map};
let map = Map::<Contig>::new();
assert!(map.md5().is_none());

pub fn md5_mut(&mut self) -> &mut Option<String>

Returns a mutable reference to the MD5 hexdigest.

Examples

use noodles_vcf::header::record::value::{map::Contig, Map};

let mut map = Map::<Contig>::new();
assert!(map.md5().is_none());

*map.md5_mut() = Some(String::from("d7eba311421bbc9d3ada44709dd61534"));
assert_eq!(map.md5(), Some("d7eba311421bbc9d3ada44709dd61534"));

pub fn url(&self) -> Option<&str>

Returns the URL.

Examples

use noodles_vcf::header::record::value::{map::Contig, Map};
let map = Map::<Contig>::new();
assert!(map.url().is_none());

pub fn url_mut(&mut self) -> &mut Option<String>

Returns a mutable reference to the URL.

Examples

use noodles_vcf::header::record::value::{map::Contig, Map};

let mut map = Map::<Contig>::new();
assert!(map.url().is_none());

*map.url_mut() = Some(String::from("https://example.com/reference.fa"));
assert_eq!(map.url(), Some("https://example.com/reference.fa"));

impl Map<Filter>

pub fn pass() -> Self

Creates a default VCF header filter map value for “PASS”.

Examples

use noodles_vcf::header::record::value::{map::Filter, Map};
let actual = Map::<Filter>::pass();
let expected = Map::<Filter>::new("All filters passed");
assert_eq!(actual, expected);

pub fn new<D>(description: D) -> Self

where D: Into<String>,

Creates a VCF header filter map value.

Examples

use noodles_vcf::header::record::value::{map::Filter, Map};
let map = Map::<Filter>::new("Quality below 10");

impl Map<Format>

pub fn new<D>(number: Number, ty: Type, description: D) -> Self

where D: Into<String>,

Creates a VCF header format map value.

Examples

use noodles_vcf::{
    header::record::value::{map::{format::{Number, Type}, Format}, Map},
    variant::record::samples::keys::key,
};

let id = key::GENOTYPE;
let map = Map::<Format>::new(Number::Count(1), Type::String, "Genotype");

impl Map<Info>

pub fn new<D>(number: Number, ty: Type, description: D) -> Self

where D: Into<String>,

Creates a VCF header info map value.

Examples

use noodles_vcf::{
    header::record::value::{map::{info::{Number, Type}, Info}, Map},
    variant::record::info::field::key,
};

let id = key::SAMPLES_WITH_DATA_COUNT;
let map = Map::<Info>::new(
    Number::Count(1),
    Type::Integer,
    "Number of samples with data",
);

impl Map<Other>

pub fn new() -> Self

Creates a nonstandard VCF header map value.

Examples

use noodles_vcf::header::record::value::{map::Other, Map};
let map = Map::<Other>::new();

impl<I> Map<I>

where I: Inner,

pub fn builder() -> Builder<I>

Creates a VCF header map value builder.

pub fn other_fields(&self) -> &IndexMap<Other<I::StandardTag>, String>

Returns the nonstandard fields in the map.

pub fn other_fields_mut( &mut self, ) -> &mut IndexMap<Other<I::StandardTag>, String>

Returns a mutable reference to the nonstandard fields in the map.

Examples

use noodles_vcf::header::record::value::{map::Filter, Map};

let tag = match "noodles".parse() {
    Ok(tag) => tag,
    Err(_) => unreachable!(),
};

let mut map = Map::<Filter>::pass();
map.other_fields_mut().insert(tag, String::from("vcf"));

impl<I> Map<I>

where I: Typed,

pub fn number(&self) -> I::Number

Returns the cardinality of the field value.

pub fn number_mut(&mut self) -> &mut I::Number

Returns a mutable reference to the number.

pub fn ty(&self) -> I::Type

Returns the type of the field value.

pub fn type_mut(&mut self) -> &mut I::Type

Returns a mutable reference to the type.

impl<I> Map<I>

where I: Described,

pub fn description(&self) -> &str

Returns the description.

pub fn description_mut(&mut self) -> &mut String

Returns a mutable reference to the description.

impl<I> Map<I>

where I: Indexed,

pub fn idx(&self) -> Option<usize>

Returns the index of the ID in the dictionary of strings.

pub fn idx_mut(&mut self) -> &mut Option<usize>

Returns a mutable reference to the index.

Trait Implementations

impl<I> Clone for Map<I>

where I: Inner + Clone, I::StandardTag: Clone,

fn clone(&self) -> Map<I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I> Debug for Map<I>

where I: Inner + Debug, I::StandardTag: Debug,

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

Formats the value using the given formatter.

impl<I> Default for Map<I>

where I: Inner + Default,

fn default() -> Self

Returns the “default value” for a type.

impl From<&str> for Map<Format>

fn from(key: &str) -> Self

Converts to this type from the input type.

impl From<&str> for Map<Info>

fn from(key: &str) -> Self

Converts to this type from the input type.

impl From<(FileFormat, &str)> for Map<Format>

fn from((file_format, key): (FileFormat, &str)) -> Self

Converts to this type from the input type.

impl From<(FileFormat, &str)> for Map<Info>

fn from((file_format, key): (FileFormat, &str)) -> Self

Converts to this type from the input type.

impl<I> PartialEq for Map<I>

where I: Inner + PartialEq, I::StandardTag: PartialEq,

fn eq(&self, other: &Map<I>) -> 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<I> Eq for Map<I>

where I: Inner + Eq, I::StandardTag: Eq,

impl<I> StructuralPartialEq for Map<I>

where I: Inner,