base_window_iterator.hpp

Go to the documentation of this file.

#ifndef GENESIS_POPULATION_WINDOW_BASE_WINDOW_ITERATOR_H_
#define GENESIS_POPULATION_WINDOW_BASE_WINDOW_ITERATOR_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2022 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 <lczech@carnegiescience.edu>
    Department of Plant Biology, Carnegie Institution For Science
    260 Panama Street, Stanford, CA 94305, USA
*/
 
#include "genesis/population/window/window.hpp"
#include "genesis/utils/containers/range.hpp"
#include "genesis/utils/core/std.hpp"
 
#include <cassert>
#include <functional>
#include <memory>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
 
namespace genesis {
namespace population {
 
// =================================================================================================
//     Base Window Iterator
// =================================================================================================
 
template<class ForwardIterator, class DataType = typename ForwardIterator::value_type>
class BaseWindowIterator
{
public:
 
    // -------------------------------------------------------------------------
    //     Typedefs and Enums
    // -------------------------------------------------------------------------
 
    using self_type         = BaseWindowIterator<ForwardIterator, DataType>;
 
    using Window            = ::genesis::population::Window<DataType>;
    using Entry             = typename Window::Entry;
    using InputType         = typename ForwardIterator::value_type;
 
    using iterator_category = std::input_iterator_tag;
    using value_type        = Window;
    using pointer           = value_type*;
    using reference         = value_type&;
    using const_reference   = value_type const&;
 
    // -------------------------------------------------------------------------
    //     Public Functors
    // -------------------------------------------------------------------------
 
    std::function<DataType( InputType const& )> entry_input_function;
 
    std::function<std::string( InputType const& )> chromosome_function;
 
    std::function<size_t( InputType const& )> position_function;
 
    // ======================================================================================
    //      Internal Public Iterator
    // ======================================================================================
 
protected:
 
    // Forward Declaration.
    class BaseIterator;
 
public:
 
    class Iterator
    {
    public:
 
        // -------------------------------------------------------------------------
        //     Constructors and Rule of Five
        // -------------------------------------------------------------------------
 
        using self_type         = BaseWindowIterator<ForwardIterator, DataType>::Iterator;
 
        using Window            = ::genesis::population::Window<DataType>;
        using Entry             = typename Window::Entry;
        using InputType         = typename ForwardIterator::value_type;
 
        using iterator_category = std::input_iterator_tag;
        using value_type        = Window;
        using pointer           = value_type*;
        using reference         = value_type&;
        using const_reference   = value_type const&;
 
    protected:
 
        Iterator() = delete;
 
        Iterator( std::unique_ptr<BaseIterator> base_iterator )
            : pimpl_( std::move( base_iterator ))
        {}
 
    public:
 
        ~Iterator() = default;
 
        Iterator( self_type const& ) = default;
        Iterator( self_type&& )      = default;
 
        Iterator& operator= ( self_type const& ) = default;
        Iterator& operator= ( self_type&& )      = default;
 
        friend BaseWindowIterator;
 
        // -------------------------------------------------------------------------
        //     Properties
        // -------------------------------------------------------------------------
 
        bool is_first_window() const
        {
            assert( pimpl_ );
            return pimpl_->is_first_window_;
        }
 
        bool is_last_window() const
        {
            assert( pimpl_ );
            return pimpl_->is_last_window_;
        }
 
        // -------------------------------------------------------------------------
        //     Accessors
        // -------------------------------------------------------------------------
 
        value_type const & operator*() const
        {
            assert( pimpl_ );
            return pimpl_->get_current_window_();
        }
 
        value_type & operator*()
        {
            assert( pimpl_ );
            return pimpl_->get_current_window_();
        }
 
        value_type const * operator->() const
        {
            assert( pimpl_ );
            return &( pimpl_->get_current_window_() );
        }
 
        value_type * operator->()
        {
            assert( pimpl_ );
            return &( pimpl_->get_current_window_() );
        }
 
        // -------------------------------------------------------------------------
        //     Iteration
        // -------------------------------------------------------------------------
 
        self_type& operator ++()
        {
            assert( pimpl_ );
            pimpl_->increment_();
            return *this;
        }
 
        // self_type operator ++(int)
        // {
        //     auto cpy = *this;
        //     increment_();
        //     return cpy;
        // }
 
        bool operator==( self_type const& other ) const
        {
            assert( pimpl_ );
            assert( other.pimpl_ );
 
            // We compare the parents as a baseline - two past-the-end iterator shall
            // always compare equal. If only one of them is past-the-end, they will compare false.
            return pimpl_->get_parent_() == other.pimpl_->get_parent_();
        }
 
        bool operator!=( self_type const& other ) const
        {
            return !(*this == other);
        }
 
        // -------------------------------------------------------------------------
        //     PIMPL-like Implementation Abstraction
        // -------------------------------------------------------------------------
 
    private:
 
        std::unique_ptr<BaseIterator> pimpl_;
 
    };
 
    // ======================================================================================
    //      Internal Base Iterator for PIMPL-like Abstraction
    // ======================================================================================
 
protected:
 
    class BaseIterator
    {
    public:
 
        // -------------------------------------------------------------------------
        //     Constructors and Rule of Five
        // -------------------------------------------------------------------------
 
        using self_type         = BaseWindowIterator<ForwardIterator, DataType>::BaseIterator;
 
        using Window            = ::genesis::population::Window<DataType>;
        using Entry             = typename Window::Entry;
        using InputType         = typename ForwardIterator::value_type;
 
        using iterator_category = std::input_iterator_tag;
        using value_type        = Window;
        using pointer           = value_type*;
        using reference         = value_type&;
        using const_reference   = value_type const&;
 
    protected:
 
        // BaseIterator() = default;
 
        BaseIterator( BaseWindowIterator const* parent )
        {
            init_( parent );
        }
 
    public:
 
        ~BaseIterator() = default;
 
        BaseIterator( self_type const& ) = default;
        BaseIterator( self_type&& )      = default;
 
        BaseIterator& operator= ( self_type const& ) = default;
        BaseIterator& operator= ( self_type&& )      = default;
 
        friend BaseWindowIterator;
        friend Iterator;
 
        // -------------------------------------------------------------------------
        //     Internal Members
        // -------------------------------------------------------------------------
 
    protected:
 
        void init_( BaseWindowIterator const* parent )
        {
            // We use the parent as a check if this Iterator is intended to be a begin()
            // or end() iterator. If its the former, init. If the latter, we are done here.
            // After we are done iterating the input (for which we do need _its_ begin and end
            // iterators), we then set the parent_ to nullptr, as a sign that we are done.
            // This allows us also to know if we reached end() (of the window iteration;
            // not of the underlying data iterator) without having to store the end() iterator
            // when using this class.
            if( ! parent ) {
                return;
            }
 
            // Check that the functors are set up.
            if( ! parent->entry_input_function ) {
                throw std::runtime_error(
                    "Need to set BaseWindowIterator::entry_input_function "
                    "before iterating over Windows with a Window Iterator."
                );
            }
            if( ! parent->chromosome_function ) {
                throw std::runtime_error(
                    "Need to set BaseWindowIterator::chromosome_function "
                    "before iterating over Windows with a Window Iterator."
                );
            }
            if( ! parent->position_function ) {
                throw std::runtime_error(
                    "Need to set BaseWindowIterator::position_function "
                    "before iterating over Windows with a Window Iterator."
                );
            }
 
            // Copy over the underlying data iterator.
            current_ = parent->begin_;
            end_     = parent->end_;
        }
 
        // -------------------------------------------------------------------------
        //     Virtual Members
        // -------------------------------------------------------------------------
 
    protected:
 
        virtual void increment_() = 0;
 
        virtual value_type& get_current_window_() const = 0;
 
        virtual BaseWindowIterator const* get_parent_() const = 0;
 
    protected:
 
        // Need to manually keep track of those...
        bool is_first_window_ = true;
        bool is_last_window_ = false;
 
        // Underlying iterator
        ForwardIterator current_;
        ForwardIterator end_;
 
    };
 
    // ======================================================================================
    //      Main Class
    // ======================================================================================
 
public:
 
    // -------------------------------------------------------------------------
    //     Constructors and Rule of Five
    // -------------------------------------------------------------------------
 
    BaseWindowIterator(
        ForwardIterator begin, ForwardIterator end
    )
        : begin_(begin)
        , end_(end)
    {}
 
    ~BaseWindowIterator() = default;
 
    BaseWindowIterator( BaseWindowIterator const& ) = default;
    BaseWindowIterator( BaseWindowIterator&& )      = default;
 
    BaseWindowIterator& operator= ( BaseWindowIterator const& ) = default;
    BaseWindowIterator& operator= ( BaseWindowIterator&& )      = default;
 
    friend Iterator;
 
    // -------------------------------------------------------------------------
    //     Iteration
    // -------------------------------------------------------------------------
 
    Iterator begin()
    {
        return Iterator( get_begin_iterator_() );
    }
 
    Iterator end()
    {
        return Iterator( get_end_iterator_() );
    }
 
    // -------------------------------------------------------------------------
    //     Virtual Members
    // -------------------------------------------------------------------------
 
protected:
 
    virtual std::unique_ptr<BaseIterator> get_begin_iterator_() = 0;
    virtual std::unique_ptr<BaseIterator> get_end_iterator_() = 0;
 
    // -------------------------------------------------------------------------
    //     Data Members
    // -------------------------------------------------------------------------
 
private:
 
    // Underlying iterator to the data that we want to put in windows.
    ForwardIterator begin_;
    ForwardIterator end_;
 
};
 
} // namespace population
} // namespace genesis
 
#endif // include guard