bit_manipulation.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 <meta/meta.hpp>

#include <climits>
#include <utility>

// Find correct header for byte-order conversion functions.
#if __has_include(<endian.h>) // unix GLIBC
    #include <endian.h>
#elif __has_include(<sys/endian.h>)  // *BSD
    #include <sys/endian.h>
#endif // __has_include(endian.h)

#include <seqan3/core/detail/endian.hpp>
#include <seqan3/core/detail/int_types.hpp>
#include <seqan3/std/concepts>

namespace seqan3::detail
{

template <typename type_t>
constexpr auto sizeof_bits = min_viable_uint_v<CHAR_BIT * sizeof(type_t)>;

constexpr bool is_power_of_two(size_t const n)
{
    return n > 0 && (n & (n-1)) == 0;
}

constexpr size_t next_power_of_two(size_t n)
{
    if (n == 0)
        return 1;

    --n;
    for (size_t shift = 1; !is_power_of_two(n + 1); shift <<= 1)
        n |= n >> shift;

    return n + 1;
}

template <std::UnsignedIntegral unsigned_t>
constexpr uint8_t bit_scan_reverse(unsigned_t n)
{
    assert(n > 0); // n == 0 might have undefined behaviour
#if defined(__GNUC__)
    if constexpr (sizeof(unsigned_t) == sizeof(unsigned long long))
        return sizeof_bits<unsigned long long> - __builtin_clzll(n) - 1;
    else if constexpr (sizeof(unsigned_t) == sizeof(unsigned long))
        return sizeof_bits<unsigned long> - __builtin_clzl(n) - 1;
    else
        return sizeof_bits<unsigned> - __builtin_clz(n) - 1;
#else
    uint8_t i = 0;
    for (; n != 0; n >>= 1, ++i);
    return i - 1;
#endif
}

template <std::Integral type>
constexpr type to_little_endian(type const in) noexcept
{
    if constexpr (endian::native == endian::little)
    {
        return in;
    }
    else if constexpr (endian::native == endian::big)
    {
        static_assert(sizeof(type) <= 8,
                      "Can only convert the byte encoding for integral numbers with a size of up to 8 bytes.");
        static_assert(is_power_of_two(sizeof(type)),
                      "Can only convert the byte encoding for integral numbers whose byte size is a power of two.");

        if constexpr (sizeof(type) == 2)
            return htole16(in);
        else if constexpr (sizeof(type) == 4)
            return htole32(in);
        else if constexpr (sizeof(type) == 8)
            return htole64(in);
        else
            return in;  // single byte.
    }
    else
    {
        static_assert(endian::native == endian::little || endian::native == endian::big,
                      "Expected a little-endian or big-endian platform.");
    }
}

} // namespace seqan3::detail