Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.apache.ode.utils; import java.io.Externalizable; import java.io.IOException; import java.io.ObjectInput; import java.io.ObjectOutput; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.Map; import java.util.Set; import javax.xml.namespace.NamespaceContext; import javax.xml.namespace.QName; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.ode.utils.stl.CollectionsX; import org.apache.ode.utils.stl.CompositeUnaryFunction; import org.apache.ode.utils.stl.EqualsUnaryFunction; import org.apache.ode.utils.stl.FilterIterator; import org.apache.ode.utils.stl.TransformIterator; /** * A simple in-memory implementation of the {@link NamespaceContext} interface * with fairly generic applicability. This class allows clients to manipulate * the context through publicly accessible methods, and provides serialization * support. * * @see NamespaceContext */ public class NSContext implements NamespaceContext, Externalizable { private static final long serialVersionUID = 1L; /** Class-level logger. */ private static final Log __log = LogFactory.getLog(NSContext.class); /** Prefix-to-URI map. */ private HashMap<String, String> _prefixToUriMap = new HashMap<String, String>() { @Override public String put(String prefix, String uri) { prefix = (String) InternPool.intern("namespace.prefixes", prefix); uri = (String) InternPool.intern("namespace.uris", uri); return super.put(prefix, uri); } }; public NSContext() { } public NSContext(NSContext map) { _prefixToUriMap.putAll(map._prefixToUriMap); } /** * @see NamespaceContext#getNamespaceURI(java.lang.String) */ public String getNamespaceURI(String prefix) { return _prefixToUriMap.get(prefix == null ? "" : prefix); } /** * @see NamespaceContext#getPrefix(java.lang.String) */ public String getPrefix(String uri) { Iterator i = getPrefixes(uri); if (i.hasNext()) { return (String) i.next(); } return null; } /** * @see NamespaceContext#getPrefixes */ @SuppressWarnings("unchecked") public Iterator getPrefixes(final String uri) { return new TransformIterator( new FilterIterator(_prefixToUriMap.entrySet().iterator(), new CompositeUnaryFunction( new EqualsUnaryFunction(uri), CollectionsX.ufnMapEntry_getValue)), CollectionsX.ufnMapEntry_getKey); } /** * Get all the prefixes with a URI mapping in this context * * @return{@link Set} of prefix {@link String}s with a URI mapping in this * context */ public Set<String> getPrefixes() { return Collections.unmodifiableSet(_prefixToUriMap.keySet()); } /** * Get all the URIs with a prefix mapping in this context * * @return{@link Set} of URI {@link String}s with a prefix mapping in this * context */ public Set<String> getUriSet() { return new HashSet<String>(_prefixToUriMap.values()); } /** * @see Externalizable#readExternal(java.io.ObjectInput) */ public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { int numKeys = in.readInt(); for (int i = 0; i < numKeys; ++i) { String prefix = in.readUTF(); String uri = in.readUTF(); _prefixToUriMap.put(prefix, uri); } if (__log.isTraceEnabled()) { __log.trace("readExternal: contents=" + _prefixToUriMap); } } /** * Add a prefix to URI mapping to this context. * * @param prefix * prefix * @param uri * URI */ public void register(String prefix, String uri) { if (uri == null) uri = ""; if (prefix == null) prefix = ""; if (__log.isTraceEnabled()) { __log.trace("register(prefix=" + prefix + ", uri=" + uri + ")"); } _prefixToUriMap.put(prefix, uri); } /** * Register a set of URI mappings at once. * * @param prefixMapping * set (map rather) of prefix-to-URI mappings. */ public void register(Map<String, String> prefixMapping) { if (__log.isTraceEnabled()) { __log.trace("register(prefixmappings=" + prefixMapping + ")"); } _prefixToUriMap.putAll(prefixMapping); } /** * @see Externalizable#writeExternal(java.io.ObjectOutput) */ public void writeExternal(ObjectOutput out) throws IOException { if (__log.isTraceEnabled()) { __log.trace("writeExternal: contents=" + _prefixToUriMap); } out.writeInt(_prefixToUriMap.size()); for (Iterator i = _prefixToUriMap.entrySet().iterator(); i.hasNext();) { Map.Entry me = (Map.Entry) i.next(); out.writeUTF((String) me.getKey()); out.writeUTF((String) me.getValue()); } } public QName derefQName(String qname) { if (qname == null) return null; int idx = qname.indexOf(':'); if (idx == -1) { return new QName(getNamespaceURI(null), qname); } String prefix = qname.substring(0, idx); String localname = qname.substring(idx + 1); String uri = getNamespaceURI(prefix); if (uri == null) { return null; } return new QName(uri, localname); } public Map<String, String> toMap() { return Collections.unmodifiableMap(_prefixToUriMap); } @Override public boolean equals(Object b) { if (b instanceof NSContext) { return _prefixToUriMap.equals(((NSContext) b)._prefixToUriMap); } else { return false; } } }