bit_field.hpp

Go to the documentation of this file.

//===- include/pstore/support/bit_field.hpp ---------------*- mode: C++ -*-===//
//*  _     _ _      __ _      _     _  *
//* | |__ (_) |_   / _(_) ___| | __| | *
//* | '_ \| | __| | |_| |/ _ \ |/ _` | *
//* | |_) | | |_  |  _| |  __/ | (_| | *
//* |_.__/|_|\__| |_| |_|\___|_|\__,_| *
//*                                    *
//===----------------------------------------------------------------------===//
//
// Part of the pstore project, under the Apache License v2.0 with LLVM Exceptions.
// See https://github.com/SNSystems/pstore/blob/master/LICENSE.txt for license
// information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef PSTORE_SUPPORT_BIT_FIELD_HPP
#define PSTORE_SUPPORT_BIT_FIELD_HPP

#include <cstddef>
#include <cstdint>
#include <limits>
#include <type_traits>

#include "pstore/support/assert.hpp"

namespace pstore {

    namespace details {

        template <typename ValueType, unsigned Bits>
        struct max_value {
            static constexpr ValueType value = static_cast<ValueType> ((ValueType{1} << Bits) - 1);
        };

        template <typename ValueType>
        struct max_value<ValueType, 8U> {
            static constexpr ValueType value = std::numeric_limits<std::uint8_t>::max ();
        };

        template <typename ValueType>
        struct max_value<ValueType, 16U> {
            static constexpr ValueType value = std::numeric_limits<std::uint16_t>::max ();
        };

        template <typename ValueType>
        struct max_value<ValueType, 32U> {
            static constexpr ValueType value = std::numeric_limits<std::uint32_t>::max ();
        };

        template <typename ValueType>
        struct max_value<ValueType, 64U> {
            static constexpr ValueType value = std::numeric_limits<std::uint64_t>::max ();
        };

        template <typename ValueType, unsigned Bits>
        constexpr ValueType max_value<ValueType, Bits>::value;
        template <typename ValueType>
        constexpr ValueType max_value<ValueType, 8U>::value;
        template <typename ValueType>
        constexpr ValueType max_value<ValueType, 16U>::value;
        template <typename ValueType>
        constexpr ValueType max_value<ValueType, 32U>::value;
        template <typename ValueType>
        constexpr ValueType max_value<ValueType, 64U>::value;


        template <typename ValueType, unsigned Index, unsigned Bits,
                  typename = typename std::enable_if<std::is_unsigned<ValueType>::value &&
                                                     Index + Bits <= sizeof (ValueType) * 8>::type>
        class bit_field_base {
        public:
            static constexpr auto first_bit = Index;
            static constexpr auto last_bit = Index + Bits;
            using value_type = ValueType;

            static constexpr value_type min () noexcept { return 0; }
            static constexpr value_type max () noexcept { return mask_; }

            constexpr value_type value () const noexcept {
                return (this->value_ >> Index) & this->mask_;
            }

            template <typename T,
                      typename = typename std::enable_if<std::is_unsigned<T>::value &&
                                                         sizeof (T) <= sizeof (value_type)>::type>
            void assign (T v) noexcept {
                value_ = static_cast<value_type> (value_ & ~(mask_ << Index)) |
                         static_cast<value_type> ((v & mask_) << Index);
            }

        private:
            static constexpr auto mask_ = max_value<ValueType, Bits>::value;
            value_type value_;
        };

    } // end namespace details


    template <typename ValueType, unsigned Index, unsigned Bits>
    class bit_field : private details::bit_field_base<ValueType, Index, Bits> {
        using inherited = details::bit_field_base<ValueType, Index, Bits>;

    public:
        using inherited::first_bit;
        using inherited::last_bit;
        using inherited::max;
        using inherited::min;
        using typename inherited::value_type;
        using assign_type = ValueType;

        using inherited::value;
        constexpr operator value_type () const noexcept { return this->value (); }

        template <typename T>
        bit_field & operator= (T v) noexcept {
            this->assign (v);
            return *this;
        }


        template <typename T>
        bit_field & operator+= (T other) noexcept {
            this->assign (static_cast<value_type> (this->value () + other));
            return *this;
        }
        template <typename T>
        bit_field & operator-= (T other) noexcept {
            this->assign (static_cast<value_type> (this->value () - other));
            return *this;
        }

        bit_field & operator++ () noexcept { return operator+=(value_type{1}); }
        bit_field operator++ (int) noexcept {
            bit_field const prev = *this;
            ++*this;
            return prev;
        }

        bit_field & operator-- () noexcept { return operator-=(value_type{1}); }
        bit_field operator-- (int) noexcept {
            bit_field const prev = *this;
            --*this;
            return prev;
        }
    };

    template <typename ValueType, unsigned Index>
    class bit_field<ValueType, Index, 1> : private details::bit_field_base<ValueType, Index, 1> {
        using inherited = details::bit_field_base<ValueType, Index, 1>;

    public:
        using inherited::first_bit;
        using inherited::last_bit;
        using inherited::max;
        using inherited::min;
        using typename inherited::value_type;
        using assign_type = bool;

        bit_field & operator= (bool const v) noexcept {
            this->assign (static_cast<value_type> (v));
            return *this;
        }

        constexpr bool value () const noexcept { return static_cast<bool> (inherited::value ()); }
        constexpr operator bool () const noexcept { return value (); }
    };

} // end namespace pstore

#endif // PSTORE_SUPPORT_BIT_FIELD_HPP