org.ioc.commons.impl.android.common.util.ObservableHashSet Maven / Gradle / Ivy

Go to download
package org.ioc.commons.impl.android.common.util;

import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Observable;
import java.util.Observer;
import java.util.Set;

import org.ioc.commons.model.features.ObservableOperation;

/**
 * An HashSet which implements Observable.
 * 
 * When the set is modified by adding, or removing an element, the registered
 * observers will receive an {@link ObservableChange} instance as argument.
 * 
 * @author Jesús Lunar Pérez
 * 
 * @param 
 */
public class ObservableHashSet extends Observable implements Set {

	private final Set dataSet = new HashSet();

	public ObservableHashSet(Observer... observers) {
		addObservers(observers);
	}

	public void addObservers(Observer... observers) {
		if (observers != null) {
			for (Observer observer : observers) {
				this.addObserver(observer);
			}
		}
	}

	public void deleteObservers(Observer... observers) {
		if (observers != null) {
			for (Observer observer : observers) {
				this.deleteObserver(observer);
			}
		}
	}

	@Override
	public int size() {
		return dataSet.size();
	}

	@Override
	public boolean isEmpty() {
		return dataSet.isEmpty();
	}

	@Override
	public boolean contains(Object o) {
		return dataSet.contains(o);
	}

	@Override
	public Iterator iterator() {
		return new ObservableIteratorWrapper(dataSet.iterator()) {

			@Override
			public void removed(E elm) {
				ObservableHashSet.this.setChanged();
				notifyObservers(new ObservableChange(ObservableOperation.Remove, Collections.singleton(elm)));
			}
		};
	}

	@Override
	public Object[] toArray() {
		return dataSet.toArray();
	}

	@Override
	public  T[] toArray(T[] a) {
		return dataSet.toArray(a);
	}

	@Override
	public boolean add(E e) {
		boolean add = dataSet.add(e);
		if (add) {
			this.setChanged();
			notifyObservers(new ObservableChange(ObservableOperation.Add, Collections.singleton(e)));
		}
		return add;
	}

	@Override
	public boolean remove(Object o) {
		boolean remove = dataSet.remove(o);
		if (remove) {
			this.setChanged();
			notifyObservers(new ObservableChange(ObservableOperation.Remove, Collections.singleton(o)));
		}
		return remove;
	}

	@Override
	public boolean containsAll(Collection c) {
		return dataSet.containsAll(c);
	}

	@Override
	public boolean addAll(Collection c) {
		boolean addAll = dataSet.addAll(c);
		if (addAll) {
			this.setChanged();
			notifyObservers(new ObservableChange(ObservableOperation.Add, c));
		}
		return addAll;
	}

	@Override
	public boolean removeAll(Collection c) {
		boolean removeAll = dataSet.removeAll(c);
		if (removeAll) {
			this.setChanged();
			notifyObservers(new ObservableChange(ObservableOperation.Remove, c));
		}
		return removeAll;
	}

	@Override
	public boolean retainAll(Collection c) {
		boolean retainAll = dataSet.retainAll(c);
		if (retainAll) {
			this.setChanged();
			notifyObservers(new ObservableChange(ObservableOperation.Remove, c));
		}
		return retainAll;
	}

	@Override
	public void clear() {
		HashSet previous = new HashSet(dataSet);
		boolean anyChanged = !previous.isEmpty();
		if (anyChanged) {
			dataSet.clear();
			this.setChanged();
			notifyObservers(new ObservableChange(ObservableOperation.Remove, previous));
		}
	}

	@Override
	public String toString() {
		return dataSet.toString();
	}
}