record.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 <tuple>
 
#include <seqan3/core/detail/template_inspection.hpp>
 
namespace seqan3
{
 
// ----------------------------------------------------------------------------
// enum field
// ----------------------------------------------------------------------------
 
enum class field
{
    // Fields used in multiple contexts ........................................
    seq,            
    id,             
    qual,           
    seq_qual,       
    offset,         
 
    // Fields unique to structure io ...........................................
    bpp,            
    structure,      
    structured_seq, 
    energy,         
    react,          
    react_err,      
    comment,        
 
    // Fields unique to alignment io ...........................................
    alignment,      
    ref_id,         
    ref_seq,        
    ref_offset,     
    header_ptr,     
 
    flag,           
    mate,           
    mapq,           
    cigar,          
    tags,           
 
    bit_score,      
    evalue,         
 
    // User defined field aliases .. ...........................................
    user_defined_0, 
    user_defined_1, 
    user_defined_2, 
    user_defined_3, 
    user_defined_4, 
    user_defined_5, 
    user_defined_6, 
    user_defined_7, 
    user_defined_8, 
    user_defined_9, 
 
    // deprecated uppercase:
    SEQ SEQAN3_DEPRECATED_310 = seq, 
    ID SEQAN3_DEPRECATED_310 = id, 
    QUAL SEQAN3_DEPRECATED_310 = qual, 
    SEQ_QUAL SEQAN3_DEPRECATED_310 = seq_qual, 
    OFFSET SEQAN3_DEPRECATED_310 = offset, 
    BPP SEQAN3_DEPRECATED_310 = bpp, 
    STRUCTURE SEQAN3_DEPRECATED_310 = structure, 
    STRUCTURED_SEQ SEQAN3_DEPRECATED_310 = structured_seq, 
    ENERGY SEQAN3_DEPRECATED_310 = energy, 
    REACT SEQAN3_DEPRECATED_310 = react, 
    REACT_ERR SEQAN3_DEPRECATED_310 = react_err, 
    COMMENT SEQAN3_DEPRECATED_310 = comment, 
    ALIGNMENT SEQAN3_DEPRECATED_310 = alignment, 
    REF_ID SEQAN3_DEPRECATED_310 = ref_id, 
    REF_SEQ SEQAN3_DEPRECATED_310 = ref_seq, 
    REF_OFFSET SEQAN3_DEPRECATED_310 = ref_offset, 
    HEADER_PTR SEQAN3_DEPRECATED_310 = header_ptr, 
    FLAG SEQAN3_DEPRECATED_310 = flag, 
    MATE SEQAN3_DEPRECATED_310 = mate, 
    MAPQ SEQAN3_DEPRECATED_310 = mapq, 
    CIGAR SEQAN3_DEPRECATED_310 = cigar, 
    TAGS SEQAN3_DEPRECATED_310 = tags, 
    BIT_SCORE SEQAN3_DEPRECATED_310 = bit_score, 
    EVALUE SEQAN3_DEPRECATED_310 = evalue, 
    USER_DEFINED_0 SEQAN3_DEPRECATED_310 = user_defined_0, 
    USER_DEFINED_1 SEQAN3_DEPRECATED_310 = user_defined_1, 
    USER_DEFINED_2 SEQAN3_DEPRECATED_310 = user_defined_2, 
    USER_DEFINED_3 SEQAN3_DEPRECATED_310 = user_defined_3, 
    USER_DEFINED_4 SEQAN3_DEPRECATED_310 = user_defined_4, 
    USER_DEFINED_5 SEQAN3_DEPRECATED_310 = user_defined_5, 
    USER_DEFINED_6 SEQAN3_DEPRECATED_310 = user_defined_6, 
    USER_DEFINED_7 SEQAN3_DEPRECATED_310 = user_defined_7, 
    USER_DEFINED_8 SEQAN3_DEPRECATED_310 = user_defined_8, 
    USER_DEFINED_9 SEQAN3_DEPRECATED_310 = user_defined_9, 
};
 
// ----------------------------------------------------------------------------
// fields
// ----------------------------------------------------------------------------
 
template <field ...fs>
struct fields
{
    static constexpr std::array<field, sizeof...(fs)> as_array{fs...};
 
    static constexpr size_t npos = std::numeric_limits<size_t>::max();
 
    static constexpr size_t index_of(field f)
    {
        for (size_t i = 0; i < sizeof...(fs); ++i)
            if (as_array[i] == f)
                return i;
        return npos;
    }
 
    static constexpr bool contains(field f)
    {
        return index_of(f) != npos;
    }
 
    static_assert([] () constexpr
                  {
                      for (size_t i = 0; i < as_array.size(); ++i)
                          for (size_t j = i + 1; j < as_array.size(); ++j)
                              if (as_array[i] == as_array[j])
                                  return false;
 
                      return true;
                  } (), "You may not include a field twice into fields<>.");
};
 
// ----------------------------------------------------------------------------
// record
// ----------------------------------------------------------------------------
 
template <typename field_types, typename field_ids>
struct record : detail::transfer_template_args_onto_t<field_types, std::tuple>
{
private:
    template <typename t>
        requires requires (t & v) { v.clear(); }
    static constexpr void clear_element(t & v) noexcept(noexcept(v.clear()))
    {
        v.clear();
    }
 
    template <typename t>
    static constexpr void clear_element(t & v) noexcept(noexcept(std::declval<t &>() = t{}))
    {
        v = {};
    }
 
    static constexpr auto expander = [] (auto & ...args) { (clear_element(args), ...); };
 
public:
    using base_type = detail::transfer_template_args_onto_t<field_types, std::tuple>;
 
    record() = default;                           
    record(record const &) = default;             
    record & operator=(record const &) = default; 
    record(record &&) = default;                  
    record & operator=(record &&) = default;      
    ~record() = default;                          
 
    using base_type::base_type;
 
    static_assert(field_types::size() == field_ids::as_array.size(),
                  "You must give as many IDs as types to seqan3::record.");
 
    void clear() noexcept(noexcept(std::apply(expander, std::declval<record &>())))
    {
        std::apply(expander, *this);
    }
 
protected:
 
    template <field f>
    using field_constant = std::integral_constant<field, f>;
 
    template <field f, typename tuple_t>
    static decltype(auto) get_impl(field_constant<f>, tuple_t && record_as_tuple)
    {
        static_assert(field_ids::contains(f), "The record does not contain the field you wish to retrieve.");
#if SEQAN3_WORKAROUND_GCC_94967
        // is_rvalue_reference_v can't be used, because tuple_t won't contain `&&` in the type due to reference
        // collapsing
        if constexpr (!std::is_lvalue_reference_v<tuple_t> && std::is_const_v<tuple_t>)
        {
            // A simple std::move(...) does not work, because it would mess up tuple_element types like `int const &`
            using return_t = std::tuple_element_t<field_ids::index_of(f), tuple_t>;
            return static_cast<return_t const &&>(std::get<field_ids::index_of(f)>(std::move(record_as_tuple)));
        }
        else
        {
            return std::get<field_ids::index_of(f)>(std::forward<tuple_t>(record_as_tuple));
        }
#else // ^^^ workaround / no workaround vvv
        return std::get<field_ids::index_of(f)>(std::forward<tuple_t>(record_as_tuple));
#endif // SEQAN3_WORKAROUND_GCC_94967
    }
};
 
} // namespace seqan3
 
namespace std
{
 
template <typename field_types, typename field_ids>
struct tuple_size<seqan3::record<field_types, field_ids>>
    : tuple_size<typename seqan3::record<field_types, field_ids>::base_type>
{};
 
template <size_t elem_no, typename field_types, typename field_ids>
struct tuple_element<elem_no, seqan3::record<field_types, field_ids>>
    : tuple_element<elem_no, typename seqan3::record<field_types, field_ids>::base_type>
{};
 
} // namespace std
 
namespace seqan3
{
 
template <field f, typename field_types, typename field_ids>
auto & get(record<field_types, field_ids> & r)
{
    static_assert(field_ids::contains(f), "The record does not contain the field you wish to retrieve.");
    return std::get<field_ids::index_of(f)>(r);
}
 
template <field f, typename field_types, typename field_ids>
auto const & get(record<field_types, field_ids> const & r)
{
    static_assert(field_ids::contains(f), "The record does not contain the field you wish to retrieve.");
    return std::get<field_ids::index_of(f)>(r);
}
 
template <field f, typename field_types, typename field_ids>
auto && get(record<field_types, field_ids> && r)
{
    static_assert(field_ids::contains(f), "The record does not contain the field you wish to retrieve.");
    return std::get<field_ids::index_of(f)>(std::move(r));
}
 
template <field f, typename field_types, typename field_ids>
auto const && get(record<field_types, field_ids> const && r)
{
    static_assert(field_ids::contains(f), "The record does not contain the field you wish to retrieve.");
#if SEQAN3_WORKAROUND_GCC_94967
    // A simple std::move(...) does not work, because it would mess up tuple_element types like `int const &`
    using return_t = std::tuple_element_t<field_ids::index_of(f), record<field_types, field_ids>>;
    return static_cast<return_t const &&>(std::get<field_ids::index_of(f)>(std::move(r)));
#else // ^^^ workaround / no workaround vvv
    return std::get<field_ids::index_of(f)>(std::move(r));
#endif // SEQAN3_WORKAROUND_GCC_94967
}
 
} // namespace seqan3