/**	Effectue la validation d'une adresse email.
 *
 *	Cette fonction va effectuer une vérification syntaxique de l'adresse email passée en paramètre.
 *
 *	\param email La valeur à valider
 *
 *	\return boolean \c true si l'adresse email est valide, \c false dans le cas contraire.
 *
 */
function validEmail(email){
	var reg = new RegExp("^[a-z]{1}[a-z0-9]*((\.|_|-)[a-z0-9]+)*@[a-z0-9]*((\.|-)[a-z0-9]+)*(\.[a-z]{2,4})$","i");
	return reg.test(email);
}

/**	Effectue la validation d'une adresse url.
 *
 *	Cette fonction va effectuer une vérification syntaxique de l'adresse url passée en paramètre.
 *
 *	Pour être valide, l'url doit comporter le protocole utilisé. C'est à dire que l'url 'www.riastudio.fr'
 *	ne sera pas considérée comme valide, mais que 'http://www.riastudio.fr' le sera. Tous les protocoles 
 *	sont acceptés par cette fonction, que ce soit http, ftp, rtsp, etc...
 * 
 *	Les urls contenant un nom d'utilisateur et éventuellement un mot de passe sont également autorisés
 *	par cette fonction.
 *
 *	De la même manière, les url comportant un numéro de port sont également supportées.
 *
 *	\param url La valeur à valider
 *
 *	\return boolean \c true si l'adresse url est valide, \c false dans le cas contraire.
 *
 */
function validUrl(url){
	// Retourne vrai si a est une adresse http valide (http://...)
	var reg = new RegExp( "^[a-z]{3,6}://([a-z0-9\_\.\-]+(:[a-z0-9\_\.\-]+)?@)?[a-z0-9]*((\.|-)[a-z0-9]+)*(\.[a-z]{2,4})", "i" );
	return reg.test(url);
}

/** Supprime les caractères espace, retour chariot et newline de début et fin de chaîne.
 *
 *	\param str Chaîne à traiter
 *
 *	\return str La chaîne originale sans ses espaces de début et de fin de chaîne.
 *
 */
function trim(str){
	str = str.replace( /^([\s]+)/g, '' ); // Supprime les caractères non-imprimables de début de chaîne
	str = str.replace( /([\s]+)$/g, '' ); // Supprime les caractères non-imprimables de fin de chaîne
	return str;
}

/** Supprime les caractères espace, retour chariot et newline de début de chaîne.
 *
 *	\param str Chaîne à traiter
 *
 *	\return str La chaîne originale sans ses espaces de début et de fin de chaîne.
 *
 */
function ltrim(str){
	return str.replace( /^([\s]+)/g, '' ); // Supprime les caractères non-imprimables de début de chaîne
}

/** Supprime les caractères espace, retour chariot et newline de fin de chaîne.
 *
 *	\param str Chaîne à traiter
 *
 *	\return str La chaîne originale sans ses espaces de fin de chaîne.
 *
 */
function rtrim(str){
	return str.replace( /([\s]+)$/g, '' ); // Supprime les caractères non-imprimables de fin de chaîne
}

/** Complète une chaîne à gauche avec le caractère de complétion.
 *	Si aucun caractère de complétion n'est précisé, la chaîne est complétée avec des espaces
 *
 *	\param str Chaîne à traiter
 *	\param padlength Longueur de la chaîne après traitement.
 *	\param padstr Optionnel, caractère de complétion.
 *
 *	\return str La chaîne de caractère originale complétée à gauche.
 *
 */
function lpad(str,padlength,padstr){
	var l = str.length;
	if( l<padlength ){
		pad = padstr=='undefined' ? ' ' : padstr;
		for( var i=0; i<padlength-l; i++ )
			str = pad + str;
	}
	return str;
}

/** Complète une chaîne à droite avec le caractère de complétion.
 *	Si aucun caractère de complétion n'est précisé, la chaîne est complétée avec des espaces
 *
 *	\param str Chaîne à traiter
 *	\param padlength Longueur de la chaîne après traitement.
 *	\param padstr Optionnel, caractère de complétion.
 *
 *	\return str La chaîne de caractère originale complétée à droite.
 *
 */
function rpad(str,padlength,padstr){
	var l = str.length;
	if( l<padlength ){
		pad = padstr=='undefined' ? ' ' : padstr;
		for( var i=0; i<padlength-l; i++ )
			str += pad;
	}
	return str;
}

/** Vérifie qu'une chaîne décrit un nombre a virgule flottante valide.
 * 	Les séparateurs de décimale acceptés sont la virgule et le point.
 */
function validFloat(ch){
	var reg = new RegExp("^[0-9]+([\.,]{1}[0-9]+)?$");
	return reg.test(ch);
}

/** Vérifie qu'une chaîne contient un nombre entier valide.
 *	En plus de sa valeur, le signe peut être précisé. Les signes + et -
 *	présents en début de chaîne sont acceptés. Le signe est optionnel.
 */
function validInt(ch){
	var reg = new RegExp("^(([\+\-]?)([0-9]+))$");
	return reg.test(ch);
}

/** Vérifie qu'une chaîne contient un nombre entier non signé valide	
 */
function validUnsignedInt(ch){
	var reg = new RegExp("^(([0-9]+))$");
	return reg.test(ch);
}


/** Vérifie qu'une chaîne contient une date au format jj/mm/aaaa.
 *
 *	En plus de la validité de son format, sa cohérence est également contrôlée.	
 *
 */
function validDate(ch){
	var reg = new RegExp("^[0-9]+/[0-9]+/[0-9]{4}$");
	var valid = reg.test(ch);
	if( valid ){
		var date = ch.split('/');
		var day = date[0];
		var month = date[1];
		if( month<=7 )
			valid = month%2==1 ? day<=31 : day<=30;
		else
			valid = month%2==0 ? day<=31 : day<=30;
		if( valid && month==2 ){
			var year = date[2];
			valid = year%4==0 ? day<=29 : day<=28;
		}
	}
	return valid;
}

/** Vérifie qu'une chaîne contient une heure au format 24:00[:00]
 *
 *	Cette fonction effectue une vérification du format et de la cohérence de l'heure passée en paramètre.
 *
 */
function validTime(ch){
	var valid = false;
	var reg = new RegExp("^([0-2][0-9]:[0-6][0-9](:[0-6][0-9])?)$");
	var res = reg.exec(ch);
	if( !res ) return false;

	if( parseInt(res[1])<=24 )
		if( parseInt(res[2])<60 )
			if( res.length==2 )
				valid = true;
			else if( res[3]<60 )
				valid = true;

	return valid;
}

/** Vérifie qu'une chaîne contient un code postal valide.
 *	Cette fonction n'est valide que pour les codes postaux français.
 */
function validCodePostal(ch){
	var reg = new RegExp("^((2A|2B|([0-9]{2}))([0-9]{3}))$","i");
	return reg.test(ch);
}

/** Vérifie qu'une chaîne contient un numéro siret valide
 */
function validSiret(ch){
	var reg = new RegExp("^([0-9]{14})$");
	return reg.test(ch);
}

/** Vérifie qu'une chaîne contient un numéro ape-naf valide
 */
function validApe(ch){
	var reg = new RegExp("^(([0-9]{3})[a-z])$","i");
	return reg.test(ch);
}

/** Vérifie qu'une chaîne contient un nombre hexadécimal
 */
function validHexa(ch){
	var reg = new RegExp("^([0-9A-F]+)$","i");
	return reg.test(ch);
}

/** Vérifie qu'une chaîne contient une couleur au format hexadécimal
 */
function validHexaColor(ch){
	var reg = new RegExp("^([0-9A-F]{6})$","i");
	return reg.test(ch);
}

/** Vérifie qu'une chaîne ne contient que des lettres et des chiffres
 */
function validAlphaNum(ch){
	var reg = new RegExp("^([a-z0-9]+)$","i");
	return reg.test(ch);
}

/** Vérifie qu'une chaîne ne contient que des lettres
 */
function validAlpha(ch){
	var reg = new RegExp("^([a-z]+)$","i");
	return reg.test(ch);
}

/** Permet de créer un mot de passe ne contenant que des lettres et des chiffres.
 *
 *	\param length Optionnel, longueur du mot de passe à générer.
 *
 *	\return string Le mot de passe généré. Ce mot de passe n'est composé que de lettres minuscules et de chiffres.
 *
 */
function createPassword(length){
	if( !length ) length = 6;
	// Crée un mot de passe aléatoire
	var chars = 'abcdefghijklmnopqrstuvwxyz1234567890';
	var pwd = '';
	for( var i=0; i<length; i++ )
		pwd += chars.substr( Math.round( chars.length * Math.random() ), 1 );
	return pwd;
}