seqan3::doxygen Namespace Reference

This is a workaround for doxygen to define re-usable shared fragments / snippets between documentation. More...

Typedefs
using	cigar_operation_table = void
using	dna15_implicit_conversion_from_rna15 = void
using	dna4_implicit_conversion_from_rna4 = void
using	dna5_implicit_conversion_from_rna5 = void
using	rna15_implicit_conversion_from_dna15 = void
using	rna4_implicit_conversion_from_dna4 = void
using	rna5_implicit_conversion_from_dna5 = void

Detailed Descriptionno-api

This is a workaround for doxygen to define re-usable shared fragments / snippets between documentation.

See also

https://github.com/doxygen/doxygen/issues/8390

Typedef Documentation

cigar_operation_table

using seqan3::doxygen::cigar_operation_table = typedef void

no-api

OP	Description
M	Alignment match (can be a sequence match or mismatch, used only in basic CIGAR representations)
I	Insertion to the reference
D	Deletion from the reference
N	Skipped region from the reference
S	Soft clipping (clipped sequences present in seqan3::sam_record::sequence)
H	Hard clipping (clipped sequences NOT present in seqan3::sam_record::sequence)
P	Padding (silent deletion from padded reference)
=	Sequence match
X	Sequence mismatch

dna15_implicit_conversion_from_rna15

using seqan3::doxygen::dna15_implicit_conversion_from_rna15 = typedef void

no-api

Normally, we do not allow implicit conversion of single argument constructors, but in this case we make an exception, because seqan3::dna15 and seqan3::rna15 are interchangeable as they behave nearly the same (e.g. same ranks, same char to rank conversion).

#include <seqan3/alphabet/nucleotide/dna15.hpp>
#include <seqan3/alphabet/nucleotide/rna15.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna15 letter1 = 'C'_rna15; // implicitly converted
    seqan3::dna15 letter2{};
    letter2 = 'C'_rna15; // implicitly converted
}

seqan3::sequences (e.g. seqan3::dna15_vector) in general aren't implicitly convertible and must be explicitly copied to be converted:

#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna15.hpp>
#include <seqan3/alphabet/nucleotide/rna15.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna15_vector vector{'A'_rna15, 'C'_rna15, 'G'_rna15}; // (element-wise) implicit conversion
 
    // but this won't work:
    // seqan3::dna15_vector dna15_vector{"ACGT"_rna15};
 
    // as a workaround you can use:
    // side note: this would also work without the implicit conversion.
    seqan3::rna15_vector rna15_vector = "ACGT"_rna15;
    seqan3::dna15_vector dna15_vector{rna15_vector.begin(), rna15_vector.end()};
}

You can avoid this copy by using std::ranges::views:

#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna15.hpp>
#include <seqan3/alphabet/nucleotide/rna15.hpp>
#include <seqan3/utility/views/convert.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna15_vector vector = "ACG"_dna15;
 
    auto rna15_view = vector | seqan3::views::convert<seqan3::rna15>;
 
    for (auto && chr: rna15_view) // converts lazily on-the-fly
    {
        static_assert(std::same_as<decltype(chr), seqan3::rna15 &&>);
    }
}

This conversion constructor only allows converting seqan3::rna15 to seqan3::dna15. Other alphabets that inherit from seqan3::rna15 will not be implicitly convertible to seqan3::dna15.

#include <seqan3/alphabet/nucleotide/dna15.hpp>
#include <seqan3/alphabet/nucleotide/rna15.hpp>
 
struct my_dna15 : public seqan3::dna15
{
    // using seqan3::dna15::dna15; // uncomment to import implicit conversion shown by letter1
};
 
struct my_rna15 : public seqan3::rna15
{};
 
int main()
{
    using namespace seqan3::literals;
 
    // my_dna15 letter1 = 'C'_rna15; // NO automatic implicit conversion!
    // seqan3::dna15 letter2 = my_rna15{}; // seqan3::dna15 only allows implicit conversion from seqan3::rna15!
}

dna4_implicit_conversion_from_rna4

using seqan3::doxygen::dna4_implicit_conversion_from_rna4 = typedef void

no-api

Normally, we do not allow implicit conversion of single argument constructors, but in this case we make an exception, because seqan3::dna4 and seqan3::rna4 are interchangeable as they behave nearly the same (e.g. same ranks, same char to rank conversion).

#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/nucleotide/rna4.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna4 letter1 = 'C'_rna4; // implicitly converted
    seqan3::dna4 letter2{};
    letter2 = 'C'_rna4; // implicitly converted
}

seqan3::sequences (e.g. seqan3::dna4_vector) in general aren't implicitly convertible and must be explicitly copied to be converted:

#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/nucleotide/rna4.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna4_vector vector{'A'_rna4, 'C'_rna4, 'G'_rna4}; // (element-wise) implicit conversion
 
    // but this won't work:
    // seqan3::dna4_vector dna4_vector{"ACGT"_rna4};
 
    // as a workaround you can use:
    // side note: this would also work without the implicit conversion.
    seqan3::rna4_vector rna4_vector = "ACGT"_rna4;
    seqan3::dna4_vector dna4_vector{rna4_vector.begin(), rna4_vector.end()};
}

You can avoid this copy by using std::ranges::views:

#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/nucleotide/rna4.hpp>
#include <seqan3/utility/views/convert.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna4_vector vector = "ACG"_dna4;
 
    auto rna4_view = vector | seqan3::views::convert<seqan3::rna4>;
 
    for (auto && chr: rna4_view) // converts lazily on-the-fly
    {
        static_assert(std::same_as<decltype(chr), seqan3::rna4 &&>);
    }
}

This conversion constructor only allows converting seqan3::rna4 to seqan3::dna4. Other alphabets that inherit from seqan3::rna4 will not be implicitly convertible to seqan3::dna4.

#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/nucleotide/rna4.hpp>
 
struct my_dna4 : public seqan3::dna4
{
    // using seqan3::dna4::dna4; // uncomment to import implicit conversion shown by letter1
};
 
struct my_rna4 : public seqan3::rna4
{};
 
int main()
{
    using namespace seqan3::literals;
 
    // my_dna4 letter1 = 'C'_rna4; // NO automatic implicit conversion!
    // seqan3::dna4 letter2 = my_rna4{}; // seqan3::dna4 only allows implicit conversion from seqan3::rna4!
}

dna5_implicit_conversion_from_rna5

using seqan3::doxygen::dna5_implicit_conversion_from_rna5 = typedef void

no-api

Normally, we do not allow implicit conversion of single argument constructors, but in this case we make an exception, because seqan3::dna5 and seqan3::rna5 are interchangeable as they behave nearly the same (e.g. same ranks, same char to rank conversion).

#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/nucleotide/rna5.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna5 letter1 = 'C'_rna5; // implicitly converted
    seqan3::dna5 letter2{};
    letter2 = 'C'_rna5; // implicitly converted
}

seqan3::sequences (e.g. seqan3::dna5_vector) in general aren't implicitly convertible and must be explicitly copied to be converted:

#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/nucleotide/rna5.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna5_vector vector{'A'_rna5, 'C'_rna5, 'G'_rna5}; // (element-wise) implicit conversion
 
    // but this won't work:
    // seqan3::dna5_vector dna5_vector{"ACGT"_rna5};
 
    // as a workaround you can use:
    // side note: this would also work without the implicit conversion.
    seqan3::rna5_vector rna5_vector = "ACGT"_rna5;
    seqan3::dna5_vector dna5_vector{rna5_vector.begin(), rna5_vector.end()};
}

You can avoid this copy by using std::ranges::views:

#include <vector>
 
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/nucleotide/rna5.hpp>
#include <seqan3/utility/views/convert.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::dna5_vector vector = "ACG"_dna5;
 
    auto rna5_view = vector | seqan3::views::convert<seqan3::rna5>;
 
    for (auto && chr: rna5_view) // converts lazily on-the-fly
    {
        static_assert(std::same_as<decltype(chr), seqan3::rna5 &&>);
    }
}

This conversion constructor only allows converting seqan3::rna5 to seqan3::dna5. Other alphabets that inherit from seqan3::rna5 will not be implicitly convertible to seqan3::dna5.

#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/alphabet/nucleotide/rna5.hpp>
 
struct my_dna5 : public seqan3::dna5
{
    // using seqan3::dna5::dna5; // uncomment to import implicit conversion shown by letter1
};
 
struct my_rna5 : public seqan3::rna5
{};
 
int main()
{
    using namespace seqan3::literals;
 
    // my_dna5 letter1 = 'C'_rna5; // NO automatic implicit conversion!
    // seqan3::dna5 letter2 = my_rna5{}; // seqan3::dna5 only allows implicit conversion from seqan3::rna5!
}

rna15_implicit_conversion_from_dna15

using seqan3::doxygen::rna15_implicit_conversion_from_dna15 = typedef void

no-api

Normally, we do not allow implicit conversion of single argument constructors, but in this case we make an exception, because seqan3::rna15 and seqan3::dna15 are interchangeable as they behave nearly the same (e.g. same ranks, same char to rank conversion).

#include <seqan3/alphabet/nucleotide/rna15.hpp>
#include <seqan3/alphabet/nucleotide/dna15.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna15 letter1 = 'C'_dna15; // implicitly converted
    seqan3::rna15 letter2{};
    letter2 = 'C'_dna15; // implicitly converted
}

seqan3::sequences (e.g. seqan3::rna15_vector) in general aren't implicitly convertible and must be explicitly copied to be converted:

#include <vector>
 
#include <seqan3/alphabet/nucleotide/rna15.hpp>
#include <seqan3/alphabet/nucleotide/dna15.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna15_vector vector{'A'_dna15, 'C'_dna15, 'G'_dna15}; // (element-wise) implicit conversion
 
    // but this won't work:
    // seqan3::rna15_vector rna15_vector{"ACGT"_dna15};
 
    // as a workaround you can use:
    // side note: this would also work without the implicit conversion.
    seqan3::dna15_vector dna15_vector = "ACGT"_dna15;
    seqan3::rna15_vector rna15_vector{dna15_vector.begin(), dna15_vector.end()};
}

You can avoid this copy by using std::ranges::views:

#include <vector>
 
#include <seqan3/alphabet/nucleotide/rna15.hpp>
#include <seqan3/alphabet/nucleotide/dna15.hpp>
#include <seqan3/utility/views/convert.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna15_vector vector = "ACG"_rna15;
 
    auto dna15_view = vector | seqan3::views::convert<seqan3::dna15>;
 
    for (auto && chr: dna15_view) // converts lazily on-the-fly
    {
        static_assert(std::same_as<decltype(chr), seqan3::dna15 &&>);
    }
}

This conversion constructor only allows converting seqan3::dna15 to seqan3::rna15. Other alphabets that inherit from seqan3::dna15 will not be implicitly convertible to seqan3::rna15.

#include <seqan3/alphabet/nucleotide/rna15.hpp>
#include <seqan3/alphabet/nucleotide/dna15.hpp>
 
struct my_rna15 : public seqan3::rna15
{
    // using seqan3::rna15::rna15; // uncomment to import implicit conversion shown by letter1
};
 
struct my_dna15 : public seqan3::dna15
{};
 
int main()
{
    using namespace seqan3::literals;
 
    // my_rna15 letter1 = 'C'_dna15; // NO automatic implicit conversion!
    // seqan3::rna15 letter2 = my_dna15{}; // seqan3::rna15 only allows implicit conversion from seqan3::dna15!
}

rna4_implicit_conversion_from_dna4

using seqan3::doxygen::rna4_implicit_conversion_from_dna4 = typedef void

no-api

Normally, we do not allow implicit conversion of single argument constructors, but in this case we make an exception, because seqan3::rna4 and seqan3::dna4 are interchangeable as they behave nearly the same (e.g. same ranks, same char to rank conversion).

#include <seqan3/alphabet/nucleotide/rna4.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna4 letter1 = 'C'_dna4; // implicitly converted
    seqan3::rna4 letter2{};
    letter2 = 'C'_dna4; // implicitly converted
}

seqan3::sequences (e.g. seqan3::rna4_vector) in general aren't implicitly convertible and must be explicitly copied to be converted:

#include <vector>
 
#include <seqan3/alphabet/nucleotide/rna4.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna4_vector vector{'A'_dna4, 'C'_dna4, 'G'_dna4}; // (element-wise) implicit conversion
 
    // but this won't work:
    // seqan3::rna4_vector rna4_vector{"ACGT"_dna4};
 
    // as a workaround you can use:
    // side note: this would also work without the implicit conversion.
    seqan3::dna4_vector dna4_vector = "ACGT"_dna4;
    seqan3::rna4_vector rna4_vector{dna4_vector.begin(), dna4_vector.end()};
}

You can avoid this copy by using std::ranges::views:

#include <vector>
 
#include <seqan3/alphabet/nucleotide/rna4.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/utility/views/convert.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna4_vector vector = "ACG"_rna4;
 
    auto dna4_view = vector | seqan3::views::convert<seqan3::dna4>;
 
    for (auto && chr: dna4_view) // converts lazily on-the-fly
    {
        static_assert(std::same_as<decltype(chr), seqan3::dna4 &&>);
    }
}

This conversion constructor only allows converting seqan3::dna4 to seqan3::rna4. Other alphabets that inherit from seqan3::dna4 will not be implicitly convertible to seqan3::rna4.

#include <seqan3/alphabet/nucleotide/rna4.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
 
struct my_rna4 : public seqan3::rna4
{
    // using seqan3::rna4::rna4; // uncomment to import implicit conversion shown by letter1
};
 
struct my_dna4 : public seqan3::dna4
{};
 
int main()
{
    using namespace seqan3::literals;
 
    // my_rna4 letter1 = 'C'_dna4; // NO automatic implicit conversion!
    // seqan3::rna4 letter2 = my_dna4{}; // seqan3::rna4 only allows implicit conversion from seqan3::dna4!
}

rna5_implicit_conversion_from_dna5

using seqan3::doxygen::rna5_implicit_conversion_from_dna5 = typedef void

no-api

Normally, we do not allow implicit conversion of single argument constructors, but in this case we make an exception, because seqan3::rna5 and seqan3::dna5 are interchangeable as they behave nearly the same (e.g. same ranks, same char to rank conversion).

#include <seqan3/alphabet/nucleotide/rna5.hpp>
#include <seqan3/alphabet/nucleotide/dna5.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna5 letter1 = 'C'_dna5; // implicitly converted
    seqan3::rna5 letter2{};
    letter2 = 'C'_dna5; // implicitly converted
}

seqan3::sequences (e.g. seqan3::rna5_vector) in general aren't implicitly convertible and must be explicitly copied to be converted:

#include <vector>
 
#include <seqan3/alphabet/nucleotide/rna5.hpp>
#include <seqan3/alphabet/nucleotide/dna5.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna5_vector vector{'A'_dna5, 'C'_dna5, 'G'_dna5}; // (element-wise) implicit conversion
 
    // but this won't work:
    // seqan3::rna5_vector rna5_vector{"ACGT"_dna5};
 
    // as a workaround you can use:
    // side note: this would also work without the implicit conversion.
    seqan3::dna5_vector dna5_vector = "ACGT"_dna5;
    seqan3::rna5_vector rna5_vector{dna5_vector.begin(), dna5_vector.end()};
}

You can avoid this copy by using std::ranges::views:

#include <vector>
 
#include <seqan3/alphabet/nucleotide/rna5.hpp>
#include <seqan3/alphabet/nucleotide/dna5.hpp>
#include <seqan3/utility/views/convert.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::rna5_vector vector = "ACG"_rna5;
 
    auto dna5_view = vector | seqan3::views::convert<seqan3::dna5>;
 
    for (auto && chr: dna5_view) // converts lazily on-the-fly
    {
        static_assert(std::same_as<decltype(chr), seqan3::dna5 &&>);
    }
}

This conversion constructor only allows converting seqan3::dna5 to seqan3::rna5. Other alphabets that inherit from seqan3::dna5 will not be implicitly convertible to seqan3::rna5.

#include <seqan3/alphabet/nucleotide/rna5.hpp>
#include <seqan3/alphabet/nucleotide/dna5.hpp>
 
struct my_rna5 : public seqan3::rna5
{
    // using seqan3::rna5::rna5; // uncomment to import implicit conversion shown by letter1
};
 
struct my_dna5 : public seqan3::dna5
{};
 
int main()
{
    using namespace seqan3::literals;
 
    // my_rna5 letter1 = 'C'_dna5; // NO automatic implicit conversion!
    // seqan3::rna5 letter2 = my_dna5{}; // seqan3::rna5 only allows implicit conversion from seqan3::dna5!
}