Buffer.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.record;
  19. import java.io.UnsupportedEncodingException;
  20. /**
  21.  * A byte sequence that is used as a Java native type for buffer.
  22.  * It is resizable and distinguishes between the count of the seqeunce and
  23.  * the current capacity.
  24.  * 
  25.  */
  26. public class Buffer implements Comparable, Cloneable {
  27.   /** Number of valid bytes in this.bytes. */
  28.   private int count;
  29.   /** Backing store for Buffer. */
  30.   private byte[] bytes = null;
  31.   /**
  32.    * Create a zero-count sequence.
  33.    */
  34.   public Buffer() {
  35.     this.count = 0;
  36.   }
  37.   /**
  38.    * Create a Buffer using the byte array as the initial value.
  39.    *
  40.    * @param bytes This array becomes the backing storage for the object.
  41.    */
  42.   public Buffer(byte[] bytes) {
  43.     this.bytes = bytes;
  44.     this.count = (bytes == null) ? 0 : bytes.length;
  45.   }
  46.   
  47.   /**
  48.    * Create a Buffer using the byte range as the initial value.
  49.    *
  50.    * @param bytes Copy of this array becomes the backing storage for the object.
  51.    * @param offset offset into byte array
  52.    * @param length length of data
  53.    */
  54.   public Buffer(byte[] bytes, int offset, int length) {
  55.     copy(bytes, offset, length);
  56.   }
  57.   
  58.   
  59.   /**
  60.    * Use the specified bytes array as underlying sequence.
  61.    *
  62.    * @param bytes byte sequence
  63.    */
  64.   public void set(byte[] bytes) {
  65.     this.count = (bytes == null) ? 0 : bytes.length;
  66.     this.bytes = bytes;
  67.   }
  68.   
  69.   /**
  70.    * Copy the specified byte array to the Buffer. Replaces the current buffer.
  71.    *
  72.    * @param bytes byte array to be assigned
  73.    * @param offset offset into byte array
  74.    * @param length length of data
  75.    */
  76.   public final void copy(byte[] bytes, int offset, int length) {
  77.     if (this.bytes == null || this.bytes.length < length) {
  78.       this.bytes = new byte[length];
  79.     }
  80.     System.arraycopy(bytes, offset, this.bytes, 0, length);
  81.     this.count = length;
  82.   }
  83.   
  84.   /**
  85.    * Get the data from the Buffer.
  86.    * 
  87.    * @return The data is only valid between 0 and getCount() - 1.
  88.    */
  89.   public byte[] get() {
  90.     if (bytes == null) {
  91.       bytes = new byte[0];
  92.     }
  93.     return bytes;
  94.   }
  95.   
  96.   /**
  97.    * Get the current count of the buffer.
  98.    */
  99.   public int getCount() {
  100.     return count;
  101.   }
  102.   
  103.   /**
  104.    * Get the capacity, which is the maximum count that could handled without
  105.    * resizing the backing storage.
  106.    * 
  107.    * @return The number of bytes
  108.    */
  109.   public int getCapacity() {
  110.     return this.get().length;
  111.   }
  112.   
  113.   /**
  114.    * Change the capacity of the backing storage.
  115.    * The data is preserved if newCapacity >= getCount().
  116.    * @param newCapacity The new capacity in bytes.
  117.    */
  118.   public void setCapacity(int newCapacity) {
  119.     if (newCapacity < 0) {
  120.       throw new IllegalArgumentException("Invalid capacity argument "+newCapacity); 
  121.     }
  122.     if (newCapacity == 0) {
  123.       this.bytes = null;
  124.       this.count = 0;
  125.       return;
  126.     }
  127.     if (newCapacity != getCapacity()) {
  128.       byte[] data = new byte[newCapacity];
  129.       if (newCapacity < count) {
  130.         count = newCapacity;
  131.       }
  132.       if (count != 0) {
  133.         System.arraycopy(this.get(), 0, data, 0, count);
  134.       }
  135.       bytes = data;
  136.     }
  137.   }
  138.   
  139.   /**
  140.    * Reset the buffer to 0 size
  141.    */
  142.   public void reset() {
  143.     setCapacity(0);
  144.   }
  145.   
  146.   /**
  147.    * Change the capacity of the backing store to be the same as the current 
  148.    * count of buffer.
  149.    */
  150.   public void truncate() {
  151.     setCapacity(count);
  152.   }
  153.   
  154.   /**
  155.    * Append specified bytes to the buffer.
  156.    *
  157.    * @param bytes byte array to be appended
  158.    * @param offset offset into byte array
  159.    * @param length length of data
  160.   */
  161.   public void append(byte[] bytes, int offset, int length) {
  162.     setCapacity(count+length);
  163.     System.arraycopy(bytes, offset, this.get(), count, length);
  164.     count = count + length;
  165.   }
  166.   
  167.   /**
  168.    * Append specified bytes to the buffer
  169.    *
  170.    * @param bytes byte array to be appended
  171.    */
  172.   public void append(byte[] bytes) {
  173.     append(bytes, 0, bytes.length);
  174.   }
  175.   
  176.   // inherit javadoc
  177.   public int hashCode() {
  178.     int hash = 1;
  179.     byte[] b = this.get();
  180.     for (int i = 0; i < count; i++)
  181.       hash = (31 * hash) + (int)b[i];
  182.     return hash;
  183.   }
  184.   
  185.   /**
  186.    * Define the sort order of the Buffer.
  187.    * 
  188.    * @param other The other buffer
  189.    * @return Positive if this is bigger than other, 0 if they are equal, and
  190.    *         negative if this is smaller than other.
  191.    */
  192.   public int compareTo(Object other) {
  193.     Buffer right = ((Buffer) other);
  194.     byte[] lb = this.get();
  195.     byte[] rb = right.get();
  196.     for (int i = 0; i < count && i < right.count; i++) {
  197.       int a = (lb[i] & 0xff);
  198.       int b = (rb[i] & 0xff);
  199.       if (a != b) {
  200.         return a - b;
  201.       }
  202.     }
  203.     return count - right.count;
  204.   }
  205.   
  206.   // inherit javadoc
  207.   public boolean equals(Object other) {
  208.     if (other instanceof Buffer && this != other) {
  209.       return compareTo(other) == 0;
  210.     }
  211.     return (this == other);
  212.   }
  213.   
  214.   // inheric javadoc
  215.   public String toString() {
  216.     StringBuffer sb = new StringBuffer(2*count);
  217.     for(int idx = 0; idx < count; idx++) {
  218.       sb.append(Character.forDigit((bytes[idx] & 0xF0) >> 4, 16));
  219.       sb.append(Character.forDigit(bytes[idx] & 0x0F, 16));
  220.     }
  221.     return sb.toString();
  222.   }
  223.   
  224.   /**
  225.    * Convert the byte buffer to a string an specific character encoding
  226.    *
  227.    * @param charsetName Valid Java Character Set Name
  228.    */
  229.   public String toString(String charsetName)
  230.     throws UnsupportedEncodingException {
  231.     return new String(this.get(), 0, this.getCount(), charsetName);
  232.   }
  233.   
  234.   // inherit javadoc
  235.   public Object clone() throws CloneNotSupportedException {
  236.     Buffer result = (Buffer) super.clone();
  237.     result.copy(this.get(), 0, this.getCount());
  238.     return result;
  239.   }
  240. }