Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.image;

import java.util.HashMap;

import java.util.Iterator;

import org.tela_botanica.client.interfaces.Rafraichissable;

import org.tela_botanica.client.modeles.Configuration;

import org.tela_botanica.client.modeles.ImageAsynchroneDAO;

import org.tela_botanica.client.modeles.ImageCarnet;

import org.tela_botanica.client.modeles.ImageUploaderAsynchroneDAO;

import org.tela_botanica.client.modeles.ListeImageAsynchroneDAO;

import org.tela_botanica.client.modeles.ListeImageCarnet;

import org.tela_botanica.client.modeles.MotsClesAsynchroneDAO;

import org.tela_botanica.client.modeles.NombreImageAsynchroneDAO;

import com.google.gwt.json.client.JSONArray;

import com.google.gwt.json.client.JSONObject;

import com.gwtext.client.data.ArrayReader;

import com.gwtext.client.data.FieldDef;

import com.gwtext.client.data.IntegerFieldDef;

import com.gwtext.client.data.MemoryProxy;

import com.gwtext.client.data.Node;

import com.gwtext.client.data.RecordDef;

import com.gwtext.client.data.Store;

import com.gwtext.client.data.StringFieldDef;

import com.gwtext.client.data.Tree;

import com.gwtext.client.widgets.tree.TreeNode;

/**

 * Modèle d'accès aux données pour les images.

 * C'est un singleton

 * @author aurelien

 *

 */

public class ImageModele implements Rafraichissable {

	/**

	 * Booleen indiquant si le médiateur est instancié (l'instance doit être unique donc le booleen est static)

	 */

	private static boolean estInstancie = false ;

	/**

	 * le modèle lui même

	 */

	private static ImageModele thisModele = null ;

	/**

	 * Le médiateur associé au modèle

	 */

	private ImageMediateur iMediateur = null ;

	/**

	 * La configuration en cours

	 */

	private Configuration config = null ;

	/**

	 * La liste des image affichées en cours

	 */

	private ListeImageCarnet cacheImage = new ListeImageCarnet(0) ;

	/**

	 * Table de correspondance entre les mots clés et leurs identifiants

	 */

	private HashMap<String, String> motsCles = new HashMap<String, String>(0) ;

	/**

	 * Le store contenant les données à afficher, que le modèle transmet au médiateur quand il le demande

	 */

	private Store st = null ;

	/**

	 * Arbre des mots clés

	 */

	private com.gwtext.client.data.Tree arbreMotsCles =  new Tree() ;

	/**

	 * Numéro de page en cours

	 */

	private int pageEncours = 0 ;

	/**

	 * Nombre de pages totales

	 */

	private int pageMax = 1 ;

	/**

	 * Taille de page (par défaut 50)

	 */

	private int taillePage = 50 ;

	/**

	 * Nombre d'éléments total correspondant à la requete

	 */

	private int nbElements = 0 ;

	/**

	 * Retourne une instance de manière unique

	 * @param im le médiateur à associer

	 * @return l'instance du modèle

	 */

	static ImageModele Instance(ImageMediateur im)

	{

		// si le modèle n'est pas encore instancié

		if(!estInstancie)

		{

			// on en crée un nouveau

			estInstancie = true ;

			thisModele = new ImageModele(im);

		}

		// sinon on retourne le "pointeur" vers le modèle lui-même

		return thisModele ;

	}

	/**

	 * Le constructeur est privé et seule la méthode instance y accède

	 * @param im le médiateur à associer

	 */

	private ImageModele(ImageMediateur im) {

		iMediateur = im ;

		config = new Configuration() ;

	}

	/**

	 * Accesseur pour le médiateur

	 * @return le médiateur associé

	 */

	public ImageMediateur getIMediateur()

	{

		return iMediateur ;

	}

	/**

	 * Appelle le DAO asynchrone pour obtenir la liste des images

	 * @param r le rafraichissable auxquel on enverra les données

	 */

	public void obtenirPhotoGalerie(Rafraichissable r)

	{

		String motsClesFiltres[][] = getIMediateur().renvoyerFiltres() ;

		int tailleFiltres = motsClesFiltres.length ;

		String[][] criteres = new String[tailleFiltres+1][2] ;

		String[][] criteres2 = new String[tailleFiltres+2][2] ;

		String[] utilisateur = {"ci_ce_utilisateur", ""+getIMediateur().getIdentifiant()} ;

		criteres[0] = utilisateur ;

		String[] limite =  {"ci_limite" ,""+taillePage } ;

		String[] taillePage = {"ci_numero_page",""+pageEncours} ;

		criteres2[0] = limite ;

		criteres2[1] = taillePage ;

		for (int i = 0 ; i < motsClesFiltres.length; i++) {

			criteres[i+1] = motsClesFiltres[i] ;

			criteres2[i+2] = motsClesFiltres[i] ;

		}

		// on les crée un DAO auquel on les transmet et qui demande le nombre d'images correspondantes (pour les pages)

		NombreImageAsynchroneDAO niaDAO = new NombreImageAsynchroneDAO(this) ;

		niaDAO.obtenirNombreImages(this, criteres) ;

		// et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images

		ListeImageAsynchroneDAO liaDAO = new ListeImageAsynchroneDAO(this);

		liaDAO.ObtenirListeImages(this, criteres2);

	}

	/**

	 * Appelle le DAO d'upload qui va choisir la methode d'upload adaptée

	 * et lancer l'interface appropriée

	 */

	@SuppressWarnings("static-access")

	public void uploaderImages()

	{

		ImageUploaderAsynchroneDAO IuADaO = new ImageUploaderAsynchroneDAO(this) ;

		IuADaO.choisirMethodeUpload() ;

	}

	/**

	 * Met à jour la liste des images à partir d'un objet

	 * @param o la nouvelle liste d'image

	 */

	public void rafraichirListeImage(Object o)

	{

		cacheImage = (ListeImageCarnet)o ;

	}

	/**

	 * Met à jour l'arbre des mots clés à partir d'un objet

	 * @param o le nouvel arbre de mots clés

	 */

	public void rafraichirArbreMotsCles(Object o)

	{

		arbreMotsCles = (com.gwtext.client.data.Tree)o ;

	}

	/**

	 * Met à jour la table de correspondance mots clés / ids

	 * à partir d'un objet

	 * @param o la nouvelle table des mots clés

	 */

	@SuppressWarnings("unchecked")

	public void rafraichirMotsCles(Object o)

	{

		if(o instanceof HashMap)

		{

			motsCles = (HashMap<String, String>)o ;

		}

	}

	/**

	 * Va chercher les métadonnées associées à une image dans la liste

	 * des images chargée dans le modèle

	 * @param r le rafraichissable auquel on enverra les informations

	 * @param id l'identifiant de l'image

	 */

	public void obtenirMetadonnees(Rafraichissable r, String id)

	{

		ImageCarnet im = (ImageCarnet)cacheImage.get(id) ;

		Object meta[] = new Object[3] ;

		meta[0] = im.getMetadonnesExif() ;

		meta[1] = im.getMetadonnesIptc() ;

		meta[2] = im.getInfoGenerales() ;

		r.rafraichir(meta,false) ;

	}

	/**

	 * Va chercher les mots clés associés à une image dans la liste

	 * des images chargée dans le modèle

	 * @param r le rafraichissable auquel on enverra les informations

	 * @param id l'identifiant de l'image

	 */

	public void obtenirMotsClesId(Rafraichissable r, String id)

	{

		ImageCarnet im = cacheImage.get(id) ;

		String motsClesId = im.getMotsCles() ;

		String[] motsClesIdTab = motsClesId.split(",") ;

		r.rafraichir(motsClesIdTab, false) ;

	}

	/**

	 * Met à jour la liste des images en local et appelle le DAO de mise

	 * à jour pour les commentaires et la date des images selectionnées

	 * @param commentaires le commentaire à appliquer

	 * @param date la date à appliquer

	 * @param ids les identifiants des images selectionnées

	 */

	public void mettreAJourCacheImage(String commentaires, String date, String note, String ids[])

	{

			for (int i = 0; i < ids.length; i++)

			{

				String key = ids[i] ;

				ImageCarnet ic = cacheImage.get(key) ;

				ic.miseAJourInfoGenerales(commentaires, date, note) ;

				mettreAjourBaseDeDonneesImageCarnet(ic) ;

			}

	}

	/**

	 * Ajoute un nouveau mot clés à la liste des mots clés locale

	 * @param text le mot clé

	 * @param id l'identifiant du mot clé

	 */

	public void mettreAjourMotsClesId(String text, String id)

	{

				 motsCles.put(id, text) ;

	}

	/**

	 * Appelle le DAO chargé de mettre à jour la base de données avec

	 * les toutes les informations des images modifiées par l'utilisateur

	 */

	public void mettreAJourBaseDeDonneesListeImageCarnet()

	{

		ListeImageAsynchroneDAO liDaO = new ListeImageAsynchroneDAO(this);

		liDaO.SynchroniserBaseDeDonnees(cacheImage);

	}

	/**

	 * Appelle le DAO chargé de mettre à jour la base de données avec

	 * les toutes les informations d'une image donnée

	 * @param ic l'image à synchroniser avec la base

	 */

	public void mettreAjourBaseDeDonneesImageCarnet(ImageCarnet ic)

	{

		ImageAsynchroneDAO iaDaO = new ImageAsynchroneDAO(this);

		iaDaO.SynchroniserBaseDeDonnees(ic) ;

	}

	/**

	 * Supprime les images données du cache local et appelle le DAO

	 * qui les supprime de la base de données

	 * @param ids les identifiants des images selectionnées

	 */

	public void supprimerImages(String[] ids)

	{

		String rids[] = new String[ids.length] ;

		ListeImageAsynchroneDAO liDao = new ListeImageAsynchroneDAO(this) ;

		for (int i = 0; i < ids.length; i++)

		{

			String key = ids[i] ;

			ImageCarnet ic = cacheImage.get(key) ;

			rids[i] = ic.getId() ;

			cacheImage.remove(key) ;

		}

		if(rids.length != 0)

		{

			liDao.supprimerBaseDeDonnees(rids);

		}

	}

	/**

	 * Met à jour les données locales suivant le type des nouvelles données

	 * et appelle le médiateur pour le notifier de la mise à jour

	 */

	public void rafraichir(Object nouvelleDonnees, boolean repandreRafraichissement)

	{

		// si l'on a reçu une liste d'images

		if(nouvelleDonnees instanceof ListeImageCarnet)

		{

				ListeImageCarnet data = (ListeImageCarnet) nouvelleDonnees ;

				Object[][] photoData = new Object[data.size()][8];

				int i = 0 ;

				if(data.size() == 0)

				{

					pageEncours = 0 ;

				}

				// on la parse et on récupère les informations quiç nous interessent

				for (Iterator<String> it = data.keySet().iterator(); it.hasNext();)

				{

					ImageCarnet im =  data.get(it.next());

					photoData[i][0] = im.getOrdre() ;

					photoData[i][1] = im.getDate() ;

					photoData[i][2] = im.getIptcCity() ;

					photoData[i][3] = im.getMake()+" "+im.getModel() ;

					photoData[i][4] = im.getSUrl() ;

					photoData[i][5] = im.getMUrl() ;

					photoData[i][6] = im.getLUrl() ;

					photoData[i][7] = im.getNote() ;

					i++ ;

				}

				// creation du store qui les contient

				FieldDef defNumImage = new IntegerFieldDef("num_image");

				FieldDef defDatImage = new StringFieldDef("dat_image");

				FieldDef defLieImage = new StringFieldDef("lie_image");

				FieldDef defAppImage = new StringFieldDef("app_image");

				FieldDef defUrlImageS = new StringFieldDef("url_image_S");

				FieldDef defUrlImageM = new StringFieldDef("url_image_M");

				FieldDef defUrlImage = new StringFieldDef("url_image");

				FieldDef defNoteImage = new IntegerFieldDef("note_image") ;

				FieldDef[] defTab = {defNumImage,defDatImage,defLieImage,defAppImage,defUrlImageS,defUrlImageM,defUrlImage,defNoteImage};

				RecordDef rd = new RecordDef(defTab) ;

				final MemoryProxy dataProxy = new MemoryProxy(photoData);

				final ArrayReader reader = new ArrayReader(rd);

				final Store photoStore = new Store(dataProxy, reader);

				rafraichirListeImage(nouvelleDonnees);

				st = photoStore ;

				st.load() ;

				// par défaut le store est trié sur le numéro d'image

				st.sort("num_image") ;

				// si on doit répandre les données, on notifie le médiateur qui les distribuera à son tour

				if(repandreRafraichissement)

				{

					getIMediateur().synchroniserDonneesZoomListeGalerie(st, this) ;

				}

		}

		// si on reçoit un tableau JSON

		if(nouvelleDonnees instanceof JSONArray)

		{

			// alors on a reçu les informations sur les mots clés

			JSONArray reponse = (JSONArray)nouvelleDonnees ;

			final int taillemax = reponse.size();

			// si le tableau est vide

			if(taillemax == 0)

			{

				// on crée un arbre vide

				TreeNode root = new TreeNode() ;

				root.setId("racine") ;

				root.setText("Tags") ;

				String[] usObj = {"Tags","racine"} ;

				root.setUserObject(usObj) ;

				arbreMotsCles.setRootNode(root) ;

			}

			// pour chacun des élements du tableau

			for (int j = 0; j < taillemax ; j++)

			{

				// on extrait les élements du tableau

				if(reponse.get(j).isObject() != null)

				{

					JSONObject noeud = (JSONObject)reponse.get(j) ;

					String id_noeud = noeud.get("cmc_id_mot_cle_utilisateur").isString().stringValue() ;

					String mot_cle = noeud.get("cmc_mot_cle").isString().stringValue() ;

					String parent = noeud.get("cmc_id_parent").isString().stringValue() ;

					String[] usObj = {mot_cle, id_noeud} ;

					// et on construit l'arbre à partir de la racine (qui est toujoursl e premier élément)

					if(id_noeud.equals("racine"))

					{

						TreeNode root = new TreeNode() ;

						root.setId(id_noeud) ;

						root.setText(mot_cle) ;

						root.setUserObject(usObj) ;

						arbreMotsCles.setRootNode(root) ;

					}

					else

					{

						// et en ajoutant les noeuds un à un (qui sont renvoyé dans l'ordre hierarchique de leur niveau

						// ce qui permet de les traiter séquentiellement)

						TreeNode node = new TreeNode() ;

						node.setId(id_noeud) ;

						node.setText(mot_cle) ;

						node.setChecked(false) ;

						Node parentNode = arbreMotsCles.getNodeById(parent) ;

						node.setUserObject(usObj) ;

						parentNode.appendChild(node) ;

					}

				}

			}

				// enfin on met à jour l'arbre des mots clés contenu dans le modèle

				rafraichirArbreMotsCles(arbreMotsCles) ;

				// et on notifie le médiateur de la mise à jour en lui passant une copie des données

				getIMediateur().rafraichirArbreMotsCles(arbreMotsCles) ;

		}

		// Si on reçoit un tableau d'entiers

		// c'est un tableau d'un seul entier qui est le nombre d'images correspondant aux critères

		if(nouvelleDonnees instanceof int[])

		{

			int[] pages = (int[])nouvelleDonnees ;

			// on calcule le nombre de pages nécessaires et on les met à jour dans le modèle

			pageMax  = calculerNbPages(pages[0]) ;

			nbElements = pages[0] ;

			// et on notifie de le mediateur du changement des valeurs

			getIMediateur().changerPageMaxEtCourante(pageMax,pageEncours,taillePage,pages[0]) ;

		}

	}

	/**

	 * Affiche les paires / valeur de tous les mots clés stockés

	 */

	public void afficherMotsCles()

	{

		for(Iterator<String> it = motsCles.keySet().iterator() ; it.hasNext() ;)

		{

			String key = it.next() ;

			String valeur = (String)motsCles.get(key) ;

			System.out.println("clé : "+key+" valeur : "+valeur);

		}

	}

	/**

	 * Met à jour les mots clés associés à une image et appelle le DAO pour synchroniser la base de données

	 * @param ids les identifiants des images selectionnées

	 * @param motsClesEnCours les mots clés à appliquer aux images

	 * @param arbreMC l'arbre de mots clés en cours

	 */

	public void mettreAjourMotsCles(String[] ids, String motsClesEnCours, com.gwtext.client.data.Tree arbreMC)

	{

		for (int i = 0; i < ids.length; i++)

		{

			if(cacheImage.containsKey(ids[i]))

			{

				ImageCarnet ic = (ImageCarnet)cacheImage.get(ids[i]) ;

				ic.mettreAjourMotsCles(motsClesEnCours) ;

				ImageAsynchroneDAO imgDao = new ImageAsynchroneDAO(this) ;

				imgDao.SynchroniserMotsClesImageBaseDeDonnees(ic) ;

			}

		}

		rafraichirArbreMotsCles(arbreMC) ;

	}

	/**

	 * Appelle le DAO des mots clés pour obtenir l'arbre complet stocké dans la base de données

	 */

	public void initialiserArbreMotsCles()

	{

		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this) ;

		MCDao.obtenirListeMotsCles(this) ;

	}

	/**

	 * Envoie l'arbre des mots clés stocké localement à l'élément rafrachissable donné, qui le demande

	 * @param r le rafraichissable demandeur de l'arbre

	 */

	public void obtenirArbreMotCle(Rafraichissable r)

	{

		r.rafraichir(arbreMotsCles, false) ;

	}

	/**

	 * Ajoute un mot clé à l'arbre des mots clés local et appelle le DAO qui fait la mise

	 * à jour de l'arbre des mots clés dans la base

	 * @param n le nouveau noeud contenant le mot clé

	 * @param arbreMC l'arbre des mots cles en cours

	 */

	public void ajouterMotCleDansArbre(TreeNode n, com.gwtext.client.data.Tree arbreMC)

	{

		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this) ;

		String[] usObj = (String[])n.getUserObject() ;

		String motCle = usObj[0] ;

		String id = usObj[1] ;

		String parentId = "" ;

		if(!id.equals("racine"))

		{

			String[] parentUsObj = (String[])n.getParentNode().getUserObject() ;

			parentId = parentUsObj[1] ;

		}

		else

		{

			parentId = "racine" ;

		}

		rafraichirArbreMotsCles(arbreMC) ;

		String nouveauMotCle = "&identifiant="+getIdentifiant()+"&motcle="+motCle+"&id="+id+"&parent="+parentId ;

		MCDao.ajouterBaseDeDonnees(nouveauMotCle) ;

	}

	/**

	 * Supprime un noeud de l'arbre des mots clés et appelle le DAO qui va supprimer

	 * les mots clés associés dans la base

	 * @param n le noeud à supprimer

	 * @param arbreMC l'arbre des mots clés en cours

	 */

	public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC)

	{

		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this) ;

		String[] usObj = (String[])n.getUserObject() ;

		String id = usObj[1] ;

		MCDao.supprimerBaseDeDonnees(id) ;

	}

	/**

	 * Modifie le noeud donné dans l'arbre des mots clés en cours et appelle le DAO

	 * qui synchronise la modification dans la base de données

	 * @param n le noeud modifié

	 * @param arbreMC l'arbre des mots clés en cours

	 */

	public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC)

	{

		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this) ;

		String[] usObj = (String[])n.getUserObject() ;

		String motCle = usObj[0] ;

		String id = usObj[1] ;

		String parentId = "" ;

		if(!id.equals("racine"))

		{

			String[] parentUsObj = (String[])n.getParentNode().getUserObject() ;

			parentId = parentUsObj[1] ;

		}

		else

		{

			parentId = "racine" ;

		}

		rafraichirArbreMotsCles(arbreMC) ;

		String motCleModifie = "&motcle="+motCle+"&id="+id+"&parent="+parentId ;

		MCDao.modifierBaseDeDonnees(motCleModifie) ;

	}

	/**

	 * Deplace un noeud dans l'arbre des mots cles et appelle le DAO qui reorganise l'arbre

	 * dans la base de donnees suivant le changement

	 * @param n le noeud deplace (et son sous arbre associe)

	 * @param arbreMC l'arbre des mots cles en cours

	 */

	public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC)

	{

		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO(this) ;

		String[] usObj = (String[])n.getUserObject() ;

		String motCle = usObj[0] ;

		String id = usObj[1] ;

		String parentId = "" ;

		if(!id.equals("racine"))

		{

			String[] parentUsObj = (String[])n.getParentNode().getUserObject() ;

			parentId = parentUsObj[1] ;

		}

		else

		{

			parentId = "racine" ;

		}

		rafraichirArbreMotsCles(arbreMC) ;

		String motCleModifie = "&motcle="+motCle+"&id="+id+"&parent="+parentId ;

		MCDao.deplacerBaseDeDonnees(motCleModifie) ;

	}

	/**

	 * Change le numéro de la page en cours et envoie une demande de mise à jour des données

	 * @param nouvellePageCourante la nouvelle page à afficher

	 */

	public void changerNumeroPage(int nouvellePageCourante)

	{

			pageEncours = nouvellePageCourante ;

			obtenirPhotoGalerie(this) ;

	}

	/**

	 * Calcule le nombre de pages nécessaires pour afficher un nombre d'élements donnés en fonction de la taille de page

	 * en cours

	 * @param nbElements le nombre d'élements total

	 * @return le nombre de pages

	 */

	public int calculerNbPages(int nbElements)

	{

		// A cause de la betise de java pour les conversion implicite on fait quelques conversions manuellement

		// pour eviter qu'il arrondisse mal la division

		// nombre de pages = (nombre d'element / taille de la page) arrondie à l'entier superieur

		double nPage = (1.0*nbElements)/(1.0*taillePage) ;

		double nPageRound = Math.ceil(nPage) ;

		Double nPageInt = new Double(nPageRound) ;

		// on convertit en entier

		return nPageInt.intValue() ;

	}

	/**

	 * Recalcule la page en cours lors du changement du nombre d'élements

	 * @param nbElements le nombre d'élements total

	 * @return la nouvelle page encours

	 */

	public int calculerPageCourante(int nbElements)

	{

		// on calcule le nombre de page

		int nouvelNbPages = calculerNbPages(nbElements) ;

		// la nouvelle page en cours

		double nPageCourante = (1.0*pageEncours)/(1.0*pageMax) * (1.0*nouvelNbPages) ;

		// on arrondit au supérieur

		double nPageRound = Math.ceil(nPageCourante) ;

		Double nPageInt = new Double(nPageRound) ;

		// on convertit en entier

		return Math.abs(nPageInt.intValue()) ;

	}

	/**

	 * Change la taille de page et recalcule la page encours

	 * @param nouvelleTaillePage la nouvelle taille de page à utiliser

	 */

	public void changerTaillePage(int nouvelleTaillePage)

	{

		taillePage = nouvelleTaillePage ;

		pageEncours = calculerPageCourante(nbElements) ;

		obtenirPhotoGalerie(this) ;

	}

	/**

	 * Notifie le mediateur que l'upload ou le download est termine et qu'il faut rafraichir les vues avec les nouvelles données

	 */

	public void requeteTerminee()

	{

		getIMediateur().demasquerChargement() ;

		getIMediateur().rafraichirToutesVues() ;

	}

	/**

	 * Obtient l'identifiant de l'utilisateur auprès du médiateur

	 * @return id de l'utilisateur

	 */

	public String getIdentifiant() {

		return getIMediateur().getIdentifiant() ;

	}

	/**

	 * renvoie la taille d'une image grâce à son identifiant

	 * @param id l'identifiant de l'image

	 * @return un tableau contenant la longueur et la hauteur de l'image

	 */

	public String[] obtenirTailleImage(String id) {

		return  (cacheImage.get(id)).getTailleImage() ;

	}

	/**

	 * Suivant l'id d'une image donnée, fais une demande au modèle pour qu'il

	 * renvoie la note associée au rafrachissable qui la demande

	 * @param r le rafraichissable demandeur de l'information

	 * @param id l'identifiant del'image

	 */

	public void obtenirNote(Rafraichissable r, String id) {

		r.rafraichir((cacheImage.get(id)).getNote() ,true) ;

	}

	/**

	 * Accesseur pour la configuration en cours d'utilisation

	 * @return la configuration

	 */

	public Configuration getConfig() {

		return config ;

	}

}