content: /*
   * OutputNodeMap.java July 2006
   *
   * Copyright (C) 2006, Niall Gallagher <niallg@users.sf.net>
   *
   * 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 com.aliyun.odps.simpleframework.xml.stream;
  
  import java.util.LinkedHashMap;
  import java.util.Iterator;
  
  /**
   * The <code>OutputNodeMap</code> is used to collect attribute nodes
   * for an output node. This will create a generic node to add to the
   * map. The nodes created will be used by the output node to write
   * attributes for an element.
   * 
   * @author Niall Gallagher
   */ 
  class OutputNodeMap extends LinkedHashMap<String, OutputNode> implements NodeMap<OutputNode> {
  
     /**
      * This is the source node that this node map belongs to.
      */         
     private final OutputNode source;
          
     /**
      * Constructor for the <code>OutputNodeMap</code> object. This is
      * used to create a node map that is used to create and collect
      * nodes, which will be used as attributes for an output element.
      */         
     public OutputNodeMap(OutputNode source) {
        this.source = source;           
     }   
     
     /**
      * This is used to acquire the actual node this map represents.
      * The source node provides further details on the context of
      * the node, such as the parent name, the namespace, and even
      * the value in the node. Care should be taken when using this. 
      * 
      * @return this returns the node that this map represents
      */
     public OutputNode getNode() {
         return source;
     }
     
     /**
      * This is used to get the name of the element that owns the
      * nodes for the specified map. This can be used to determine
      * which element the node map belongs to.
      * 
      * @return this returns the name of the owning element
      */  
     public String getName() {
        return source.getName();           
     }   
  
     /**
      * This is used to add a new <code>Node</code> to the map. The
      * node that is created is a simple name value pair. Once the
      * node is created it can be retrieved by its given name.
      *
      * @param name this is the name of the node to be created
      * @param value this is the value to be given to the node
      * 
      * @return this is the node that has been added to the map
      */    
     public OutputNode put(String name, String value) {
        OutputNode node = new OutputAttribute(source, name, value);
        
        if(source != null) {
           put(name, node);
        }
        return node;
     }
     
     /**
      * This is used to remove the <code>Node</code> mapped to the
      * given name.  This returns a name value pair that represents
      * an attribute. If no node is mapped to the specified name 
      * then this method will a return null value.
      *
      * @param name this is the name of the node to remove
      * 
      * @return this will return the node mapped to the given name
      */    
     public OutputNode remove(String name) {
        return super.remove(name);
     }
  
     /**
      * This is used to acquire the <code>Node</code> mapped to the
      * given name. This returns a name value pair that represents
      * an element. If no node is mapped to the specified name then 
      * this method will return a null value.
      *
      * @param name this is the name of the node to retrieve
      * 
      * @return this will return the node mapped to the given name
      */   
     public OutputNode get(String name) {
        return super.get(name);
     }
  
     /**
      * This returns an iterator for the names of all the nodes in
      * this <code>OutputNodeMap</code>. This allows the names to be 
      * iterated within a for each loop in order to extract nodes.
      *
      * @return this returns the names of the nodes in the map
      */    
     public Iterator<String> iterator() {
        return keySet().iterator();           
     }
  }
  