/**
* Helper-Script, mit Javascrip-Hilfsmethoden
**/
(function() {
// Inet-Library-"package" holen
var iLibs = window.iLibs;
if (typeof(iLibs) == "undefined" || iLibs == null) {
    iLibs = {};
    window.iLibs = iLibs;
}
// Die urspruengliche "$U"-Variable sichern
if (window.$U)
    var _$U = window.$U;

var JSUtils = {
    id:             "JSUtils",                      // Die eindeutige Id, dieser Library
    dependencies:   [                               // Abhaengigkeiten mit anderen Libraries
                        "DependencyHandler"
                    ],

    /**
    * Wenn keine globale Variable "$U" gesetzt werden soll und die urspruengliche Variable wiederhergestellt werden soll
    * (falls andere Libraries verwendet werden, welche dieselbe Variable verwenden), kann mit dieser Methode der
    * Ursprungszustand hergestellt werden und man bekommt dadurch die Moeglichkeit, einen eigenen Variablennamen zu
    * vergeben.
    * @return this
    **/
    noConflict: function noConflict() {
        window.$U = _$U;
        return this;
    },

    /**
    * Mit dieser Methode wird ein bestimmtes Property aus dem uebergebenen JSON-Objekt geholt. Dabei wird
    * beruecksichtigt, dass jObj, oder der herausgeholte Wert null, bzw. undefined sein koennten. Des weiteren
    * kann noch ein Default-Wert uebergeben werden, welcher in so einem Fall zurueckgeliefert wird. Wenn der
    * Default-Wert nicht gegeben ist, wird stattdessen null zurueckgeliefert
    * @param jObj   Das JSON-Objekt
    * @param oProp  Das Property, welches aus jObj geholt werden soll.
    * @param oDef   Der Default-Wert, welcher zurueckgeliefert wird, wenn jObj oder jObj[oProp] null oder
    *               undefined sind. Dieser Parameter ist optional
    * @return Das Property in jObj. Bzw. oDef, wenn jObj, oder jObj[oProp] undefined oder null sind, bzw. null,
    *         wenn oDef nicht gesetzt ist
    **/
    $P: function $P(jObj, oProp, oDef) {
        if (!this.$S(jObj) || !this.$S(jObj[oProp])) {
            if (typeof(oDef) != "undefined")
                return oDef;
            else
                return null;
        }
        return jObj[oProp];
    },

    /**
    * Prueft, ob ein Wert gesetzt und nicht null ist.
    * @param oElement   Das zu pruefende Element
    * @return false, wenn oElement undefined oder null ist
    **/
    $S: function $S(oElement) {
        if (typeof(oElement) == "undefined" || oElement === null)
            return false;
        return true;
    },

    /**
    * Prueft, ob der uebergebene Wert gesetzt, bzw. eine Funktion ist.
    * @param pFunction Der zu pruefende Wert
    * @return true, wenn es sich dabei um eine Funktion handelt. false, wenn pFunction nicht gesetzt, bzw. keine
    *           Funktion ist
    **/
    $F: function $F(pFunction) {
        if (!this.$S(pFunction))
            return false;
        return typeof(pFunction) === "function";
    },

    /**
    * Diese Methode prueft, ob oValue in aoArray vorkommt. Wenn aoArray kein Array ist, wird aoArray trotzdem noch mit
    * oValue verglichen und bei Gleichheit true, zurueckgeliefert
    * @param aoArray    Das Array, in welchem nach oValue nachgeschaut wird
    * @param oValue     Der Wert, der gesucht wird
    * @param bStrict    true, wenn beim Vergleich auch der Typ beruecksichtigt werden soll. Bei false wird ggf. bei
    *                   ungleichen Typen zuerst in den entsprechenden Typ konvertiert und dann verglichen.
    *                   Optionaler Parameter. Default: false
    * @return true, wenn oValue in aoArray vorkommt, bzw. wenn aoArray kein Array ist, aber dennoch oValue entspricht.
    *                   false, wenn oValue nicht im aoArray vorkommt, und oValue != aoArray (wenn aoArray kein Array
    *                   ist), oder wenn aoArray undefined oder null ist
    **/
    contains: function contains(aoArray, oValue, bStrict) {
        var bStEq = this.$S(bStrict) && bStrict === true ? true : false;
        if (!this.$S(aoArray))
            return false;
        if (!(aoArray instanceof Array)) {
            if (aoArray === oValue)
                return true;
            else
                return false;
        }
        for (var i = 0; i < aoArray.length; i++) {
            if (bStEq){
                if (aoArray[i] === oValue)
                    return true;
            }
            else {
                if (aoArray[i] == oValue)
                    return true;
            }
        }
        return false;
    },

    /**
    * Mit dieser Methode werden aus einem JSON-Objekt jene Properties herausgefiltert und zurueckgeliefert
    * (in einem neuen JSON-Objekt), welche im aoProp-Array vorkommen
    * @param jJSN   Das JSON-Objekt, mit den Properties, welche gefiltert werden sollen.
    * @param aoProp Das Array mit den Properties, die gefiltert werden sollen.
    * @return Ein neues JSON-Objekt, mit den aus dem jJSN-Objekt gefilterten Properties. Wenn jJSN null ist,
    *               wird null zurueckgeliefert. Wenn aoProp-Eintraege nicht im jJSON vorkommen, werden keine
    *               entsprechenden Properties im neuen JSON-Objekt aufgenommen, sondern einfach ausgelassen.
    *               Wenn aoProp undefined, oder null ist, wird null zurueckgeliefert
    **/
    filterJSON: function filterJSON(jJSN, aoProp) {
        if (!this.$S(aoProp))
            return null;
        var aoProperties = aoProp instanceof Array ? aoProp : [aoProp];
        if (!this.$S(jJSN))
            return null;
        var jNew = {};
        for (var oProp in jJSN) {
            for (var i = 0; i < aoProperties.length; i++) {
                if (aoProperties[i] == oProp)
                    jNew[oProp] = jJSN[oProp];
            }
        }
        return jNew;
    },

    /**
    * Prueft, ob oValue gesetzt, bzw. definiert ist. Sollte dies nicht der Fall sein, wird oSubstitute zurueckgeliefert
    * @param oValue         Der Wert, welcher geprueft werden soll
    * @param oSubstitute    Der Wert, welcher zurueckgeliefert werden soll, wenn oValue undefined oder null ist
    * @return Liefert oValue, wenn oValue != undefined, bzw != null. Ansonsten oSubstitute
    **/
    nvl: function nvl(oValue, oSubstitute) {
        return this.$S(oValue) ? oValue : oSubstitute;
    },

    /**
    * Fuellt den angegebenen String mit "sFillChar", bis zur Laenge "iLength" auf.
    * @param sString    Der zu fuellende String
    * @param sFillChar  Der Character, mit welchem sString aufgefuellt werden soll. Wenn mehr als 1 Char uebergeben
    *                   wird, wird das Zeichen an Index 0 verwendet
    * @param iLength    Die Laenge, bis zu welcher der uebergebene String aufgefuellt werden soll.
    * @param bFillLeft  true, wenn der String auf der linken Seite aufgefuellt werden soll. Bei false wird der String
    *                   auf der rechten Seite aufgefuellt. Dieser Parameter ist optional. Default: true
    * @return Der befuellte String.
    **/
// ungetestet
    fillStr: function fillStr(sString, sFillChar, iLength, bFillLeft) {
        var sStr = this.$S(sString) ? typeof(sString) == "string" ? sString : new String(sString) : "";
        var bFL = this.$S(bFillLeft) ? bFillLeft : true;
        var sFChar = this.$S(sFillChar) ? sFillChar.length > 1 ? sFillChar.charAt(0) : sFillChar : "";
        if (sFChar === "")
            return sStr;
        var sFill = "";
        for (var i = sStr.length; i < iLength; i++)
            sFill += sFChar;
        return bFL === false ? (sStr + sFill) : (sFill + sStr);
    }
};

// Die JSUtils im inet-Library-Package als globale Variable zur Verfuegung stellen
iLibs["JSUtils"] = JSUtils;
// Die JSUtils, als globale $U-Variable zuer Verfuegung stellen
window.$U = JSUtils;
// Die JSUtils in die Liste der geladenen Libraries aufnehmen
var _aoLoadedLibs = window.$LoadedLibs;
if (!JSUtils.$S(_aoLoadedLibs)) {
    _aoLoadedLibs = [];
    window.$LoadedLibs = _aoLoadedLibs;
}
_aoLoadedLibs[_aoLoadedLibs.length] = JSUtils;
})();