Struct noodles::csi::binning_index::index::reference_sequence::ReferenceSequence

pub struct ReferenceSequence<I> { /* private fields */ }

A binning index reference sequence.

Implementations

impl<I> ReferenceSequence<I>

where I: Index,

pub fn new( bins: IndexMap<usize, Bin>, index: I, metadata: Option<Metadata> ) -> ReferenceSequence<I>

Creates a binning index reference sequence.

Examples

use noodles_csi::binning_index::index::ReferenceSequence;
let reference_sequence = ReferenceSequence::new(Default::default(), Vec::new(), None);

pub fn bins(&self) -> &IndexMap<usize, Bin>

Returns the list of bins in the reference sequence.

This list does not include the metadata pseudo-bin. Use binning_index::ReferenceSequence::metadata instead.

Examples

use noodles_csi::binning_index::index::ReferenceSequence;
let reference_sequence = ReferenceSequence::new(Default::default(), Vec::new(), None);
assert!(reference_sequence.bins().is_empty());

pub fn index(&self) -> &I

Returns the index.

The index is optional and can be empty.

pub fn query<J>( &self, min_shift: u8, depth: u8, interval: J ) -> Result<Vec<&Bin>, Error>

where J: Into<Interval>,

Returns a list of bins in this reference sequence that intersects the given range.

The interval values are 1-based.

Examples

use noodles_core::Position;
use noodles_csi::binning_index::index::ReferenceSequence;

let reference_sequence = ReferenceSequence::new(Default::default(), Vec::new(), None);
let start = Position::try_from(8)?;
let end = Position::try_from(13)?;

let query_bins = reference_sequence.query(14, 5, start..=end)?;
assert!(query_bins.is_empty());

pub fn min_offset( &self, min_shift: u8, depth: u8, start: Position ) -> VirtualPosition

Finds the start virtual position of the first record in the bin that contains that given start position.

Examples

use noodles_bgzf as bgzf;
use noodles_core::Position;
use noodles_csi::binning_index::index::{
    reference_sequence::{index::BinnedIndex, Bin},
    ReferenceSequence,
};

const MIN_SHIFT: u8 = 4;
const DEPTH: u8 = 2;

let bins = [(1, Bin::new(Vec::new()))].into_iter().collect();
let index = [(1, bgzf::VirtualPosition::from(233))].into_iter().collect();
let reference_sequence: ReferenceSequence<BinnedIndex> = ReferenceSequence::new(bins, index, None);

let start = Position::try_from(8)?;
assert_eq!(
    reference_sequence.min_offset(MIN_SHIFT, DEPTH, start),
    bgzf::VirtualPosition::from(233)
);

let start = Position::try_from(144)?;
assert_eq!(
    reference_sequence.min_offset(MIN_SHIFT, DEPTH, start),
    bgzf::VirtualPosition::default()
);

pub fn first_record_in_last_linear_bin_start_position( &self ) -> Option<VirtualPosition>

Returns the start position of the first record in the last linear bin.

This uses the linear index, if available; otherwise, the largest linear offset of all the bins is returned. If there is neither a linear index nor a collection of bins, this returns None.

Examples

use noodles_bgzf as bgzf;
use noodles_csi::binning_index::index::{
    reference_sequence::{index::BinnedIndex, Bin},
    ReferenceSequence,
};

let reference_sequence = ReferenceSequence::new(
    Default::default(),
    vec![
        bgzf::VirtualPosition::from(8),
        bgzf::VirtualPosition::from(13),
        bgzf::VirtualPosition::from(21),
    ],
    None,
);
assert_eq!(
    reference_sequence.first_record_in_last_linear_bin_start_position(),
    Some(bgzf::VirtualPosition::from(21))
);

let mut reference_sequence: ReferenceSequence<BinnedIndex> = ReferenceSequence::new(
    [
        (0, Bin::new(Vec::new())),
        (2, Bin::new(Vec::new())),
        (9, Bin::new(Vec::new())),
    ]
    .into_iter()
    .collect(),
    [
        (0, bgzf::VirtualPosition::from(8)),
        (2, bgzf::VirtualPosition::from(21)),
        (9, bgzf::VirtualPosition::from(13)),
    ]
    .into_iter()
    .collect(),
    None,
);

assert_eq!(
    reference_sequence.first_record_in_last_linear_bin_start_position(),
    Some(bgzf::VirtualPosition::from(21))
);

let reference_sequence = ReferenceSequence::new(Default::default(), Vec::new(), None);
assert!(reference_sequence.first_record_in_last_linear_bin_start_position().is_none());

Trait Implementations

impl<I> Clone for ReferenceSequence<I>

where I: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I> Debug for ReferenceSequence<I>

where I: Debug,

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

Formats the value using the given formatter.

impl<I> PartialEq for ReferenceSequence<I>

where I: PartialEq,

fn eq(&self, other: &ReferenceSequence<I>) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I> ReferenceSequence for ReferenceSequence<I>

where I: Index,

fn metadata(&self) -> Option<&Metadata>

Returns the optional metadata for the reference sequence.

impl<I> Eq for ReferenceSequence<I>

where I: Eq,

impl<I> StructuralPartialEq for ReferenceSequence<I>