Application: gvSIG desktop

<?xml version="1.0" encoding="UTF-8"?>

<classpath>

    <classpathentry kind="src" path="src"/>

    <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>

    <classpathentry kind="output" path="bin"/>

</classpath>

<?xml version="1.0" encoding="UTF-8"?>

<projectDescription>

	<name>libDriverManager</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

			<name>org.eclipse.jdt.core.javabuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>de.loskutov.FileSync.FSBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

		<nature>org.eclipse.jdt.core.javanature</nature>

	</natures>

</projectDescription>

package com.hardcode.driverManager.pruebas;

import java.io.File;

import java.io.IOException;

import com.hardcode.driverManager.DriverLoadException;

import com.hardcode.driverManager.DriverManager;

/**

 * @author Fernando Gonz?lez Cort?s

 */

public class DriverManagerMain {

	public static void main(String[] args) throws IOException, DriverLoadException {

		DriverManager dm = new DriverManager();

		dm.loadDrivers(new File ("c:\\tirar\\"));

		Adder a = (Adder) dm.getDriver("num");

		System.out.println(a.add("3", "4"));

		a = (Adder) dm.getDriver("txt");

		System.out.println(a.add("3", "4"));

	}

}

package com.hardcode.driverManager.pruebas;

import com.hardcode.driverManager.Driver;

/**

 * @author Fernando Gonz?lez Cort?s

 */

public class NumericAdderDriver implements Driver, Adder{

	/**

	 * @see com.hardcode.driverManager.pruebas.Adder#add(java.lang.String, java.lang.String)

	 */

	public String add(String a, String b) {

		return new Integer(new Integer(a).intValue() + new Integer(b).intValue()).toString();

	}

	/**

	 * @see com.hardcode.driverManager.Driver#getName()

	 */

	public String getName() {

		return "drivers para n?meros del Fernan";

	}

}

package com.hardcode.driverManager.pruebas;

/**

 * @author Fernando Gonz?lez Cort?s

 */

public interface Adder {

	public String add(String a, String b);

}

package com.hardcode.driverManager.pruebas;

import com.hardcode.driverManager.Driver;

/**

 * @author Fernando Gonz?lez Cort?s

 */

public class TextAdderDriver implements Driver, Adder{

	/**

	 * @see com.hardcode.driverManager.pruebas.Adder#add(java.lang.String, java.lang.String)

	 */

	public String add(String a, String b) {

		return a+b;

	}

	/**

	 * @see com.hardcode.driverManager.Driver#getName()

	 */

	public String getName() {

		return "Driver para texto del Fernan";

	}

}

package com.hardcode.driverManager;

import java.util.Hashtable;

import java.util.Vector;

/**

 * Esta clase mantiene la informaci?n sobre los classloader de los plugins con

 * la intenci?n de poder obtener dado el nombre de una clase la lista de

 * PluginClassLoader que pueden cargarla

 *

 * @author Fernando Gonz?lez Cort?s

 */

public abstract class DriverClassLoaderManager {

    private static Hashtable nombresLista = new Hashtable();

    /**

     * Registra un class loader para una clase determinada

     *

     * @param className Nombre de la clase

     * @param cl Classloader que puede cargar la clase

     */

    public static void registerClass(String className, ClassLoader cl) {

        Vector lista = (Vector) nombresLista.get(className);

        if (lista == null) {

            lista = new Vector();

            lista.add(cl);

            nombresLista.put(className, lista);

        } else {

            lista.add(cl);

        }

    }

    /**

     * Devuelve la lista de classloader que pueden cargar la clase

     *

     * @param className Nombre de la clase de la cual se quiere obtener un

     *        classloader que la cargue

     *

     * @return Vector de classLoaders que pueden cargar una clase con ese

     *         nombre

     */

    public static Vector getClassLoaderList(String className) {

        return (Vector) nombresLista.get(className);

    }

}

package com.hardcode.driverManager;

import java.io.File;

import java.io.IOException;

import java.net.MalformedURLException;

import java.net.URL;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

/**

 * Para el driver manager, el driver viene determinado por un directorio dentro

 * del cual se encuentran uno o m?s jar's. La clase Driver ha de implementar

 * la interfaz Driver y su nombre debe terminar en "Driver" y tener un

 * constructor sin par?metros.

 * 

 * <p>

 * Esta clase es la encargada de la carga y validaci?n de los drivers y de la

 * obtenci?n de los mismo apartir de un tipo

 * </p>

 *

 * @author Fernando Gonz?lez Cort?s

 */

public class DriverManager {

	private File extDir;

	private DriverValidation validation;

	private HashMap nombreDriverClass = new HashMap();

	private ArrayList failures = new ArrayList();

	/**

	 * Devuelve un array con los directorios de los plugins

	 *

	 * @param dirExt Directorio a partir del que se cuelgan los directorios de

	 * 		  los drivers

	 *

	 * @return Array de los subdirectorios

	 */

	private File[] getPluginDirs(File dirExt) {

		if (!dirExt.exists()) {

			return new File[0];

		}

		ArrayList ret = new ArrayList();

		File[] files = dirExt.listFiles();

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

			if (files[i].isDirectory()) {

				ret.add(files[i]);

			}

		}

		return (File[]) ret.toArray(new File[0]);

	}

	/**

	 * Obtiene los jar's de un directorio y los devuelve en un array

	 *

	 * @param dir Directorio del que se quieren obtener los jars

	 *

	 * @return Array de jars

	 */

	private URL[] getJars(File dir) {

		ArrayList ret = new ArrayList();

		File[] dirContent = dir.listFiles();

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

			if (dirContent[i].getName().toLowerCase().endsWith(".jar")) {

				try {

					ret.add(new URL("file:" + dirContent[i].getAbsolutePath()));

				} catch (MalformedURLException e) {

					//No se puede dar

				}

			}

		}

		return (URL[]) ret.toArray(new URL[0]);

	}

	/**

	 * Carga los drivers y asocia con el tipo del driver.

	 *

	 * @param dir Directorio ra?z de los drivers

	 */

	public void loadDrivers(File dir) {

		try {

			if (validation == null) {

				validation = new DriverValidation() {

							public boolean validate(Driver d) {

								return true;

							}

						};

			}

			//Se obtiene la lista de directorios

			File[] dirs = getPluginDirs(dir);

			//Para cada directorio se obtienen todos sus jars

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

				URL[] jars = getJars(dirs[i]);

				//Se crea el classloader

				DriverClassLoader cl = new DriverClassLoader(jars,

						dirs[i].getAbsolutePath(),

						this.getClass().getClassLoader());

				//Se obtienen los drivers

				Class[] drivers = cl.getDrivers();

				//Se asocian los drivers con su tipo si superan la validaci?n

				for (int j = 0; j < drivers.length; j++) {

					try {

						Driver driver = (Driver) drivers[j].newInstance();

						if (validation.validate(driver)) {

							if (nombreDriverClass.put(driver.getName(),

										drivers[j]) != null) {

								throw new IllegalStateException(

									"Two drivers with the same name");

							}

						}

					} catch (ClassCastException e) {

						/*

						 * No todos los que terminan en Driver son drivers

						 * de los nuestros, los ignoramos

						 */

					} catch (Throwable t) {

						/*

						 * A?n a riesgo de capturar algo que no debemos, ignoramos cualquier driver que pueda

						 * dar cualquier tipo de problema, pero continuamos

						 */

						failures.add(t);

					}

				}

			}

		} catch (ClassNotFoundException e) {

			failures.add((Throwable) e);

		} catch (IOException e) {

			failures.add((Throwable) e);

		}

	}

	/**

	 * DOCUMENT ME!

	 *

	 * @return DOCUMENT ME!

	 */

	public Throwable[] getLoadFailures() {

		return (Throwable[]) failures.toArray(new Throwable[0]);

	}

	/**

	 * Obtiene el Driver asociado al tipo que se le pasa como par?metro

	 *

	 * @param name Objeto que devolvi? alguno de los drivers en su m?todo

	 * 		  getType

	 *

	 * @return El driver asociado o null si no se encuentra el driver

	 *

	 * @throws DriverLoadException if this Class represents an abstract class,

	 * 		   an interface, an array class, a primitive type, or void; or if

	 * 		   the class has no nullary constructor; or if the instantiation

	 * 		   fails for some other reason

	 */

	public Driver getDriver(String name) throws DriverLoadException {

		try {

			Class driverClass = (Class) nombreDriverClass.get(name);

			if (driverClass == null) throw new DriverLoadException("No se encontr? el driver: " + name);

			return (Driver) driverClass.newInstance();

		} catch (InstantiationException e) {

			throw new DriverLoadException(e);

		} catch (IllegalAccessException e) {

			throw new DriverLoadException(e);

		}

	}

	/**

	 * Establece el objeto validador de los drivers. En la carga se comprobar?

	 * si cada driver es v?lido mediante el m?todo validate del objeto

	 * validation establecido con este m?todo. Pro defecto se validan todos

	 * los drivers

	 *

	 * @param validation objeto validador

	 */

	public void setValidation(DriverValidation validation) {

		this.validation = validation;

	}

	/**

	 * Obtiene los tipos de todos los drivers del sistema

	 *

	 * @return DOCUMENT ME!

	 */

	public String[] getDriverNames() {

		ArrayList names = new ArrayList(nombreDriverClass.size());

		Iterator iterator = nombreDriverClass.keySet().iterator();

		while (iterator.hasNext()) {

			names.add((String) iterator.next());

		}

		return (String[]) names.toArray(new String[0]);

	}

	/**

	 * Obtiene la clase del driver relacionado con el tipo que se pasa como

	 * par?metro

	 *

	 * @param driverName DOCUMENT ME!

	 *

	 * @return DOCUMENT ME!

	 */

	public Class getDriverClassByName(String driverName) {

		return (Class) nombreDriverClass.get(driverName);

	}

	/**

	 * DOCUMENT ME!

	 *

	 * @param driverName DOCUMENT ME!

	 * @param superClass DOCUMENT ME!

	 *

	 * @return DOCUMENT ME!

	 *

	 * @throws RuntimeException DOCUMENT ME!

	 */

	public boolean isA(String driverName, Class superClass) {

		Class driverClass = (Class) nombreDriverClass.get(driverName);

		if (driverClass == null) {

			throw new RuntimeException("No such driver");

		}

		Class[] interfaces = driverClass.getInterfaces();

		if (interfaces != null) {

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

				if (interfaces[i] == superClass) {

					return true;

				} else {

					if (recursiveIsA(interfaces[i], superClass)) {

						return true;

					}

				}

			}

		}

		Class class_ = driverClass.getSuperclass();

		if (class_ != null) {

			if (class_ == superClass) {

				return true;

			} else {

				if (recursiveIsA(class_, superClass)) {

					return true;

				}

			}

		}

		return false;

	}

	/**

	 * DOCUMENT ME!

	 *

	 * @param interface_ DOCUMENT ME!

	 * @param superInterface DOCUMENT ME!

	 *

	 * @return DOCUMENT ME!

	 */

	private boolean recursiveIsA(Class interface_, Class superInterface) {

		Class[] interfaces = interface_.getInterfaces();

		if (interfaces != null) {

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

				if (interfaces[i] == superInterface) {

					return true;

				} else {

					if (recursiveIsA(interfaces[i], superInterface)) {

						return true;

					}

				}

			}

		}

		Class class_ = interface_.getSuperclass();

		if (class_ != null) {

			if (class_ == superInterface) {

				return true;

			} else {

				if (recursiveIsA(class_, superInterface)) {

					return true;

				}

			}

		}

		return false;

	}

}

package com.hardcode.driverManager;

/**

 * Interfaz a implementar por los objetos de validaci?n

 *

 * @author Fernando Gonz?lez Cort?s

 */

public interface DriverValidation {

    /**

     * El m?todo validate se invocar? al crear los drivers, y ser? el validador

     * el que indicar? qu? driver es v?lido para la aplicaci?n y cual no

     *

     * @param d Driver a validar

     *

     * @return true o false en caso de que el driver sea o no sea valido

     */

    public boolean validate(Driver d);

}

package com.hardcode.driverManager;

import java.io.File;

import java.io.IOException;

import java.net.MalformedURLException;

import java.net.URL;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

/**

 * Para el writer manager, el writer viene determinado por un directorio dentro

 * del cual se encuentran uno o m?s jar's. La clase Writer ha de implementar

 * la interfaz Writer y su nombre debe terminar en "Writer" y tener un

 * constructor sin par?metros.

 *

 * <p>

 * Esta clase es la encargada de la carga y validaci?n de los writers y de la

 * obtenci?n de los mismo apartir de un tipo

 * </p>

 *

 * @author Vicente Caballero Navarro

 */

public class WriterManager {

	private DriverValidation validation;

	private HashMap nombreWriterClass = new HashMap();

	private ArrayList failures = new ArrayList();

	/**

	 * Devuelve un array con los directorios de los plugins

	 *

	 * @param dirExt Directorio a partir del que se cuelgan los directorios de

	 * 		  los drivers

	 *

	 * @return Array de los subdirectorios

	 */

	private File[] getPluginDirs(File dirExt) {

		if (!dirExt.exists()) {

			return new File[0];

		}

		ArrayList ret = new ArrayList();

		File[] files = dirExt.listFiles();

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

			if (files[i].isDirectory()) {

				ret.add(files[i]);

			}

		}

		return (File[]) ret.toArray(new File[0]);

	}

	/**

	 * Obtiene los jar's de un directorio y los devuelve en un array

	 *

	 * @param dir Directorio del que se quieren obtener los jars

	 *

	 * @return Array de jars

	 */

	private URL[] getJars(File dir) {

		ArrayList ret = new ArrayList();

		File[] dirContent = dir.listFiles();

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

			if (dirContent[i].getName().toLowerCase().endsWith(".jar")) {

				try {

					ret.add(new URL("file:" + dirContent[i].getAbsolutePath()));

				} catch (MalformedURLException e) {

					//No se puede dar

				}

			}

		}

		return (URL[]) ret.toArray(new URL[0]);

	}

	/**

	 * Carga los drivers y asocia con el tipo del driver.

	 *

	 * @param dir Directorio ra?z de los drivers

	 */

	public void loadWriters(File dir) {

		try {

			if (validation == null) {

				validation = new DriverValidation() {

							public boolean validate(Driver d) {

								return true;

							}

						};

			}

			//Se obtiene la lista de directorios

			File[] dirs = getPluginDirs(dir);

			//Para cada directorio se obtienen todos sus jars

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

				URL[] jars = getJars(dirs[i]);

				//Se crea el classloader

				DriverClassLoader cl = new DriverClassLoader(jars,

						dirs[i].getAbsolutePath(),

						this.getClass().getClassLoader());

				//Se obtienen los drivers

				Class[] writers = cl.getWriters();

				//Se asocian los drivers con su tipo si superan la validaci?n

				for (int j = 0; j < writers.length; j++) {

					try {

						Driver driver = (Driver) writers[j].newInstance();

						if (validation.validate(driver)) {

							if (nombreWriterClass.put(driver.getName(),

										writers[j]) != null) {

								throw new IllegalStateException(

									"Two drivers with the same name");

							}

						}

					} catch (ClassCastException e) {

						/*

						 * No todos los que terminan en Driver son drivers

						 * de los nuestros, los ignoramos

						 */

					} catch (Throwable t) {

						/*

						 * A?n a riesgo de capturar algo que no debemos, ignoramos cualquier driver que pueda

						 * dar cualquier tipo de problema, pero continuamos

						 */

						failures.add(t);

					}

				}

			}

		} catch (ClassNotFoundException e) {

			failures.add((Throwable) e);

		} catch (IOException e) {

			failures.add((Throwable) e);

		}

	}

	/**

	 * DOCUMENT ME!

	 *

	 * @return DOCUMENT ME!

	 */

	public Throwable[] getLoadFailures() {

		return (Throwable[]) failures.toArray(new Throwable[0]);

	}

	/**

	 * Obtiene el Writer asociado al tipo que se le pasa como par?metro

	 *

	 * @param name Objeto que devolvi? alguno de los writers en su m?todo

	 * 		  getType

	 *

	 * @return El writer asociado o null si no se encuentra el driver

	 *

	 * @throws DriverLoadException if this Class represents an abstract class,

	 * 		   an interface, an array class, a primitive type, or void; or if

	 * 		   the class has no nullary constructor; or if the instantiation

	 * 		   fails for some other reason

	 */

	public Driver getWriter(String name) throws DriverLoadException {

		try {

			Class driverClass = (Class) nombreWriterClass.get(name);

			if (driverClass == null) throw new DriverLoadException("No se encontr? el writer: " + name);

			return (Driver) driverClass.newInstance();

		} catch (InstantiationException e) {

			throw new DriverLoadException(e);

		} catch (IllegalAccessException e) {

			throw new DriverLoadException(e);

		}

	}

	/**

	 * Establece el objeto validador de los drivers. En la carga se comprobar?

	 * si cada driver es v?lido mediante el m?todo validate del objeto

	 * validation establecido con este m?todo. Pro defecto se validan todos

	 * los drivers

	 *

	 * @param validation objeto validador

	 */

	public void setValidation(DriverValidation validation) {

		this.validation = validation;

	}

	/**

	 * Obtiene los tipos de todos los writers del sistema

	 *

	 * @return DOCUMENT ME!

	 */

	public String[] getWriterNames() {

		ArrayList names = new ArrayList(nombreWriterClass.size());

		Iterator iterator = nombreWriterClass.keySet().iterator();

		while (iterator.hasNext()) {

			names.add((String) iterator.next());

		}

		return (String[]) names.toArray(new String[0]);

	}

	/**

	 * Obtiene la clase del writer relacionado con el tipo que se pasa como

	 * par?metro

	 *

	 * @param driverName DOCUMENT ME!

	 *

	 * @return DOCUMENT ME!

	 */

	public Class getWriterClassByName(String writerName) {

		return (Class) nombreWriterClass.get(writerName);

	}

	/**

	 * DOCUMENT ME!

	 *

	 * @param writerName DOCUMENT ME!

	 * @param superClass DOCUMENT ME!

	 *

	 * @return DOCUMENT ME!

	 *

	 * @throws RuntimeException DOCUMENT ME!

	 */

	public boolean isA(String writerName, Class superClass) {

		Class writerClass = (Class) nombreWriterClass.get(writerName);

		if (writerClass == null) {

			throw new RuntimeException("No such driver");

		}

		Class[] interfaces = writerClass.getInterfaces();

		if (interfaces != null) {

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

				if (interfaces[i] == superClass) {

					return true;

				} else {

					if (recursiveIsA(interfaces[i], superClass)) {

						return true;

					}

				}

			}

		}

		Class class_ = writerClass.getSuperclass();

		if (class_ != null) {

			if (class_ == superClass) {

				return true;

			} else {

				if (recursiveIsA(class_, superClass)) {

					return true;

				}

			}

		}

		return false;

	}

	/**

	 * DOCUMENT ME!

	 *

	 * @param interface_ DOCUMENT ME!

	 * @param superInterface DOCUMENT ME!

	 *

	 * @return DOCUMENT ME!

	 */

	private boolean recursiveIsA(Class interface_, Class superInterface) {

		Class[] interfaces = interface_.getInterfaces();

		if (interfaces != null) {

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

				if (interfaces[i] == superInterface) {

					return true;

				} else {

					if (recursiveIsA(interfaces[i], superInterface)) {

						return true;

					}

				}

			}

		}

		Class class_ = interface_.getSuperclass();

		if (class_ != null) {

			if (class_ == superInterface) {

				return true;

			} else {

				if (recursiveIsA(class_, superInterface)) {

					return true;

				}

			}

		}

		return false;

	}

}

package com.hardcode.driverManager;

import java.io.DataInputStream;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.net.MalformedURLException;

import java.net.URL;

import java.net.URLClassLoader;

import java.security.AllPermission;

import java.security.CodeSource;

import java.security.PermissionCollection;

import java.security.Permissions;

import java.util.ArrayList;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.List;

import java.util.StringTokenizer;

import java.util.Vector;

import java.util.jar.JarException;

import java.util.zip.ZipEntry;

import java.util.zip.ZipFile;

/**

 * Class loader que carga las clases pedidas por los plugins de manera que

 * primero busca en el classpath, luego busca en el directorio del propio

 * plugin en los jars especificados por el xml y en caso de no encontrar la

 * clase pide al PluginClassLoaderManager la lista de plugins que pueden

 * satisfacer la clase e intenta cargarlo con cada un de ellos hasta que lo

 * consigue con uno.

 *

 * @author Fernando Gonz?lez Cort?s

 */

public class DriverClassLoader extends URLClassLoader {

    private Hashtable clasesJar = new Hashtable();

    private String baseDir;

    /**

     * Creates a new PluginClassLoader object.

     *

     * @param jars Array con la ruta de los jars en los que buscar? las clases

     *        el plugin

     * @param baseDir Directorio base del plugin que se carga. Es en directorio

     *        donde se buscan los resources en el m?todo getResources

     * @param cl ClassLoader padre del classLoader, al que se le pedir?

     *        resolver las clases antes de utilizar el algoritmo propio

     *

     * @throws IOException Si no se puede leer alguno de los jars

     * @throws IllegalArgumentException Si no se especifica un array de jars

     * @throws JarException Si hay dos clases con el mismo nombre en el plugin

     */

    public DriverClassLoader(URL[] jars, String baseDir, ClassLoader cl)

        throws IOException {

        super(jars, cl);

        this.baseDir = baseDir;

        if (jars == null) {

            throw new IllegalArgumentException("jars cannot be null"); //$NON-NLS-1$

        }

        //Se itera por las URLS que deben de ser jar's

        ZipFile[] jarFiles = new ZipFile[jars.length];

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

            jarFiles[i] = new ZipFile(jars[i].getPath());

            Enumeration entradas = jarFiles[i].entries();

            //Se itera por todos los .class del jar

            while (entradas.hasMoreElements()) {

                //Se obtiene la entrada

                ZipEntry file = (ZipEntry) entradas.nextElement();

                String fileName = file.getName();

                //Se obtiene el nombre de la clase

                if (!fileName.toLowerCase().endsWith(".class")) { //$NON-NLS-1$

                    continue;

                }

                fileName = fileName.substring(0, fileName.length() - 6).replace('/',

                        '.');

                //Se cromprueba si ya hab?a una clase con dicho nombre

                if (clasesJar.get(fileName) != null) {

                    throw new JarException(

                        "two or more classes with the same name in the jars: " +

                        fileName);

                }

                //Se registra la clase

                clasesJar.put(fileName, jarFiles[i]);

                DriverClassLoaderManager.registerClass(fileName, this);

            }

        }

    }

    /**

     * Carga la clase

     *

     * @param name Nombre de la clase

     * @param resolve SI se ha de resolver la clase o no

     *

     * @return Clase cargada

     *

     * @throws ClassNotFoundException Si no se pudo encontrar la clase

     */

    protected Class loadClass(String name, boolean resolve)

        throws ClassNotFoundException {

    	Class c = null;

        try {

            c = super.loadClass(name, resolve);

        } catch (ClassNotFoundException e1) {

            if (c == null) {

                // Convert class name argument to filename

                // Convert package names into subdirectories

                try {

                    ZipFile jar = (ZipFile) clasesJar.get(name);

                    if (jar == null) {

                        Vector cls = (Vector) DriverClassLoaderManager.getClassLoaderList(name);

                        if (cls != null) {

                            for (int i = 0; i < cls.size(); i++) {

                                c = ((DriverClassLoader) cls.elementAt(i)).loadClass(name,

                                        resolve);

                                if (c != null) {

                                    break;

                                }

                            }

                        }

                    } else {

                        String fileName = name.replace('.', '/') + ".class"; //$NON-NLS-1$

                        ZipEntry classFile = jar.getEntry(fileName);

                        byte[] data = loadClassData(classFile,

                                jar.getInputStream(classFile));

                        c = defineClass(name, data, 0, data.length);

                    }

                    if (c == null) {

                        throw new ClassNotFoundException(name);

                    }

                } catch (IOException e) {

                    throw new ClassNotFoundException("Error_reading_file" +

                        name); //$NON-NLS-1$

                }

            }

        }

        if (resolve) {

            resolveClass(c);

        }

        return c;

    }

    /**

     * obtiene el array de bytes de la clase

     *

     * @param classFile Entrada dentro del jar contiene los bytecodes de la

     *        clase (el .class)

     * @param is InputStream para leer la entrada del jar

     *

     * @return Bytes de la clase

     *

     * @throws IOException Si no se puede obtener el .class del jar

     */

    private byte[] loadClassData(ZipEntry classFile, InputStream is)

        throws IOException {

        // Get size of class file

        int size = (int) classFile.getSize();

        // Reserve space to read

        byte[] buff = new byte[size];

        // Get stream to read from

        DataInputStream dis = new DataInputStream(is);

        // Read in data

        dis.readFully(buff);

        // close stream

        dis.close();

        // return data

        return buff;

    }

    /**

     * Obtiene los recursos tomando como la raiz el directorio base del plugin.

     * Si no se encuentra el recurso ah? se invoca a getResource del

     * classloader padre, que buscar? en el jar de la aplicaci?n. Si ah?

     * tampoco se encuentra nada se devolver? null.

     *

     * @param res Nombre del recurso

     *

     * @return URL del recurso o null si no se pudo encontrar

     */

    public URL getResource(String res) {

        File dir = new File(baseDir);

        try {

            ArrayList resource = new ArrayList();

            StringTokenizer st = new StringTokenizer(res, "\\/");

            while (st.hasMoreTokens()) {

                String token = st.nextToken();

                resource.add(token);

            }

            URL ret = getResource(dir, resource);

            if (ret != null) {

                return ret;

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

        return super.getResource(res);

    }

    /**

     * Busca recursivamente el recurso res en el directorio base. res es una

     * lista de String's con los directorios del path y base es el directorio

     * a partir del cual se busca dicho recurso. En cada ejecuci?n del m?todo

     * se toma el primer elemento de res y se busca dicho directorio en el

     * directorio base. Si se encuentra, ser? el directorio base para una

     * nueva llamada.

     *

     * @param base Directorio desde donde parte la b?squeda del recurso.

     * @param res Lista de strings con el path del recurso que se quiere

     *        encontrar

     *

     * @return URL con el recurso

     */

    private URL getResource(File base, List res) {

        File[] files = base.listFiles();

        String parte = (String) res.get(0);

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

            if (files[i].getName().compareTo(parte) == 0) {

                if (res.size() == 1) {

                    try {

                        return new URL("file:" + files[i].toString());

                    } catch (MalformedURLException e) {

                        return null;

                    }

                } else {

                    return getResource(files[i], res.subList(1, res.size()));

                }

            }

        }

        return null;

    }

    /**

     * Devuelve el nombre del directorio del plugin

     *

     * @return

     */

    public String getPluginName() {

        String ret = baseDir.substring(baseDir.lastIndexOf(File.separatorChar) +

                1);

        return ret;

    }

    /**

     * @see java.security.SecureClassLoader#getPermissions(java.security.CodeSource)

     */

    protected PermissionCollection getPermissions(CodeSource codesource) {

        Permissions perms = new Permissions();

        perms.add(new AllPermission());

        return (perms);

    }

    /**

     * Devuelve una instancia de cada driver encontrado en los jars del

     * classloader

     *

     * @return array de drivers

     *

     * @throws ClassNotFoundException if the class cannot be located by the

     *         specified class loader

     */

    public Class[] getDrivers() throws ClassNotFoundException{

        ArrayList drivers = new ArrayList();

        Enumeration e = clasesJar.keys();

        while (e.hasMoreElements()) {

            String fileName = (String) e.nextElement();

            if (fileName.endsWith("Driver")) {

                Class driver = (Class) this.loadClass(fileName);

                drivers.add(driver);

            }

        }

        return (Class[]) drivers.toArray(new Class[0]);

    }

    /**

     * Devuelve una instancia de cada writer encontrado en los jars del

     * classloader

     *

     * @return array de drivers

     *

     * @throws ClassNotFoundException if the class cannot be located by the

     *         specified class loader

     */

    public Class[] getWriters() throws ClassNotFoundException{

        ArrayList writers = new ArrayList();

        Enumeration e = clasesJar.keys();

        while (e.hasMoreElements()) {

            String fileName = (String) e.nextElement();

            if (fileName.endsWith("Writer")) {

                Class driver = (Class) this.loadClass(fileName);

                writers.add(driver);

            }

        }

        return (Class[]) writers.toArray(new Class[0]);

    }

}

package com.hardcode.driverManager;

public class DriverLoadException extends RuntimeException {

	/**

	 * 

	 */

	public DriverLoadException() {

		super();

	}

	/**

	 * @param message

	 */

	public DriverLoadException(String message) {

		super(message);

	}

	/**

	 * @param message

	 * @param cause

	 */

	public DriverLoadException(String message, Throwable cause) {

		super(message, cause);

	}

	/**

	 * @param cause

	 */

	public DriverLoadException(Throwable cause) {

		super(cause);

	}

}

package com.hardcode.driverManager;

/**

 * Interfaz que debe ser implementada por todos l

 *

 * @author Fernando Gonz?lez Cort?s

 */

public interface Driver {

    /**

     * Debe devolver un objeto que se asociar? en el manager al driver. El

     * DriverManager recibir? peticiones de un objeto y deber? devolver el

     * driver asociado

     *

     * @return Objeto asociado al driver. Se recomienda que sea un String

     */

    public String getName();

}

bin

<project name="Driver Manager" default="generar-jar" basedir=".">

	<description>

        Instala el plugin

    </description>

	<!-- set global properties for this build

	<property name="drivers-dir" location="../Andami/gvSIG/extensiones/com.iver.cit.gvsig/drivers" />-->

	<target name="init">

		<!-- Create the time stamp -->

		<tstamp />

	</target>

	<target name="generar-jar" depends="init" description="Genera los jars del driver manager">

		<jar jarfile="driver-manager-1.1.jar" basedir="./bin"/>

	</target>

</project>

<project name="Core plugin" default="dist" basedir=".">

    <description>

        Instala el plugin

    </description>

  <!-- set global properties for this build -->

  <property name="src" location="src"/>

  <property name="build" location="bin"/>

  <property name="dist"  location="dist"/>

  <property name="plugin" value="com.iver.core"/>

  <property name="targetDir" location="../_fwAndami/gvSIG/extensiones"/>

  <target name="init">

    <!-- Create the time stamp -->

    <tstamp/>

    <!-- Create the build directory structure used by compile -->

    <mkdir dir="${build}"/>

  </target>

  <target name="dist" description="generate the distribution" >

    <!-- Create the distribution directory -->

    <mkdir dir="${dist}"/>

    <!-- Put everything in ${build} into the MyProject-${DSTAMP}.jar file -->

    <copy todir="${build}">

    	<fileset dir="${src}" includes="**"/>

    </copy>

    <jar jarfile="${dist}/${plugin}.jar" basedir="${build}"/>

    <copy file="config.xml" todir="${dist}"/>

    <copy todir="${dist}">

    	<fileset dir="." includes="text*.properties"/>

    </copy>

    <copy todir="${dist}/images">

    	<fileset dir="images/" includes="*"/>

    </copy>

    <copy todir="${dist}">

    	<fileset dir="." includes="*.jar"/>

    </copy>

    <move todir="${targetDir}/${plugin}/">

    	<fileset dir="${dist}" includes="**/**"/>

    </move>

  </target>

  <target name="clean"

        description="clean up" >

    <!-- Delete the ${build} and ${dist} directory trees -->

    <delete dir="${build}"/>

    <delete dir="${dist}"/>

  </target>

</project>

<?xml version="1.0" encoding="UTF-8"?>

<classpath>

	<classpathentry kind="src" path="src"/>

	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>

	<classpathentry kind="lib" path="/_fwAndami/lib/log4j-1.2.8.jar"/>

	<classpathentry kind="src" path="/_fwAndami"/>

	<classpathentry kind="lib" path="/_fwAndami/lib/castor-0.9.5.3-xml.jar"/>

	<classpathentry kind="lib" path="/_fwAndami/lib/iver-utiles.jar"/>

	<classpathentry kind="output" path="bin"/>

</classpath>

#text_en.properties

__catalan=valencian

aceptar=OK

cancelar=Cancel

Cascada=Cascade

cascada_enable=There must be at least one visible window

cascada_tooltip=Arrange windows in cascade

Configurar=Configure

configurar_ANDAMI=ANDAMI configuration dialog.

Consola=Console

descripcion=Description

directorio=Directory

directorio_extensiones=Extensions directory.

errores=Errors

examinar=Examine

extension_activada=Active extension.  

general=General

info=Information

opciones=Options

prioridad=Priority

Tile=Tile

tile_tooltip=Arrange the windows in tile

titulo_consola=Information console

todos=All

ventana=Window

Ver=Show