com.intellij.util.io.DataExternalizer Java Examples

@Override
public void saveTo(DataOutput out, DataExternalizer<? super Value> externalizer) throws IOException {
  if (needsCompacting()) {
    getMergedData().saveTo(out, externalizer);
  }
  else {
    final TIntHashSet set = myInvalidated;
    if (set != null && set.size() > 0) {
      for (int inputId : set.toArray()) {
        DataInputOutputUtil.writeINT(out, -inputId); // mark inputId as invalid, to be processed on load in ValueContainerImpl.readFrom
      }
    }

    final UpdatableValueContainer<Value> toAppend = myAdded;
    if (toAppend != null && toAppend.size() > 0) {
      toAppend.saveTo(out, externalizer);
    }
  }
}
 

public VcsLogFullDetailsIndex(@Nonnull String logId,
                              @Nonnull String name,
                              final int version,
                              @Nonnull DataIndexer<Integer, T, VcsFullCommitDetails> indexer,
                              @Nonnull DataExternalizer<T> externalizer,
                              @Nonnull FatalErrorHandler fatalErrorHandler,
                              @Nonnull Disposable disposableParent) throws IOException {
  myID = ID.create(name);
  myName = name;
  myLogId = logId;
  myIndexer = indexer;
  myFatalErrorHandler = fatalErrorHandler;

  myMapReduceIndex = createMapReduceIndex(externalizer, version);

  Disposer.register(disposableParent, this);
}
 

public static <Key, Value> void checkValuesHaveProperEqualsAndHashCode(@Nonnull Map<Key, Value> data, @Nonnull IndexId<Key, Value> indexId, @Nonnull DataExternalizer<Value> valueExternalizer) {
  if (DebugAssertions.DEBUG) {
    for (Map.Entry<Key, Value> e : data.entrySet()) {
      final Value value = e.getValue();
      if (!(Comparing.equal(value, value) && (value == null || value.hashCode() == value.hashCode()))) {
        LOG.error("Index " + indexId + " violates equals / hashCode contract for Value parameter");
      }

      try {
        final BufferExposingByteArrayOutputStream out = new BufferExposingByteArrayOutputStream();
        DataOutputStream outputStream = new DataOutputStream(out);
        valueExternalizer.save(outputStream, value);
        outputStream.close();
        final Value deserializedValue = valueExternalizer.read(new DataInputStream(out.toInputStream()));

        if (!(Comparing.equal(value, deserializedValue) && (value == null || value.hashCode() == deserializedValue.hashCode()))) {
          LOG.error("Index " + indexId + " deserialization violates equals / hashCode contract for Value parameter");
        }
      }
      catch (IOException ex) {
        LOG.error(ex);
      }
    }
  }
}
 

@Nonnull
private static ThrowableComputable<PersistentHashMap<String, Record>, IOException> getComputable(final File file) {
  return () -> new PersistentHashMap<>(file, EnumeratorStringDescriptor.INSTANCE, new DataExternalizer<Record>() {
    @Override
    public void save(@Nonnull DataOutput out, Record value) throws IOException {
      out.writeInt(value.magnitude);
      out.writeLong(value.date.getTime());
      out.writeLong(value.configurationHash);
    }

    @Override
    public Record read(@Nonnull DataInput in) throws IOException {
      return new Record(in.readInt(), new Date(in.readLong()), in.readLong());
    }
  }, 4096, CURRENT_VERSION);
}
 

protected MyMapIndexStorage(@Nonnull File storageFile,
                            @Nonnull KeyDescriptor<Integer> keyDescriptor,
                            @Nonnull DataExternalizer<T> valueExternalizer,
                            int cacheSize,
                            boolean keyIsUniqueForIndexedFile) throws IOException {
  super(storageFile, keyDescriptor, valueExternalizer, cacheSize, keyIsUniqueForIndexedFile);
}
 

ValueContainerMap(@Nonnull final File file,
                  @Nonnull KeyDescriptor<Key> keyKeyDescriptor,
                  @Nonnull DataExternalizer<Value> valueExternalizer,
                  boolean keyIsUniqueForIndexedFile,
                  @Nonnull IntIntFunction inputRemapping) throws IOException {
  super(file, keyKeyDescriptor, new ValueContainerExternalizer<>(valueExternalizer, inputRemapping));
  myValueExternalizer = valueExternalizer;
  myKeyIsUniqueForIndexedFile = keyIsUniqueForIndexedFile;
}
 

public SmallMapSerializer(final File file, final KeyDescriptor<K> keyDescriptor, final DataExternalizer<V> valueExternalizer) {
  myFile = file;
  myKeyDescriptor = keyDescriptor;
  myValueExternalizer = valueExternalizer;
  myMap = new HashMap<KeyWrapper<K>, V>();
  init();
}
 

@Nonnull
@Override
public DataExternalizer<SerializedStubTree> createValueExternalizer() {
  File path = getIndexPath();
  SerializationManagerImpl manager = new SerializationManagerImpl(new File(new File(path, StringUtil.toLowerCase(StubUpdatingIndex.INDEX_ID.getName())), "rep.names"), true);
  Disposer.register(ApplicationManager.getApplication(), manager);
  return new SerializedStubTreeDataExternalizer(false, manager);
}
 

@Override
public void saveTo(DataOutput out, DataExternalizer<? super Value> externalizer) throws IOException {
  DataInputOutputUtil.writeINT(out, size());

  for (final InvertedIndexValueIterator<Value> valueIterator = getValueIterator(); valueIterator.hasNext(); ) {
    final Value value = valueIterator.next();
    externalizer.save(out, value);
    Object fileSetObject = valueIterator.getFileSetObject();

    if (fileSetObject instanceof Integer) {
      DataInputOutputUtil.writeINT(out, (Integer)fileSetObject); // most common 90% case during index building
    }
    else {
      // serialize positive file ids with delta encoding
      ChangeBufferingList originalInput = (ChangeBufferingList)fileSetObject;
      IntIdsIterator intIterator = originalInput.sortedIntIterator();
      if (DebugAssertions.DEBUG) DebugAssertions.assertTrue(intIterator.hasAscendingOrder());

      if (intIterator.size() == 1) {
        DataInputOutputUtil.writeINT(out, intIterator.next());
      }
      else {
        DataInputOutputUtil.writeINT(out, -intIterator.size());
        int prev = 0;

        while (intIterator.hasNext()) {
          int fileId = intIterator.next();
          DataInputOutputUtil.writeINT(out, fileId - prev);
          prev = fileId;
        }
      }
    }
  }
}
 

@NotNull
public DataExternalizer<ServiceSerializable> getValueExternalizer() {
    return EXTERNALIZER;
}
 

@Nonnull
@Override
public DataExternalizer<Integer> getValueExternalizer() {
  return myValueExternalizer;
}
 

public AbstractForwardIndexAccessor(@Nonnull DataExternalizer<DataType> externalizer) {
  myDataTypeExternalizer = externalizer;
}
 

@NotNull
public DataExternalizer<ContainerBuilderCall> getValueExternalizer() {
    return EXTERNALIZER;
}
 

@Nonnull
@Override
public DataExternalizer<VirtualFilePersistentState> getSourceStateExternalizer() {
  return VirtualFilePersistentState.EXTERNALIZER;
}
 

@NotNull
@Override
public DataExternalizer<Void> getValueExternalizer() {
    return VoidDataExternalizer.INSTANCE;
}
 

@NotNull
public DataExternalizer<PhpInjectFileReference> getValueExternalizer() {
    return VALUE_EXTERNALIZER;
}
 

@NotNull
@Override
public DataExternalizer<String> getValueExternalizer() {
  return myKeyDescriptor;
}
 

@Nonnull
@Override
public DataExternalizer<Integer> getValueExternalizer() {
  return myValueExternalizer;
}
 

@NotNull
@Override
public DataExternalizer<DoctrineModelSerializable> getValueExternalizer() {
    return EXTERNALIZER;
}
 

@NotNull
@Override
public DataExternalizer<StubIndexedRoute> getValueExternalizer() {
    return EXTERNALIZER;
}
 

@NotNull
@Override
public DataExternalizer<Integer> getValueExternalizer() {
    return EnumeratorIntegerDescriptor.INSTANCE;
}
 

@NotNull
@Override
public DataExternalizer<Set<String>> getValueExternalizer() {
    return DATA_EXTERNALIZER;
}
 

@NotNull
@Override
public DataExternalizer<Void> getValueExternalizer() {
    return VoidDataExternalizer.INSTANCE;
}
 

@Override
public DataExternalizer<List<HaxeClassInfo>> getValueExternalizer() {
  return myExternalizer;
}
 

@Override
public DataExternalizer<List<HaxeClassInfo>> getValueExternalizer() {
  return myExternalizer;
}
 

public static <Data> ByteArraySequence serializeToByteSeq(@Nonnull Data data, @Nonnull DataExternalizer<Data> externalizer, int bufferInitialSize) throws IOException {
  BufferExposingByteArrayOutputStream out = new BufferExposingByteArrayOutputStream(ourSpareByteArray.getBuffer(bufferInitialSize));
  DataOutputStream stream = new DataOutputStream(out);
  externalizer.save(stream, data);
  return out.toByteArraySequence();
}
 

/**
 * Returns {@link DataExternalizer} instance.
 *
 * @return {@link #DATA_EXTERNALIZER}
 */
@NotNull
@Override
public DataExternalizer<IgnoreEntryOccurrence> getValueExternalizer() {
    return DATA_EXTERNALIZER;
}
 

@NotNull
@Override
public DataExternalizer<Set<String>> getValueExternalizer() {
    return EXTERNALIZER;
}
 

@NotNull
public DataExternalizer<Void> getValueExternalizer() {
    return VoidDataExternalizer.INSTANCE;
}
 

public AbstractMapForwardIndexAccessor(@Nonnull DataExternalizer<DataType> externalizer) {
  super(externalizer);
}