SeqAn3  3.0.3
The Modern C++ library for sequence analysis.
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 Description

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

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

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).

int main()
{
using namespace seqan3::literals;
seqan3::dna15 letter1 = 'C'_rna15; // implicitly converted
seqan3::dna15 letter2{};
letter2 = 'C'_rna15; // implicitly converted
}
The 15 letter DNA alphabet, containing all IUPAC smybols minus the gap.
Definition: dna15.hpp:51
Provides seqan3::dna15, container aliases and string literals.
The SeqAn namespace for literals.
Provides seqan3::rna15, container aliases and string literals.

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

#include <vector>
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>
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 &&>);
}
}
The 15 letter RNA alphabet, containing all IUPAC smybols minus the gap.
Definition: rna15.hpp:51
Provides seqan3::views::convert.

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.

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

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).

int main()
{
using namespace seqan3::literals;
seqan3::dna4 letter1 = 'C'_rna4; // implicitly converted
seqan3::dna4 letter2{};
letter2 = 'C'_rna4; // implicitly converted
}
The four letter DNA alphabet of A,C,G,T.
Definition: dna4.hpp:53
Provides seqan3::dna4, container aliases and string literals.
Provides seqan3::rna4, container aliases and string literals.

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

#include <vector>
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>
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 &&>);
}
}
The four letter RNA alphabet of A,C,G,U.
Definition: rna4.hpp:49

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.

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

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).

int main()
{
using namespace seqan3::literals;
seqan3::dna5 letter1 = 'C'_rna5; // implicitly converted
seqan3::dna5 letter2{};
letter2 = 'C'_rna5; // implicitly converted
}
The five letter DNA alphabet of A,C,G,T and the unknown character N.
Definition: dna5.hpp:51
Provides seqan3::dna5, container aliases and string literals.
Provides seqan3::rna5, container aliases and string literals.

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

#include <vector>
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>
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 &&>);
}
}
The five letter RNA alphabet of A,C,G,U and the unknown character N.
Definition: rna5.hpp:49

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.

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

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).

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>
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>
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.

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

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).

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>
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>
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.

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

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).

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>
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>
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.

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!
}