--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/WebServiceExtensionsV1.1/WebServiceToolWorkflow_REST_SOAP/lib/SAWADLParser/src/edu/uga/cs/lsdis/meteors/wadls/util/xml/DOMUtils.java	Tue Jul 05 19:34:18 2011 -0400
@@ -0,0 +1,641 @@
+/*
+ * (c) Copyright IBM Corp 2001, 2005 
+ */
+
+package edu.uga.cs.lsdis.meteors.wadls.util.xml;
+
+import java.io.*;
+import java.util.*;
+import org.w3c.dom.*;
+
+import javax.wadls.*;
+import javax.xml.namespace.*;
+
+public class DOMUtils {
+  /**
+   * The namespaceURI represented by the prefix <code>xmlns</code>.
+   */
+  private static String NS_URI_XMLNS = "http://www.w3.org/2000/xmlns/";
+
+  private static final String ATTR_XMLNS = "xmlns";
+  
+  /**
+   * Returns a list of attributes of an element. Returns an 
+   * empty list if the element has no attributes. Does not
+   * include namespace declarations.
+   *
+   * @param el       Element whose attributes are returned
+   * @return the List of Attr
+   */
+  static public List getAttributes (Element el) {
+    String nodename, prefix = null;
+    List attrs = new Vector();
+    NamedNodeMap attrMap = el.getAttributes();
+    for(int i = 0; i < attrMap.getLength(); i++)
+    {
+      nodename = attrMap.item(i).getNodeName();
+      prefix = attrMap.item(i).getPrefix();
+      
+      if (ATTR_XMLNS.equals(nodename) || ATTR_XMLNS.equals(prefix))
+      {
+        //ignore namespace declarations
+        continue;
+      }
+      else
+      {
+        attrs.add(attrMap.item(i));  
+      }
+    }
+      
+    return attrs;
+  }
+
+  /**
+   * Returns the value of an attribute of an element. Returns null
+   * if the attribute is not found (whereas Element.getAttribute
+   * returns "" if an attrib is not found). This method should be
+   * used for elements that support extension attributes because it
+   * does not track unexpected attributes.
+   *
+   * @param el       Element whose attrib is looked for
+   * @param attrName name of attribute to look for
+   * @return the attribute value
+   */
+  static public String getAttribute (Element el, String attrName) {
+    String sRet = null;
+    Attr   attr = el.getAttributeNode(attrName);
+
+    if (attr != null) {
+      sRet = attr.getValue();
+    }
+    return sRet;
+  }
+
+  /**
+   * Returns the value of an attribute of an element. Returns null
+   * if the attribute is not found (whereas Element.getAttribute
+   * returns "" if an attrib is not found). This method should be
+   * used for elements that do not support extension attributes
+   * because it tracks the element's remaining attributes so that
+   * eventually any unexpected attributes can be identified.
+   *
+   * @param el       Element whose attrib is looked for
+   * @param attrName name of attribute to look for
+   * @param remainingAttrs List of remaining attributes 
+   * @return the attribute value
+   */
+  static public String getAttribute (Element el, String attrName, List remainingAttrs) {
+    String sRet = null;
+    Attr   attr = el.getAttributeNode(attrName);
+    
+    if (attr != null) {
+      sRet = attr.getValue();
+      remainingAttrs.remove(attr);
+    }
+    return sRet;
+  }
+
+  /**
+   * Returns the value of an attribute of an element. Returns null
+   * if the attribute is not found (whereas Element.getAttributeNS
+   * returns "" if an attrib is not found).
+   *
+   * @param el       Element whose attrib is looked for
+   * @param namespaceURI namespace URI of attribute to look for
+   * @param localPart local part of attribute to look for
+   * @return the attribute value
+   */
+  static public String getAttributeNS (Element el,
+                                       String namespaceURI,
+                                       String localPart) {
+    String sRet = null;
+    Attr   attr = el.getAttributeNodeNS (namespaceURI, localPart);
+
+    if (attr != null) {
+      sRet = attr.getValue ();
+    }
+
+    return sRet;
+  }
+
+  /**
+   * Returns the value of an attribute of an element. Returns null
+   * if the attribute is not found (whereas Element.getAttributeNS
+   * returns "" if an attrib is not found).
+   *
+   * @param el       Element whose attrib is looked for
+   * @param namespaceURI namespace URI of attribute to look for
+   * @param localPart local part of attribute to look for
+   * @return the attribute value
+   */
+  static public String getAttributeNS (Element el,
+                                       String namespaceURI,
+                                       String localPart,
+                                       List remainingAttrs) {
+    String sRet = null;
+    Attr   attr = el.getAttributeNodeNS (namespaceURI, localPart);
+
+    if (attr != null) {
+        sRet = attr.getValue();
+        remainingAttrs.remove(attr);
+      }
+
+    return sRet;
+  }
+  
+  /**
+   * Concat all the text and cdata node children of this elem and return
+   * the resulting text.
+   *
+   * @param parentEl the element whose cdata/text node values are to
+   *                 be combined.
+   * @return the concatanated string.
+   */
+  static public String getChildCharacterData (Element parentEl) {
+    if (parentEl == null) {
+      return null;
+    }
+    Node          tempNode = parentEl.getFirstChild();
+    StringBuffer  strBuf   = new StringBuffer();
+    CharacterData charData;
+
+    while (tempNode != null) {
+      switch (tempNode.getNodeType()) {
+        case Node.TEXT_NODE :
+        case Node.CDATA_SECTION_NODE : charData = (CharacterData)tempNode;
+                                       strBuf.append(charData.getData());
+                                       break;
+      }
+      tempNode = tempNode.getNextSibling();
+    }
+    return strBuf.toString();
+  }
+
+  /**
+   * Return the first child element of the given element. Null if no
+   * children are found.
+   *
+   * @param elem Element whose child is to be returned
+   * @return the first child element.
+   */
+  public static Element getFirstChildElement (Element elem) {
+    for (Node n = elem.getFirstChild (); n != null; n = n.getNextSibling ()) {
+      if (n.getNodeType () == Node.ELEMENT_NODE) {
+        return (Element) n;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Return the next sibling element of the given element. Null if no
+   * more sibling elements are found.
+   *
+   * @param elem Element whose sibling element is to be returned
+   * @return the next sibling element.
+   */
+  public static Element getNextSiblingElement (Element elem) {
+    for (Node n = elem.getNextSibling (); n != null; n = n.getNextSibling ()) {
+      if (n.getNodeType () == Node.ELEMENT_NODE) {
+        return (Element) n;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Return the first child element of the given element which has the
+   * given attribute with the given value.
+   *
+   * @param elem      the element whose children are to be searched
+   * @param attrName  the attrib that must be present
+   * @param attrValue the desired value of the attribute
+   *
+   * @return the first matching child element.
+   */
+  public static Element findChildElementWithAttribute (Element elem,
+                   String attrName,
+                   String attrValue) {
+    for (Node n = elem.getFirstChild (); n != null; n = n.getNextSibling ()) {
+      if (n.getNodeType () == Node.ELEMENT_NODE) {
+        if (attrValue.equals (DOMUtils.getAttribute ((Element) n, attrName))) {
+          return (Element) n;
+        }
+      }
+    }
+    return  null;
+  }
+
+  /**
+   * Count number of children of a certain type of the given element.
+   *
+   * @param elem the element whose kids are to be counted
+   *
+   * @return the number of matching kids.
+   */
+  public static int countKids (Element elem, short nodeType) {
+    int nkids = 0;
+    for (Node n = elem.getFirstChild (); n != null; n = n.getNextSibling ()) {
+      if (n.getNodeType () == nodeType) {
+        nkids++;
+      }
+    }
+    return nkids;
+  }
+
+  /**
+   * Given a prefix and a node, return the namespace URI that the prefix
+   * has been associated with. This method is useful in resolving the
+   * namespace URI of attribute values which are being interpreted as
+   * QNames. If prefix is null, this method will return the default
+   * namespace.
+   *
+   * @param context the starting node (looks up recursively from here)
+   * @param prefix the prefix to find an xmlns:prefix=uri for
+   *
+   * @return the namespace URI or null if not found
+   */
+  public static String getNamespaceURIFromPrefix (Node context,
+                                                  String prefix) {
+    short nodeType = context.getNodeType ();
+    Node tempNode = null;
+
+    switch (nodeType)
+    {
+      case Node.ATTRIBUTE_NODE :
+      {
+        tempNode = ((Attr) context).getOwnerElement ();
+        break;
+      }
+      case Node.ELEMENT_NODE :
+      {
+        tempNode = context;
+        break;
+      }
+      default :
+      {
+        tempNode = context.getParentNode ();
+        break;
+      }
+    }
+
+    while (tempNode != null && tempNode.getNodeType () == Node.ELEMENT_NODE)
+    {
+      Element tempEl = (Element) tempNode;
+      String namespaceURI = null;
+      if (prefix == null){
+    	  namespaceURI = getAttribute (tempEl, "xmlns");
+    	  if (namespaceURI == null)
+    		  namespaceURI = getAttribute (tempEl, "targetNamespace");
+      }
+      else
+    	  namespaceURI = getAttributeNS (tempEl, NS_URI_XMLNS, prefix);
+
+      if (namespaceURI != null)
+      {
+        return namespaceURI;
+      }
+      else
+      {
+        tempNode = tempEl.getParentNode ();
+      }
+    }
+
+    return null;
+  }
+
+  public static QName getQName(String prefixedValue,
+                               Element contextEl,
+                               Application app)
+                                 throws WADLSException
+  {
+    int    index        = prefixedValue.indexOf(':');
+    String prefix       = (index != -1)
+                          ? prefixedValue.substring(0, index)
+                          : null;
+    String localPart    = prefixedValue.substring(index + 1);
+    String namespaceURI = getNamespaceURIFromPrefix(contextEl, prefix);
+
+    if (namespaceURI != null)
+    {
+      registerUniquePrefix(prefix, namespaceURI, app);
+
+      return new QName(namespaceURI, localPart);
+    }
+    else
+    {
+      String faultCode = (prefix == null)
+                         ? WADLSException.NO_PREFIX_SPECIFIED
+                         : WADLSException.UNBOUND_PREFIX;
+
+      WADLSException wsdlExc = new WADLSException(faultCode,
+                                                "Unable to determine " +
+                                                "namespace of '" +
+                                                prefixedValue + "'.");
+
+      wsdlExc.setLocation(XPathUtils.getXPathExprFromNode(contextEl));
+
+      throw wsdlExc;
+    }
+  }
+
+  public static void registerUniquePrefix(String prefix,
+                                          String namespaceURI,
+                                          Application app)
+  {
+    String tempNSUri = app.getNamespace(prefix);
+
+    if (tempNSUri != null && tempNSUri.equals(namespaceURI))
+    {
+      return;
+    }
+
+    while (tempNSUri != null && !tempNSUri.equals(namespaceURI))
+    {
+      prefix += "_";
+      tempNSUri = app.getNamespace(prefix);
+    }
+
+    app.addNamespace(prefix, namespaceURI);
+  }
+
+  /**
+   * This method should be used for elements that support extension attributes
+   * because it does not track the remaining attributes to test for unexpected 
+   * attributes.
+   */
+  public static QName getQualifiedAttributeValue(Element el,
+                                                 String attrName,
+                                                 String elDesc,
+                                                 boolean isRequired,
+                                                 Application app)
+                                                   throws WADLSException
+  {
+    String attrValue = DOMUtils.getAttribute(el, attrName);
+
+    if (attrValue != null)
+    {
+      return getQName(attrValue, el, app);
+    }
+    else if (isRequired)
+    {
+      WADLSException wsdlExc = new WADLSException(WADLSException.INVALID_WADL,
+                                                "The '" + attrName +
+                                                "' attribute must be " +
+                                                "specified for every " +
+                                                elDesc + " element.");
+
+      wsdlExc.setLocation(XPathUtils.getXPathExprFromNode(el));
+
+      throw wsdlExc;
+    }
+    else
+    {
+      return null;
+    }
+  }
+
+  /**
+   * This method should be used for elements that do not support extension attributes
+   * because it tracks the remaining attributes so that eventually any
+   * unexpected attributes can be identified.
+   */
+  public static QName getQualifiedAttributeValue(Element el,
+                                                 String attrName,
+                                                 String elDesc,
+                                                 boolean isRequired,
+                                                 Application app,
+                                                 List remainingAttrs)
+                                                   throws WADLSException
+  {
+    String attrValue = null;
+    
+    attrValue = DOMUtils.getAttribute(el, attrName, remainingAttrs);
+
+    if (attrValue != null)
+    {
+      return getQName(attrValue, el, app);
+    }
+    else if (isRequired)
+    {
+      WADLSException wsdlExc = new WADLSException(WADLSException.INVALID_WADL,
+                                                "The '" + attrName +
+                                                "' attribute must be " +
+                                                "specified for every " +
+                                                elDesc + " element.");
+
+      wsdlExc.setLocation(XPathUtils.getXPathExprFromNode(el));
+
+      throw wsdlExc;
+    }
+    else
+    {
+      return null;
+    }
+  }
+
+  public static void throwWADLException(Element location) throws WADLSException
+  {
+    String elName = QNameUtils.newQName(location).toString();
+
+    WADLSException wsdlExc = new WADLSException(WADLSException.INVALID_WADL,
+                                              "Encountered unexpected element '" +
+                                              elName + "'.");
+
+    wsdlExc.setLocation(XPathUtils.getXPathExprFromNode(location));
+
+    throw wsdlExc;
+  }
+
+  public static void throwWADLException(Element location, List remainingAttrs) throws WADLSException
+  {
+    String elName = QNameUtils.newQName(location).toString();
+    
+    StringBuffer sb = new StringBuffer();
+    ListIterator i = remainingAttrs.listIterator();
+    while (i.hasNext())
+    {
+      String attrName = QNameUtils.newQName((Attr)i.next()).toString();
+      sb.append(attrName);
+      sb.append( i.hasNext() ? " " : "");
+    }
+
+    WADLSException wsdlExc = new WADLSException(WADLSException.INVALID_WADL,
+                                              "Element '" +
+                                              elName +
+                                              "' contained unexpected attributes: '" +
+                                              sb.toString() +
+                                              "'");
+
+    wsdlExc.setLocation(XPathUtils.getXPathExprFromNode(location));
+
+    throw wsdlExc;
+  }
+
+  public static void printAttribute(String name,
+                                    String value,
+                                    PrintWriter pw)
+  {
+    if (value != null)
+    {
+      pw.print(' ' + name + "=\"" + cleanString(value) + '\"');
+    }
+  }
+
+  /**
+   * Prints attributes with qualified names.
+   */
+  public static void printQualifiedAttribute(QName name,
+                                             String value,
+                                             Application app,
+                                             PrintWriter pw)
+                                               throws WADLSException
+  {
+    if (name != null)
+    {
+      printAttribute(getQualifiedValue(name.getNamespaceURI(),
+                                       name.getLocalPart(),
+                                       app),
+                     value,
+                     pw);
+    }
+  }
+
+  public static void printQualifiedAttribute(QName name,
+                                             QName value,
+                                             Application app,
+                                             PrintWriter pw)
+                                               throws WADLSException
+  {
+    if (value != null)
+    {
+      printAttribute(getQualifiedValue(name.getNamespaceURI(),
+                                       name.getLocalPart(),
+                                       app),
+                     getQualifiedValue(value.getNamespaceURI(),
+                                       value.getLocalPart(),
+                                       app),
+                     pw);
+    }
+  }
+
+  public static void printQualifiedAttribute(String name,
+                                             QName value,
+                                             Application app,
+                                             PrintWriter pw)
+                                               throws WADLSException
+  {
+    if (value != null)
+    {
+      printAttribute(name,
+                     getQualifiedValue(value.getNamespaceURI(),
+                                       value.getLocalPart(),
+                                       app),
+                     pw);
+    }
+  }
+
+  public static String getQualifiedValue(String namespaceURI,
+                                         String localPart,
+                                         Application app)
+                                           throws WADLSException
+  {
+    String prefix = null;
+
+    if (namespaceURI != null && !namespaceURI.equals(""))
+    {
+      prefix = getPrefix(namespaceURI, app);
+    }
+
+    return ((prefix != null && !prefix.equals(""))
+            ? prefix + ":"
+            : "") + localPart;
+  }
+
+  public static String getPrefix(String namespaceURI,
+                                 Application app)
+                                   throws WADLSException
+  {
+    String prefix = app.getPrefix(namespaceURI);
+
+    if (prefix == null)
+    {
+      throw new WADLSException(WADLSException.OTHER_ERROR,
+                              "Can't find prefix for '" + namespaceURI +
+                              "'. Namespace prefixes must be set on the" +
+                              " Definition object using the " +
+                              "addNamespace(...) method.");
+    }
+
+    return prefix;
+  }
+
+  public static String cleanString(String orig)
+  {
+    if (orig == null)
+    {
+      return "";
+    }
+
+    StringBuffer strBuf = new StringBuffer();
+    char[] chars = orig.toCharArray();
+    boolean inCDATA = false;
+
+    for (int i = 0; i < chars.length; i++)
+    {
+      if (!inCDATA)
+      {
+        switch (chars[i])
+        {
+          case '&'  : strBuf.append("&amp;");
+                      break;
+          case '\"' : strBuf.append("&quot;");
+                      break;
+          case '\'' : strBuf.append("&apos;");
+                      break;
+          case '<'  :
+                      {
+                        if (chars.length >= i + 9)
+                        {
+                          String tempStr = new String(chars, i, 9);
+
+                          if (tempStr.equals("<![CDATA["))
+                          {
+                            strBuf.append(tempStr);
+                            i += 8;
+                            inCDATA = true;
+                          }
+                          else
+                          {
+                            strBuf.append("&lt;");
+                          }
+                        }
+                        else
+                        {
+                          strBuf.append("&lt;");
+                        }
+                      }
+                      break;
+          case '>'  : strBuf.append("&gt;");
+                      break;
+          default   : strBuf.append(chars[i]);
+                      break;
+        }
+      }
+      else
+      {
+        strBuf.append(chars[i]);
+
+        if (chars[i] == '>'
+            && chars[i - 1] == ']'
+            && chars[i - 2] == ']')
+        {
+          inCDATA = false;
+        }
+      }
+    }
+
+    return strBuf.toString();
+  }
+}
+