Java NamespaceContext类代码示例

import org.intellij.lang.xpath.context.NamespaceContext; //导入依赖的package包/类
private static void checkPrefixReferences(AnnotationHolder holder, QNameElement element, ContextProvider myProvider) {
  final PsiReference[] references = element.getReferences();
  for (PsiReference reference : references) {
    if (reference instanceof PrefixReference) {
      final PrefixReference pr = ((PrefixReference)reference);
      if (!pr.isSoft() && pr.isUnresolved()) {
        final TextRange range = pr.getRangeInElement().shiftRight(pr.getElement().getTextRange().getStartOffset());
        final Annotation a = holder.createErrorAnnotation(range, "Unresolved namespace prefix '" + pr.getCanonicalText() + "'");
        a.setHighlightType(ProblemHighlightType.LIKE_UNKNOWN_SYMBOL);

        final NamespaceContext namespaceContext = myProvider.getNamespaceContext();
        final PrefixedName qName = element.getQName();
        if (namespaceContext != null && qName != null) {
          final IntentionAction[] fixes = namespaceContext.getUnresolvedNamespaceFixes(reference, qName.getLocalName());
          for (IntentionAction fix : fixes) {
            a.registerFix(fix);
          }
        }
      }
    }
  }
}
 

import org.intellij.lang.xpath.context.NamespaceContext; //导入依赖的package包/类
private static boolean namespaceMatches(PrefixedName prefixedName,
                                        String uri,
                                        NamespaceContext namespaceContext,
                                        XmlElement context,
                                        boolean allowDefault) {
  if (namespaceContext == null) return true;

  final String namespaceURI;
  if (prefixedName.getPrefix() != null) {
    if (uri == null || uri.length() == 0) return false;

    namespaceURI = namespaceContext.getNamespaceURI(prefixedName.getPrefix(), context);
  } else {
    if (!allowDefault) return (uri == null || uri.length() == 0);

    if ((namespaceURI = namespaceContext.getDefaultNamespace(context)) == null) {
      return (uri == null || uri.length() == 0);
    }
  }
  return uri.equals(namespaceURI);
}
 

import org.intellij.lang.xpath.context.NamespaceContext; //导入依赖的package包/类
protected RefactoringOptions getSettings(XPathExpression expression, Set<XPathExpression> matchingExpressions) {
  final String name = Messages.showInputDialog(expression.getProject(), "Function Name: ", getRefactoringName(), Messages.getQuestionIcon());
  final boolean[] b = new boolean[]{false};
  if (name != null) {
    final String[] parts = name.split(":", 2);
    if (parts.length < 2) {
      Messages.showMessageDialog(expression.getProject(), "Custom functions require a prefixed name", "Error", Messages.getErrorIcon());
      b[0] = true;
    }
    final XmlElement context = PsiTreeUtil.getContextOfType(expression, XmlElement.class);
    final NamespaceContext namespaceContext = expression.getXPathContext().getNamespaceContext();
    if (namespaceContext != null && context != null && namespaceContext.resolve(parts[0], context) == null) {
      Messages.showMessageDialog(expression.getProject(), "Prefix '" + parts[0] + "' is not defined", "Error", Messages.getErrorIcon());
      b[0] = true;
    }
  }
  return new RefactoringOptions() {
    @Override
    public boolean isCanceled() {
      return b[0];
    }

    @Override
    public String getName() {
      return name;
    }
  };
}
 

import org.intellij.lang.xpath.context.NamespaceContext; //导入依赖的package包/类
private static void addNamespaceCompletions(NamespaceContext namespaceContext, Set<Lookup> list, XmlElement context) {
  if (namespaceContext != null) {
    final Collection<String> knownPrefixes = namespaceContext.getKnownPrefixes(context);
    for (String prefix : knownPrefixes) {
      if (prefix != null && prefix.length() > 0) {
        list.add(new NamespaceLookup(prefix));
      }
    }
  }
}
 

import org.intellij.lang.xpath.context.NamespaceContext; //导入依赖的package包/类
@Nullable
public PsiElement resolve() {
  final ContextProvider provider = getElement().getXPathContext();
  final NamespaceContext namespaceContext = provider.getNamespaceContext();
  if (namespaceContext != null) {
    return namespaceContext.resolve(getCanonicalText(), provider.getContextElement());
  } else {
    return null;
  }
}
 

import org.intellij.lang.xpath.context.NamespaceContext; //导入依赖的package包/类
@TestOnly
public static void install(Disposable parent) {
  final NamespaceContext old = ContextProvider.DefaultProvider.NULL_NAMESPACE_CONTEXT;
  ContextProvider.DefaultProvider.NULL_NAMESPACE_CONTEXT = TestNamespaceContext.INSTANCE;
  Disposer.register(parent, new Disposable() {
    @Override
    public void dispose() {
      ContextProvider.DefaultProvider.NULL_NAMESPACE_CONTEXT = old;
    }
  });
}
 

import org.intellij.lang.xpath.context.NamespaceContext; //导入依赖的package包/类
@Override
public NamespaceContext getNamespaceContext() {
  return null;
}
 

import org.intellij.lang.xpath.context.NamespaceContext; //导入依赖的package包/类
@NotNull
public NamespaceContext getNamespaceContext() {
  return XsltNamespaceContext.NAMESPACE_CONTEXT;
}
 

import org.intellij.lang.xpath.context.NamespaceContext; //导入依赖的package包/类
public static Collection<Lookup> getFunctionCompletions(XPathElement element) {
  final XPathFile xpathFile = (XPathFile)element.getContainingFile();

  final ContextProvider contextProvider = ContextProvider.getContextProvider(xpathFile);
  final NamespaceContext nsContext = contextProvider.getNamespaceContext();

  String uri;
  PrefixedName qn = null;
  if (element instanceof QNameElement) {
    qn = ((QNameElement)element).getQName();
    if (qn != null) {
      QName qName = contextProvider.getQName(qn, element);
      if (qn.getPrefix() != null) {
        if (qName != null) {
          uri = qName.getNamespaceURI();
        } else {
          return Collections.emptySet();
        }
      } else {
        uri = null;
      }
    } else {
      uri = null;
    }
  } else {
    uri = null;
  }

  final Map<Pair<QName, Integer>, ? extends Function> functions = contextProvider.getFunctionContext().getFunctions();
  final List<Lookup> lookups = new ArrayList<Lookup>(functions.size());
  for (Map.Entry<Pair<QName, Integer>, ? extends Function> entry : functions.entrySet()) {
    final Function functionDecl = entry.getValue();
    final QName f = entry.getKey().first;
    final String p;
    if (nsContext != null) {
      String namespaceURI = f.getNamespaceURI();
      if (uri != null && !namespaceURI.equals(uri)) {
        continue;
      }
      final String prefixForURI = nsContext.getPrefixForURI(namespaceURI, PsiTreeUtil.getContextOfType(element, XmlElement.class, true));
      if (prefixForURI == null && namespaceURI.length() > 0) {
        continue;
      }
      p = qn == null || qn.getPrefix() == null ? makePrefix(prefixForURI) : "";
    } else {
      p = "";
    }
    lookups.add(FunctionLookup.newFunctionLookup(p + f.getLocalPart(), functionDecl));
  }
  return lookups;
}
 

import org.intellij.lang.xpath.context.NamespaceContext; //导入依赖的package包/类
private boolean canResolve() {
  final NamespaceContext namespaceContext = getElement().getXPathContext().getNamespaceContext();
  return namespaceContext != null && !"xml".equals(getCanonicalText());
}
 

import org.intellij.lang.xpath.context.NamespaceContext; //导入依赖的package包/类
public NamespaceContext getNamespaceContext() {
  return null;
}
 

import org.intellij.lang.xpath.context.NamespaceContext; //导入依赖的package包/类
@Nullable
@Override
public NamespaceContext getNamespaceContext(@NotNull XmlElement xmlElement)
{
	return XsltNamespaceContext.NAMESPACE_CONTEXT;
}