Struct ArrayKmer 

pub struct ArrayKmer<const K: usize, AlphabetType: Alphabet> { /* private fields */ }

A k-mer stored as array of plain characters.

Trait Implementations

impl<const K: usize, AlphabetType: Clone + Alphabet> Clone for ArrayKmer<K, AlphabetType>

where AlphabetType::CharacterType: Clone,

fn clone(&self) -> ArrayKmer<K, AlphabetType>

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> Debug for ArrayKmer<K, AlphabetType>

where AlphabetType::CharacterType: Debug,

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

Formats the value using the given formatter.

impl<const K: usize, AlphabetType: Alphabet> FromIterator<<AlphabetType as Alphabet>::CharacterType> for ArrayKmer<K, AlphabetType>

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

Creates a value from an iterator.

impl<const K: usize, AlphabetType: Alphabet> GenomeSequence<AlphabetType, SliceSubGenome<AlphabetType>> for ArrayKmer<K, AlphabetType>

fn as_genome_subsequence(&self) -> &SliceSubGenome<AlphabetType>

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> GenomeSequenceMut<AlphabetType, SliceSubGenome<AlphabetType>> for ArrayKmer<K, AlphabetType>

fn as_genome_subsequence_mut(&mut self) -> &mut SliceSubGenome<AlphabetType>

Get a reference to this genome as its subsequence type.

impl<const K: usize, AlphabetType: Hash + Alphabet> Hash for ArrayKmer<K, AlphabetType>

where AlphabetType::CharacterType: Hash,

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> Index<Range<usize>> for ArrayKmer<K, AlphabetType>

type Output = SliceSubGenome<AlphabetType>

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> Index<usize> for ArrayKmer<K, AlphabetType>

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> IndexMut<Range<usize>> for ArrayKmer<K, AlphabetType>

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

Performs the mutable indexing (container[index]) operation.

impl<const K: usize, AlphabetType: Alphabet> IndexMut<usize> for ArrayKmer<K, AlphabetType>

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

Performs the mutable indexing (container[index]) operation.

impl<const K: usize, AlphabetType: Ord + Alphabet> Ord for ArrayKmer<K, AlphabetType>

where AlphabetType::CharacterType: Ord,

fn cmp(&self, other: &ArrayKmer<K, AlphabetType>) -> 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> OwnedGenomeSequence<AlphabetType, SliceSubGenome<AlphabetType>> for ArrayKmer<K, AlphabetType>

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> OwnedKmer<K, AlphabetType, SliceSubGenome<AlphabetType>> for ArrayKmer<K, AlphabetType>

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: PartialEq + Alphabet> PartialEq for ArrayKmer<K, AlphabetType>

where AlphabetType::CharacterType: PartialEq,

fn eq(&self, other: &ArrayKmer<K, AlphabetType>) -> 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: PartialOrd + Alphabet> PartialOrd for ArrayKmer<K, AlphabetType>

where AlphabetType::CharacterType: PartialOrd,

fn partial_cmp(&self, other: &ArrayKmer<K, AlphabetType>) -> 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> Sequence<<AlphabetType as Alphabet>::CharacterType, SliceSubGenome<AlphabetType>> for ArrayKmer<K, AlphabetType>

type Iterator<'a> = Iter<'a, <AlphabetType as Alphabet>::CharacterType> 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> SequenceMut<<AlphabetType as Alphabet>::CharacterType, SliceSubGenome<AlphabetType>> for ArrayKmer<K, AlphabetType>

type IteratorMut<'a> = IterMut<'a, <AlphabetType as Alphabet>::CharacterType> where Self: 'a, AlphabetType::CharacterType: 'a

The mutable iterator type of the sequence.

fn iter_mut(&mut self) -> Self::IteratorMut<'_>

Returns a mutable iterator over the sequence.

impl<const K: usize, AlphabetType: Eq + Alphabet> Eq for ArrayKmer<K, AlphabetType>

where AlphabetType::CharacterType: Eq,

impl<const K: usize, AlphabetType: Alphabet> OwnedSequence<<AlphabetType as Alphabet>::CharacterType, SliceSubGenome<AlphabetType>> for ArrayKmer<K, AlphabetType>

impl<const K: usize, AlphabetType: Alphabet> StructuralPartialEq for ArrayKmer<K, AlphabetType>