Move methods from Board to BitBoard

BitBoard.h

@@ -8,101 +8,129 @@ class BitBoard final {
 public:
     using U64 = uint64_t;
 
-    BitBoard(uint64_t v = 0);
+    BitBoard(U64 v = 0);
 
     explicit constexpr operator bool() const {
         return mBoard != 0;
     }
-
     explicit constexpr operator unsigned long long() const {
         return mBoard;
     }
-
     operator void *() const {
         return (void *) mBoard;
     }
 
     // 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);
-    }
+    constexpr bool operator==(const BitBoard &rhs) const;
+    constexpr bool operator!=(const BitBoard &rhs) const;
+    constexpr bool operator<(const BitBoard &rhs) const;
+    constexpr bool operator>(const BitBoard &rhs) const;
+    constexpr bool operator<=(const BitBoard &rhs) const;
+    constexpr bool operator>=(const BitBoard &rhs) const;
 
     // 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;
-    }
+    constexpr bool operator!() const;
+    constexpr bool operator&&(const BitBoard &rhs) const;
+    constexpr bool operator||(const BitBoard &rhs) const;
 
-    // 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~() {
+    // Bitwise operators
+    constexpr BitBoard &operator&=(const BitBoard &rhs);
+    constexpr BitBoard &operator|=(const BitBoard &rhs);
+    constexpr BitBoard &operator^=(const BitBoard &rhs);
+    constexpr BitBoard &operator<<=(const BitBoard &rhs);
+    constexpr BitBoard &operator>>=(const BitBoard &rhs);
+    BitBoard operator~() const {
         BitBoard result(*this);
         result.mBoard = ~mBoard;
         return result;
     }
+    friend BitBoard operator^(const BitBoard &lhs, const BitBoard &rhs);
+    friend BitBoard operator|(const BitBoard &lhs, const BitBoard &rhs);
+    friend BitBoard operator&(const BitBoard &lhs, const BitBoard &rhs);
+    friend BitBoard operator<<(const BitBoard &lhs, const BitBoard &rhs);
+    friend BitBoard operator>>(const BitBoard &lhs, const BitBoard &rhs);
 
-    // 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;
-    }
+    // Arithmetic operators
+    constexpr BitBoard &operator+=(const BitBoard &rhs);
+    constexpr BitBoard &operator-=(const BitBoard &rhs);
+    constexpr BitBoard &operator%=(const BitBoard &rhs);
+    friend BitBoard operator+(const BitBoard &lhs, const BitBoard &rhs);
+    friend BitBoard operator-(const BitBoard &lhs, const BitBoard &rhs);
+    friend BitBoard operator%(const BitBoard &lhs, const BitBoard &rhs);
 
     // Stream operator
     friend std::ostream &operator<<(std::ostream &os, const BitBoard &board);
 
+    constexpr void clear(unsigned i);
+    constexpr void set(unsigned i);
+    BitBoard left(unsigned i) const;
+    BitBoard right(unsigned i) const;
+    static BitBoard fromIndex(unsigned i);
+
+    static BitBoard genShift(BitBoard x, int s);
+    static BitBoard getRank(int r);
+
+    // Returns the number of trailing 0-bits in b.
+    // WARN: Check for 0!
+    int lsb() const;
+
 private:
     U64 mBoard = {};
 
 };
 
+// Relational operators
+constexpr bool BitBoard::operator==(const BitBoard &rhs) const {
+    return mBoard == rhs.mBoard;
+}
+constexpr bool BitBoard::operator!=(const BitBoard &rhs) const {
+    return !(rhs == *this);
+}
+constexpr bool BitBoard::operator<(const BitBoard &rhs) const {
+    return mBoard < rhs.mBoard;
+}
+constexpr bool BitBoard::operator>(const BitBoard &rhs) const {
+    return rhs < *this;
+}
+constexpr bool BitBoard::operator<=(const BitBoard &rhs) const {
+    return !(rhs < *this);
+}
+constexpr bool BitBoard::operator>=(const BitBoard &rhs) const {
+    return !(*this < rhs);
+}
+
+// Logical operators
+constexpr bool BitBoard::operator!() const {
+    return !mBoard;
+}
+constexpr bool BitBoard::operator&&(const BitBoard &rhs) const {
+    return mBoard && rhs.mBoard;
+}
+constexpr bool BitBoard::operator||(const BitBoard &rhs) const {
+    return mBoard || rhs.mBoard;
+}
+
 // Bitwise operators
+constexpr BitBoard &BitBoard::operator&=(const BitBoard &rhs) {
+    mBoard &= rhs.mBoard;
+    return *this;
+}
+constexpr BitBoard &BitBoard::operator|=(const BitBoard &rhs) {
+    mBoard |= rhs.mBoard;
+    return *this;
+}
+constexpr BitBoard &BitBoard::operator^=(const BitBoard &rhs) {
+    mBoard ^= rhs.mBoard;
+    return *this;
+}
+constexpr BitBoard &BitBoard::operator<<=(const BitBoard &rhs) {
+    mBoard <<= rhs.mBoard;
+    return *this;
+}
+constexpr BitBoard &BitBoard::operator>>=(const BitBoard &rhs) {
+    mBoard >>= rhs.mBoard;
+    return *this;
+}
 inline BitBoard operator^(const BitBoard &lhs, const BitBoard &rhs) {
     BitBoard result(lhs);
     result ^= rhs;
@@ -130,6 +158,18 @@ inline BitBoard operator>>(const BitBoard &lhs, const BitBoard &rhs) {
 }
 
 // Arithmetic operators
+constexpr BitBoard &BitBoard::operator+=(const BitBoard &rhs) {
+    mBoard += rhs.mBoard;
+    return *this;
+}
+constexpr BitBoard &BitBoard::operator-=(const BitBoard &rhs) {
+    mBoard -= rhs.mBoard;
+    return *this;
+}
+constexpr BitBoard &BitBoard::operator%=(const BitBoard &rhs) {
+    mBoard %= rhs.mBoard;
+    return *this;
+}
 inline BitBoard operator+(const BitBoard &lhs, const BitBoard &rhs) {
     BitBoard result(lhs);
     result += rhs;
@@ -146,4 +186,23 @@ inline BitBoard operator%(const BitBoard &lhs, const BitBoard &rhs) {
     return result;
 }
 
+constexpr void BitBoard::set(const unsigned i) {
+    mBoard |= (1ULL << i);
+}
+constexpr void BitBoard::clear(const unsigned i) {
+    mBoard &= ~(1ULL << i);
+}
+inline BitBoard BitBoard::fromIndex(const unsigned i) {
+    return 1ULL << i;
+}
+inline BitBoard BitBoard::left(const unsigned int i) const {
+    return (mBoard >> i);
+}
+inline BitBoard BitBoard::right(const unsigned int i) const {
+    return (mBoard << i);
+}
+inline int BitBoard::lsb() const {
+    return __builtin_ctzll(mBoard);
+}
+
 #endif //CHESS_ENGINE_BITBOARD_HPP