kmer_scanner.hpp

Go to the documentation of this file.

#ifndef GENESIS_SEQUENCE_KMER_KMER_SCANNER_H_
#define GENESIS_SEQUENCE_KMER_KMER_SCANNER_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2024 Lucas Czech
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
    Contact:
    Lucas Czech <lucas.czech@sund.ku.dk>
    University of Copenhagen, Globe Institute, Section for GeoGenetics
    Oster Voldgade 5-7, 1350 Copenhagen K, Denmark
*/
 
#include "genesis/sequence/kmer/kmer.hpp"
 
#include <array>
#include <cassert>
#include <climits>
#include <cstdint>
#include <limits>
#include <stdexcept>
#include <string>
 
namespace genesis {
namespace sequence {
 
// =================================================================================================
//     Kmer Scanner
// =================================================================================================
 
template<typename Tag>
class KmerScanner
{
public:
 
    // -------------------------------------------------------------------------
    //     Member Types
    // -------------------------------------------------------------------------
 
    using self_type         = KmerScanner;
    using value_type        = Kmer<Tag>;
    using pointer           = value_type*;
    using reference         = value_type&;
    using iterator_category = std::input_iterator_tag;
 
    // ======================================================================================
    //      Internal Iterator
    // ======================================================================================
 
public:
 
    class Iterator
    {
        // -------------------------------------------------------------------------
        //     Typedefs and Enums
        // -------------------------------------------------------------------------
 
    public:
 
        using self_type         = KmerScanner::Iterator;
        using value_type        = Kmer<Tag>;
        using pointer           = value_type const*;
        using reference         = value_type const&;
        using iterator_category = std::input_iterator_tag;
 
        // -------------------------------------------------------------------------
        //     Constructors and Rule of Five
        // -------------------------------------------------------------------------
 
    private:
 
        Iterator() = default;
 
        Iterator( KmerScanner const* parent )
            : parent_( parent )
        {
            // Safeguard
            if( ! parent_ ) {
                return;
            }
 
            // Start streaming the data
            increment_();
        }
 
    public:
 
        ~Iterator() = default;
 
        Iterator( self_type const& ) = default;
        Iterator( self_type&& )      = default;
 
        Iterator& operator= ( self_type const& ) = default;
        Iterator& operator= ( self_type&& )      = default;
 
        friend KmerScanner;
 
        // -------------------------------------------------------------------------
        //     Iterator Accessors
        // -------------------------------------------------------------------------
 
        value_type const* operator->() const
        {
            return &kmer_;
        }
 
        value_type* operator->()
        {
            return &kmer_;
        }
 
        value_type const& operator*() const
        {
            return kmer_;
        }
 
        value_type& operator*()
        {
            return kmer_;
        }
 
        // -------------------------------------------------------------------------
        //     Iteration
        // -------------------------------------------------------------------------
 
        self_type& operator ++ ()
        {
            increment_();
            return *this;
        }
 
        bool operator==( self_type const& it ) const
        {
            return parent_ == it.parent_;
        }
 
        bool operator!=( self_type const& it ) const
        {
            return !(*this == it);
        }
 
        // -------------------------------------------------------------------------
        //     Internal Members
        // -------------------------------------------------------------------------
 
    private:
 
        // ---------------------------------------------
        //     Increment and Processing Samples
        // ---------------------------------------------
 
        void increment_()
        {
            // inc or restat
        }
 
        void init_kmer_from_position_()
        {
            assert( parent_ );
 
            while( true ) {
                if( position_ + Kmer<Tag>::k() > parent_->input.size() ) {
                    parent_ = nullptr;
                    return;
                }
                if( position_ + len == Kmer<Tag>::k() ) {
                    break;
                }
 
                encoding.char_to_rank()
            }
        }
 
        // -------------------------------------------------------------------------
        //     Data Members
        // -------------------------------------------------------------------------
 
    private:
 
        // Parent. If null, this indicates the end of the input and that we are done iterating.
        KmerScanner const* parent_ = nullptr;
 
        Kmer<Tag>::WordType kmer_;
        size_t position_ = 0;
    };
 
    // ======================================================================================
    //      Main Class
    // ======================================================================================
 
    // -------------------------------------------------------------------------
    //     Constructors and Rule of Five
    // -------------------------------------------------------------------------
 
    KmerScanner( std::string const& input )
        : input_( input )
    {}
 
    KmerScanner( std::string&& input )
        : input_( std::move( input ))
    {}
 
    KmerScanner( std::string const& input, uint8_t k )
        : input_( input )
    {
        Kmer<Tag>::set_k( k );
    }
 
    KmerScanner( std::string&& input, uint8_t k )
        : input_( std::move( input ))
    {
        Kmer<Tag>::set_k( k );
    }
 
    ~KmerScanner() = default;
 
    KmerScanner( self_type const& ) = default;
    KmerScanner( self_type&& )      = default;
 
    self_type& operator= ( self_type const& ) = default;
    self_type& operator= ( self_type&& )      = default;
 
    // -------------------------------------------------------------------------
    //     Iteration
    // -------------------------------------------------------------------------
 
    Iterator begin() const
    {
        return Iterator( this );
    }
 
    Iterator end() const
    {
        return Iterator();
    }
 
    // -------------------------------------------------------------------------
    //     Data Members
    // -------------------------------------------------------------------------
 
private:
 
    std::string input_;
 
};
 
} // namespace sequence
} // namespace genesis
 
#endif // include guard