alignment_coordinate.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2019, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2019, 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/core/debug_stream.hpp>
#include <seqan3/core/detail/strong_type.hpp>
#include <seqan3/std/concepts>
#include <seqan3/std/iterator>

namespace seqan3::detail
{
struct column_index_type : detail::strong_type<size_t, column_index_type>
{
    using detail::strong_type<size_t, column_index_type>::strong_type;
};

struct row_index_type : detail::strong_type<size_t, row_index_type>
{
    using detail::strong_type<size_t, row_index_type>::strong_type;
};

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 !std::Same<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 !std::Same<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 const c_idx,
                                               row_index_type 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;)
};

template <typename coordinate_type>
    requires std::Same<remove_cvref_t<coordinate_type>, alignment_coordinate> ||
             detail::is_value_specialisation_of_v<remove_cvref_t<coordinate_type>,
                                                  detail::advanceable_alignment_coordinate>
inline debug_stream_type & operator<<(debug_stream_type & s, coordinate_type && c)
{
    s << std::tie(c.first, c.second);
    return s;
}

} // namespace seqan3