org.openxri.xml.Service Maven / Gradle / Ivy
The newest version!
/*
* Copyright 2005 OpenXRI Foundation
*
* Licensed 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.openxri.xml;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.Serializable;
import java.net.URISyntaxException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
import org.apache.xerces.dom.DocumentImpl;
import org.apache.xerces.parsers.DOMParser;
import org.apache.xml.security.exceptions.XMLSecurityException;
import org.apache.xml.security.keys.KeyInfo;
import org.openxri.XRIParseException;
import org.openxri.util.DOMUtils;
import org.openxri.util.PrioritizedList;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.xml.sax.InputSource;
/**
* This class describes the Service XML element used for XRI Authority
* resolution.
*
* @author =chetan
* @author =wil
* @author =peacekeeper
*/
public class Service implements Cloneable, Serializable
{
private static org.apache.commons.logging.Log soLog =
org.apache.commons.logging.LogFactory.getLog(Service.class.getName());
private ProviderID providerID;
private Vector localIDs;
private List types;
private List paths;
private List mediaTypes;
private Integer priority;
private KeyInfo keyInfo;
private List uris;
private PrioritizedList prioritizedURIs;
private Vector redirects;
private PrioritizedList prioritizedRedirects = null;
private Vector refs;
private PrioritizedList prioritizedRefs = null;
private HashMap otherChildrenVectorMap = new HashMap();
/**
* Contructs an empty Service element
*/
public Service()
{
reset();
}
/**
* This method constructs the object from DOM. It does not keep a
* copy of the DOM around. Whitespace information is lost in this process.
*/
public Service(Element oElem) throws URISyntaxException
{
fromDOM(oElem);
}
/**
* Resets the internal state of this object
*/
public void reset()
{
providerID = null;
localIDs = new Vector();
types = new Vector();
paths = new Vector();
mediaTypes = new Vector();
priority = null;
keyInfo = null;
uris = new Vector();
prioritizedURIs = null;
redirects = new Vector();
prioritizedRedirects = null;
refs = new Vector();
prioritizedRefs = null;
otherChildrenVectorMap = new HashMap();
}
/**
* This method populates the object from DOM. It does not keep a
* copy of the DOM around. Whitespace information is lost in this processs.
*/
public void fromDOM(Element oElem) throws URISyntaxException
{
reset();
String val = oElem.getAttribute(Tags.ATTR_PRIORITY);
if (val != null && val.length() > 0) {
setPriority(new Integer(val));
}
for (
Element oChild = DOMUtils.getFirstChildElement(oElem); oChild != null;
oChild = DOMUtils.getNextSiblingElement(oChild))
{
// pre-grab the name and text value
String sChildName = oChild.getLocalName();
if (sChildName == null) sChildName = oChild.getNodeName();
if (sChildName.equals(Tags.TAG_TYPE)) {
// TODO: validate XRI/IRI/URI (must be in URI-normal form)
types.add(SEPType.fromXML(oChild));
}
else if (sChildName.equals(Tags.TAG_PROVIDERID)) {
ProviderID p = new ProviderID();
p.fromXML(oChild);
this.providerID = p;
}
else if (sChildName.equals(Tags.TAG_PATH)) {
paths.add(SEPPath.fromXML(oChild));
}
else if (sChildName.equals(Tags.TAG_MEDIATYPE)) {
mediaTypes.add(SEPMediaType.fromXML(oChild));
}
else if (sChildName.equals(Tags.TAG_URI)) {
addURI(SEPUri.fromXML(oChild));
}
else if (sChildName.equals(Tags.TAG_REF)) {
addRef(new Ref(oChild));
}
else if (sChildName.equals(Tags.TAG_REDIRECT)) {
addRedirect(new Redirect(oChild));
}
else if (sChildName.equals(Tags.TAG_LOCALID)) {
addLocalID(new LocalID(oChild));
}
else if (
(oChild.getNamespaceURI() != null) &&
oChild.getNamespaceURI().equals(Tags.NS_XMLDSIG) &&
(oChild.getLocalName() != null) &&
oChild.getLocalName().equals(Tags.TAG_KEYINFO))
{
try {
keyInfo = new KeyInfo(oChild, "");
}
catch (XMLSecurityException oEx) {
soLog.warn("Error constructing KeyInfo.", oEx);
}
}
else {
Vector oVector =
(Vector) otherChildrenVectorMap.get(sChildName);
if (oVector == null) {
oVector = new Vector();
otherChildrenVectorMap.put(sChildName, oVector);
}
// Instead of Storing just the Child Value, store a clone of the complete
// Node that if we support multiple child elements and also custom NameSpaces
oVector.add(oChild.cloneNode(true));
}
}
}
/**
* Returns the media type element value
* @deprecated
*/
public String getMediaType()
{
soLog.warn("getMediaType - deprecated.");
SEPMediaType mtype = getMediaTypeAt(0);
return (mtype != null)? mtype.getValue(): null;
}
/**
* Returns the number of media types in this service
*/
public int getNumMediaTypes()
{
return (mediaTypes == null) ? 0 : mediaTypes.size();
}
/**
* Returns the media type at the given index.
*/
public SEPMediaType getMediaTypeAt(int n)
{
if(this.mediaTypes != null) return (SEPMediaType)mediaTypes.get(n);
return null;
}
/**
* Sets the media type element value
* @deprecated
*/
public void setMediaType(String sVal)
{
soLog.warn("setMediaType - deprecated.");
SEPMediaType mediaType = new SEPMediaType(sVal,null,null);
mediaTypes.add(mediaType);
}
/**
* Adds a media type to this Service
*/
public void addMediaType(String sVal)
{
addMediaType(sVal,null,null);
}
/**
* Adds a media type to this Service with attributes
*/
public void addMediaType(String sVal, String match, Boolean select)
{
SEPMediaType mediaType = new SEPMediaType(sVal,match, select);
mediaTypes.add(mediaType);
}
/**
* Returns the type element value
* @deprecated
*/
public String getType()
{
soLog.warn("getType is deprecated.");
SEPType type = getTypeAt(0);
return (type != null)? type.getValue(): null;
}
/**
* Returns the number of types in this service
*/
public int getNumTypes()
{
return (types == null) ? 0 : types.size();
}
/**
* Returns the type at the given index.
*/
public SEPType getTypeAt(int n)
{
if(this.types != null)
return (SEPType) types.get(n);
return null;
}
/**
* Sets the type element value
* @deprecated
*/
public void setType(String sVal)
{
soLog.warn("setType is deprecated.");
types.add(new SEPType(sVal,null,null));
}
/**
* Adds a type to this Service
*/
public void addType(String sVal)
{
addType(sVal,null,null);
}
/**
* Adds a type to this Service with attributes
*/
public void addType(String sVal, String match, Boolean select)
{
types.add(new SEPType(sVal,match,select));
}
/**
* Returns true if the given type is equivalent to the type of this service.
* TODO - this should probably compare the normalized type rather than
* performing a straight string comparison. Also, there may be multiple
* types associated with a service.
* @deprecated
*/
public boolean matchType(String sVal)
{
for (int i = 0; i < getNumTypes(); i++) {
SEPType type = (SEPType)getTypeAt(i);
if(type.match(sVal)) return true;
}
return false;
}
/**
* Returns the number of URIs
*/
public int getNumURIs()
{
return (uris == null) ? 0 : uris.size();
}
/**
* Returns the first URI
* @deprecated
*/
public SEPUri getURI()
{
soLog.warn("getURI is deprecated.");
return getURIAt(0);
}
/**
* Returns the URI at the given index
*/
public SEPUri getURIAt(int n)
{
return (n < getNumURIs()) ? (SEPUri) uris.get(n) : null;
}
/**
* Returns the first URI for the given scheme
*/
public SEPUri getURIForScheme(String sScheme)
{
if (sScheme == null) return null;
for (int i = 0; i < getNumURIs(); i++)
{
// just return the first URI that matches the
// requested scheme
SEPUri oURI = (SEPUri)getURIAt(i);
if (oURI != null && oURI.getURI() != null &&
oURI.getURI().getScheme().equalsIgnoreCase(sScheme))
return oURI;
}
return null;
}
/**
* Returns the a vector of URIs
*/
public List getURIs()
{
return uris;
}
/**
* Returns the URIs in sorted in priority order
* @return
*/
public ArrayList getPrioritizedURIs()
{
if (prioritizedURIs == null)
return new ArrayList();
return prioritizedURIs.getList();
}
/**
* Adds a URI to the service
*/
public void addURI(String sURI)
{
addURI(sURI, null, null);
}
/**
* Adds a URI to the service with attributes
*/
public void addURI(String sURI, Integer priority, String append)
{
try {
SEPUri uri = new SEPUri(sURI, priority, append);
addURI(uri);
}
catch (Exception e) {
throw new XRIParseException("BadURI", e);
}
}
/**
* Adds an SEPUri object to the list of URIs
* @param uri
*/
public void addURI(SEPUri uri)
{
if (prioritizedURIs == null)
{
prioritizedURIs = new PrioritizedList();
}
uris.add(uri);
Integer priority = uri.getPriority();
prioritizedURIs.addObject((priority == null)? PrioritizedList.PRIORITY_NULL : priority.toString(), uri);
}
/**
* Get a Servie Path
*/
public SEPPath getPathAt(int n)
{
return (n < getNumPaths()) ? (SEPPath) paths.get(n) : null;
}
/**
* Adds a URI to the service
*/
public void addPath(String sPath)
{
addPath(sPath,null,null);
}
/**
* Adds a URI to the service with attributes
*/
public void addPath(String sPath, String match, Boolean select)
{
try {
paths.add(new SEPPath(sPath,match,select));
}catch (Exception e) {
throw new XRIParseException("BadPath", e);
}
}
/**
* Returns the number of URIs
*/
public int getNumPaths()
{
return (paths == null) ? 0 : paths.size();
}
/**
* Returns the authority id element value
*/
public String getProviderId()
{
return (providerID != null) ? providerID.getValue(): null;
}
/**
* Sets the authority id element value
*/
public void setProviderId(String val)
{
providerID = new ProviderID(val);
}
/**
* Sets the key info element
*/
public void setKeyInfo(KeyInfo oKeyInfo)
{
keyInfo = oKeyInfo;
}
/**
* Returns the key info element
*/
public KeyInfo getKeyInfo()
{
return keyInfo;
}
/**
* Stores simple elements in the Service by Tag
*
* Here we are converting the String object that is being passed into XML
* Element before storing it into otherChildrenVectorMap Vector. The reason
* we are doing this is, we need to preserve NameSpaces, and also support a scenario
* where a Child Element under Service Element, can have Sub Elements. With this
* it will preserve all the Text Nodes under the Sub Element.
*
* @param sTag - The tag name. Needs to be the Fully Qualified Name of the XML Element.
*
* For Example "usrns1:info1" or "info1" (If not using NameSpaces)
*
* @param sTagValue - The tag values. Needs to be valid XML String like --
*
* "Newton "
* @return -- Boolean - -True if the String could be Successfully Parsed and Stored, Else it will return false
*
*/
public boolean setOtherTagValues(String sTag, String sTagValue)
{
String xmlStr =
"\n" + sTagValue;
boolean returnValue = false;
try
{
InputStream oIn = new ByteArrayInputStream(xmlStr.getBytes());
DOMParser oDOMParser = DOMUtils.getDOMParser();
oDOMParser.parse(new InputSource(oIn));
Document oDOMDoc = oDOMParser.getDocument();
Element oElement = oDOMDoc.getDocumentElement();
Vector oVector = (Vector) otherChildrenVectorMap.get(sTag);
if (oVector == null)
{
oVector = new Vector();
otherChildrenVectorMap.put(sTag, oVector);
}
oVector.add(oElement.cloneNode(true));
returnValue = true;
}
catch (Exception exp)
{
exp.printStackTrace();
returnValue = false;
}
return returnValue;
}
/**
* Returns unspecified simple elements in the Service by Tag
* @param sTag - The tag name to get values for
* @return a vector of text values whose element tag names match sTag
*/
public Vector getOtherTagValues(String sTag)
{
return (Vector) otherChildrenVectorMap.get(sTag);
}
public void setExtension(String extension) throws URISyntaxException, ParseException {
String xmlStr = "" +
"" +
extension
+ "