pgnreader-string-utils.h

Go to the documentation of this file.

// Hoover Chess Utilities / PGN reader
// Copyright (C) 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__PGNREADER_STRING_UTILS_H_INCLUDED
#define HOOVER_CHESS_UTILS__PGN_READER__PGNREADER_STRING_UTILS_H_INCLUDED
 
#include "chessboard.h"
#include "chessboard-types.h"
 
#include <algorithm>
#include <array>
#include <cassert>
#include <cstddef>
#include <limits>
#include <string_view>
#include <type_traits>
 
namespace hoover_chess_utils::pgn_reader
{
 
 
struct MiniString_Uninitialized { };
 
template <std::size_t t_maxLen>
class MiniString
{
    static_assert(t_maxLen > 0U);
    static_assert(t_maxLen <= 255U);
 
private:
    std::uint8_t m_length;
    std::array<char, t_maxLen> m_storage;
 
public:
 
    constexpr MiniString() noexcept : m_length { }
    {
    }
 
    constexpr MiniString(MiniString_Uninitialized) noexcept
    {
    }
 
    MiniString(const MiniString &) = default;
 
    MiniString(MiniString &&) = default;
 
    MiniString &operator = (const MiniString &) & = default;
 
    MiniString &operator = (MiniString &&) & = default;
 
    ~MiniString() = default;
 
    constexpr void setLength(std::uint8_t length) noexcept
    {
        assert(length <= t_maxLen);
 
        m_length = length;
    }
 
    constexpr void assign(const char *str) noexcept
    {
        std::size_t len { };
 
        while (*str != '\0' && len < t_maxLen)
            m_storage[len++] = *str++;
 
        m_length = len;
    }
 
    constexpr void assign(const char *str, std::size_t strLen) noexcept
    {
        const std::size_t len { std::min(capacity(), strLen) };
 
        for (std::size_t i { }; i < len; ++i)
            m_storage[i] = str[i];
 
        m_length = len;
    }
 
    constexpr inline char operator [] (std::size_t index) const noexcept
    {
        assert(index <= t_maxLen);
        return m_storage[index];
    }
 
    constexpr inline char &operator [] (std::size_t index) noexcept
    {
        assert(index <= t_maxLen);
        return m_storage[index];
    }
 
    constexpr inline char *data() noexcept
    {
        return m_storage.data();
    }
 
    constexpr inline const char *data() const noexcept
    {
        return m_storage.data();
    }
 
    static constexpr inline std::size_t capacity() noexcept
    {
        return t_maxLen;
    }
 
    constexpr inline std::size_t size() const noexcept
    {
        assert(m_length <= t_maxLen);
        return m_length;
    }
 
    constexpr std::string_view getStringView() const
    {
        return std::string_view { m_storage.data(), size() };
    }
};
 
using FenString = MiniString<96U>;
 
class StringUtils
{
public:
    static constexpr inline char colChar(Square sq) noexcept
    {
        return 'a' + columnOf(sq);
    }
 
    static constexpr inline char rowChar(Square sq) noexcept
    {
        return '1' + rowOf(sq);
    }
 
    static MiniString<2U> sourceMaskToString(SquareSet srcMask) noexcept;
 
    static MiniString<13U> plyNumToString(std::uint32_t plyNum) noexcept
    {
        return moveNumToString(moveNumOfPly(plyNum), colorOfPly(plyNum));
    }
 
    template <std::size_t bufSize, typename UintRangeType, typename UintType>
    static char *genUnsignedToString(char *s, UintType num) noexcept
    {
        static_assert(std::is_unsigned_v<UintType>);
        static_assert(std::is_integral_v<UintType>);
        static_assert(std::is_unsigned_v<UintRangeType>);
        static_assert(std::is_integral_v<UintRangeType>);
        static_assert(std::numeric_limits<UintRangeType>::digits10 + 1U == bufSize);
 
        // force limit the range
        num &= std::numeric_limits<UintRangeType>::max();
 
        char *i = s;
 
        do
        {
            *i++ = '0' + (num % 10U);
            num /= 10U;
        }
        while (num > 0U);
 
        // Workaround for GCC bug: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106757
        //
        // This should be just:
        //
        // std::reverse(s, i);
 
        const std::size_t len = i - s;
        [[assume(len <= bufSize)]];
 
        for (std::size_t c { }; c < len / 2U; ++c)
            std::swap(s[c], s[len - c - 1U]);
 
        return i;
    }
 
    static MiniString<13U> moveNumToString(std::uint_fast32_t moveNum, Color turn) noexcept
    {
        // max length: "4294967295..."
        //              1234567890123 = 13 chars
        MiniString<13U> ret { MiniString_Uninitialized() };
 
        char *i = ret.data();
 
        i = genUnsignedToString<10U, std::uint32_t>(i, moveNum);
 
        *i++ = '.';
        if (turn == Color::BLACK)
        {
            *i++ = '.';
            *i++ = '.';
        }
 
        ret.setLength(i - ret.data());
        return ret;
    }
 
    static constexpr char promoPieceChar(Piece promo) noexcept
    {
        static_assert(Piece::KNIGHT == Piece { 2U });
        static_assert(Piece::BISHOP == Piece { 3U });
        static_assert(Piece::ROOK   == Piece { 4U });
        static_assert(Piece::QUEEN  == Piece { 5U });
 
        std::uint32_t pieceCharactersWord {
            (static_cast<std::uint32_t>('R') << 0U)  |
            (static_cast<std::uint32_t>('Q') << 8U)  |
            (static_cast<std::uint32_t>('N') << 16U) |
            (static_cast<std::uint32_t>('B') << 24U) };
 
        unsigned int shift { (static_cast<std::uint8_t>(promo) & 3U) * 8U };
        return static_cast<char>((pieceCharactersWord >> shift) & 0xFFU);
    }
 
    static constexpr MiniString<1U> pieceToSanStr(Piece p) noexcept
    {
        static_assert(Piece::NONE   == Piece { 0U });
        static_assert(Piece::PAWN   == Piece { 1U });
        static_assert(Piece::KNIGHT == Piece { 2U });
        static_assert(Piece::BISHOP == Piece { 3U });
        static_assert(Piece::ROOK   == Piece { 4U });
        static_assert(Piece::QUEEN  == Piece { 5U });
        static_assert(Piece::KING   == Piece { 6U });
 
        constexpr std::uint64_t pieceCharactersWord {
            (static_cast<std::uint64_t>('?') << 0U)   |
            (static_cast<std::uint64_t>('N') << 16U)  |
            (static_cast<std::uint64_t>('B') << 24U)  |
            (static_cast<std::uint64_t>('R') << 32U)  |
            (static_cast<std::uint64_t>('Q') << 40U)  |
            (static_cast<std::uint64_t>('K') << 48U) };
 
        if (p > Piece::KING)
            p = Piece::NONE;
 
        const unsigned int index { static_cast<unsigned int>(p) };
 
        char pieceCharacter { static_cast<char>((pieceCharactersWord >> (index * 8U)) & 0xFFU) };
 
        MiniString<1U> ret { MiniString_Uninitialized() };
        ret[0U] = pieceCharacter;
        ret.setLength(pieceCharacter != '\0' ? 1U : 0U);
 
        return ret;
    }
 
    static MiniString<7U> moveToSanAndPlay(ChessBoard &board, Move move);
 
    static MiniString<7U> moveToSan(const ChessBoard &board, Move move)
    {
        ChessBoard tmpBoard { board };
        return moveToSanAndPlay(tmpBoard, move);
    }
 
    static std::string_view pieceAndColorToString(PieceAndColor pc) noexcept;
 
    static std::string_view squareToString(Square sq, std::string_view emptySquareName) noexcept;
 
    static std::string_view moveTypeAndPromotionToString(MoveTypeAndPromotion typeAndPromotion) noexcept;
 
    static void boardToFEN(const ChessBoard &board, FenString &fen) noexcept;
 
};
 
 
}
 
#endif