Java 类com.intellij.openapi.util.NullableLazyValue 实例源码

public FilePathLookupElement lookupElementForFile(
    Project project, VirtualFile file, @Nullable WorkspacePath workspacePath) {
  NullableLazyValue<Icon> icon =
      new NullableLazyValue<Icon>() {
        @Override
        protected Icon compute() {
          if (file.findChild("BUILD") != null) {
            return BlazeIcons.BuildFile;
          }
          if (file.isDirectory()) {
            return PlatformIcons.FOLDER_ICON;
          }
          PsiFile psiFile = PsiManager.getInstance(project).findFile(file);
          return psiFile != null ? psiFile.getIcon(0) : AllIcons.FileTypes.Any_type;
        }
      };
  String fullLabel =
      workspacePath != null ? getFullLabel(workspacePath.relativePath()) : file.getPath();
  String itemText = workspacePath != null ? getItemText(workspacePath.relativePath()) : fullLabel;
  return new FilePathLookupElement(fullLabel, itemText, quoteType, icon);
}

@RequiredReadAction
public MsilPropertyAsCSharpPropertyDeclaration(PsiElement parent, MsilPropertyEntry variable, List<Pair<DotNetXXXAccessor, MsilMethodEntry>> pairs)
{
    super(parent, getAdditionalModifiers(variable, pairs), variable);
    myAccessors = buildAccessors(this, pairs);

    myTypeForImplementValue = NullableLazyValue.of(() ->
    {
        String nameFromBytecode = getVariable().getNameFromBytecode();
        String typeBeforeDot = StringUtil.getPackageName(nameFromBytecode);
        SomeType someType = SomeTypeParser.parseType(typeBeforeDot, nameFromBytecode);
        if(someType != null)
        {
            return new DummyType(getProject(), MsilPropertyAsCSharpPropertyDeclaration.this, someType);
        }
        return null;
    });
}

@RequiredReadAction
public MsilEventAsCSharpEventDeclaration(PsiElement parent, MsilEventEntry variable, List<Pair<DotNetXXXAccessor, MsilMethodEntry>> pairs)
{
    super(parent, MsilPropertyAsCSharpPropertyDeclaration.getAdditionalModifiers(variable, pairs), variable);
    myAccessors = MsilPropertyAsCSharpPropertyDeclaration.buildAccessors(this, pairs);

    myTypeForImplementValue = NullableLazyValue.of(() ->
    {
        String nameFromBytecode = getVariable().getNameFromBytecode();
        String typeBeforeDot = StringUtil.getPackageName(nameFromBytecode);
        SomeType someType = SomeTypeParser.parseType(typeBeforeDot, nameFromBytecode);
        if(someType != null)
        {
            return new DummyType(getProject(), MsilEventAsCSharpEventDeclaration.this, someType);
        }
        return null;
    });
}

@RequiredReadAction
public MsilMethodAsCSharpMethodDeclaration(PsiElement parent, @Nullable MsilClassEntry declaration, @NotNull GenericParameterContext genericParameterContext, @NotNull MsilMethodEntry methodEntry)
{
    super(parent, CSharpModifier.EMPTY_ARRAY, methodEntry);
    myDelegate = declaration;

    setGenericParameterList(declaration != null ? declaration : methodEntry, genericParameterContext);

    myTypeForImplementValue = NullableLazyValue.of(() ->
    {
        String nameFromBytecode = myOriginal.getNameFromBytecode();
        String typeBeforeDot = StringUtil.getPackageName(nameFromBytecode);
        SomeType someType = SomeTypeParser.parseType(typeBeforeDot, nameFromBytecode);
        if(someType != null)
        {
            return new DummyType(getProject(), MsilMethodAsCSharpMethodDeclaration.this, someType);
        }
        return null;
    });
}

@RequiredReadAction
public MsilModifierListToCSharpModifierList(@NotNull CSharpModifier[] additional, @NotNull PsiElement parent, @NotNull DotNetModifierList modifierList)
{
    super(parent, modifierList);
    myAdditional = additional;
    myModifierList = modifierList;

    if(myModifierList.hasModifier(MsilTokens.SERIALIZABLE_KEYWORD))
    {
        addAdditionalAttribute(new CSharpLightAttributeBuilder(myModifierList, DotNetTypes.System.Serializable));
    }

    if(myModifierList.hasModifier(MsilTokens.BRACKET_OUT_KEYWORD))
    {
        addAdditionalAttribute(new CSharpLightAttributeBuilder(myModifierList, DotNetTypes2.System.Runtime.InteropServices.OutAttribute));
    }

    if(myModifierList.hasModifier(MsilTokens.BRACKET_IN_KEYWORD))
    {
        addAdditionalAttribute(new CSharpLightAttributeBuilder(myModifierList, DotNetTypes2.System.Runtime.InteropServices.InAttribute));
    }

    myAttributeHolderValue = NullableLazyValue.of(() -> ExternalAttributesUtil.findHolder(myModifierList));
}

public EvaluationContextImpl(@NotNull SuspendContextImpl suspendContext, @NotNull StackFrameProxyImpl frameProxy)
{
    myThisObject = NullableLazyValue.of(() ->
    {
        try
        {
            return frameProxy.thisObject();
        }
        catch(EvaluateException ignore)
        {
        }
        return null;
    });
    myFrameProxy = frameProxy;
    mySuspendContext = suspendContext;
}

@Nullable
public MappingList findMappingList(@NotNull List<Url> sourceUrls, @Nullable VirtualFile sourceFile, @Nullable NullableLazyValue<SourceResolver.Resolver> resolver) {
  MappingList mappings = sourceResolver.findMappings(sourceUrls, this, sourceFile);
  if (mappings == null && resolver != null) {
    SourceResolver.Resolver resolverValue = resolver.getValue();
    if (resolverValue != null) {
      mappings = sourceResolver.findMappings(sourceFile, this, resolverValue);
    }
  }
  return mappings;
}

public boolean processMappingsInLine(@NotNull List<Url> sourceUrls,
                                     int sourceLine,
                                     @NotNull MappingList.MappingsProcessorInLine mappingProcessor,
                                     @Nullable VirtualFile sourceFile,
                                     @Nullable NullableLazyValue<SourceResolver.Resolver> resolver) {
  MappingList mappings = findMappingList(sourceUrls, sourceFile, resolver);
  return mappings != null && mappings.processMappingsInLine(sourceLine, mappingProcessor);
}

public PathReference(@NotNull String path, final @NotNull Function<PathReference, Icon> icon) {
  myPath = path;
  myIcon = new NullableLazyValue<Icon>() {
    @Override
    protected Icon compute() {
      return icon.fun(PathReference.this);
    }
  };
}

public PathReference(@NotNull String path, final @NotNull Function<PathReference, Icon> icon) {
  myPath = path;
  myIcon = new NullableLazyValue<Icon>() {
    @Override
    protected Icon compute() {
      return icon.fun(PathReference.this);
    }
  };
}

protected void setGenericParameterList(@NotNull DotNetGenericParameterListOwner owner, @NotNull GenericParameterContext genericParameterContext)
{
    DotNetGenericParameterList genericParameterList = owner.getGenericParameterList();
    myGenericParameterList = MsilGenericParameterListAsCSharpGenericParameterList.build(this, genericParameterList, genericParameterContext);
    myGenericConstraintListValue = new NullableLazyValue<CSharpLightGenericConstraintList>()
    {
        @Nullable
        @Override
        @RequiredReadAction
        protected CSharpLightGenericConstraintList compute()
        {
            return MsilAsCSharpBuildUtil.buildConstraintList(myGenericParameterList);
        }
    };
}

public PathReference(@Nonnull String path, final @Nonnull Function<PathReference, Icon> icon) {
  myPath = path;
  myIcon = new NullableLazyValue<Icon>() {
    @Override
    protected Icon compute() {
      return icon.fun(PathReference.this);
    }
  };
}

public NullableLazyValue<Icon> getIcon() {
  return myIcon;
}

public NullableLazyValue<String> getTypeName() {
  return myName;
}

public FilePathLookupElement(
    String fullLabel, String itemText, QuoteType quoteWrapping, NullableLazyValue<Icon> icon) {
  super(fullLabel, quoteWrapping);
  this.itemText = itemText;
  this.icon = icon;
}

public NullableLazyValue<Icon> getIcon() {
  return myIcon;
}

public NullableLazyValue<String> getTypeName() {
  return myName;
}

@RequiredReadAction
public MsilPropertyAsCSharpIndexMethodDeclaration(PsiElement parent, MsilPropertyEntry propertyEntry, List<Pair<DotNetXXXAccessor, MsilMethodEntry>> pairs)
{
    super(parent, propertyEntry);

    myAccessors = MsilPropertyAsCSharpPropertyDeclaration.buildAccessors(this, pairs);
    myModifierList = new MsilModifierListToCSharpModifierList(MsilPropertyAsCSharpPropertyDeclaration.getAdditionalModifiers(propertyEntry, pairs), this, propertyEntry.getModifierList());

    String name = getName();
    if(!Comparing.equal(name, DotNetPropertyDeclaration.DEFAULT_INDEX_PROPERTY_NAME))
    {
        CSharpLightAttributeBuilder attribute = new CSharpLightAttributeBuilder(propertyEntry, DotNetTypes.System.Runtime.CompilerServices.IndexerName);

        attribute.addParameterExpression(name);

        myModifierList.addAdditionalAttribute(attribute);
    }
    Pair<DotNetXXXAccessor, MsilMethodEntry> p = pairs.get(0);

    DotNetParameter firstParameter = p.getSecond().getParameters()[0];
    myParameters = new DotNetParameter[]{new MsilParameterAsCSharpParameter(this, firstParameter, this, 0)};

    myTypeForImplementValue = NullableLazyValue.of(() ->
    {
        String nameFromBytecode = myOriginal.getNameFromBytecode();
        String typeBeforeDot = StringUtil.getPackageName(nameFromBytecode);
        SomeType someType = SomeTypeParser.parseType(typeBeforeDot, nameFromBytecode);
        if(someType != null)
        {
            return new DummyType(getProject(), MsilPropertyAsCSharpIndexMethodDeclaration.this, someType);
        }
        return null;
    });

    myReturnTypeRefValue = NotNullLazyValue.createValue(() -> MsilToCSharpUtil.extractToCSharp(myOriginal.toTypeRef(false), myOriginal));
    myParameterTypeRefsValue = NotNullLazyValue.createValue(() ->
    {
        DotNetParameter[] parameters = getParameters();
        DotNetTypeRef[] typeRefs = new DotNetTypeRef[parameters.length];
        for(int i = 0; i < parameters.length; i++)
        {
            DotNetParameter parameter = parameters[i];
            typeRefs[i] = parameter.toTypeRef(false);
        }
        return typeRefs;
    });
}

public NullableLazyValue<Icon> getIcon() {
  return myIcon;
}

public NullableLazyValue<String> getTypeName() {
  return myName;
}

public EvaluationContextImpl(@NotNull SuspendContextImpl suspendContext, StackFrameProxyImpl frameProxy, @Nullable Value thisObject)
{
    myThisObject = NullableLazyValue.of(() -> thisObject);
    myFrameProxy = frameProxy;
    mySuspendContext = suspendContext;
}