kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-04-29 16:23:09 +00:00
Code Issues Releases Wiki Activity

Use the map type template parameter to access map()

Browse source 
It is more natural than using the family subtype and also
use two single maps instead of a std::pair.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2011-09-11 10:45:59 +01:00
parent b706165527
commit 35018fa307
2 changed files with 22 additions and 28 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
src/endgame.cpp
View file

@ -93,16 +93,13 @@ namespace {
return Position(fen, false, 0).get_material_key();
}
typedef Endgames::EMap<Value>::type EFMap;
typedef Endgames::EMap<ScaleFactor>::type SFMap;
} // namespace
/// Endgames member definitions
template<> const EFMap& Endgames::map<Value>() const { return maps.first; }
template<> const SFMap& Endgames::map<ScaleFactor>() const { return maps.second; }
template<> const Endgames::M1& Endgames::map<Endgames::M1>() const { return m1; }
template<> const Endgames::M2& Endgames::map<Endgames::M2>() const { return m2; }
Endgames::Endgames() {
@ -125,10 +122,10 @@ Endgames::Endgames() {
Endgames::~Endgames() {
for (EFMap::const_iterator it = map<Value>().begin(); it != map<Value>().end(); ++it)
for (M1::const_iterator it = m1.begin(); it != m1.end(); ++it)
delete it->second;
for (SFMap::const_iterator it = map<ScaleFactor>().begin(); it != map<ScaleFactor>().end(); ++it)
for (M2::const_iterator it = m2.begin(); it != m2.end(); ++it)
delete it->second;
}
@ -136,23 +133,12 @@ template<EndgameType E>
void Endgames::add(const string& keyCode) {
typedef typename eg_family<E>::type T;
typedef typename EMap<T>::type M;
typedef typename Map<T>::type M;
const_cast<M&>(map<T>()).insert(std::make_pair(mat_key(keyCode), new Endgame<E>(WHITE)));
const_cast<M&>(map<T>()).insert(std::make_pair(mat_key(swap_colors(keyCode)), new Endgame<E>(BLACK)));
const_cast<M&>(map<M>()).insert(std::make_pair(mat_key(keyCode), new Endgame<E>(WHITE)));
const_cast<M&>(map<M>()).insert(std::make_pair(mat_key(swap_colors(keyCode)), new Endgame<E>(BLACK)));
}
template<typename T>
EndgameBase<T>* Endgames::get(Key key) const {
typename EMap<T>::type::const_iterator it = map<T>().find(key);
return it != map<T>().end() ? it->second : NULL;
}
// Explicit template instantiations
template EndgameBase<Value>* Endgames::get<Value>(Key key) const;
template EndgameBase<ScaleFactor>* Endgames::get<ScaleFactor>(Key key) const;
/// Mate with KX vs K. This function is used to evaluate positions with
/// King and plenty of material vs a lone king. It simply gives the

22
src/endgame.h
View file

@ -98,20 +98,28 @@ private:
struct Endgames {
template<typename T>
struct EMap { typedef std::map<Key, EndgameBase<T>*> type; };
struct Map { typedef std::map<Key, EndgameBase<T>*> type; };
typedef Map<Value>::type M1;
typedef Map<ScaleFactor>::type M2;
Endgames();
~Endgames();
template<typename T> EndgameBase<T>* get(Key key) const;
template<typename T>
EndgameBase<T>* get(Key key) const {
typedef typename Map<T>::type M;
typename M::const_iterator it = map<M>().find(key);
return it != map<M>().end() ? it->second : NULL;
}
private:
template<EndgameType E> void add(const std::string& keyCode);
template<typename M> const M& map() const;
// Here we store two maps, for evaluate and scaling functions...
std::pair<EMap<Value>::type, EMap<ScaleFactor>::type> maps;
// ...and here is the accessing template function
template<typename T> const typename EMap<T>::type& map() const;
M1 m1;
M2 m2;
};
#endif // !defined(ENDGAME_H_INCLUDED)