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

#include <meta/meta.hpp>

#include <seqan3/core/type_list.hpp>
#include <seqan3/core/type_traits/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,           
    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, 
};

// ----------------------------------------------------------------------------
// 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>
{
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()
    {
        clear_impl(*this, std::make_integer_sequence<size_t, field_types::size()>{});
    }
private:
    template <size_t ...Is>
    constexpr void clear_impl(base_type & tup, std::integer_sequence<size_t, Is...> const &)
    {
        ((std::get<Is>(tup) = {}), ...);
    }
};

} // namespace seqan3

namespace std
{

template <typename field_types, typename field_ids>
struct tuple_size<seqan3::record<field_types, field_ids>>
{
    static constexpr size_t value = tuple_size_v<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>>
{
    using type = std::tuple_element_t<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.");
    return std::get<field_ids::index_of(f)>(std::move(r));
}

} // namespace seqan3