Java IndexInput.readLong方法代码示例

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
private NumericDocValues loadLongField(FieldInfo field, IndexInput input) throws IOException {
  CodecUtil.checkHeader(input, Lucene40DocValuesFormat.INTS_CODEC_NAME,
                               Lucene40DocValuesFormat.INTS_VERSION_START,
                               Lucene40DocValuesFormat.INTS_VERSION_CURRENT);
  int valueSize = input.readInt();
  if (valueSize != 8) {
    throw new CorruptIndexException("invalid valueSize: " + valueSize);
  }
  int maxDoc = state.segmentInfo.getDocCount();
  final long values[] = new long[maxDoc];
  for (int i = 0; i < values.length; i++) {
    values[i] = input.readLong();
  }
  ramBytesUsed.addAndGet(RamUsageEstimator.sizeOf(values));
  return new NumericDocValues() {
    @Override
    public long get(int docID) {
      return values[docID];
    }
  };
}
 

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
private NumericDocValues loadDoubleField(FieldInfo field, IndexInput input) throws IOException {
  CodecUtil.checkHeader(input, Lucene40DocValuesFormat.FLOATS_CODEC_NAME,
                               Lucene40DocValuesFormat.FLOATS_VERSION_START,
                               Lucene40DocValuesFormat.FLOATS_VERSION_CURRENT);
  int valueSize = input.readInt();
  if (valueSize != 8) {
    throw new CorruptIndexException("invalid valueSize: " + valueSize);
  }
  int maxDoc = state.segmentInfo.getDocCount();
  final long values[] = new long[maxDoc];
  for (int i = 0; i < values.length; i++) {
    values[i] = input.readLong();
  }
  ramBytesUsed.addAndGet(RamUsageEstimator.sizeOf(values));
  return new NumericDocValues() {
    @Override
    public long get(int docID) {
      return values[docID];
    }
  };
}
 

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
private void readFields(IndexInput meta, FieldInfos infos) throws IOException {
  int fieldNumber = meta.readVInt();
  while (fieldNumber != -1) {
    FieldInfo info = infos.fieldInfo(fieldNumber);
    if (info == null) {
      throw new CorruptIndexException("Invalid field number: " + fieldNumber + " (resource=" + meta + ")");
    } else if (!info.hasNorms()) {
      throw new CorruptIndexException("Invalid field: " + info.name + " (resource=" + meta + ")");
    }
    NormsEntry entry = new NormsEntry();
    entry.format = meta.readByte();
    entry.offset = meta.readLong();
    switch(entry.format) {
      case CONST_COMPRESSED:
      case UNCOMPRESSED:
      case TABLE_COMPRESSED:
      case DELTA_COMPRESSED:
        break;
      default:
        throw new CorruptIndexException("Unknown format: " + entry.format + ", input=" + meta);
    }
    norms.put(fieldNumber, entry);
    fieldNumber = meta.readVInt();
  }
}
 

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
public CompressedIndexInput(IndexInput in) throws IOException {
    super("compressed(" + in.toString() + ")");
    this.in = in;
    readHeader(in);
    this.version = in.readInt();
    long metaDataPosition = in.readLong();
    long headerLength = in.getFilePointer();
    in.seek(metaDataPosition);
    this.totalUncompressedLength = in.readVLong();
    int size = in.readVInt();
    offsets = BigArrays.NON_RECYCLING_INSTANCE.newLongArray(size);
    for (int i = 0; i < size; i++) {
        offsets.set(i, in.readVLong());
    }
    this.currentOffsetIdx = -1;
    this.currentUncompressedChunkPointer = 0;
    in.seek(headerLength);
}
 

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
private SortedDocValues loadBytesVarSorted(FieldInfo field, IndexInput data, IndexInput index) throws IOException {
  CodecUtil.checkHeader(data, Lucene40DocValuesFormat.BYTES_VAR_SORTED_CODEC_NAME_DAT,
                              Lucene40DocValuesFormat.BYTES_VAR_SORTED_VERSION_START,
                              Lucene40DocValuesFormat.BYTES_VAR_SORTED_VERSION_CURRENT);
  CodecUtil.checkHeader(index, Lucene40DocValuesFormat.BYTES_VAR_SORTED_CODEC_NAME_IDX,
                               Lucene40DocValuesFormat.BYTES_VAR_SORTED_VERSION_START,
                               Lucene40DocValuesFormat.BYTES_VAR_SORTED_VERSION_CURRENT);

  long maxAddress = index.readLong();
  PagedBytes bytes = new PagedBytes(16);
  bytes.copy(data, maxAddress);
  final PagedBytes.Reader bytesReader = bytes.freeze(true);
  final PackedInts.Reader addressReader = PackedInts.getReader(index);
  final PackedInts.Reader ordsReader = PackedInts.getReader(index);

  final int valueCount = addressReader.size() - 1;
  ramBytesUsed.addAndGet(bytesReader.ramBytesUsed() + addressReader.ramBytesUsed() + ordsReader.ramBytesUsed());

  return correctBuggyOrds(new SortedDocValues() {
    @Override
    public int getOrd(int docID) {
      return (int)ordsReader.get(docID);
    }

    @Override
    public BytesRef lookupOrd(int ord) {
      final BytesRef term = new BytesRef();
      long startAddress = addressReader.get(ord);
      long endAddress = addressReader.get(ord+1);
      bytesReader.fillSlice(term, startAddress, (int)(endAddress - startAddress));
      return term;
    }

    @Override
    public int getValueCount() {
      return valueCount;
    }
  });
}
 

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
static NumericEntry readNumericEntry(IndexInput meta) throws IOException {
  NumericEntry entry = new NumericEntry();
  entry.format = meta.readVInt();
  entry.missingOffset = meta.readLong();
  entry.packedIntsVersion = meta.readVInt();
  entry.offset = meta.readLong();
  entry.count = meta.readVLong();
  entry.blockSize = meta.readVInt();
  switch(entry.format) {
    case GCD_COMPRESSED:
      entry.minValue = meta.readLong();
      entry.gcd = meta.readLong();
      break;
    case TABLE_COMPRESSED:
      if (entry.count > Integer.MAX_VALUE) {
        throw new CorruptIndexException("Cannot use TABLE_COMPRESSED with more than MAX_VALUE values, input=" + meta);
      }
      final int uniqueValues = meta.readVInt();
      if (uniqueValues > 256) {
        throw new CorruptIndexException("TABLE_COMPRESSED cannot have more than 256 distinct values, input=" + meta);
      }
      entry.table = new long[uniqueValues];
      for (int i = 0; i < uniqueValues; ++i) {
        entry.table[i] = meta.readLong();
      }
      break;
    case DELTA_COMPRESSED:
      break;
    default:
      throw new CorruptIndexException("Unknown format: " + entry.format + ", input=" + meta);
  }
  return entry;
}
 

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
static BinaryEntry readBinaryEntry(IndexInput meta) throws IOException {
  BinaryEntry entry = new BinaryEntry();
  entry.format = meta.readVInt();
  entry.missingOffset = meta.readLong();
  entry.minLength = meta.readVInt();
  entry.maxLength = meta.readVInt();
  entry.count = meta.readVLong();
  entry.offset = meta.readLong();
  switch(entry.format) {
    case BINARY_FIXED_UNCOMPRESSED:
      break;
    case BINARY_PREFIX_COMPRESSED:
      entry.addressInterval = meta.readVInt();
      entry.addressesOffset = meta.readLong();
      entry.packedIntsVersion = meta.readVInt();
      entry.blockSize = meta.readVInt();
      break;
    case BINARY_VARIABLE_UNCOMPRESSED:
      entry.addressesOffset = meta.readLong();
      entry.packedIntsVersion = meta.readVInt();
      entry.blockSize = meta.readVInt();
      break;
    default:
      throw new CorruptIndexException("Unknown format: " + entry.format + ", input=" + meta);
  }
  return entry;
}
 

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
static NumericEntry readNumericEntry(IndexInput meta) throws IOException {
  NumericEntry entry = new NumericEntry();
  entry.format = meta.readVInt();
  entry.missingOffset = meta.readLong();
  entry.offset = meta.readLong();
  entry.count = meta.readVLong();
  switch(entry.format) {
    case GCD_COMPRESSED:
      entry.minValue = meta.readLong();
      entry.gcd = meta.readLong();
      entry.bitsPerValue = meta.readVInt();
      break;
    case TABLE_COMPRESSED:
      final int uniqueValues = meta.readVInt();
      if (uniqueValues > 256) {
        throw new CorruptIndexException("TABLE_COMPRESSED cannot have more than 256 distinct values, input=" + meta);
      }
      entry.table = new long[uniqueValues];
      for (int i = 0; i < uniqueValues; ++i) {
        entry.table[i] = meta.readLong();
      }
      entry.bitsPerValue = meta.readVInt();
      break;
    case DELTA_COMPRESSED:
      entry.minValue = meta.readLong();
      entry.bitsPerValue = meta.readVInt();
      break;
    case MONOTONIC_COMPRESSED:
      entry.packedIntsVersion = meta.readVInt();
      entry.blockSize = meta.readVInt();
      break;
    default:
      throw new CorruptIndexException("Unknown format: " + entry.format + ", input=" + meta);
  }
  entry.endOffset = meta.readLong();
  return entry;
}
 

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
/** Reads terms file header. */
protected int readHeader(IndexInput input) throws IOException {
  int version = CodecUtil.checkHeader(input, BlockTreeTermsWriter.TERMS_CODEC_NAME,
                        BlockTreeTermsWriter.VERSION_START,
                        BlockTreeTermsWriter.VERSION_CURRENT);
  if (version < BlockTreeTermsWriter.VERSION_APPEND_ONLY) {
    dirOffset = input.readLong();
  }
  return version;
}
 

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
/** Reads index file header. */
protected int readIndexHeader(IndexInput input) throws IOException {
  int version = CodecUtil.checkHeader(input, BlockTreeTermsWriter.TERMS_INDEX_CODEC_NAME,
                        BlockTreeTermsWriter.VERSION_START,
                        BlockTreeTermsWriter.VERSION_CURRENT);
  if (version < BlockTreeTermsWriter.VERSION_APPEND_ONLY) {
    indexDirOffset = input.readLong(); 
  }
  return version;
}
 

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
/** Seek {@code input} to the directory offset. */
protected void seekDir(IndexInput input, long dirOffset)
    throws IOException {
  if (version >= BlockTreeTermsWriter.VERSION_CHECKSUM) {
    input.seek(input.length() - CodecUtil.footerLength() - 8);
    dirOffset = input.readLong();
  } else if (version >= BlockTreeTermsWriter.VERSION_APPEND_ONLY) {
    input.seek(input.length() - 8);
    dirOffset = input.readLong();
  }
  input.seek(dirOffset);
}
 

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
static BinaryEntry readBinaryEntry(IndexInput meta) throws IOException {
  BinaryEntry entry = new BinaryEntry();
  entry.format = meta.readVInt();
  entry.missingOffset = meta.readLong();
  entry.minLength = meta.readVInt();
  entry.maxLength = meta.readVInt();
  entry.count = meta.readVLong();
  entry.offset = meta.readLong();
  switch(entry.format) {
    case BINARY_FIXED_UNCOMPRESSED:
      break;
    case BINARY_PREFIX_COMPRESSED:
      entry.addressesOffset = meta.readLong();
      entry.packedIntsVersion = meta.readVInt();
      entry.blockSize = meta.readVInt();
      entry.reverseIndexOffset = meta.readLong();
      break;
    case BINARY_VARIABLE_UNCOMPRESSED:
      entry.addressesOffset = meta.readLong();
      entry.packedIntsVersion = meta.readVInt();
      entry.blockSize = meta.readVInt();
      break;
    default:
      throw new CorruptIndexException("Unknown format: " + entry.format + ", input=" + meta);
  }
  return entry;
}
 

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
private BinaryDocValues loadBytesVarDeref(FieldInfo field) throws IOException {
  String dataName = IndexFileNames.segmentFileName(state.segmentInfo.name + "_" + Integer.toString(field.number), segmentSuffix, "dat");
  String indexName = IndexFileNames.segmentFileName(state.segmentInfo.name + "_" + Integer.toString(field.number), segmentSuffix, "idx");
  IndexInput data = null;
  IndexInput index = null;
  boolean success = false;
  try {
    data = dir.openInput(dataName, state.context);
    CodecUtil.checkHeader(data, Lucene40DocValuesFormat.BYTES_VAR_DEREF_CODEC_NAME_DAT,
                                Lucene40DocValuesFormat.BYTES_VAR_DEREF_VERSION_START,
                                Lucene40DocValuesFormat.BYTES_VAR_DEREF_VERSION_CURRENT);
    index = dir.openInput(indexName, state.context);
    CodecUtil.checkHeader(index, Lucene40DocValuesFormat.BYTES_VAR_DEREF_CODEC_NAME_IDX,
                                 Lucene40DocValuesFormat.BYTES_VAR_DEREF_VERSION_START,
                                 Lucene40DocValuesFormat.BYTES_VAR_DEREF_VERSION_CURRENT);

    final long totalBytes = index.readLong();
    final PagedBytes bytes = new PagedBytes(16);
    bytes.copy(data, totalBytes);
    final PagedBytes.Reader bytesReader = bytes.freeze(true);
    final PackedInts.Reader reader = PackedInts.getReader(index);
    CodecUtil.checkEOF(data);
    CodecUtil.checkEOF(index);
    ramBytesUsed.addAndGet(bytesReader.ramBytesUsed() + reader.ramBytesUsed());
    success = true;
    return new BinaryDocValues() {
      
      @Override
      public BytesRef get(int docID) {
        final BytesRef term = new BytesRef();
        long startAddress = reader.get(docID);
        BytesRef lengthBytes = new BytesRef();
        bytesReader.fillSlice(lengthBytes, startAddress, 1);
        byte code = lengthBytes.bytes[lengthBytes.offset];
        if ((code & 128) == 0) {
          // length is 1 byte
          bytesReader.fillSlice(term, startAddress + 1, (int) code);
        } else {
          bytesReader.fillSlice(lengthBytes, startAddress + 1, 1);
          int length = ((code & 0x7f) << 8) | (lengthBytes.bytes[lengthBytes.offset] & 0xff);
          bytesReader.fillSlice(term, startAddress + 2, length);
        }
        return term;
      }
    };
  } finally {
    if (success) {
      IOUtils.close(data, index);
    } else {
      IOUtils.closeWhileHandlingException(data, index);
    }
  }
}
 

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
protected long readSize(IndexInput input) throws IOException {
  return input.readLong();
}
 

import org.apache.lucene.store.IndexInput; //导入方法依赖的package包/类
/** 
 * Returns (but does not validate) the checksum previously written by {@link #checkFooter}.
 * @return actual checksum value
 * @throws IOException if the footer is invalid
 */
public static long retrieveChecksum(IndexInput in) throws IOException {
  in.seek(in.length() - footerLength());
  validateFooter(in);
  return in.readLong();
}