Move_outcome.hpp

Go to the documentation of this file.

/*******************************************************************************
 Causal Dynamical Triangulations in C++ using CGAL
 
 Copyright © 2026 Adam Getchell
 ******************************************************************************/

 
#ifndef CDT_PLUSPLUS_MOVE_OUTCOME_HPP
#define CDT_PLUSPLUS_MOVE_OUTCOME_HPP
 
#include <cstdint>
#include <expected>
#include <string_view>
 
#include "Move_tracker.hpp"
 
namespace cdt::ergodic_moves
{
  enum class MoveFailure : std::uint8_t
  {
    NO_CANDIDATE,         
    INVALID_TOPOLOGY,     
    CAUSAL_INVALIDITY,    
    STALE_CANDIDATE,      
    EXECUTION_FAILURE,    
    INVARIANT_VIOLATION,  
    UNKNOWN_MOVE          
  };

  struct MoveError
  {
    MoveFailure category;
    move_tracker::MoveType requested_move;

    [[nodiscard]] constexpr auto reason() const noexcept -> MoveFailure
    { return category; }

    [[nodiscard]] constexpr auto move() const noexcept -> move_tracker::MoveType
    { return requested_move; }

    [[nodiscard]] constexpr auto message() const noexcept -> std::string_view
    {
      using enum MoveFailure;
      switch (category)
      {
        case NO_CANDIDATE: return "No raw proposal site is available.";
        case INVALID_TOPOLOGY:
          return "The selected proposal site is not part of the triangulation.";
        case CAUSAL_INVALIDITY:
          return "The selected proposal site violates a CDT move invariant.";
        case STALE_CANDIDATE:
          return "The prepared proposal site no longer exists.";
        case EXECUTION_FAILURE:
          return "CGAL rejected execution of the prepared move.";
        case INVARIANT_VIOLATION:
          return "The executed move violated a manifold postcondition.";
        case UNKNOWN_MOVE: return "The requested Pachner move is unknown.";
      }
      return "The move failed for an unknown reason.";
    }

    auto operator==(MoveError const& other) const -> bool = default;
  };

  template <typename ManifoldType>
  using MoveResult = std::expected<ManifoldType, MoveError>;

  enum class MoveOutcome : std::uint8_t
  {
    INAPPLICABLE        = 0,  
    METROPOLIS_ACCEPTED = 1,  
    METROPOLIS_REJECTED = 2,  
    EXECUTION_FAILED    = 3,  
    SUCCEEDED           = 4   
  };

  class MetropolisTransition
  {
    move_tracker::MoveType m_move;
    MoveOutcome            m_outcome;
 
   public:
    constexpr MetropolisTransition(move_tracker::MoveType const move,
                                   MoveOutcome const outcome) noexcept
        : m_move{move}, m_outcome{outcome}
    {}

    [[nodiscard]] constexpr auto move() const noexcept -> move_tracker::MoveType
    { return m_move; }

    [[nodiscard]] constexpr auto outcome() const noexcept -> MoveOutcome
    { return m_outcome; }

    [[nodiscard]] constexpr auto successful() const noexcept -> bool
    {
      return m_outcome == MoveOutcome::METROPOLIS_ACCEPTED ||
             m_outcome == MoveOutcome::METROPOLIS_REJECTED ||
             m_outcome == MoveOutcome::SUCCEEDED;
    }

    [[nodiscard]] constexpr auto accepted() const noexcept -> bool
    { return m_outcome == MoveOutcome::METROPOLIS_ACCEPTED; }

    auto operator==(MetropolisTransition const& other) const -> bool = default;
  };

  [[nodiscard]] constexpr auto outcome_from(MoveError const error) noexcept
      -> MoveOutcome
  {
    using enum MoveFailure;
    switch (error.reason())
    {
      case NO_CANDIDATE:
      case INVALID_TOPOLOGY:
      case CAUSAL_INVALIDITY: return MoveOutcome::INAPPLICABLE;
      case STALE_CANDIDATE:
      case EXECUTION_FAILURE:
      case INVARIANT_VIOLATION:
      case UNKNOWN_MOVE: return MoveOutcome::EXECUTION_FAILED;
    }
    return MoveOutcome::EXECUTION_FAILED;
  }

  [[nodiscard]] constexpr auto format_as(MoveError const error) noexcept
      -> std::string_view
  { return error.message(); }
}  // namespace cdt::ergodic_moves
 
#endif  // CDT_PLUSPLUS_MOVE_OUTCOME_HPP