Java Code Examples for org.w3c.dom.NamedNodeMap

public NextStateOperation(Node node){
  super(node);
  NamedNodeMap attr=node.getAttributes();
  long state;
  try {
    state=Long.parseLong(attr.getNamedItem("state").getNodeValue());
  }
 catch (  Exception e) {
    state=0;
  }
  this.nextState=state;
}
 

protected String getAttributeValue(Node node,String attrName){
  NamedNodeMap attrs=node.getAttributes();
  Node attrNode=attrs.getNamedItem(attrName);
  if (attrNode != null) {
    return attrNode.getNodeValue();
  }
  return "";
}
 

/** 
 * Reads the value of the specified <code>attribute</code>, returning the <code>defaultValue</code> string if not present.
 * @param node node to read the attribute.
 * @param attribute attribute name.
 * @param defaultValue the default value to return if attribute is not found.
 * @return the attribute value or <code>defaultValue</code> if not found.
 */
public static String readAttribute(Node node,String attribute,String defaultValue){
  NamedNodeMap attributes=node.getAttributes();
  if (null == attributes)   return defaultValue;
  Node attr=attributes.getNamedItem(attribute);
  if (null == attr)   return defaultValue;
  return attr.getNodeValue();
}
 

private static String getAttributeValue(Node node,String attributeName){
  NamedNodeMap attributes=node.getAttributes();
  if (attributes != null) {
    Node attribute=attributes.getNamedItem(attributeName);
    if (attribute != null)     return attribute.getNodeValue();
  }
  return null;
}
 

public static Map<String,String> findAttributesValues(Node node){
  Map<String,String> retval=new HashMap<String,String>();
  NamedNodeMap attrs=node.getAttributes();
  if (attrs != null) {
    for (int i=0; i < attrs.getLength(); i++) {
      Node attr=attrs.item(i);
      String name=attr.getNodeName();
      String value=attr.getNodeValue();
      retval.put(name,value);
    }
  }
  return retval;
}
 

protected String getType(Node node){
  NamedNodeMap attribs=node.getAttributes();
  if (attribs == null) {
    return null;
  }
  Node nodeType=attribs.getNamedItem("type");
  String type=null;
  if (nodeType != null) {
    type=nodeType.getNodeValue();
  }
  return type;
}
 

/** 
 * {@inheritDoc}
 */
@Override public List<String> getAttributeNames(){
  List<String> names=new ArrayList<String>();
  NamedNodeMap attrs=_element.getAttributes();
  for (int i=0; i < attrs.getLength(); i++) {
    Attr attr=(Attr)attrs.item(i);
    String name=XMLHelper.nameOf(attr);
    names.add(name);
  }
  return names;
}
 

private static void readAttributes(final Node target,final org.w3c.dom.Node source){
  final NamedNodeMap attributes=source.getAttributes();
  if (attributes != null) {
    for (int i=0; i < attributes.getLength(); i++) {
      final org.w3c.dom.Node attribute=attributes.item(i);
      target.attribute(attribute.getNodeName(),attribute.getNodeValue());
    }
  }
}
 

protected void processRecordFilter(Document doc){
  NodeList nodeList=doc.getElementsByTagName(NDCTEXTFILTER);
  Node n=nodeList.item(0);
  if (n == null) {
    return;
  }
  NamedNodeMap map=n.getAttributes();
  String text=getValue(map,NAME);
  if (text == null || text.equals("")) {
    return;
  }
  _monitor.setNDCLogRecordFilter(text);
}
 

private void readAttributes(final Node target,final org.w3c.dom.Node source){
  final NamedNodeMap attributes=source.getAttributes();
  if (attributes != null) {
    for (int i=0; i < attributes.getLength(); i++) {
      final org.w3c.dom.Node attribute=attributes.item(i);
      target.attribute(attribute.getNodeName(),attribute.getNodeValue());
    }
  }
}
 

/** 
 * Replace node name of <code>element</code> with new name <code>newNodeName</code>.
 * @param element
 * @param newNodeName
 * @return
 */
public static Element replaceNodeName(Element element,String newNodeName){
  Document document=element.getOwnerDocument();
  Element element2=document.createElement(newNodeName);
  NamedNodeMap attrs=element.getAttributes();
  for (int i=0; i < attrs.getLength(); i++) {
    Attr attr2=(Attr)document.importNode(attrs.item(i),true);
    element2.getAttributes().setNamedItem(attr2);
  }
  while (element.hasChildNodes()) {
    element2.appendChild(element.getFirstChild());
  }
  element.getParentNode().replaceChild(element2,element);
  return element2;
}
 

private static String getValue(final Element rootElement,final String tagName,final String attributeName){
  String result="";
  NodeList list=rootElement.getElementsByTagName(tagName);
  if (list.getLength() > 0) {
    NamedNodeMap attributes=list.item(0).getAttributes();
    Node pathNode=attributes.getNamedItem(attributeName);
    result=pathNode.getNodeValue();
  }
  return result;
}
 

@Override public ImmutableMap<String,String> getAttributes(){
  final ImmutableMap.Builder<String,String> result=ImmutableMap.builder();
  final NamedNodeMap attribs=element.getAttributes();
  for (int i=0; i < attribs.getLength(); i++) {
    final Attr attrib=(Attr)attribs.item(i);
    result.put(attrib.getName(),attrib.getValue());
  }
  return result.build();
}
 

/** 
 * Changes the tag name of an element.
 * @param elem Element which name should be changed
 * @param newName new tag name of the element
 * @return true if the name was changed successfully or false otherwise
 */
static public boolean changeTagName(Element elem,String newName){
  if (elem == null)   return false;
  Document doc=elem.getOwnerDocument();
  Element newElem=doc.createElement(newName);
  NamedNodeMap attrs=elem.getAttributes();
  for (int i=0; i < attrs.getLength(); i++) {
    Attr attr2=(Attr)doc.importNode(attrs.item(i),true);
    newElem.getAttributes().setNamedItem(attr2);
  }
  for (Node node=elem.getFirstChild(); node != null; node=node.getNextSibling())   newElem.appendChild(node.cloneNode(true));
  Node parent=elem.getParentNode();
  parent.replaceChild(newElem,elem);
  return true;
}
 

private String writeAttributes(Element element){
  StringBuffer attributeString=new StringBuffer();
  NamedNodeMap attributeMap=element.getAttributes();
  int length=attributeMap.getLength();
  for (int i=0; i < length; i++) {
    Attr attributeNode=(Attr)attributeMap.item(i);
    String name=attributeNode.getName();
    String value=attributeNode.getValue();
    attributeString.append(" ").append(name).append("=\"").append(value).append("\"");
  }
  return attributeString.toString();
}
 

/** 
 * Parse <osgi:natural> element.
 * @param element
 * @return
 */
protected Comparator parseNaturalComparator(Element element){
  Comparator comparator=null;
  NamedNodeMap attributes=element.getAttributes();
  for (int x=0; x < attributes.getLength(); x++) {
    Attr attribute=(Attr)attributes.item(x);
    String name=attribute.getLocalName();
    String value=attribute.getValue();
    if (BASIS.equals(name)) {
      if (SERVICE_REFERENCE_ORDER.equals(value))       return SERVICE_REFERENCE_COMPARATOR;
 else       if (SERVICE_ORDER.equals(value))       return null;
    }
  }
  return comparator;
}
 

private void attributeProperties(Element element,ParserContext parserContext,String beanTypeName,MutableBeanMetadata beanMetaData){
  NamedNodeMap attrs=element.getAttributes();
  for (int i=0; i < attrs.getLength(); i++) {
    Attr attr=(Attr)attrs.item(i);
    if (namespace.equals(attr.getNamespaceURI()) || attr.getNamespaceURI() == null) {
      String attrName=attr.getLocalName();
      String value=attr.getValue().trim();
      String propertyName=mappingMetaData.getPropertyName(beanTypeName,attrName);
      String propertyEditor=mappingMetaData.getPropertyEditor(beanTypeName,attrName);
      addProperty(propertyName,value,propertyEditor,beanMetaData,parserContext);
    }
  }
}
 

@Override public String toString(){
  StringBuilder sb=new StringBuilder();
  NamedNodeMap attributes=e.getAttributes();
  for (int i=0; i < attributes.getLength(); i++) {
    Node attr=attributes.item(i);
    sb.append(" " + attr.getNodeName() + "=\""+ attr.getNodeValue()+ "\"");
  }
  String tagName=e.getTagName();
  return "<" + tagName + " "+ sb.toString()+ ">"+ getInnerXml(e)+ "</"+ tagName+ ">";
}
 

public Node getIDAttribute(Node node){
  NamedNodeMap attributes=node.getAttributes();
  if (attributes == null)   return null;
  String[] names=getIDAttributeNames();
  for (int i=0; i < names.length; i++) {
    Node nameAttrib=attributes.getNamedItem(names[i]);
    if (nameAttrib != null)     return nameAttrib;
  }
  return null;
}
 

private void processMapping(Node node,Map map){
  NamedNodeMap attributes=node.getAttributes();
  String url=attributes.getNamedItem("url").getTextContent();
  String parameters=attributes.getNamedItem("parameters").getTextContent();
  map.put(url,this.convertToList(parameters));
}
 

public static String getAttributeValue(Node node,String name){
  if (node == null || !node.hasAttributes()) {
    return null;
  }
  NamedNodeMap attributes=node.getAttributes();
  if (attributes.getNamedItem(name) == null) {
    return null;
  }
  return attributes.getNamedItem(name).getNodeValue();
}
 

private IAccessRule readAccessRule(Node ruleNode) throws SAXException {
  NamedNodeMap attributes=ruleNode.getAttributes();
  int kind=Integer.parseInt(getAttribute(attributes,KIND));
  IPath pattern=new Path(getAttribute(attributes,PATTERN));
  return JavaCore.newAccessRule(pattern,kind);
}
 

/** 
 * Update the specified nsRegistry mappings with the nsRegistry declarations defined by the given XML element.
 * @param elem
 * @param nsRegistry
 * @throws javax.jcr.RepositoryException
 */
private static void updateNamespaceMapping(Element elem,NamespaceRegistry nsRegistry) throws RepositoryException {
  NamedNodeMap attributes=elem.getAttributes();
  for (int i=0; i < attributes.getLength(); i++) {
    Attr attr=(Attr)attributes.item(i);
    if (attr.getName().startsWith(ATTR_XMLNS)) {
      String prefix=attr.getName().substring(ATTR_XMLNS.length());
      String uri=attr.getValue();
      nsRegistry.registerNamespace(prefix,uri);
    }
  }
}
 

private void fillModelAttributes(ExmlModel model,JsonObject jsonObject,Node componentNode,ConfigClass configClass){
  NamedNodeMap attributes=componentNode.getAttributes();
  for (int i=0; i < attributes.getLength(); i++) {
    Attr attribute=(Attr)attributes.item(i);
    String attributeName=attribute.getLocalName();
    String attributeValue=attribute.getValue();
    ConfigAttribute configAttribute=getCfgByName(configClass,attributeName);
    jsonObject.set(attributeName,getAttributeValue(attributeValue,configAttribute == null ? null : configAttribute.getType()));
  }
  fillModelAttributesFromSubElements(model,jsonObject,componentNode,configClass);
}
 

private String getAttribute(Node node,String name){
  NamedNodeMap attrs=node.getAttributes();
  if (attrs == null) {
    return null;
  }
  Node item=attrs.getNamedItem(name);
  if (item == null) {
    return null;
  }
  return item.getNodeValue();
}
 

/** 
 * Decodes all attributes of the given node using decodeAttribute.
 */
protected void decodeAttributes(mxCodec dec,Node node,Object obj){
  NamedNodeMap attrs=node.getAttributes();
  if (attrs != null) {
    for (int i=0; i < attrs.getLength(); i++) {
      Node attr=attrs.item(i);
      decodeAttribute(dec,attr,obj);
    }
  }
}
 

/** 
 * Get an attribute value if it exists, or <code>null</code>
 */
static final String attr(Element element,String name,boolean ignoreNamespace){
  NamedNodeMap attributes=element.getAttributes();
  for (int i=0; i < attributes.getLength(); i++) {
    String localName=attributes.item(i).getNodeName();
    if (ignoreNamespace) {
      localName=stripNamespace(localName);
    }
    if (name.equals(localName)) {
      return attributes.item(i).getNodeValue();
    }
  }
  return null;
}
 

/** 
 * Parses the node for a given attribute. The comparison type can be specified, e.g. OrdinalIgnoreCase. If the attribute is not found, null is returned.
 */
private static Node findAttributeEquals(Node node,String attributeName,StringComparison comparisonType){
  NamedNodeMap attributes=node.getAttributes();
  for (int i=0; i < attributes.getLength(); i++) {
    Node attr=attributes.item(i);
    String name=attr.getNodeName();
    if (!StringUtils.isNullOrEmpty(name))     if (StringUtils.equal(name,attributeName,comparisonType))     return attr;
  }
  return null;
}
 

/** 
 * Get the names of the attributes specified on this element
 * @return The names of the elements specified
 */
public String[] getAttributeNames(){
  NamedNodeMap map=dom.getAttributes();
  String[] names=new String[map.getLength()];
  for (int i=0; i < names.length; i++) {
    names[i]=map.item(i).getNodeName();
  }
  return names;
}
 

@Override protected void doStart() throws ServiceStartException {
  final Layout layout=new PatternLayout("[%p %d] %c{1} - %m%n");
  rootLogger=Logger.getRootLogger();
  rootLogger.removeAllAppenders();
  rootLogger.addAppender(new ConsoleAppender(layout,"System.err"));
  final NodeList nodes=config.getLoggersNode().getChildNodes();
  for (int i=0; i < nodes.getLength(); i++) {
    final Node node=nodes.item(i);
    if (!"logger".equals(node.getNodeName()))     continue;
    final NamedNodeMap attributes=node.getAttributes();
    final Logger logger=Logger.getLogger(attributes.getNamedItem("name").getNodeValue());
    logger.setLevel(Level.toLevel(attributes.getNamedItem("level").getNodeValue()));
  }
}
 

private String getOpeningTag(){
  StringBuilder b=new StringBuilder().append("<").append(elem.getTagName());
  NamedNodeMap attrs=elem.getAttributes();
  for (int i=0; i < attrs.getLength(); i++) {
    Attr attr=(Attr)attrs.item(i);
    b.append(String.format(" %s='%s'",attr.getName(),UiBinderWriter.escapeAttributeText(attr.getValue())));
  }
  b.append(">");
  return b.toString();
}
 

private Element getContextRootProperty(Element webModuleElement){
  NodeList webModuleElementProperties=webModuleElement.getElementsByTagName("property");
  for (int i=0; i < webModuleElementProperties.getLength(); i++) {
    Element property=(Element)webModuleElementProperties.item(i);
    NamedNodeMap attributes=property.getAttributes();
    Attr nameAttribute=(Attr)attributes.getNamedItem("name");
    if (nameAttribute.getNodeValue().equals("context-root")) {
      return property;
    }
  }
  return null;
}
 

/** 
 * ??amoeba.xml?dbServerList???dbServer?????
 * @param current
 * @return
 */
private DBServerConfig loadServer(Element current){
  DBServerConfig serverConfig=new DBServerConfig();
  NamedNodeMap nodeMap=current.getAttributes();
  Map<String,Object> map=new HashMap<String,Object>();
  for (int i=0; i < nodeMap.getLength(); i++) {
    Node node=nodeMap.item(i);
    if (node instanceof org.w3c.dom.Attr) {
      Attr attr=(Attr)node;
      map.put(attr.getName(),attr.getNodeValue());
    }
  }
  ParameterMapping.mappingObject(serverConfig,map);
  BeanObjectEntityConfig factory=DocumentUtil.loadBeanConfig(DocumentUtil.getTheOnlyElement(current,"factoryConfig"));
  BeanObjectEntityConfig pool=DocumentUtil.loadBeanConfig(DocumentUtil.getTheOnlyElement(current,"poolConfig"));
  if (pool != null) {
    serverConfig.setPoolConfig(pool);
  }
  if (factory != null) {
    serverConfig.setFactoryConfig(factory);
  }
  return serverConfig;
}
 

private void serialize(Element e,XmlSerializer s,int depth,String spaces) throws Exception {
  String name=e.getTagName();
  writeSpace(s,depth,spaces);
  s.startTag("",name);
  if (e.hasAttributes()) {
    NamedNodeMap nm=e.getAttributes();
    for (int i=0; i < nm.getLength(); i++) {
      Attr attr=(Attr)nm.item(i);
      s.attribute("",attr.getName(),attr.getValue());
    }
  }
  if (e.hasChildNodes()) {
    NodeList nl=e.getChildNodes();
    int elements=0;
    for (int i=0; i < nl.getLength(); i++) {
      Node n=nl.item(i);
      short type=n.getNodeType();
switch (type) {
case Node.ELEMENT_NODE:
        serialize((Element)n,s,depth + 1,spaces);
      elements++;
    break;
case Node.TEXT_NODE:
  s.text(text(n));
break;
case Node.CDATA_SECTION_NODE:
s.cdsect(text(n));
break;
}
}
if (elements > 0) {
writeSpace(s,depth,spaces);
}
}
s.endTag("",name);
}
 

private void runC2B(Document c2b){
  Node root=c2b.getElementsByTagName("c2b").item(0);
  title=root.getAttributes().getNamedItem("title").getNodeValue();
  author=root.getAttributes().getNamedItem("author").getNodeValue();
  level=root.getAttributes().getNamedItem("level").getNodeValue();
  media=root.getAttributes().getNamedItem("media").getNodeValue();
  NodeList beats=c2b.getElementsByTagName("beat");
  targets=new ArrayList<Target>();
  for (int i=0; i < beats.getLength(); i++) {
    NamedNodeMap attribs=beats.item(i).getAttributes();
    double time=Double.parseDouble(attribs.getNamedItem("time").getNodeValue());
    int x=Integer.parseInt(attribs.getNamedItem("x").getNodeValue());
    int y=Integer.parseInt(attribs.getNamedItem("y").getNodeValue());
    String colorStr=attribs.getNamedItem("color").getNodeValue();
    targets.add(new Target(time,x,y,colorStr));
  }
  if ((beats.getLength() == 0) || forceEditMode) {
    displayCreateLevelAlert();
  }
 else {
    videoUri=Uri.parse(media);
    background.setVideoURI(videoUri);
  }
}
 

/** 
 * Extracts the attributes from a container node and create the corresponding layer.
 * @param parsingNode The container node
 * @return The layer extracted from this container
 */
private Layer parseLayerProperties(Node parsingNode){
  NamedNodeMap attributes=parsingNode.getAttributes();
  Node nameNode=attributes.getNamedItem("name");
  String name=nameNode.getNodeValue();
  Node lineStyleNode=attributes.getNamedItem("lineStyle");
  int lineStyle=Integer.parseInt(lineStyleNode.getNodeValue());
  Node thicknessNode=attributes.getNamedItem("thickness");
  double thickness=XMLUtils.nodeToDouble(thicknessNode);
  LineStyle[] styles=LineStyle.values();
  Layer layer=new Layer(Constant.WHITE,name,styles[lineStyle],thickness);
  Node visibleNode=attributes.getNamedItem("visible");
  if (visibleNode != null) {
    boolean visible=Boolean.parseBoolean(visibleNode.getNodeValue());
    layer.setVisible(visible);
  }
  Node lockedNode=attributes.getNamedItem("locked");
  if (lockedNode != null) {
    boolean locked=Boolean.parseBoolean(lockedNode.getNodeValue());
    layer.setLocked(locked);
  }
  return layer;
}
 

private void createEngines(){
  NodeList nlist=xmlinput.getElementsByTagName("SearchEngine");
  SearchEngineURLQueryAnalyzer.SearchEngine[] listEngines=new SearchEngineURLQueryAnalyzer.SearchEngine[nlist.getLength()];
  for (int i=0; i < nlist.getLength(); i++) {
    try {
      NamedNodeMap nnm=nlist.item(i).getAttributes();
      String EngineName=nnm.getNamedItem("engine").getNodeValue();
      String EnginedomainSubstring=nnm.getNamedItem("domainSubstring").getNodeValue();
      Map<String,String> splits=new HashMap<String,String>();
      NodeList listSplits=xmlinput.getElementsByTagName("splitToken");
      for (int k=0; k < listSplits.getLength(); k++) {
        if (listSplits.item(k).getParentNode().getAttributes().getNamedItem("engine").getNodeValue().equals(EngineName)) {
          splits.put(listSplits.item(k).getAttributes().getNamedItem("plainToken").getNodeValue(),listSplits.item(k).getAttributes().getNamedItem("regexToken").getNodeValue());
        }
      }
      SearchEngineURLQueryAnalyzer.SearchEngine Se=new SearchEngineURLQueryAnalyzer.SearchEngine(EngineName,EnginedomainSubstring,splits);
      System.out.println("Search Engine: " + Se.toString());
      listEngines[i]=Se;
    }
 catch (    Exception e) {
      logger.log(Level.WARNING,"Unable to create search engines!",e);
    }
  }
  engines=listEngines;
}
 

private void findNamespaces(Set<URI> namespaces,Node node){
  if (node instanceof Element || node instanceof Attr) {
    String ns=node.getNamespaceURI();
    if (ns != null && !isBlueprintNamespace(ns) && !isIgnorableAttributeNamespace(ns)) {
      namespaces.add(URI.create(ns));
    }
 else     if (ns == null && node instanceof Attr && SCOPE_ATTRIBUTE.equals(node.getNodeName()) && ((Attr)node).getOwnerElement() != null && BLUEPRINT_NAMESPACE.equals(((Attr)node).getOwnerElement().getNamespaceURI()) && BEAN_ELEMENT.equals(((Attr)node).getOwnerElement().getLocalName())) {
      URI scopeNS=getNamespaceForAttributeValue(node);
      if (scopeNS != null) {
        namespaces.add(scopeNS);
      }
    }
  }
  NamedNodeMap nnm=node.getAttributes();
  if (nnm != null) {
    for (int i=0; i < nnm.getLength(); i++) {
      findNamespaces(namespaces,nnm.item(i));
    }
  }
  NodeList nl=node.getChildNodes();
  for (int i=0; i < nl.getLength(); i++) {
    findNamespaces(namespaces,nl.item(i));
  }
}
 

public void fromXml(String xml) throws Exception {
  InputSource is=new InputSource(new StringReader(xml));
  Document doc=docBuilder.parse(is);
  Element root=doc.getDocumentElement();
  setRecordType(root.getTagName());
  long timestamp=Long.parseLong(root.getAttribute("ts"));
  setTimestamp(timestamp);
  NodeList children=root.getChildNodes();
  for (int i=0; i < children.getLength(); i++) {
    if (!children.item(i).getNodeName().equals("Metrics")) {
      continue;
    }
    NamedNodeMap attrs=children.item(i).getAttributes();
    if (attrs == null) {
      continue;
    }
    GenericChukwaMetrics metrics=new GenericChukwaMetrics();
    for (int a=0; a < attrs.getLength(); a++) {
      Attr attr=(Attr)attrs.item(a);
      String name=attr.getName();
      String value=attr.getValue();
      if (name.equals("key")) {
        metrics.setKey(value);
      }
 else {
        metrics.put(name,value);
      }
    }
    addMetrics(metrics);
  }
}
 

private Map<String,String> getNameForId(Node source){
  Map<String,String> result=new HashMap<String,String>();
  String id=null, name=null;
  NodeList data=source.getChildNodes();
  for (int i=0; i < data.getLength(); ++i) {
    Node n=data.item(i);
    if (n.getNodeType() != Node.ELEMENT_NODE) {
      continue;
    }
    if ("Id".equals(n.getNodeName())) {
      id=n.getTextContent();
    }
 else     if ("Item".equals(n.getNodeName())) {
      NamedNodeMap attrs=n.getAttributes();
      if (attrs.getNamedItem("Name") != null && "Title".equals(attrs.getNamedItem("Name").getNodeValue())) {
        name=n.getTextContent();
      }
    }
  }
  if (id != null) {
    if (name != null) {
      result.put(id,fixCase(name));
    }
 else {
      result.put(id,id);
    }
  }
  return result;
}
 

static void printElementAttributes(Document doc){
  NodeList nl=doc.getElementsByTagName("*");
  Element e;
  Node n;
  NamedNodeMap nnm;
  String attrname;
  String attrval;
  int i, len;
  len=nl.getLength();
  for (int j=0; j < len; j++) {
    e=(Element)nl.item(j);
    System.err.println(e.getTagName() + ":");
    nnm=e.getAttributes();
    if (nnm != null) {
      for (i=0; i < nnm.getLength(); i++) {
        n=nnm.item(i);
        attrname=n.getNodeName();
        attrval=n.getNodeValue();
        System.err.print(" " + attrname + " = "+ attrval);
      }
    }
    System.err.println();
  }
}
 

private boolean parseLines(Document doc){
  NodeList nList=doc.getElementsByTagName("line");
  for (int i=0; i < nList.getLength(); i++) {
    Node nNode=nList.item(i);
    if (nNode.hasAttributes()) {
      NamedNodeMap map=nNode.getAttributes();
      String x1Value=map.getNamedItem("x1").getNodeValue();
      String y1Value=map.getNamedItem("y1").getNodeValue();
      String x2Value=map.getNamedItem("x2").getNodeValue();
      String y2Value=map.getNamedItem("y2").getNodeValue();
      if (x1Value != "" || y1Value != "" || x2Value != "" || y2Value != " ") {
        double x1=stringToDouble(x1Value);
        double y1=stringToDouble(y1Value);
        double x2=stringToDouble(x2Value);
        double y2=stringToDouble(y2Value);
        Line line=new Line(x1,y1,x2,y2);
        pattern.addLine(line);
      }
    }
  }
  return true;
}
 

public void translateNamespaces(@Nonnull Document xmlDoc,boolean addNsToAttributes){
  Stack<Node> nodes=new Stack<Node>();
  nodes.push(xmlDoc.getDocumentElement());
  while (!nodes.isEmpty()) {
    Node node=nodes.pop();
switch (node.getNodeType()) {
case Node.ATTRIBUTE_NODE:
case Node.ELEMENT_NODE:
      Value<String> value=this.translations.get(new Key<String>(node.getNamespaceURI()));
    if (value != null) {
      node=xmlDoc.renameNode(node,value.getValue(),node.getNodeName());
    }
  break;
}
if (addNsToAttributes) {
NamedNodeMap attributes=node.getAttributes();
if (!(attributes == null || attributes.getLength() == 0)) {
  for (int i=0, count=attributes.getLength(); i < count; ++i) {
    Node attribute=attributes.item(i);
    if (attribute != null) {
      nodes.push(attribute);
    }
  }
}
}
NodeList childNodes=node.getChildNodes();
if (!(childNodes == null || childNodes.getLength() == 0)) {
for (int i=0, count=childNodes.getLength(); i < count; ++i) {
  Node childNode=childNodes.item(i);
  if (childNode != null) {
    nodes.push(childNode);
  }
}
}
}
}
 

private Cluster getCluster(Element el) throws Exception {
  NamedNodeMap elementsmap=el.getAttributes();
  Map<String,String> clusterelementsmap=new HashMap<String,String>(elementsmap.getLength());
  for (int i=0; i < elementsmap.getLength(); ++i) {
    Attr attribute=(Attr)elementsmap.item(i);
    logger.info(attribute.getName() + ":" + attribute.getValue());
    clusterelementsmap.put(attribute.getName(),attribute.getValue());
  }
  String cRootDir=defaults.get(ROOTDIR);
  NodeList list=el.getElementsByTagName(ROOTDIR);
  if (list != null && list.getLength() == 1) {
    Element elem=(Element)list.item(0);
    cRootDir=elem.getTextContent();
  }
  Map<String,DestinationStream> consumeStreams=new HashMap<String,DestinationStream>();
  logger.debug("getting consume streams for Cluster ::" + clusterelementsmap.get(NAME));
  List<DestinationStream> consumeStreamList=getConsumeStreams(clusterelementsmap.get(NAME));
  if (consumeStreamList != null && consumeStreamList.size() > 0) {
    for (    DestinationStream consumeStream : consumeStreamList) {
      consumeStreams.put(consumeStream.getName(),consumeStream);
    }
  }
  if (cRootDir == null)   cRootDir=defaults.get(ROOTDIR);
  return new Cluster(clusterelementsmap,cRootDir,consumeStreams,getSourceStreams(clusterelementsmap.get(NAME)));
}
 

static public Map<String,String> getXSDataClassTypes(IFile uml) throws Exception {
  HashMap<String,String> xsDataClasses=new HashMap<String,String>();
  DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
  DocumentBuilder db=dbf.newDocumentBuilder();
  Document doc=db.parse(uml.getContents());
  doc.getDocumentElement().normalize();
  NodeList nodelist=doc.getElementsByTagName("packagedElement");
  for (int i=0; i < nodelist.getLength(); i++) {
    Node node=nodelist.item(i);
    NamedNodeMap attribs=node.getAttributes();
    if (attribs.getNamedItem("xmi:type").getNodeValue().equals("uml:Class") == false) {
      continue;
    }
    String name=attribs.getNamedItem("name").getNodeValue();
    String generalization="";
    NodeList children=node.getChildNodes();
    for (int j=0; j < children.getLength(); j++) {
      if (children.item(j).getNodeName().equals("generalization")) {
        try {
          NodeList c1=children.item(j).getChildNodes();
          NamedNodeMap c2=c1.item(1).getAttributes();
          String gen=c2.getNamedItem("href").getNodeValue();
          String[] split=gen.split("#");
          IFile path=uml.getParent().getFile(new Path(split[0]));
          generalization=getReferencedObject(split[1],path);
        }
 catch (        Exception e) {
          NamedNodeMap a1=children.item(j).getAttributes();
          String gen=a1.getNamedItem("general").getNodeValue();
          generalization=getReferencedObject(gen,uml);
        }
      }
    }
    xsDataClasses.put(name,generalization);
  }
  return xsDataClasses;
}
 

public String getAttributeValue(Object o,String namespaceURI,String attrName){
  Element e=(Element)o;
  if (namespaceURI == TreeResolver.NO_NAMESPACE) {
    return e.getAttribute(attrName);
  }
 else   if (namespaceURI == null) {
    if (e.getLocalName() == null) {
      return e.getAttribute(attrName);
    }
 else {
      NamedNodeMap attrs=e.getAttributes();
      int l=attrs.getLength();
      for (int i=0; i < l; i++) {
        Attr attr=(Attr)attrs.item(i);
        if (attrName.equals(attr.getLocalName())) {
          return attr.getValue();
        }
      }
      return "";
    }
  }
 else {
    return e.getAttributeNS(namespaceURI,attrName);
  }
}
 

private void putElement(final Node node) throws IOException {
  final Namespace ns=_cache.namespace(node.getPrefix(),node.getNamespaceURI());
  final Tag tag=_cache.tag(lname(node),ns);
  _pd.startTag(tag);
  NamedNodeMap atts=node.getAttributes();
  final int end=atts.getLength();
  for (int i=0; i < end; ++i) {
    final Attr dattr=(Attr)atts.item(i);
    final String iri=dattr.getNamespaceURI();
    if (XMLNS_200_URI.equals(iri)) {
      final Namespace na=_cache.namespace(dattr.getLocalName(),dattr.getValue());
      if (na != ns)       _pd.addNamespace(na);
    }
  }
  for (int i=0; i < end; ++i) {
    final Attr dattr=(Attr)atts.item(i);
    final String iri=dattr.getNamespaceURI();
    if (!XMLNS_200_URI.equals(iri)) {
      final Attribute attr=_cache.attribute(lname(dattr),_cache.namespace(dattr.getPrefix(),iri));
      _pd.addAttr(attr,dattr.getValue());
    }
  }
  putNodeList(node.getChildNodes());
  _pd.endTag(tag);
}
 

public void fromXml(String xml) throws Exception {
  InputSource is=new InputSource(new StringReader(xml));
  Document doc=docBuilder.parse(is);
  Element root=doc.getDocumentElement();
  setRecordType(root.getTagName());
  long timestamp=Long.parseLong(root.getAttribute("ts"));
  setTimestamp(timestamp);
  NodeList children=root.getChildNodes();
  for (int i=0; i < children.getLength(); i++) {
    if (!children.item(i).getNodeName().equals("Metrics")) {
      continue;
    }
    NamedNodeMap attrs=children.item(i).getAttributes();
    if (attrs == null) {
      continue;
    }
    GenericChukwaMetrics metrics=new GenericChukwaMetrics();
    for (int a=0; a < attrs.getLength(); a++) {
      Attr attr=(Attr)attrs.item(a);
      String name=attr.getName();
      String value=attr.getValue();
      if (name.equals("key")) {
        metrics.setKey(value);
      }
 else {
        metrics.put(name,value);
      }
    }
    addMetrics(metrics);
  }
}
 

/** 
 * @return an object of SAMProgramRecord for base calling program
 */
public SAMProgramRecord readBaseCallProgramRecord(){
  Node nodeSoftware;
  try {
    XPathExpression exprBaseCallSoftware=xpath.compile("/BaseCallAnalysis/Run/Software");
    nodeSoftware=(Node)exprBaseCallSoftware.evaluate(baseCallsConfigDoc,XPathConstants.NODE);
  }
 catch (  XPathExpressionException ex) {
    log.error(ex,"Problems to read base calling program /BaseCallAnalysis/Run/Software");
    return null;
  }
  NamedNodeMap nodeMapSoftware=nodeSoftware.getAttributes();
  String softwareName=nodeMapSoftware.getNamedItem("Name").getNodeValue();
  String softwareVersion=nodeMapSoftware.getNamedItem("Version").getNodeValue();
  if (softwareName == null || softwareVersion == null) {
    log.warn("No base calling program name or version returned");
  }
  SAMProgramRecord baseCallProgramConfig=new SAMProgramRecord("basecalling");
  baseCallProgramConfig.setProgramName(softwareName);
  baseCallProgramConfig.setProgramVersion(softwareVersion);
  baseCallProgramConfig.setAttribute("DS","Basecalling Package");
  return baseCallProgramConfig;
}
 

public static void extractModelReferences(WSDLElement element,Model model,URI elementUri){
  if (null == model || false == model.isOpen())   return;
  Object obj=element.getExtensionAttribute(modelRefQName);
  if (obj != null) {
    processModelRefString(obj.toString(),model,elementUri);
  }
  List<UnknownExtensibilityElement> extElements=element.getExtensibilityElements();
  if (extElements != null && extElements.size() > 0) {
    for (    UnknownExtensibilityElement extElement : extElements) {
      NamedNodeMap nodeMap=extElement.getElement().getAttributes();
      if (null == nodeMap || 0 == nodeMap.getLength())       return;
      int len=nodeMap.getLength();
      for (int i=0; i < len; i++) {
        if (nodeMap.item(i) != null && nodeMap.item(i).getNodeName() != null && nodeMap.item(i).getNodeName().contains("modelReference")) {
          processModelRefString(nodeMap.item(i).getNodeValue(),model,elementUri);
        }
      }
    }
  }
}
 

@Override public Object getData(){
  final NamedNodeMap attributes=this.node.getAttributes();
  final WzDataType type=this.getType();
switch (type) {
case DOUBLE:
    final double doubleValue=Double.parseDouble(attributes.getNamedItem("value").getNodeValue());
  return Double.valueOf(doubleValue);
case FLOAT:
final float floatValue=Float.parseFloat(attributes.getNamedItem("value").getNodeValue());
return Float.valueOf(floatValue);
case INT:
final int intValue=Integer.parseInt(attributes.getNamedItem("value").getNodeValue());
return Integer.valueOf(intValue);
case SHORT:
final short shortValue=Short.parseShort(attributes.getNamedItem("value").getNodeValue());
return Short.valueOf(shortValue);
case STRING:
case UOL:
return attributes.getNamedItem("value").getNodeValue();
case VECTOR:
final String xNode=attributes.getNamedItem("x").getNodeValue();
final String yNode=attributes.getNamedItem("y").getNodeValue();
final int x=Integer.parseInt(xNode);
final int y=Integer.parseInt(yNode);
return new Point(x,y);
case CANVAS:
final String widthNode=attributes.getNamedItem("width").getNodeValue();
final String heightNode=attributes.getNamedItem("height").getNodeValue();
final int width=Integer.parseInt(widthNode);
final int height=Integer.parseInt(heightNode);
final File file=new File(this.imageDataDir,this.getName() + ".png");
return new FileStoredPngWzCanvas(width,height,file);
}
return null;
}
 

private void parseDialog(Node dialogNode){
  Node nameNode=getChildNode(dialogNode,XML_NAME);
  DialogModel dialog=new DialogModel(nameNode.getTextContent());
  Node propertiesNode=getChildNode(dialogNode,XML_PROPERTIES);
  NodeList properties=propertiesNode.getChildNodes();
  for (int i=0; i < properties.getLength(); i++) {
    Node curNode=properties.item(i);
    if (XML_PROPERTY.equals(curNode.getLocalName())) {
      NamedNodeMap nnm=curNode.getAttributes();
      String propertyName=nnm.getNamedItem(XML_NAME).getTextContent();
      String propertyType=nnm.getNamedItem(XML_TYPE).getTextContent();
      String propertyValue=nnm.getNamedItem(XML_VALUE).getTextContent();
      ComponentProperty property=new ComponentProperty(propertyName,propertyType,propertyValue);
      dialog.getProperties().add(property);
    }
  }
  Node componentsNode=getChildNode(dialogNode,XML_COMPONENTS);
  NodeList components=componentsNode.getChildNodes();
  for (int i=0; i < components.getLength(); i++) {
    Node curNode=components.item(i);
    if (XML_COMPONENT.equals(curNode.getLocalName())) {
      Component component=parseComponent(curNode);
      dialog.getComponents().add(component);
    }
  }
  dialogs.add(dialog);
}
 

private void domToSoap(Element domElement,ExtensionElement element) throws SOAPException {
  final String parentPrefix=element.getSOAPElement().getElementName().getPrefix();
  final String parentNamespaceUri=element.getSOAPElement().getElementName().getURI();
  final String nsPrefix=XML_NS_DECL_PREFIX + XML_NS_SEPARATOR;
  final NodeList nodeList=domElement.getChildNodes();
  for (int i=0; i < nodeList.getLength(); i++) {
    final org.w3c.dom.Node node=nodeList.item(i);
    if (node.getNodeType() == org.w3c.dom.Node.TEXT_NODE) {
      element.getSOAPElement().addTextNode(node.getNodeValue());
    }
    if (node.getNodeType() != org.w3c.dom.Node.ELEMENT_NODE) {
      continue;
    }
    final Element child=(Element)node;
    final ExtensionElement addedChild;
    if (child.getNamespaceURI().equals(parentNamespaceUri)) {
      addedChild=element.addChildElement(child.getLocalName());
    }
 else {
      addedChild=null;
    }
    final NamedNodeMap nodeMap=child.getAttributes();
    for (int j=0; j < nodeMap.getLength(); j++) {
      final Attr attribute=(Attr)nodeMap.item(j);
      final String name=attribute.getName();
      final String value=attribute.getValue();
      if (!name.equals(nsPrefix + NAMESPACE_PREFIX_DS) && !name.startsWith(XML_NS_DECL_PREFIX)) {
        addedChild.addAttribute(soapEnvelope.createName(name),value);
      }
    }
    domToSoap(child,addedChild);
  }
}
 

/** 
 * Get a list of configured blogs for the calling user. This method requires authentication with 'read' permission.
 * @param serviceId (Optional) Optionally only return blogs for a givenservice id. You can get a list of from BlogsApi.getServices().
 * @return a list of configured blogs for the calling user.
 * @throws JinxException if there are any errors.
 */
public List<Blog> getList(String serviceId) throws JinxException {
  List<Blog> list=new ArrayList<Blog>();
  Map<String,String> params=new TreeMap<String,String>();
  params.put("method","flickr.blogs.getList");
  params.put("api_key",Jinx.getInstance().getApiKey());
  if (!JinxUtils.isEmpty(serviceId)) {
    params.put("service",serviceId.trim());
  }
  Document doc=Jinx.getInstance().callFlickr(params,true);
  NodeList nodes=doc.getElementsByTagName("blog");
  if (nodes != null) {
    for (int i=0; i < nodes.getLength(); i++) {
      Blog b=new Blog();
      Node blogNode=nodes.item(i);
      NamedNodeMap attrs=blogNode.getAttributes();
      b.setId(JinxUtils.getAttribute(attrs,"id"));
      b.setName(JinxUtils.getAttribute(attrs,"name"));
      b.setService(JinxUtils.getAttribute(attrs,"service"));
      b.setNeedsPassword(JinxUtils.getAttributeAsBoolean(attrs,"needspassword"));
      b.setUrl(JinxUtils.getAttribute(attrs,"url"));
      list.add(b);
    }
  }
  return list;
}
 

/** 
 * @deprecated 
 */
public static void loadLearnHistory(Document document,LearnHistory history){
  Element rootTag=(Element)document.getElementsByTagName(STATS_ROOT).item(0);
  if (rootTag == null)   return;
  NodeList childs=rootTag.getChildNodes();
  for (int i=0; i < childs.getLength(); i++) {
    Node child=childs.item(i);
    if (child.getNodeType() != Node.ELEMENT_NODE)     continue;
    NamedNodeMap attributes=child.getAttributes();
    Date start=readDate(attributes,STATS_START);
    Date end=readDate(attributes,STATS_END);
    int passed=readInt(attributes,STATS_PASSED);
    int failed=readInt(attributes,STATS_FAILED);
    int skipped=readInt(attributes,STATS_SKIPPED);
    int relearned=readInt(attributes,STATS_RELEARNED);
    history.addSummary(start,end,passed,failed,skipped,relearned);
  }
  history.setIsLoaded(true);
}
 

/** 
 * Parses all global settings form the main configuration file.
 * @param root The root element of the configuration.
 */
private final void parseGlobalSettings(final Element root){
  final NodeList globalConfiguration=root.getElementsByTagName(ELEMENT_GLOBAL);
  final ResultFunctionFactory resultFunctionFactory=new ResultFunctionFactory();
  Node parameter;
  NodeList parameters;
  NamedNodeMap attributes;
  SettingEntry key;
  for (int i=0; i < globalConfiguration.getLength(); i++) {
    parameters=globalConfiguration.item(i).getChildNodes();
    for (int j=0; j < parameters.getLength(); j++) {
      parameter=parameters.item(j);
      if (parameter.getNodeType() == Node.ELEMENT_NODE) {
        attributes=parameter.getAttributes();
        key=new SettingEntry();
        key.setScope(attributes.getNamedItem(ATTRIBUTE_SCOPE).getNodeValue());
        key.setResult(resultFunctionFactory.create(attributes.getNamedItem(ATTRIBUTE_RESULT).getNodeValue()));
        key.setValue(parameter.getTextContent());
synchronized (globalConfig) {
          globalConfig.put(OperationalTextKey.valueOfEx(parameter.getNodeName()),key);
        }
      }
    }
  }
}
 

/** 
 * Extract the name for the EL-resolvers defined in the config file.
 * @param applicationNode the application config dom-node
 * @param configFilePath path to the config file
 * @return a Map with el-resolver id's and classnames
 */
private Map<String,String> getElResolvers(Node applicationNode,String configFilePath){
  Map<String,String> result=new HashMap<String,String>();
  String xpathElResolver="/faces-config/application/el-resolver";
  String xpathElResolverClassName="./text()";
  String xpathElResolverIdAttributeName="id";
  NodeList elResolvers=ParserUtils.query(applicationNode,xpathElResolver,configFilePath);
  for (int i=0; i < elResolvers.getLength(); i++) {
    Node elResolver=elResolvers.item(i);
    NamedNodeMap elAttributes=elResolver.getAttributes();
    Node elResolverIdAttribute=elAttributes.getNamedItem(xpathElResolverIdAttributeName);
    String elResolverId=null;
    if (elResolverIdAttribute != null) {
      elResolverId=elResolverIdAttribute.getTextContent();
    }
    String className=ParserUtils.querySingle(elResolver,xpathElResolverClassName,configFilePath);
    if (elResolverId != null) {
      result.put(elResolverId,className);
    }
 else {
      result.put(className,className);
    }
  }
  return result;
}
 

/** 
 * Parse the DOM tree and create HTML segments
 * @param node
 * @param sIndent
 */
private static void parseDOMTree(Node node,Segment segment,String domPath){
  String nodeName=node.getNodeName();
  domPath+=nodeName + "-";
  segment.setSegmentDOMPath(domPath);
  String nodeValue=node.getNodeValue();
  NamedNodeMap attrributes=node.getAttributes();
  if (attrributes != null) {
    int attributeCount=attrributes.getLength();
    for (int i=0; i < attributeCount; i++) {
      Attr item=(Attr)attrributes.item(i);
      if (item.getName().equals("href")) {
        String href=item.getValue();
        segment.setURL(href);
        break;
      }
    }
  }
  if (nodeName != null && nodeName.equals("br")) {
    segment.addLineBreak();
  }
  if (nodeName != null && nodeName.equals("hr")) {
    segment.addHorizontalLine();
  }
  if (nodeName != null && nodeValue != null && nodeName.equals("#text")) {
    segment.addSegmentText(nodeValue);
  }
  Node child=node.getFirstChild();
  while (child != null) {
    parseDOMTree(child,segment,domPath);
    child=child.getNextSibling();
  }
}
 

public void loadFromFile(InputStream stream){
  try {
    DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
    DocumentBuilder db=dbf.newDocumentBuilder();
    Document doc=db.parse(stream);
    NodeList favouritesList=doc.getElementsByTagName("Favourites");
    if (favouritesList.getLength() == 1) {
      Node favouritesNode=favouritesList.item(0);
      NodeList favourites=favouritesNode.getChildNodes();
      for (int i=0; i < favourites.getLength(); i++) {
        try {
          NamedNodeMap attributes=favourites.item(i).getAttributes();
          Node nameNode=attributes.getNamedItem("name");
          String name=nameNode.getNodeValue();
          Node hostNode=attributes.getNamedItem("host");
          String host=hostNode.getNodeValue();
          Node portNode=attributes.getNamedItem("port");
          int port=Integer.parseInt(portNode.getNodeValue());
          this.favourites.add(new BusURL(host,port,name));
        }
 catch (        Exception ex) {
        }
      }
    }
  }
 catch (  Exception ex) {
    logger.log(Level.SEVERE,"Error while reading connections from file\n");
  }
}
 

/** 
 * Parse XML document into a list of Definition objects. <p/> XML looks like this: <definitions> <definition sequence="0"> <text>A procedure for critical evaluation; a means of determining the presence, quality, or truth of something; a trial:  a test of one's eyesight; subjecting a hypothesis to a test; a test of an athlete's endurance. </text> <partOfSpeech>noun</partOfSpeech> <score>0.0</score> <sourceDictionary>ahd-legacy</sourceDictionary> <word>test</word> </definition> <definition sequence="1"> <text>A series of questions, problems, or physical responses designed to determine knowledge, intelligence, or ability.</text> <partOfSpeech>noun</partOfSpeech> <score>0.0</score> <sourceDictionary>ahd-legacy</sourceDictionary> <word>test</word> </definition> </definitions>
 * @param doc the XML document to parse.
 * @return list of Definition objects.
 * @throws KnickerException if there are any errors.
 */
static List<Definition> buildDefinitions(Document doc) throws KnickerException {
  List<Definition> definitions=new ArrayList<Definition>();
  try {
    NodeList defNodes=doc.getElementsByTagName("definition");
    for (int i=0; i < defNodes.getLength(); i++) {
      Definition definition=new Definition();
      Node defNode=defNodes.item(i);
      NamedNodeMap nnm=defNode.getAttributes();
      definition.setSequence(Util.getAttributeAsInt(nnm,"sequence"));
      definition.setText(Util.getNamedChildTextContent(defNode,"text"));
      definition.setPartOfSpeech(Util.getNamedChildTextContent(defNode,"partOfSpeech"));
      definition.setScore(Util.getNamedChildTextContent(defNode,"score"));
      definition.setSourceDictionary(Util.getNamedChildTextContent(defNode,"sourceDictionary"));
      definition.setWord(Util.getNamedChildTextContent(defNode,"word"));
      definition.setAttributionText(Util.getNamedChildTextContent(defNode,"attributionText"));
      definitions.add(definition);
    }
  }
 catch (  Exception e) {
    throw buildKnickerException("buildDefinitions",doc,e);
  }
  return definitions;
}
 

/** 
 * Compares the attributes of two XML <code>Node</code> objects. This method returns <code>true</code> if all attribute name-value pairs match  disregarding their order of placement.
 * @param n1    first <code>Node</code>
 * @param n2    second <code>Node</code>
 * @return  boolean
 */
public static boolean diffAttributes(Node n1,Node n2){
  NamedNodeMap n1Atts=n1.getAttributes();
  NamedNodeMap n2Atts=n2.getAttributes();
  if (n1Atts.getLength() != n2Atts.getLength()) {
    return false;
  }
  for (int i=0; i < n1Atts.getLength(); i++) {
    Node a1=n1Atts.item(i);
    Node a2Val=n2Atts.getNamedItem(a1.getNodeName());
    if (a2Val == null || !a1.getNodeValue().equals(a2Val.getNodeValue())) {
      return false;
    }
  }
  return true;
}
 

/** 
 * Find a node in a subtree. The search is started at the given node. The list of ids contains the document-id split by "/".
 * @param node where to start the search
 * @param ids list of node ids
 * @return the node that matches the path given in the list of ids
 */
protected synchronized Node findNode(Node node,List ids){
  if (ids.size() < 1) {
    return node;
  }
  NodeList nodes=node.getChildNodes();
  for (int i=0; i < nodes.getLength(); i++) {
    NamedNodeMap attributes=nodes.item(i).getAttributes();
    if (attributes != null) {
      Node idAttribute=attributes.getNamedItem("id");
      if (idAttribute != null && !"".equals(idAttribute.getNodeValue()) && idAttribute.getNodeValue().equals(ids.get(0))) {
        return findNode(nodes.item(i),ids.subList(1,ids.size()));
      }
    }
  }
  return null;
}
 

@Test public void createNode_addAutoIncrementChange() throws Exception {
  AddAutoIncrementChange change=new AddAutoIncrementChange();
  change.setSchemaName("SCHEMA_NAME");
  change.setTableName("TABLE_NAME");
  change.setColumnName("COLUMN_NAME");
  change.setColumnDataType("DATATYPE(255)");
  Element node=new XMLChangeLogSerializer(DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument()).createNode(change);
  assertEquals("addAutoIncrement",node.getTagName());
  NamedNodeMap attributes=node.getAttributes();
  for (int i=0; i < attributes.getLength(); i++) {
    Node attribute=attributes.item(i);
    if (attribute.getNodeName().equals("schemaName")) {
      assertEquals("SCHEMA_NAME",attribute.getNodeValue());
    }
 else     if (attribute.getNodeName().equals("tableName")) {
      assertEquals("TABLE_NAME",attribute.getNodeValue());
    }
 else     if (attribute.getNodeName().equals("columnName")) {
      assertEquals("COLUMN_NAME",attribute.getNodeValue());
    }
 else     if (attribute.getNodeName().equals("columnDataType")) {
      assertEquals("DATATYPE(255)",attribute.getNodeValue());
    }
 else {
      fail("unexpected attribute " + attribute.getNodeName());
    }
  }
}
 

/** 
 * Returns a sorted list of attributes. 
 */
protected Attr[] sortAttributes(NamedNodeMap attrs){
  int len=(attrs != null) ? attrs.getLength() : 0;
  Attr array[]=new Attr[len];
  for (int i=0; i < len; i++) {
    array[i]=(Attr)attrs.item(i);
  }
  for (int i=0; i < len - 1; i++) {
    String name=null;
    if (this.qualifiedNames) {
      name=array[i].getNodeName();
    }
 else {
      name=array[i].getLocalName();
    }
    int index=i;
    for (int j=i + 1; j < len; j++) {
      String curName=null;
      if (this.qualifiedNames) {
        curName=array[j].getNodeName();
      }
 else {
        curName=array[j].getLocalName();
      }
      if (curName.compareTo(name) < 0) {
        name=curName;
        index=j;
      }
    }
    if (index != i) {
      Attr temp=array[i];
      array[i]=array[index];
      array[index]=temp;
    }
  }
  return (array);
}
 

protected String getAttributeString(NamedNodeMap attributes,String attributeName){
  String attributeValue=null;
  if (attributes != null) {
    Node node=attributes.getNamedItem(attributeName);
    attributeValue=node == null ? null : node.getNodeValue();
  }
  return attributeValue;
}
 

/** 
 * Returns a sorted list of attributes. 
 */
private Attr[] sortAttributes(NamedNodeMap attrs){
  int len=(attrs != null) ? attrs.getLength() : 0;
  Attr[] array=new Attr[len];
  for (int i=0; i < len; i++) {
    array[i]=(Attr)attrs.item(i);
  }
  for (int i=0; i < len - 1; i++) {
    String name=array[i].getNodeName();
    int index=i;
    for (int j=i + 1; j < len; j++) {
      String curName=array[j].getNodeName();
      if (curName.compareTo(name) < 0) {
        name=curName;
        index=j;
      }
    }
    if (index != i) {
      Attr temp=array[i];
      array[i]=array[index];
      array[index]=temp;
    }
  }
  return (array);
}
 

static String getNamedItemNodeValue(NamedNodeMap attributes,String name,String defvalue){
  if (attributes == null) {
    return null;
  }
  Node namenode=attributes.getNamedItem(name);
  if (namenode == null)   return defvalue;
  if (namenode.getNodeValue() == null)   return defvalue;
  return namenode.getNodeValue();
}
 

/** 
 * Returns a sorted list of attributes. 
 */
private Attr[] sortAttributes(NamedNodeMap attrs){
  int len=(attrs != null) ? attrs.getLength() : 0;
  Attr array[]=new Attr[len];
  for (int i=0; i < len; i++) {
    array[i]=(Attr)attrs.item(i);
  }
  for (int i=0; i < len - 1; i++) {
    String name=array[i].getNodeName();
    int index=i;
    for (int j=i + 1; j < len; j++) {
      String curName=array[j].getNodeName();
      if (curName.compareTo(name) < 0) {
        name=curName;
        index=j;
      }
    }
    if (index != i) {
      Attr temp=array[i];
      array[i]=array[index];
      array[index]=temp;
    }
  }
  return (array);
}