function StringTool()
{
}

StringTool.padIntWithZeroes = function(n, width)
{
    var pad = "000000000000000000000000000000";
    var s = n.toString();
    
    if (s.length < width)
    {
        s = pad.substring(0, width - s.length) + s;
    }
    
    return s;
}

StringTool.formatFloat = function(val, prec)
{
    // todo: support negative values
    
    var res;
    
    if (prec > 0)
    {
        var multi = MathTool.intPow(10, prec);
        var multiZeros = multi.toString().substr(1);
        
        res = (Math.round(val * multi) / multi).toString();
        
        // deal with '.'
        var dotPos = res.indexOf(".");
        if (dotPos == -1)
        {
            res += "." + multiZeros;
        }
        else
        {
            var fracLen = res.length - (dotPos + 1);
            res += multiZeros.substr(fracLen);
        }
    }
    else
    {
        res = Math.round(val).toString();
    }

    return res;
}

StringTool.format = function (formatString)
{
    var args = new Array();
    for (var i=1; i<arguments.length; i++)
    {
        args.push(arguments[i]);
    }
    
    var str = StringTool.formatArray(formatString, args);

    return str;
}

StringTool.formatArray = function(formatString, paramsArray)
{
    var str = formatString;
    var regexp = new RegExp("{([0-9])+(?::([0-9]+))?}", "g");
    var patterns = [];
    
    do
    {
        var res = regexp.exec(str);
        if ((res) && (res.length > 0))
        {
            var index = Number(res[1]);
            
            if (res[2])
            {
                var prec = res[2];
                var param = paramsArray[index].toString();
                param = param.formatFloat(prec);
                res.parameter = param;
            }
            else
            {
                res.parameter = paramsArray[index];
            }
            patterns.push(res);
        }
    }
    while (res != null)
    
    for (var i=0; i<patterns.length; i++)
    {
        var pattern = patterns[i];
        while(true)
        {
            var tmpStr = str.replace(pattern[0], pattern.parameter);
            if (tmpStr == str) break;
            str = tmpStr;
        }
    }
    
    return str;

}

// <String> class modifying

String.prototype.contains = function(s)
{
    return this.indexOf(s) >= 0;
}

String.prototype.startsWith = function(s, ignoreCase)
{   
    if (this.length < s.length) return false;
    
    var res;
    
    if (!ignoreCase)
    {
        res = this.substr(0, s.length) == s;
    }
    else
    {
        res = this.toLowerCase().substr(0, s.length) == s.toLowerCase();
    }
    
    return res;
}

String.prototype.endsWith = function(s, ignoreCase)
{
    var pos = this.length - s.length;
    var sub = this.substr(pos);
    var res;
    if (ignoreCase)
    {
        res = sub == s;
    }
    else
    {
        res = sub.toLowerCase() == s.toLowerCase();
    }
    
    return res;
}

String.prototype.trim = function()
{   
    var i;
    for (i = 0; i <= this.length; ++i)
    {
        if (i < this.length && this.charCodeAt(i) > 32) break;
    }
    
    if (i == this.length) return "";
    var beg = i;
    
    for (i = this.length - 1; i >= beg; --i)
    {
        if (this.charCodeAt(i) > 32) break;
    }
    var end = i;
    
    return this.substring(beg, end + 1);
}

String.prototype.htmlUnescape = function()
{
    var res = this;
    
    res = res.replace(/&nbsp;/gi, " ");
    res = res.replace(/&gt;/gi, ">");
    res = res.replace(/&lt;/gi, "<");
    res = res.replace(/&amp;/gi, "&");
    
    return res;
}

String.prototype.htmlEscape = function(escapeSpaces)
{
    var res = this;    
    res = res.replace(/&/gi, "&amp;");
    res = res.replace(/>/gi, "&gt;");
    res = res.replace(/</gi, "&lt;");
    if (escapeSpaces) res = res.replace(/ /gi, "&nbsp;");
    return res;
}

String.prototype.formatFloat = function(prec)
{
    return StringTool.formatFloat(this, prec);
}

// todo: buggy. will return false on valid floats like 1.2e-20
String.prototype.isFloat = function()
{
    var res = /^-?\d{1,20}(\.\d{1,20})?$/.test(this);
    return res;
}

String.prototype.isInt = function()
{
    var res = /^-?\d{1,10}$/.test(this);
    return res;
}

String.prototype.toInt = function()
{
    if (!this.isInt()) return null;
    return Number(this);
}

String.prototype.isEmail = function()
{
    var regexp = "^(?:[A-Za-z0-9_.]+)@(?:(?:[A-Za-z0-9_]+).)+[a-zA-Z]+$";
    var res = (this.match(regexp) != null);
    
    return res;
}

var _format = StringTool.format;