alignment_coordinate.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <type_traits>
 
#include <seqan3/alignment/matrix/detail/matrix_coordinate.hpp>
#include <seqan3/core/detail/debug_stream_tuple.hpp>
#include <seqan3/core/detail/debug_stream_type.hpp>
#include <seqan3/core/detail/strong_type.hpp>
#include <seqan3/core/type_traits/template_inspection.hpp>
#include <seqan3/std/concepts>
#include <seqan3/std/iterator>
 
namespace seqan3::detail
{
 
enum struct advanceable_alignment_coordinate_state : uint8_t
{
    none,
    column,
    row
};
 
template <advanceable_alignment_coordinate_state state = advanceable_alignment_coordinate_state::none>
class advanceable_alignment_coordinate
{
public:
 
    using difference_type = std::make_signed_t<size_t>;
 
    constexpr advanceable_alignment_coordinate() noexcept = default;                                    
    constexpr advanceable_alignment_coordinate(advanceable_alignment_coordinate const &) noexcept = default;
    constexpr advanceable_alignment_coordinate(advanceable_alignment_coordinate &&) noexcept = default; 
    constexpr advanceable_alignment_coordinate & operator=(advanceable_alignment_coordinate const &) noexcept = default;
    constexpr advanceable_alignment_coordinate & operator=(advanceable_alignment_coordinate &&) noexcept = default;
    ~advanceable_alignment_coordinate() noexcept = default;                                             
 
    template <advanceable_alignment_coordinate_state other_state>
        requires (other_state != state)
    constexpr advanceable_alignment_coordinate(advanceable_alignment_coordinate<other_state> const & other) :
        first{other.first},
        second{other.second}
    {}
 
    template <advanceable_alignment_coordinate_state other_state>
        requires (other_state != state)
    constexpr advanceable_alignment_coordinate(advanceable_alignment_coordinate<other_state> && other) :
        first{std::move(other.first)},
        second{std::move(other.second)}
    {}
 
    constexpr advanceable_alignment_coordinate(column_index_type<size_t> const c_idx,
                                               row_index_type<size_t> const r_idx) noexcept :
        first{c_idx.get()},
        second{r_idx.get()}
    {}
 
    constexpr friend bool operator==(advanceable_alignment_coordinate const & lhs,
                                     advanceable_alignment_coordinate const & rhs) noexcept
    {
        return std::tie(lhs.first, lhs.second) == std::tie(rhs.first, rhs.second);
    }
 
    constexpr friend bool operator!=(advanceable_alignment_coordinate const & lhs,
                                     advanceable_alignment_coordinate const & rhs) noexcept
    {
        return std::tie(lhs.first, lhs.second) != std::tie(rhs.first, rhs.second);
    }
 
    constexpr friend bool operator<=(advanceable_alignment_coordinate const & lhs,
                                     advanceable_alignment_coordinate const & rhs) noexcept
    {
        return std::tie(lhs.first, lhs.second) <= std::tie(rhs.first, rhs.second);
    }
 
    constexpr friend bool operator< (advanceable_alignment_coordinate const & lhs,
                                     advanceable_alignment_coordinate const & rhs) noexcept
    {
        return std::tie(lhs.first, lhs.second) < std::tie(rhs.first, rhs.second);
    }
 
    constexpr friend bool operator>=(advanceable_alignment_coordinate const & lhs,
                                     advanceable_alignment_coordinate const & rhs) noexcept
    {
        return std::tie(lhs.first, lhs.second) >= std::tie(rhs.first, rhs.second);
    }
 
    constexpr friend bool operator> (advanceable_alignment_coordinate const & lhs,
                                     advanceable_alignment_coordinate const & rhs) noexcept
    {
        return std::tie(lhs.first, lhs.second) > std::tie(rhs.first, rhs.second);
    }
 
    constexpr advanceable_alignment_coordinate & operator++(/*pre-increment*/) noexcept
        requires (state != advanceable_alignment_coordinate_state::none)
    {
        if constexpr (state == advanceable_alignment_coordinate_state::column)
            ++this->first;
        else
            ++this->second;
        return *this;
    }
 
    constexpr advanceable_alignment_coordinate operator++(int /*post-increment*/) noexcept
        requires (state != advanceable_alignment_coordinate_state::none)
    {
        advanceable_alignment_coordinate tmp{*this};
        ++(*this);
        return tmp;
    }
 
    constexpr advanceable_alignment_coordinate & operator--(/*pre-decrement*/) noexcept
        requires (state != advanceable_alignment_coordinate_state::none)
    {
        if constexpr (state == advanceable_alignment_coordinate_state::column)
            --this->first;
        else
            --this->second;
        return *this;
    }
 
    constexpr advanceable_alignment_coordinate operator--(int /*post-decrement*/) noexcept
        requires (state != advanceable_alignment_coordinate_state::none)
    {
        advanceable_alignment_coordinate tmp{*this};
        --(*this);
        return tmp;
    }
 
    constexpr advanceable_alignment_coordinate & operator+=(difference_type const offset) noexcept
        requires (state != advanceable_alignment_coordinate_state::none)
    {
        if constexpr (state == advanceable_alignment_coordinate_state::column)
            this->first += offset;
        else
            this->second += offset;
        return *this;
    }
 
    constexpr advanceable_alignment_coordinate & operator-=(difference_type const offset) noexcept
        requires (state != advanceable_alignment_coordinate_state::none)
    {
        if constexpr (state == advanceable_alignment_coordinate_state::column)
            this->first -= offset;
        else
            this->second -= offset;
        return *this;
    }
 
    constexpr advanceable_alignment_coordinate operator+(difference_type const offset) const noexcept
        requires (state != advanceable_alignment_coordinate_state::none)
    {
        advanceable_alignment_coordinate tmp{*this};
        tmp += offset;
        return tmp;
    }
 
    constexpr advanceable_alignment_coordinate operator-(difference_type const offset) const noexcept
        requires (state != advanceable_alignment_coordinate_state::none)
    {
        advanceable_alignment_coordinate tmp{*this};
        tmp -= offset;
        return tmp;
    }
 
    constexpr difference_type operator-(advanceable_alignment_coordinate const & other) const noexcept
        requires (state != advanceable_alignment_coordinate_state::none)
    {
        if constexpr (state == advanceable_alignment_coordinate_state::column)
            return this->first - other.first;
        else
            return this->second - other.second;
    }
 
 
    constexpr friend advanceable_alignment_coordinate operator+(difference_type const offset,
                                                                advanceable_alignment_coordinate const & me) noexcept
        requires (state != advanceable_alignment_coordinate_state::none)
    {
        return me + offset;
    }
 
    size_t first{};
    size_t second{};
};
 
} // namespace seqan3::detail
 
namespace seqan3
{
 
class alignment_coordinate
    : public detail::advanceable_alignment_coordinate<detail::advanceable_alignment_coordinate_state::none>
{
    using base_t = detail::advanceable_alignment_coordinate<detail::advanceable_alignment_coordinate_state::none>;
 
public:
 
    constexpr alignment_coordinate() = default;                                         
    constexpr alignment_coordinate(alignment_coordinate const &) = default;             
    constexpr alignment_coordinate(alignment_coordinate &&) = default;                  
    constexpr alignment_coordinate & operator=(alignment_coordinate const &) = default; 
    constexpr alignment_coordinate & operator=(alignment_coordinate &&) = default;      
    ~alignment_coordinate() = default;                                                  
 
    using base_t::base_t;
 
    constexpr alignment_coordinate(base_t const & base) : base_t{base}
    {}
 
    constexpr alignment_coordinate(base_t && base) : base_t{std::move(base)}
    {}
 
    using base_t::first;
    using base_t::second;
 
    SEQAN3_DOXYGEN_ONLY(size_t first;)
    SEQAN3_DOXYGEN_ONLY(size_t second;)
 
    constexpr operator detail::matrix_coordinate() const
    {
        return detail::matrix_coordinate{detail::row_index_type{second}, detail::column_index_type{first}};
    }
};
 
template <typename char_t, typename coordinate_type>
    requires std::same_as<std::remove_cvref_t<coordinate_type>, alignment_coordinate> ||
             detail::is_value_specialisation_of_v<std::remove_cvref_t<coordinate_type>,
                                                  detail::advanceable_alignment_coordinate>
inline debug_stream_type<char_t> & operator<<(debug_stream_type<char_t> & s, coordinate_type && c)
{
    s << std::tie(c.first, c.second);
    return s;
}
 
} // namespace seqan3