exceptions.hpp

#ifndef _TARTAN_BOARD_EXCEPTIONS_HPP_
#define _TARTAN_BOARD_EXCEPTIONS_HPP_
 
#include <tartan/board.hpp>
#include <stdexcept>
#include <string>
 
namespace tt::ex {
 
class tartan : public std::logic_error {
public:
    using logic_error::logic_error;
    virtual ~tartan() = default;
};
 
class bad_set : public tartan {
public:
    bad_set(
        const std::string& what_arg = "Can not produce piece set"
    ) : tartan(what_arg) {};
};
 
class bad_piece : public tartan {
public:
    bad_piece(
        const Piece* p, 
        const std::string& what_arg = "Invalid piece"
    ) : tartan(what_arg) { e_piece = p; }
    const Piece* piece() const { return e_piece; };
private:
    const Piece* e_piece;
};
 
class null_piece : public bad_piece {
public:
    null_piece(
        const std::string what_arg = "Piece does not exists"
    ) : bad_piece(nullptr, what_arg) {};
    const Piece* piece() const = delete;
};
 
class foreign_piece : public bad_piece {
public:
    foreign_piece(
        const Piece* p, 
        const Board* b, 
        const std::string& what_arg = "Piece does not belong to this board"
    ) : bad_piece(p, what_arg) { e_board = b; };
    const Board* board() const { return e_board; };
private:
    const Board* e_board;
};
 
class bad_piece_spec : public bad_piece {
public:
    bad_piece_spec(
        const std::string& spec,
        const std::string what_arg = "Invalid piece specification"
    ) : bad_piece(nullptr, what_arg) { e_spec = spec; };  
    const std::string& spec() const { return e_spec; };
private:
    std::string e_spec;
};
 
class position_is_taken : public bad_piece {
public:
    position_is_taken(
        const Piece* p, 
        const std::string& what_arg = "Piece position is taken"
    ) : bad_piece(p, what_arg) {};
};
    
class illegal_move : public tartan {
public:
    illegal_move(const Piece* p, const Piece::Position& to, 
                            const std::string& what_arg = "Illegal move") : 
        tartan(what_arg), e_piece(p), e_to(to) {
    };
    const Piece* piece() const { return e_piece; };
    const Piece::Position& to() const { return e_to; };
    virtual ~illegal_move() = default;
private:
    const Piece* e_piece;
    const Piece::Position& e_to;
};
 
class tile_is_empty : public illegal_move {
public:
    tile_is_empty(
        const Piece::Position& from, 
        const Piece::Position& to, 
        const std::string& what_arg = "Selected tile is empty") 
    :   illegal_move(nullptr, to, what_arg), e_from(from) {};
    const Piece* piece() = delete;
    const Piece::Position& from() const { return e_from; };
private:
    const Piece::Position& e_from;
};
 
class piece_in_wrong_color : public illegal_move {
public:
    piece_in_wrong_color(
        const Piece* p, 
        const Piece::Position& to, 
        const std::string& what_arg = "Moved piece is in wrong color") 
    :   illegal_move(p, to, what_arg) {};
};
 
class can_not_move : public illegal_move {
public:
    can_not_move(
        const Piece* p,
        const Piece::Position& to, 
        const std::string& what_arg = "Selected piece can't move") 
    :   illegal_move(p, to, what_arg) {};
};
 
class no_such_move : public illegal_move {
public:
    no_such_move(
        const Piece* p,
        const Piece::Position& to, 
        const std::string& what_arg = "Selected piece can't perform such move") 
    :   illegal_move(p, to, what_arg) {};
};
 
class illegal_turn : public tartan {
public:
    illegal_turn(const std::string& what_arg) :
        tartan(what_arg) {};
    illegal_turn(const char* what_arg) :
        tartan(what_arg) {};
};
 
class bad_piece_type : public tartan {
public:
    bad_piece_type(const std::string what_arg = "Piece type is illegal") :
        tartan(what_arg) {};
};
 
}
 
#endif // !_TARTAN_BOARD_EXCEPTIONS_HPP_