bit_set.h

/*****************************************************************************
 * VCLib                                                                     *
 * Visual Computing Library                                                  *
 *                                                                           *
 * Copyright(C) 2021-2025                                                    *
 * Visual Computing Lab                                                      *
 * ISTI - Italian National Research Council                                  *
 *                                                                           *
 * All rights reserved.                                                      *
 *                                                                           *
 * This program is free software; you can redistribute it and/or modify      *
 * it under the terms of the Mozilla Public License Version 2.0 as published *
 * by the Mozilla Foundation; either version 2 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              *
 * Mozilla Public License Version 2.0                                        *
 * (https://www.mozilla.org/en-US/MPL/2.0/) for more details.                *
 ****************************************************************************/
 
#ifndef VCL_SPACE_CORE_BIT_SET_H
#define VCL_SPACE_CORE_BIT_SET_H
 
#include "bit_set/bit_proxy.h"
 
#include <vclib/concepts/types.h>
#include <vclib/io/serialization.h>
 
#include <stdexcept>
#include <string>
 
namespace vcl {
 
template<std::integral T>
class BitSet
{
    T mBits = static_cast<T>(0);
 
public:
    static constexpr std::size_t SIZE = sizeof(T) * 8;
 
    BitSet() = default;
 
    template<NonBoolIntegralOrEnum I>
    BitSet(std::initializer_list<I> l)
    {
        for (const auto& i : l) {
            if constexpr (std::is_enum_v<I>)
                at(toUnderlying(i)) = true;
            else
                at(i) = true;
        }
    }
 
    template<typename B>
    BitSet(std::initializer_list<B> l) requires std::same_as<bool, B>
    {
        if (l.size() > SIZE)
            throw std::invalid_argument(
                "BitSet: list size is greater than the number of bits of the "
                "BitSet");
 
        for (uint i = 0; const auto& b : l)
            at(i++) = b;
    }
 
    constexpr std::size_t size() const { return SIZE; }
 
    bool operator[](uint i) const
    {
        assert(i < SIZE);
        return mBits & (1 << i);
    }
 
    BitProxy<T> operator[](uint i)
    {
        assert(i < SIZE);
        return BitProxy(mBits, i);
    }
 
    bool at(uint i) const
    {
        if (i < SIZE)
            return mBits & (1 << i);
        else
            throw std::out_of_range(std::to_string(i) + " out of range.");
    }
 
    BitProxy<T> at(uint i)
    {
        if (i < SIZE)
            return BitProxy(mBits, i);
        else
            throw std::out_of_range(std::to_string(i) + " out of range.");
    }
 
    bool all() const { return mBits == ~static_cast<T>(0); }
 
    bool any() const { return !none(); }
 
    bool none() const { return mBits == static_cast<T>(0); }
 
    BitSet<T> set()
    {
        mBits = ~static_cast<T>(0);
        return *this;
    }
 
    BitSet<T> set(bool b, uint i)
    {
        at(i) = b;
        return *this;
    }
 
    BitSet<T> reset()
    {
        mBits = 0;
        return *this;
    }
 
    BitSet<T> reset(uint i)
    {
        at(i) = false;
        return *this;
    }
 
    BitSet<T> flip()
    {
        mBits = ~mBits;
        return *this;
    }
 
    BitSet<T> flip(uint i)
    {
        at(i) = !at(i);
        return *this;
    }
 
    T underlying() const { return mBits; }
 
    BitSet<T> operator&(const BitSet<T>& other) const
    {
        return BitSet<T>(mBits & other.mBits);
    }
 
    BitSet<T> operator|(const BitSet<T>& other) const
    {
        return BitSet<T>(mBits | other.mBits);
    }
 
    BitSet<T> operator^(const BitSet<T>& other) const
    {
        return BitSet<T>(mBits ^ other.mBits);
    }
 
    BitSet<T> operator~() const { return BitSet<T>(~mBits); }
 
    BitSet<T>& operator&=(const BitSet<T>& other)
    {
        mBits &= other.mBits;
        return *this;
    }
 
    BitSet<T>& operator|=(const BitSet<T>& other)
    {
        mBits |= other.mBits;
        return *this;
    }
 
    BitSet<T>& operator^=(const BitSet<T>& other)
    {
        mBits ^= other.mBits;
        return *this;
    }
 
    void serialize(std::ostream& os) const { vcl::serialize(os, mBits); }
 
    void deserialize(std::istream& is) { vcl::deserialize(is, mBits); }
 
    auto operator<=>(const BitSet<T>&) const = default;
 
    template<typename U>
    friend std::ostream& operator<<(std::ostream& os, const BitSet<U>& bs);
 
private:
    // constructor to initialize the BitSet with a given integral value
    BitSet(T bits) : mBits(bits) {}
};
 
template<typename T>
std::ostream& operator<<(std::ostream& os, const BitSet<T>& bs)
{
    os << "BitSet<" << typeid(T).name() << ">(";
    for (uint i = 0; i < bs.size(); i++)
        os << bs[i];
    os << ")";
    return os;
}
 
/* Specialization Aliases */
 
using BitSet8 = BitSet<char>;
 
using BitSet16 = BitSet<short>;
 
using BitSet32 = BitSet<int>;
 
using BitSet64 = BitSet<std::size_t>;
 
} // namespace vcl
 
#endif // VCL_SPACE_CORE_BIT_SET_H