Java NullableLazyValue类代码示例

import com.intellij.openapi.util.NullableLazyValue; //导入依赖的package包/类
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);
}
 

import com.intellij.openapi.util.NullableLazyValue; //导入依赖的package包/类
@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;
	});
}
 

import com.intellij.openapi.util.NullableLazyValue; //导入依赖的package包/类
@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;
	});
}
 

import com.intellij.openapi.util.NullableLazyValue; //导入依赖的package包/类
@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;
	});
}
 

import com.intellij.openapi.util.NullableLazyValue; //导入依赖的package包/类
@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));
}
 

import com.intellij.openapi.util.NullableLazyValue; //导入依赖的package包/类
public EvaluationContextImpl(@NotNull SuspendContextImpl suspendContext, @NotNull StackFrameProxyImpl frameProxy)
{
	myThisObject = NullableLazyValue.of(() ->
	{
		try
		{
			return frameProxy.thisObject();
		}
		catch(EvaluateException ignore)
		{
		}
		return null;
	});
	myFrameProxy = frameProxy;
	mySuspendContext = suspendContext;
}
 

import com.intellij.openapi.util.NullableLazyValue; //导入依赖的package包/类
@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;
}
 

import com.intellij.openapi.util.NullableLazyValue; //导入依赖的package包/类
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);
}
 

import com.intellij.openapi.util.NullableLazyValue; //导入依赖的package包/类
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);
    }
  };
}
 

import com.intellij.openapi.util.NullableLazyValue; //导入依赖的package包/类
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);
		}
	};
}
 

import com.intellij.openapi.util.NullableLazyValue; //导入依赖的package包/类
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);
    }
  };
}
 

import com.intellij.openapi.util.NullableLazyValue; //导入依赖的package包/类
public NullableLazyValue<Icon> getIcon() {
  return myIcon;
}
 

import com.intellij.openapi.util.NullableLazyValue; //导入依赖的package包/类
public NullableLazyValue<String> getTypeName() {
  return myName;
}
 

import com.intellij.openapi.util.NullableLazyValue; //导入依赖的package包/类
public FilePathLookupElement(
    String fullLabel, String itemText, QuoteType quoteWrapping, NullableLazyValue<Icon> icon) {
  super(fullLabel, quoteWrapping);
  this.itemText = itemText;
  this.icon = icon;
}
 

import com.intellij.openapi.util.NullableLazyValue; //导入依赖的package包/类
@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;
	});
}