Application: gvSIG desktop » Library: org.gvsig.tools

package org.gvsig.tools.util;

import java.util.AbstractMap;

import java.util.Arrays;

import java.util.Collection;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

/**

 *

 * @author jjdelcerro

 * 

 * @param <K> the type of keys maintained by this map

 * @param <V> the type of mapped values

 *

 */

public class UnmodifiableBasicMapToMapAdapter<K,V> implements Map<K,V> {

    private final UnmodifiableBasicMap<K,V> umap;

    public UnmodifiableBasicMapToMapAdapter(UnmodifiableBasicMap<K,V> umap ) {

        this.umap = umap;

    }

    @Override

    public int size() {

        return this.umap.size();

    }

    @Override

    public boolean isEmpty() {

        return this.umap.isEmpty();

    }

    @Override

    public boolean containsKey(Object key) {

        return this.umap.containsKey((K) key);

    }

    @Override

    public boolean containsValue(Object value) {

        for (V v : umap) {

            if( value == v ) {

                return true;

            }

            if( value!= null &&  v!=null ) {

                if( value.equals(v) ) {

                    return true;

                }

            }

        }

        return false;

    }

    @Override

    public V get(Object key) {

        return (V) this.umap.get((K) key);

    }

    @Override

    public Set<K> keySet() {    

        return new UnmodifiableBasicMapKeySet();

    }

    @Override

    public Collection<V> values() {

        return new UnmodifiableBasicMapValues();

    }

    @Override

    public Set<Entry<K, V>> entrySet() {

        return new UnmodifiableBasicMapEntrySet();

    }

    @Override

    public V put(K key, V value) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public V remove(Object key) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public void putAll(Map<? extends K, ? extends V> m) {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    @Override

    public void clear() {

        throw new UnsupportedOperationException("Not supported yet."); 

    }

    private abstract class AbstractUnmodifiableBasicMapCollection {

        public int size() {

            return umap.size();

        }

        public boolean isEmpty() {

            return umap.isEmpty();

        }

        public abstract boolean contains(Object value);

        public abstract Iterator iterator();

        public boolean containsAll(Collection c) {

            for (Object element : c) {

                if( !contains(element) ) {

                    return false;

                }

            }

            return true;

        }

        public Object[] toArray(Object[] a) {

            int sz = this.size();

            if( a.length<sz ) {

                a = Arrays.copyOf(new Object[] { null }, sz, a.getClass());

            }

            int n = 0;

            Iterator it = this.iterator();

            while( it.hasNext() ) {

                a[n] = it.next();

            }

            return a;

        }

        public Object[] toArray() {

            throw new UnsupportedOperationException("Not supported yet."); 

        }

        public boolean add(Object e) {

            throw new UnsupportedOperationException("Not supported yet."); 

        }

        public boolean remove(Object o) {

            throw new UnsupportedOperationException("Not supported yet."); 

        }

        public boolean addAll(Collection c) {

            throw new UnsupportedOperationException("Not supported yet."); 

        }

        public boolean retainAll(Collection c) {

            throw new UnsupportedOperationException("Not supported yet."); 

        }

        public boolean removeAll(Collection c) {

            throw new UnsupportedOperationException("Not supported yet."); 

        }

        public void clear() {

            throw new UnsupportedOperationException("Not supported yet."); 

        }

    }

    class UnmodifiableBasicMapEntrySet 

            extends AbstractUnmodifiableBasicMapCollection 

            implements Set {

        @Override

        public boolean contains(Object value) {

            for (K key : umap.keySet()) {

                Map.Entry entry = new AbstractMap.SimpleEntry<>(key, umap.get(key));

                if( value == entry ) {

                    return true;

                }

                if( value!= null ) {

                    if( value.equals(entry) ) {

                        return true;

                    }

                }

            }

            return false;

        }

        @Override

        public Iterator<Entry<K,V>> iterator() {

            final Iterator<K> it = umap.keySet().iterator();

            return new Iterator<Entry<K,V>>() {

                @Override

                public boolean hasNext() {

                    return it.hasNext();

                }

                @Override

                public Entry<K, V> next() {

                    K key = it.next();

                    Map.Entry entry = new AbstractMap.SimpleEntry<>(key, umap.get(key));

                    return entry;

                }

            };

        }

    }

    class UnmodifiableBasicMapKeySet 

            extends AbstractUnmodifiableBasicMapCollection 

            implements Set {

        @Override

        public boolean contains(Object value) {

            return umap.keySet().contains((K) value);

        }

        @Override

        public Iterator<K> iterator() {

            return umap.keySet().iterator();

        }

    }

    class UnmodifiableBasicMapValues 

            extends AbstractUnmodifiableBasicMapCollection 

            implements Collection {

        @Override

        public boolean contains(Object value) {

            for (V v : umap) {

                if( value == v ) {

                    return true;

                }

                if( value!= null &&  v!=null ) {

                    if( value.equals(v) ) {

                        return true;

                    }

                }

            }

            return false;

        }

        @Override

        public Iterator<V> iterator() {

            return umap.iterator();

        }

    }

}