<!--// 2006 Intelygenz  - www.intelygenz.com <%//-->

i_marray_nVersion=0.256;

/* 2006 Intelygenz  - www.intelygenz.com
	[VER] 	 M:\ig_intelygenz\ig05_intranet\desarrollo\areas\dev\docs\i_marray.txt
	[UPDATE] M:\ig_intelygenz\ig05_intranet\desarrollo\areas\dev\libs\js\i_marray.js
		Open -> i_core.js, i_igz.js
*/
if (!oCore.m_bIsServer){
	oIGZ.f_loadLib("i_marray", i_marray_nVersion);
}
var i_marray_nInstances = 0;

function MArray(a_sCOLs, a_aROWs){
	i_marray_nInstances++;
	this.m_sObj		= "[NotAnObject] MArray_instance_"+i_marray_nInstances;
	this.m_nVersion = i_marray_nVersion;
	this.m_sKeyName = "[MArray v"+this.m_nVersion+"]";

	this.m_a_sCOLs  = a_sCOLs;	//Campos  (Strings)
	if(!a_aROWs) a_aROWs = []
	this.m_a_aROWs  = a_aROWs;	//Valores (Arrays)

	if (this.m_a_aROWs.length && this.m_a_sCOLs.length!=this.m_a_aROWs[0].length && !(this.m_a_aROWs.length==1 && this.m_a_aROWs[0].length==0) ) {
		ErrorJS("["+this.m_sKeyName +"] MArray invalido: número de campos ("+this.m_a_sCOLs.length+") distinto del número de valores de cada campo ("+this.m_a_aROWs[0].length+")\n\nCOLs:\n"+ this.m_a_sCOLs + "\nVALs:\n"+this.m_a_aROWs[0]+ "\n")
	}


	// TOOLs (Utilidades)
	//
	this.f_fillFromOldMArray = function (maOldMArray, bDelete){
		if(bDelete) this.m_a_aROWs = [];
		this.m_a_sCOLs = maOldMArray[0];
		var nCols 	  = this.m_a_sCOLs.length;
		var f = -1, F = maOldMArray.f_maGetRegs();
		while ( ++f < F ) {
			this.f_addRow( maOldMArray[1].slice(f*nCols, (f*nCols)+nCols) );
		}
	}
	this.f_debug = function (bHTML, bAll){
		var sReg="COLs.\n ["+this.m_a_sCOLs+"]\nROWs.\n";
		if(bAll || this.f_length()<6){
			for (var f=0; f<this.f_length(); f++){
				sReg+="("+f+") ["+this.m_a_aROWs[f]+"]\n";
			}
		}
		else {
			var nResumen = 3;
			for (var f=0; f<nResumen; f++){ sReg+="("+f+") ["+this.m_a_aROWs[f]+"]\n"; }
			sReg+=". . .\n";
			for (var f=this.f_length()-nResumen; f<this.f_length(); f++){ sReg+="("+f+") ["+this.m_a_aROWs[f]+"]\n"; }
		}
		sReg+="Total Reg. "+this.f_length();
		sReg = this.m_sKeyName+" - DEBUG\n"+sReg;
		if(bHTML) sReg = sReg.f_replace("\n", "<BR />");
		return (sReg);
	}

	this.f_getColPos = function (sColName){
		var nCol = this.m_a_sCOLs.f_indexOf(sColName)
		//if (nCol==-1) ErrorJS(FunCaller()+"["+this.m_sKeyName+".f_getColPos] no existe el campo ["+sColName+"] en el MArray ["+this.m_a_sCOLs+"]");
		return (nCol);
	}
	this.f_getColName = function (nColPos){
		var sCol = this.m_a_sCOLs [nColPos]
		//if (nCol==-1) ErrorJS(FunCaller()+"["+this.m_sKeyName+".f_getColPos] no existe el campo ["+sColName+"] en el MArray ["+this.m_a_sCOLs+"]");
		return (sCol);
	}

	this.f_getCols = function (){ return (this.m_a_sCOLs.length); }

	// Devuelve una copia del array de columnas
	this.f_subCols = function (){ return ([].concat(this.m_a_sCOLs)); }

	// Vacia el MArray
	this.f_clean = function (){ this.m_a_aROWs=[]; }

	this.f_subColsPos = function (a_sColName){
		var nColPos, a_nCols=[];
		for(var f=0; f<a_sColName.length; f++){
			nColPos  = this.f_getColPos(a_sColName[f]);
			if (nColPos!=-1) a_nCols.push(nColPos);
		}
		return(a_nCols);
	}


	this.f_addColEXML=function (sCampo,sEXML){
		oIEXML.f_addColEXML (this,sCampo,sEXML)
	}

	this.f_modColEXML=function (sCampo,sEXML){
		oIEXML.f_modColEXML (this,sCampo,sEXML)
	}

	this.f_concat = function (maData){
		this.m_a_aROWs = this.m_a_aROWs.concat( maData.m_a_aROWs );
	}

	// Operaciones Booleanas: por defecto se modifica el MArray
	// nReturn = 1 : Devuelve a_aROWs resultante
	// nReturn = 2 : Devuelve maMArray resultante
	// nType = -1 : Elimina las filas de maOtherData que coincidan con this
	this.f_boolean = function (maOtherData, nType, nReturn) {
		if( IsMArrayOld(maOtherData) ) {
			maOtherDataTmp = new MArray();
			maOtherDataTmp.f_fillFromOldMArray(maOtherData);
			maOtherData = maOtherDataTmp;
		}
		var a_nRegs = [];
		var f, F;
		switch (nType) {
			case -1:
				for ( var f=0, F=maOtherData.f_length(); f<F; f++ ) {
					a_nRegs = a_nRegs.concat( this.f_subIndexOf(this.f_subCols(), maOtherData.f_getRow(f)) );
				}
				this.f_delRows( a_nRegs );
				break;
			default :
				break;
		}

		var vReturn = null;
		switch ( nReturn ) {
			case 1 :
				vReturn = this.f_subRows(a_nRegs);
				break;
			case 2 :
				vReturn = this.f_subRows(a_nRegs, 1);
				break;
		}
		return vReturn;
	}


	// ADDs (Añaden valores)
	//
	this.f_addRow = function(a_vRow, nReg, bReplace){
		if(IsNull(a_vRow) || a_vRow==""){
			a_vRow = [];
			for(var f=0, F = this.f_getCols(); f<F; f++){
				a_vRow.push("");
			}
		}
		if (bReplace) {
			this.m_a_aROWs[nReg] = a_vRow;
		}
		else {
			this.f_addRows([a_vRow], nReg);
		}
	}

	this.f_addRows = function(a_aRows, nReg){
//		alert(String(GetType(a_aRows[0])).toUpperCase().indexOf("FUNCTION ARRAY()")+" _ "+(String(GetType(a_aRows[0])).toUpperCase().indexOf("FUNCTION ARRAY()")!=-1))
/*		if (!IsArray(a_aRows[0])){
			alert( [[1],[2]][0].constructor==Array )
			a_aRows = [a_aRows];
		}
	*/	if((!nReg && nReg!=0) || nReg>=this.f_length()) {
			this.m_a_aROWs=this.m_a_aROWs.concat(a_aRows);
		}
		else {
			var a_vArray = this.m_a_aROWs.slice(0, nReg);
			a_vArray = a_vArray.concat(a_aRows);
			a_vArray = a_vArray.concat(this.m_a_aROWs.slice(nReg, this.f_length()));
			this.m_a_aROWs=a_vArray;
		}
	}

	this.f_addCol = function(sColName, a_vVALs){
		if (IsArray(a_vVALs)) {
			if (a_vVALs.length!=this.f_length()) ErrorJS("["+this.m_sKeyName+".f_addCol] Número incorrecto de valores. ["+a_vVALs+"]("+a_vVALs.length+") -> ("+this.f_length+")");
		}
		else {
			if (IsNull(a_vVALs)) {
				a_vVALs=new Array(this.f_length());
			}
			else {
				var sVal = a_vVALs
				a_vVALs=new Array();
				for (var f=0; f<this.f_length(); f++) a_vVALs.push(sVal);
			}
		}
		this.m_a_sCOLs[this.m_a_sCOLs.length]=sColName;
		for (var f=0; f<this.f_length(); f++){
			this.m_a_aROWs[f].push(a_vVALs[f]);
		}
	}

	//SETs y MODs (Asignan valores o modifican el MArray)
	//
	this.f_setVal = function (sColName, vVal, nReg){
		var nColPos = this.f_getColPos(sColName);
		if (nColPos!=-1) {
			this.m_a_aROWs[nReg][nColPos] = vVal;
		}
		else ErrorJS(FunCaller()+"["+this.m_sKeyName+".f_setVal] no existe el campo ["+sColName+"] en el MArray ["+this.m_a_sCOLs+"]");
	}

	this.f_setValIf = function (a_sColNameIn, a_vValIn, sColNameOut, vValOut, bFirst, bLast){
		if(!IsArray(a_sColNameIn)){
			a_sColNameIn = [a_sColNameIn];
			a_vValIn	 = [a_vValIn];
		}
		var a_nRegs = this.f_subIndexOf(a_sColNameIn, a_vValIn);

//		if (a_nRegs!=-1){	//v0.217
		if (a_nRegs.length) {
			var f=-1;
			if (bFirst) this.f_setVal(sColNameOut, vValOut, a_nRegs[0]);
			else if (bLast) this.f_setVal(sColNameOut, vValOut, a_nRegs[a_nRegs.length-1]);
			else {
				while(++f<a_nRegs.length){
					this.f_setVal(sColNameOut, vValOut, a_nRegs[f]);
				}
			}
		}
	}

	//GETs (Devuelven valores)
	//
	this.f_length = function (){ return (this.m_a_aROWs.length); }

	this.f_getCol = function (sColName){
		var nColPos = this.f_getColPos(sColName);
		var a_vCol  = [];
		if (nColPos==-1) ErrorJS(FunCaller()+"["+this.m_sKeyName+".f_getCol] no existe el campo ["+sColName+"] en el MArray ["+this.m_a_sCOLs+"]");
		var f=this.f_length();
		while (--f>=0) {
			a_vCol.push(this.m_a_aROWs[f][nColPos]);
		}
		return (a_vCol.reverse());
	}

	this.f_getVal = function (sColName, nReg, sReturn){
		if (isNaN(nReg) || nReg<0 || nReg>=this.f_length() ) {
			if (IsUndefined(sReturn)) ErrorJS (FunCaller()+"["+this.m_sKeyName+".f_getVal] no existe el registro "+nReg+".El MArray tiene "+this.f_length() +". Campo: ("+this.m_a_sCOLs+")")
		}
		else {
			var nCol = this.f_getColPos(sColName);
			if(nCol!=-1) sReturn = this.m_a_aROWs[nReg][nCol];
			else if (IsUndefined(sReturn)) ErrorJS ("["+this.m_sKeyName+".f_getVal] no existe la columna '"+sColName+"' en el MArray ("+this.m_a_sCOLs+")");
		}
		return (sReturn);
	}

	this.f_getValIf = function (sColIf, sValIf, sColReturn, vValReturn, bLast){
		var nReg = this.f_getReg(sColIf, sValIf, bLast);
		if(nReg!=-1) vValReturn = this.f_getVal(sColReturn, nReg);
		return (vValReturn);
	}

	this.f_subDistinctSub = function (a_nRegs,sCampo,bIndices) {
		var a_sRegs = this.f_subVals (sCampo, a_nRegs)

		var a_nRegsF = a_sRegs.f_subDistinct(1);
		if (bIndices) {
			a_nRegsF = a_nRegs.f_getVals (a_nRegsF)
		}
		else {
			a_nRegsF = a_sRegs.f_getVals (a_nRegsF);
		}
		return (a_nRegsF);
	}

	this.f_subDistinct = function(sCampo,bIndices,bCaseDependiente,bRepetidos,bOrdenados){
		var a_vDistinct = []
		var a_vCol = this.f_getCol (sCampo)
		if (a_vCol.length) a_vDistinct = a_vCol.f_subDistinct (bIndices,!bCaseDependiente,bRepetidos,!bOrdenados)
		return (a_vDistinct)
	}

	this.f_subVals = function (a_sColName, a_nRegs, bReturnMA){
		if (bReturnMA) a_sColName = this.m_a_sCOLs;
		else if (!IsArray(a_sColName)) a_sColName = [a_sColName];
		if (!a_nRegs) a_nRegs = [0];
		else if (!IsArray(a_nRegs)) a_nRegs = [a_nRegs];
		var a_vROWs	  = [];
		var a_vVals   = [];
		var a_nColPos = this.f_subColsPos(a_sColName);

		var nREGs = a_nRegs.length;
		var nCOLs = a_nColPos.length;
		for(var f=0; f<nREGs; f++){
			a_vVals = [];
			for(var g=0; g<nCOLs; g++){
				a_vVals.push(this.m_a_aROWs[a_nRegs[f]][a_nColPos[g]]);
			}
			a_vROWs.push(a_vVals);
		}
//		if (a_vROWs.length==0) a_vROWs = -1;		// v0.216
		if(bReturnMA){
//			if(a_vROWs!=-1) a_vROWs = new MArray(this.m_a_sCOLs, a_vROWs);		//v0.216
			if(a_vROWs.length) a_vROWs = new MArray(this.m_a_sCOLs, a_vROWs);
			else a_vROWs = new MArray(this.m_a_sCOLs);
		}
		return (a_vROWs);
	}

	this.f_subValsIf = function (sColIf, sValIf, a_sColsReturn, bCaseInd, bDist, bReturnMA, bIndices){
		var a_nRegs = this.f_subRegs(sColIf, sValIf, bCaseInd);
		if (bDist) {
			var a_sColName = a_sColsReturn
			if (IsArray(a_sColsReturn)) a_sColName = a_sColsReturn[0];
			a_nRegs = this.f_subDistinctSub (a_nRegs,a_sColName,1)

//			var a_sRegs = this.f_subVals (a_sColsReturn, a_nRegs)
//			var a_nRegs2 = a_sRegs.f_subDistinct (1)
//			a_nRegs = a_nRegs.f_getVals(a_nRegs2)
		}
		if (!bIndices) a_nRegs = this.f_subVals(a_sColsReturn, a_nRegs, bReturnMA);
		return (a_nRegs);
	}

	this.f_subRegs  = function (sColName, vVal, bCaseInd){
		var a_nRegs = [];
		var f;
		var nColPos = this.f_getColPos(sColName);
		if (bCaseInd) {
			for (f=0; f<this.f_length(); f++) {
				if (this.m_a_aROWs[f][nColPos].toUpperCase()==vVal.toUpperCase()) a_nRegs.push(f);
			}
		}
		else {
			for (f=0; f<this.f_length(); f++){
				if(this.m_a_aROWs[f][nColPos]==vVal) a_nRegs.push(f);
			}
		}
		return (a_nRegs);
	}

	this.f_getReg = function (sColName, vVal, bLast){
		var nRegPos = -1
		var nColPos = this.f_getColPos(sColName);
		if (nColPos!=-1) {
			var nReg = 0
			if (bLast) {
				nReg = this.f_length()-1;
				while(nReg>-1 && nRegPos==-1){
					if(this.m_a_aROWs[nReg][nColPos]==vVal) nRegPos = nReg;
					nReg--;
				}
			}
			else {
				while (nReg<this.f_length() && nRegPos==-1) {
					if (this.m_a_aROWs[nReg][nColPos]==vVal) nRegPos = nReg;
					nReg++;
				}
			}
		}
		return (nRegPos);
	}

	this.f_subRows = function (a_nRegs, bReturnMA){
		var a_aROWs = [];
		for(var f=0; f<a_nRegs.length; f++){
			a_aROWs[a_aROWs.length]=this.m_a_aROWs[a_nRegs[f]];
		}
		if(bReturnMA) a_aROWs = new MArray(this.m_a_sCOLs, a_aROWs);
		return (a_aROWs);
	}
	this.f_getRow = function (nReg, bReturnMA){
		var a_vROW = this.m_a_aROWs[nReg];
		if(bReturnMA) a_vROW = new MArray(this.m_a_sCOLs, [a_vROW]);
		return (a_vROW);
	}
	this.f_subRowsIf = function (a_sColName, a_vColVal, bNot, bLike, bReturnMA){
		var a_nRegs = this.f_subIndexOf(a_sColName, a_vColVal, bNot, bLike);
		return ( this.f_subRows(a_nRegs, bReturnMA) );
	}

	this.f_subIndexOf = function(a_sColName, a_vColVal, bNot, bLike, bIndices, bCaseDep, bParte, bAcentoDep, bRepetidos,bDistinto){
		if(IsArray(a_sColName) || arguments.length<5){
			if(!IsArray(a_sColName)){
				a_sColName = [a_sColName];
				a_vColVal  = [a_vColVal];
			}
			var nCol	 = 0;
			var vColVal  = a_vColVal[nCol];
			var a_nRegs = [], a_vCol = this.f_getCol(a_sColName[nCol]);
			var n = a_vCol.length;
			if (bNot){
				while(--n>=0) {
					if(a_vCol[n]!=vColVal) a_nRegs.push(n);
				}
			}
			else {
				if (bLike){
					while(--n>=0) {
						if (a_vCol[n].indexOf(vColVal)!=-1) a_nRegs.push(n);
					}
				}
				else {
					while(--n>=0) {
						if(a_vCol[n]==vColVal) a_nRegs.push(n);
					}
				}
			}
			if (a_sColName.length>1){	// Busqueda múltiple
				var a_nRegs_tmp;
				while(++nCol<a_sColName.length){
					a_vCol  = this.f_getCol(a_sColName[nCol])
					vColVal = a_vColVal[nCol];
					n = a_nRegs.length;
					a_nRegs_tmp = [];
					if (bNot){
						while(--n>=0) {
							if(a_vCol[a_nRegs[n]]!=vColVal) a_nRegs_tmp.push(a_nRegs[n]);
						}
					}
					else {
						if (bLike) {
							while(--n>=0) {
								if(a_vCol[a_nRegs[n]].indexOf(vColVal)!=-1) a_nRegs_tmp.push(a_nRegs[n]);
							}
						}
						else {
							while(--n>=0) {
								if(a_vCol[a_nRegs[n]]==vColVal) a_nRegs_tmp.push(a_nRegs[n]);
							}
						}
					}
					a_nRegs=a_nRegs_tmp;
				}
			}
//			if(a_nRegs.length==0) a_nRegs = -1		//	v0.217
//			else
			if(a_nRegs.length && (a_sColName.length & 1)) a_nRegs = a_nRegs.reverse();

			return (a_nRegs);
		}
		else {
			var a_vSub = [];
			var a_vCol = this.f_getCol(a_sColName);
			if (a_vCol.length) {
				if(!IsArray(a_vColVal)) a_vColVal = [a_vColVal];
				for (var f=0;f<a_vColVal.length;f++){
					a_vSub = a_vSub.concat(a_vCol.f_subIndexOf (a_vColVal[f],bIndices,bCaseDep,bParte,bAcentoDep,0,0,bDistinto));
				}
				if (a_vColVal.length>1 && !bRepetidos) a_vSub = a_vSub.f_subDistinct (0,!bCaseDep,bRepetidos,1);
			}
			return (a_vSub);
		}
	}


	this.f_getClone = function (){
		return ( new MArray([].concat(this.m_a_sCOLs), [].concat(this.m_a_aROWs)) );
	}

	this.f_sumaCampos = function (a_sCampos,a_nRegs){
		if(!IsArray(a_nRegs)) a_nRegs = [a_nRegs];
		var maValores = this.f_subValByRegs (a_sCampos, a_nRegs)
		var a_sValores = new Array()
		for (var f=0;f<a_nRegs.length;f++) {
			a_sValores = a_sValores.concat(maValores[f])
		}
//alert(a_sCampos +"\n"+a_nRegs+"\n"+a_sValores+"\n"+a_sValores.length+"\n"+a_sValores.f_suma())
		return (a_sValores.f_suma())
	}

	this.f_sumaCol = function (sCampo) {
		return (this.f_sumaColIf(sCampo));
	}

	this.f_sumaColIf = function (sCampo,sCampoIf,sValueIf,bDist){
		var a_sValores = [];
		if (sCampoIf) {
			a_sValores = this.f_subValsIf (sCampoIf, sValueIf, sCampo, null, bDist);
		}
		else {
			a_sValores = this.f_getCol (sCampo);
		}
		return (a_sValores.f_suma());
	}

	// Solo admite AND y OR y % en los valores, ni los nombres de las columnas ni los valores son CaseSensitive.
	//	ej1: sSearch="Nombre='Jonas' AND Apellido='Da Cruz'"
	//	ej2: sSearch="Nombre='Jonas' OR Empresa='Intelygenz' OR Empresa='IGZ'"
	//	ej3: sSearch="Nombre='%nas' OR Empresa='Int%'"
	this.f_search = function(sSearch){ }


	//Da un subarray de un marray con los camposOut de los registros a_nRegs
	// [a_sCampoOut] : Por defecto devuelve todos los campos
	this.f_subValByRegs = function (a_sCampoOut, a_nRegs){
		var a_vVals=new Array();
		if(a_sCampoOut && !IsArray(a_sCampoOut)) a_sCampoOut = [a_sCampoOut];
		if(!a_sCampoOut || a_sCampoOut.length==0) a_sCampoOut = this.m_a_sCOLs;
		for(var f=0; f<a_nRegs.length; f++){
			a_vVals[f] = [];
			for(var g=0; g<a_sCampoOut.length; g++){
				a_vVals[f][g]=this.f_getVal(a_sCampoOut[g], a_nRegs[f]);
			}
		}
		return (a_vVals);
	}

	// Sorts
	//
	this.f_sort = function(sCampo,bIndices,bDesc,sNewCol,nOrden,bCaseDependiente){
		var a_vOrdenado = []
		var a_vCol = this.f_getCol(sCampo);
		if (a_vCol.length) a_vOrdenado = a_vCol.f_sort (bIndices,bDesc,nOrden,bCaseDependiente)
		if(sNewCol) this.f_addCol(sNewCol, a_vOrdenado);
		return (a_vOrdenado);
	}

	//NO USAR !!!
	this.f_multiSortBETA = function (a_sCamposSort, bIndices, sNewCol, bTrace){
		var f, g, h, nInc, sCampoOld, a_vCol, a_nIndices, a_nSub, a_nSubInd, a_nSubNew;
		var sDescKey = "<DESC>";
		var sTrace = ""

		var sCampo = a_sCamposSort[0];
		var bDesc  = 0;
		var nOrden = sCampo.toUpperCase().indexOf(sDescKey);
		if(nOrden!=-1){
			bDesc  = 1;
			sCampo = sCampo.substring(nOrden);
		}
		sCampo=sCampo.f_trim();
		a_vValores=this.f_sort(sCampo, 0, bDesc);
		a_nIndices=this.f_sort(sCampo, 1, bDesc);
sTrace+="Odenado por: "+sCampo+((bDesc)? " DESC" : " ASC")+"\n";
sTrace+="--a_vValores["+a_vValores+"]\n";
sTrace+="--a_nIndices["+a_nIndices+"]\n";
sTrace+="\n";
		for(f=1; f<a_sCamposSort.length; f++){
			sCampo=a_sCamposSort[f];
			bDesc=0;
			nOrden=sCampo.toUpperCase().indexOf(sDescKey);
			if(nOrden!=-1){
				bDesc=1
				sCampo=sCampo.substring(nOrden);
			}
			sCampo=sCampo.f_trim();
			g=0;
sTrace+="Odenando por: "+sCampo+((bDesc)? " DESC" : " ASC")+"\n";
			while(g<a_nIndices.length){
				a_nSub=a_vValores.f_subIndexOf( a_vValores[g], 1);			//subarray con indices de los valores repetidos
				if(a_nSub.length>1){
					a_sSub=this.f_subValByRegs(sCampo, a_nSub);			//subarray con los valores del nuevo campo de cada uno de esos indices
					a_nSub=a_sSub.f_sort(1, bDesc);							//subarray ordenado de indices
sTrace+="---ordenando subarrays de elementos repetidos: "+a_vValores[g]+"\n"
sTrace+="-----a_nSub["+a_nSub+"]\n"
					a_nSubInd=a_nIndices.slice(g, g+a_nSub.length);			//Ordeno subarray de indices a partir del orden de a_nSub
sTrace+="-----creando subarray de indices a_nIndices de ("+g+" a "+(a_nSub.length+1)+"\n";
					a_nSubNew=new Array(a_nSubInd.length);
sTrace+="---aplicando suborden de a_nSub["+a_nSub+"] a a_nSubInd["+a_nSubInd+"]\n";
					for(h=0; h<a_nSubInd.length; h++){
						a_nSubNew[a_nSub[h]]=a_nSubInd[h]
					}
sTrace+="---borrando indices: a_nIndices["+a_nIndices+"]\n"
					a_nIndices=a_nIndices.f_delete(g, a_nSub.length);	//borro el tramo anterior que no esta ordenado
sTrace+="-----de "+g+" hasta "+a_nSub.length;
sTrace+="-----borrados -> a_nIndices["+a_nIndices+"]\n"

sTrace+="---insertando indices nuevos:\n";
sTrace+="-----a_nSubNew["+a_nSubNew+"]\n";
					a_nIndices=a_nIndices.f_insert(a_nSubNew, g);			//inserto el nuevo tramo ordenado
sTrace+="-----a_nIndices["+a_nIndices+"]\n";
				}
				nInc=a_nSub.length;
				if(nInc==0) nInc=1;
				g+=nInc;													//siguiente tramo
			}
			a_vValores=this.f_subValByRegs(sCampo, a_nIndices);			//actualizo subarray de valores ordenado por el nuevo campo
sTrace+="--a_vValores["+a_vValores+"]\n";
sTrace+="--a_nIndices["+a_nIndices+"]\n";
sTrace+="-------------------------------------------------\n";
		}
sTrace+="--a_vValores["+a_vValores+"]\n";
sTrace+="--a_nIndices["+a_nIndices+"]\n";
if(bTrace) ErrorJS("["+this.m_sKeyName+".f_maMultiSort] [TRACE] (Esto NO es un ERROR):\n"+sTrace);
		if(sNewCol) this.f_addCol(sNewCol, a_nIndices);
		if(bIndices) return (a_nIndices);
	}

	//DELs (Borran valores)
	//
	this.f_delRows = function (a_nRegPos, nRegs){
		if ( !IsArray( a_nRegPos ) ) {
			var nRegPos = a_nRegPos;
			if (nRegPos!=0 && !nRegPos) nRegPos = this.f_length()-1;
			if (!nRegs || nRegPos+nRegs>this.f_length()) nRegs = 1;
			this.m_a_aROWs = this.m_a_aROWs.f_delete(nRegPos, nRegs)
		}
		else {
			a_nRegPos = a_nRegPos.sort().reverse();
			for ( var f=0, F=a_nRegPos.length; f<F; f++ ) {
				this.m_a_aROWs = this.m_a_aROWs.f_delete(a_nRegPos[f], 1);
			}			
		}
	}
	this.f_delRow = function (nRegPos){ this.f_delRows(nRegPos, 1); }

	this.f_delRowIf = function (sColIf, vColIf){
		var nReg = this.f_getReg(sColIf, vColIf);
		if(nReg!=-1) this.f_delRow(nReg);
	}

	this.f_delRowsIf = function (a_sColName, a_vColVal, bNot, bLike){
		var a_nRegs = this.f_subIndexOf(a_sColName, a_vColVal, bNot, bLike);
		for(var f=0, F=a_nRegs.length; f<F; f++){
			this.f_delRow(a_nRegs[f]);
		}
	}


	//Retro-Compatibilidad
	//
	this.f_maAddCol 	= function (sNewCol,vValor){ this.f_addCol(sNewCol, vValor); }
	this.f_maDeleteRow  = function (nRegPos,nRegs){ this.f_delRow(nRegPos, nRegs) }
	this.f_maDebug		= function (){ return( this.f_debug() ); }
	this.f_maGetColPos 	= function (sCampo){ return (this.f_getColPos(sCampo)); }
	this.f_maSetValIf   = function (sCampoIf,sValueIf,sCampo,vValue, bAddIfNot){ this.f_setValIf(sCampoIf, sValueIf, sCampo, vValue); }
	this.f_maGetRegs	= function (){ return (this.f_length() ); }
	this.f_maGetCol		= function (sCampo){ return( this.f_getCol(sCampo) ); }
	this.f_maGetColName	= function (nPos){ return( this.f_getColName(nPos) ); }
	this.f_maGetCols	= function (){ return( this.f_getCols() ); }
	this.f_maGetVal		= function (sCampo,a_nReg,sReturn){
										if (IsArray(a_nReg)) return (this.f_subVals (sCampo,a_nReg))
										else return(this.f_getVal(sCampo, a_nReg, sReturn));
							}
	this.f_maGetValIf	= function (sColReturn,sColIf,sValIf,vValReturn){ return(this.f_getValIf(sColIf, sValIf, sColReturn, vValReturn, 0)); }
	this.f_maGetReg		= function (sColName,vVal){ return this.f_getReg (sColName, vVal, 0)}
	this.f_maGetRows	= function (a_nRegs){ return (this.f_subRows(a_nRegs,0))  }
	this.f_maNewRow 	= function (a_vValues,nRegPos,bDelRegs){ this.f_addRow(a_vValues, nRegPos); }
	this.f_maSetVal 	= function (sCampo,vValue,nReg){ this.f_setVal(sCampo,vValue,nReg); }
	this.f_maSubDistinct= function (sCampo,bIndices,bCaseDependiente,bRepetidos,bOrdenados) { return (this.f_subDistinct(sCampo,bIndices,bCaseDependiente,bRepetidos,bOrdenados))}
	this.f_maSubIndexOf = function (sCampo,vTexto,bIndices,bCaseDep,bParte,bAcentoDep,bRepetidos,bDistinto)	{ return (this.f_subIndexOf (sCampo,vTexto ,0    ,0     , bIndices, bCaseDep, bParte, bAcentoDep, bRepetidos, bDistinto )) }
	this.f_maSort 		= function (sCampo,bIndices,bDesc,sNewCol,nOrden,bCaseDependiente){ return (this.f_sort(sCampo,bIndices,bDesc,sNewCol,nOrden,bCaseDependiente)); }
	this.f_maSumaCampos = function (a_sCampos,a_nRegs) { return (this.f_sumaCampos (a_sCampos, a_nRegs)) }
	this.f_maSubValByRegs = function (a_sCampos,a_nRegs) { return (this.f_subValByRegs (a_sCampos, a_nRegs)) }
	this.f_maSumaColIf	= function (sCampo,sCampoIf,sValueIf,bDistinto){ return (this.f_sumaColIf (sCampo,sCampoIf,sValueIf,bDistinto)) }

	this.f_maSubSort = function(a_nIndices,sCampo,bIndices,bOrdenacion,nOrden,bCaseDependiente){
		var a_vOrdenado = []
		var a_vCol = this.f_maGetVal (sCampo,a_nIndices)
		if (a_vCol.length) a_vOrdenado = a_vCol.f_sort (bIndices,bOrdenacion,nOrden,bCaseDependiente)
		if (bIndices) a_vOrdenado = a_nIndices.f_subVal (a_vOrdenado)
		return (a_vOrdenado)
	}

}

//<!--%>//-->
