searchscore.cpp

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: searchscore.cpp
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#include "belofte.h"
 
//-----------------------------------------------------------------------
 
bSearchScore::bSearchScore(bScore const& sc) noexcept
  : m_score{sc}
{
}
 
bSearchScore::bSearchScore(bScore const& sc, scoretype_t const& st) noexcept
  : m_score{sc}
  , m_type{st}
{
}
 
bSearchScore::bSearchScore(bSearchScore const& sc) noexcept
  : m_score{sc.m_score}
  , m_type{sc.m_type}
{
}
 
bSearchScore::bSearchScore(bSearchScore&& sc) noexcept
  : m_score{std::move(sc.m_score)}
  , m_type{std::move(sc.m_type)}
{
}
 
bSearchScore::bSearchScore(bBestMoveInfo const& bmi, scoretype_t const& st) noexcept
  : m_score{std::move(bmi.getScore())}
  , m_type{st}
{
}
 
bSearchScore& bSearchScore::operator=(bSearchScore&& sc) noexcept
{
  m_score = std::move(sc.m_score);
  m_type  = std::move(sc.m_type);
 
  return *this;
}
 
bSearchScore& bSearchScore::operator=(bScore const& sc) noexcept
{
  m_score = sc;
 
  return *this;
}
 
bSearchScore& bSearchScore::operator=(bScore&& sc) noexcept
{
  m_score = sc;
 
  return *this;
}
 
bSearchScore::~bSearchScore()
{
}
 
bSearchScore bSearchScore::operator-() const
{
  if (!m_type) {
    bSearchScore(-m_score);
  } else if (m_type == tScoreType::SC_ALPHA) {
    return bSearchScore(-m_score, tScoreType::SC_BETA);
  } else if (m_type == tScoreType::SC_BETA) {
    return bSearchScore(-m_score, tScoreType::SC_ALPHA);
  }
  return bSearchScore(-m_score, m_type);
}
 
std::string const operator+(std::string const& lhs, bSearchScore const& sc)
{
  return lhs + sc.operator std::string();
}
 
std::string const operator+(bSearchScore const& sc, std::string const& rhs)
{
  return sc.operator std::string() + rhs;
}
 
bool operator>(bScore const& lhsc, bSearchScore const& rhsc)
{
  return lhsc > rhsc.getRealScore();
}
 
bool operator>=(bScore const& lhsc, bSearchScore const& rhsc)
{
  return lhsc >= rhsc.getRealScore();
}
 
bool operator>(bSearchScore const& lhsc, bScore const& rhsc)
{
  return lhsc.getRealScore() > rhsc;
}
 
bool operator>(bSearchScore const& lhsc, bSearchScore const& rhsc)
{
  return lhsc.getRealScore() > rhsc.getRealScore();
}
 
bSearchScore::operator std::string() const
{
  if (!m_type) {
    return belofte::scoreAsStr(m_score);
#if defined(BELOFTE_NOUNICODE)
  } else if (m_type == tScoreType::SC_ALPHA) {
    return "alpha: " + belofte::scoreAsStr(m_score);
  } else if (m_type == tScoreType::SC_BETA) {
    return "beta: " + belofte::scoreAsStr(m_score);
  } else if (m_type == tScoreType::SC_CHILD) {
    return "search: " + belofte::scoreAsStr(m_score);
  } else if (m_type == tScoreType::SC_BEST) {
    return "best: " + belofte::scoreAsStr(m_score);
#else
  } else if (m_type == tScoreType::SC_ALPHA) {
    return "𝛼: " + belofte::scoreAsStr(m_score);
  } else if (m_type == tScoreType::SC_BETA) {
    return "𝛽: " + belofte::scoreAsStr(m_score);
  } else if (m_type == tScoreType::SC_CHILD) {
    return "⅀: " + belofte::scoreAsStr(m_score);
  } else if (m_type == tScoreType::SC_BEST) {
    return "↑: " + belofte::scoreAsStr(m_score);
#endif
  }
  return belofte::scoreAsStr(m_score);
}
 
//-----------------------------------------------------------------------
 
// eof