Struct Map

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

A SAM header record map value.

Implementations

impl Map<Header>

pub fn new(version: Version) -> Self

Creates a SAM header record header map value with a format version.

Examples

use noodles_sam::header::record::value::{
    map::{self, header::Version},
    Map,
};

let header = Map::<map::Header>::new(Version::new(1, 6));

pub fn version(&self) -> Version

Returns the format version.

Examples

use noodles_sam::header::record::value::{
    map::{self, header::Version},
    Map,
};

let header = Map::<map::Header>::new(Version::new(1, 6));
assert_eq!(header.version(), Version::new(1, 6));

pub fn version_mut(&mut self) -> &mut Version

Returns a mutable reference to the format version.

Examples

use noodles_sam::header::record::value::{map::{self, header::Version}, Map};
let mut header = Map::<map::Header>::default();
*header.version_mut() = Version::new(1, 5);
assert_eq!(header.version(), Version::new(1, 5));

impl Map<ReferenceSequence>

pub fn new(length: NonZeroUsize) -> Self

Creates a reference sequence with a length.

Examples

use std::num::NonZeroUsize;
use noodles_sam::header::record::value::{map::ReferenceSequence, Map};
let reference_sequence = Map::<ReferenceSequence>::new(NonZeroUsize::try_from(13)?);

pub fn length(&self) -> NonZeroUsize

Returns the reference sequence length.

Examples

use std::num::NonZeroUsize;
use noodles_sam::header::record::value::{map::ReferenceSequence, Map};
let reference_sequence = Map::<ReferenceSequence>::new(NonZeroUsize::try_from(13)?);
assert_eq!(usize::from(reference_sequence.length()), 13);

pub fn length_mut(&mut self) -> &mut NonZeroUsize

Returns a mutable reference to the reference sequence length.

Examples

use std::num::NonZeroUsize;

use noodles_sam::header::record::value::{map::ReferenceSequence, Map};

let length = NonZeroUsize::try_from(13)?;
let mut reference_sequence = Map::<ReferenceSequence>::new(length);
assert_eq!(reference_sequence.length(), length);

let length = NonZeroUsize::try_from(8)?;
*reference_sequence.length_mut() = length;
assert_eq!(reference_sequence.length(), length);

impl<I> Map<I>

where I: Inner,

pub fn builder() -> Builder<I>

Creates a SAM header record map value.

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

Returns the nonstandard fields in the map.

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

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

Example

use bstr::BString;
use noodles_sam::header::record::value::{map::{tag, Header}, Map};
let mut map = Map::<Header>::new(Default::default());
let nd = tag::Other::try_from([b'n', b'd'])?;
map.other_fields_mut().insert(nd, BString::from("noodles"));

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<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,