acr/NamespaceUtils.java

   1 package org.argeo.api.acr;
   2
   3 import java.util.Collections;
   4 import java.util.Comparator;
   5 import java.util.Iterator;
   6 import java.util.Objects;
   7 import java.util.Set;
   8 import java.util.function.Function;
   9
  10 import javax.xml.XMLConstants;
  11 import javax.xml.namespace.NamespaceContext;
  12 import javax.xml.namespace.QName;
  13
  14 public class NamespaceUtils {
  15
  16         public static ContentName parsePrefixedName(String nameWithPrefix) {
  17                 return parsePrefixedName(RuntimeNamespaceContext.getNamespaceContext(), nameWithPrefix);
  18         }
  19
  20         public static ContentName parsePrefixedName(NamespaceContext nameSpaceContext, String nameWithPrefix) {
  21                 Objects.requireNonNull(nameWithPrefix, "Name cannot be null");
  22                 if (nameWithPrefix.charAt(0) == '{') {
  23                         return new ContentName(QName.valueOf(nameWithPrefix), nameSpaceContext);
  24                 }
  25                 int index = nameWithPrefix.indexOf(':');
  26                 if (index < 0) {
  27                         return new ContentName(nameWithPrefix);
  28                 }
  29                 String prefix = nameWithPrefix.substring(0, index);
  30                 // TODO deal with empty name?
  31                 String localName = nameWithPrefix.substring(index + 1);
  32                 String namespaceURI = nameSpaceContext.getNamespaceURI(prefix);
  33                 if (XMLConstants.NULL_NS_URI.equals(namespaceURI))
  34                         throw new IllegalStateException("Prefix " + prefix + " is unbound.");
  35                 return new ContentName(namespaceURI, localName, prefix);
  36         }
  37
  38         public static String toPrefixedName(QName name) {
  39                 return toPrefixedName(RuntimeNamespaceContext.getNamespaceContext(), name);
  40         }
  41
  42         public static String toPrefixedName(NamespaceContext nameSpaceContext, QName name) {
  43                 if (XMLConstants.NULL_NS_URI.equals(name.getNamespaceURI()))
  44                         return name.getLocalPart();
  45                 String prefix = nameSpaceContext.getPrefix(name.getNamespaceURI());
  46                 if (prefix == null)
  47                         throw new IllegalStateException("Namespace " + name.getNamespaceURI() + " is unbound.");
  48                 return prefix + ":" + name.getLocalPart();
  49         }
  50
  51         public final static Comparator<QName> QNAME_COMPARATOR = new Comparator<QName>() {
  52
  53                 @Override
  54                 public int compare(QName qn1, QName qn2) {
  55                         if (Objects.equals(qn1.getNamespaceURI(), qn2.getNamespaceURI())) {// same namespace
  56                                 return qn1.getLocalPart().compareTo(qn2.getLocalPart());
  57                         } else {
  58                                 return qn1.getNamespaceURI().compareTo(qn2.getNamespaceURI());
  59                         }
  60                 }
  61
  62         };
  63
  64         public static boolean hasNamespace(QName qName) {
  65                 return !qName.getNamespaceURI().equals(XMLConstants.NULL_NS_URI);
  66         }
  67
  68         public static void checkNoPrefix(String unqualified) {
  69                 if (unqualified.indexOf(':') >= 0)
  70                         throw new IllegalArgumentException("Name " + unqualified + " has a prefix");
  71         }
  72
  73         public static QName unqualified(String name) {
  74                 checkNoPrefix(name);
  75                 return new ContentName(XMLConstants.NULL_NS_URI, name, XMLConstants.DEFAULT_NS_PREFIX);
  76
  77         }
  78
  79         /*
  80          * DEFAULT NAMESPACE CONTEXT OPERATIONS as specified in NamespaceContext
  81          */
  82         public static String getStandardPrefix(String namespaceURI) {
  83                 if (namespaceURI == null)
  84                         throw new IllegalArgumentException("Namespace URI cannot be null");
  85                 if (XMLConstants.XML_NS_URI.equals(namespaceURI))
  86                         return XMLConstants.XML_NS_PREFIX;
  87                 else if (XMLConstants.XMLNS_ATTRIBUTE_NS_URI.equals(namespaceURI))
  88                         return XMLConstants.XMLNS_ATTRIBUTE;
  89                 return null;
  90         }
  91
  92         public static Iterator<String> getStandardPrefixes(String namespaceURI) {
  93                 String prefix = getStandardPrefix(namespaceURI);
  94                 if (prefix == null)
  95                         return null;
  96                 return Collections.singleton(prefix).iterator();
  97         }
  98
  99         public static String getStandardNamespaceURI(String prefix) {
 100                 if (prefix == null)
 101                         throw new IllegalArgumentException("Prefix cannot be null");
 102                 if (XMLConstants.XML_NS_PREFIX.equals(prefix))
 103                         return XMLConstants.XML_NS_URI;
 104                 else if (XMLConstants.XMLNS_ATTRIBUTE.equals(prefix))
 105                         return XMLConstants.XMLNS_ATTRIBUTE_NS_URI;
 106                 return null;
 107         }
 108
 109         public static String getNamespaceURI(Function<String, String> mapping, String prefix) {
 110                 String namespaceURI = NamespaceUtils.getStandardNamespaceURI(prefix);
 111                 if (namespaceURI != null)
 112                         return namespaceURI;
 113                 if (XMLConstants.DEFAULT_NS_PREFIX.equals(prefix))
 114                         return XMLConstants.NULL_NS_URI;
 115                 namespaceURI = mapping.apply(prefix);
 116                 if (namespaceURI != null)
 117                         return namespaceURI;
 118                 return XMLConstants.NULL_NS_URI;
 119         }
 120
 121         public static String getPrefix(Function<String, String> mapping, String namespaceURI) {
 122                 String prefix = NamespaceUtils.getStandardPrefix(namespaceURI);
 123                 if (prefix != null)
 124                         return prefix;
 125                 if (XMLConstants.NULL_NS_URI.equals(namespaceURI))
 126                         return XMLConstants.DEFAULT_NS_PREFIX;
 127                 return mapping.apply(namespaceURI);
 128         }
 129
 130         public static Iterator<String> getPrefixes(Function<String, Set<String>> mapping, String namespaceURI) {
 131                 Iterator<String> standard = NamespaceUtils.getStandardPrefixes(namespaceURI);
 132                 if (standard != null)
 133                         return standard;
 134                 if (XMLConstants.NULL_NS_URI.equals(namespaceURI))
 135                         return Collections.singleton(XMLConstants.DEFAULT_NS_PREFIX).iterator();
 136                 Set<String> prefixes = mapping.apply(namespaceURI);
 137                 assert prefixes != null;
 138                 return prefixes.iterator();
 139         }
 140
 141         /** singleton */
 142         private NamespaceUtils() {
 143         }
 144
 145 }