//====================================================================================
//20110106 liq
//测试环境：IE 8.0、Firefox 3.6、Safari 5.0、chrome 8.0、Opera 11
//
//DataBrigde 对象
//完成客户端与服务器端的同步或异步通信
//与此对象也有一个服务器端的 DataBrigde 对象，用于接收并返回服务器端信息
//通信数据格式 XML文本
//提交与返回都是通过 dataList 进行与XML文本的转换
//====================================================================================
function DataBrigde() {
    this.controller = new String();
    this.action = new String();
    this.url = new String();
	this.urlValue = new String();
    this.xmlStr = null;
    this.xmlDoc = null;
    this.dataList = new Array();

    this.clearDataList = function () { return DataBrigde_clearDataList(this) }
    this.getDataList = function (xmlStr) { return DataBrigde_getDataList(xmlStr, this); };
    this.setDataList = function (dataList) { return DataBrigde_setDataList(dataList, this); };
    this.getData = function (name) { return DataBrigde_getData(name, this); };
    this.setData = function (name, data) { return DataBrigde_setData(name, data, this); };
    this.xmlToData = function (elem) { return DataBrigde_xmlToData(elem, this); };
    this.dataToXml = function (data) { return DataBrigde_dataToXml(data, this); };
    this.getObjType = function (value) { return DataBrigde_getObjType(value, this); };

    this.sendUrl = function (controller, action) { return DataBrigde_sendUrl(controller, action, this); }
    this.send = function (beforeFun, completeFun, completeFunData) { return DataBrigde_send(this, arguments.length, beforeFun, completeFun, completeFunData); }
}

//接收服务器端数据-----------------------------------------------
function DataBrigde_getDataList(xmlStr, baseObj) {
    baseObj.xmlStr = xmlStr;
    var xmlDom = new XmlDom();
    baseObj.xmlDoc = xmlDom.loadXml("<dataList/>");
	baseObj.dataList = new Array();
    baseObj.xmlDoc = xmlDom.loadXml(xmlStr);

    baseObj.clearDataList();
	if (baseObj.xmlDoc.documentElement==null) return false;

    var nodeList = baseObj.xmlDoc.documentElement.childNodes;
    var data = new Data();

    for (var i = 0; i < nodeList.length; i++) {
        data = baseObj.xmlToData(nodeList[i]);
        baseObj.dataList.push(data);
    }

    return baseObj.dataList;
}

//发送服务器端数据-----------------------------------------------
function DataBrigde_setDataList(dataList, baseObj) {
    var xmlDom = new XmlDom();
    baseObj.xmlDoc = xmlDom.loadXml("<dataList/>");
	baseObj.dataList = new Array();
    if(dataList!=null)baseObj.dataList = dataList;
    var elem = null;

    for (var i = 0; i < baseObj.dataList.length; i++) {
        elem = baseObj.dataToXml(dataList[i]);
        baseObj.xmlDoc.firstChild.appendChild(elem);
    }

    baseObj.xmlStr = xmlDom.xml(baseObj.xmlDoc);
    return baseObj.xmlStr;
}

//读取提交到服务器端的URL地址------------------------------------------------------
function DataBrigde_sendUrl(controller, action, baseObj) {
    baseObj.controller = controller;
    baseObj.action = action;
    var value = encodeURIComponent(baseObj.xmlStr);
    var randomnum = Math.random();
    var url = "/webSiteResource/controller/" + controller + ".aspx?randomnum=" + randomnum;
    baseObj.url = url;
    baseObj.urlValue = "controller=" + controller + "&action=" + action + "&value=" + (value);
    return url;
}

//提交数据并读取服务器返回数据------------------------------------------------------
function DataBrigde_send(baseObj, parameterNum, beforeFun, completeFun, completeFunData) {
    var xmlHttp = new XmlHttp();
    var xmlHttpText = null;

    if (parameterNum == 0) {
        xmlHttpText = xmlHttp.loadXMLHTTP(baseObj.url, baseObj.urlValue);
		baseObj.getDataList(xmlHttpText);

    }
    else {
        xmlHttp.loadXMLHTTP(baseObj.url, baseObj.urlValue, beforeFun, completeFun, completeFunData);
    }

    return xmlHttpText;
}

//读取数据-----------------------------------------------------
function DataBrigde_getData(name, baseObj) {
    var data = null;
    for (var i = 0; i < baseObj.dataList.length; i++) {
        if (name.toLowerCase() == baseObj.dataList[i].name.toLowerCase()) {
            data = baseObj.dataList[i].value;
            break;
        }
    }
    return data;
}

//设置数据-----------------------------------------------------
function DataBrigde_setData(name, data, baseObj) {
    var isok = false;
    for (var i = 0; i < baseObj.dataList.Count; i++) {
        if (name.toLowerCase() == baseObj.dataList[i].name.toLowerCase()) {
            baseObj.dataList[i].value = data;
            isok = true;
            break;
        }
    }
    return isok;
}

//XML节点转换Data对象------------------------------------------
function DataBrigde_xmlToData(elem, baseObj) {
    var data = new Data();
    data.name = elem.getAttribute("name");
    data.type = elem.getAttribute("type");

    if (data.type.toLowerCase() == "string") {
        var dataBrigdeString = new DataBrigdeString(baseObj.xmlDoc);
        data.value = dataBrigdeString.xmlTextToObject("string", elem.firstChild.nodeValue);
    }
    else if (data.type.toLowerCase() == "xml") {
        var dataBrigdeXmlDoc = new DataBrigdeXmlDoc(baseObj.xmlDoc);
        data.value = dataBrigdeXmlDoc.xmlDataToXmlDoc(elem.firstChild);
    }
    else if (data.type.toLowerCase() == "table") {
        var dataBrigdeTable = new DataBrigdeTable(baseObj.xmlDoc);
        data.value = dataBrigdeTable.xmlToTable(elem.firstChild);
    }
    else if (data.type.toLowerCase() == "hash") {
        var dataBrigdeHash = new DataBrigdeHash(baseObj.xmlDoc);
        data.value = dataBrigdeHash.xmlToHash(elem.firstChild);
    }
    else {
        throw new Error("未找到相应的数据类型.");
    }

    return data;
}

//Data对象转换XML节点------------------------------------------
function DataBrigde_dataToXml(data, baseObj) {
    var elem = baseObj.xmlDoc.createElement("data");
    if (data.type == null) {
        data.type = baseObj.getObjType(data.value);
    }

    elem.setAttribute("name", data.name);
    elem.setAttribute("type", data.type);

    if (data.type.toLowerCase() == "string") {
        var dataBrigdeString = new DataBrigdeString(baseObj.xmlDoc);
        elem.appendChild(dataBrigdeString.objectToXmlText(data.value));
    }
    else if (data.type.toLowerCase() == "xml") {
        var dataBrigdeXmlDoc = new DataBrigdeXmlDoc(baseObj.xmlDoc);
        elem.appendChild(dataBrigdeXmlDoc.xmlDataToXmlDoc(data.value));
    }
    else if (data.type.toLowerCase() == "table") {
        var dataBrigdeTable = new DataBrigdeTable(baseObj.xmlDoc);
        elem.appendChild(dataBrigdeTable.tableToXml(data.value));
    }
    else if (data.type.toLowerCase() == "hash") {
        var dataBrigdeHash = new DataBrigdeHash(baseObj.xmlDoc);
        elem.appendChild(dataBrigdeHash.hashToXml(data.value));
    }
    else {
        throw new Error("未找到相应的数据类型。");
    }

    return elem;
}

//读取对象类型---------------------------------------------
function DataBrigde_getObjType(value, baseObj) {
    var type = value.constructor;
    if (type == String) {
        type = "string";
    }
    else if (type == DataTable) {
        type = "table";
    }
    else if (type == HashTable) {
        type = "hash";
    }
    else {
        throw new Error("数据类型不正确。");
    }
    return type;
}

//清空DataList内容-----------------------------------------
function DataBrigde_clearDataList(baseObj) {
    if (baseObj.dataList == null) return;
    for (var i = 0; i < baseObj.dataList.length; i++) {
        delete baseObj.dataList[i];
    }
}


//====================================================================================
//XmlHttp 对象
//完成客户端与服务器端的同步或异步通信
//====================================================================================
function XmlHttp() {
    this.createXMLHTTP = function () { return XmlHttp_createXMLHTTP(); }
    this.loadXMLHTTP = function (url , value, beforeFun, completeFun, completeFunData) {
		if (arguments.length == 1) return XmlHttp_loadXMLHTTP_sync(url, this);
		if (arguments.length == 2) return XmlHttp_loadXMLHTTP_post_sync(url, value, this);
        if (arguments.length == 4) return XmlHttp_loadXMLHTTP_async(url, beforeFun, completeFun, completeFunData, this);
        if (arguments.length == 5) return XmlHttp_loadXMLHTTP_post_async(url, value, beforeFun, completeFun, completeFunData, this);
    }
    this.getXMLHTTPText = function (xmlHttpObj) { return XmlHttp_getXMLHTTPText(xmlHttpObj); }
}


//创建XmlHttp对象------------------------------------------------------------------
function XmlHttp_createXMLHTTP() {
    var xmlhttp = null;
    if (window.XMLHttpRequest) {
        xmlhttp = new XMLHttpRequest(); //IE7+,Firefox,Chrome,Opera,Safari
    }
    else {
        xmlhttp = new ActiveXObject("Microsoft.XMLHTTP"); //IE6,IE5
    }
    return xmlhttp;
}

//加载XMLHTTP对象 同步-------------------------------------------------------------
function XmlHttp_loadXMLHTTP_sync(url, baseObj) {
    var str = "";
    var xmlhttp = baseObj.createXMLHTTP();
    xmlhttp.open("get", url, false);
    xmlhttp.send();
    if (xmlhttp.readyState == 4) {
        if (xmlhttp.status == 200) {
            str = xmlhttp.responseText;
        }
        else {
            throw new Error("status:" + xmlhttp.status + ". URL:" + url);
        }
    }
    return str;
}

//加载XMLHTTP对象 异步------------------------------------------------------------
function XmlHttp_loadXMLHTTP_async(url, beforeFun, completeFun, completeFunData, baseObj) {
    var xmlhttp = baseObj.createXMLHTTP();
    xmlhttp.open("get", url, true);
    xmlhttp.onreadystatechange = function () {
        if (xmlhttp.readyState == 4) {
            if (xmlhttp.status == 200) {
                if (completeFun) completeFun(xmlhttp.responseText, completeFunData);
            }
            else {
                throw new Error("status:" + xmlhttp.status + ". URL:" + url);
            }
        }
        else {
            if (beforeFun) beforeFun();
        }
    }
	
    xmlhttp.send();
    return xmlhttp;
}


//加载XMLHTTP对象 POST 同步-------------------------------------------------------------
function XmlHttp_loadXMLHTTP_post_sync(url, value, baseObj) {
    var str = "";
    var xmlhttp = XmlHttp_createXMLHTTP();

    xmlhttp.open("POST", url, false);
    xmlhttp.setRequestHeader("Content-Length", value.length);
    xmlhttp.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
    xmlhttp.send(value);

    if (xmlhttp.readyState == 4) {
        if (xmlhttp.status == 200) str = xmlhttp.responseText;
        else throw new Error("status:" + xmlhttp.status + ". URL:" + url + "&" + value);
    }

    return str;
}

//加载XMLHTTP对象 POST 异步------------------------------------------------------------
function XmlHttp_loadXMLHTTP_post_async(url, value, beforeFun, completeFun, completeFunData, baseObj) {
    var xmlhttp = baseObj.createXMLHTTP();

    xmlhttp.open("POST", url, true);
    xmlhttp.setRequestHeader("Content-Length", value.length);
    xmlhttp.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");

    xmlhttp.onreadystatechange = function () {
        if (xmlhttp.readyState == 4) {
            if (xmlhttp.status == 200) if (completeFun) completeFun(xmlhttp.responseText, completeFunData);
            else throw new Error("status:" + xmlhttp.status + ". URL:" + url + "&" + value);
        }
        else if (beforeFun) beforeFun();
    }
	
    xmlhttp.send(value);
    return xmlhttp;
}


//返回请求字符串------------------------------------------------------------------
function XmlHttp_getXMLHTTPText(xmlHttpObj) {
    var str = xmlHttpObj.responseText;
    return str;
}

//====================================================================================
//XmlDom 对象
//将XmlDom对象与XML文本相互转换
//====================================================================================
function XmlDom() {
    this.xmlDoc = null;
    this.xmlStr = null;
    this.isIE = function () { return XmlDom_isIE(); }
    this.createXmlDom = function () { return XmlDom_createXmlDom(this); }
    this.loadXml = function (xmlStr) { return XmlDom_loadXml(xmlStr, this); }
    this.loadXmlFile = function (xmlFile) { return XmlDom_loadXmlFile(xmlFile, this); }
    this.xml = function (elem) { return XmlDom_xml(elem, this); }
    this.importNode = function (xmlDoc, elem) { return XmlDom_importNode(xmlDoc, elem, this); }
    this.xpath = function (xmlDoc, path) { return XmlDom_xpath(xmlDoc, path, this); }
}

//是否是IE浏览器----------------------------------------------------
function XmlDom_isIE() {
    var isok = null;
    if (window.ActiveXObject) {
        isok = true;
    }
    else if (document.implementation && document.implementation.createDocument) {
        isok = false;
    }
    else {
        throw new Error("XMLDOM对象生成错误.");
    }
    return isok;
}

//创建XMLDOM对象--------------------------------------------------------------
function XmlDom_createXmlDom(baseObj) {
    if (baseObj.isIE()) {
        baseObj.xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
        baseObj.xmlDoc.async = false;
    }
    else {
        baseObj.xmlDoc = document.implementation.createDocument("", "", null);
        baseObj.xmlDoc.async = false;
    }
    return baseObj.xmlDoc;
}

//将XML文本转换成XMLDOM对象----------------------------------------------------
function XmlDom_loadXml(xmlStr, baseObj) {
    baseObj.xmlDoc = baseObj.createXmlDom();
    if (baseObj.isIE()) {
        baseObj.xmlDoc.loadXML(xmlStr);
    }
    else {
        baseObj.xmlDoc = (new DOMParser()).parseFromString(xmlStr, "text/xml");
    }
    return baseObj.xmlDoc;
}

//将XML文件转换成XMLDOM对象----------------------------------------------------
function XmlDom_loadXmlFile(xmlFile, baseObj) {
    baseObj.xmlDoc = baseObj.createXmlDom();
	baseObj.xmlDoc.async=false;
	baseObj.xmlDoc.load(xmlFile);
    return baseObj.xmlDoc;
}

//将XMLDOM对象转换成XML文本----------------------------------------------------
function XmlDom_xml(elem, baseObj) {
    var value = null;
    if (baseObj.isIE()) {
        value = elem.xml;
    }
    else {
        value = (new XMLSerializer()).serializeToString(elem);
    }
    return value;
}

//文档复制--------------------------------------------------------------------
function XmlDom_importNode(xmlDoc, elem, baseObj) {
    if (baseObj.isIE()) {
        return elem;
    }
    else {
        return xmlDoc.importNode(elem, true);
    }
}

//实现XPath操作---------------------------------------------------------------
function XmlDom_xpath(xmlDoc, path, baseObj) {
    var node = null;
    if (baseObj.isIE()) {
        node = xmlDoc.selectSingleNode(path);
    }
    else {
        var items = xmlDoc.evaluate(path, xmlDoc, null, XPathResult.ANY_UNORDERED_NODE_TYPE, null);
        node = items.singleNodeValue;
    }
    return node;
}

//====================================================================================
//DataBrigdeString 对象
//将 XMLDOC内容 转换成 String 对象
//====================================================================================
function DataBrigdeString(xmlDoc) {
    this.xmlDoc = xmlDoc;
    this.xmlTextToObject = function (type, str) { return DataBrigdeString_xmlTextToObject(type, str, this); }
    this.objectToXmlText = function (obj) { return DataBrigdeString_objectToXmlText(obj, this); }
    this.checkValue = function (str) { return DataBrigdeString_checkValue(str, this); }
    this.encode = function (str) { return DataBrigdeString_encode(str, this); }
    this.decode = function (str) { return DataBrigdeString_decode(str, this); }
    this.trim = function (str) { return DataBrigdeString_trim(str, this); }
    this.replaceAll = function (str, s1, s2) { return DataBrigdeString_replaceAll(str, s1, s2, this); }
    this.clearArray = function (arr) { return DataBrigdeString_clearArray(arr, this); }
    this.strToObj = function (type, str) { return DataBrigdeString_strToObj(type, str, this); }
    this.objToStr = function (obj) { return DataBrigdeString_objToStr(obj, this); }
    this.getType = function (obj) { return DataBrigdeString_getType(obj, this); }
}

//XML内容转字符串-----------------------------------------------------------------
function DataBrigdeString_xmlTextToObject(type, str, baseObj) {
    var obj = null;
    str = baseObj.decode(str);
    var alertStr = baseObj.checkValue(str);
    if (alertStr != "") {
        throw new Error("提交内容可能有恶意代码：" + alertStr);
    }
    else {
        obj = baseObj.strToObj(type, str);
    }
    return obj;
}

//字符串转XML内容-----------------------------------------------------------------
function DataBrigdeString_objectToXmlText(obj, baseObj) {
    var str = baseObj.objToStr(obj);
    str = escape(baseObj.encode(str));
    var xmlText = baseObj.xmlDoc.createCDATASection(str);
    return xmlText;
}

//内容验证------------------------------------------------------------------------
function DataBrigdeString_checkValue(str, baseObj) {
    return "";
}

//编码----------------------------------------------------------------------------
function DataBrigdeString_encode(str, baseObj) {
    str = baseObj.trim(str);
    return str;
}

//解码----------------------------------------------------------------------------
function DataBrigdeString_decode(str, baseObj) {
    str = baseObj.trim(str);
    return str;
}

//去除前后空格------------------------------------------------------------------
function DataBrigdeString_trim(str, baseObj) {
    str = new String(str);
    return str.replace(/(^\s*)|(\s*$)/g, "");
}

//批量替换字符------------------------------------------------------------------
function DataBrigdeString_replaceAll(str, s1, s2, baseObj) {
    return str.replace(new RegExp(s1, "gm"), s2);
}

//清空数组---------------------------------------------------------------------
function DataBrigdeString_clearArray(arr, baseObj) {
    if (arr == null) return;
    for (var i = 0; i < baseObj.dataList.length; i++) {
        delete arr[i];
    }
    return arr;
}

//类别转换 字符串转对象----------------------------------------------------------
function DataBrigdeString_strToObj(type, str, baseObj) {
    var value = null;
    if (type == "int") {
        value = parseInt(str);
    }
    else if (type == "float") {
        value = parseFloat(str);
    }
    else if (type == "boolean") {
        if (str == "1" || str.toLowerCase() == "true") {
            value = true;
        }
        else {
            value = false;
        }
    }
    else if (type == "date") {
        value = new Date(str);
    }
    else {
        value = new String(str);
    }
    return value;
}

//类别转换 对象转字符串----------------------------------------------------------
function DataBrigdeString_objToStr(obj, baseObj) {
    var value = "";
    if (obj.constructor == Date) {
        value = "" + obj.getFullYear() + "-" + (obj.getMonth()+1) + "-" + obj.getDate() + " " + obj.getHours() + ":" + obj.getMinutes() + ":" + obj.getSeconds() + "";
    }
    else {
        value = new String(obj);
    }
    return value;
}

//读取对象类型-------------------------------------------------------------------
function DataBrigdeString_getType(obj, baseObj) {
    var type = "string";
    if (obj.constructor == String) {
        type = "string";
    }
    else if (obj.constructor == Boolean) {
        type = "boolean";
    }
    else if (obj.constructor == Number) {
        type = "float";
    }
    else if (obj.constructor == Date) {
        type = "date";
    }
    else {
        type = "string";
    }
    return type;
}

//====================================================================================
//DataBrigdeXmlDoc 对象
//将 XMLDOC内容 转换成 XmlDoc 对象
//====================================================================================
function DataBrigdeXmlDoc(xmlDoc) {
    this.xmlDoc = xmlDoc;
    this.elem = null;
    this.xmlDataToXmlDoc = function (elem) { return DataBrigdeXmlDoc_xmlDataToXmlDoc(elem, this); }
    this.xmlDocToXmlData = function (elem) { return DataBrigdeXmlDoc_xmlDocToXmlData(elem, this); }
}

//向XMLDOC对象插入XML节点-------------------------------------------
function DataBrigdeXmlDoc_xmlDataToXmlDoc(elem, baseObj) {
    var xmlDom = new XmlDom();
    this.elem = xmlDom.importNode(baseObj.xmlDoc, elem);
    return this.elem;
}

//向XMLDOC对象读取XML节点-------------------------------------------
function DataBrigdeXmlDoc_xmlDocToXmlData(elem, baseObj) {
    var xmlDom = new XmlDom();
    this.elem = xmlDom.importNode(baseObj.xmlDoc, elem);
    return this.elem;
}


//====================================================================================
//DataBrigdeTable 对象
//将 XMLDOC 转换成 DataTable 对象
//====================================================================================
function DataBrigdeTable(xmlDoc) {
    this.dt = new DataTable();
    this.xmlDoc = xmlDoc;
    this.elem = null;

    this.xmlToTable = function (elem) { return DataBrigdeTable_xmlToTable(elem, this); }
    this.tableToXml = function (dt) { return DataBrigdeTable_tableToXml(dt, this); }
    this.getXMLType = function (dcType) { return DataBrigdeTable_getXMLType(dcType, this); }
    this.getDCType = function (dcType) { return DataBrigdeTable_getDCType(dcType, this); }
    this.getTableDc = function () { return DataBrigdeTable_getTableDc(this); }
    this.getXMLDc = function () { return DataBrigdeTable_getXMLDc(this); }
    this.getTableDr = function () { return DataBrigdeTable_getTableDr(this); }
    this.getXMLDr = function () { return DataBrigdeTable_getXMLDr(this); }
}

//XML转换成DataTable----------------------------------------
function DataBrigdeTable_xmlToTable(elem, baseObj) {
    baseObj.elem = elem;
    baseObj.dt.name = elem.getAttribute("name");
    baseObj.getTableDc();
    baseObj.getTableDr();
    return baseObj.dt;
}

//DataTable转换成XML----------------------------------------
function DataBrigdeTable_tableToXml(dt, baseObj) {
    baseObj.dt = dt;
    baseObj.elem = baseObj.xmlDoc.createElement("table");
    baseObj.elem.setAttribute("name", dt.name);
    baseObj.elem.setAttribute("length", dt.length);
    baseObj.getXMLDc();
    baseObj.getXMLDr();
    return baseObj.elem;
}

//DataTable的数据类型转换成传输中的数据类型----------------------
function DataBrigdeTable_getXMLType(dcType, baseObj) {
    return dcType;
}

//传输中的数据类型转换成DataTable的数据类型----------------------
function DataBrigdeTable_getDCType(dcType, baseObj) {
    return dcType;
}

//生成数据表字段-------------------------------
function DataBrigdeTable_getTableDc(baseObj) {
    var dc = new Array();
    var elemList = baseObj.elem.firstChild.childNodes;
    for (var i = 0; i < elemList.length; i++) {
        dc.push(new DataColumn(elemList[i].getAttribute("name"), elemList[i].getAttribute("type")));
    }
    baseObj.dt.Columns = dc;
}

//生成XML字段节点-------------------------------
function DataBrigdeTable_getXMLDc(baseObj) {
    var columnsElem = null;
    var valueElem = null;
    columnsElem = baseObj.xmlDoc.createElement("columns");
    for (var i = 0; i < baseObj.dt.Columns.length; i++) {
        valueElem = baseObj.xmlDoc.createElement("value");
        valueElem.setAttribute("name", baseObj.dt.Columns[i].name);
        valueElem.setAttribute("type", baseObj.getXMLType(baseObj.dt.Columns[i].type));
        columnsElem.appendChild(valueElem);
    }
    baseObj.elem.appendChild(columnsElem);
}


//生成数据表行----------------------------------
function DataBrigdeTable_getTableDr(baseObj) {
    var dataBrigdeString = new DataBrigdeString(baseObj.xmlDoc);
    var elemRows = null;
    var elemValue = null;
    var name = "";
    var value = "";
    var obj = null;
    var dr = new Array();
    var dc = new Array();
    baseObj.Rows = dataBrigdeString.clearArray(baseObj.Rows);
    var rowsList = baseObj.elem.childNodes;

    for (var i = 0; i < rowsList.length; i++) {
        elemRows = rowsList[i];
        if (elemRows.nodeName == "rows") {
            dc = new Array();
            for (var j = 0; j < elemRows.childNodes.length; j++) {
                obj = new Object();
                elemValue = elemRows.childNodes[j];
                value = dataBrigdeString.xmlTextToObject(elemValue.getAttribute("type"), elemValue.firstChild.nodeValue);
                dc[j] = value;
            }
            dr.push(dc);
        }
    }
    baseObj.dt.Rows = dr;
    baseObj.dt.length = baseObj.dt.Rows.length;
}

//生成XML数据行----------------------------------
function DataBrigdeTable_getXMLDr(baseObj) {
    var dataBrigdeString = new DataBrigdeString(baseObj.xmlDoc);
    var rowsElem = null;
    var valueElem = null;
    var row = null;
    var vlaue = "";

    for (var i = 0; i < baseObj.dt.Rows.length; i++) {
        row = baseObj.dt.Rows[i];
        rowsElem = baseObj.xmlDoc.createElement("rows");
        rowsElem.setAttribute("line", i);
        for (var j = 0; j < row.length; j++) {
            valueElem = baseObj.xmlDoc.createElement("value");
            valueElem.setAttribute("name", baseObj.dt.Columns[j].name);
            valueElem.setAttribute("type", baseObj.dt.Columns[j].type);
            vlaue = dataBrigdeString.objectToXmlText(baseObj.dt.Rows[i][j]);
            valueElem.appendChild(vlaue);
            rowsElem.appendChild(valueElem);
        }
        baseObj.elem.appendChild(rowsElem);
    }
}

//====================================================================================
//DataBrigdeHash 对象
//将 XMLDOC 转换成 HashTable 对象
//====================================================================================
function DataBrigdeHash(xmlDoc) {
    this.ht = new HashTable();
    this.xmlDoc = xmlDoc;
    this.elem = null;
    this.xmlToHash = function (elem) { return DataBrigdeHash_xmlToHash(elem, this); }
    this.hashToXml = function (ht) { return DataBrigdeHash_hashToXml(ht, this); }
}

//XML节点转换成Hash表--------------------------------------------
function DataBrigdeHash_xmlToHash(elem, baseObj) {
    baseObj.elem = elem;
    var value = "";
    var hashElem = null;
    var dataBrigdeString = new DataBrigdeString(this.xmlDoc);
    for (var i = 0; i < baseObj.elem.childNodes.length; i++) {
        hashElem = baseObj.elem.childNodes[i];
        value = dataBrigdeString.xmlTextToObject(hashElem.getAttribute("type"), hashElem.firstChild.nodeValue);
        baseObj.ht.add(hashElem.getAttribute("key"), value);
    }
    return baseObj.ht;
}

//Hash表转换成XML节点--------------------------------------------
function DataBrigdeHash_hashToXml(ht, baseObj) {
    baseObj.ht = ht;
    var dataBrigdeString = new DataBrigdeString(baseObj.xmlDoc);
    baseObj.elem = baseObj.xmlDoc.createElement("hash");
    var valueElem = null;
    for (var i = 0; i < ht.count(); i++) {
        valueElem = baseObj.xmlDoc.createElement("value");
        valueElem.setAttribute("key", ht.keys()[i]);
        valueElem.setAttribute("type", dataBrigdeString.getType(ht.values()[i]));
        valueElem.appendChild(dataBrigdeString.objectToXmlText(ht.values()[i]));
        baseObj.elem.appendChild(valueElem);
    }
    return baseObj.elem;
}

//====================================================================================
//DataTable 对象
//模拟服务器端DataTable对象
//====================================================================================
function DataTable() {
    this.name = new String;
    this.length = new Number;

    this.Rows = new Array();
    this.Columns = new Array();

    this.value = function (row, column) { return DataTable_value(row, column, this); }

    this.arrRows = function (columns) {
        if (arguments.length == 0) return baseObj.Rows;
        if (arguments.length == 1) return DataTable_arrRows(columns, this);
    }
    this.arrColumns = function () { return DataTable_arrColumns(this); }

	this.search=function(key,value){ return DataTable_search(key,value,this); }
}

//DataRow 对象--------------------------------------------------------------------------------
function DataRow(name,value) {
    this.name = name;
    this.value = value;
}

//DataColumn 对象--------------------------------------------------------------------------------
function DataColumn(name,type) {
    this.name = name;
    this.type = type;
}

//读取字段数组---------------------------------------------------------------------------
function DataTable_arrColumns(baseObj) {
    return baseObj.Columns;
}

//读取数据数组---------------------------------------------------------------------------
function DataTable_arrRows(columns, baseObj) {
    var columnsNum = new Array();
    var dr = new Array();
    var dc = null;

    for (var i = 0; i < columns.length; i++) {
        for (var j = 0; j < baseObj.Columns.length; j++) {
            if (baseObj.Columns[j].name.toLowerCase() == columns[i].toLowerCase()) {
                columnsNum.push(j);
            }
        }
    }

    for (var i = 0; i < baseObj.Rows.length; i++) {
        dc = new Array();
        for (var j = 0; j < columnsNum.length; j++) {
            dc.push(baseObj.Rows[i][columnsNum[j]]);
        }
        dr.push(dc);
    }

    return dr;
}

//读取数据表内容-------------------------------------------------------------------------
function DataTable_value(row, column, baseObj) {
    if(baseObj.Rows.length<(row+1)) return null;
	var value = "";
    if (typeof (column) == "number") {
        value = baseObj.Rows[row][column];
    }
    else if (typeof (column) == "string") {
        for (var i = 0; i < baseObj.Columns.length; i++) {
            if (baseObj.Columns[i].name.toLowerCase() == column.toLowerCase()) {
                value = baseObj.Rows[row][i];
				break;
            }
        }
    }
    return value;
}

//检索内容-------------------------------------------------------------------------------

function DataTable_search(key,value,baseObj)
{
	var num=0;
	for(var i=0;i<baseObj.Rows.length;i++)
	{
		if(baseObj.value(i,key)==value)
		{
			num=i;
			break;
		}
	}
	return num;
}


//====================================================================================
//HashTable 对象
//针对 HashTable 相关操作
//====================================================================================
function HashTable() {
    this._hash = new Object();
    this.add = function (key, value) {
        if (typeof (key) != "undefined") {
            if (this.contains(key) == false) {
                this._hash[key] = (typeof (value) == "undefined" ? null : value);
                return true;
            } else {
                return false;
            }
        } else {
            return false;
        }
    }
    this.remove = function (key) { delete this._hash[key]; }
    this.count = function () { var i = 0; for (var k in this._hash) { i++; } return i; }
    this.value = function (key) { return this._hash[key]; }
    this.contains = function (key) { return typeof (this._hash[key]) != "undefined"; }
    this.clear = function () { for (var k in this._hash) { delete this._hash[k]; } }
    this.keys = function () { var arr = new Array(); for (var key in this._hash) { arr.push(key); } return arr; }
    this.values = function () { var arr = new Array(); for (var key in this._hash) { arr.push(this._hash[key]); } return arr; }
}

//====================================================================================
//Data 对象
//规定客户端与服务器端数据传输格式
//name 数据名称
//type 数据格式 主要定3种：string, datatable, xmlDoc
//value 数据内容 将根据 type 格式不种在传输过程中进行不同格式转换
//====================================================================================
function Data(name, type, value) {
    this.name = new String();
    this.type = new String();
    this.value = new Object();

    if (arguments.length == 2) {
        this.name = arguments[0];
        this.type = null;
        this.value = arguments[1];
    }
    else if (arguments.length == 3) {
        this.name = arguments[0];
        this.type = arguments[1];
        this.value = arguments[2];
    }
    else {
    }
}