aQute.bnd.osgi.resource.DeferredValueMap Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of biz.aQute.bndlib Show documentation
bndlib: A Swiss Army Knife for OSGi
The newest version!
package aQute.bnd.osgi.resource;

import java.util.AbstractMap;
import java.util.AbstractSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.function.Function;

class DeferredValueMap extends AbstractMap implements Map {
	private final Map map;

	DeferredValueMap(Map map) {
		this.map = map;
	}

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

	@Override
	public boolean containsKey(Object key) {
		return map.containsKey(key);
	}

	@Override
	public boolean containsValue(Object value) {
		return map.containsValue(value);
	}

	@SuppressWarnings("unchecked")
	@Override
	public V get(Object key) {
		V v = map.get(key);
		if (v instanceof DeferredValue) {
			v = ((DeferredValue) v).get();
		}
		return v;
	}

	/**
	 * This get method will not unwrap a DeferredValue.
	 *
	 * @param key The map key.
	 * @return The DeferredValue or value.
	 */
	Object getDeferred(Object key) {
		Object v = map.get(key);
		return v;
	}

	@Override
	public boolean equals(Object o) {
		return map.equals(o);
	}

	@Override
	public int hashCode() {
		return map.hashCode();
	}

	@Override
	public Set> entrySet() {
		return new EntrySet<>(map);
	}

	@Override
	public Set keySet() {
		return map.keySet();
	}

	final static class EntrySet extends AbstractSet> {
		private final Set> entries;

		EntrySet(Map map) {
			this.entries = map.entrySet();
		}

		@Override
		public Iterator> iterator() {
			return new EntryIterator<>(entries);
		}

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

	final static class EntryIterator implements Iterator> {
		private final Iterator> iterator;

		EntryIterator(Set> entries) {
			this.iterator = entries.iterator();
		}

		@Override
		public boolean hasNext() {
			return iterator.hasNext();
		}

		@Override
		public Entry next() {
			Entry entry = iterator.next();
			V v = entry.getValue();
			if (v instanceof DeferredValue) {
				@SuppressWarnings("unchecked")
				DeferredValue deferred = (DeferredValue) v;
				return new DeferredValueEntry<>(entry.getKey(), deferred);
			}
			return entry;
		}
	}

	@Override
	public V put(K key, V value) {
		throw new UnsupportedOperationException();
	}

	@Override
	public V remove(Object key) {
		throw new UnsupportedOperationException();
	}

	@Override
	public void putAll(Map map) {
		throw new UnsupportedOperationException();
	}

	@Override
	public void clear() {
		throw new UnsupportedOperationException();
	}

	@Override
	public void replaceAll(BiFunction function) {
		throw new UnsupportedOperationException();
	}

	@Override
	public V putIfAbsent(K key, V value) {
		throw new UnsupportedOperationException();
	}

	@Override
	public boolean remove(Object key, Object value) {
		throw new UnsupportedOperationException();
	}

	@Override
	public boolean replace(K key, V oldValue, V newValue) {
		throw new UnsupportedOperationException();
	}

	@Override
	public V replace(K key, V value) {
		throw new UnsupportedOperationException();
	}

	@Override
	public V computeIfAbsent(K key, Function mappingFunction) {
		throw new UnsupportedOperationException();
	}

	@Override
	public V computeIfPresent(K key, BiFunction remappingFunction) {
		throw new UnsupportedOperationException();
	}

	@Override
	public V compute(K key, BiFunction remappingFunction) {
		throw new UnsupportedOperationException();
	}

	@Override
	public V merge(K key, V value, BiFunction remappingFunction) {
		throw new UnsupportedOperationException();
	}
}