void
BHandler::SetFilterList(BList* filters)
{
BLooper* looper = fLooper;
if (looper != NULL && !looper->IsLocked()) {
debugger("Owning Looper must be locked before calling SetFilterList");
return;
}
/**
@note I would like to use BObjectList internally, but this function is
spec'd such that fFilters would get deleted and then assigned
'filters', which would obviously mess this up. Wondering if
anyone ever assigns a list of filters and then checks against
FilterList() to see if they are the same.
*/
// TODO: Explore issues with using BObjectList
if (fFilters != NULL) {
fFilters->DoForEach(FilterDeleter);
delete fFilters;
}
fFilters = filters;
if (fFilters) {
for (int32 i = 0; i < fFilters->CountItems(); ++i) {
BMessageFilter* filter =
static_cast<BMessageFilter*>(fFilters->ItemAt(i));
if (filter != NULL)
filter->SetLooper(looper);
}
}
}
status_t ObservableHandler::notify(
BMessage* message) {
#if DEBUG
BLooper* l = Looper();
ASSERT(l);
ASSERT(l->IsLocked());
#endif
return Invoke(message);
}
status_t ObservableHandler::Archive(
BMessage* archive,
bool deep) const {
#if DEBUG
BLooper* l = Looper();
ASSERT(l);
ASSERT(l->IsLocked());
#endif
if(m_released)
return B_NOT_ALLOWED; // can't archive a dead object
return _inherited::Archive(archive, deep);
}
void ObservableHandler::_handleAddObserver(
BMessage* message) {
#if DEBUG
BLooper* l = Looper();
ASSERT(l);
ASSERT(l->IsLocked());
#endif
BMessage reply;
BMessenger observer;
status_t err = message->FindMessenger(
"observer", &observer);
if(err < B_OK) {
PRINT((
"* ObservableHandler::_handleAddObserver(): no observer specified!\n"));
// send reply? +++++
return;
}
if(m_released) {
// already quitting
reply.what = M_BAD_TARGET;
reply.AddMessenger("target", BMessenger(this));
reply.AddMessenger("observer", observer);
message->SendReply(&reply);
return;
}
else if(IndexOfTarget(observer.Target(0)) != -1) {
// observer already added
reply.what = M_BAD_OBSERVER;
reply.AddMessenger("target", BMessenger(this));
reply.AddMessenger("observer", observer);
message->SendReply(&reply);
return;
}
// valid observer given
// add it
err = AddTarget(observer.Target(0));
ASSERT(err == B_OK);
// call hook
observerAdded(observer);
}
bool
BHandler::RemoveFilter(BMessageFilter* filter)
{
BLooper* looper = fLooper;
if (looper != NULL && !looper->IsLocked()) {
debugger("Owning Looper must be locked before calling SetFilterList");
return false;
}
if (fFilters != NULL && fFilters->RemoveItem((void*)filter)) {
filter->SetLooper(NULL);
return true;
}
return false;
}
void
BHandler::AddFilter(BMessageFilter* filter)
{
BLooper* looper = fLooper;
if (looper != NULL && !looper->IsLocked()) {
debugger("Owning Looper must be locked before calling SetFilterList");
return;
}
if (looper != NULL)
filter->SetLooper(looper);
if (fFilters == NULL)
fFilters = new BList;
fFilters->AddItem(filter);
}
void ObservableHandler::_handleRemoveObserver(
BMessage* message) {
#if DEBUG
BLooper* l = Looper();
ASSERT(l);
ASSERT(l->IsLocked());
#endif
BMessage reply;
BMessenger observer;
status_t err = message->FindMessenger(
"observer", &observer);
if(err < B_OK) {
PRINT((
"* ObservableHandler::_handleRemoveObserver(): no observer specified!\n"));
// send reply? +++++
return;
}
int32 index = IndexOfTarget(observer.Target(0));
if(index == -1) {
reply.what = M_BAD_OBSERVER;
reply.AddMessenger("target", BMessenger(this));
reply.AddMessenger("observer", observer);
message->SendReply(&reply);
return;
}
// valid observer given; remove it & call notification hook
RemoveTarget(index);
observerRemoved(observer);
// time to shut down?
if(m_released && !CountTargets()) {
releaseComplete();
delete this; // BOOM!
}
}
