/ - Diff - | gvSIG desktop 1 - gvSIG

Revision 26870

     package com.iver.utiles.extensionPointsOld;
     /**
      * @deprecated @see org.gvsig.tools.extensionPoint.ExtensionPointsSingleton
      */
     public class ExtensionPointsSingleton extends ExtensionPoints {
     	private static final long serialVersionUID = -630976693542039111L;
     	private static ExtensionPoints extensionPoints = new ExtensionPointsSingleton();
     	private ExtensionPointsSingleton() {
     		super();
+    	}
     	public static ExtensionPoints getInstance() {
     		return ExtensionPointsSingleton.extensionPoints;
+    	}
+    }

     package com.iver.utiles.extensionPointsOld;
     import java.util.Map;
     /**
      * Interface utilizado para indicar al registro de extensiones que no se trata
      * de una clase lo que hey registrado, si no una instancia de un objeto a usar
      * para crear la extension.
+     *
+     *
      * @author jjdelcerro
      * @deprecated @see org.gvsig.tools.extensionPoint.IExtensionBuilder
      */
     public interface IExtensionBuilder {
     	/**
     	 * Crea una instancia de la extension y la retorna.
     	 * <br>
     	 * @return
     	 */
     	public Object create();
     	/**
     	 * Crea una instancia de la extension y la retorna.
     	 * <br>
     	 * En <i>args</i> recibira la lista de argumeentos a utilizar
     	 * para crear la extension.
     	 * <br>
     	 * @param args
     	 * @return
     	 */
     	public Object create(Object [] args);
     	public Object create(Map args);
+    }

     <html>
     <body>
     <p>
     Este paquete expone un mecanismo para registro de clases.
     </p>
     <p>
     Permite registrar clases o factorias de clases que luego pueden ser
     recuperadas para construir instancias.
     </p>
     <p>
     La finalidad de este registro es el manejo de puntos de extension a una
     aplicacion. Una aplicacion declara o registra con un nombre los puntos de
     extension que va a tener. Cada punto de extension puede tener registradas una
     o mas extensiones. Cuando se quiere a?adir una extension a la aplicacion, se
     registra la clase o factoria que gestiona esa extension para el punto de extension
     que se desee.
     </p>
     <p>
     Veamos esto con un ejemplo.
     </p>
     <p>
     Supongamos que queremos a?adir un punto de extension a la aplicacion gvSIG, que
     permita asignar un mecanismo de presentacion de la informacion asociada a la
     herramienta de "informacion" especializada segun el tipo de tema sobre el que se
     esta trabajando.
     </p>
     <p>
     Lo primero que tendriamos que hacer es darle un nombre al punto de extension.
     Lo llamaremos "InfoByPoint". Para esto, la aplicacion que valla a utilizar
     las extensiones que se registren en este punto deberia hacer lo siguiente:
     </p>
     <pre>
       ExtensionPoint infoByPoint = new ExtensionPoint("InfoByPoint","Registra las distintas extensiones que se pueden a?adir al 'InfoByPoint'");
       ExtensionPoints extensionPoints = ExtensionPointsSingleton.getInstance();
       extensionPoints.put(infoByPoint);
     </pre>
     <p>
     Con esto creamos un punto de extension de nombre "InfoByPoint", recogemos la
     instancia del registro de extensiones e insertamos el nuevo punto de extenstion
     en el.<br>
     Normalmente esta operacion, en el contexto de gvSIG, se realizaria en la
     inicializacion de la extension de andami en la que vallamos a a?adir
     la herramienta de informacion.
     </p>
     <p>
     Las extensiones a registrar en el "InfoByPoint" podrian consistir un un
     JPanel que gestione la presentacion a usar para el tema.
     </p>
     <p>
     Luego, desde la parte de la aplicacion que necesite a?adir nueva funcionalidad
     en este punto de extension, se deberia a?adir la extension. Por ejemplo
     en la extension de andami de WMS, se podria a?adir a "InfoByPoint" la posibilidad
     de usar una forma especial de presentacion. Podria hacerse:
     </p>
     <pre>
         ExtensionPoints extensionPoints = ExtensionPointsSingleton.getInstance();
         extensionPoints.add("InfoByPoint","WMS",PanelQueGestionaLaExtension);
     </pre>
     <p>
     Donde "PanelQueGestionaLaExtension" sera el JPanel que gestiona la extension para
     "InfoByPoint" de WMS.
     </p>
     <p>
     Si quieran acceder a la extension de nombre "WMS"
     se haria:
     </p>
     <pre>
         ExtensionPoints extensionPoints = ExtensionPointsSingleton.getInstance();
         ExtensionPoint infoByPoint = (ExtensionPoint)extensionPoints.get("InfoByPoint");
         Object ext = infoByPoint.create("WMS");
     </pre>
     <p>
     Y esto nos devolberia un objeto JPanel que gestiona la extension "WMS"
     para el "InfoByPoint".
     </p>
     <p>
     Si quisiesemos recorrer las distintas extensiones de ese punto podriamos
     hacerlo asi:
     </p>
     <pre>
         ExtensionPoints extensionPoints = ExtensionPointsSingleton.getInstance();
         ExtensionPoint infoByPoint = (ExtensionPoint)extensionPoints.get("InfoByPoint");
         Iterator infoByPoint =infoByPoint.keySet().iterator();
         while( i.hasNext() ) {
           String nombre = (String)i.next();
           ...
           // Y para crear los JPanel asociados a la extension...
           Object panel = infoByPoint.create(nombre);
           ...
+        }
     </pre>
     <p>
     Ademas de registrar clases en un punto de extension, se pueden registrar
     instancias que implementen el interface de IExtensionBuilder. En este caso,
     cuando se invoque al metodo "create" del punto de extension, en lugar
     de crear una instancia, como no tiene la clase, este invocara al metodo
     create del objeto que ha sido registrado.
     </p>
     <p>
     Podemos encontrar un ejemplo de esto en la extension de JDBC para el
     catalogo. Como no existe una capa especifica para las capas JDBC, en lugar
     de registrar en el punto de extension una clase "capa JDBC", se registra
     una clase que implementa el interface IExtensionBuilder, que en su
     metodo create construye una capa vectorial y la inicializa de la forma
     apropiada para funcionar con la fuente de datos de JDBC.
     </p>
     <p>
     Hay que tener en cuenta que para un punto de extension dado, deberia ser
     trasparente que se registren en el clases o instancias que contruyen las clases.
     E incluso que es posible mezclar en un punto de extension los dos
     mecanismos, como es el caso del catalogo.
     </p>
     </body>
     </html>

     package com.iver.utiles.extensionPointsOld;
     import java.lang.reflect.Constructor;
     import java.lang.reflect.InvocationTargetException;
     import java.util.Map;
     /**
      * Clase de utilidad usada para crear las extensiones.
+     *
      * Esta clase presenta un par de metodos estaticos para permitir crear un objeto
      * a partir de una clase.
+     *
      * @author jjdelcerro
      * @deprecated @see org.gvsig.tools.extensionPoint.ExtensionBuilder
      */
     public abstract class ExtensionBuilder implements IExtensionBuilder {
     	/**
     	 * Crea un objeto de la clase indicada.
+    	 *
     	 * @param cls Clase de la que crear la instancia
     	 * @return
+    	 *
     	 * @throws InstantiationException
     	 * @throws IllegalAccessException
     	 */
     	public static Object create(Class cls) throws InstantiationException, IllegalAccessException {
     		Object obj = null;
     		if( cls == null ) {
     			return null;
+    		}
     		obj = cls.newInstance();
     		return obj;
+    	}
     	/**
     	 * Crea un objeto de la clase indicada.
+    	 *
     	 * Crea un objeto de la clase indicada pasandole al constructor
     	 * los argumentos indicados en <i>args</i>.
     	 * <br>
     	 * @param cls Clase de la que crear la instancia
     	 * @param args Argumentos que pasar al constructor.
     	 * @return
+    	 *
     	 * @throws SecurityException
     	 * @throws NoSuchMethodException
     	 * @throws IllegalArgumentException
     	 * @throws InstantiationException
     	 * @throws IllegalAccessException
     	 * @throws InvocationTargetException
     	 */
     	public static Object create(Class cls, Object [] args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
     		Object obj = null;
     		Constructor create = null;
     		Class [] types = new Class[args.length];
     		if( cls == null ) {
     			return null;
+    		}
     		for( int n=0 ; n<args.length ; n++ ) {
     			Object arg = args[n];
     			types[n] = arg.getClass();
+    		}
     		create = cls.getConstructor(types);
     		obj = create.newInstance(args);
     		return obj;
+    	}
     	/**
     	 * Crea un objeto de la clase indicada.
+    	 *
     	 * Crea un objeto de la clase indicada pasandole al constructor
     	 * un como argumento un Map..
     	 * <br>
     	 * @param cls Clase de la que crear la instancia
     	 * @param args Map a pasar como argumento al constructor.
     	 * @return
+    	 *
     	 * @throws SecurityException
     	 * @throws NoSuchMethodException
     	 * @throws IllegalArgumentException
     	 * @throws InstantiationException
     	 * @throws IllegalAccessException
     	 * @throws InvocationTargetException
     	 */
     	public static Object create(Class cls, Map args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
     		Object obj = null;
     		Constructor create = null;
     		Class [] types = new Class[1];
     		Object [] argsx = new Object[1];
     		if( cls == null ) {
     			return null;
+    		}
     		types[0] = Map.class;
     		argsx[0] = args;
     		create = cls.getConstructor(types);
     		obj = create.newInstance(argsx);
     		return obj;
+    	}
+    }

     package com.iver.utiles.extensionPointsOld;
     import java.lang.reflect.InvocationTargetException;
     import java.security.KeyException;
     import java.util.*;
     /**
      * Esta clase permite registrar extensiones para un punto de extension. <br>
      * <br>
      * La clase se comporta como un Map que mantiene el orden de insercion de los
      * elementos, para que puedan ser recorridos en ese orden. <br>
      * Ademas de registrar las extensiones para un punto de extension, presenta
      * metodos para facilitar la creacion de la extension. <br>
      * A la hora de registrar una extension, mediante el metodo <i>put</i>, podremos
      * suministrarle una clase o una instancia que implemente el interface
      * IExtensionBuilder. Si le suministramos una clase, cuando queramos crear la
      * extension mediante el metodo <i>create</i>, se creara una instancia de la
      * clase y se retornara. Si lo que se suministro fue una instancia que
      * implementa el interface IExtensionBuilder, se invocara al metodo
      * <i>create</i> de esta para crear la extension. <br>
+     *
      * @author jjdelcerro
+     *
      * @deprecated @see org.gvsig.tools.extensionPoint.ExtensionPoint
      */
     public class ExtensionPoint extends LinkedHashMap {
         private static final long serialVersionUID = -5908427725588553371L;
     	private String name;
     	private String description;
     	private Hashtable extensionDescriptions = new Hashtable();
     	private Hashtable aliases = new Hashtable();
     	/**
     	 * Construye un punto de extension.
     	 * <br>
     	 * @param extensionPointName Nombre del punto de extension.
     	 */
     	public ExtensionPoint(String extensionPointName) {
     		this.name = extensionPointName;
+    	}
     	/**
     	 * Construye un punto de extension.
     	 * <br>
     	 * @param extensionPointName Nombre del punto de extension
     	 * @param description Descripcion del punto de extension
     	 */
     	public ExtensionPoint(String extensionPointName, String description) {
     		this.name = extensionPointName;
     		this.description = description;
+    	}
     	/**
     	 * Retorna el nombre de punto de extension.
     	 * <br>
     	 * @return Nombre del punto de extension
     	 */
     	public String getName() {
     		return this.name;
+    	}
     	/**
     	 * Retorna la descripcion asociada al punto de extension.
     	 * <br>
     	 * @return descripcion del punto de extension
     	 */
     	public String getDescription() {
     		return this.description;
+    	}
     	/**
     	 * Asocia una descripcion al punto de extension.
     	 * <br>
+    	 *
     	 * @param description
     	 */
     	public void setDescripcion(String description) {
     		this.description = description;
+    	}
     	/**
     	 * Retorna la descripcion asociada a una extension.
     	 * <br>
     	 * @param key
     	 * <br>
     	 * @return descripcion del punto de extension
     	 */
     	public String getExtensionDescription(String key) {
     		return (String)this.extensionDescriptions.get(key);
+    	}
     	/**
     	 * Asocia una descripcion a una extension registrada.
     	 * <br>
+    	 *
     	 * @param key Nombre de la extension
     	 * @param description
     	 */
     	public void setExtensionDescription(String key,String description) {
     		if (this.containsKey(key)) {
     			this.extensionDescriptions.put(key,description);
+    		}
+    	}
     	/**
     	 * A?ade una extension con su descripcion asociada
+    	 *
     	 * @param key clave de la extension
     	 * @param decription descripcion de la extension
     	 * @param value extension
     	 */
     	public Object put(String key, String description,Object value) {
     		this.extensionDescriptions.put(key,description);
     		return super.put(key,value);
+    	}
     	/**
     	 * A?ade una extension antes de la indicada con beforeKey,
     	 * con su descripcion asociada
+    	 *
     	 * @param key clave de la extension
     	 * @param decription descripcion de la extension
     	 * @param value extension
     	 */
     	public Object insert(String beforeKey, String key, String description,Object value) {
     		boolean mover = false;
     		Map tmp = new LinkedHashMap();
     		for (Iterator i = this.entrySet().iterator(); i.hasNext(); ) {
                 Map.Entry e = (Map.Entry)i.next();
                 if ( e.getKey().equals(beforeKey) ) {
                 	mover = true;
+                }
                 if( mover ) {
                 	tmp.put(e.getKey(), e.getValue());
+                }
+            }
     		for (Iterator i = tmp.keySet().iterator(); i.hasNext(); ) {
     			String key1 = (String)i.next();
     			this.remove(key1);
+    		}
     		if ( description!= null ) {
     			this.extensionDescriptions.put(key,description);
+    		}
     		Object returnValue = super.put(key,value);
     		this.putAll(tmp);
     		return returnValue;
+    	}
     	/**
     	 * Crea una extension.
     	 * <br>
     	 * Dado un nombre de extension asociada a este punto de extension, crea
     	 * el objeto registrado para manejar la extension.
     	 * <br>
     	 * Si el objeto registrado para esa extension implementa el interface
     	 * <i>IExtensionBuilder</i>, se invoca al metodo create para crear la instancia
     	 * de la extension.
     	 * <br>
     	 * Si no implementa este interface, debera ser una clase, y se creara una
     	 * instancia de esa clase.
     	 * <br>
     	 * @param name Nombre de la extension a crear.
     	 * @return La instancia creada de la extension.
+    	 *
     	 * @throws InstantiationException
     	 * @throws IllegalAccessException
     	 */
     	public Object create(String name) throws InstantiationException, IllegalAccessException {
     		Object extension = this.get(name);
     		if (extension == null) {
     			extension = this.get(this.aliases.get(name));
+    		}
     		if( extension instanceof IExtensionBuilder ) {
     			return ((IExtensionBuilder)extension).create();
+    		}
     		return ExtensionBuilder.create((Class) extension);
+    	}
     	/**
     	 * Crea una extension.
     	 * <br>
     	 * Dado un nombre de extension asociada a este punto de extension, crea
     	 * el objeto registrado para manejar la extension.
     	 * <br>
     	 * A la hora de crear la instancia de la extension, le pasara los parametros
     	 * indicados en <i>args</i>.
     	 * <br>
     	 * Debido a que los argumentos se pasan como un array de objetos, no es posible
     	 * pasar al constructor de la extension parametros de tipos basicos como <i>int</i>
     	 * o <i>long</i>. Se deberan pasar como objetos y existir un constructor de la clase
     	 * que los pueda recibir de esta manera.
     	 * <br>
     	 * @param name Nombre de la extension a crear.
     	 * @param args Array de objetos a pasar como parametros en la construccion de la instancia de la extension.
     	 * @return La instancia creada de la extension.
+    	 *
     	 * @throws SecurityException
     	 * @throws NoSuchMethodException
     	 * @throws IllegalArgumentException
     	 * @throws InstantiationException
     	 * @throws IllegalAccessException
     	 * @throws InvocationTargetException
     	 */
     	public Object create(String name, Object [] args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
     		Object extension = this.get(name);
     		if (extension == null) {
     			extension = this.get(this.aliases.get(name));
+    		}
     		if( extension instanceof IExtensionBuilder ) {
     			return ((IExtensionBuilder)extension).create(args);
+    		}
     		return ExtensionBuilder.create((Class) extension, args);
+    	}
     	public Object create(String name, Map args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
     		Object extension = this.get(name);
     		if (extension == null) {
     			extension = this.get(this.aliases.get(name));
+    		}
     		if( extension instanceof IExtensionBuilder ) {
     			return ((IExtensionBuilder)extension).create(args);
+    		}
     		return ExtensionBuilder.create((Class) extension, args);
+    	}
     	/**
     	 * Crea un alias para una extension registrada.
     	 * <br>
     	 * @param item Nombre de la extension registrada.
     	 * @param alias alias a a?adir.
+    	 *
     	 **/
     	public void addAlias(String item, String alias) throws KeyException{
     		if (!this.containsKey(item)) {
     			throw new KeyException(item);
+    		}
     		this.aliases.put(alias,item);
+    	}
+    }

     package com.iver.utiles.extensionPointsOld;
     import java.util.TreeMap;
     /**
      * Clase para registro de puntos de extension. <br>
      * <br>
+     *
      * @author jjdelcerro
      * @deprecated @see org.gvsig.tools.extensionPoint.ExtensionPoints
      */
     public class ExtensionPoints extends TreeMap {
     	private static final long serialVersionUID = -798417910971607414L;
     	/**
     	 * Evita que se a?adan elementos que no son puntos de extension.
     	 * <br>
     	 * <br>
     	 * Aunque la clase se comporta como un <i>Map</i>, no esta permitido
     	 * a?adir a esta objetos que no sean de la clase <i>ExtensionPoint</i>.
     	 * Si intentamos a?adir un elemento que no sea de esta clase, se disparara
     	 * una excepcion ClassCastException.
     	 * <br>
     	 * <br>
     	 * @see java.util.Map#put(java.lang.Object, java.lang.Object)
     	 */
     	public Object put(Object key, Object value) throws ClassCastException  {
     		throw  new ClassCastException();
+    	}
     	/**
     	 * A?ade un punto de extension al registro de puntos de extension.
     	 * <br>
     	 * <br>
     	 * Mediante este metodo puede a?adir un punto de extension al registro
     	 * de puntos de extension, llevandose detras todas las extensiones que
     	 * esten registradas en el.
     	 * <br>
     	 * <br>
     	 * En caso de que ya existiese un punto de extension con el nombre dado,
     	 * a?adira a este las extensiones del punto de extension suministrado.
     	 * <br>
     	 * <br>
     	 * @param value Punto de extension a registrar
     	 * @return
+    	 *
     	 */
     	public Object put(ExtensionPoint value) {
     		return put(value.getName(),value);
+    	}
     	/**
     	 * A?ade un punto de extension al registro de puntos de extension.
     	 * <br>
     	 * <br>
     	 * Mediante este metodo puede a?adir un punto de extension al registro
     	 * de puntos de extension, llevandose detras todas las extensiones que
     	 * esten registradas en el.
     	 * <br>
     	 * <br>
     	 * En caso de que ya existiese un punto de extension con el nombre dado,
     	 * a?adira a este las extensiones del punto de extension suministrado.
     	 * <br>
     	 * <br>
     	 * Cuando se a?ade un punto de extension, es imprescindible que <i>key</i> y
     	 * el nombre del punto de extension que se este a?adiendo coincidan.
     	 * <br>
     	 * <br>
     	 * @param key Nombre del punto de extension
     	 * @param value Punto de extension a registrar
     	 * @return
+    	 *
     	 */
     	public Object put(String key, ExtensionPoint value) {
     		if ( !value.getName().equals(key) ) {
     			throw new IllegalArgumentException ();
+    		}
     		ExtensionPoint n = (ExtensionPoint)super.get(key);
     		if( n == null ) {
     			return super.put(key,value);
+    		}
     		// Como estamos actualizando un punto de extension, a?adimos a este las
     		// extensiones del que nos acaban de suministrar.
     		n.putAll(value);
     		return value;
+    	}
     	/**
     	 * Registra una extension en un punto de extension.
     	 * <br>
     	 * <br>
     	 * Mediante este metodo puede registrar sobre un punto de extension
     	 * una extension. La extension esta identificada mediante un nombre
     	 * unico, y una clase que se usara para manejar la extension o una
     	 * clase que contruira el objeto que maneje la extension.
     	 * <br>
     	 * <br>
     	 * Si ya existe en el punto de extension indicado por <i>extensionPointName</i>
     	 * una extension con el nombre <i>name</i>, esta sera sustituida por la
     	 * nueva extension.
     	 * <br>
     	 * @param extensionPointName Nombre del punto de extension
     	 * @param name Nombre o identificador de la extension
     	 * @param data Clase que implementa la extension o que la construye.
+    	 *
+    	 *
     	 */
     	public void add(String extensionPointName, String name, Object data) {
     		ExtensionPoint extensionPoint = (ExtensionPoint)super.get(extensionPointName);
     		if( extensionPoint == null ) {
     			extensionPoint = new ExtensionPoint(extensionPointName);
     			super.put(extensionPoint.getName(), extensionPoint);
+    		}
     		extensionPoint.put(name, data);
+    	}
     	/**
     	 * Registra una extension en un punto de extension.
     	 * <br>
     	 * <br>
     	 * Mediante este metodo puede registrar sobre un punto de extension
     	 * una extension. La extension esta identificada mediante un nombre
     	 * unico, y una clase que se usara para manejar la extension o una
     	 * clase que contruira el objeto que maneje la extension.
     	 * <br>
     	 * <br>
     	 * Si ya existe en el punto de extension indicado por <i>extensionPointName</i>
     	 * una extension con el nombre <i>name</i>, esta sera sustituida por la
     	 * nueva extension.
     	 * <br>
     	 * @param extensionPointName Nombre del punto de extension
     	 * @param name Nombre o identificador de la extension
     	 * @param description descripcion de la extension.
     	 * @param data Clase que implementa la extension o que la construye.
+    	 *
+    	 *
     	 */
     	public void add(String extensionPointName, String name, String description, Object data) {
     		ExtensionPoint extensionPoint = (ExtensionPoint)super.get(extensionPointName);
     		if( extensionPoint == null ) {
     			extensionPoint = new ExtensionPoint(extensionPointName);
     			super.put(extensionPoint.getName(), extensionPoint);
+    		}
     		extensionPoint.put(name,description, data);
+    	}
+    }

Also available in: Unified diff