/*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch 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.hadoop.mr;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import org.apache.hadoop.io.ArrayWritable;
import org.apache.hadoop.io.MapWritable;
import org.apache.hadoop.io.Writable;
import org.apache.hadoop.util.ReflectionUtils;
/**
* Similar to {@link MapWritable} expect that it uses a {@link LinkedHashMap} underneath to preserve insertion order (and thus its structure). Extends {@link MapWritable} for compatibility reasons.
*/
public class LinkedMapWritable extends MapWritable {
private Map<Writable, Writable> instance;
/** Default constructor. */
public LinkedMapWritable() {
this.instance = new LinkedHashMap<Writable, Writable>();
addToMap(LinkedMapWritable.class);
}
/**
* Copy constructor.
*
* @param other the map to copy from
*/
public LinkedMapWritable(MapWritable other) {
this();
copy(other);
}
/** {@inheritDoc} */
public void clear() {
instance.clear();
}
/** {@inheritDoc} */
public boolean containsKey(Object key) {
return instance.containsKey(key);
}
/** {@inheritDoc} */
public boolean containsValue(Object value) {
return instance.containsValue(value);
}
/** {@inheritDoc} */
public Set<Map.Entry<Writable, Writable>> entrySet() {
return instance.entrySet();
}
/** {@inheritDoc} */
public Writable get(Object key) {
return instance.get(key);
}
/** {@inheritDoc} */
public boolean isEmpty() {
return instance.isEmpty();
}
/** {@inheritDoc} */
public Set<Writable> keySet() {
return instance.keySet();
}
/** {@inheritDoc} */
public Writable put(Writable key, Writable value) {
addToMap(key.getClass());
addToMap(value.getClass());
return instance.put(key, value);
}
/** {@inheritDoc} */
public void putAll(Map<? extends Writable, ? extends Writable> t) {
for (Map.Entry<? extends Writable, ? extends Writable> e : t.entrySet()) {
put(e.getKey(), e.getValue());
}
}
/** {@inheritDoc} */
public Writable remove(Object key) {
return instance.remove(key);
}
/** {@inheritDoc} */
public int size() {
return instance.size();
}
/** {@inheritDoc} */
public Collection<Writable> values() {
return instance.values();
}
// Writable
/** {@inheritDoc} */
@Override
public void write(DataOutput out) throws IOException {
super.write(out);
// Write out the number of entries in the map
out.writeInt(instance.size());
// Then write out each key/value pair
for (Map.Entry<Writable, Writable> e : instance.entrySet()) {
out.writeByte(getId(e.getKey().getClass()));
e.getKey().write(out);
out.writeByte(getId(e.getValue().getClass()));
e.getValue().write(out);
}
}
/** {@inheritDoc} */
@SuppressWarnings("unchecked")
@Override
public void readFields(DataInput in) throws IOException {
super.readFields(in);
// First clear the map. Otherwise we will just accumulate
// entries every time this method is called.
this.instance.clear();
// Read the number of entries in the map
int entries = in.readInt();
// Then read each key/value pair
for (int i = 0; i < entries; i++) {
Writable key = (Writable) ReflectionUtils.newInstance(getClass(in.readByte()), getConf());
key.readFields(in);
Writable value = (Writable) ReflectionUtils.newInstance(getClass(in.readByte()), getConf());
value.readFields(in);
instance.put(key, value);
}
}
@SuppressWarnings("unchecked")
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof Map))
return false;
Map<Writable, Writable> m = (Map<Writable, Writable>) o;
if (m.size() != size())
return false;
try {
Iterator<Entry<Writable, Writable>> i = entrySet().iterator();
while (i.hasNext()) {
Entry<Writable, Writable> e = i.next();
Writable key = e.getKey();
Writable value = e.getValue();
if (value == null) {
if (!(m.get(key) == null && m.containsKey(key)))
return false;
}
else {
if (!value.equals(m.get(key)))
return false;
}
}
} catch (ClassCastException unused) {
return false;
} catch (NullPointerException unused) {
return false;
}
return true;
}
@Override
public int hashCode() {
int h = 0;
Iterator<Entry<Writable, Writable>> i = entrySet().iterator();
while (i.hasNext())
h += i.next().hashCode();
return h;
}
@Override
public String toString() {
Iterator<Entry<Writable, Writable>> i = entrySet().iterator();
if (!i.hasNext())
return "{}";
StringBuilder sb = new StringBuilder();
sb.append('{');
for (;;) {
Entry<Writable, Writable> e = i.next();
Writable key = e.getKey();
Writable value = e.getValue();
sb.append(key == this ? "(this Map)" : key);
sb.append('=');
if (value instanceof ArrayWritable) {
sb.append(Arrays.toString(((ArrayWritable) value).get()));
}
else {
sb.append(value == this ? "(this Map)" : value);
}
if (!i.hasNext())
return sb.append('}').toString();
sb.append(", ");
}
}
}