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

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.io;
  19. import java.io.IOException;
  20. import java.io.DataInput;
  21. import java.io.DataOutput;
  22. import org.apache.commons.logging.Log;
  23. import org.apache.commons.logging.LogFactory;
  24. /** 
  25.  * A byte sequence that is usable as a key or value.
  26.  * It is resizable and distinguishes between the size of the seqeunce and
  27.  * the current capacity. The hash function is the front of the md5 of the 
  28.  * buffer. The sort order is the same as memcmp.
  29.  */
  30. public class BytesWritable extends BinaryComparable
  31.     implements WritableComparable<BinaryComparable> {
  32.   private static final Log LOG = LogFactory.getLog(BytesWritable.class);
  33.   private static final int LENGTH_BYTES = 4;
  34.   private static final byte[] EMPTY_BYTES = {};
  35.   private int size;
  36.   private byte[] bytes;
  37.   
  38.   /**
  39.    * Create a zero-size sequence.
  40.    */
  41.   public BytesWritable() {this(EMPTY_BYTES);}
  42.   
  43.   /**
  44.    * Create a BytesWritable using the byte array as the initial value.
  45.    * @param bytes This array becomes the backing storage for the object.
  46.    */
  47.   public BytesWritable(byte[] bytes) {
  48.     this.bytes = bytes;
  49.     this.size = bytes.length;
  50.   }
  51.   
  52.   /**
  53.    * Get the data from the BytesWritable.
  54.    * @return The data is only valid between 0 and getLength() - 1.
  55.    */
  56.   public byte[] getBytes() {
  57.     return bytes;
  58.   }
  59.   /**
  60.    * Get the data from the BytesWritable.
  61.    * @deprecated Use {@link #getBytes()} instead.
  62.    */
  63.   @Deprecated
  64.   public byte[] get() {
  65.     return getBytes();
  66.   }
  67.   /**
  68.    * Get the current size of the buffer.
  69.    */
  70.   public int getLength() {
  71.     return size;
  72.   }
  73.   /**
  74.    * Get the current size of the buffer.
  75.    * @deprecated Use {@link #getLength()} instead.
  76.    */
  77.   @Deprecated
  78.   public int getSize() {
  79.     return getLength();
  80.   }
  81.   
  82.   /**
  83.    * Change the size of the buffer. The values in the old range are preserved
  84.    * and any new values are undefined. The capacity is changed if it is 
  85.    * necessary.
  86.    * @param size The new number of bytes
  87.    */
  88.   public void setSize(int size) {
  89.     if (size > getCapacity()) {
  90.       setCapacity(size * 3 / 2);
  91.     }
  92.     this.size = size;
  93.   }
  94.   
  95.   /**
  96.    * Get the capacity, which is the maximum size that could handled without
  97.    * resizing the backing storage.
  98.    * @return The number of bytes
  99.    */
  100.   public int getCapacity() {
  101.     return bytes.length;
  102.   }
  103.   
  104.   /**
  105.    * Change the capacity of the backing storage.
  106.    * The data is preserved.
  107.    * @param new_cap The new capacity in bytes.
  108.    */
  109.   public void setCapacity(int new_cap) {
  110.     if (new_cap != getCapacity()) {
  111.       byte[] new_data = new byte[new_cap];
  112.       if (new_cap < size) {
  113.         size = new_cap;
  114.       }
  115.       if (size != 0) {
  116.         System.arraycopy(bytes, 0, new_data, 0, size);
  117.       }
  118.       bytes = new_data;
  119.     }
  120.   }
  121.   /**
  122.    * Set the BytesWritable to the contents of the given newData.
  123.    * @param newData the value to set this BytesWritable to.
  124.    */
  125.   public void set(BytesWritable newData) {
  126.     set(newData.bytes, 0, newData.size);
  127.   }
  128.   /**
  129.    * Set the value to a copy of the given byte range
  130.    * @param newData the new values to copy in
  131.    * @param offset the offset in newData to start at
  132.    * @param length the number of bytes to copy
  133.    */
  134.   public void set(byte[] newData, int offset, int length) {
  135.     setSize(0);
  136.     setSize(length);
  137.     System.arraycopy(newData, offset, bytes, 0, size);
  138.   }
  139.   // inherit javadoc
  140.   public void readFields(DataInput in) throws IOException {
  141.     setSize(0); // clear the old data
  142.     setSize(in.readInt());
  143.     in.readFully(bytes, 0, size);
  144.   }
  145.   
  146.   // inherit javadoc
  147.   public void write(DataOutput out) throws IOException {
  148.     out.writeInt(size);
  149.     out.write(bytes, 0, size);
  150.   }
  151.   
  152.   public int hashCode() {
  153.     return super.hashCode();
  154.   }
  155.   /**
  156.    * Are the two byte sequences equal?
  157.    */
  158.   public boolean equals(Object right_obj) {
  159.     if (right_obj instanceof BytesWritable)
  160.       return super.equals(right_obj);
  161.     return false;
  162.   }
  163.   /**
  164.    * Generate the stream of bytes as hex pairs separated by ' '.
  165.    */
  166.   public String toString() { 
  167.     StringBuffer sb = new StringBuffer(3*size);
  168.     for (int idx = 0; idx < size; idx++) {
  169.       // if not the first, put a blank separator in
  170.       if (idx != 0) {
  171.         sb.append(' ');
  172.       }
  173.       String num = Integer.toHexString(0xff & bytes[idx]);
  174.       // if it is only one digit, add a leading 0.
  175.       if (num.length() < 2) {
  176.         sb.append('0');
  177.       }
  178.       sb.append(num);
  179.     }
  180.     return sb.toString();
  181.   }
  182.   /** A Comparator optimized for BytesWritable. */ 
  183.   public static class Comparator extends WritableComparator {
  184.     public Comparator() {
  185.       super(BytesWritable.class);
  186.     }
  187.     
  188.     /**
  189.      * Compare the buffers in serialized form.
  190.      */
  191.     public int compare(byte[] b1, int s1, int l1,
  192.                        byte[] b2, int s2, int l2) {
  193.       return compareBytes(b1, s1+LENGTH_BYTES, l1-LENGTH_BYTES, 
  194.                           b2, s2+LENGTH_BYTES, l2-LENGTH_BYTES);
  195.     }
  196.   }
  197.   
  198.   static {                                        // register this comparator
  199.     WritableComparator.define(BytesWritable.class, new Comparator());
  200.   }
  201.   
  202. }