Constructeur

Initialisation

• pDepth:Number La profondeur de l'indexation des lexiques

Propriétés

Méthodes

Evénements

• onReady() Lorsque la recherche est prête
• onError() Lorsqu'il y a une erreur dans la préparation

Change log

Source

import com.neolao.data.XMLManager;
import com.neolao.data.ArrayIterator;
import com.neolao.data.language.Lexicon;
import com.neolao.data.language.WordLexicon;
import com.neolao.data.language.TranslationLexicon;
/**
 * Gestionnaire de lexique
 * @author 		neolao <neo@neolao.com>
 * @version 		1.1 (27/06/2005)
 * @link		http://resources.neolao.com/flash/classes/data/language/LexiconManager
 */
dynamic class com.neolao.data.language.LexiconManager {
	public var className:String = "LexiconManager";
	public var version:String = "1.1";
 
	// ----------------------------- CONSTANTES --------------------------------
	/**
	 * Le temps de temporisation pour chaque interval
	 */
	private var INTERVAL_MS:Number = 1;
	/**
	 * Le nombre d'exécution des traitements
	 */
	private var NB_EXEC:Number = 200;
	/**
	 * Racines des cookies
	 */
	private var COOKIES_ROOT:String = "/";
 
	// ----------------------------- VARIABLES ---------------------------------
	/**
	 * La profondeur de l'indexation des lexiques
	 */
	private var _depth:Number;
	/**
	 * Liste des XML externes à charger
	 */
	private var _xmlExtList:ArrayIterator;
	/**
	 * Gestionnaire XML
	 */
	private var _xml:XMLManager;
	/**
	 * Interval
	 */
	private var _interval:Number;
	/**
	 * XMLNode courant
	 */
	private var _xmlNodeCurrent:XMLNode;
	/**
	 * Liste des Lexicon
	 */
	private var _lexiconList:ArrayIterator;
	/**
	 * Indique si la recherche est prête
	 */
	private var _ready:Boolean;
 
	// ----------------------------- EVENEMENTS --------------------------------
	/**
	 * Evénement invoqué lorsque la préparation est finie
	 */
	public var onReady:Function;
	/**
	 * Evénement invoqué lorsqu'il y a une erreur
	 */
	public var onError:Function;
 
	/*============================= CONSTRUCTEUR =============================*/
	/*========================================================================*/
	/**
	 * Initialisation
	 * @param pDepth La profondeur de l'indexation des lexiques
	 */
	public function LexiconManager(pDepth:Number){
		// Initialisation des variables
		_depth = (pDepth === undefined)?3:pDepth;
		_xmlExtList = new ArrayIterator();
		_lexiconList = new ArrayIterator();
		_ready = false;
	}
	/*======================= FIN = CONSTRUCTEUR = FIN =======================*/
	/*========================================================================*/
 
	/*=========================== METHODES PRIVEES ===========================*/
	/*========================================================================*/
	/**
	 * Vérifie dans les cookies si le Lexicon n'y est pas
	 * @param pName Le nom du cookie
	 * @param pDate La date du fichier XML à comparer avec le cookie
	 */
	private function _cookiesCheck(pFrom:String, pTo:String, pDate:String):Boolean{
		var vName:String = pFrom+"-"+pTo;
		var vLexicon:Lexicon;
		var vCookies:SharedObject = SharedObject.getLocal(vName, COOKIES_ROOT);
 
		if(vCookies.data.database != undefined){
			// La base de données FR-GB existe dans les cookies
			if(vCookies.data.date >= pDate){
				// La base de données enregistrée est à jour, on l'utilise
				// Enregistrement dans le manager
				vLexicon = new Lexicon(vCookies.data.database, pFrom, vName);
				vLexicon.date = pDate;
				_lexiconList.push(vLexicon);
				return true;
			}else{
				// Le fichier est plus récent, il faut le parser
				return false;
			}
		}else{
			return false;
		}
	}
	/**
	 * Enregistre les données d'un Lexicon dans un cookie
	 */
	private function _cookiesSave(pName:String, pDatabase:Object, pDate:String){
		var vCookies:SharedObject = SharedObject.getLocal(pName, COOKIES_ROOT);
 
		vCookies.data.database = pDatabase;
		vCookies.data.date = pDate;
		vCookies.flush();
	}
	/**
	 * Parse du XML chargé
	 */
	private function _xmlParse(){
		var vParent:Object = this["parent"];
		var vXMLFirstChild:XMLNode = this["firstChild"];
 
		if(!vParent._cookiesCheck(vXMLFirstChild.attributes.from, vXMLFirstChild.attributes.to, vXMLFirstChild.attributes.date)){
			vParent._xmlNodeCurrent = vXMLFirstChild.firstChild;
			vParent._xmlToLexicon(vXMLFirstChild.attributes.from, vXMLFirstChild.attributes.to, new Array());
		}else{
			vParent._xmlNext();
		}
	}
	/**
	 * Erreur de parsage
	 */
	private function _xmlError(){
		var vParent:Object = this["parent"];
 
		vParent.onError.apply(vParent);
	}
	/**
	 * Formatage de la liste pour que la class Lexicon la comprenne
	 * @param pFrom La langue est du lexique
	 * @param pTo La langue de traduction
	 * @param pList La liste des TranslationLexicon
	 */
	private function _xmlToLexicon(pFrom:String, pTo:String, pList:Array){
		var vWord1:WordLexicon;
		var vWord2:WordLexicon;
		var vTransTmp:TranslationLexicon;
		var vTransTmpObj:Object;
		var vWordSearch:Array;
 
		clearInterval(_interval);
 
		if(_xmlNodeCurrent === null || _xmlNodeCurrent === undefined){
			// Il n'y a plus de XMLNode
			_lexiconList.push(new Lexicon(pList, _depth, pFrom+"-"+pTo));
			_xmlNext();
		}else{
			for(var i=0; i<NB_EXEC; i++){
				if(_xmlNodeCurrent){
					vWordSearch = _xmlNodeCurrent.attributes.search.split(",");
					vWord1 = new WordLexicon(pFrom, _xmlNodeCurrent.attributes.label, vWordSearch);
					vWord2 = new WordLexicon(pTo, _xmlNodeCurrent.attributes.translation);
					vTransTmp = new TranslationLexicon(vWord1, [vWord2]);
					vTransTmpObj = vTransTmp.toObject();
					vTransTmpObj.sound = _xmlNodeCurrent.attributes.sound;
 
					pList.push(vTransTmpObj);
 
					// On passe au XMLNode suivant
					_xmlNodeCurrent = _xmlNodeCurrent.nextSibling;
				}
			}
 
			_interval = setInterval(this, "_xmlToLexicon", INTERVAL_MS, pFrom, pTo, pList);
		}
	}
	/**
	 * Traitement du prochain XML
	 */
	private function _xmlNext(){		
		// Prochain XML
 
		if(_xmlExtList.hasNext()){
			_xml = new XMLManager(String(_xmlExtList.next()), _xmlParse, _xmlError);
			_xml.parent = this;
			_xml.load();
		}else{
			// Il n'y a plus d'XML à charger
			// On vérifie si tous les Lexicon sont ready
			_checkReady();
		}
	}
	/**
	 * Vérifie si tous les Lexicon sont ready
	 */
	private function _checkReady():Boolean{
		var vOK:Number = 0;
		var vLexicon:Object;
 
		clearInterval(_interval);
 
		_lexiconList.reset();
		while(_lexiconList.hasNext()){
			vLexicon = _lexiconList.next();
 
			if(vLexicon.ready){
				_cookiesSave(vLexicon.name, vLexicon.database, vLexicon.date);
				vOK++;
			}else{
				_interval = setInterval(this, "_checkReady", INTERVAL_MS);
				return false;
			}
		}
 
		_ready = true;
		onReady.apply(this);
 
		return true;
	}
	/*===================== FIN = METHODES PRIVEES = FIN =====================*/
	/*========================================================================*/
 
	/*============================ GETTER  SETTER ============================*/
	/*========================================================================*/
	/**
	 * Indique si la recherche est prête
	 */
	public function get ready():Boolean{
		return _ready;
	}
	/*====================== FIN = GETTER  SETTER = FIN ======================*/
	/*========================================================================*/
 
	/*========================== METHODES PUBLIQUES ==========================*/
	/*========================================================================*/
	/**
	 * Ajoute un XML externe comme source de lexique
	 * @param pURL Le XML externe à ajouter
	 */
	public function addXML(pURL:String){
		_xmlExtList.push(pURL);
	}
	/**
	 * Préparation du lexique
	 */
	public function init(){
		// Chargement des XML externes
		_xmlNext();
	}
	/**
	 * Lancer une recherche
	 * @param pLexicon Le lexique dans lequel on cherche
	 * @param pWord Le mot que l'on cherche
	 * @return La liste des mots trouvés
	 */
	public function search(pLexicon:Number, pWord:String):Array{
		if(_ready){
			return _lexiconList[pLexicon].search(pWord);
		}
	}
	/*==================== FIN = METHODES PUBLIQUES = FIN ====================*/
	/*========================================================================*/
}