Java OutputNode.getChild方法代码示例

import org.simpleframework.xml.stream.OutputNode; //导入方法依赖的package包/类
private static <T> void writeList(Serializer ser, OutputStream os, String listElement, List<T> list) throws Exception {
	Format format = new Format("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
	OutputNode doc = NodeBuilder.write(new OutputStreamWriter(os, UTF_8), format);
	OutputNode root = doc.getChild("root");
	root.setComment(BACKUP_COMMENT);
	OutputNode listNode = root.getChild(listElement);

	if (list != null) {
		for (T t : list) {
			try {
				ser.write(t, listNode);
			} catch (Exception e) {
				log.debug("Exception While writing node of type: " + t.getClass(), e);
			}
		}
	}
	root.commit();
}
 

import org.simpleframework.xml.stream.OutputNode; //导入方法依赖的package包/类
/**
 * This <code>write</code> method is used to convert the provided
 * object to an XML element. This creates a child node from the
 * given <code>OutputNode</code> object. Once this child element 
 * is created it is populated with the fields of the source object
 * in accordance with the XML schema class.  
 * 
 * @param source this is the object to be serialized to XML
 * @param expect this is the class that is expected to be written
 * @param name this is the name of the root annotation used 
 * 
 * @throws Exception thrown if there is a problem serializing
 */
public void write(OutputNode node, Object source, Class expect, String name) throws Exception {
   OutputNode child = node.getChild(name);
   Type type = getType(expect);
   
   if(source != null) {
      Class actual = source.getClass();
      Decorator decorator = getDecorator(actual);
      
      if(decorator != null) {
         decorator.decorate(child);
      }
      if(!context.setOverride(type, source, child)) {
         getComposite(actual).write(child, source);         
      }
   }         
   child.commit();      
}
 

import org.simpleframework.xml.stream.OutputNode; //导入方法依赖的package包/类
/**
 * This method is used to write the value to the specified node.
 * This will write the item as an element to the provided node,
 * also this enables references to be used during serialization.
 * 
 * @param node this is the node that the value is written to
 * @param item this is the item that is to be written
 */
private void writeElement(OutputNode node, Object item) throws Exception {
   Class expect = type.getType();
   String key = entry.getKey();
   
   if(key == null) {
      key = context.getName(expect);
   }    
   String name = style.getElement(key);
   OutputNode child = node.getChild(name);  
   
   if(item != null) {
      if(!isOverridden(child, item)) {
         root.write(child, item);
      }
   }
}
 

import org.simpleframework.xml.stream.OutputNode; //导入方法依赖的package包/类
/**
 * This write method is used to write all the element contacts from
 * the provided source object to the XML element. This visits all
 * the contacts marked with the <code>Element</code> annotation in
 * the source object. All annotated contacts are written as children
 * to the XML element. This will throw an exception if a required
 * contact within the source object is null. 
 * 
 * @param source this is the source object to be serialized
 * @param node this is the XML element to write elements to
 * @param section this is the section that defines the XML structure
 */
private void writeElements(OutputNode node, Object source, Section section) throws Exception {
    for(String name : section) {
      Section child = section.getSection(name);
      
      if(child != null) {
         OutputNode next = node.getChild(name);

         writeSection(next, source, child);
      } else {
         String path = section.getPath(name);
         Label label = section.getElement(path);
         Class expect = context.getType(type, source);
         Object value = criteria.get(label);
         
         if(value == null) {
            if(label == null) {
              throw new ElementException("Element '%s' not defined in %s", name, expect);
            }
            writeUnion(node, source, section, label);
         }
      }            
   }
}
 

import org.simpleframework.xml.stream.OutputNode; //导入方法依赖的package包/类
/**
 * This write method is used to append the provided object as an
 * element to the given XML element object. This will recursively
 * write the contacts from the provided object as elements. This is
 * done using the <code>Converter</code> acquired from the contact
 * label. If the type of the contact value is not of the same
 * type as the XML schema class a "class" attribute is appended.
 * <p>
 * If the element being written is inline, then this will not 
 * check to see if there is a "class" attribute specifying the
 * name of the class. This is because inline elements do not have
 * an outer class and thus could never have an override.
 * 
 * @param value this is the value to be set as an element
 * @param node this is the XML element to write the element to
 * @param label the label that contains the contact details
 */
private void writeElement(OutputNode node, Object value, Label label) throws Exception {
   if(value != null) {
      Class real = value.getClass();
      Label match = label.getLabel(real);
      String name = match.getName();
      Type type = label.getType(real); 
      OutputNode next = node.getChild(name);

      if(!match.isInline()) {
         writeNamespaces(next, type, match);
      }
      if(match.isInline() || !isOverridden(next, value, type)) {
         Converter convert = match.getConverter(context);
         boolean data = match.isData();
         
         next.setData(data);
         writeElement(next, value, convert);
      }
   }
}
 

import org.simpleframework.xml.stream.OutputNode; //导入方法依赖的package包/类
public void testLargeList() throws Exception {
   Context context = getContext();
   Group group = getGroup();
   Type type = new ClassType(CompositeListUnionTest.class);
   List<Shape> list = new ArrayList<Shape>();
   Expression expression = new PathParser("some/path", type, new Format());
   CompositeListUnion union = new CompositeListUnion(
         context,
         group,
         expression,
         type);
   InputNode node = NodeBuilder.read(new StringReader(LARGE_SOURCE));
   
   for(InputNode next = node.getNext(); next != null; next = node.getNext()) {
      union.read(next, list);
   }
   OutputNode output = NodeBuilder.write(new PrintWriter(System.err), new Format(3));
   OutputNode parent = output.getChild("parent");
   
   union.write(parent, list);
}
 

import org.simpleframework.xml.stream.OutputNode; //导入方法依赖的package包/类
public void write(OutputNode node) throws Exception {
    OutputNode member = node.getChild(CODE);
    OutputNode nameNode = member.getChild(Member.NAME);
    nameNode.setValue(name);
    OutputNode valueNode = member.getChild(Value.CODE);
    value.write(valueNode);
}
 

import org.simpleframework.xml.stream.OutputNode; //导入方法依赖的package包/类
@Override
public void write(OutputNode node) throws Exception {
    OutputNode child = node.getChild(CODE);
    OutputNode dataNode = child.getChild(ArrayValue.DATA);
    for (Value datum : data) {
        datum.write(dataNode.getChild(Value.CODE));
    }
}
 

import org.simpleframework.xml.stream.OutputNode; //导入方法依赖的package包/类
@Override
public void write(OutputNode node) throws Exception {
    OutputNode struct = node.getChild(CODE);
    for (Member member : members) {
        member.write(struct);
    }
}
 

import org.simpleframework.xml.stream.OutputNode; //导入方法依赖的package包/类
/**
 * This <code>write</code> method will write the specified object
 * to the given XML element as as list entries. Each entry within
 * the given list must be assignable to the given primitive type.
 * This will deserialize each entry type as a primitive value. In
 * order to do this the parent string provided forms the element.
 * 
 * @param node this is the parent output node to write values to
 * @param source this is the source collection to be serialized 
 * @param mode this is used to determine whether to output CDATA    
 */ 
private void write(OutputNode node, Object source, Mode mode) throws Exception {
   Collection list = (Collection) source;
   
   for(Object item : list) {
      if(item != null) {
         OutputNode child = node.getChild(parent);
      
         if(!isOverridden(child, item)) { 
            child.setMode(mode);
            root.write(child, item);
         }
      }
   }
}
 

import org.simpleframework.xml.stream.OutputNode; //导入方法依赖的package包/类
/**
 * This <code>write</code> method will write the key value pairs
 * within the provided map to the specified XML node. This will 
 * write each entry type must contain a key and value so that
 * the entry can be deserialized in to the map as a pair. If the
 * key or value object is composite it is read as a root object 
 * so its <code>Root</code> annotation must be present.
 * 
 * @param node this is the node the map is to be written to
 * @param map this is the source map that is to be written 
 * @param mode this is the mode that has been inherited
 */
private void write(OutputNode node, Map map, Mode mode) throws Exception {   
   String root = entry.getEntry();
   String name = style.getElement(root);
   
   for(Object index : map.keySet()) {
      OutputNode next = node.getChild(name);
      Object item = map.get(index);            
      
      next.setMode(mode); 
      key.write(next, index);            
      value.write(next, item);                  
   }
}
 

import org.simpleframework.xml.stream.OutputNode; //导入方法依赖的package包/类
/**
 * This method is used to write the value to the specified node.
 * The value written to the node can be an attribute or an element
 * depending on the annotation attribute values. This method will
 * maintain references for serialized elements.
 * 
 * @param node this is the node that the value is written to
 * @param item this is the item that is to be written
 * @param key this is the name of the element to be created
 */   
private void writeElement(OutputNode node, Object item, String key) throws Exception {
   String name = style.getAttribute(key);
   OutputNode child = node.getChild(name);

   if(item != null) {        
      if(!isOverridden(child, item)) {
         root.write(child, item);
      }
   }
}
 

import org.simpleframework.xml.stream.OutputNode; //导入方法依赖的package包/类
/**
 * This <code>write</code> method will write the specified object
 * to the given XML element as as array entries. Each entry within
 * the given array must be assignable to the array component type.
 * This will deserialize each entry type as a primitive value. In
 * order to do this the parent string provided forms the element.
 * 
 * @param source this is the source object array to be serialized 
 * @param node this is the XML element container to be populated
 */ 
public void write(OutputNode node, Object source) throws Exception {
   int size = Array.getLength(source);
   
   for(int i = 0; i < size; i++) {
      OutputNode child = node.getChild(parent);
      
      if(child == null) {
         break;
      }
      write(child, source, i);
   }
}
 

import org.simpleframework.xml.stream.OutputNode; //导入方法依赖的package包/类
/**
 * This <code>write</code> method will write the key value pairs
 * within the provided map to the specified XML node. This will 
 * write each entry type must contain a key and value so that
 * the entry can be deserialized in to the map as a pair. If the
 * key or value object is composite it is read as a root object 
 * so its <code>Root</code> annotation must be present.
 * 
 * @param node this is the node the map is to be written to
 * @param source this is the source map that is to be written 
 */
public void write(OutputNode node, Object source) throws Exception {
   Map map = (Map) source;                
   
   for(Object index : map.keySet()) {
      String root = entry.getEntry();
      String name = style.getElement(root);
      OutputNode next = node.getChild(name);
      Object item = map.get(index);            
      
      key.write(next, index);            
      value.write(next, item);                  
   }
}
 

import org.simpleframework.xml.stream.OutputNode; //导入方法依赖的package包/类
/**
 * This <code>write</code> method will write the specified object
 * to the given XML element as as list entries. Each entry within
 * the given list must be assignable to the given primitive type.
 * This will deserialize each entry type as a primitive value. In
 * order to do this the parent string provided forms the element.
 * 
 * @param source this is the source object array to be serialized 
 * @param node this is the XML element container to be populated
 */ 
public void write(OutputNode node, Object source) throws Exception {
   Collection list = (Collection) source;                
   
   for(Object item : list) {
      if(item != null) {
         OutputNode child = node.getChild(parent);         

         if(!isOverridden(child, item)) { 
            root.write(child, item);
         }
      }
   }
}