236 lines
8.2 KiB
C++
236 lines
8.2 KiB
C++
|
// Boost.Signals2 library
|
||
|
|
|
||
|
|
// Copyright Frank Mori Hess 2007-2008.
|
||
|
|
// Use, modification and
|
||
|
|
// distribution is subject to the Boost Software License, Version
|
||
|
|
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||
|
|
// http://www.boost.org/LICENSE_1_0.txt)
|
||
|
|
|
||
|
|
// For more information, see http://www.boost.org
|
||
|
|
|
||
|
|
#ifndef BOOST_SIGNALS2_SLOT_GROUPS_HPP
|
||
|
|
#define BOOST_SIGNALS2_SLOT_GROUPS_HPP
|
||
|
|
|
||
|
|
#include <boost/signals2/connection.hpp>
|
||
|
|
#include <boost/optional.hpp>
|
||
|
|
#include <list>
|
||
|
|
#include <map>
|
||
|
|
#include <utility>
|
||
|
|
|
||
|
|
namespace boost {
|
||
|
|
namespace signals2 {
|
||
|
|
namespace detail {
|
||
|
|
enum slot_meta_group {front_ungrouped_slots, grouped_slots, back_ungrouped_slots};
|
||
|
|
template<typename Group>
|
||
|
|
struct group_key
|
||
|
|
{
|
||
|
|
typedef std::pair<enum slot_meta_group, boost::optional<Group> > type;
|
||
|
|
};
|
||
|
|
template<typename Group, typename GroupCompare>
|
||
|
|
class group_key_less
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
group_key_less()
|
||
|
|
{}
|
||
|
|
group_key_less(const GroupCompare &group_compare): _group_compare(group_compare)
|
||
|
|
{}
|
||
|
|
bool operator ()(const typename group_key<Group>::type &key1, const typename group_key<Group>::type &key2) const
|
||
|
|
{
|
||
|
|
if(key1.first != key2.first) return key1.first < key2.first;
|
||
|
|
if(key1.first != grouped_slots) return false;
|
||
|
|
return _group_compare(key1.second.get(), key2.second.get());
|
||
|
|
}
|
||
|
|
private:
|
||
|
|
GroupCompare _group_compare;
|
||
|
|
};
|
||
|
|
template<typename Group, typename GroupCompare, typename ValueType>
|
||
|
|
class grouped_list
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
typedef group_key_less<Group, GroupCompare> group_key_compare_type;
|
||
|
|
private:
|
||
|
|
typedef std::list<ValueType> list_type;
|
||
|
|
typedef std::map
|
||
|
|
<
|
||
|
|
typename group_key<Group>::type,
|
||
|
|
typename list_type::iterator,
|
||
|
|
group_key_compare_type
|
||
|
|
> map_type;
|
||
|
|
typedef typename map_type::iterator map_iterator;
|
||
|
|
typedef typename map_type::const_iterator const_map_iterator;
|
||
|
|
public:
|
||
|
|
typedef typename list_type::iterator iterator;
|
||
|
|
typedef typename list_type::const_iterator const_iterator;
|
||
|
|
typedef typename group_key<Group>::type group_key_type;
|
||
|
|
|
||
|
|
grouped_list(const group_key_compare_type &group_key_compare):
|
||
|
|
_group_key_compare(group_key_compare)
|
||
|
|
{}
|
||
|
|
grouped_list(const grouped_list &other): _list(other._list),
|
||
|
|
_group_map(other._group_map), _group_key_compare(other._group_key_compare)
|
||
|
|
{
|
||
|
|
// fix up _group_map
|
||
|
|
typename map_type::const_iterator other_map_it;
|
||
|
|
typename list_type::iterator this_list_it = _list.begin();
|
||
|
|
typename map_type::iterator this_map_it = _group_map.begin();
|
||
|
|
for(other_map_it = other._group_map.begin();
|
||
|
|
other_map_it != other._group_map.end();
|
||
|
|
++other_map_it, ++this_map_it)
|
||
|
|
{
|
||
|
|
BOOST_ASSERT(this_map_it != _group_map.end());
|
||
|
|
this_map_it->second = this_list_it;
|
||
|
|
typename list_type::const_iterator other_list_it = other.get_list_iterator(other_map_it);
|
||
|
|
typename map_type::const_iterator other_next_map_it = other_map_it;
|
||
|
|
++other_next_map_it;
|
||
|
|
typename list_type::const_iterator other_next_list_it = other.get_list_iterator(other_next_map_it);
|
||
|
|
while(other_list_it != other_next_list_it)
|
||
|
|
{
|
||
|
|
++other_list_it;
|
||
|
|
++this_list_it;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
iterator begin()
|
||
|
|
{
|
||
|
|
return _list.begin();
|
||
|
|
}
|
||
|
|
iterator end()
|
||
|
|
{
|
||
|
|
return _list.end();
|
||
|
|
}
|
||
|
|
iterator lower_bound(const group_key_type &key)
|
||
|
|
{
|
||
|
|
map_iterator map_it = _group_map.lower_bound(key);
|
||
|
|
return get_list_iterator(map_it);
|
||
|
|
}
|
||
|
|
iterator upper_bound(const group_key_type &key)
|
||
|
|
{
|
||
|
|
map_iterator map_it = _group_map.upper_bound(key);
|
||
|
|
return get_list_iterator(map_it);
|
||
|
|
}
|
||
|
|
void push_front(const group_key_type &key, const ValueType &value)
|
||
|
|
{
|
||
|
|
map_iterator map_it;
|
||
|
|
if(key.first == front_ungrouped_slots)
|
||
|
|
{// optimization
|
||
|
|
map_it = _group_map.begin();
|
||
|
|
}else
|
||
|
|
{
|
||
|
|
map_it = _group_map.lower_bound(key);
|
||
|
|
}
|
||
|
|
m_insert(map_it, key, value);
|
||
|
|
}
|
||
|
|
void push_back(const group_key_type &key, const ValueType &value)
|
||
|
|
{
|
||
|
|
map_iterator map_it;
|
||
|
|
if(key.first == back_ungrouped_slots)
|
||
|
|
{// optimization
|
||
|
|
map_it = _group_map.end();
|
||
|
|
}else
|
||
|
|
{
|
||
|
|
map_it = _group_map.upper_bound(key);
|
||
|
|
}
|
||
|
|
m_insert(map_it, key, value);
|
||
|
|
}
|
||
|
|
void erase(const group_key_type &key)
|
||
|
|
{
|
||
|
|
map_iterator map_it = _group_map.lower_bound(key);
|
||
|
|
iterator begin_list_it = get_list_iterator(map_it);
|
||
|
|
iterator end_list_it = upper_bound(key);
|
||
|
|
if(begin_list_it != end_list_it)
|
||
|
|
{
|
||
|
|
_list.erase(begin_list_it, end_list_it);
|
||
|
|
_group_map.erase(map_it);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
iterator erase(const group_key_type &key, const iterator &it)
|
||
|
|
{
|
||
|
|
BOOST_ASSERT(it != _list.end());
|
||
|
|
map_iterator map_it = _group_map.lower_bound(key);
|
||
|
|
BOOST_ASSERT(map_it != _group_map.end());
|
||
|
|
BOOST_ASSERT(weakly_equivalent(map_it->first, key));
|
||
|
|
if(map_it->second == it)
|
||
|
|
{
|
||
|
|
iterator next = it;
|
||
|
|
++next;
|
||
|
|
// if next is in same group
|
||
|
|
if(next != upper_bound(key))
|
||
|
|
{
|
||
|
|
_group_map[key] = next;
|
||
|
|
}else
|
||
|
|
{
|
||
|
|
_group_map.erase(map_it);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return _list.erase(it);
|
||
|
|
}
|
||
|
|
void clear()
|
||
|
|
{
|
||
|
|
_list.clear();
|
||
|
|
_group_map.clear();
|
||
|
|
}
|
||
|
|
private:
|
||
|
|
/* Suppress default assignment operator, since it has the wrong semantics. */
|
||
|
|
grouped_list& operator=(const grouped_list &other);
|
||
|
|
|
||
|
|
bool weakly_equivalent(const group_key_type &arg1, const group_key_type &arg2)
|
||
|
|
{
|
||
|
|
if(_group_key_compare(arg1, arg2)) return false;
|
||
|
|
if(_group_key_compare(arg2, arg1)) return false;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
void m_insert(const map_iterator &map_it, const group_key_type &key, const ValueType &value)
|
||
|
|
{
|
||
|
|
iterator list_it = get_list_iterator(map_it);
|
||
|
|
iterator new_it = _list.insert(list_it, value);
|
||
|
|
if(map_it != _group_map.end() && weakly_equivalent(key, map_it->first))
|
||
|
|
{
|
||
|
|
_group_map.erase(map_it);
|
||
|
|
}
|
||
|
|
map_iterator lower_bound_it = _group_map.lower_bound(key);
|
||
|
|
if(lower_bound_it == _group_map.end() ||
|
||
|
|
weakly_equivalent(lower_bound_it->first, key) == false)
|
||
|
|
{
|
||
|
|
/* doing the following instead of just
|
||
|
|
_group_map[key] = new_it;
|
||
|
|
to avoid bogus error when enabling checked iterators with g++ */
|
||
|
|
_group_map.insert(typename map_type::value_type(key, new_it));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
iterator get_list_iterator(const const_map_iterator &map_it)
|
||
|
|
{
|
||
|
|
iterator list_it;
|
||
|
|
if(map_it == _group_map.end())
|
||
|
|
{
|
||
|
|
list_it = _list.end();
|
||
|
|
}else
|
||
|
|
{
|
||
|
|
list_it = map_it->second;
|
||
|
|
}
|
||
|
|
return list_it;
|
||
|
|
}
|
||
|
|
const_iterator get_list_iterator(const const_map_iterator &map_it) const
|
||
|
|
{
|
||
|
|
const_iterator list_it;
|
||
|
|
if(map_it == _group_map.end())
|
||
|
|
{
|
||
|
|
list_it = _list.end();
|
||
|
|
}else
|
||
|
|
{
|
||
|
|
list_it = map_it->second;
|
||
|
|
}
|
||
|
|
return list_it;
|
||
|
|
}
|
||
|
|
|
||
|
|
list_type _list;
|
||
|
|
// holds iterators to first list item in each group
|
||
|
|
map_type _group_map;
|
||
|
|
group_key_compare_type _group_key_compare;
|
||
|
|
};
|
||
|
|
} // end namespace detail
|
||
|
|
enum connect_position { at_back, at_front };
|
||
|
|
} // end namespace signals2
|
||
|
|
} // end namespace boost
|
||
|
|
|
||
|
|
#endif // BOOST_SIGNALS2_SLOT_GROUPS_HPP
|