third-party/atomix/storage/src/main/java/io/atomix/storage/buffer/ReadOnlyBuffer.java

   1 /*
   2  * Copyright 2015-present Open Networking Foundation
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package io.atomix.storage.buffer;
  17
  18 import io.atomix.utils.concurrent.ReferenceManager;
  19
  20 import java.nio.ReadOnlyBufferException;
  21
  22 /**
  23  * Read-only buffer.
  24  *
  25  * @author <a href="http://github.com/kuujo">Jordan Halterman</a>
  26  */
  27 public class ReadOnlyBuffer extends AbstractBuffer {
  28   private final Buffer root;
  29
  30   public ReadOnlyBuffer(Buffer buffer, ReferenceManager<Buffer> referenceManager) {
  31     super(buffer.bytes(), referenceManager);
  32     this.root = buffer;
  33   }
  34
  35   @Override
  36   public boolean isDirect() {
  37     return root.isDirect();
  38   }
  39
  40   @Override
  41   public boolean isFile() {
  42     return root.isFile();
  43   }
  44
  45   @Override
  46   public boolean isReadOnly() {
  47     return true;
  48   }
  49
  50   @Override
  51   public Buffer compact() {
  52     throw new ReadOnlyBufferException();
  53   }
  54
  55   @Override
  56   protected void compact(int from, int to, int length) {
  57     throw new ReadOnlyBufferException();
  58   }
  59
  60   @Override
  61   public Buffer duplicate() {
  62     return new ReadOnlyBuffer(root, referenceManager);
  63   }
  64
  65   @Override
  66   public Buffer acquire() {
  67     root.acquire();
  68     return this;
  69   }
  70
  71   @Override
  72   public boolean release() {
  73     return root.release();
  74   }
  75
  76   @Override
  77   public Buffer zero(int offset, int length) {
  78     throw new ReadOnlyBufferException();
  79   }
  80
  81   @Override
  82   public Buffer zero(int offset) {
  83     throw new ReadOnlyBufferException();
  84   }
  85
  86   @Override
  87   public Buffer zero() {
  88     throw new ReadOnlyBufferException();
  89   }
  90
  91   @Override
  92   public Buffer writeBoolean(int offset, boolean b) {
  93     throw new ReadOnlyBufferException();
  94   }
  95
  96   @Override
  97   public Buffer write(Buffer buffer) {
  98     throw new ReadOnlyBufferException();
  99   }
 100
 101   @Override
 102   public Buffer write(Bytes bytes) {
 103     throw new ReadOnlyBufferException();
 104   }
 105
 106   @Override
 107   public Buffer write(Bytes bytes, int offset, int length) {
 108     throw new ReadOnlyBufferException();
 109   }
 110
 111   @Override
 112   public Buffer write(int offset, Bytes bytes, int srcOffset, int length) {
 113     throw new ReadOnlyBufferException();
 114   }
 115
 116   @Override
 117   public Buffer write(byte[] bytes) {
 118     throw new ReadOnlyBufferException();
 119   }
 120
 121   @Override
 122   public Buffer write(byte[] bytes, int offset, int length) {
 123     throw new ReadOnlyBufferException();
 124   }
 125
 126   @Override
 127   public Buffer write(int offset, byte[] bytes, int srcOffset, int length) {
 128     throw new ReadOnlyBufferException();
 129   }
 130
 131   @Override
 132   public Buffer writeByte(int b) {
 133     throw new ReadOnlyBufferException();
 134   }
 135
 136   @Override
 137   public Buffer writeByte(int offset, int b) {
 138     throw new ReadOnlyBufferException();
 139   }
 140
 141   @Override
 142   public Buffer writeUnsignedByte(int b) {
 143     throw new ReadOnlyBufferException();
 144   }
 145
 146   @Override
 147   public Buffer writeUnsignedByte(int offset, int b) {
 148     throw new ReadOnlyBufferException();
 149   }
 150
 151   @Override
 152   public Buffer writeChar(char c) {
 153     throw new ReadOnlyBufferException();
 154   }
 155
 156   @Override
 157   public Buffer writeChar(int offset, char c) {
 158     throw new ReadOnlyBufferException();
 159   }
 160
 161   @Override
 162   public Buffer writeShort(short s) {
 163     throw new ReadOnlyBufferException();
 164   }
 165
 166   @Override
 167   public Buffer writeShort(int offset, short s) {
 168     throw new ReadOnlyBufferException();
 169   }
 170
 171   @Override
 172   public Buffer writeUnsignedShort(int s) {
 173     throw new ReadOnlyBufferException();
 174   }
 175
 176   @Override
 177   public Buffer writeUnsignedShort(int offset, int s) {
 178     throw new ReadOnlyBufferException();
 179   }
 180
 181   @Override
 182   public Buffer writeMedium(int m) {
 183     throw new ReadOnlyBufferException();
 184   }
 185
 186   @Override
 187   public Buffer writeMedium(int offset, int m) {
 188     throw new ReadOnlyBufferException();
 189   }
 190
 191   @Override
 192   public Buffer writeUnsignedMedium(int m) {
 193     throw new ReadOnlyBufferException();
 194   }
 195
 196   @Override
 197   public Buffer writeUnsignedMedium(int offset, int m) {
 198     throw new ReadOnlyBufferException();
 199   }
 200
 201   @Override
 202   public Buffer writeInt(int i) {
 203     throw new ReadOnlyBufferException();
 204   }
 205
 206   @Override
 207   public Buffer writeInt(int offset, int i) {
 208     throw new ReadOnlyBufferException();
 209   }
 210
 211   @Override
 212   public Buffer writeUnsignedInt(long i) {
 213     throw new ReadOnlyBufferException();
 214   }
 215
 216   @Override
 217   public Buffer writeUnsignedInt(int offset, long i) {
 218     throw new ReadOnlyBufferException();
 219   }
 220
 221   @Override
 222   public Buffer writeLong(long l) {
 223     throw new ReadOnlyBufferException();
 224   }
 225
 226   @Override
 227   public Buffer writeLong(int offset, long l) {
 228     throw new ReadOnlyBufferException();
 229   }
 230
 231   @Override
 232   public Buffer writeFloat(float f) {
 233     throw new ReadOnlyBufferException();
 234   }
 235
 236   @Override
 237   public Buffer writeFloat(int offset, float f) {
 238     throw new ReadOnlyBufferException();
 239   }
 240
 241   @Override
 242   public Buffer writeDouble(double d) {
 243     throw new ReadOnlyBufferException();
 244   }
 245
 246   @Override
 247   public Buffer writeDouble(int offset, double d) {
 248     throw new ReadOnlyBufferException();
 249   }
 250
 251   @Override
 252   public Buffer writeBoolean(boolean b) {
 253     throw new ReadOnlyBufferException();
 254   }
 255
 256   @Override
 257   public Buffer writeUTF8(String s) {
 258     throw new ReadOnlyBufferException();
 259   }
 260
 261   @Override
 262   public Buffer flush() {
 263     throw new ReadOnlyBufferException();
 264   }
 265
 266   @Override
 267   public void close() {
 268     root.release();
 269   }
 270
 271 }