align_pairwise.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 <functional>
#include <iostream>
#include <tuple>
#include <type_traits>

#include <meta/meta.hpp>

#include <seqan3/alignment/configuration/all.hpp>
#include <seqan3/alignment/pairwise/alignment_result.hpp>
#include <seqan3/alignment/pairwise/alignment_configurator.hpp>
#include <seqan3/alignment/pairwise/execution/all.hpp>
#include <seqan3/core/algorithm/all.hpp>
#include <seqan3/core/parallel/execution.hpp>
#include <seqan3/core/type_traits/basic.hpp>
#include <seqan3/range/view/persist.hpp>
#include <seqan3/std/concepts>
#include <seqan3/std/ranges>

namespace seqan3
{

template <typename exec_policy_t, typename sequence_t, typename alignment_config_t>
    requires is_execution_policy_v<exec_policy_t> &&
             detail::AlignPairwiseSingleInput<std::remove_reference_t<sequence_t>> &&
             std::CopyConstructible<std::remove_reference_t<sequence_t>> &&
             detail::is_type_specialisation_of_v<alignment_config_t, configuration>
constexpr auto align_pairwise(exec_policy_t const & exec,
                              sequence_t && seq,
                              alignment_config_t const & config)
{
    static_assert(std::tuple_size_v<std::remove_reference_t<sequence_t>> == 2,
                  "Alignment configuration error: Expects exactly two sequences for pairwise alignments.");

    static_assert(std::ranges::ViewableRange<std::tuple_element_t<0, std::remove_reference_t<sequence_t>>> &&
                  std::ranges::ViewableRange<std::tuple_element_t<1, std::remove_reference_t<sequence_t>>>,
                  "Alignment configuration error: The tuple elements must model std::ranges::ViewableRange.");

    return align_pairwise(exec, std::view::single(std::forward<sequence_t>(seq)), config);
}

template <typename sequence_t, typename alignment_config_t>
    requires detail::AlignPairwiseSingleInput<std::remove_reference_t<sequence_t>> &&
             std::CopyConstructible<std::remove_reference_t<sequence_t>> &&
             detail::is_type_specialisation_of_v<alignment_config_t, configuration>
constexpr auto align_pairwise(sequence_t && seq, alignment_config_t const & config)
{
    static_assert(std::tuple_size_v<std::remove_reference_t<sequence_t>> == 2,
                  "Alignment configuration error: Expects exactly two sequences for pairwise alignments.");

    static_assert(std::ranges::ViewableRange<std::tuple_element_t<0, std::remove_reference_t<sequence_t>>> &&
                  std::ranges::ViewableRange<std::tuple_element_t<1, std::remove_reference_t<sequence_t>>>,
                  "Alignment configuration error: The tuple elements must model std::ranges::ViewableRange.");

    return align_pairwise(seqan3::seq, std::forward<sequence_t>(seq), config);
}

template <typename sequence_t, typename alignment_config_t>
    requires detail::AlignPairwiseRangeInputConcept<sequence_t> &&
             detail::is_type_specialisation_of_v<alignment_config_t, configuration>
constexpr auto align_pairwise(sequence_t && seq, alignment_config_t const & config)
{
    return align_pairwise(seqan3::seq, std::forward<sequence_t>(seq), config);
}

template <typename exec_policy_t, typename sequence_t, typename alignment_config_t>
    requires is_execution_policy_v<exec_policy_t> &&
             detail::AlignPairwiseRangeInputConcept<sequence_t> &&
             detail::is_type_specialisation_of_v<alignment_config_t, configuration>
constexpr auto align_pairwise(exec_policy_t const & exec,
                              sequence_t && seq,
                              alignment_config_t const & config)
{
    using first_seq_t  = std::tuple_element_t<0, value_type_t<sequence_t>>;
    using second_seq_t = std::tuple_element_t<1, value_type_t<sequence_t>>;

    static_assert(std::ranges::RandomAccessRange<first_seq_t> && std::ranges::SizedRange<first_seq_t>,
                  "Alignment configuration error: The sequence must model RandomAccessRange and SizedRange.");
    static_assert(std::ranges::RandomAccessRange<second_seq_t> && std::ranges::SizedRange<second_seq_t>,
                  "Alignment configuration error: The sequence must model RandomAccessRange and SizedRange.");

    // Pipe with view::persist to allow rvalue non-view ranges.
    auto seq_view = std::forward<sequence_t>(seq) | view::persist;
    // Configure the alignment algorithm.
    auto kernel = detail::alignment_configurator::configure<decltype(seq_view)>(config);
    // Create a two-way executor for the alignment.
    detail::alignment_executor_two_way executor{std::move(seq_view), kernel, exec};
    // Return the range over the alignments.
    return alignment_range{std::move(executor)};
}

} // namespace seqan3