ceph/src/arrow/java/vector/src/main/java/org/apache/arrow/vector/ExtensionTypeVector.java

   1 /*
   2  * Licensed to the Apache Software Foundation (ASF) under one or more
   3  * contributor license agreements.  See the NOTICE file distributed with
   4  * this work for additional information regarding copyright ownership.
   5  * The ASF licenses this file to You under the Apache License, Version 2.0
   6  * (the "License"); you may not use this file except in compliance with
   7  * the License.  You may obtain a copy of the License at
   8  *
   9  *    http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 package org.apache.arrow.vector;
  19
  20 import java.util.Iterator;
  21 import java.util.List;
  22
  23 import org.apache.arrow.memory.ArrowBuf;
  24 import org.apache.arrow.memory.BufferAllocator;
  25 import org.apache.arrow.memory.OutOfMemoryException;
  26 import org.apache.arrow.util.Preconditions;
  27 import org.apache.arrow.vector.compare.VectorVisitor;
  28 import org.apache.arrow.vector.complex.reader.FieldReader;
  29 import org.apache.arrow.vector.ipc.message.ArrowFieldNode;
  30 import org.apache.arrow.vector.types.Types.MinorType;
  31 import org.apache.arrow.vector.types.pojo.Field;
  32 import org.apache.arrow.vector.util.CallBack;
  33 import org.apache.arrow.vector.util.TransferPair;
  34
  35 /**
  36  * A vector that wraps an underlying vector, used to help implement extension types.
  37  * @param <T> The wrapped vector type.
  38  */
  39 public abstract class ExtensionTypeVector<T extends ValueVector & FieldVector> extends BaseValueVector implements
  40     FieldVector {
  41
  42   private final T underlyingVector;
  43   private final String name;
  44
  45   /**
  46    * Instantiate an extension type vector.
  47    * @param name name of the vector
  48    * @param allocator allocator for memory management
  49    * @param underlyingVector underlying filed vector
  50    */
  51   public ExtensionTypeVector(String name, BufferAllocator allocator, T underlyingVector) {
  52     super(allocator);
  53     Preconditions.checkNotNull(underlyingVector, "underlyingVector can not be null.");
  54     this.name = name;
  55     this.underlyingVector = underlyingVector;
  56   }
  57
  58   /**
  59    * Instantiate an extension type vector.
  60    * @param field field materialized by this vector.
  61    * @param allocator allocator for memory management
  62    * @param underlyingVector underlying filed vector
  63    */
  64   public ExtensionTypeVector(Field field, BufferAllocator allocator, T underlyingVector) {
  65     this(field.getName(), allocator, underlyingVector);
  66   }
  67
  68   @Override
  69   public String getName() {
  70     return name;
  71   }
  72
  73   /** Get the underlying vector. */
  74   public T getUnderlyingVector() {
  75     return underlyingVector;
  76   }
  77
  78   @Override
  79   public void allocateNew() throws OutOfMemoryException {
  80     this.underlyingVector.allocateNew();
  81   }
  82
  83   @Override
  84   public boolean allocateNewSafe() {
  85     return this.underlyingVector.allocateNewSafe();
  86   }
  87
  88   @Override
  89   public void reAlloc() {
  90     this.underlyingVector.reAlloc();
  91   }
  92
  93   @Override
  94   public void setInitialCapacity(int numRecords) {
  95     this.underlyingVector.setInitialCapacity(numRecords);
  96   }
  97
  98   @Override
  99   public int getValueCapacity() {
 100     return this.underlyingVector.getValueCapacity();
 101   }
 102
 103   @Override
 104   public void reset() {
 105     this.underlyingVector.reset();
 106   }
 107
 108   @Override
 109   public Field getField() {
 110     return this.underlyingVector.getField();
 111   }
 112
 113   @Override
 114   public MinorType getMinorType() {
 115     return MinorType.EXTENSIONTYPE;
 116   }
 117
 118   @Override
 119   public TransferPair getTransferPair(String ref, BufferAllocator allocator) {
 120     return underlyingVector.getTransferPair(ref, allocator);
 121   }
 122
 123   @Override
 124   public TransferPair getTransferPair(String ref, BufferAllocator allocator, CallBack callBack) {
 125     return underlyingVector.getTransferPair(ref, allocator, callBack);
 126   }
 127
 128   @Override
 129   public TransferPair makeTransferPair(ValueVector target) {
 130     return underlyingVector.makeTransferPair(target);
 131   }
 132
 133   @Override
 134   public FieldReader getReader() {
 135     return underlyingVector.getReader();
 136   }
 137
 138   @Override
 139   public int getBufferSize() {
 140     return underlyingVector.getBufferSize();
 141   }
 142
 143   @Override
 144   public int getBufferSizeFor(int valueCount) {
 145     return underlyingVector.getBufferSizeFor(valueCount);
 146   }
 147
 148   @Override
 149   public ArrowBuf[] getBuffers(boolean clear) {
 150     return underlyingVector.getBuffers(clear);
 151   }
 152
 153   @Override
 154   public ArrowBuf getValidityBuffer() {
 155     return underlyingVector.getValidityBuffer();
 156   }
 157
 158   @Override
 159   public ArrowBuf getDataBuffer() {
 160     return underlyingVector.getDataBuffer();
 161   }
 162
 163   @Override
 164   public ArrowBuf getOffsetBuffer() {
 165     return underlyingVector.getOffsetBuffer();
 166   }
 167
 168   @Override
 169   public int getValueCount() {
 170     return underlyingVector.getValueCount();
 171   }
 172
 173   @Override
 174   public void setValueCount(int valueCount) {
 175     underlyingVector.setValueCount(valueCount);
 176   }
 177
 178   /**
 179    * Get the extension object at the specified index.
 180    *
 181    * <p>Generally, this should access the underlying vector and construct the corresponding Java object from the raw
 182    * data.
 183    */
 184   @Override
 185   public abstract Object getObject(int index);
 186
 187   @Override
 188   public int getNullCount() {
 189     return underlyingVector.getNullCount();
 190   }
 191
 192   @Override
 193   public boolean isNull(int index) {
 194     return underlyingVector.isNull(index);
 195   }
 196
 197   @Override
 198   public void initializeChildrenFromFields(List<Field> children) {
 199     underlyingVector.initializeChildrenFromFields(children);
 200   }
 201
 202   @Override
 203   public List<FieldVector> getChildrenFromFields() {
 204     return underlyingVector.getChildrenFromFields();
 205   }
 206
 207   @Override
 208   public void loadFieldBuffers(ArrowFieldNode fieldNode, List<ArrowBuf> ownBuffers) {
 209     underlyingVector.loadFieldBuffers(fieldNode, ownBuffers);
 210   }
 211
 212   @Override
 213   public List<ArrowBuf> getFieldBuffers() {
 214     return underlyingVector.getFieldBuffers();
 215   }
 216
 217   /**
 218    * Get the inner vectors.
 219    *
 220    * @deprecated This API will be removed as the current implementations no longer support inner vectors.
 221    *
 222    * @return the inner vectors for this field as defined by the TypeLayout
 223    */
 224   @Deprecated
 225   @Override
 226   public List<BufferBacked> getFieldInnerVectors() {
 227     return underlyingVector.getFieldInnerVectors();
 228   }
 229
 230   @Override
 231   public long getValidityBufferAddress() {
 232     return underlyingVector.getValidityBufferAddress();
 233   }
 234
 235   @Override
 236   public long getDataBufferAddress() {
 237     return underlyingVector.getDataBufferAddress();
 238   }
 239
 240   @Override
 241   public long getOffsetBufferAddress() {
 242     return underlyingVector.getOffsetBufferAddress();
 243   }
 244
 245   @Override
 246   public void clear() {
 247     underlyingVector.clear();
 248   }
 249
 250   @Override
 251   public void close() {
 252     underlyingVector.close();
 253   }
 254
 255   @Override
 256   public TransferPair getTransferPair(BufferAllocator allocator) {
 257     return underlyingVector.getTransferPair(allocator);
 258   }
 259
 260   @Override
 261   public Iterator<ValueVector> iterator() {
 262     return underlyingVector.iterator();
 263   }
 264
 265   @Override
 266   public BufferAllocator getAllocator() {
 267     return underlyingVector.getAllocator();
 268   }
 269
 270   @Override
 271   public <OUT, IN> OUT accept(VectorVisitor<OUT, IN> visitor, IN value) {
 272     return visitor.visit(this, value);
 273   }
 274 }