BitView.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
// Based on https://github.com/TheLartians/BitLens
 
#pragma once
 
#include <climits>
#include <cstddef>
#include <iterator>
#include <type_traits>
#include <utility>
 
namespace CeresEngine {
 
    template<class Word> struct WordSize { static constexpr size_t value = sizeof(Word) * CHAR_BIT; };
 
    template<class Word> class BitReference {
    private:
        size_t offset;
        Word& value;
 
    public:
        constexpr BitReference(Word& v, const size_t o) noexcept : offset(o), value(v) {
            static_assert(std::is_integral<Word>::value && std::is_unsigned<Word>::value, "Only unsigned integer value types are supported");
        }
 
        constexpr BitReference(const BitReference&) noexcept = default;
        constexpr BitReference(BitReference&&) noexcept = default;
 
        BitReference& operator=(bool v) noexcept {
            value = (value & ~(Word(1) << offset)) | (Word(v) << offset);
            return *this;
        }
 
        constexpr operator bool() const noexcept { return (value >> offset) & Word(1); }
        BitReference& operator=(const BitReference& v) noexcept { return *this = bool(v); }
    };
 
    template<class Word> void swap(BitReference<Word>& a, BitReference<Word>& b) {
        bool tmp = a;
        a = b;
        b = tmp;
    }
 
    template<class ContainerIterator> class BitIterator {
    private:
        using Word = typename std::remove_reference<decltype(*std::declval<ContainerIterator>())>::type;
        static constexpr auto WORD_SIZE = WordSize<Word>::value;
        ContainerIterator mIterator;
        size_t mIndex;
 
    public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type = BitReference<Word>;
        using difference_type = size_t;
        using reference = value_type;
 
        constexpr BitIterator(ContainerIterator i, const size_t o) noexcept : mIterator(i), mIndex(o) {}
 
        BitIterator& operator++(int) noexcept {
            BitIterator copy(*this);
            mIndex++;
            return copy;
        }
 
        BitIterator operator++() noexcept {
            ++mIndex;
            return *this;
        }
 
        BitIterator& operator--(int) noexcept {
            BitIterator copy(*this);
            mIndex--;
            return copy;
        }
 
        BitIterator operator--() noexcept {
            --mIndex;
            return *this;
        }
 
        [[nodiscard]] BitIterator operator+(const int n) const noexcept { return BitIterator(mIterator, mIndex + n); }
        [[nodiscard]] BitIterator operator-(const int n) const noexcept { return BitIterator(mIterator, mIndex - n); }
        [[nodiscard]] size_t operator-(const BitIterator& other) const noexcept { return mIndex - other.mIndex; }
 
        [[nodiscard]] constexpr bool operator!=(const BitIterator& other) const { return mIterator != other.mIterator || mIndex != other.mIndex; }
        [[nodiscard]] constexpr bool operator==(const BitIterator& other) const { return mIterator == other.mIterator && mIndex == other.mIndex; }
 
        [[nodiscard]] constexpr BitReference<Word> operator*() const noexcept {
            return BitReference<Word>(*(mIterator + mIndex / WORD_SIZE), mIndex % WORD_SIZE);
        }
    };
 
    template<class Container> class BitView {
    private:
        Container& mContainer;
 
    public:
        using Word = typename std::remove_reference<decltype(std::declval<Container>()[0])>::type;
        static constexpr auto WORD_SIZE = WordSize<Word>::value;
 
        constexpr BitView(Container& container) noexcept : mContainer(container) {}
 
        [[nodiscard]] size_t size() const noexcept(noexcept(mContainer.size())) { return mContainer.size() * WORD_SIZE; }
 
        void resize(size_t N, const bool v = false) noexcept(noexcept(mContainer.resize(0, 0))) {
            Word offset = N % WORD_SIZE == 0 ? 0 : 1;
            mContainer.resize(N / WORD_SIZE + offset, v ? ~0 : 0);
        }
 
        [[nodiscard]] constexpr BitReference<Word> operator[](size_t i) noexcept(noexcept(mContainer[0])) {
            Word offset = i % WORD_SIZE;
            return BitReference<Word>(mContainer[i / WORD_SIZE], offset);
        }
 
        [[nodiscard]] constexpr BitReference<const Word> operator[](size_t i) const noexcept(noexcept(mContainer[0])) {
            Word offset = i % WORD_SIZE;
            return BitReference<const Word>(mContainer[i / WORD_SIZE], offset);
        }
 
        [[nodiscard]] constexpr auto begin() noexcept(noexcept(mContainer.begin())) { return BitIterator(mContainer.begin(), 0); }
        [[nodiscard]] constexpr auto end() noexcept(noexcept(mContainer.begin())) { return BitIterator(mContainer.begin(), size()); }
 
        [[nodiscard]] constexpr auto begin() const noexcept(noexcept(mContainer.begin())) { return BitIterator(mContainer.begin(), 0); }
        [[nodiscard]] constexpr auto end() const noexcept(noexcept(mContainer.begin())) { return BitIterator(mContainer.begin(), size()); }
 
        [[nodiscard]] Container& data() noexcept { return mContainer; }
 
        [[nodiscard]] const Container& data() const noexcept { return mContainer; }
    };
 
    template<class C> class BitContainer : public BitView<C> {
    private:
        C mDataContainer;
 
    public:
        constexpr BitContainer() noexcept(noexcept(C())) : BitView<C>(mDataContainer) {}
        constexpr BitContainer(const BitContainer& other) noexcept(noexcept(C(std::declval<const C&>())))
                : mDataContainer(other.data()), BitView<C>(mDataContainer) {}
        constexpr BitContainer(BitContainer&& other) noexcept(noexcept(C(std::declval<C&&>())))
                : mDataContainer(std::move(other.data())), BitView<C>(mDataContainer) {}
 
        template<typename... Args> BitContainer(Args&&... args) : mDataContainer(std::forward<Args...>(args...)), BitView<C>(mDataContainer) {}
    };
 
} // namespace CeresEngine