Small simplification of endgame functions API
authorMarco Costalba <mcostalba@gmail.com>
Sun, 14 Aug 2011 10:52:27 +0000 (11:52 +0100)
committerMarco Costalba <mcostalba@gmail.com>
Sun, 14 Aug 2011 11:12:14 +0000 (12:12 +0100)
No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
src/endgame.cpp
src/endgame.h
src/material.cpp

index f8f4c802d118441c09a5da4e405867605695a336..c55013f3ac141f531c3bee0192a63ee4da85eb17 100644 (file)
@@ -101,57 +101,59 @@ namespace {
 
 /// Endgames member definitions
 
-template<> const Endgames::EFMap& Endgames::get<EF>() const { return maps.first; }
-template<> const Endgames::SFMap& Endgames::get<SF>() const { return maps.second; }
+template<> const Endgames::EFMap& Endgames::map<EF>() const { return maps.first; }
+template<> const Endgames::SFMap& Endgames::map<SF>() const { return maps.second; }
 
 Endgames::Endgames() {
 
-  add<Endgame<Value, KNNK>  >("KNNK");
-  add<Endgame<Value, KPK>   >("KPK");
-  add<Endgame<Value, KBNK>  >("KBNK");
-  add<Endgame<Value, KRKP>  >("KRKP");
-  add<Endgame<Value, KRKB>  >("KRKB");
-  add<Endgame<Value, KRKN>  >("KRKN");
-  add<Endgame<Value, KQKR>  >("KQKR");
-  add<Endgame<Value, KBBKN> >("KBBKN");
-
-  add<Endgame<ScaleFactor, KNPK>    >("KNPK");
-  add<Endgame<ScaleFactor, KRPKR>   >("KRPKR");
-  add<Endgame<ScaleFactor, KBPKB>   >("KBPKB");
-  add<Endgame<ScaleFactor, KBPPKB>  >("KBPPKB");
-  add<Endgame<ScaleFactor, KBPKN>   >("KBPKN");
-  add<Endgame<ScaleFactor, KRPPKRP> >("KRPPKRP");
+  add<Value, KPK>("KPK");
+  add<Value, KNNK>("KNNK");
+  add<Value, KBNK>("KBNK");
+  add<Value, KRKP>("KRKP");
+  add<Value, KRKB>("KRKB");
+  add<Value, KRKN>("KRKN");
+  add<Value, KQKR>("KQKR");
+  add<Value, KBBKN>("KBBKN");
+
+  add<ScaleFactor, KNPK>("KNPK");
+  add<ScaleFactor, KRPKR>("KRPKR");
+  add<ScaleFactor, KBPKB>("KBPKB");
+  add<ScaleFactor, KBPKN>("KBPKN");
+  add<ScaleFactor, KBPPKB>("KBPPKB");
+  add<ScaleFactor, KRPPKRP>("KRPPKRP");
 }
 
 Endgames::~Endgames() {
 
-  for (EFMap::const_iterator it = get<EF>().begin(); it != get<EF>().end(); ++it)
+  for (EFMap::const_iterator it = map<EF>().begin(); it != map<EF>().end(); ++it)
       delete it->second;
 
-  for (SFMap::const_iterator it = get<SF>().begin(); it != get<SF>().end(); ++it)
+  for (SFMap::const_iterator it = map<SF>().begin(); it != map<SF>().end(); ++it)
       delete it->second;
 }
 
-template<class T>
+template<typename T, EndgameType E>
 void Endgames::add(const string& keyCode) {
 
-  typedef typename T::Base F;
-  typedef std::map<Key, F*> M;
+  typedef Endgame<T, E> EG;
+  typedef typename EG::Base B;
+  typedef std::map<Key, B*> M;
 
-  const_cast<M&>(get<F>()).insert(std::pair<Key, F*>(mat_key(keyCode), new T(WHITE)));
-  const_cast<M&>(get<F>()).insert(std::pair<Key, F*>(mat_key(swap_colors(keyCode)), new T(BLACK)));
+  const_cast<M&>(map<B>()).insert(std::pair<Key, B*>(mat_key(keyCode), new EG(WHITE)));
+  const_cast<M&>(map<B>()).insert(std::pair<Key, B*>(mat_key(swap_colors(keyCode)), new EG(BLACK)));
 }
 
-template<class T>
-T* Endgames::get(Key key) const {
+template<typename T>
+EndgameBase<T>* Endgames::get(Key key) const {
 
-  typename std::map<Key, T*>::const_iterator it = get<T>().find(key);
-  return it != get<T>().end() ? it->second : NULL;
+  typedef EndgameBase<T> E;
+  typename std::map<Key, E*>::const_iterator it = map<E>().find(key);
+  return it != map<E>().end() ? it->second : NULL;
 }
 
 // Explicit template instantiations
-template EF* Endgames::get<EF>(Key key) const;
-template SF* Endgames::get<SF>(Key key) const;
+template EF* Endgames::get<Value>(Key key) const;
+template SF* Endgames::get<ScaleFactor>(Key key) const;
 
 
 /// Mate with KX vs K. This function is used to evaluate positions with
index e35c7b0a1036d8f359e21084a008930036ff61ce..af5da0519ec8bb0bc624ea03459c9eff8dac2c79 100644 (file)
@@ -97,16 +97,16 @@ class Endgames {
 public:
   Endgames();
   ~Endgames();
-  template<class T> T* get(Key key) const;
+  template<typename T> EndgameBase<T>* get(Key key) const;
 
 private:
-  template<class T> void add(const std::string& keyCode);
+  template<typename T, EndgameType E> void add(const std::string& keyCode);
 
   // Here we store two maps, for evaluate and scaling functions...
   std::pair<EFMap, SFMap> maps;
 
   // ...and here is the accessing template function
-  template<typename T> const std::map<Key, T*>& get() const;
+  template<typename T> const std::map<Key, T*>& map() const;
 };
 
 #endif // !defined(ENDGAME_H_INCLUDED)
index 19a334baa25727e35ee2f198b3e72d93e14b7267..ce63e8b5b2df17b95d3fde7abb074c86801db7fa 100644 (file)
@@ -117,7 +117,7 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) const {
   // Let's look if we have a specialized evaluation function for this
   // particular material configuration. First we look for a fixed
   // configuration one, then a generic one if previous search failed.
-  if ((mi->evaluationFunction = funcs->get<EndgameBase<Value> >(key)) != NULL)
+  if ((mi->evaluationFunction = funcs->get<Value>(key)) != NULL)
       return mi;
 
   if (is_KXK<WHITE>(pos))
@@ -154,7 +154,7 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) const {
   // scaling functions and we need to decide which one to use.
   EndgameBase<ScaleFactor>* sf;
 
-  if ((sf = funcs->get<EndgameBase<ScaleFactor> >(key)) != NULL)
+  if ((sf = funcs->get<ScaleFactor>(key)) != NULL)
   {
       mi->scalingFunction[sf->color()] = sf;
       return mi;