Struct BitArrayKmer 

pub struct BitArrayKmer<const K: usize, AlphabetType: Alphabet, BitArrayType = usize>
where
    BitArrayType: BitViewSized + BitStore,
{ /* private fields */ }

A k-mer stored as array of minimum-bit characters.

Trait Implementations

impl<const K: usize, AlphabetType: Alphabet, BitArrayType: BitViewSized + BitStore> Clone for BitArrayKmer<K, AlphabetType, BitArrayType>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const K: usize, AlphabetType: Debug + Alphabet, BitArrayType> Debug for BitArrayKmer<K, AlphabetType, BitArrayType>

where BitArrayType: BitViewSized + BitStore + Debug,

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

Formats the value using the given formatter.

impl<const K: usize, AlphabetType: Alphabet, BitArrayType: BitViewSized + BitStore> FromIterator<<AlphabetType as Alphabet>::CharacterType> for BitArrayKmer<K, AlphabetType, BitArrayType>

fn from_iter<T: IntoIterator<Item = AlphabetType::CharacterType>>( iter: T, ) -> Self

Creates a value from an iterator.

impl<const K: usize, AlphabetType: Alphabet, BitArrayType: BitViewSized + BitStore + BitView<Store = BitArrayType>> GenomeSequence<AlphabetType, BitVectorSubGenome<AlphabetType, BitArrayType>> for BitArrayKmer<K, AlphabetType, BitArrayType>

fn as_genome_subsequence( &self, ) -> &BitVectorSubGenome<AlphabetType, BitArrayType>

Get a reference to this genome as its subsequence type.

fn is_valid(&self) -> bool

Returns true if this genome is valid, i.e. it contains no invalid characters.

fn clone_as_vec(&self) -> Vec<u8>

Copies this genome string into a Vec.

fn as_string(&self) -> String

Returns the genome as nucleotide string.

fn reverse_complement_iter( &self, ) -> ReverseComplementIterator<Self::Iterator<'_>, AlphabetType>

Returns an iterator over the reverse complement of this genome. Panics if the iterator his an invalid character (see not valid).

fn cloned_k_mer_iter<const K: usize, KmerType: OwnedKmer<K, AlphabetType, GenomeSubsequence>>( &self, ) -> OwnedKmerIterator<'_, Self, KmerType>

Returns an iterator over the k-mers of this genome. The k-mers are cloned from this genome.

fn convert_with_reverse_complement<ReverseComplementSequence: OwnedGenomeSequence<AlphabetType, ReverseComplementSubsequence>, ReverseComplementSubsequence: GenomeSequence<AlphabetType, ReverseComplementSubsequence> + ?Sized>( &self, ) -> ReverseComplementSequence

Returns an owned copy of the reverse complement of this genome. Panics if this genome is not valid.

fn convert<ResultSequence: OwnedGenomeSequence<AlphabetType, ResultSubsequence>, ResultSubsequence: GenomeSequence<AlphabetType, ResultSubsequence> + ?Sized>( &self, ) -> ResultSequence

Returns an owned copy of this genome.

fn is_canonical(&self) -> bool

Returns true if the genome is canonical. A canonical genome is lexicographically smaller or equal to its reverse complement.

fn is_self_complemental(&self) -> bool

Returns true if the genome is self-complemental. A self-complemental genome is equivalent to its reverse complement.

impl<const K: usize, AlphabetType: Alphabet, BitArrayType: BitViewSized + BitStore> Hash for BitArrayKmer<K, AlphabetType, BitArrayType>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const K: usize, AlphabetType: Alphabet, BitArrayType: BitViewSized + BitStore + BitView<Store = BitArrayType>> Index<Range<usize>> for BitArrayKmer<K, AlphabetType, BitArrayType>

type Output = BitVectorSubGenome<AlphabetType, BitArrayType>

The returned type after indexing.

fn index(&self, index: Range<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<const K: usize, AlphabetType: Alphabet, BitArrayType: BitViewSized + BitStore + BitView<Store = BitArrayType>> Index<usize> for BitArrayKmer<K, AlphabetType, BitArrayType>

type Output = <AlphabetType as Alphabet>::CharacterType

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<const K: usize, AlphabetType: Alphabet, BitArrayType: BitViewSized + BitStore> Ord for BitArrayKmer<K, AlphabetType, BitArrayType>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<const K: usize, AlphabetType: Alphabet, BitArrayType: BitViewSized + BitStore + BitView<Store = BitArrayType>> OwnedGenomeSequence<AlphabetType, BitVectorSubGenome<AlphabetType, BitArrayType>> for BitArrayKmer<K, AlphabetType, BitArrayType>

fn clone_as_reverse_complement(&self) -> Self

Returns the reverse complement of this genome. Panics if this genome is not valid.

fn from_iter_u8<T: IntoIterator<Item = u8>>( iter: T, ) -> Result<Self, AlphabetError>

Constructs an owned genome sequence from an IntoIter over ASCII characters. If any character is not part of the alphabet, then None is returned.

fn from_slice_u8(slice: &[u8]) -> Result<Self, AlphabetError>

Constructs an owned genome sequence from a slice of ASCII characters. If any character is not part of the alphabet, then None is returned.

impl<const K: usize, AlphabetType: Alphabet, BitArrayType: BitViewSized + BitStore + BitView<Store = BitArrayType>> OwnedKmer<K, AlphabetType, BitVectorSubGenome<AlphabetType, BitArrayType>> for BitArrayKmer<K, AlphabetType, BitArrayType>

fn successor( &self, successor: <AlphabetType as Alphabet>::CharacterType, ) -> Self

Get the successor of this k-mer with the specified character.

impl<const K: usize, AlphabetType: Alphabet, BitArrayType: BitViewSized + BitStore> PartialEq for BitArrayKmer<K, AlphabetType, BitArrayType>

fn eq(&self, other: &Self) -> 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<const K: usize, AlphabetType: Alphabet, BitArrayType: BitViewSized + BitStore> PartialOrd for BitArrayKmer<K, AlphabetType, BitArrayType>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const K: usize, AlphabetType: Alphabet, BitArrayType: BitViewSized + BitStore + BitView<Store = BitArrayType>> Sequence<<AlphabetType as Alphabet>::CharacterType, BitVectorSubGenome<AlphabetType, BitArrayType>> for BitArrayKmer<K, AlphabetType, BitArrayType>

type Iterator<'a> = BitVectorSubGenomeIterator<'a, AlphabetType, BitArrayType> where Self: 'a, AlphabetType::CharacterType: 'a

The iterator type of the sequence.

fn iter(&self) -> Self::Iterator<'_>

Returns an iterator over the sequence.

fn len(&self) -> usize

Returns the length of the sequence.

fn prefix(&self, len: usize) -> &Subsequence

Returns a prefix with length len of this sequence. Panics if len >= self.len().

fn suffix(&self, len: usize) -> &Subsequence

Returns a suffix with length len of this sequence. Panics if len >= self.len().

fn is_empty(&self) -> bool

Returns true if the sequence is empty.

fn first(&self) -> Option<&Item>

Returns the first item of the sequence.

fn last(&self) -> Option<&Item>

Returns the last item of the sequence.

fn is_proper_subsequence_of(&self, other: &Self) -> bool

where Item: Eq,

Returns true if this is a proper subsequence of the given sequence. Proper means that the sequences are not equal.

fn contains(&self, item: &Item) -> bool

where Item: Eq,

Returns true if this sequence contains the given item.

fn forward_merge_iter_assume_mergeable<'a>( &'a self, suffix: &'a Self, ) -> Chain<Self::Iterator<'a>, Skip<Self::Iterator<'a>>>

where Item: Eq,

Returns an iterator over this sequence merged before the given other sequence under the assumption that the sequences can be merged this way. A merge is possible if a non-empty suffix of this sequence equals a non-empty prefix of the other sequence.

fn backward_merge_iter_assume_mergeable<'a>( &'a self, suffix: &'a Self, ) -> Chain<Self::Iterator<'a>, Skip<Self::Iterator<'a>>>

where Item: Eq,

Returns an iterator over this sequence merged after the given other sequence under the assumption that the sequences can be merged this way. A merge is possible if a non-empty prefix of this sequence equals a non-empty suffix of the other sequence.

fn to_debug_string(&self) -> String

where Item: Debug,

Converts the sequence to a string using the debug formatting of the items.

impl<const K: usize, AlphabetType: Alphabet, BitArrayType: BitViewSized + BitStore + Copy> Copy for BitArrayKmer<K, AlphabetType, BitArrayType>

impl<const K: usize, AlphabetType: Alphabet, BitArrayType: BitViewSized + BitStore> Eq for BitArrayKmer<K, AlphabetType, BitArrayType>

impl<const K: usize, AlphabetType: Alphabet, BitArrayType: BitViewSized + BitStore + BitView<Store = BitArrayType>> OwnedSequence<<AlphabetType as Alphabet>::CharacterType, BitVectorSubGenome<AlphabetType, BitArrayType>> for BitArrayKmer<K, AlphabetType, BitArrayType>