MapWritable.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:4k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Copyright 2007 The Apache Software Foundation
  3.  *
  4.  * Licensed to the Apache Software Foundation (ASF) under one
  5.  * or more contributor license agreements.  See the NOTICE file
  6.  * distributed with this work for additional information
  7.  * regarding copyright ownership.  The ASF licenses this file
  8.  * to you under the Apache License, Version 2.0 (the
  9.  * "License"); you may not use this file except in compliance
  10.  * with the License.  You may obtain a copy of the License at
  11.  *
  12.  *     http://www.apache.org/licenses/LICENSE-2.0
  13.  *
  14.  * Unless required by applicable law or agreed to in writing, software
  15.  * distributed under the License is distributed on an "AS IS" BASIS,
  16.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17.  * See the License for the specific language governing permissions and
  18.  * limitations under the License.
  19.  */
  20. package org.apache.hadoop.io;
  21. import java.io.DataInput;
  22. import java.io.DataOutput;
  23. import java.io.IOException;
  24. import java.util.Collection;
  25. import java.util.HashMap;
  26. import java.util.Map;
  27. import java.util.Set;
  28. import org.apache.hadoop.util.ReflectionUtils;
  29. /**
  30.  * A Writable Map.
  31.  */
  32. public class MapWritable extends AbstractMapWritable
  33.   implements Map<Writable, Writable> {
  34.   private Map<Writable, Writable> instance;
  35.   
  36.   /** Default constructor. */
  37.   public MapWritable() {
  38.     super();
  39.     this.instance = new HashMap<Writable, Writable>();
  40.   }
  41.   
  42.   /**
  43.    * Copy constructor.
  44.    * 
  45.    * @param other the map to copy from
  46.    */
  47.   public MapWritable(MapWritable other) {
  48.     this();
  49.     copy(other);
  50.   }
  51.   
  52.   /** {@inheritDoc} */
  53.   public void clear() {
  54.     instance.clear();
  55.   }
  56.   /** {@inheritDoc} */
  57.   public boolean containsKey(Object key) {
  58.     return instance.containsKey(key);
  59.   }
  60.   /** {@inheritDoc} */
  61.   public boolean containsValue(Object value) {
  62.     return instance.containsValue(value);
  63.   }
  64.   /** {@inheritDoc} */
  65.   public Set<Map.Entry<Writable, Writable>> entrySet() {
  66.     return instance.entrySet();
  67.   }
  68.   /** {@inheritDoc} */
  69.   public Writable get(Object key) {
  70.     return instance.get(key);
  71.   }
  72.   
  73.   /** {@inheritDoc} */
  74.   public boolean isEmpty() {
  75.     return instance.isEmpty();
  76.   }
  77.   /** {@inheritDoc} */
  78.   public Set<Writable> keySet() {
  79.     return instance.keySet();
  80.   }
  81.   /** {@inheritDoc} */
  82.   @SuppressWarnings("unchecked")
  83.   public Writable put(Writable key, Writable value) {
  84.     addToMap(key.getClass());
  85.     addToMap(value.getClass());
  86.     return instance.put(key, value);
  87.   }
  88.   /** {@inheritDoc} */
  89.   public void putAll(Map<? extends Writable, ? extends Writable> t) {
  90.     for (Map.Entry<? extends Writable, ? extends Writable> e: t.entrySet()) {
  91.       put(e.getKey(), e.getValue());
  92.     }
  93.   }
  94.   /** {@inheritDoc} */
  95.   public Writable remove(Object key) {
  96.     return instance.remove(key);
  97.   }
  98.   /** {@inheritDoc} */
  99.   public int size() {
  100.     return instance.size();
  101.   }
  102.   /** {@inheritDoc} */
  103.   public Collection<Writable> values() {
  104.     return instance.values();
  105.   }
  106.   
  107.   // Writable
  108.   
  109.   /** {@inheritDoc} */
  110.   @Override
  111.   public void write(DataOutput out) throws IOException {
  112.     super.write(out);
  113.     
  114.     // Write out the number of entries in the map
  115.     
  116.     out.writeInt(instance.size());
  117.     // Then write out each key/value pair
  118.     
  119.     for (Map.Entry<Writable, Writable> e: instance.entrySet()) {
  120.       out.writeByte(getId(e.getKey().getClass()));
  121.       e.getKey().write(out);
  122.       out.writeByte(getId(e.getValue().getClass()));
  123.       e.getValue().write(out);
  124.     }
  125.   }
  126.   /** {@inheritDoc} */
  127.   @SuppressWarnings("unchecked")
  128.   @Override
  129.   public void readFields(DataInput in) throws IOException {
  130.     super.readFields(in);
  131.     
  132.     // First clear the map.  Otherwise we will just accumulate
  133.     // entries every time this method is called.
  134.     this.instance.clear();
  135.     
  136.     // Read the number of entries in the map
  137.     
  138.     int entries = in.readInt();
  139.     
  140.     // Then read each key/value pair
  141.     
  142.     for (int i = 0; i < entries; i++) {
  143.       Writable key = (Writable) ReflectionUtils.newInstance(getClass(
  144.           in.readByte()), getConf());
  145.       
  146.       key.readFields(in);
  147.       
  148.       Writable value = (Writable) ReflectionUtils.newInstance(getClass(
  149.           in.readByte()), getConf());
  150.       
  151.       value.readFields(in);
  152.       instance.put(key, value);
  153.     }
  154.   }
  155. }