org.elasticsearch.util.gnu.trove.decorator.TLongShortHashMapDecorator Maven / Gradle / Ivy
/*
* Licensed to Elastic Search and Shay Banon under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. Elastic Search 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 org.elasticsearch.util.gnu.trove.decorator;
import org.elasticsearch.util.gnu.trove.TLongShortHashMap;
import org.elasticsearch.util.gnu.trove.TLongShortIterator;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.*;
//////////////////////////////////////////////////
// THIS IS A GENERATED CLASS. DO NOT HAND EDIT! //
//////////////////////////////////////////////////
/**
* Wrapper class to make a TLongShortHashMap conform to the java.util.Map API.
* This class simply decorates an underlying TLongShortHashMap and translates the Object-based
* APIs into their Trove primitive analogs.
*
*
* Note that wrapping and unwrapping primitive values is extremely inefficient. If
* possible, users of this class should override the appropriate methods in this class
* and use a table of canonical values.
*
*
* Created: Mon Sep 23 22:07:40 PDT 2002
*
* @author Eric D. Friedman
* @author Rob Eden
*/
public class TLongShortHashMapDecorator extends AbstractMap
implements Map, Externalizable, Cloneable {
/**
* the wrapped primitive map
*/
protected TLongShortHashMap _map;
/**
* FOR EXTERNALIZATION ONLY!!
*/
public TLongShortHashMapDecorator() {
}
/**
* Creates a wrapper that decorates the specified primitive map.
*/
public TLongShortHashMapDecorator(TLongShortHashMap map) {
super();
this._map = map;
}
/**
* Returns a reference to the map wrapped by this decorator.
*/
public TLongShortHashMap getMap() {
return _map;
}
/**
* Clones the underlying trove collection and returns the clone wrapped in a new
* decorator instance. This is a shallow clone except where primitives are
* concerned.
*
* @return a copy of the receiver
*/
public TLongShortHashMapDecorator clone() {
try {
TLongShortHashMapDecorator copy = (TLongShortHashMapDecorator) super.clone();
copy._map = (TLongShortHashMap) _map.clone();
return copy;
} catch (CloneNotSupportedException e) {
// assert(false);
throw new InternalError(); // we are cloneable, so this does not happen
}
}
/**
* Inserts a key/value pair into the map.
*
* @param key an Object
value
* @param value an Object
value
* @return the previous value associated with key,
* or Short(0) if none was found.
*/
public Short put(Long key, Short value) {
return wrapValue(_map.put(unwrapKey(key), unwrapValue(value)));
}
/**
* Retrieves the value for key
*
* @param key an Object
value
* @return the value of key or null if no such mapping exists.
*/
public Short get(Long key) {
long k = unwrapKey(key);
short v = _map.get(k);
// 0 may be a false positive since primitive maps
// cannot return null, so we have to do an extra
// check here.
if (v == 0) {
return _map.containsKey(k) ? wrapValue(v) : null;
} else {
return wrapValue(v);
}
}
/**
* Empties the map.
*/
public void clear() {
this._map.clear();
}
/**
* Deletes a key/value pair from the map.
*
* @param key an Object
value
* @return the removed value, or Short(0) if it was not found in the map
*/
public Short remove(Long key) {
return wrapValue(_map.remove(unwrapKey(key)));
}
/**
* Returns a Set view on the entries of the map.
*
* @return a Set
value
*/
public Set> entrySet() {
return new AbstractSet>() {
public int size() {
return _map.size();
}
public boolean isEmpty() {
return TLongShortHashMapDecorator.this.isEmpty();
}
public boolean contains(Object o) {
if (o instanceof Map.Entry) {
Object k = ((Map.Entry) o).getKey();
Object v = ((Map.Entry) o).getValue();
return TLongShortHashMapDecorator.this.containsKey(k)
&& TLongShortHashMapDecorator.this.get(k).equals(v);
} else {
return false;
}
}
public Iterator> iterator() {
return new Iterator>() {
private final TLongShortIterator it = _map.iterator();
public Map.Entry next() {
it.advance();
final Long key = wrapKey(it.key());
final Short v = wrapValue(it.value());
return new Map.Entry() {
private Short val = v;
public boolean equals(Object o) {
return o instanceof Map.Entry
&& ((Map.Entry) o).getKey().equals(key)
&& ((Map.Entry) o).getValue().equals(val);
}
public Long getKey() {
return key;
}
public Short getValue() {
return val;
}
public int hashCode() {
return key.hashCode() + val.hashCode();
}
public Short setValue(Short value) {
val = value;
return put(key, value);
}
};
}
public boolean hasNext() {
return it.hasNext();
}
public void remove() {
it.remove();
}
};
}
public boolean add(Short o) {
throw new UnsupportedOperationException();
}
public boolean remove(Object o) {
throw new UnsupportedOperationException();
}
public boolean addAll(Collection> c) {
throw new UnsupportedOperationException();
}
public boolean retainAll(Collection c) {
throw new UnsupportedOperationException();
}
public boolean removeAll(Collection c) {
throw new UnsupportedOperationException();
}
public void clear() {
TLongShortHashMapDecorator.this.clear();
}
};
}
/**
* Checks for the presence of val in the values of the map.
*
* @param val an Object
value
* @return a boolean
value
*/
public boolean containsValue(Object val) {
return _map.containsValue(unwrapValue(val));
}
/**
* Checks for the present of key in the keys of the map.
*
* @param key an Object
value
* @return a boolean
value
*/
public boolean containsKey(Object key) {
return _map.containsKey(unwrapKey(key));
}
/**
* Returns the number of entries in the map.
*
* @return the map's size.
*/
public int size() {
return this._map.size();
}
/**
* Indicates whether map has any entries.
*
* @return true if the map is empty
*/
public boolean isEmpty() {
return size() == 0;
}
/**
* Copies the key/value mappings in map into this map.
* Note that this will be a deep copy, as storage is by
* primitive value.
*
* @param map a Map
value
*/
public void putAll(Map map) {
Iterator> it = map.entrySet().iterator();
for (int i = map.size(); i-- > 0;) {
Entry e = it.next();
this.put(e.getKey(), e.getValue());
}
}
/**
* Wraps a key
*
* @param k key in the underlying map
* @return an Object representation of the key
*/
protected Long wrapKey(long k) {
return Long.valueOf(k);
}
/**
* Unwraps a key
*
* @param key wrapped key
* @return an unwrapped representation of the key
*/
protected long unwrapKey(Object key) {
return ((Long) key).longValue();
}
/**
* Wraps a value
*
* @param k value in the underlying map
* @return an Object representation of the value
*/
protected Short wrapValue(short k) {
return Short.valueOf(k);
}
/**
* Unwraps a value
*
* @param value wrapped value
* @return an unwrapped representation of the value
*/
protected short unwrapValue(Object value) {
return ((Short) value).shortValue();
}
// Implements Externalizable
public void readExternal(ObjectInput in)
throws IOException, ClassNotFoundException {
// VERSION
in.readByte();
// MAP
_map = (TLongShortHashMap) in.readObject();
}
// Implements Externalizable
public void writeExternal(ObjectOutput out) throws IOException {
// VERSION
out.writeByte(0);
// MAP
out.writeObject(_map);
}
} // TLongShortHashMapDecorator