From a1d4dadaa28c773e5eaaf0264cea0f1e6241abde Mon Sep 17 00:00:00 2001
From: Arthur Bols <arthur@bols.dev>
Date: Thu, 22 Dec 2022 00:45:27 +0100
Subject: [PATCH] [BitBoard] improvements

---
 BitBoard.cpp | 156 +-------------------------------------------------
 BitBoard.h   | 159 +++++++++++++++++++++++++++++++++++++++------------
 2 files changed, 123 insertions(+), 192 deletions(-)

diff --git a/BitBoard.cpp b/BitBoard.cpp
index 2f2d422..30c7d73 100644
--- a/BitBoard.cpp
+++ b/BitBoard.cpp
@@ -1,102 +1,9 @@
-#include <iostream>
 #include "BitBoard.h"
 
-//BitBoard::BitBoard() {
-//    mBoard = 0;
-//}
-
 BitBoard::BitBoard(uint64_t v) {
     mBoard = v;
 }
 
-BitBoard::operator bool() const {
-    return mBoard != 0;
-}
-
-BitBoard::operator unsigned long long() const {
-    return mBoard;
-}
-
-bool BitBoard::operator==(const BitBoard &rhs) const {
-    return mBoard == rhs.mBoard;
-}
-
-bool BitBoard::operator!=(const BitBoard &rhs) const {
-    return !(rhs == *this);
-}
-
-bool BitBoard::operator<(const BitBoard &rhs) const {
-    return mBoard < rhs.mBoard;
-}
-
-bool BitBoard::operator>(const BitBoard &rhs) const {
-    return rhs < *this;
-}
-
-bool BitBoard::operator<=(const BitBoard &rhs) const {
-    return !(rhs < *this);
-}
-
-bool BitBoard::operator>=(const BitBoard &rhs) const {
-    return !(*this < rhs);
-}
-
-BitBoard &BitBoard::operator&=(const BitBoard &rhs) {
-    mBoard &= rhs.mBoard;
-    return *this;
-}
-
-BitBoard &BitBoard::operator|=(const BitBoard &rhs) {
-    mBoard |= rhs.mBoard;
-    return *this;
-}
-
-BitBoard &BitBoard::operator^=(const BitBoard &rhs) {
-    mBoard ^= rhs.mBoard;
-    return *this;
-}
-
-BitBoard &BitBoard::operator<<=(const BitBoard &rhs) {
-    mBoard <<= rhs.mBoard;
-    return *this;
-}
-
-BitBoard &BitBoard::operator>>=(const BitBoard &rhs) {
-    mBoard >>= rhs.mBoard;
-    return *this;
-}
-
-BitBoard BitBoard::operator~() {
-    BitBoard result(*this);
-    result.mBoard = ~mBoard;
-    return result;
-}
-
-BitBoard &BitBoard::operator+=(const BitBoard &rhs) {
-    mBoard += rhs.mBoard;
-    return *this;
-}
-
-BitBoard &BitBoard::operator-=(const BitBoard &rhs) {
-    mBoard -= rhs.mBoard;
-    return *this;
-}
-
-BitBoard &BitBoard::operator*=(const BitBoard &rhs) {
-    mBoard *= rhs.mBoard;
-    return *this;
-}
-
-BitBoard &BitBoard::operator/=(const BitBoard &rhs) {
-    mBoard /= rhs.mBoard;
-    return *this;
-}
-
-BitBoard &BitBoard::operator%=(const BitBoard &rhs) {
-    mBoard %= rhs.mBoard;
-    return *this;
-}
-
 std::ostream &operator<<(std::ostream &os, const BitBoard &board) {
     // For debugging only, performance isn't important
     for (int i = 7; i >= 0; i--) {
@@ -116,65 +23,4 @@ std::ostream &operator<<(std::ostream &os, const BitBoard &board) {
     }
 
     return os;
-}
-bool BitBoard::operator!() const {
-    return !mBoard;
-}
-
-bool BitBoard::operator&&(const BitBoard &rhs) const {
-    return mBoard && rhs.mBoard;
-}
-
-bool BitBoard::operator||(const BitBoard &rhs) const {
-    return mBoard || rhs.mBoard;
-}
-BitBoard::operator void *() const {
-    return (void *) mBoard;
-}
-
-BitBoard operator&(const BitBoard &lhs, const BitBoard &rhs) {
-    BitBoard result(lhs);
-    result &= rhs;
-    return result;
-}
-
-BitBoard operator|(const BitBoard &lhs, const BitBoard &rhs) {
-    BitBoard result(lhs);
-    result |= rhs;
-    return result;
-}
-
-BitBoard operator^(const BitBoard &lhs, const BitBoard &rhs) {
-    BitBoard result(lhs);
-    result ^= rhs;
-    return result;
-}
-BitBoard operator<<(const BitBoard &lhs, const BitBoard &rhs) {
-    BitBoard result(lhs);
-    result <<= rhs;
-    return result;
-}
-
-BitBoard operator>>(const BitBoard &lhs, const BitBoard &rhs) {
-    BitBoard result(lhs);
-    result >>= rhs;
-    return result;
-}
-
-BitBoard operator-(const BitBoard &lhs, const BitBoard &rhs) {
-    BitBoard result(lhs);
-    result -= rhs;
-    return result;
-}
-
-BitBoard operator*(const BitBoard &lhs, const BitBoard &rhs) {
-    BitBoard result(lhs);
-    result *= rhs;
-    return result;
-}
-
-BitBoard operator%(const BitBoard &lhs, const BitBoard &rhs) {
-    BitBoard result(lhs);
-    result %= rhs;
-    return result;
-}
+}
\ No newline at end of file
diff --git a/BitBoard.h b/BitBoard.h
index 9c558de..d208e43 100644
--- a/BitBoard.h
+++ b/BitBoard.h
@@ -3,7 +3,6 @@
 
 #include <cstdint>
 #include <ostream>
-#include "CastlingRights.hpp"
 
 class BitBoard final {
 public:
@@ -11,54 +10,140 @@ public:
 
     BitBoard(uint64_t v = 0);
 
-//    explicit operator uint64_t() const;
-    explicit operator bool() const;
-    explicit operator unsigned long long() const;
-    operator void*() const;
+    explicit constexpr operator bool() const {
+        return mBoard != 0;
+    }
 
-    bool operator==(const BitBoard &rhs) const;
-    bool operator!=(const BitBoard &rhs) const;
-    bool operator<(const BitBoard &rhs) const;
-    bool operator>(const BitBoard &rhs) const;
-    bool operator<=(const BitBoard &rhs) const;
-    bool operator>=(const BitBoard &rhs) const;
+    explicit constexpr operator unsigned long long() const {
+        return mBoard;
+    }
 
-    // bitset operations
-    BitBoard &operator&=(const BitBoard &rhs);
-    BitBoard &operator|=(const BitBoard &rhs);
-    BitBoard &operator^=(const BitBoard &rhs);
-    BitBoard &operator<<=(const BitBoard &rhs);
-    BitBoard &operator>>=(const BitBoard &rhs);
-    BitBoard operator~();
+    operator void *() const {
+        return (void *) mBoard;
+    }
 
-    bool operator!() const;
-    bool operator&&(const BitBoard &rhs) const;
-    bool operator||(const BitBoard &rhs) const;
+    // Relational operators
+    constexpr bool operator==(const BitBoard &rhs) const {
+        return mBoard == rhs.mBoard;
+    }
+    constexpr bool operator!=(const BitBoard &rhs) const {
+        return !(rhs == *this);
+    }
+    constexpr bool operator<(const BitBoard &rhs) const {
+        return mBoard < rhs.mBoard;
+    }
+    constexpr bool operator>(const BitBoard &rhs) const {
+        return rhs < *this;
+    }
+    constexpr bool operator<=(const BitBoard &rhs) const {
+        return !(rhs < *this);
+    }
+    constexpr bool operator>=(const BitBoard &rhs) const {
+        return !(*this < rhs);
+    }
 
-    BitBoard &operator+=(const BitBoard &rhs);
-    BitBoard &operator-=(const BitBoard &rhs);
-    BitBoard &operator*=(const BitBoard &rhs);
-    BitBoard &operator/=(const BitBoard &rhs);
-    BitBoard &operator%=(const BitBoard &rhs);
+    // Logical operators
+    constexpr bool operator!() const {
+        return !mBoard;
+    }
+    constexpr bool operator&&(const BitBoard &rhs) const {
+        return mBoard && rhs.mBoard;
+    }
+    constexpr bool operator||(const BitBoard &rhs) const {
+        return mBoard || rhs.mBoard;
+    }
 
+    // Compound Bitwise assignment operators
+    constexpr BitBoard &operator&=(const BitBoard &rhs) {
+        mBoard &= rhs.mBoard;
+        return *this;
+    }
+    constexpr BitBoard &operator|=(const BitBoard &rhs) {
+        mBoard |= rhs.mBoard;
+        return *this;
+    }
+    constexpr BitBoard &operator^=(const BitBoard &rhs) {
+        mBoard ^= rhs.mBoard;
+        return *this;
+    }
+    constexpr BitBoard &operator<<=(const BitBoard &rhs) {
+        mBoard <<= rhs.mBoard;
+        return *this;
+    }
+    constexpr BitBoard &operator>>=(const BitBoard &rhs) {
+        mBoard >>= rhs.mBoard;
+        return *this;
+    }
+    BitBoard operator~() {
+        BitBoard result(*this);
+        result.mBoard = ~mBoard;
+        return result;
+    }
+
+    // Compound Arithmetic assignment operators
+    constexpr BitBoard &operator+=(const BitBoard &rhs) {
+        mBoard += rhs.mBoard;
+        return *this;
+    }
+    constexpr BitBoard &operator-=(const BitBoard &rhs) {
+        mBoard -= rhs.mBoard;
+        return *this;
+    }
+    constexpr BitBoard &operator%=(const BitBoard &rhs) {
+        mBoard %= rhs.mBoard;
+        return *this;
+    }
+
+    // Stream operator
     friend std::ostream &operator<<(std::ostream &os, const BitBoard &board);
-//    friend bool operator&&(const bool &lhs, const BitBoard &rhs);
 
 private:
     U64 mBoard = {};
 
 };
 
+// Bitwise operators
+inline BitBoard operator^(const BitBoard &lhs, const BitBoard &rhs) {
+    BitBoard result(lhs);
+    result ^= rhs;
+    return result;
+}
+inline BitBoard operator|(const BitBoard &lhs, const BitBoard &rhs) {
+    BitBoard result(lhs);
+    result |= rhs;
+    return result;
+}
+inline BitBoard operator&(const BitBoard &lhs, const BitBoard &rhs) {
+    BitBoard result(lhs);
+    result &= rhs;
+    return result;
+}
+inline BitBoard operator<<(const BitBoard &lhs, const BitBoard &rhs) {
+    BitBoard result(lhs);
+    result <<= rhs;
+    return result;
+}
+inline BitBoard operator>>(const BitBoard &lhs, const BitBoard &rhs) {
+    BitBoard result(lhs);
+    result >>= rhs;
+    return result;
+}
 
-BitBoard operator^(const BitBoard &lhs, const BitBoard &rhs);
-BitBoard operator|(const BitBoard &lhs, const BitBoard &rhs);
-BitBoard operator&(const BitBoard &lhs, const BitBoard &rhs);
-BitBoard operator<<(const BitBoard &lhs, const BitBoard &rhs);
-BitBoard operator>>(const BitBoard &lhs, const BitBoard &rhs);
-BitBoard operator+(const BitBoard &lhs, const BitBoard &rhs);
-BitBoard operator-(const BitBoard &lhs, const BitBoard &rhs);
-//BitBoard operator*(const BitBoard &lhs, const BitBoard &rhs);
-//BitBoard operator/(const BitBoard &lhs, const BitBoard &rhs);
-BitBoard operator%(const BitBoard &lhs, const BitBoard &rhs);
+// Arithmetic operators
+inline BitBoard operator+(const BitBoard &lhs, const BitBoard &rhs) {
+    BitBoard result(lhs);
+    result += rhs;
+    return result;
+}
+inline BitBoard operator-(const BitBoard &lhs, const BitBoard &rhs) {
+    BitBoard result(lhs);
+    result -= rhs;
+    return result;
+}
+inline BitBoard operator%(const BitBoard &lhs, const BitBoard &rhs) {
+    BitBoard result(lhs);
+    result %= rhs;
+    return result;
+}
 
 #endif //CHESS_ENGINE_BITBOARD_HPP