inline Observer& Observer::operator=(const Observer& o) {
iterator i;
for (i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->unregisterObserver(this);
observables_ = o.observables_;
for (i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->registerObserver(this);
return *this;
}
inline void ObservableSettings::enableUpdates() {
boost::lock_guard<boost::mutex> lock(mutex_);
// if there are outstanding deferred updates, do the notification
updatesType_ = UpdatesEnabled;
if (deferredObservers_.size()) {
bool successful = true;
std::string errMsg;
for (iterator i=deferredObservers_.begin();
i!=deferredObservers_.end(); ++i) {
try {
const ext::shared_ptr<Observer::Proxy> proxy = i->lock();
if (proxy)
proxy->update();
} catch (std::exception& e) {
successful = false;
errMsg = e.what();
} catch (...) {
successful = false;
}
}
deferredObservers_.clear();
QL_ENSURE(successful,
"could not notify one or more observers: " << errMsg);
}
}
inline void Observer::unregisterWithAll() {
boost::lock_guard<boost::recursive_mutex> lock(mutex_);
for (iterator i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->unregisterObserver(proxy_);
observables_.clear();
}
inline Observer::~Observer() {
boost::lock_guard<boost::recursive_mutex> lock(mutex_);
if (proxy_)
proxy_->deactivate();
for (iterator i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->unregisterObserver(proxy_);
}
inline Observer& Observer::operator=(const Observer& o) {
boost::lock_guard<boost::recursive_mutex> lock(mutex_);
if (!proxy_) {
proxy_.reset(new Proxy(this));
}
iterator i;
for (i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->unregisterObserver(proxy_);
{
boost::lock_guard<boost::recursive_mutex> lock(o.mutex_);
observables_ = o.observables_;
}
for (i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->registerObserver(proxy_);
return *this;
}
inline Observer::Observer(const Observer& o) {
proxy_.reset(new Proxy(this));
{
boost::lock_guard<boost::recursive_mutex> lock(o.mutex_);
observables_ = o.observables_;
}
for (iterator i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->registerObserver(proxy_);
}
int check_node(int x, int y, int z, MapData * map, int destroy)
{
if (nodes == NULL) {
nodes = (Position*)malloc(sizeof(Position) * NODE_RESERVE_SIZE);
nodes_size = NODE_RESERVE_SIZE;
}
node_pos = 0;
push_back_node(x, y, z);
while (node_pos > 0) {
if (node_pos >= nodes_size - 6) {
nodes_size += NODE_RESERVE_SIZE;
nodes = (Position*)realloc((void*)nodes,
sizeof(Position) * nodes_size);
}
const Position * current_node = pop_back_node();
z = current_node->z;
if (z >= 62) {
marked.clear();
return 1;
}
x = current_node->x;
y = current_node->y;
int i = get_pos(x, y, z);
// already visited?
pair<set_type<int>::iterator, bool> ret;
ret = marked.insert(i);
if (ret.second) {
add_node(x, y, z - 1, map);
add_node(x, y - 1, z, map);
add_node(x, y + 1, z, map);
add_node(x - 1, y, z, map);
add_node(x + 1, y, z, map);
add_node(x, y, z + 1, map);
}
}
// destroy the node's path!
if (destroy) {
for (set_type<int>::const_iterator iter = marked.begin();
iter != marked.end(); ++iter)
{
map->geometry[*iter] = 0;
map->colors.erase(*iter);
}
}
marked.clear();
return 0;
}
//-----------------------------------------------------------------//
handle_type insert(const T& st) {
handle_type h;
if(erase_set_.empty()) {
h = static_cast<handle_type>(array_.size());
array_.push_back(st);
} else {
set_it it = erase_set_.begin();
h = *it;
array_[h] = st;
erase_set_.erase(it);
}
return h;
}
//-----------------------------------------------------------------//
handle_type create() {
handle_type h;
if(erase_set_.empty()) {
if(current_ < limit_) {
h = current_;
++current_;
} else {
current_ = limit_ - 1;
h = 0;
}
} else {
set_it it = erase_set_.begin();
h = *it;
erase_set_.erase(it);
}
return h;
}
powerset_type powerset(set_type const& set)
{
typedef set_type::const_iterator set_iter;
typedef std::vector<set_iter> vec;
typedef vec::iterator vec_iter;
struct local
{
static int dereference(set_iter v) { return *v; }
};
powerset_type result;
vec elements;
do
{
set_type tmp;
std::transform(elements.begin(), elements.end(),
std::inserter(tmp, tmp.end()),
local::dereference);
result.insert(tmp);
if (!elements.empty() && ++elements.back() == set.end())
{
elements.pop_back();
}
else
{
set_iter iter;
if (elements.empty())
{
iter = set.begin();
}
else
{
iter = elements.back();
++iter;
}
for (; iter != set.end(); ++iter)
{
elements.push_back(iter);
}
}
} while (!elements.empty());
return result;
}
inline void Observer::unregisterWithAll() {
for (iterator i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->unregisterObserver(this);
observables_.clear();
}
inline Observer::~Observer() {
for (iterator i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->unregisterObserver(this);
}
inline Observer::Observer(const Observer& o)
: observables_(o.observables_) {
for (iterator i=observables_.begin(); i!=observables_.end(); ++i)
(*i)->registerObserver(this);
}
iterator begin () const {
return m_set.begin ();
}
bool disjoint(const set_type& a, const set_type& b) {
counting_output_iterator out;
return std::set_intersection(a.begin(), a.end(),
b.begin(), b.end(), out).count() == 0;
}
void printSet(set_type s) {
for (typename set_type::iterator p = s.begin(); p != s.end(); p++)
cout << *p << ' ';
cout << endl;
}
