src/hlvariant/icsapi_wrapped.h

   1 /*
   2   Copyright (c) 2007 Paolo Capriotti <p.capriotti@gmail.com>
   3             (c) 2007 Maurizio Monge <maurizio.monge@kdemail.net>
   4
   5   This program is free software; you can redistribute it and/or modify
   6   it under the terms of the GNU General Public License as published by
   7   the Free Software Foundation; either version 2 of the License, or
   8   (at your option) any later version.
   9 */
  10
  11 #ifndef HLVARIANT__ICSAPI_WRAPPED_H
  12 #define HLVARIANT__ICSAPI_WRAPPED_H
  13
  14 #include "icsapi.h"
  15 #include "tagua_wrapped.h"
  16
  17 namespace HLVariant {
  18
  19 template <typename Variant>
  20 class WrappedICSAPI : public ICSAPI {
  21 public:
  22   virtual PositionPtr createChessboard(int, bool, bool, bool, bool, const Point&);
  23   virtual PiecePtr createPiece(const QString& description);
  24   virtual MovePtr parseVerbose(const QString& str, const PositionPtr& ref);
  25 };
  26
  27 // IMPLEMENTATION
  28
  29 template <typename Variant>
  30 PositionPtr WrappedICSAPI<Variant>::createChessboard(
  31                           int turn,
  32                           bool wkCastle,
  33                           bool wqCastle,
  34                           bool bkCastle,
  35                           bool bqCastle,
  36                           const Point& enPassant) {
  37   return PositionPtr(new WrappedPosition<Variant>(
  38     typename VariantData<Variant>::GameState(
  39       static_cast<typename VariantData<Variant>::Piece::Color>(turn),
  40       wkCastle,
  41       wqCastle,
  42       bkCastle,
  43       bqCastle,
  44       enPassant)));
  45 }
  46
  47 template <typename Variant>
  48 PiecePtr WrappedICSAPI<Variant>::createPiece(const QString& description) {
  49   return PiecePtr(new WrappedPiece<Variant>(
  50     VariantData<Variant>::Piece::fromDescription(description)));
  51 }
  52
  53 template <typename Variant>
  54 MovePtr WrappedICSAPI<Variant>::parseVerbose(const QString& str, const PositionPtr& _ref) {
  55   if (!_ref)
  56     return MovePtr();
  57
  58   WrappedPosition<Variant>* ref = dynamic_cast<WrappedPosition<Variant>*>(_ref.get());
  59   if (ref) {
  60     typename VariantData<Variant>::Serializer serializer("ics-verbose");
  61     return MovePtr(new WrappedMove<Variant>(
  62       serializer.deserialize(str, ref->inner())));
  63   }
  64   else {
  65     MISMATCH(*_ref.get(), WrappedPosition<Variant>);
  66     return MovePtr();
  67   }
  68 }
  69
  70 /**
  71   * Helper metafunction to create a null ICSAPI object
  72   * if the variant does not support ICS.
  73   */
  74 template <typename Variant, bool hasICS>
  75 struct ReturnICSAPIAux { };
  76
  77 template <typename Variant>
  78 struct ReturnICSAPIAux<Variant, true> {
  79   static ICSAPI* apply() {
  80     return new WrappedICSAPI<Variant>();
  81   }
  82 };
  83
  84 template <typename Variant>
  85 struct ReturnICSAPIAux<Variant, false> {
  86   static ICSAPI* apply() { return 0; }
  87 };
  88
  89 template <typename Variant>
  90 struct ReturnICSAPI
  91 : public ReturnICSAPIAux<Variant, Variant::hasICS> { };
  92
  93
  94
  95 }
  96
  97 #endif // HLVARIANT__ICSAPI_WRAPPED_H
  98