Java StubInputStream类代码示例

import com.intellij.psi.stubs.StubInputStream; //导入依赖的package包/类
@NotNull
@Override
public PsiClassStub deserialize(@NotNull final StubInputStream dataStream, final StubElement parentStub) throws IOException {
  byte flags = dataStream.readByte();
  boolean isAnonymous = PsiClassStubImpl.isAnonymous(flags);
  boolean isEnumConst = PsiClassStubImpl.isEnumConstInitializer(flags);
  JavaClassElementType type = typeForClass(isAnonymous, isEnumConst);

  if (!isAnonymous) {
    StringRef name = dataStream.readName();
    StringRef qname = dataStream.readName();
    int languageLevelId = dataStream.readByte();
    StringRef sourceFileName = dataStream.readName();
    PsiClassStubImpl classStub = new PsiClassStubImpl(type, parentStub, qname, name, null, flags);
    classStub.setLanguageLevel(LanguageLevel.values()[languageLevelId]);
    classStub.setSourceFileName(sourceFileName);
    return classStub;
  }
  else {
    StringRef baseRef = dataStream.readName();
    return new PsiClassStubImpl(type, parentStub, null, null, baseRef, flags);
  }
}
 

import com.intellij.psi.stubs.StubInputStream; //导入依赖的package包/类
@Nullable
public static QualifiedName deserialize(StubInputStream dataStream) throws IOException {
  QualifiedName qName;
  int size = dataStream.readVarInt();
  if (size == 0) {
    qName = null;
  }
  else {
    qName = new QualifiedName(size);
    for (int i = 0; i < size; i++) {
      final StringRef name = dataStream.readName();
      qName.myComponents.add(name == null ? null : name.getString());
    }
  }
  return qName;
}
 

import com.intellij.psi.stubs.StubInputStream; //导入依赖的package包/类
@NotNull
public PyTargetExpressionStub deserialize(@NotNull final StubInputStream stream, final StubElement parentStub)
    throws IOException {
  String name = StringRef.toString(stream.readName());
  String docString = stream.readUTFFast();
  if (docString.isEmpty()) {
    docString = null;
  }
  PyTargetExpressionStub.InitializerType initializerType = PyTargetExpressionStub.InitializerType.fromIndex(stream.readVarInt());
  if (initializerType == PyTargetExpressionStub.InitializerType.Custom) {
    final String typeName = stream.readName().getString();
    for(CustomTargetExpressionStubType type: getCustomStubTypes()) {
      if (type.getClass().getCanonicalName().equals(typeName)) {
        CustomTargetExpressionStub stub = type.deserializeStub(stream);
        return new PyTargetExpressionStubImpl(name, docString, stub, parentStub);
      }
    }
    throw new IOException("Unknown custom stub type " + typeName);
  }
  QualifiedName initializer = QualifiedName.deserialize(stream);
  boolean isQualified = stream.readBoolean();
  return new PyTargetExpressionStubImpl(name, docString, initializerType, initializer, isQualified, parentStub);
}
 

import com.intellij.psi.stubs.StubInputStream; //导入依赖的package包/类
@NotNull
public static SerializedFqnTypeRef deserialize(@NotNull StubInputStream stream) throws IOException {
  String shortNameStr = StringRef.toString(stream.readName());

  Qn shortName = null;
  List<Qn> namespacesToSearch = null;

  if (shortNameStr != null) {
    shortName = Qn.fromDotSeparated(shortNameStr);

    namespacesToSearch = StubSerializerUtil.deserializeList(s -> {
      StringRef namespaceRef = s.readName();
      String namespace = StringRef.toString(namespaceRef);
      return namespace == null ? null : Qn.fromDotSeparated(namespace);
    }, stream, true);
  }

  return new SerializedFqnTypeRef(shortName, namespacesToSearch);
}
 

import com.intellij.psi.stubs.StubInputStream; //导入依赖的package包/类
@NotNull
public static <T> Set<T> deserializeSet(@NotNull Deserializer<T> itemDeserializer,
                                        @NotNull StubInputStream stream,
                                        boolean skipNulls) throws IOException {
  short numItems = stream.readShort();

  // can't do this, we may want to add more elements to it later on
  // if (numItems == 0) return Collections.emptySet();

  Set<T> result = ContainerUtil.newTroveSet();
  for (int i = 0; i < numItems; i++) {
    T item = itemDeserializer.deserialize(stream);
    if (item != null || skipNulls)
      result.add(item);
  }

  return result;
}
 

import com.intellij.psi.stubs.StubInputStream; //导入依赖的package包/类
@NotNull
public static <T> List<T> deserializeList(@NotNull Deserializer<T> itemDeserializer,
                                          @NotNull StubInputStream stream,
                                          boolean skipNulls) throws IOException {
  short numItems = stream.readShort();

  // can't do this, we may want to add more elements to it later on
  // if (numItems == 0) return Collections.emptyList();

  List<T> result = ContainerUtil.newSmartList(); // our lists often contain only one element
  for (int i = 0; i < numItems; i++) {
    T item = itemDeserializer.deserialize(stream);
    if (item != null || skipNulls)
      result.add(item);
  }

  return result;
}
 

import com.intellij.psi.stubs.StubInputStream; //导入依赖的package包/类
@Override
@Nullable
public LuaTableStub deserialize(StubInputStream dataStream, StubElement parentStub) throws IOException {
    boolean hasType = dataStream.readBoolean();
    byte[] typedata = null;
    if (hasType)
    {
        int len = dataStream.readVarInt();
        if (len < 0) ((SerializationManagerEx) SerializationManagerEx.getInstance()).repairNameStorage();

        if (len <= 0) {
            return new LuaTableStubImpl(parentStub);
        }

        typedata = new byte[len];
        dataStream.read(typedata, 0, len);
    }

    return new LuaTableStubImpl(parentStub, typedata);
}
 

import com.intellij.psi.stubs.StubInputStream; //导入依赖的package包/类
@NotNull
@Override
public PsiClassStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException
{
	byte flags = dataStream.readByte();
	boolean isAnonymous = PsiClassStubImpl.isAnonymous(flags);

	if(!isAnonymous)
	{
		StringRef name = dataStream.readName();
		StringRef qname = dataStream.readName();
		StringRef sourceFileName = dataStream.readName();
		PsiClassStubImpl classStub = new PsiClassStubImpl(this, parentStub, StringRef.toString(qname), StringRef.toString(name), null, flags);
		classStub.setSourceFileName(StringRef.toString(sourceFileName));
		return classStub;
	}
	else
	{
		StringRef baseRef = dataStream.readName();
		return new PsiClassStubImpl(this, parentStub, null, null, StringRef.toString(baseRef), flags);
	}
}
 

import com.intellij.psi.stubs.StubInputStream; //导入依赖的package包/类
@NotNull
public static TypeInfo readTYPE(@NotNull StubInputStream record) throws IOException
{
	int flags = 0xFF & record.readByte();
	if(flags == FREQUENT_INDEX_MASK)
	{
		return NULL;
	}

	int frequentIndex = FREQUENT_INDEX_MASK & flags;
	byte arrayCount = isSet(flags, HAS_ARRAY_COUNT) ? record.readByte() : 0;
	boolean hasEllipsis = isSet(flags, HAS_ELLIPSIS);

	String text = frequentIndex == 0 ? StringRef.toString(record.readName()) : ourIndexFrequentType[frequentIndex];

	return new TypeInfo(text, arrayCount, hasEllipsis, PsiAnnotationStub.EMPTY_ARRAY);
}
 

import com.intellij.psi.stubs.StubInputStream; //导入依赖的package包/类
@NotNull
@Override
public TemplateDefinitionStub deserialize(
    @NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
  final StringRef ref = dataStream.readName();
  return new TemplateDefinitionStub(parentStub, ref.getString());
}
 

import com.intellij.psi.stubs.StubInputStream; //导入依赖的package包/类
@NotNull
@Override
public NamespaceDeclarationStub deserialize(
    @NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
  final StringRef ref = dataStream.readName();
  return new NamespaceDeclarationStub(parentStub, ref.getString());
}
 

import com.intellij.psi.stubs.StubInputStream; //导入依赖的package包/类
@NotNull
@Override
public AtParamStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub)
    throws IOException {
  final StringRef ref = dataStream.readName();
  final StringRef ref2 = dataStream.readName();
  return new AtParamStub(
      parentStub, ref.getString(), ref2.getString(), dataStream.readBoolean());
}
 

import com.intellij.psi.stubs.StubInputStream; //导入依赖的package包/类
@Override
public LuaCompoundIdentifierStub deserialize(StubInputStream dataStream, StubElement parentStub) throws IOException {
    StringRef ref = dataStream.readName();

    final Pair<LuaType, byte[]> pair = LuaStubUtils.readSubstitutableType(dataStream);
    byte[] typedata = pair.getSecond();
    LuaType type = pair.first;

    boolean isDeclaration = dataStream.readBoolean();

    return new LuaCompoundIdentifierStubImpl(parentStub, ref, isDeclaration, typedata, type);
}
 

import com.intellij.psi.stubs.StubInputStream; //导入依赖的package包/类
@Override
public LuaModuleDeclarationStub deserialize(StubInputStream dataStream, StubElement parentStub) throws
        IOException {
    StringRef ref = dataStream.readName();
    StringRef mref = dataStream.readName();

    int len = dataStream.readVarInt();
    byte[] typedata = new byte[len];
    int readLen = dataStream.read(typedata, 0, len);

    assert readLen == len;

    return new LuaModuleDeclarationStubImpl(parentStub, ref, mref, typedata);
}
 

import com.intellij.psi.stubs.StubInputStream; //导入依赖的package包/类
public static Pair<LuaType, byte[]> readSubstitutableType(StubInputStream dataStream) throws IOException {
    final boolean primitive = dataStream.readBoolean();
    LuaType type = null;
    byte[] bytes = null;


    if (primitive)
        type = LuaPrimitiveType.PRIMITIVE_TYPES[dataStream.readByte()];
    else {
        bytes = new byte[dataStream.readVarInt()];
        int len = dataStream.read(bytes, 0, bytes.length);
        assert len == bytes.length : "read wrong length";
    }
    return new Pair<LuaType, byte[]>(type, bytes);
}