Java SmartPointerManager类代码示例

import com.intellij.psi.SmartPointerManager; //导入依赖的package包/类
public LocalQuickFixOnPsiElement(PsiElement startElement, PsiElement endElement) {
  if (startElement == null || endElement == null) {
    myStartElement = myEndElement = null;
    return;
  }
  LOG.assertTrue(startElement.isValid());
  PsiFile startContainingFile = startElement.getContainingFile();
  PsiFile endContainingFile = startElement == endElement ? startContainingFile : endElement.getContainingFile();
  if (startElement != endElement) {
    LOG.assertTrue(endElement.isValid());
    LOG.assertTrue(startContainingFile == endContainingFile, "Both elements must be from the same file");
  }
  Project project = startContainingFile == null ? startElement.getProject() : startContainingFile.getProject(); // containingFile can be null for a directory
  myStartElement = SmartPointerManager.getInstance(project).createSmartPsiElementPointer(startElement, startContainingFile);
  myEndElement = endElement == startElement ? null : SmartPointerManager.getInstance(project).createSmartPsiElementPointer(endElement, endContainingFile);
}
 

import com.intellij.psi.SmartPointerManager; //导入依赖的package包/类
public void setData(PsiElement _element, String text, final boolean clearHistory, String effectiveExternalUrl, String ref) {
  myEffectiveExternalUrl = effectiveExternalUrl;
  if (myElement != null) {
    myBackStack.push(saveContext());
    myForwardStack.clear();
  }

  final SmartPsiElementPointer element = _element != null && _element.isValid()
                                         ? SmartPointerManager.getInstance(_element.getProject()).createSmartPsiElementPointer(_element)
                                         : null;

  if (element != null) {
    setElement(element);
  }

  myIsEmpty = false;
  updateControlState();
  setDataInternal(element, text, new Rectangle(0, 0), ref);

  if (clearHistory) clearHistory();
}
 

import com.intellij.psi.SmartPointerManager; //导入依赖的package包/类
@Override
public Object createAnchor(Object element) {
  if (element instanceof PsiElement) {
    final PsiElement psiElement = (PsiElement)element;

    return ApplicationManager.getApplication().runReadAction(new Computable<Object>() {
      @Override
      public Object compute() {
        SmartPointerWrapper pointer = psiElement.getUserData(PSI_ANCHORIZER_POINTER);
        if (!psiElement.isValid()) {
          return pointer != null ? pointer : psiElement;
        }

        if (pointer == null || pointer.myPointer.getElement() != psiElement) {
          Project project = psiElement.getProject();
          SmartPsiElementPointer<PsiElement> psiElementPointer = SmartPointerManager.getInstance(project).createSmartPsiElementPointer(psiElement);
          pointer = new SmartPointerWrapper(psiElementPointer);
          psiElement.putUserData(PSI_ANCHORIZER_POINTER, pointer);
        }
        return pointer;
      }
    });
  }
  return super.createAnchor(element);
}
 

import com.intellij.psi.SmartPointerManager; //导入依赖的package包/类
public UsageHolder(PsiElement element, UsageInfo[] usageInfos) {
  Project project = element.getProject();
  myElementPointer = SmartPointerManager.getInstance(project).createSmartPsiElementPointer(element);

  GeneratedSourcesFilter[] filters = GeneratedSourcesFilter.EP_NAME.getExtensions();
  for (UsageInfo usageInfo : usageInfos) {
    if (!(usageInfo instanceof SafeDeleteReferenceUsageInfo)) continue;
    final SafeDeleteReferenceUsageInfo usage = (SafeDeleteReferenceUsageInfo)usageInfo;
    if (usage.getReferencedElement() != element) continue;

    if (!usage.isSafeDelete()) {
      myUnsafeUsages++;
      if (usage.isNonCodeUsage || isInGeneratedCode(usage, project, filters)) {
        myNonCodeUnsafeUsages++;
      }
    }
  }
}
 

import com.intellij.psi.SmartPointerManager; //导入依赖的package包/类
public GroovyResolveSnapshot(final PsiElement scope) {
  myProject = scope.getProject();
  myDocument = PsiDocumentManager.getInstance(myProject).getDocument(scope.getContainingFile());
  final SmartPointerManager pointerManager = SmartPointerManager.getInstance(myProject);
  final Map<PsiElement, SmartPsiElementPointer> pointers = new HashMap<PsiElement, SmartPsiElementPointer>();
  scope.accept(new GroovyPsiElementVisitor(new GroovyRecursiveElementVisitor() {
    @Override
    public void visitReferenceExpression(GrReferenceExpression refExpr) {
      if (!refExpr.isQualified()) {
        PsiElement resolved = refExpr.resolve();
        if (resolved instanceof GrMember) {
          SmartPsiElementPointer key = pointerManager.createSmartPsiElementPointer(refExpr);
          SmartPsiElementPointer value = pointers.get(resolved);
          if (value == null) {
            value = pointerManager.createSmartPsiElementPointer(resolved);
            pointers.put(resolved, value);
          }
          myReferencesMap.put(key, value);
        }
      }
      super.visitReferenceExpression(refExpr);
    }
  }));
}
 

import com.intellij.psi.SmartPointerManager; //导入依赖的package包/类
public void setData(PsiElement _element, String text, final boolean clearHistory) {
  if (myElement != null) {
    myBackStack.push(saveContext());
    myForwardStack.clear();
  }

  final SmartPsiElementPointer element = _element != null && _element.isValid()
                                         ? SmartPointerManager.getInstance(_element.getProject()).createSmartPsiElementPointer(_element)
                                         : null;

  if (element != null) {
    myElement = element;
  }

  myIsEmpty = false;
  updateControlState();
  setDataInternal(element, text, new Rectangle(0, 0));

  if (clearHistory) clearHistory();
}
 

import com.intellij.psi.SmartPointerManager; //导入依赖的package包/类
/**
 * Creates a line marker info for the element.
 * @param element         the element for which the line marker is created.
 * @param range     the range (relative to beginning of file) with which the marker is associated
 * @param icon            the icon to show in the gutter for the line marker
 * @param updatePass      the ID of the daemon pass during which the marker should be recalculated
 * @param tooltipProvider the callback to calculate the tooltip for the gutter icon
 * @param navHandler      the handler executed when the gutter icon is clicked
 */
public LineMarkerInfo(@Nonnull T element,
                      @Nonnull TextRange range,
                      Icon icon,
                      int updatePass,
                      @Nullable Function<? super T, String> tooltipProvider,
                      @Nullable GutterIconNavigationHandler<T> navHandler,
                      @Nonnull GutterIconRenderer.Alignment alignment) {
  myIcon = icon;
  myTooltipProvider = tooltipProvider;
  myIconAlignment = alignment;
  elementRef = SmartPointerManager.getInstance(element.getProject()).createSmartPsiElementPointer(element);
  myNavigationHandler = navHandler;
  startOffset = range.getStartOffset();
  endOffset = range.getEndOffset();
  this.updatePass = 11; //Pass.LINE_MARKERS;
}
 

import com.intellij.psi.SmartPointerManager; //导入依赖的package包/类
public PsiElement[] tryCreate(@Nonnull final String inputString) {
  if (inputString.length() == 0) {
    Messages.showMessageDialog(myProject, IdeBundle.message("error.name.should.be.specified"), CommonBundle.getErrorTitle(), Messages.getErrorIcon());
    return PsiElement.EMPTY_ARRAY;
  }

  Ref<List<SmartPsiElementPointer>> createdElements = Ref.create();
  Exception exception = executeCommand(getActionName(inputString), () -> {
    PsiElement[] psiElements = create(inputString);
    SmartPointerManager manager = SmartPointerManager.getInstance(myProject);
    createdElements.set(ContainerUtil.map(psiElements, manager::createSmartPsiElementPointer));
  });
  if (exception != null) {
    handleException(exception);
    return PsiElement.EMPTY_ARRAY;
  }

  return ContainerUtil.mapNotNull(createdElements.get(), SmartPsiElementPointer::getElement).toArray(PsiElement.EMPTY_ARRAY);
}
 

import com.intellij.psi.SmartPointerManager; //导入依赖的package包/类
public void setData(PsiElement _element, String text, final boolean clearHistory, String effectiveExternalUrl, String ref) {
  if (myElement != null) {
    myBackStack.push(saveContext());
    myForwardStack.clear();
  }
  myEffectiveExternalUrl = effectiveExternalUrl;

  final SmartPsiElementPointer element = _element != null && _element.isValid() ? SmartPointerManager.getInstance(_element.getProject()).createSmartPsiElementPointer(_element) : null;

  if (element != null) {
    setElement(element);
  }

  myIsEmpty = false;
  updateControlState();
  setDataInternal(element, text, new Rectangle(0, 0), ref);

  if (clearHistory) clearHistory();
}
 

import com.intellij.psi.SmartPointerManager; //导入依赖的package包/类
public static void cacheParticularEntity(PsiFile file, XmlEntityDecl decl)
{
	synchronized(LOCK)
	{
		final Map<String, CachedValue<XmlEntityDecl>> cachingMap = getCachingMap(file);
		final String name = decl.getName();
		if(cachingMap.containsKey(name))
		{
			return;
		}
		final SmartPsiElementPointer declPointer = SmartPointerManager.getInstance(file.getProject()).createSmartPsiElementPointer(decl);

		cachingMap.put(name, CachedValuesManager.getManager(file.getProject()).createCachedValue(() ->
		{
			PsiElement declElement = declPointer.getElement();
			if(declElement instanceof XmlEntityDecl && declElement.isValid() && name.equals(((XmlEntityDecl) declElement).getName()))
			{
				return new CachedValueProvider.Result<>((XmlEntityDecl) declElement, declElement);
			}
			cachingMap.put(name, null);
			return new CachedValueProvider.Result<>(null, ModificationTracker.NEVER_CHANGED);
		}, false));
	}
}
 

import com.intellij.psi.SmartPointerManager; //导入依赖的package包/类
@Nullable
public SmartPsiElementPointer<XmlTag> doFix(Project project, ProblemDescriptor descriptor, boolean reformat) {
  PsiElement element = descriptor.getPsiElement();
  if (element instanceof XmlAttributeValue) {
    element = element.getParent();
  }
  else if (!(element instanceof XmlAttribute)) {
    return null;
  }
  XmlAttribute attribute = (XmlAttribute)element;
  XmlTag parent = attribute.getParent();

  if (!FileModificationService.getInstance().prepareFileForWrite(parent.getContainingFile())) return null;

  SmartPsiElementPointer<XmlTag> pointer = SmartPointerManager.getInstance(project).createSmartPsiElementPointer(parent);

  doRemove(project, attribute, parent);

  if (reformat) {
    reformatStartTag(project, pointer);
  }
  return pointer;
}
 

import com.intellij.psi.SmartPointerManager; //导入依赖的package包/类
public void tryToInit()
{
	if(myProvider == null || myElementPointer != null)
	{
		return;
	}

	ApplicationManager.getApplication().runReadAction(new Runnable()
	{
		@Override
		public void run()
		{
			PsiElement psiElementById = myProvider.getPsiElementById(myPsiElementId, myProject);
			if(psiElementById == null)
			{
				return;
			}
			myElementPointer = SmartPointerManager.getInstance(myProject).createSmartPsiElementPointer(psiElementById);
		}
	});
}
 

import com.intellij.psi.SmartPointerManager; //导入依赖的package包/类
public static Query<PsiClass> search(@NotNull SearchParameters parameters)
{
	return INSTANCE.createUniqueResultsQuery(parameters, ContainerUtil.<SmartPsiElementPointer<PsiClass>>canonicalStrategy(), new Function<PsiClass, SmartPsiElementPointer<PsiClass>>()
	{
		@Override
		public SmartPsiElementPointer<PsiClass> fun(final PsiClass psiClass)
		{
			return ApplicationManager.getApplication().runReadAction(new Computable<SmartPsiElementPointer<PsiClass>>()
			{
				@Override
				public SmartPsiElementPointer<PsiClass> compute()
				{
					return SmartPointerManager.getInstance(psiClass.getProject()).createSmartPsiElementPointer(psiClass);
				}
			});
		}
	});
}
 

import com.intellij.psi.SmartPointerManager; //导入依赖的package包/类
@Override
public int compareTo(UsageGroup usageGroup) {
  if (!(usageGroup instanceof MethodUsageGroup)) {
    LOG.error("MethodUsageGroup expected but " + usageGroup.getClass() + " found");
  }
  MethodUsageGroup other = (MethodUsageGroup)usageGroup;
  if (SmartPointerManager.getInstance(myProject).pointToTheSameElement(myMethodPointer, other.myMethodPointer)) {
    return 0;
  }
  if (!UsageViewSettings.getInstance().IS_SORT_MEMBERS_ALPHABETICALLY) {
    Segment segment1 = myMethodPointer.getRange();
    Segment segment2 = other.myMethodPointer.getRange();
    if (segment1 != null && segment2 != null) {
      return segment1.getStartOffset() - segment2.getStartOffset();
    }
  }

  return myName.compareToIgnoreCase(other.myName);
}
 

import com.intellij.psi.SmartPointerManager; //导入依赖的package包/类
public PropertyQuickFix(
    @NotNull final PhpClass primaryClass,
    @NotNull final String propertyName,
    @NotNull final String propertyType
) {
    final SmartPointerManager pointerManager = SmartPointerManager.getInstance(primaryClass.getProject());

    primaryClassPointer = pointerManager.createSmartPsiElementPointer(primaryClass);
    this.propertyName = propertyName;
    this.propertyType = propertyType;
    familyName = String.format("Declare @property $%s on %s class", propertyName, primaryClass.getName());
}