hbase-common/src/main/java/org/apache/hadoop/hbase/util/SimpleByteRange.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.hbase.util;
  19
  20 import org.apache.yetus.audience.InterfaceAudience;
  21
  22 /**
  23  *  A read only version of the {@link ByteRange}.
  24  */
  25 @InterfaceAudience.Public
  26 public class SimpleByteRange extends AbstractByteRange {
  27   public SimpleByteRange() {
  28   }
  29
  30   public SimpleByteRange(int capacity) {
  31     this(new byte[capacity]);
  32   }
  33
  34   /**
  35    * Create a new {@code ByteRange} over the provided {@code bytes}.
  36    * @param bytes The array to wrap.
  37    */
  38   public SimpleByteRange(byte[] bytes) {
  39     set(bytes);
  40   }
  41
  42   /**
  43    * Create a new {@code ByteRange} over the provided {@code bytes}.
  44    * @param bytes The array to wrap.
  45    * @param offset The offset into {@code bytes} considered the beginning
  46    *          of this range.
  47    * @param length The length of this range.
  48    */
  49   public SimpleByteRange(byte[] bytes, int offset, int length) {
  50     set(bytes, offset, length);
  51   }
  52
  53   //
  54   // methods for managing the backing array and range viewport
  55   //
  56
  57   @Override
  58   public ByteRange unset() {
  59     throw new ReadOnlyByteRangeException();
  60   }
  61
  62   @Override
  63   public ByteRange set(int capacity) {
  64     if (super.bytes != null) {
  65       throw new ReadOnlyByteRangeException();
  66     }
  67     return super.set(capacity);
  68   }
  69
  70   @Override
  71   public ByteRange set(byte[] bytes) {
  72     if (super.bytes != null) {
  73       throw new ReadOnlyByteRangeException();
  74     }
  75     return super.set(bytes);
  76   }
  77
  78   @Override
  79   public ByteRange set(byte[] bytes, int offset, int length) {
  80     if (super.bytes != null) {
  81       throw new ReadOnlyByteRangeException();
  82     }
  83     return super.set(bytes, offset, length);
  84   }
  85
  86   //
  87   // methods for retrieving data
  88   //
  89   @Override
  90   public ByteRange put(int index, byte val) {
  91     throw new ReadOnlyByteRangeException();
  92   }
  93
  94   @Override
  95   public ByteRange put(int index, byte[] val) {
  96     throw new ReadOnlyByteRangeException();
  97   }
  98
  99   @Override
 100   public ByteRange put(int index, byte[] val, int offset, int length) {
 101     throw new ReadOnlyByteRangeException();
 102   }
 103
 104   //
 105   // methods for duplicating the current instance
 106   //
 107
 108   @Override
 109   public ByteRange shallowCopy() {
 110     SimpleByteRange clone = new SimpleByteRange(bytes, offset, length);
 111     if (isHashCached()) {
 112       clone.hash = hash;
 113     }
 114     return clone;
 115   }
 116
 117   @Override
 118   public ByteRange shallowCopySubRange(int innerOffset, int copyLength) {
 119     SimpleByteRange clone = new SimpleByteRange(bytes, offset + innerOffset,
 120         copyLength);
 121     if (isHashCached()) {
 122       clone.hash = hash;
 123     }
 124     return clone;
 125   }
 126
 127   @Override
 128   public boolean equals(Object thatObject) {
 129     if (thatObject == null){
 130       return false;
 131     }
 132     if (this == thatObject) {
 133       return true;
 134     }
 135     if (hashCode() != thatObject.hashCode()) {
 136       return false;
 137     }
 138     if (!(thatObject instanceof SimpleByteRange)) {
 139       return false;
 140     }
 141     SimpleByteRange that = (SimpleByteRange) thatObject;
 142     return Bytes.equals(bytes, offset, length, that.bytes, that.offset, that.length);
 143   }
 144
 145   @Override
 146   public ByteRange deepCopy() {
 147     SimpleByteRange clone = new SimpleByteRange(deepCopyToNewArray());
 148     if (isHashCached()) {
 149       clone.hash = hash;
 150     }
 151     return clone;
 152   }
 153
 154   @Override
 155   public ByteRange putInt(int index, int val) {
 156     throw new ReadOnlyByteRangeException();
 157   }
 158
 159   @Override
 160   public ByteRange putLong(int index, long val) {
 161     throw new ReadOnlyByteRangeException();
 162   }
 163
 164   @Override
 165   public ByteRange putShort(int index, short val) {
 166     throw new ReadOnlyByteRangeException();
 167   }
 168
 169   @Override
 170   public int putVLong(int index, long val) {
 171     throw new ReadOnlyByteRangeException();
 172   }
 173 }