enum EndgameType {
// Evaluation functions
+
KXK, // Generic "mate lone king" eval
KBNK, // KBN vs K
KPK, // KP vs K
KNNK, // KNN vs K
KmmKm, // K and two minors vs K and one or two minors
+
// Scaling functions
+
KBPsK, // KB+pawns vs K
KQKRPs, // KQ vs KR+pawns
KRPKR, // KRP vs KR
};
-/// Base and derived template class for endgame evaluation and scaling functions
+/// Base and derived templates for endgame evaluation and scaling functions
template<typename T>
struct EndgameBase {
/// and scaling base objects. Then we use polymorphism to invoke the actual
/// endgame function calling its apply() method that is virtual.
-class Endgames {
+struct Endgames {
- typedef std::map<Key, EndgameBase<Value>*> EFMap;
- typedef std::map<Key, EndgameBase<ScaleFactor>*> SFMap;
+ template<typename T>
+ struct EMap { typedef std::map<Key, EndgameBase<T>*> type; };
-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;
+ std::pair<EMap<Value>::type, EMap<ScaleFactor>::type> maps;
// ...and here is the accessing template function
- template<typename T> const std::map<Key, T*>& get() const;
+ template<typename T> const typename EMap<T>::type& map() const;
};
#endif // !defined(ENDGAME_H_INCLUDED)