/**questa libreria necessita delle librerie:
 *	util.js
 *	AZArray.js
 */
 
/**Il codice seguente estende l'interfaccia del
 * oggetto buit-in String di JavaScript.
 */

String.prototype.replace = String_replace;
String.prototype.tokensToAZArray = String_tokensToAZArray;
String.prototype.tokensToAZArrayWithEscape = String_tokensToAZArrayWithEscape;
String.prototype.nextDigitIndex = String_nextDigitIndex;
String.prototype.nextNonDigitIndex = String_nextNonDigitIndex;
String.prototype.nextNaturalString = String_nextNaturalString;

/**Sostituisce in s le occorrenze di sOldToken con sNewToken
 * da sinistra a destra. I seguenti esempi chiariscono il
 * comportamento in casi particolari:
 *	this = "quello che vuoi"
 *	sOldToken = ""
 *	sNewToken = "quest'altro che vuoi"
 *	return "quello che vuoi"	// solo le prime due "a" vengono sostituite
 *
 *	this = "aaa"
 *	sOldToken = "aa"
 *	sNewToken = "a"
 *	return "aa"	// solo le prime due "a" vengono sostituite
 *
 *	this = aaaa
 *	sOldToken = aa
 *	sNewToken = a
 *	return aa	// vengono sostituite le prime due e le ultime due "A"
 *
 *	this = ababa
 *	sOldToken = aba
 *	sNewToken = c
 *	return cba	
 *
 *	this = abababa
 *	sOldToken = aba
 *	sNewToken = c
 *	return cbc	// vengono sostituite le prime due e le ultime due "A"
 */
function String_replace(sOldToken, sNewToken)
{
	if (sOldToken == "")
		return this;
	var i = 0;
	var j = this.indexOf(sOldToken);
	var res = "";
	while (j >= 0)
	{
		res += this.substring(i, j) + sNewToken;
		i = j + sOldToken.length;
		j = this.indexOf(sOldToken, i);
	}
	res += this.substring(i, this.length);
	return res;
}

/**Questa funzione separa i token di una stringa.
 * @param sTokens stringa di token
 * @param sSeparator separatore di token (non deve essere stringa vuota!)
 * @return array con i tokens
 */
function String_tokensToAZArray(sSeparator)
{
	var sTokens = this;
	var iSep = sTokens.indexOf(sSeparator);
	var asRes = new AZArray(0, 0, "");
	while (iSep >= 0)
	{
		asRes.length += 1;
		asRes[asRes.length - 1] = sTokens.substring(0, iSep);
		sTokens = sTokens.substring(iSep + sSeparator.length);
		iSep = sTokens.indexOf(sSeparator);
	}
	if (sTokens != "")
	{
		asRes.length += 1;
		asRes[asRes.length - 1] = sTokens;
	}
	return asRes;
}

/**Questa funzione separa i token di una stringa.
 * @param sSeparator separatore di token (non deve essere stringa vuota!)
 * @param sEscape sequenza di escape per il separatore (non deve essere stringa vuota!)
 * @return array con i tokens
 */
function String_tokensToAZArrayWithEscape(sSeparator, sEscape)
{
	var sTokens = this;
	var asRes = new AZArray(0, 0, "");
	var iSep = sTokens.indexOf(sSeparator);
	var iEsc = sTokens.indexOf(sEscape);
	var sTemp = "";
	while ((iSep >= 0) && (iEsc >= 0))
	{
		if (iSep < iEsc)
		{
			sTemp += sTokens.substring(0, iSep);
			asRes.length += 1;
			asRes[asRes.length - 1] = sTemp;
			sTokens = sTokens.substring(iSep + sSeparator.length);
			sTemp = "";
		}
		else
		{
			sTemp += sTokens.substring(0, iEsc) + sSeparator;
			sTokens = sTokens.substring(iEsc + sEscape.length);
		}
		iSep = sTokens.indexOf(sSeparator);
		iEsc = sTokens.indexOf(sEscape);
	}
	while (iSep >= 0)
	{
		sTemp += sTokens.substring(0, iSep);
		asRes.length += 1;
		asRes[asRes.length - 1] = sTemp;
		sTokens = sTokens.substring(iSep + sSeparator.length);
		sTemp = "";
		iSep = sTokens.indexOf(sSeparator);
	}
	while (iEsc >= 0)
	{
		sTemp += sTokens.substring(0, iEsc);
		sTokens = sTokens.substring(iEsc + sEscape.length);
		iEsc = sTokens.indexOf(sEscape);
	}
	sTemp += sTokens;
	if (sTemp.length > 0)
	{
		asRes.length += 1;
		asRes[asRes.length - 1] = sTemp;
	}
	return asRes;
}

/**Cerca la posizione di una cifra nella stringa.
 * @param iFromIndex (default 0) posizione a partire dalla quale cercare
 * @return indice della cifra trovata, -1 se non presente
 */
function String_nextDigitIndex(iFromIndex)
{
	if (isUndefined(iFromIndex))
		iFromIndex = 0;
	if (iFromIndex < 0)
		return -1;
	var c;
	while (iFromIndex < this.length)
	{
		c = this.charAt(iFromIndex);
		if (c < "0" || c > "9")
			iFromIndex++;
		else return iFromIndex;
	}
	return -1;
}

/**Cerca la posizione di un carattere che non è una cifra.
 * @param iFromIndex (default 0) posizione a partire dalla quale cercare
 * @return
 *	indice della 'non cifra' trovata
 *	-1 se non presente
 */
function String_nextNonDigitIndex(iFromIndex)
{
	if (isUndefined(iFromIndex))
		iFromIndex = 0;
	if (iFromIndex < 0)
		return -1;
	var c;
	while (iFromIndex < s.length)
	{
		c = this.charAt(iFromIndex);
		if (c < "0" || c > "9")
			return iFromIndex;
		else iFromIndex++;
	}
	return -1;
}

/**Cerca un numero naturale
 * @param iFromIndex (default 0) posizione a partire dalla quale cercare
 * @return il numero naturale, null se non presente
 */
function String_nextNaturalString(iFromIndex)
{
	if (isUndefined(iFromIndex))
		iFromIndex = 0;
	iFromIndex = this.nextDigitIndex(iFromIndex);
	if (iFromIndex < 0)
		return null;
	var iToIndex = this.nextNonDigitIndex(iFromIndex);
	if (iToIndex < 0)
		iToIndex = this.length;
	return this.substring(iFromIndex, iToIndex);
}