src/hlvariant/icsapi_wrapped.h

   1 #ifndef HLVARIANT__ICSAPI_WRAPPED_H
   2 #define HLVARIANT__ICSAPI_WRAPPED_H
   3
   4 #include "icsapi.h"
   5 #include "tagua_wrapped.h"
   6
   7 namespace HLVariant {
   8
   9 template <typename Variant>
  10 class WrappedICSAPI : public ICSAPI {
  11 public:
  12   virtual PositionPtr createChessboard(int, bool, bool, bool, bool, const Point&);
  13   virtual PiecePtr createPiece(const QString& description);
  14   virtual MovePtr parseVerbose(const QString& str, const PositionPtr& ref);
  15 };
  16
  17 // IMPLEMENTATION
  18
  19 template <typename Variant>
  20 PositionPtr WrappedICSAPI<Variant>::createChessboard(
  21                           int turn,
  22                           bool wkCastle,
  23                           bool wqCastle,
  24                           bool bkCastle,
  25                           bool bqCastle,
  26                           const Point& enPassant) {
  27   return PositionPtr(new WrappedPosition<Variant>(
  28     typename VariantData<Variant>::GameState(
  29       static_cast<typename VariantData<Variant>::Piece::Color>(turn),
  30       wkCastle,
  31       wqCastle,
  32       bkCastle,
  33       bqCastle,
  34       enPassant)));
  35 }
  36
  37 template <typename Variant>
  38 PiecePtr WrappedICSAPI<Variant>::createPiece(const QString& description) {
  39   return PiecePtr(new WrappedPiece<Variant>(
  40     VariantData<Variant>::Piece::fromDescription(description)));
  41 }
  42
  43 template <typename Variant>
  44 MovePtr WrappedICSAPI<Variant>::parseVerbose(const QString& str, const PositionPtr& _ref) {
  45   if (!_ref)
  46     return MovePtr();
  47
  48   WrappedPosition<Variant>* ref = dynamic_cast<WrappedPosition<Variant>*>(_ref.get());
  49   if (ref) {
  50     typename VariantData<Variant>::Serializer serializer(
  51       VariantData<Variant>::Serializer::ICS_VERBOSE);
  52     return MovePtr(new WrappedMove<Variant>(
  53       serializer.deserialize(str, ref->inner())));
  54   }
  55   else {
  56     MISMATCH(*_ref.get(), WrappedPosition<Variant>);
  57     return MovePtr();
  58   }
  59 }
  60
  61 /**
  62   * Helper metafunction to create a null ICSAPI object
  63   * if the variant does not support ICS.
  64   */
  65 template <typename Variant, bool hasICS>
  66 struct ReturnICSAPIAux { };
  67
  68 template <typename Variant>
  69 struct ReturnICSAPIAux<Variant, true> {
  70   static ICSAPI* apply() {
  71     return new WrappedICSAPI<Variant>();
  72   }
  73 };
  74
  75 template <typename Variant>
  76 struct ReturnICSAPIAux<Variant, false> {
  77   static ICSAPI* apply() { return 0; }
  78 };
  79
  80 template <typename Variant>
  81 struct ReturnICSAPI
  82 : public ReturnICSAPIAux<Variant, Variant::hasICS> { };
  83
  84
  85
  86 }
  87
  88 #endif // HLVARIANT__ICSAPI_WRAPPED_H
  89