BitRef.h

Go to the documentation of this file.

#pragma once
// SPDX-FileCopyrightText: 2025 Nessan Fitzmaurice <nzznfitz+gh@icloud.com>
// SPDX-License-Identifier: MIT

 
#include <gf2/store_word.h>
#include <format>
 
namespace gf2 {
 
// Forward declaration of the `BitStore` class which generates `BitRef` instances from index operations.
template<typename Store>
class BitStore;

template<typename Store>
class BitRef {
private:
    // The bit-store we are referencing.
    BitStore<Store>* m_store;
 
    // The index of the bit of interest within that bit-store
    usize m_index;
 
public:
    BitRef(BitStore<Store>* store, usize index) : m_store(store), m_index(index) {}
 
    // The default compiler generator implementations for most "rule of 5" methods will be fine ...
    constexpr BitRef() = default;
    constexpr BitRef(const BitRef&) = default;
    constexpr BitRef(BitRef&&) noexcept = default;
    ~BitRef() = default;

    constexpr operator bool() const { return m_store->get(m_index); }

    constexpr BitRef& operator=(bool rhs) {
        m_store->set(m_index, rhs);
        return *this;
    }

    constexpr BitRef& operator=(const BitRef& rhs) {
        m_store->set(m_index, static_cast<bool>(rhs));
        return *this;
    }

    constexpr BitRef& flip() {
        m_store->flip(m_index);
        return *this;
    }

    constexpr BitRef& operator&=(bool rhs) {
        if (!rhs) m_store->set(m_index, false);
        return *this;
    }

    constexpr BitRef& operator&=(const BitRef& rhs) {
        if (!static_cast<bool>(rhs)) m_store->set(m_index, false);
        return *this;
    }

    constexpr BitRef& operator|=(bool rhs) {
        if (rhs) m_store->set(m_index);
        return *this;
    }

    constexpr BitRef& operator|=(const BitRef& rhs) {
        if (static_cast<bool>(rhs)) m_store->set(m_index);
        return *this;
    }

    constexpr BitRef& operator^=(bool rhs) {
        if (rhs) m_store->flip(m_index);
        return *this;
    }

    constexpr BitRef& operator^=(const BitRef& rhs) {
        if (static_cast<bool>(rhs)) m_store->flip(m_index);
        return *this;
    }
};
 
} // namespace gf2

template<typename Store>
struct std::formatter<gf2::BitRef<Store>> : std::formatter<bool> {
    template<typename FormatContext>
    auto format(const gf2::BitRef<Store>& bit, FormatContext& ctx) const {
        return std::formatter<bool>::format(static_cast<bool>(bit), ctx);
    }
};