Flex3 xml处理类MyXMLUtils.as

//
//  My System
//  Copyright 2008-2009 My Systems Incorporated
//  All Rights Reserved.
//
//  NOTICE: My System permits you to use, modify, and distribute this file
//  Langversion ActionScript 3.0
//  playerversion Flash 9.0
//  DATE: 2008-12-02 keren
//  QQ: 994251681
//  MSN: keren1515@hotmail.com
//

//X4E属性访问方法总结：
//           node.@id
//           node.attribute("id")
//           node.['@id']
//           node.@['id']

package org.app.utils.common
{
 public class MyXMLUtils
 {
  private static var instance:MyXMLUtils = null;
  public static function getInstance():MyXMLUtils{
   if(instance == null){
    instance = new MyXMLUtils(new SingletonEnforcer());
   }
   return instance;
  }
  public function MyXMLUtils(enforcer:SingletonEnforcer)
  {
   if(enforcer==null)throw new Error("This class is singletonEnforcer.");
  }
  
  /**
   * 把一段字符串解析成xml对象
   */
  public function createXML(str:String,
        ignoreCommnets:Boolean=false,
        ignoreWhitespace:Boolean=false):XML{
   try{
    XML.ignoreComments = ignoreCommnets;
    XML.ignoreWhitespace = ignoreWhitespace;
    var xml:XML = new XML(str);
    return xml;
   }catch(error:Error){
    throw error;
   }
   return null;
  }
  
  /**
   * 创建新的xml节点对象
   * @param String nodeName 节点名称
   * @param String nodeValue 节点值
   * @return XML 构建的新的节点对象
   */
  public function createSingleNode(nodeName:String,nodeValue:String):XML{
   try{
    var str:String = "<"+nodeName+">"+nodeValue+"</"+nodeName+">";
    return new XML(str);
   }catch(error:Error){
    throw error;
   }
   return null;
  }
  
  /**
   * 创建一系列节点对象
   * @param String nodeName 节点名称
   * @param Array nodeValue 节点值数组
   * @return XMLList 构建的新的节点对象
   */
  public function createNodeList(nodeName:String,nodeValue:Array):XMLList{
   try{
    var xmlList:XMLList = new XMLList();
    var node:XML;
    for(var i:int=0;i<nodeValue.length;i++){
     node = this.createSingleNode(nodeName,nodeValue[i]);
     xmlList+=node;
    }
    return xmlList;
   }catch(error:Error){
    throw error;
   }
   return null;
  }
  
  /**
   * XML与XMLList之间的相互转换
   */
  public function toXML(xmlList:XMLList):XML{
   return new XML("<>"+xmlList.toXMLString()+"</>");
  }
  public function toXMLList(xml:XML):XMLList{
   var xmlList:XMLList = new XMLList();
   xmlList+=xml;
   return xmlList;
  }
  /**
   * 转换xml对象成字符串
   */
  public function toXMLString(xml:*):String{
   try{
    var res:String = "";
    if(xml != null && xml is XML){
     res = xml.toXMLString();
    }else if(xml != null && xml is XMLList){
     var item:XML;
     for each(item in xml){
      res+=item.toXMLString();
     }
    }
    return res;
   }catch(error:Error){
    throw error;
   }
   return null;
  }
  /**
   * 返回文本串,比如：<a>aaa</a>,那么返回的是：aaa;
   */
  public function toString(xml:*):String{
   try{
    var res:String = "";
    if(xml != null && xml is XML){
     res = xml.toString();
    }else if(xml != null && xml is XMLList){
     var item:XML;
     for each(item in xml){
      res+=item.toString();
     }
    }
    return res;
   }catch(error:Error){
    throw error;
   }
   return null;
  }
  
  /**
   * 添加子节点信息到目标XML的最后，使新加的节点成为最后节点[只针对根节点下的第一层子节点]
   * @param src_xml 新的节点信息XML对象
   * @param target_xml 要操作的目标XML对象
   * @return Boolean true:成功 false:失败
   */
  public function appendNode(src_xml:*, target_xml:XML):Boolean{
   try{
    if(target_xml != null && target_xml is XML){
     if(src_xml is XML || src_xml is XMLList){
      target_xml.appendChild(src_xml);
      return true;
     }else if(src_xml is String){
      var xml:XML = new XML(src_xml);
      target_xml.appendChild(xml);
      return true;
     }
    }
   }catch(error:Error){
    throw error;
   }
   return false;
  }
  
  /**
   * 取得目标xml对象的第一个子节点的节点名称
   * @param XML 要操作的xml对象
   * @return String 节点名称
   */
  public function getSubNodeName(target_xml:XML):String{
   try{
    if(target_xml == null || !(target_xml is XML))return null;
    var xmlList:XMLList = target_xml.children();
    if(xmlList == null)return null;
    var subNode:XML = null;
    for each(subNode in xmlList){
     break;
    }
    if(subNode != null && subNode is XML){
     return subNode.name();
    }
   }catch(error:Error){
    throw error;
   }
   return null;
  }
  
  /**
   * 取得某个节点的名称
   */
  public function getNodeName(node:XML):String{
   return node.name();
  }
  /**
   * 取得节点的值
   */
  public function getNodeValue(node:XML):String{
   return node.toString();
  }
  
  /**
   * 在指定的位置插入新的节点信息，根据 before来判断插入的位置;
   * 1,如果不指定位置，插入子节点信息到目标XML的第一个根节点下的第一层的第一个位置，
   *   使新加的节点成为第一个节点。
   *
   * [注意]是针对根节点下的第一层子节点
   * @param String src_xml 新的节点信息,如果是字符串的话，必须是单节点的字符串,
   *                eg: src_xml = "<a0>00000</a0>";
   * @param XML target_xml 要操作的目标XML对象
   * @param int position 插入的位置
   * @param Boolean before true：指定位置之后
   *                      false： 指定位置之前
   *
   * @return Boolean true:成功 false:失败
   */
  public function insertNode(src_xml:*, target_xml:XML,
        position:int=0, before:Boolean=false):Boolean{
   try{
    if(target_xml == null || !(target_xml is XML)){
     return false;
    }
    var o:Object = null;
    if(src_xml is XML || src_xml is XMLList){
     o = src_xml;
    }else if(src_xml is String){
     o = new XML(src_xml);
    }
    
    //当前目标对象的下级节点个数
    var count:int = target_xml.length();
    trace("--count:"+count);
    if(count<=0){
     //新节点成为第一个子节点
     target_xml.prependChild(o);
     return true;
    }
    
    //节点位置处理
    if(position <=0){
     //新节点成为第一个子节点
     target_xml.prependChild(o);
     return true;
    }
    
    //取得子节点的名称
    var nodeName:String = this.getSubNodeName(target_xml);
    if(position >= count){
     position = count -1;
    }
    var tmpXML:XML = this.getChildByNodeNameAndPosition(target_xml, nodeName, position);
    var xmlList:XMLList = this.toXMLList(tmpXML);
    trace("==="+xmlList.toString());
    if(before){//前
     target_xml.insertChildBefore(xmlList,o);
    }else{//后
     target_xml.insertChildAfter(xmlList,o);
    }
   }catch(error:Error){
    throw error;
   }
   return true;
  }
  
  /**
   * 取得指定位置的节点对象
   * [注意]只能取根节点下的第一级子节点
   *
   * @param XML target_xml 操作的XML对象
   * @param int position 指定的位置
   *
   * @return XML 目标节点信息[XML]
   */
  public function getChildByPosition(target_xml:XML, position:int):XML{
   try{
    var xmlList:XMLList = target_xml.children();
    if(xmlList == null || !(xmlList is XMLList))return null;
    trace(xmlList.length());
    if(position<0 || position > xmlList.length())return null;
    var item:XML;
    var index:int=0;
             for each(item in xmlList) {
//                 trace("item: " + item.toXMLString());
     if(position==index)return item;
     index++;
             }
   }catch(error:Error){
    throw error;
   }
   return null;
  }
  
  /**
   * 取得某个节点名称的列表
   * [注意]只能取根节点下的第一级子节点
   */
  public function getChildByNodeName(target_xml:XML,nodeName:String):XMLList{
   return target_xml.child(nodeName);
  }
  /**
   * 取得指定位置的节点对象
   * [注意]只能取根节点下的第一级子节点
   *
   * @param XML target_xml 操作的XML对象
   * @param String nodeString 节点名称
   * @param int position 指定的位置
   *
   * @return XML 目标节点信息[XML]
   */
  public function getChildByNodeNameAndPosition(target_xml:XML,
         nodeName:String, position:int):XML{
   try{
    return target_xml.child(nodeName)[position];
   }catch(error:Error){
    throw error;
   }
   return null;
  }
  /**
   * 取得指定节点名称和节点值的XML对象
   * [注意]只能取根节点下的第一级子节点
   */
  public function getChildByNodeNameAndNodeValue(target_xml:XML,
        nodeName:String,nodeValue:String):XML{
   try{
    //判断是否存在该节点
//    if(target_xml.hasOwnProperty(nodeName)){
//     trace("-------"+target_xml.child(nodeName).(elements(nodeName)==nodeValue);
//     return target_xml.child(nodeName).(elements(nodeName)==nodeValue);
//    }
    var xmlList:XMLList = target_xml.child(nodeName);
    var item:XML;
    var tmp:String;
    for each(item in xmlList){
     tmp = item.toString();
     if(tmp == nodeValue)return item;
    }
   }catch(error:Error){
    throw error;
   }
   return null;
  }
  /**
   * 取得指定节点名称和属性名称、属性值的XMLList对象
   * [注意]只能取根节点下的第一级子节点
   */
  public function getChildByNodeNameAndAttrName(target_xml:XML, nodeName:String,
        attrName:String,attrValue:String):XMLList{
   try{
    //xml.child(nodeName).(@attrname=='attrvalue')
    return target_xml.child(nodeName).(attribute(attrName)==attrValue);
   }catch(error:Error){
    throw error;
   }
   return null;
  }
  
  /**
   * 取得某个节点的所有属性信息,如果节点名为null，那么取当前节点的属性集
   * [注意]只能取根节点下的第一级子节点
   *
   */
  public function getAttrs(target_xml:XML,nodeName:String=null,position:int=0):Array{
   try{
//    return target_xml.child(nodeName)[position].attributes();//这个只是返回所有的属性值
    var xml:XML;
    if(nodeName == null){
     //取当前节点的属性集合
     xml = target_xml;
    }else{
     xml = target_xml.child(nodeName)[position];
    }
    
    var xmlList:XMLList = xml.attributes();
    var arr:Array = new Array();
    var tmpArr:Array = null;
    for each(xml in xmlList){
     tmpArr = new Array();
     tmpArr.push(xml.name());
     tmpArr.push(xml.toString());
     arr.push(tmpArr);
    }
    return arr;
   }catch(error:Error){
    throw error;
   }
   return null;
  }
  
  /**
   * 取得当前节点的某个属性值
   */
  public function getAttrValue(node:XML,attrName:String):String{
   try{
    var xmlList:XMLList = node.attribute(attrName);
    var item:XML;
    for each(item in xmlList){
     break;
    }
    return item.toString();
   }catch(error:Error){
    throw error;
   }
   return null;
  }
  
  /**
   * 删除某个节点
   * [注意]只能取根节点下的第一级子节点
   * Boolean true:成功 false:失败
   */
  public function deleteNodeByNodeNameAndAttr(target_xml:XML,nodeName:String,
       attrName:String,attrValue:String):Boolean{
   var flg:Boolean = false;
   try{
    var xmlList:XMLList = target_xml.child(nodeName).(attribute(attrName)==attrValue);
    for each(var xml:XML in xmlList){
     var position:int = xml.childIndex();//当前节点在父节点下的index
     delete target_xml.child(nodeName)[position];
     flg = true;
    }
    
   }catch(error:Error){
    throw error;
   }
   return flg;
  }
  /**
   * 删除某个节点,根据节点名和位置
   * [注意]只能取根节点下的第一级子节点
   */
  public function deleteNodeByNodeNameAndPosition(target_xml:XML,nodeName:String,
       position:int):Boolean{
   try{
    delete target_xml.child(nodeName)[position];
   }catch(error:Error){
    throw error;
   }
   return true;
  }
  /**
   * 删除一个指定位置的节点
   * [注意]只能取根节点下的第一级子节点
   * @param XML target_xml 目标xml对象
   * @param int position 指定的位置
   * @return Boolean true/false
   */
  public function deleteNodeByPosition(target_xml:XML, position:int):Boolean{
   try{
    var node:XML = this.getChildByPosition(target_xml, position);
    if(node != null){
     var nodeName:String = this.getNodeName(node);
     return this.deleteNodeByNodeNameAndPosition(target_xml,nodeName,position);
    }
   }catch(error:Error){
    throw error;
   }
   return false;
  }
  
  //节点属性操作：修改 添加 删除
  public function changeNodeAttr(node:XML,nodeName:String,nodeValue:String):XML{
   node.@[nodeName]=nodeValue;
   return node;
  }
  //节点值操作：修改
  public function changeNodeValue(node:XML,nodeValue:String):XML{
//   node. = nodeValue;
   return node;
  }
  
  
  
 }//end class
}//end package
class SingletonEnforcer {}