bits.h

Go to the documentation of this file.

/* *****************************************************************************
 * kblib is a general utility library for C++14 and C++17, intended to provide
 * performant high-level abstractions and more expressive ways to do simple
 * things.
 *
 * Copyright (c) 2021 killerbee
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 * ****************************************************************************/
 
#ifndef KBLIB_BITS_H
#define KBLIB_BITS_H
 
#include <algorithm>
#include <array>
#include <bitset>
#include <limits>
#include <memory>
#include <utility>
#include <vector>
 
#include "fakestd.h"
#include "simple.h"
#include "stats.h"
#include "tdecl.h"
#include "traits.h"
 
namespace KBLIB_NS {
 
template <typename Int>
constexpr int bits_of = std::numeric_limits<Int>::digits;
 
#if KBLIB_USE_CXX17
 
namespace detail_bits {
 
   template <typename Key, typename Value>
   class trie_node {
      std::unique_ptr<std::array<trie_node, 4>> children;
      unsigned char storage[sizeof(Value)]{};
      bool exists = false;
 
      template <typename... Args>
      auto create(Args&&... args) noexcept(
          std::is_nothrow_constructible<Value, Args...>::value) -> Value& {
         clear();
         // This variable must exist for exception safety. exists should not be
         // set to true if an exception is thrown.
         auto v = *new (storage) Value(args...);
         exists = true;
         return *v;
      }
 
      auto clear() noexcept -> void {
         if (exists) {
            get()->~Value();
         }
         return;
      }
 
      KBLIB_NODISCARD auto get() noexcept -> Value& {
         assert(exists);
         return *reinterpret_cast<Value*>(storage);
      }
      KBLIB_NODISCARD auto get() const noexcept -> const Value& {
         assert(exists);
         return *reinterpret_cast<Value*>(storage);
      }
   };
 
} // namespace detail_bits
/*
template <typename Key, typename Value>
class bit_trie {
 public:
  using value_type = Value;
  using key_type = Key;
  using mapped_type = Value;
 
  static_assert(std::is_integral<key_type>::value,
                "key_type must be an integral type.");
  static_assert(std::is_nothrow_destructible<mapped_type>::value,
                "mapped_type must be nothrow destructible.");
 
  void insert(key_type, const mapped_type&);
  void insert(key_type, mapped_type&&);
 
 private:
  std::array<detail_bits::trie_node, bits_of<key_type>> roots;
};//*/
 
template <typename Key, Key key_range, typename Value>
class compact_bit_trie {
 public:
   struct key_type {
      Key prefix;
      std::uint16_t bits : filg2(key_range);
   };
 
   using value_type = Value;
   using mapped_type = Value;
   using size_type = uint_smallest_t<key_range>;
   using difference_type = int_smallest_t<key_range>;
   using reference = value_type&;
   using const_reference = const value_type&;
   using pointer = value_type*;
   using const_pointer = const value_type*;
 
   template <typename V>
   class iterator_t;
 
   using iterator = iterator_t<Value>;
   using const_iterator = iterator_t<const Value>;
   using reverse_iterator = std::reverse_iterator<iterator>;
   using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
   using bitset_type = std::bitset<bits_of<Key>>;
 
   static_assert(std::is_integral<Key>::value, "Key must be an integral type.");
   static_assert(std::is_unsigned<Key>::value, "Key must be unsigned.");
   static_assert(std::is_nothrow_destructible<mapped_type>::value,
                 "mapped_type must be nothrow destructible.");
 
   KBLIB_NODISCARD auto at(key_type key) const
       noexcept(false) -> const_reference {
      if (empty()) {
         throw std::out_of_range("searched in an empty compact_bit_trie");
      }
      if (key.bits > bits_of<Key>) {
         throw std::invalid_argument("key prefix longer than key length");
      }
      size_type node = 1;
      const bitset_type search = key.prefix;
      int idx = 0;
      while (node and idx < key.bits) {
         if (auto val = storage[node].val) {
            return values[val];
         } else {
            node = storage[node].children[search[idx++]];
         }
      }
      throw std::out_of_range("key not found in compact_bit_trie");
   }
 
   KBLIB_NODISCARD auto at(key_type key) noexcept(false) -> reference {
      if (empty()) {
         throw std::out_of_range("searched in an empty compact_bit_trie");
      }
      if (key.bits > bits_of<Key>) {
         throw std::invalid_argument("key prefix longer than key length");
      }
      size_type node = 1;
      const bitset_type search = key.prefix;
      int idx = 0;
      while (node and idx < key.bits) {
         if (auto val = storage[node].val) {
            return values[val];
         } else {
            node = storage[node].children[search[idx++]];
         }
      }
      throw std::out_of_range("key not found in compact_bit_trie");
   }
 
   KBLIB_NODISCARD auto find_deep(key_type key, size_type depth = -1) const
       noexcept(false) -> const_reference {
      if (empty()) {
         throw std::out_of_range("searched in an empty compact_bit_trie");
      }
      if (key.bits > bits_of<Key>) {
         throw std::invalid_argument("key prefix longer than key length");
      }
      size_type node = 1;
      size_type found = 0;
      const bitset_type search = key.prefix;
      int idx = 0;
      while (node and idx < key.bits) {
         if (auto val = storage[node].val) {
            found = val;
            if (depth--) {
               break;
            }
         }
         node = storage[node].children[search[idx++]];
      }
      if (found) {
         return values[found];
      } else {
         throw std::out_of_range("key not found in compact_bit_trie");
      }
   }
 
   KBLIB_NODISCARD auto find_deep(key_type key,
                                  size_type depth
                                  = -1) noexcept(false) -> reference {
      if (empty()) {
         throw std::out_of_range("searched in an empty compact_bit_trie");
      }
      if (key.bits > bits_of<Key>) {
         throw std::invalid_argument("key prefix longer than key length");
      }
      size_type node = 1;
      size_type found = 0;
      const bitset_type search = key.prefix;
      int idx = 0;
      while (node and idx < key.bits) {
         if (auto val = storage[node].val) {
            found = val;
            if (depth--) {
               break;
            }
         }
         node = storage[node].children[search[idx++]];
      }
      if (found) {
         return values[found];
      } else {
         throw std::out_of_range("key not found in compact_bit_trie");
      }
   }
 
   KBLIB_NODISCARD auto empty() const noexcept -> bool {
      return values.empty();
   }
 
   template <typename... Ts>
   auto emplace(key_type key, Ts&&... args) -> bool {
      size_type node = get_storage_node_for(key);
      if (auto& v = storage[node].val; v != max) {
         return false;
      } else {
         values.emplace_back(std::forward<Ts>(args)...);
         v = static_cast<size_type>(values.size() - 1);
         return true;
      }
   }
 
   auto insert(key_type key, const value_type& value) -> bool {
      return emplace(key, value);
   }
   auto insert(key_type key, value_type&& value) -> bool {
      return emplace(key, std::move(value));
   }
 
   auto insert_or_assign(key_type key, const value_type& value) -> reference {
      size_type node = get_storage_node_for(key);
      auto& v = storage[node].val;
      if (v != -1) {
         values.push_back(value);
         v = static_cast<size_type>(values.size() - 1);
      } else {
         values[v] = value;
      }
      return values[v];
   }
 
   auto insert_or_assign(key_type key, value_type&& value) -> reference {
      size_type node = get_storage_node_for(key);
      auto& v = storage[node].val;
      if (v != -1) {
         values.push_back(std::move(value));
         v = static_cast<size_type>(values.size() - 1);
      } else {
         values[v] = std::move(value);
      }
      return values[v];
   }
 
   bool erase(key_type key);
   bool prune(key_type prefix);
   auto clear() -> void {
      storage.clear();
      values.clear();
   }
 
   KBLIB_NODISCARD auto size() const noexcept -> size_type {
      return static_cast<size_type>(values.size());
   }
 
   KBLIB_NODISCARD auto memory_use() const noexcept -> std::size_t {
      return storage.capacity() * sizeof(inline_node)
             + values.size() * sizeof(Value);
   }
 
   auto shrink_to_fit() -> void {
      storage.shrink_to_fit();
      values.shrink_to_fit();
   }
 
 private:
   struct inline_node {
      size_type children[2];
      size_type parent;
      size_type val;
   };
   std::vector<inline_node> storage;
   std::vector<Value> values;
 
   auto do_init() -> void {
      if (storage.size() < 2) {
         storage.resize(2);
         storage[0] = {};
         storage[1] = {};
      }
   }
 
   KBLIB_NODISCARD auto get_storage_node_for(key_type key) -> size_type {
      if (key.bits > bits_of<Key>) {
         throw std::invalid_argument("key prefix longer than key length");
      }
      const bitset_type search = key.prefix;
      size_type node = 1;
      do_init();
      for (std::size_t i : range<std::size_t>(key.bits - 1)) {
         if (auto n = storage[node].children[std::as_const(search)[i]]) {
            node = n;
         } else {
            storage.push_back({{0, 0}, node, max});
            node = static_cast<size_type>(storage.size() - 1);
            storage[node].children[std::as_const(search)[i]] = node;
         }
      }
      return node;
   }
 
 public:
   template <typename V>
   class iterator_t {
    public:
      using value_type = V;
      using pointer = V*;
      using reference = V&;
      using difference_type = compact_bit_trie::difference_type;
      using iterator_category = std::bidirectional_iterator_tag;
 
      iterator_t() = default;
      iterator_t(const compact_bit_trie& range)
          : tree_ptr{&range.storage}
          , values_ptr{&range.values}
          , node{0} {}
 
      auto operator*() const noexcept -> reference {
         return (*values_ptr)[(*tree_ptr)[node].val];
      }
      auto operator->() const noexcept -> pointer {
         return std::addressof((*values_ptr)[(*tree_ptr)[node].val]);
      }
      auto operator++() -> iterator_t {}
 
    private:
      iterator_t(const compact_bit_trie& range, size_type n_)
          : iterator_t(range) {
         node = n_;
      }
 
      const std::vector<inline_node>* tree_ptr{};
      const std::vector<Value>* values_ptr{};
      size_type node{};
   };
};
 
constexpr inline auto memswap(unsigned char* A, unsigned char* B,
                              std::size_t size) noexcept -> void {
   for (auto i : range(size)) {
      (swap)(A[i], B[i]);
   }
   return;
}
 
inline auto memswap(void* A, void* B, std::size_t size) noexcept -> void {
   auto Ab = static_cast<unsigned char*>(A);
   auto Bb = static_cast<unsigned char*>(B);
   memswap(Ab, Bb, size);
   return;
}
 
#endif
 
template <unsigned offset, unsigned size, typename Storage>
struct bitfield {
   auto operator()() const noexcept -> Storage {
      return (get() >> offset) & ((1u << size) - 1);
   }
   auto operator()(const Storage val) noexcept -> Storage {
      // Clear the bits for this field
      get() &= ~(((1u << size) - 1) << offset);
      // Set the field
      get() |= (val & ((1u << size) - 1)) << offset;
      return val;
   }
   operator Storage() const noexcept { return (*this)(); }
   auto operator=(Storage val) noexcept -> Storage { return (*this)(val); }
 
   // allowed by pointer-interconvertibility when placed in a union
   Storage& get() noexcept { return *reinterpret_cast<Storage*>(this); }
   const Storage& get() const noexcept {
      return *reinterpret_cast<const Storage*>(this);
   }
   // ensure that there is an object for pointer-interconvertibility to find
   Storage raw_;
   // Is this a good idea?
   auto operator&() -> void = delete;
};
 
namespace detail_bits {
 
   template <typename Parent, typename ReturnT,
             ReturnT (Parent::*Set)(ReturnT) noexcept,
             ReturnT (Parent::*Get)() const noexcept>
   struct bitfield_proxy {
      Parent* p;
      constexpr auto operator=(ReturnT val) noexcept -> ReturnT {
         return (p->*Set)(val);
      }
      constexpr operator ReturnT() const noexcept { return (p->*Get)(); }
   };
 
} // namespace detail_bits
 
#define KBLIB_INTERNAL_BITFIELD_MACRO(offset, size, name, raw)              \
   static_assert(offset >= 0 and size > 0,                                  \
                 "BITFIELD cannot have negative offset or size");           \
                                                                            \
 private:                                                                   \
   constexpr auto name##_get_impl() const noexcept -> decltype(raw) {       \
      return (raw >> kblib::to_unsigned(offset))                            \
             & ((decltype(raw)(1) << kblib::to_unsigned(size)) - 1u);       \
   }                                                                        \
                                                                            \
 public:                                                                    \
   KBLIB_NODISCARD constexpr auto name() const noexcept -> decltype(raw) {  \
      return name##_get_impl();                                             \
   }                                                                        \
                                                                            \
 private:                                                                   \
   constexpr auto name##_set_impl(                                          \
       const decltype(raw) val) noexcept -> decltype(raw) {                 \
      /* Clear the bits for this field */                                   \
      raw &= ~(((decltype(raw)(1) << kblib::to_unsigned(size)) - 1u)        \
               << kblib::to_unsigned(offset));                              \
      /* Set the field */                                                   \
      raw |= (val & ((decltype(raw)(1) << kblib::to_unsigned(size)) - 1u))  \
             << kblib::to_unsigned(offset);                                 \
      return val;                                                           \
   }                                                                        \
                                                                            \
 public:                                                                    \
   constexpr auto name(const decltype(raw) val) noexcept -> decltype(raw) { \
      return name##_set_impl(val);                                          \
   }                                                                        \
                                                                            \
   KBLIB_NODISCARD constexpr auto name() noexcept -> auto {                 \
      using Parent = std::remove_pointer<decltype(this)>::type;             \
      return kblib::detail_bits::bitfield_proxy<Parent, decltype(raw),      \
                                                &Parent::name##_set_impl,   \
                                                &Parent::name##_get_impl>{  \
          this};                                                            \
   }                                                                        \
                                                                            \
   template <decltype(raw) val, decltype(raw) basis = 0>                    \
   constexpr static decltype(raw) set_##name##_v                            \
       = (basis                                                             \
          & ~(((decltype(raw)(1) << kblib::to_unsigned(size)) - 1u)         \
              << kblib::to_unsigned(offset)))                               \
         | (val & ((decltype(raw)(1) << kblib::to_unsigned(size)) - 1u))    \
               << kblib::to_unsigned(offset);                               \
                                                                            \
   template <decltype(raw) basis>                                           \
   constexpr static decltype(raw) get_##name##_v                            \
       = (basis >> kblib::to_unsigned(offset))                              \
         & ((decltype(raw)(1) << kblib::to_unsigned(size)) - 1u);           \
   constexpr static std::size_t name##_shift_v = offset;                    \
   constexpr static std::size_t name##_width_v = size;
 
namespace detail_bits {
 
   template <typename Type, typename Storage>
   struct pun_proxy {
      Storage& base;
      auto operator=(const Type val) noexcept -> pun_proxy& {
         std::memcpy(&base, &val, sizeof val);
         return *this;
      }
      operator Type() const noexcept {
         Type ret;
         std::memcpy(&ret, &base, sizeof ret);
         return ret;
      }
   };
 
   template <typename Type, typename Storage>
   struct array_pun_proxy {
      Storage& base;
      Type data;
      bool dirty = false;
      operator Type&() noexcept {
         if (dirty) {
            std::memcpy(&base, &data, sizeof data);
         }
         dirty = true;
         return data;
      }
      operator const Type&() const noexcept {
         if (dirty) {
            std::memcpy(&base, &data, sizeof data);
         }
         return data;
      }
      ~array_pun_proxy() {
         if (dirty) {
            std::memcpy(&base, &data, sizeof data);
         }
      }
      array_pun_proxy(const array_pun_proxy&) = delete;
      array_pun_proxy(array_pun_proxy&&) = delete;
      array_pun_proxy& operator=(const array_pun_proxy&) = delete;
      array_pun_proxy& operator=(array_pun_proxy&&) = delete;
   };
 
   template <typename T>
   struct array_filter {
      using type = T;
   };
   template <typename T, std::size_t N>
   struct array_filter<T[N]> {
      using type = std::array<T, N>;
   };
   template <typename T>
   struct array_filter<T[]> {
      using type = std::array<T, 0>;
   };
 
   template <typename T, std::size_t S>
   struct array_filter2 {
      using type = T;
   };
   template <typename T, std::size_t N, std::size_t S>
   struct array_filter2<T[N], S> {
      using type = std::array<T, N>;
   };
   template <typename T, std::size_t S>
   struct array_filter2<T[], S> {
      using type = std::array<T, S / sizeof(T)>;
   };
 
   template <typename P, typename Type, std::size_t S, std::size_t,
             bool aliases
             = is_aliasing_type_v<typename std::remove_extent<Type>::type>>
   struct pun_el {
 
      using type = typename array_filter2<Type, S>::type;
 
      static_assert(std::is_trivially_copyable<type>::value,
                    "Type must be trivially copyable");
 
      KBLIB_NODISCARD auto get() noexcept -> auto {
         return pun_proxy<type, decltype(P::raw)>{static_cast<P*>(this)->raw};
      }
      KBLIB_NODISCARD auto get() const noexcept -> auto {
         return pun_proxy<const type, const decltype(P::raw)>{
             static_cast<const P*>(this)->raw};
      }
   };
 
   template <typename P, typename Type, std::size_t S, std::size_t I>
   struct pun_el<P, Type[S], S, I, true> {
      using type = Type[S];
 
      KBLIB_NODISCARD auto get() noexcept -> decltype(auto) {
         return reinterpret_cast<type&>(static_cast<P*>(this)->raw);
      }
      KBLIB_NODISCARD auto get() const noexcept -> decltype(auto) {
         return reinterpret_cast<const type&>(static_cast<const P*>(this)->raw);
      }
   };
 
   template <typename P, typename Type, std::size_t S, std::size_t I>
   struct pun_el<P, Type[], S, I, true> {
      using type = Type[S];
 
      KBLIB_NODISCARD auto get() noexcept -> decltype(auto) {
         return reinterpret_cast<type&>(static_cast<P*>(this)->raw);
      }
      KBLIB_NODISCARD auto get() const noexcept -> decltype(auto) {
         return reinterpret_cast<const type&>(static_cast<const P*>(this)->raw);
      }
   };
 
   template <std::size_t S, typename I_S, typename... Types>
   struct punner_impl;
 
   template <std::size_t S, std::size_t... Is, typename... Types>
   struct punner_impl<S, std::index_sequence<Is...>, Types...>
       : pun_el<punner_impl<S, std::index_sequence<Is...>, Types...>, Types, S,
                Is>... {
 
      alignas(std::max({alignof(typename std::remove_extent<
                                Types>::type)...})) unsigned char raw[S]{};
   };
 
   template <typename... Types>
   constexpr std::size_t max_size
       = std::max({sizeof(typename array_filter<Types>::type)...});
 
} // namespace detail_bits
 
template <typename... Types>
struct punner
    : private detail_bits::punner_impl<detail_bits::max_size<Types...>,
                                       std::index_sequence_for<Types...>,
                                       Types...> {
 private:
   constexpr static std::size_t storage_size = detail_bits::max_size<Types...>;
   using impl_t
       = detail_bits::punner_impl<storage_size,
                                  std::index_sequence_for<Types...>, Types...>;
   using tuple_t = std::tuple<Types...>;
   template <std::size_t I>
   using r_element_t = typename std::tuple_element<I, tuple_t>::type;
 
   static_assert(std::is_standard_layout<impl_t>::value, "");
 
 public:
   template <std::size_t I>
   using base_t = detail_bits::pun_el<impl_t, r_element_t<I>, storage_size, I>;
   template <std::size_t I>
   using element_t = typename base_t<I>::type;
 
   template <std::size_t I>
   KBLIB_NODISCARD auto get() & noexcept -> decltype(auto) {
      static_assert(std::is_base_of<base_t<I>, impl_t>::value, "");
      return static_cast<base_t<I>&>(*this).get();
   }
   template <std::size_t I>
   KBLIB_NODISCARD auto get() const& noexcept -> decltype(auto) {
      return static_cast<const base_t<I>&>(*this).get();
   }
   template <std::size_t I>
   KBLIB_NODISCARD auto get() && noexcept -> decltype(auto) {
      return static_cast<base_t<I>&&>(*this).get();
   }
   template <std::size_t I>
   KBLIB_NODISCARD auto get() const&& noexcept -> decltype(auto) {
      return static_cast<const base_t<I>&&>(*this).get();
   }
};
 
} // namespace KBLIB_NS
 
namespace std {
 
template <std::size_t I, typename... Types>
struct tuple_element<I, kblib::punner<Types...>> {
   using type = typename kblib::punner<Types...>::template element_t<I>;
};
 
template <typename... Types>
struct tuple_size<kblib::punner<Types...>>
    : public std::integral_constant<std::size_t, sizeof...(Types)> {};
 
} // namespace std
 
namespace KBLIB_NS {
 
template <std::size_t I, typename... Types>
KBLIB_NODISCARD auto get(punner<Types...>& p) noexcept -> decltype(auto) {
   return p.template get<I>();
}
template <std::size_t I, typename... Types>
KBLIB_NODISCARD auto get(const punner<Types...>& p) noexcept -> decltype(auto) {
   return p.template get<I>();
}
template <std::size_t I, typename... Types>
KBLIB_NODISCARD auto get(punner<Types...>&& p) noexcept -> decltype(auto) {
   return p.template get<I>();
}
template <std::size_t I, typename... Types>
KBLIB_NODISCARD auto get(const punner<Types...>&& p) noexcept
    -> decltype(auto) {
   return p.template get<I>();
}
 
#if KBLIB_USE_CXX17
template <typename Type, auto Storage>
class union_pun {
 private:
   using sptr_t = decltype(Storage);
   using class_t = kblib::class_t<Storage>;
   using member_t = kblib::member_of_t<sptr_t>;
   using proxy_t = detail_bits::pun_proxy<Type, member_t>;
   using const_proxy_t = detail_bits::pun_proxy<Type, const member_t>;
 
   static_assert(sizeof(Type) <= sizeof(member_t),
                 "Type will not fit in the provided storage.");
   static_assert(std::is_trivially_copyable_v<Type>,
                 "Type must be trivially copyable.");
   static_assert(
       std::is_trivially_copyable_v<std::remove_all_extents_t<member_t>>,
       "Storage type must be trivially copyable.");
 
   KBLIB_NODISCARD auto base() noexcept -> member_t& {
      return reinterpret_cast<class_t*>(this)->*Storage;
   }
   KBLIB_NODISCARD auto base() const noexcept -> const member_t& {
      return reinterpret_cast<const class_t*>(this)->*Storage;
   }
 
 public:
   KBLIB_NODISCARD auto operator()() const noexcept -> const_proxy_t {
      return {base()};
   }
   auto operator()(const Type val) noexcept -> proxy_t {
      std::memcpy(&base(), &val, sizeof val);
      return {base()};
   }
   operator Type() const noexcept { return (*this)(); }
   auto operator=(const Type val) noexcept -> proxy_t { return (*this)(val); }
};
 
template <typename Type, std::size_t N, auto Storage>
class union_pun<Type[N], Storage> {
 private:
   using class_t = kblib::class_t<Storage>;
   using member_t = kblib::member_t<class_t, Storage>;
   using type = std::array<Type, N>;
   using proxy_t = detail_bits::pun_proxy<type, member_t>;
   using const_proxy_t = detail_bits::pun_proxy<type, const member_t>;
 
   static_assert(sizeof(type) <= sizeof(member_t),
                 "Type will not fit in the provided storage.");
   static_assert(std::is_trivially_copyable_v<type>,
                 "Type must be trivially copyable.");
   static_assert(
       std::is_trivially_copyable_v<std::remove_all_extents_t<member_t>>,
       "Storage type must be trivially copyable.");
 
   KBLIB_NODISCARD auto base() noexcept -> member_t& {
      return reinterpret_cast<class_t*>(this)->*Storage;
   }
   KBLIB_NODISCARD auto base() const noexcept -> const member_t& {
      return reinterpret_cast<const class_t*>(this)->*Storage;
   }
 
 public:
   KBLIB_NODISCARD auto operator()() const noexcept -> const_proxy_t {
      return {base()};
   }
   auto operator()(const Type (&val)[N]) noexcept -> proxy_t {
      std::memcpy(&base(), &val, sizeof val);
      return {base()};
   }
   operator type() const noexcept { return (*this)(); }
   auto operator=(const Type (&val)[N]) noexcept -> proxy_t {
      return (*this)(val);
   }
};
#endif
 
} // namespace KBLIB_NS
 
#endif // KBLIB_BITS_H
 
#if KBLIB_DEF_MACROS and not defined(BITFIELD)
#define BITFIELD(offset, size, name, raw) \
   KBLIB_INTERNAL_BITFIELD_MACRO(offset, size, name, raw)
#endif // KBLIB_DEF_MACROS and not defined(BITFIELD)