// warranty.
/**
- * @file debug_map_base.hpp
+ * @file detail/debug_map_base.hpp
* Contains a debug-mode base for all maps.
*/
{ return (__out << '(' << p.first << ',' << p.second << ')'); }
#define PB_DS_CLASS_T_DEC \
- template<typename Key, class Eq_Fn, typename Const_Key_Reference>
+ template<typename Key, typename Eq_Fn, typename Const_Key_Reference>
#define PB_DS_CLASS_C_DEC \
debug_map_base<Key, Eq_Fn, Const_Key_Reference>
- template<typename Key, class Eq_Fn, typename Const_Key_Reference>
+ /// Debug base class.
+ template<typename Key, typename Eq_Fn, typename Const_Key_Reference>
class debug_map_base
{
private:
- typedef typename std::allocator<Key> key_allocator;
- typedef typename key_allocator::size_type size_type;
- typedef Const_Key_Reference const_key_reference;
- typedef std::_GLIBCXX_STD_C::list<Key> key_set;
- typedef typename key_set::iterator key_set_iterator;
- typedef typename key_set::const_iterator const_key_set_iterator;
- typedef __gnu_cxx::throw_allocator_random<Key> key_db_allocator;
- typedef typename key_db_allocator::never_adjustor never_adjustor;
+ typedef Const_Key_Reference key_const_reference;
+ typedef std::_GLIBCXX_STD_C::list<Key> key_repository;
+ typedef typename key_repository::size_type size_type;
+ typedef typename key_repository::iterator iterator;
+ typedef typename key_repository::const_iterator const_iterator;
protected:
debug_map_base();
- debug_map_base(const PB_DS_CLASS_C_DEC& other);
+ debug_map_base(const PB_DS_CLASS_C_DEC&);
~debug_map_base();
inline void
- insert_new(const_key_reference r_key);
+ insert_new(key_const_reference);
inline void
- erase_existing(const_key_reference r_key);
+ erase_existing(key_const_reference);
void
clear();
inline void
- check_key_exists(const_key_reference r_key,
- const char* file, int line) const;
+ check_key_exists(key_const_reference, const char*, int) const;
inline void
- check_key_does_not_exist(const_key_reference r_key,
- const char* file, int line) const;
+ check_key_does_not_exist(key_const_reference, const char*, int) const;
inline void
- check_size(size_type size, const char* file, int line) const;
+ check_size(size_type, const char*, int) const;
void
- swap(PB_DS_CLASS_C_DEC& other);
+ swap(PB_DS_CLASS_C_DEC&);
template<typename Cmp_Fn>
void
- split(const_key_reference, Cmp_Fn, PB_DS_CLASS_C_DEC&);
+ split(key_const_reference, Cmp_Fn, PB_DS_CLASS_C_DEC&);
void
- join(PB_DS_CLASS_C_DEC& other, bool with_cleanup = true);
+ join(PB_DS_CLASS_C_DEC&, bool with_cleanup = true);
private:
void
- assert_valid(const char* file, int line) const;
+ assert_valid(const char*, int) const;
- const_key_set_iterator
- find(const_key_reference r_key) const;
+ const_iterator
+ find(key_const_reference) const;
- key_set_iterator
- find(const_key_reference r_key);
+ iterator
+ find(key_const_reference);
- key_set m_key_set;
- Eq_Fn m_eq;
+ key_repository m_keys;
+ Eq_Fn m_eq;
};
PB_DS_CLASS_T_DEC
PB_DS_CLASS_T_DEC
PB_DS_CLASS_C_DEC::
- debug_map_base(const PB_DS_CLASS_C_DEC& other) : m_key_set(other.m_key_set)
+ debug_map_base(const PB_DS_CLASS_C_DEC& other)
+ : m_keys(other.m_keys), m_eq(other.m_eq)
{ PB_DS_ASSERT_VALID((*this)) }
PB_DS_CLASS_T_DEC
PB_DS_CLASS_T_DEC
inline void
PB_DS_CLASS_C_DEC::
- insert_new(const_key_reference r_key)
+ insert_new(key_const_reference r_key)
{
PB_DS_ASSERT_VALID((*this))
- if (find(r_key) != m_key_set.end())
+ if (find(r_key) != m_keys.end())
{
std::cerr << "insert_new key already present " << r_key << std::endl;
- std::abort;
+ std::abort();
}
- never_adjustor never;
__try
{
- m_key_set.push_back(r_key);
+ m_keys.push_back(r_key);
}
__catch(...)
{
PB_DS_CLASS_T_DEC
inline void
PB_DS_CLASS_C_DEC::
- erase_existing(const_key_reference r_key)
+ erase_existing(key_const_reference r_key)
{
PB_DS_ASSERT_VALID((*this))
- key_set_iterator it = find(r_key);
- if (it == m_key_set.end())
+ iterator it = find(r_key);
+ if (it == m_keys.end())
{
std::cerr << "erase_existing" << r_key << std::endl;
std::abort();
}
- m_key_set.erase(it);
+ m_keys.erase(it);
PB_DS_ASSERT_VALID((*this))
}
clear()
{
PB_DS_ASSERT_VALID((*this))
- m_key_set.clear();
+ m_keys.clear();
PB_DS_ASSERT_VALID((*this))
}
PB_DS_CLASS_T_DEC
inline void
PB_DS_CLASS_C_DEC::
- check_key_exists(const_key_reference r_key,
+ check_key_exists(key_const_reference r_key,
const char* __file, int __line) const
{
assert_valid(__file, __line);
- if (find(r_key) == m_key_set.end())
+ if (find(r_key) == m_keys.end())
{
std::cerr << __file << ':' << __line << ": check_key_exists "
<< r_key << std::endl;
PB_DS_CLASS_T_DEC
inline void
PB_DS_CLASS_C_DEC::
- check_key_does_not_exist(const_key_reference r_key,
+ check_key_does_not_exist(key_const_reference r_key,
const char* __file, int __line) const
{
assert_valid(__file, __line);
- if (find(r_key) != m_key_set.end())
+ if (find(r_key) != m_keys.end())
{
using std::cerr;
using std::endl;
check_size(size_type size, const char* __file, int __line) const
{
assert_valid(__file, __line);
- const size_type key_set_size = m_key_set.size();
- if (size != key_set_size)
+ const size_type keys_size = m_keys.size();
+ if (size != keys_size)
{
- std::cerr << __file << ':' << __line << ": check_size " << size
- << " != " << key_set_size << std::endl;
+ std::cerr << __file << ':' << __line << ": check_size "
+ << size << " != " << keys_size << std::endl;
std::abort();
}
}
swap(PB_DS_CLASS_C_DEC& other)
{
PB_DS_ASSERT_VALID((*this))
- m_key_set.swap(other.m_key_set);
+ m_keys.swap(other.m_keys);
+ std::swap(m_eq, other.m_eq);
PB_DS_ASSERT_VALID((*this))
}
PB_DS_CLASS_T_DEC
- typename PB_DS_CLASS_C_DEC::const_key_set_iterator
+ typename PB_DS_CLASS_C_DEC::const_iterator
PB_DS_CLASS_C_DEC::
- find(const_key_reference r_key) const
+ find(key_const_reference r_key) const
{
PB_DS_ASSERT_VALID((*this))
- typedef const_key_set_iterator iterator_type;
- for (iterator_type it = m_key_set.begin(); it != m_key_set.end(); ++it)
+ typedef const_iterator iterator_type;
+ for (iterator_type it = m_keys.begin(); it != m_keys.end(); ++it)
if (m_eq(*it, r_key))
return it;
- return m_key_set.end();
+ return m_keys.end();
}
PB_DS_CLASS_T_DEC
- typename PB_DS_CLASS_C_DEC::key_set_iterator
+ typename PB_DS_CLASS_C_DEC::iterator
PB_DS_CLASS_C_DEC::
- find(const_key_reference r_key)
+ find(key_const_reference r_key)
{
PB_DS_ASSERT_VALID((*this))
- key_set_iterator it = m_key_set.begin();
- while (it != m_key_set.end())
+ iterator it = m_keys.begin();
+ while (it != m_keys.end())
{
if (m_eq(*it, r_key))
return it;
PB_DS_CLASS_C_DEC::
assert_valid(const char* __file, int __line) const
{
- const_key_set_iterator prime_it = m_key_set.begin();
- while (prime_it != m_key_set.end())
+ const_iterator prime_it = m_keys.begin();
+ while (prime_it != m_keys.end())
{
- const_key_set_iterator sec_it = prime_it;
+ const_iterator sec_it = prime_it;
++sec_it;
- while (sec_it != m_key_set.end())
+ while (sec_it != m_keys.end())
{
PB_DS_DEBUG_VERIFY(!m_eq(*sec_it, *prime_it));
PB_DS_DEBUG_VERIFY(!m_eq(*prime_it, *sec_it));
template<typename Cmp_Fn>
void
PB_DS_CLASS_C_DEC::
- split(const_key_reference r_key, Cmp_Fn cmp_fn, PB_DS_CLASS_C_DEC& other)
+ split(key_const_reference r_key, Cmp_Fn cmp_fn, PB_DS_CLASS_C_DEC& other)
{
other.clear();
- key_set_iterator it = m_key_set.begin();
- while (it != m_key_set.end())
- if (cmp_fn(r_key, * it))
+ iterator it = m_keys.begin();
+ while (it != m_keys.end())
+ if (cmp_fn(r_key, *it))
{
other.insert_new(*it);
- it = m_key_set.erase(it);
+ it = m_keys.erase(it);
}
else
++it;
PB_DS_CLASS_C_DEC::
join(PB_DS_CLASS_C_DEC& other, bool with_cleanup)
{
- key_set_iterator it = other.m_key_set.begin();
- while (it != other.m_key_set.end())
+ iterator it = other.m_keys.begin();
+ while (it != other.m_keys.end())
{
insert_new(*it);
if (with_cleanup)
- it = other.m_key_set.erase(it);
+ it = other.m_keys.erase(it);
else
++it;
}
- _GLIBCXX_DEBUG_ASSERT(!with_cleanup || other.m_key_set.empty());
+ _GLIBCXX_DEBUG_ASSERT(!with_cleanup || other.m_keys.empty());
}
#undef PB_DS_CLASS_T_DEC
OSDN Git Service
