chessboard-types-squareset.h

Go to the documentation of this file.

// Hoover Chess Utilities / PGN reader
// Copyright (C) 2024-2025  Sami Kiminki
//
// 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 HOOVER_CHESS_UTILS__PGN_READER__CHESSBOARD_TYPES_SQUARESET_H_INCLUDED
#define HOOVER_CHESS_UTILS__PGN_READER__CHESSBOARD_TYPES_SQUARESET_H_INCLUDED
 
#include "chessboard-types.h"
 
#include <atomic>
#include <bit>
#include <cassert>
#include <cstdint>
#include <type_traits>
 
 
namespace hoover_chess_utils::pgn_reader
{
 
class SquareSet
{
private:
    std::uint64_t m_bitmask { };
 
public:
    constexpr inline SquareSet() = default;
 
    constexpr inline SquareSet(std::same_as<Square> auto... squares) noexcept :
        m_bitmask {  }
    {
        std::uint64_t bitmask { };
        for (auto sq : std::initializer_list<Square>{ squares... })
        {
            const auto sqRaw { static_cast<SquareUnderlyingType>(sq) };
 
            assert(sqRaw < 64U);
            [[assume(sqRaw < 64U)]];
 
            bitmask |= UINT64_C(1) << sqRaw;
        }
 
        m_bitmask = bitmask;
    }
 
    constexpr ~SquareSet() = default;
 
    constexpr inline SquareSet(const SquareSet &) = default;
 
    constexpr inline SquareSet(SquareSet &&) = default;
 
    constexpr inline SquareSet &operator = (const SquareSet &) = default;
 
    constexpr inline SquareSet &operator = (SquareSet &&) = default;
 
    explicit constexpr inline SquareSet(std::uint64_t mask) noexcept :
        m_bitmask { mask }
    {
    }
 
    explicit constexpr inline operator std::uint64_t() const noexcept
    {
        return m_bitmask;
    }
 
    constexpr inline std::uint_fast8_t popcount() const noexcept
    {
        return std::popcount(m_bitmask);
    }
 
    constexpr inline Square firstSquare() const noexcept
    {
        return Square(std::countr_zero(m_bitmask));
    }
 
    constexpr inline Square lastSquare() const noexcept
    {
        SquareUnderlyingType tmp = 63U - std::countl_zero(m_bitmask);
        return tmp <= 63U ? Square(tmp) : Square::NONE;
    }
 
    constexpr inline SquareSet removeFirstSquare() const noexcept
    {
        return SquareSet { m_bitmask & (m_bitmask - 1U) };
    }
 
    constexpr inline SquareSet operator & (SquareSet other) const noexcept
    {
        return SquareSet { m_bitmask & other.m_bitmask };
    }
 
    constexpr inline SquareSet operator | (SquareSet other) const noexcept
    {
        return SquareSet { m_bitmask | other.m_bitmask };
    }
 
    constexpr inline SquareSet operator ^ (SquareSet other) const noexcept
    {
        return SquareSet { m_bitmask ^ other.m_bitmask };
    }
 
    constexpr inline SquareSet &operator &= (SquareSet other) noexcept
    {
        m_bitmask &= other.m_bitmask;
        return (*this);
    }
 
    constexpr inline SquareSet &operator |= (SquareSet other) noexcept
    {
        m_bitmask |= other.m_bitmask;
        return (*this);
    }
 
    constexpr inline SquareSet &operator ^= (SquareSet other) noexcept
    {
        m_bitmask ^= other.m_bitmask;
        return (*this);
    }
 
    constexpr inline SquareSet operator ~ () const noexcept
    {
        return SquareSet { ~m_bitmask };
    }
 
    constexpr inline SquareSet operator << (std::uint_fast8_t shift) const noexcept
    {
        return SquareSet { m_bitmask << shift };
    }
 
    constexpr inline SquareSet operator >> (std::uint_fast8_t shift) const noexcept
    {
        return SquareSet { m_bitmask >> shift };
    }
 
    constexpr inline SquareSet rotl(std::int_fast8_t shift) const noexcept
    {
        return SquareSet { std::rotl(m_bitmask, shift) };
    }
 
    constexpr inline SquareSet rotr(std::int_fast8_t shift) const noexcept
    {
        return SquareSet { std::rotr(m_bitmask, shift) };
    }
 
    constexpr inline SquareSet operator <<= (std::uint_fast8_t shift) noexcept
    {
        m_bitmask <<= shift;
        return (*this);
    }
 
    constexpr inline SquareSet operator >>= (std::uint_fast8_t shift) noexcept
    {
        m_bitmask >>= shift;
        return (*this);
    }
 
    constexpr inline SquareSet flipVert() const noexcept
    {
        return SquareSet { std::byteswap(m_bitmask) };
    }
 
    constexpr inline bool operator == (SquareSet other) const noexcept
    {
        return m_bitmask == other.m_bitmask;
    }
 
    constexpr inline bool operator != (SquareSet other) const noexcept
    {
        return m_bitmask != other.m_bitmask;
    }
 
    SquareSet parallelExtract(SquareSet extractMask) noexcept;
 
    SquareSet parallelDeposit(SquareSet extractMask) noexcept;
 
    static constexpr inline SquareSet none() noexcept
    {
        return SquareSet { };
    }
 
    static constexpr inline SquareSet all() noexcept
    {
        return SquareSet { 0xFF'FF'FF'FF'FF'FF'FF'FFU };
    }
 
    static constexpr inline SquareSet column(RowColumn col) noexcept
    {
        assert(col <= 7U);
        [[assume(col <= 7U)]];
 
        return SquareSet { std::uint64_t { 0x01'01'01'01'01'01'01'01U } << col };
    }
 
    static constexpr inline SquareSet row(RowColumn row) noexcept
    {
        assert(row <= 7U);
        [[assume(row <= 7U)]];
 
        return SquareSet { std::uint64_t { 0x00'00'00'00'00'00'00'FFU } << (row * 8U) };
    }
 
    static constexpr inline SquareSet square(Square sq) noexcept
    {
        assert(static_cast<SquareUnderlyingType>(sq) <= 63U);
        [[assume(static_cast<SquareUnderlyingType>(sq) <= 63U)]];
 
        return SquareSet { std::uint64_t { 1U } << static_cast<SquareUnderlyingType>(sq) };
    }
 
    static constexpr inline SquareSet squareOrNone(Square sq) noexcept
    {
        const std::uint64_t bitToShift { sq < Square::NONE };
        return SquareSet { std::rotl(bitToShift, static_cast<SquareUnderlyingType>(sq)) };
    }
 
    static constexpr inline SquareSet square(RowColumn col, RowColumn row) noexcept
    {
        assert(col <= 7U);
        assert(row <= 7U);
 
        const auto shift { col + (row * 8U) };
        [[assume(shift <= 63U)]];
 
        return SquareSet { std::uint64_t { 1U } << shift };
    }
 
    constexpr inline bool isMember(Square sq) const noexcept
    {
        assert(static_cast<std::uint8_t>(sq) <= 63U);
        [[assume(static_cast<std::uint8_t>(sq) <= 63U)]];
 
        return (m_bitmask & (std::uint64_t { 1U } << static_cast<SquareUnderlyingType>(sq))) != 0U;
    }
 
    constexpr inline SquareSet allIfNone() const noexcept
    {
        return SquareSet { m_bitmask ? SquareSet::none() : SquareSet::all() };
    }
 
    constexpr inline SquareSet allIfAny() const noexcept
    {
        return SquareSet { m_bitmask ? SquareSet::all() : SquareSet::none() };
    }
};
 
}
 
#define SQUARESET_ENUMERATE_INTERNAL(sq, squareSet, tmpMask, ...)       \
    do                                                                  \
    {                                                                   \
        SquareSet tmpMask { squareSet };                                \
                                                                        \
        while (true)                                                    \
        {                                                               \
            const Square sq { tmpMask.firstSquare() };                  \
                                                                        \
            if (sq > Square::H8)                                        \
                break;                                                  \
                                                                        \
            tmpMask &= ~SquareSet::square(sq);                          \
                                                                        \
            __VA_ARGS__;                                                \
        }                                                               \
    }                                                                   \
    while (false)
 
#define SQUARESET_ENUMERATE(sq, squareSet, ...)                         \
    SQUARESET_ENUMERATE_INTERNAL(sq, squareSet, squareset_enumerate_internal_mask, __VA_ARGS__)
 
#endif