/*
- * Copyright 2005 the original author or authors.
+ * Copyright 2005-2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
- */
-
+ */
package org.wamblee.observer;
-import java.util.List;
import java.util.ArrayList;
+import java.util.List;
import java.util.Map;
import java.util.TreeMap;
-import org.apache.log4j.Logger;
-
/**
* Implements subscription and notification logic for an observer pattern. This
* class is thread safe.
*/
public class Observable<ObservableType, Event> {
-
- private static final Logger LOGGER = Logger.getLogger(Observable.class);
-
/**
* Observable.
*/
- private ObservableType _observable;
+ private ObservableType observable;
/**
* Used to notify observers.
*/
- private ObserverNotifier<ObservableType, Event> _notifier;
+ private ObserverNotifier<ObservableType, Event> notifier;
/**
* Map of subscription to observer.
*/
- private Map<Long, Observer<ObservableType, Event>> _observers;
+ private Map<Long, Observer<ObservableType, Event>> observers;
/**
* Counter for subscriptions. Holds the next subscription.
*/
- private long _counter;
+ private long counter;
/**
* Constructs the observable.
* Object used for implementing notification of listeners.
*/
public Observable(ObservableType aObservable,
- ObserverNotifier<ObservableType, Event> aNotifier) {
- _observable = aObservable;
- _notifier = aNotifier;
- _observers = new TreeMap<Long, Observer<ObservableType, Event>>();
- _counter = 0;
+ ObserverNotifier<ObservableType, Event> aNotifier) {
+ observable = aObservable;
+ notifier = aNotifier;
+ observers = new TreeMap<Long, Observer<ObservableType, Event>>();
+ counter = 0;
}
/**
* @return Event Event to send.
*/
public synchronized long subscribe(Observer<ObservableType, Event> aObserver) {
- long subscription = _counter++; // integer rage is so large it will
- // never roll over.
- _observers.put(subscription, aObserver);
+ long subscription = counter++; // integer rage is so large it will
+ // never roll over.
+
+ observers.put(subscription, aObserver);
+
return subscription;
}
* In case the subscription is not known.
*/
public synchronized void unsubscribe(long aSubscription) {
- Object obj = _observers.remove(aSubscription);
+ Object obj = observers.remove(aSubscription);
+
if (obj == null) {
- throw new IllegalArgumentException("Subscription '" + aSubscription
- + "'");
+ throw new IllegalArgumentException("Subscription '" +
+ aSubscription + "'");
}
}
* @return Number of subscribed observers.
*/
public int getObserverCount() {
- return _observers.size();
+ return observers.size();
}
/**
// Make sure we do the notification while not holding the lock to avoid
// potential deadlock
// situations.
- List<Observer<ObservableType, Event>> observers = new ArrayList<Observer<ObservableType, Event>>();
+ List<Observer<ObservableType, Event>> myObservers = new ArrayList<Observer<ObservableType, Event>>();
+
synchronized (this) {
- observers.addAll(_observers.values());
+ myObservers.addAll(observers.values());
}
- for (Observer<ObservableType, Event> observer : observers) {
- _notifier.update(observer, _observable, aEvent);
- }
- }
- /*
- * (non-Javadoc)
- *
- * @see java.lang.Object#finalize()
- */
- @Override
- protected void finalize() throws Throwable {
- if (_observers.size() > 0) {
- LOGGER
- .error("Still observers registered at finalization of observer!");
- for (Observer observer : _observers.values()) {
- LOGGER.error(" observer: " + observer);
- }
+ for (Observer<ObservableType, Event> observer : myObservers) {
+ notifier.update(observer, observable, aEvent);
}
-
- super.finalize();
}
-
}