/* * Copyright (C) 2006-2007 Sun Microsystems, Inc. All rights reserved. Use is * subject to license terms. */package org.jdesktop.observablecollections;import java.util.AbstractList;import java.util.AbstractMap;import java.util.AbstractSet;import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;import java.util.List;import java.util.Map;import java.util.Set;import java.util.concurrent.CopyOnWriteArrayList;/** * {@code ObservableCollections} provides factory methods for creating * observable lists and maps. *  *  * @author sky */public final class ObservableCollections {    /**     * Creates and returns an {@code ObservableMap} wrapping the supplied     * {@code Map}.     *     * @param map the {@code Map} to wrap     * @return an {@code ObservableMap}     * @throws IllegalArgumentException if {@code map} is {@code null}     */    public static <K,V> ObservableMap<K,V> observableMap(Map<K,V> map) {        if (map == null) {            throw new IllegalArgumentException("Map must be non-null");        }        return new ObservableMapImpl<K,V>(map);    }    /**     * Creates and returns an {@code ObservableList} wrapping the supplied     * {@code List}.     *     * @param list the {@code List} to wrap     * @return an {@code ObservableList}     * @throws IllegalArgumentException if {@code list} is {@code null}     */    public static <E> ObservableList<E> observableList(List<E> list) {        if (list == null) {            throw new IllegalArgumentException("List must be non-null");        }        return new ObservableListImpl<E>(list, false);    }    /**     * Creates and returns an {@code ObservableListHelper} wrapping     * the supplied {@code List}. If you can track changes to the underlying     * list, use this method instead of {@code observableList()}.     *     * @param list the {@code List} to wrap     * @return an {@code ObservableList}     * @throws IllegalArgumentException if {@code list} is {@code null}     *     * @see #observableList     */    public static <E> ObservableListHelper<E> observableListHelper(List<E> list) {        ObservableListImpl<E> oList = new ObservableListImpl<E>(list, true);        return new ObservableListHelper<E>(oList);    }        /**     * {@code ObservableListHelper} is created by {@code observableListHelper},     * and useful when changes to individual elements of the list can be     * tracked.     *     * @see #observableListHelper     */    public static final class ObservableListHelper<E> {        private final ObservableListImpl<E> list;        ObservableListHelper(ObservableListImpl<E> list) {            this.list = list;        }        /**         * Returns the {@code ObservableList}.         *         * @return the observable list         */        public ObservableList<E> getObservableList() {            return list;        }        /**         * Sends notification that the element at the specified index         * has changed.         *         * @param index the index of the element that has changed         * @throws ArrayIndexOutOfBoundsException if index is outside the         *         range of the {@code List} ({@code < 0 || >= size})         */        public void fireElementChanged(int index) {            if (index < 0 || index >= list.size()) {                throw new ArrayIndexOutOfBoundsException("Illegal index");            }            list.fireElementChanged(index);        }    }    private static final class ObservableMapImpl<K,V> extends AbstractMap<K,V>             implements ObservableMap<K,V> {        private Map<K,V> map;        private List<ObservableMapListener> listeners;        private Set<Map.Entry<K,V>> entrySet;                ObservableMapImpl(Map<K,V> map) {            this.map = map;            listeners = new CopyOnWriteArrayList<ObservableMapListener>();        }                public void clear() {            // Remove all elements via iterator to trigger notification            Iterator<K> iterator = keySet().iterator();            while (iterator.hasNext()) {                iterator.next();                iterator.remove();            }        }        public boolean containsKey(Object key) {            return map.containsKey(key);        }        public boolean containsValue(Object value) {            return map.containsValue(value);        }        public Set<Map.Entry<K,V>> entrySet() {            Set<Map.Entry<K,V>> es = entrySet;            return es != null ? es : (entrySet = new EntrySet());        }                public V get(Object key) {            return map.get(key);        }        public boolean isEmpty() {            return map.isEmpty();        }                public V put(K key, V value) {            V lastValue;            if (containsKey(key)) {                lastValue = map.put(key, value);                for (ObservableMapListener listener : listeners) {                    listener.mapKeyValueChanged(this, key, lastValue);                }            } else {                lastValue = map.put(key, value);                for (ObservableMapListener listener : listeners) {                    listener.mapKeyAdded(this, key);                }            }            return lastValue;        }                public void putAll(Map<? extends K, ? extends V> m) {            for (K key : m.keySet()) {                put(key, m.get(key));            }        }                public V remove(Object key) {            if (containsKey(key)) {                V value = map.remove(key);                for (ObservableMapListener listener : listeners) {                    listener.mapKeyRemoved(this, key, value);                }                return value;            }            return null;        }                public int size() {            return map.size();        }                public void addObservableMapListener(ObservableMapListener listener) {            listeners.add(listener);        }        public void removeObservableMapListener(ObservableMapListener listener) {            listeners.remove(listener);        }                        private class EntryIterator implements Iterator<Map.Entry<K,V>> {            private Iterator<Map.Entry<K,V>> realIterator;            private Map.Entry<K,V> last;                        EntryIterator() {                realIterator = map.entrySet().iterator();            }            public boolean hasNext() {                return realIterator.hasNext();            }            public Map.Entry<K,V> next() {                last = realIterator.next();                return last;            }            public void remove() {                if (last == null) {                    throw new IllegalStateException();                }                Object toRemove = last.getKey();                last = null;                ObservableMapImpl.this.remove(toRemove);            }        }                private class EntrySet extends AbstractSet<Map.Entry<K,V>> {            public Iterator<Map.Entry<K,V>> iterator() {                return new EntryIterator();            }            @SuppressWarnings("unchecked")            public boolean contains(Object o) {                if (!(o instanceof Map.Entry)) {                    return false;                }                Map.Entry<K,V> e = (Map.Entry<K,V>)o;                return containsKey(e.getKey());            }            @SuppressWarnings("unchecked")            public boolean remove(Object o) {                if (o instanceof Map.Entry) {                    K key = ((Map.Entry<K,V>)o).getKey();                    if (containsKey(key)) {                        remove(key);                        return true;                    }                }                return false;            }                        public int size() {                return ObservableMapImpl.this.size();            }            public void clear() {                ObservableMapImpl.this.clear();            }        }    }        private static final class ObservableListImpl<E> extends AbstractList<E>            implements ObservableList<E> {        private final boolean supportsElementPropertyChanged;        private List<E> list;        private List<ObservableListListener> listeners;                ObservableListImpl(List<E> list, boolean supportsElementPropertyChanged) {            this.list = list;            listeners = new CopyOnWriteArrayList<ObservableListListener>();            this.supportsElementPropertyChanged = supportsElementPropertyChanged;        }        public E get(int index) {            return list.get(index);        }        public int size() {            return list.size();        }        public E set(int index, E element) {            E oldValue = list.set(index, element);            for (ObservableListListener listener : listeners) {                listener.listElementReplaced(this, index, oldValue);            }            return oldValue;        }        public void add(int index, E element) {            list.add(index, element);            modCount++;            for (ObservableListListener listener : listeners) {                listener.listElementsAdded(this, index, 1);            }        }        public E remove(int index) {            E oldValue = list.remove(index);            modCount++;            for (ObservableListListener listener : listeners) {                listener.listElementsRemoved(this, index,                        java.util.Collections.singletonList(oldValue));            }            return oldValue;        }        public boolean addAll(Collection<? extends E> c) {            return addAll(size(), c);        }                public boolean addAll(int index, Collection<? extends E> c) {            if (list.addAll(index, c)) {                modCount++;                for (ObservableListListener listener : listeners) {                    listener.listElementsAdded(this, index, c.size());                }            }            return false;        }        public void clear() {            List<E> dup = new ArrayList<E>(list);            list.clear();            modCount++;            if (dup.size() != 0) {                for (ObservableListListener listener : listeners) {                    listener.listElementsRemoved(this, 0, dup);                }            }        }        public boolean containsAll(Collection<?> c) {            return list.containsAll(c);        }        public <T> T[] toArray(T[] a) {            return list.toArray(a);        }        public Object[] toArray() {            return list.toArray();        }        private void fireElementChanged(int index) {            for (ObservableListListener listener : listeners) {                listener.listElementPropertyChanged(this, index);            }        }        public void addObservableListListener(ObservableListListener listener) {            listeners.add(listener);        }        public void removeObservableListListener(ObservableListListener listener) {            listeners.remove(listener);        }        public boolean supportsElementPropertyChanged() {            return supportsElementPropertyChanged;        }    }}