Source code: com/aendvari/common/model/ModelUtil.java

   /*
    * ModelUtil.java
    *
    * Copyright (c) 2001, 2002 Aendvari, Ltd. All Rights Reserved.
    *
    * See the file LICENSE for terms of use.
    *
    */
   
  package com.aendvari.common.model;
  
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.Map;
  
  import java.io.Writer;
  import java.io.StringWriter;
  import java.io.IOException;
  
  import com.aendvari.common.model.*;
  
  import com.aendvari.common.osm.*;
  import com.aendvari.common.model.osm.*;
  
  /**
   * <p>Provides various utility methods for the model classes.</p>
   *
   * @author  Scott Milne
   *
   */
  
  public class ModelUtil
  {
    /* Transfer */
  
  
    /**
     * Updates the children of the specified {@link ModelNode} using the
     * values stored within other {@link ModelNode ModelNodes}.
     *
     * @param    sourceNode          The {@link ModelNode} to read data from.
     * @param    sourceExpression      An expression selecting the source node.
     *                      Null to use <code>sourceNode</code>.
     *
     * @param    destinationNode        The {@link ModelNode} containing the data to update.
     * @param    destinationExpression    An expression selecting the destination node.
     *                      Null to use <code>destinationNode</code>.
     *
     * @param    createNodes          True creates destination nodes if they do not exist. False ignores unmatched nodes.
     *
     */
  
    public static void updateNodes(
      ModelNode sourceNode, String sourceExpression,
      ModelNode destinationNode, String destinationExpression,
      boolean createNodes)
    {
      ModelTree sourceTree = sourceNode.getOwnerModelTree();
      ModelTree destinationTree = destinationNode.getOwnerModelTree();
  
      // get root source node
      ModelNode rootSource = sourceNode;
  
      if (sourceExpression != null)
      {
        // get specified node
        rootSource = sourceTree.getNode(sourceNode, sourceExpression);
  
        // can not continue if root doesn't exist
        if (rootSource == null)
        {
          throw new ModelException("Node can not be found at '" + sourceExpression + "'.");
        }
      }
  
      // get root destination node
      ModelNode rootDestination = destinationNode;
  
      if (destinationExpression != null)
      {
        // get specified node
        rootDestination = destinationTree.getNode(destinationNode, destinationExpression);
  
        // can not continue if root doesn't exist
        if (rootDestination == null)
        {
          throw new ModelException("Node can not be found at '" + destinationExpression + "'.");
        }
      }
  
      // the updateNode() method requires that the 'source' node be a child
      // and that 'destination' be the parent of the similar named child
  
      // traverse through the children of the source root and
      // send to updateNode()
  
      Iterator nodeIterator = rootSource.getChildNodes().iterator();
  
      while (nodeIterator.hasNext())
     {
       ModelNode sourceChild = (ModelNode)nodeIterator.next();
 
       // read children and store in children of current destination node
       updateNode(destinationTree, sourceChild, rootDestination, createNodes);
     }
   }
 
   /**
    * Updates the value of the supplied node. Each child node is then recursively
    * updated.
    *
    * @param    destinationTree        The {@link ModelTree} being updated.
    * @param    sourceNode          The {@link ModelNode} to read data from.
    * @param    destinationParent      The {@link ModelNode} containing the child to update.
    * @param    createNodes          True creates destination nodes if they do not exist. False ignores unmatched nodes.
    *
    */
 
   protected static void updateNode(
     ModelTree destinationTree, ModelNode sourceNode, ModelNode destinationParent, boolean createNodes)
   {
     // use the name of the source node to find the destination node
     ModelNode updateNode = destinationTree.getNode(destinationParent, sourceNode.getNodeName());
 
     // check if node exists
     if (updateNode == null)
     {
       // if not, then create output node if requested
       if (createNodes)
       {
         updateNode = destinationTree.createNode(
           sourceNode.getNodeName(), sourceNode.getNodeValue());
       }
       else
       {
         // ignore source value
         return;
       }
     }
     // if so, then copy value
     else
     {
       // update node value from source node
       updateNode.setNodeValue(sourceNode.getNodeValue().toString());
     }
 
     // update children
     Iterator nodeIterator = sourceNode.getChildNodes().iterator();
 
     while (nodeIterator.hasNext())
     {
       ModelNode sourceChild = (ModelNode)nodeIterator.next();
 
       // read children and store in children of current destination node
       updateNode(destinationTree, sourceChild, updateNode, createNodes);
     }
   }
 
 
   /* Deletion */
 
 
   /**
    * Sets the values of the supplied node and all of its children to an
    * empty string. Each child is then recursively visited and cleared.
    *
    * @param    baseNode          The base {@link ModelNode} of the nodes to clear.
    *
    */
 
   public static void clearNodes(ModelNode baseNode)
   {
     // update node value
     baseNode.setNodeValue("");
 
     // update children
     Iterator nodeIterator = baseNode.getChildNodes().iterator();
 
     while (nodeIterator.hasNext())
     {
       ModelNode child = (ModelNode)nodeIterator.next();
 
       clearNodes(child);
     }
   }
 
   /**
    * Removes the children having the specified name from the supplied node.
    *
    * @param    modelNode          The parent {@link ModelNode}.
    * @param    childName          The name of the children to remove.
    *
    */
 
   public static void removeNamedChildren(ModelNode modelNode, String childName)
   {
     // retrieve list of node name 'childName'
     Iterator nodeIterator = modelNode.getOwnerModelTree().getNodes(modelNode, childName).iterator();
 
     // remove all of the selected nodes from the parent
     while (nodeIterator.hasNext())
     {
       ModelNode entry = (ModelNode)nodeIterator.next();
       modelNode.removeChild(entry);
     }
   }
 
   /**
    * Removes all children of the supplied node.
    *
    * @param    modelNode          The parent {@link ModelNode}.
    *
    */
 
   public static void removeAllChildren(ModelNode modelNode)
   {
     // retrieve list of children
     Iterator nodeIterator = modelNode.getChildNodes().iterator();
 
     // remove all children
     while (nodeIterator.hasNext())
     {
       ModelNode entry = (ModelNode)nodeIterator.next();
       modelNode.removeChild(entry);
     }
   }
 
   /**
    * Removes all children of the selected node.
    *
    * @param    modelNode          The parent {@link ModelNode}.
    * @param    selectExpression      An expression selecting a single {@link ModelNode}.
    *                      Relative to <code>modelNode</code>.
    *
    */
 
   public static void removeAllChildren(ModelNode modelNode, String selectExpression)
   {
     // determine specified node
     ModelNode removeNode = modelNode.getOwnerModelTree().getNode(modelNode, selectExpression);
 
     // check for valid selection
     if (removeNode == null)
     {
       throw new ModelException("Node can not be found at '" + selectExpression + "'.");
     }
 
     // remove children of node
     removeAllChildren(removeNode);
   }
 
 
   /* OSM methods */
 
 
   /**
    * Copies data from the specified location in the supplied {@link Osm OSM} to the
    * destination {@link ModelNode}.
    *
    * @param    sourceNode          The {@link OsmNode} to read data from.
    * @param    sourceExpression      An expression selecting the source node.
    *                      Null to use <code>sourceNode</code>.
    * @param    destinationNode        The {@link ModelNode} containing the data to update.
    * @param    createNodes          True creates destination nodes if they do not exist. False ignores unmatched nodes.
    *
    */
 
   public static void osmToModel(
     OsmNode sourceNode, String sourceExpression, ModelNode destinationNode, boolean createNodes)
   {
     OsmNode selectedNode = sourceNode;
 
     // select OSM node if expression if provided
     if (sourceExpression != null)
     {
       // select the OSM node
       selectedNode = SimpleOsmPath.getNode(sourceNode, sourceExpression, false);
 
       // check for valid selection
       if (selectedNode == null)
       {
         // if OSM node doesn't exist, then nothing to copy
         return;
       }
     }
 
     // create a ModelNode from the selected node
     OsmModelTree modelTree = new OsmModelTree();
     ModelNode modelNode = modelTree.createNode(selectedNode);
 
     // copy data
     updateNodes(modelNode, null, destinationNode, null, createNodes);
   }
 
   /**
    * Copies data from the {@link ModelNode} into the specified location of the
    * supplied {@link Osm OSM}.
    *
    * @param    sourceNode          The {@link ModelNode} to read data from.
    * @param    destinationNode        The {@link OsmNode} containing the data to update.
    * @param    destinationExpression    An expression selecting the destination node.
    *                      Null to use <code>destinationNode</code>.
    * @param    createNodes          True creates destination nodes if they do not exist. False ignores unmatched nodes.
    *
    */
 
   public static void modelToOsm(
     ModelNode sourceNode, OsmNode destinationNode, String destinationExpression, boolean createNodes)
   {
     OsmNode selectedNode = destinationNode;
 
     // select OSM node if expression if provided
     if (destinationExpression != null)
     {
       // select the OSM node
       selectedNode = SimpleOsmPath.getNode(destinationNode, destinationExpression, false);
 
       // check for valid selection
       if (selectedNode == null)
       {
         throw new ModelException("Node can not be found at '" + destinationExpression + "'.");
       }
     }
 
     // create a ModelNode from the selected node
     OsmModelTree modelTree = new OsmModelTree();
     ModelNode modelNode = modelTree.createNode(selectedNode);
 
     // copy data
     updateNodes(sourceNode, null, modelNode, null, createNodes);
   }
 
 
   /* Output */
 
 
   /**
    * Writes the supplied {@link ModelNode} and its children to a string.
    *
    * @param    modelNode          The {@link ModelNode} to read data from.
    *
    * @return                  A string containing the {@link ModelNode} data.
    *
    */
 
   public static String writeNode(ModelNode modelNode)
   {
     StringWriter buffer = new StringWriter();
 
     try
     {
       examineNode(modelNode, buffer, "");
     }
     catch (IOException exception)
     {
       // ignore exception
     }
 
     return buffer.toString();
   }
 
   /**
    * Writes the supplied {@link ModelNode} and its children to output.
    *
    * @param    modelNode          The {@link ModelNode} to read data from.
    * @param    output            The {@link Writer} to output text to.
    *
    * @exception  IOException          Error writing to {@link Writer}.
    *
    */
 
   public static void writeNode(ModelNode modelNode, Writer output)
     throws IOException
   {
     examineNode(modelNode, output, "");
   }
 
   /**
    * Outputs a single {@link ModelNode}, then recursively examines children.
    *
    * @param    modelNode          The {@link ModelNode} instance to examine.
    * @param    output            The {@link Writer} to output text to.
    * @param    indent            The indentation level for the display.
    *
    * @exception  IOException          Error writing to {@link Writer}.
    *
    */
 
   protected static void examineNode(ModelNode modelNode, Writer output, String indent)
     throws IOException
   {
     // start tag
     output.write(indent);
     output.write("<");
     output.write(modelNode.getNodeName());
 
     // output attributes
     Iterator attributeIterator = modelNode.getAttributes().values().iterator();
 
     while (attributeIterator.hasNext())
     {
       Map.Entry attribute = (Map.Entry)attributeIterator.next();
 
       output.write(" ");
       output.write(attribute.getKey().toString());
       output.write("=\"");
       output.write(attribute.getValue().toString());
       output.write("\"");
     }
 
     output.write(">");
 
     // track when a child node has been output
     boolean childOutput = false;
 
     // check for children
     if (modelNode.hasChildNodes())
     {
       // output children
       Iterator childIterator = modelNode.getChildNodes().iterator();
 
       while (childIterator.hasNext())
       {
         ModelNode childNode = (ModelNode)childIterator.next();
 
         // skip internal nodes
         if (childNode.getNodeName().startsWith("#")) continue;
 
         // start a new line at first child node
         if (!childOutput)
         {
           output.write("\n");
           childOutput = true;
         }
 
         // examine child
         examineNode(childNode, output, indent + "    ");
       }
 
       // prepare for close tag
       if (childOutput)
       {
         output.write(indent);
       }
     }
 
     // check for value
     if ((modelNode.getNodeValue() != null) && (!childOutput))
     {
       // output node value
       output.write(modelNode.getNodeValue());
     }
 
     // close tag
     output.write("</");
     output.write(modelNode.getNodeName());
     output.write(">\n");
   }
 }