window.hpp

Go to the documentation of this file.

#ifndef GENESIS_POPULATION_WINDOW_WINDOW_H_
#define GENESIS_POPULATION_WINDOW_WINDOW_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 <lczech@carnegiescience.edu>
    Department of Plant Biology, Carnegie Institution For Science
    260 Panama Street, Stanford, CA 94305, USA
*/
 
#include <cassert>
#include <deque>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "genesis/population/window/base_window.hpp"
#include "genesis/population/genome_region.hpp"
 
namespace genesis {
namespace population {
 
// =================================================================================================
//     Auxiliary Structures
// =================================================================================================
 
struct EmptyAccumulator
{};
 
// =================================================================================================
//     Genomic Window
// =================================================================================================
 
template<class D, class A = EmptyAccumulator>
class Window final : public BaseWindow<D>
{
public:
 
    // -------------------------------------------------------------------------
    //     Typedefs and Enums
    // -------------------------------------------------------------------------
 
    using Data = D;
    using Accumulator = A;
 
    struct Entry
    {
        Entry( size_t index, size_t position, Data const& data )
            : index(index)
            , position(position)
            , data(data)
        {}
 
        Entry( size_t index, size_t position, Data&& data )
            : index(index)
            , position(position)
            , data(std::move( data ))
        {}
 
        operator Data&()
        {
            return data;
        }
 
        operator Data const&() const
        {
            return data;
        }
 
        size_t index;
 
        size_t position;
 
        Data data;
    };
 
    using self_type       = Window<Data, Accumulator>;
    using container       = std::deque<Entry>;
 
    using value_type      = Entry;
    using reference       = value_type&;
    using const_reference = value_type const&;
 
    using iterator               = typename container::iterator;
    using const_iterator         = typename container::const_iterator;
    using reverse_iterator       = typename container::reverse_iterator;
    using const_reverse_iterator = typename container::const_reverse_iterator;
 
    using difference_type = typename container::difference_type;
    using size_type       = typename container::size_type;
 
    // -------------------------------------------------------------------------
    //     Constructors and Rule of Five
    // -------------------------------------------------------------------------
 
    Window() = default;
    virtual ~Window() override = default;
 
    Window( Window const& ) = default;
    Window( Window&& )      = default;
 
    Window& operator= ( Window const& ) = default;
    Window& operator= ( Window&& )      = default;
 
    // -------------------------------------------------------------------------
    //     General Properties
    // -------------------------------------------------------------------------
 
    size_t entry_count() const
    {
        return entries_.size();
    }
 
    size_t size() const
    {
        return entries_.size();
    }
 
    bool empty() const
    {
        return entries_.empty();
    }
 
    double saturation() const
    {
        double const es = static_cast<double>( entries_.size() );
        double const wd = static_cast<double>( this->width() );
        double const frac = es / wd;
 
        assert( this->width() > 0 );
        assert( frac >= 0.0 );
        assert( frac <= 1.0 );
        return frac;
    }
 
    size_t span() const
    {
        if( entries_.empty() ) {
            return 0;
        }
        return entries_.back().position - entries_.front().position + 1;
    }
 
    // -------------------------------------------------------------------------
    //     Data Accessors
    // -------------------------------------------------------------------------
 
    reference operator[]( size_t index )
    {
        assert( index < entries_.size() );
        return entries_[ index ];
    }
 
    const_reference operator[]( size_t index ) const
    {
        assert( index < entries_.size() );
        return entries_[ index ];
    }
 
    reference at( size_t index )
    {
        return entries_.at( index );
    }
 
    const_reference at( size_t index ) const
    {
        return entries_.at( index );
    }
 
    iterator begin()
    {
        return entries_.begin();
    }
 
    const_iterator begin() const
    {
        return entries_.begin();
    }
 
    iterator end()
    {
        return entries_.end();
    }
 
    const_iterator end() const
    {
        return entries_.end();
    }
 
    container const& entries() const
    {
        return entries_;
    }
 
    container& entries()
    {
        return entries_;
    }
 
    Accumulator& accumulator()
    {
        return accumulator_;
    }
 
 
    Accumulator const& accumulator() const
    {
        return accumulator_;
    }
 
    // -------------------------------------------------------------------------
    //     Modifiers and Helpers
    // -------------------------------------------------------------------------
 
    void validate() const
    {
        if( this->first_position() == 0 ) {
            throw std::runtime_error( "Invalid Window with first_position() == 0." );
        }
        if( this->last_position() < this->first_position() ) {
            throw std::runtime_error( "Invalid Window with last_position() < first_position()." );
        }
        for( auto const& entry : entries_ ) {
            if( entry.position < this->first_position() || entry.position > this->last_position() ) {
                throw std::runtime_error(
                    "Invalid Window::Entry in chromosome " + this->chromosome() + " at position " +
                    std::to_string( entry.position ) +
                    ", which is not between the window boundaries [" +
                    std::to_string( this->first_position() ) + "," +
                    std::to_string( this->last_position() ) + "]."
                );
            }
        }
    }
 
    // -------------------------------------------------------------------------
    //     Virtual Members
    // -------------------------------------------------------------------------
 
private:
 
    virtual void clear_() override
    {
        accumulator_   = Accumulator{};
        entries_       = container{};
    }
 
    // -------------------------------------------------------------------------
    //     Data Members
    // -------------------------------------------------------------------------
 
private:
 
    Accumulator accumulator_;
    container entries_;
 
};
 
} // namespace population
} // namespace genesis
 
#endif // include guard