Java DataExternalizer类代码示例

import com.intellij.util.io.DataExternalizer; //导入依赖的package包/类
public static DataExternalizer<EnumeratedMethodIncompleteSignature> createDataExternalizer() {
  return new DataExternalizer<EnumeratedMethodIncompleteSignature>() {
    @Override
    public void save(@NotNull final DataOutput out, final EnumeratedMethodIncompleteSignature value) throws IOException {
      out.writeInt(value.getOwner());
      out.writeInt(value.getName());
      out.writeBoolean(value.isStatic());
    }

    @Override
    public EnumeratedMethodIncompleteSignature read(@NotNull final DataInput in) throws IOException {
      return new EnumeratedMethodIncompleteSignature(in.readInt(),
                                                     in.readInt(),
                                                     in.readBoolean());
    }
  };
}
 

import com.intellij.util.io.DataExternalizer; //导入依赖的package包/类
public ObjectObjectPersistentMultiMaplet(final File file,
                                      final KeyDescriptor<K> keyExternalizer,
                                      final DataExternalizer<V> valueExternalizer,
                                      final CollectionFactory<V> collectionFactory) throws IOException {
  myValueExternalizer = valueExternalizer;
  myMap = new PersistentHashMap<K, Collection<V>>(file, keyExternalizer, new CollectionDataExternalizer<V>(valueExternalizer, collectionFactory));
  myCache = new SLRUCache<K, Collection>(CACHE_SIZE, CACHE_SIZE, keyExternalizer) {
    @NotNull
    @Override
    public Collection createValue(K key) {
      try {
        final Collection<V> collection = myMap.get(key);
        return collection == null? NULL_COLLECTION : collection;
      }
      catch (IOException e) {
        throw new BuildDataCorruptedException(e);
      }
    }
  };
}
 

import com.intellij.util.io.DataExternalizer; //导入依赖的package包/类
public IntObjectPersistentMultiMaplet(final File file,
                                      final KeyDescriptor<Integer> keyExternalizer,
                                      final DataExternalizer<V> valueExternalizer,
                                      final CollectionFactory<V> collectionFactory) throws IOException {
  myValueExternalizer = valueExternalizer;
  myMap = new PersistentHashMap<Integer, Collection<V>>(file, keyExternalizer, new CollectionDataExternalizer<V>(valueExternalizer, collectionFactory));
  myCache = new SLRUCache<Integer, Collection>(CACHE_SIZE, CACHE_SIZE) {
    @NotNull
    @Override
    public Collection createValue(Integer key) {
      try {
        final Collection<V> collection = myMap.get(key);
        return collection == null? NULL_COLLECTION : collection;
      }
      catch (IOException e) {
        throw new BuildDataCorruptedException(e);
      }
    }
  };
}
 

import com.intellij.util.io.DataExternalizer; //导入依赖的package包/类
@NotNull
private static ThrowableComputable<PersistentHashMap<String, Record>, IOException> getComputable(final File file) {
  return new ThrowableComputable<PersistentHashMap<String, Record>, IOException>() {
    @Override
    public PersistentHashMap<String, Record> compute() throws IOException {
      return new PersistentHashMap<String, Record>(file, new EnumeratorStringDescriptor(), new DataExternalizer<Record>() {
        @Override
        public void save(@NotNull DataOutput out, Record value) throws IOException {
          out.writeInt(value.magnitude);
          out.writeLong(value.date.getTime());
        }

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

import com.intellij.util.io.DataExternalizer; //导入依赖的package包/类
@Override
public void saveTo(DataOutput out, DataExternalizer<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 ValueContainer<Value> toAppend = getAddedDelta();
    if (toAppend != null && toAppend.size() > 0) {
      toAppend.saveTo(out, externalizer);
    }
  }
}
 

import com.intellij.util.io.DataExternalizer; //导入依赖的package包/类
@NotNull
@Override
public DataExternalizer<XsdNamespaceBuilder> getValueExternalizer() {
  return new DataExternalizer<XsdNamespaceBuilder>() {
    @Override
    public void save(@NotNull DataOutput out, XsdNamespaceBuilder value) throws IOException {
      IOUtil.writeUTF(out, value.getNamespace() == null ? "" : value.getNamespace());
      IOUtil.writeUTF(out, value.getVersion() == null ? "" : value.getVersion());
      writeList(out, value.getTags());
      writeList(out, value.getRootTags());
    }

    @Override
    public XsdNamespaceBuilder read(@NotNull DataInput in) throws IOException {

      return new XsdNamespaceBuilder(IOUtil.readUTF(in),
                                     IOUtil.readUTF(in),
                                     readList(in),
                                     readList(in));
    }
  };
}
 

import com.intellij.util.io.DataExternalizer; //导入依赖的package包/类
@NotNull
@Override
public DataExternalizer<CMakeCommandExpr> getValueExternalizer() {
    return new DataExternalizer<CMakeCommandExpr>() {
        @Override
        public void save(@NotNull DataOutput dataOutput, CMakeCommandExpr cMakeCommandExpr) throws IOException {
            dataOutput.writeChars(cMakeCommandExpr.getText());
        }

        @Override
        public CMakeCommandExpr read(@NotNull DataInput dataInput) throws IOException {
            // Create new file from string content and return first file element
            // TODO:
            String name = "test.dummy.cmake";
            CMakeFile tmp = (CMakeFile) PsiFileFactory.getInstance(null).
                    createFileFromText(name, CMakeFileType.INSTANCE, dataInput.readLine());
            return (CMakeCommandExpr) tmp.getFirstChild().getFirstChild().getFirstChild();
        }
    };
}
 

import com.intellij.util.io.DataExternalizer; //导入依赖的package包/类
public ObjectObjectPersistentMultiMaplet(final File file,
                                      final KeyDescriptor<K> keyExternalizer,
                                      final DataExternalizer<V> valueExternalizer,
                                      final CollectionFactory<V> collectionFactory) throws IOException {
  myValueExternalizer = valueExternalizer;
  myMap = new PersistentHashMap<K, Collection<V>>(file, keyExternalizer, new CollectionDataExternalizer<V>(valueExternalizer, collectionFactory));
  myCache = new SLRUCache<K, Collection>(CACHE_SIZE, CACHE_SIZE) {
    @NotNull
    @Override
    public Collection createValue(K key) {
      try {
        final Collection<V> collection = myMap.get(key);
        return collection == null? NULL_COLLECTION : collection;
      }
      catch (IOException e) {
        throw new RuntimeException(e);
      }
    }
  };
}
 

import com.intellij.util.io.DataExternalizer; //导入依赖的package包/类
public IntObjectPersistentMaplet(final File file, final DataExternalizer<V> externalizer) {
  try {
    myMap = new PersistentHashMap<Integer, V>(file, new IntInlineKeyDescriptor(), externalizer);
    myCache = new SLRUCache<Integer, Object>(CACHE_SIZE, CACHE_SIZE) {
      @NotNull
      @Override
      public Object createValue(Integer key) {
        try {
          final V v1 = myMap.get(key);
          return v1 == null? NULL_OBJ : v1;
        }
        catch (IOException e) {
          throw new RuntimeException(e);
        }
      }
    };
  }
  catch (IOException e) {
    throw new RuntimeException(e);
  }
}
 

import com.intellij.util.io.DataExternalizer; //导入依赖的package包/类
public IntObjectPersistentMultiMaplet(final File file,
                                      final KeyDescriptor<Integer> keyExternalizer,
                                      final DataExternalizer<V> valueExternalizer,
                                      final CollectionFactory<V> collectionFactory) throws IOException {
  myValueExternalizer = valueExternalizer;
  myMap = new PersistentHashMap<Integer, Collection<V>>(file, keyExternalizer, new CollectionDataExternalizer<V>(valueExternalizer, collectionFactory));
  myCache = new SLRUCache<Integer, Collection>(CACHE_SIZE, CACHE_SIZE) {
    @NotNull
    @Override
    public Collection createValue(Integer key) {
      try {
        final Collection<V> collection = myMap.get(key);
        return collection == null? NULL_COLLECTION : collection;
      }
      catch (IOException e) {
        throw new RuntimeException(e);
      }
    }
  };
}
 

import com.intellij.util.io.DataExternalizer; //导入依赖的package包/类
ClassType(final DependencyContext context, final DataInput in) {
  try {
    className = in.readInt();
    final int size = in.readInt();
    if (size == 0) {
      typeArgs = EMPTY_TYPE_ARRAY;
    }
    else {
      typeArgs = new AbstractType[size];
      final DataExternalizer<AbstractType> externalizer = externalizer(context);
      for (int i = 0; i < size; i++) {
        typeArgs[i] = externalizer.read(in);
      }
    }
  }
  catch (IOException e) {
    throw new RuntimeException(e);
  }
}
 

import com.intellij.util.io.DataExternalizer; //导入依赖的package包/类
public static DataExternalizer<MethodShortSignature> createDataExternalizer() {
  final EnumeratorStringDescriptor stringDescriptor = new EnumeratorStringDescriptor();
  return new DataExternalizer<MethodShortSignature>() {

    @Override
    public void save(final DataOutput out, final MethodShortSignature value) throws IOException {
      stringDescriptor.save(out, value.getName());
      stringDescriptor.save(out, value.getSignature());
    }

    @Override
    public MethodShortSignature read(final DataInput in) throws IOException {
      return new MethodShortSignature(stringDescriptor.read(in), stringDescriptor.read(in));
    }
  };
}
 

import com.intellij.util.io.DataExternalizer; //导入依赖的package包/类
@Override
public DataExternalizer<XsdNamespaceBuilder> getValueExternalizer() {
  return new DataExternalizer<XsdNamespaceBuilder>() {
    @Override
    public void save(DataOutput out, XsdNamespaceBuilder value) throws IOException {
      out.writeUTF(value.getNamespace() == null ? "" : value.getNamespace());
      out.writeUTF(value.getVersion() == null ? "" : value.getVersion());
      out.writeInt(value.getTags().size());
      for (String s : value.getTags()) {
        out.writeUTF(s);
      }
    }

    @Override
    public XsdNamespaceBuilder read(DataInput in) throws IOException {

      int count;
      XsdNamespaceBuilder builder = new XsdNamespaceBuilder(in.readUTF(), in.readUTF(), new ArrayList<String>(count = in.readInt()));
      for (int i = 0; i < count; i++) {
        builder.getTags().add(in.readUTF());
      }
      return builder;
    }
  };
}
 

import com.intellij.util.io.DataExternalizer; //导入依赖的package包/类
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 = new MyMapReduceIndex(myIndexer, externalizer, version);

  Disposer.register(disposableParent, this);
}
 

import com.intellij.util.io.DataExternalizer; //导入依赖的package包/类
@Override
public void saveTo(DataOutput out, DataExternalizer<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 = getAddedDelta();
    if (toAppend != null && toAppend.size() > 0) {
      toAppend.saveTo(out, externalizer);
    }
  }
}