/*
 * Copyright 2014 The Netty Project
 *
 * The Netty Project licenses this file to you under the Apache License, version 2.0 (the
 * "License"); you may not use this file except in compliance with the License. You may obtain a
 * copy of the License at:
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, 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 io.netty.util.collection;

import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;

Utilities for byte-based primitive collections.
/** * Utilities for byte-based primitive collections. */
public final class ByteCollections { private static final ByteObjectMap<Object> EMPTY_MAP = new EmptyMap(); private ByteCollections() { }
Returns an unmodifiable empty ByteObjectMap.
/** * Returns an unmodifiable empty {@link ByteObjectMap}. */
@SuppressWarnings("unchecked") public static <V> ByteObjectMap<V> emptyMap() { return (ByteObjectMap<V>) EMPTY_MAP; }
Creates an unmodifiable wrapper around the given map.
/** * Creates an unmodifiable wrapper around the given map. */
public static <V> ByteObjectMap<V> unmodifiableMap(final ByteObjectMap<V> map) { return new UnmodifiableMap<V>(map); }
An empty map. All operations that attempt to modify the map are unsupported.
/** * An empty map. All operations that attempt to modify the map are unsupported. */
private static final class EmptyMap implements ByteObjectMap<Object> { @Override public Object get(byte key) { return null; } @Override public Object put(byte key, Object value) { throw new UnsupportedOperationException("put"); } @Override public Object remove(byte key) { return null; } @Override public int size() { return 0; } @Override public boolean isEmpty() { return true; } @Override public boolean containsKey(Object key) { return false; } @Override public void clear() { // Do nothing. } @Override public Set<Byte> keySet() { return Collections.emptySet(); } @Override public boolean containsKey(byte key) { return false; } @Override public boolean containsValue(Object value) { return false; } @Override public Iterable<PrimitiveEntry<Object>> entries() { return Collections.emptySet(); } @Override public Object get(Object key) { return null; } @Override public Object put(Byte key, Object value) { throw new UnsupportedOperationException(); } @Override public Object remove(Object key) { return null; } @Override public void putAll(Map<? extends Byte, ?> m) { throw new UnsupportedOperationException(); } @Override public Collection<Object> values() { return Collections.emptyList(); } @Override public Set<Entry<Byte, Object>> entrySet() { return Collections.emptySet(); } }
An unmodifiable wrapper around a ByteObjectMap.
Type parameters:
  • <V> – the value type stored in the map.
/** * An unmodifiable wrapper around a {@link ByteObjectMap}. * * @param <V> the value type stored in the map. */
private static final class UnmodifiableMap<V> implements ByteObjectMap<V> { private final ByteObjectMap<V> map; private Set<Byte> keySet; private Set<Entry<Byte, V>> entrySet; private Collection<V> values; private Iterable<PrimitiveEntry<V>> entries; UnmodifiableMap(ByteObjectMap<V> map) { this.map = map; } @Override public V get(byte key) { return map.get(key); } @Override public V put(byte key, V value) { throw new UnsupportedOperationException("put"); } @Override public V remove(byte key) { throw new UnsupportedOperationException("remove"); } @Override public int size() { return map.size(); } @Override public boolean isEmpty() { return map.isEmpty(); } @Override public void clear() { throw new UnsupportedOperationException("clear"); } @Override public boolean containsKey(byte key) { return map.containsKey(key); } @Override public boolean containsValue(Object value) { return map.containsValue(value); } @Override public boolean containsKey(Object key) { return map.containsKey(key); } @Override public V get(Object key) { return map.get(key); } @Override public V put(Byte key, V value) { throw new UnsupportedOperationException("put"); } @Override public V remove(Object key) { throw new UnsupportedOperationException("remove"); } @Override public void putAll(Map<? extends Byte, ? extends V> m) { throw new UnsupportedOperationException("putAll"); } @Override public Iterable<PrimitiveEntry<V>> entries() { if (entries == null) { entries = new Iterable<PrimitiveEntry<V>>() { @Override public Iterator<PrimitiveEntry<V>> iterator() { return new IteratorImpl(map.entries().iterator()); } }; } return entries; } @Override public Set<Byte> keySet() { if (keySet == null) { keySet = Collections.unmodifiableSet(map.keySet()); } return keySet; } @Override public Set<Entry<Byte, V>> entrySet() { if (entrySet == null) { entrySet = Collections.unmodifiableSet(map.entrySet()); } return entrySet; } @Override public Collection<V> values() { if (values == null) { values = Collections.unmodifiableCollection(map.values()); } return values; }
Unmodifiable wrapper for an iterator.
/** * Unmodifiable wrapper for an iterator. */
private class IteratorImpl implements Iterator<PrimitiveEntry<V>> { final Iterator<PrimitiveEntry<V>> iter; IteratorImpl(Iterator<PrimitiveEntry<V>> iter) { this.iter = iter; } @Override public boolean hasNext() { return iter.hasNext(); } @Override public PrimitiveEntry<V> next() { if (!hasNext()) { throw new NoSuchElementException(); } return new EntryImpl(iter.next()); } @Override public void remove() { throw new UnsupportedOperationException("remove"); } }
Unmodifiable wrapper for an entry.
/** * Unmodifiable wrapper for an entry. */
private class EntryImpl implements PrimitiveEntry<V> { private final PrimitiveEntry<V> entry; EntryImpl(PrimitiveEntry<V> entry) { this.entry = entry; } @Override public byte key() { return entry.key(); } @Override public V value() { return entry.value(); } @Override public void setValue(V value) { throw new UnsupportedOperationException("setValue"); } } } }