Java OutputNode.isCommitted方法代码示例

import org.simpleframework.xml.stream.OutputNode; //导入方法依赖的package包/类
/**
 * The <code>write</code> method uses the name of the XML element to
 * select a converter to be used to write the instance. Selection of
 * the converter is done by looking up the associated label from
 * the union group using the instance type. Once the converter has
 * been selected it is used to write the instance.
 * 
 * @param source this is the source collection 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;                  
   
   if(group.isInline()) {
      if(!list.isEmpty()) {
         write(node, list);
      } else if(!node.isCommitted()){
         node.remove();
      }
   } else {
      write(node, list);
   }
}
 

import org.simpleframework.xml.stream.OutputNode; //导入方法依赖的package包/类
/**
 * The <code>write</code> method uses the name of the XML element to
 * select a converter to be used to write the instance. Selection of
 * the converter is done by looking up the associated label from
 * the union group using the instance type. Once the converter has
 * been selected it is used to write the instance.
 * 
 * @param node this is the XML element used to write the instance
 * @param source this is the value that is to be written
 */
public void write(OutputNode node, Object source) throws Exception {               
   Map map = (Map) source;

   if(group.isInline()) {
      if(!map.isEmpty()) {
         write(node, map);
      } else if(!node.isCommitted()){
         node.remove();
      }
   } else {
      write(node, map);
   }
}
 

import org.simpleframework.xml.stream.OutputNode; //导入方法依赖的package包/类
public void write(OutputNode node, Entry entry) throws Exception {
   if(!node.isCommitted()) {
      node.remove();
   }
   serializer.write(entry, node.getParent());
}
 

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 collection must be assignable from the annotated 
 * type specified within the <code>ElementList</code> annotation.
 * Each entry is serialized as a root element, that is, its
 * <code>Root</code> annotation is used to extract the name. 
 * 
 * @param source this is the source collection 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;              
   OutputNode parent = node.getParent();      
   
   if(!node.isCommitted()) {
      node.remove();
   }
   write(parent, list);
}
 

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 collection to be serialized 
 * @param node this is the XML element container to be populated
 */ 
public void write(OutputNode node, Object source) throws Exception {               
   OutputNode parent = node.getParent();      
   Mode mode = node.getMode();
   
   if(!node.isCommitted()) {
      node.remove();
   }      
   write(parent, source, mode);
}
 

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 {               
   OutputNode parent = node.getParent();  
   Mode mode = node.getMode();
   Map map = (Map) source;

   if(!node.isCommitted()) {
      node.remove();
   }
   write(parent, map, mode);
}