Application: gvSIG desktop

import org.gvsig.fmap.dal.feature.OpenFeatureStoreParameters;

        OpenFeatureStoreParameters, FilesystemStoreParameters {

import org.gvsig.fmap.dal.feature.spi.ExpressionEvaluatorBase;

import org.gvsig.fmap.dal.ExpressionEvaluator;

        parameters.validate();

    public  ExpressionEvaluator createExpresion() {

        return new ExpressionEvaluatorBase();

    }

    @Override

import org.gvsig.fmap.dal.ExpressionEvaluator;

    public ExpressionEvaluator createExpression() {

            return ((FeatureStoreProvider_v2)this.provider).createExpression();

import org.gvsig.tools.dispose.DisposeUtils;

        @Override

        public Feature first() {

            DisposableIterator it = null;

            try {

                it = this.iterator();

                if( it == null ) {

                    return null;

                }

                Feature f = (Feature) it.next();

                return f;

            } finally {

                DisposeUtils.disposeQuietly(it);

            }

        }

import org.gvsig.tools.dispose.DisposeUtils;

    @Override

    public Feature first() {

        DisposableIterator it = null;

        try {

            it = this.iterator();

            if( it == null ) {

                return null;

            }

            Feature f = (Feature) it.next();

            return f;

        } finally {

            DisposeUtils.disposeQuietly(it);

        }

    }

import org.gvsig.fmap.dal.feature.OpenFeatureStoreParameters;

        boolean use = parameters instanceof OpenFeatureStoreParameters;

    <dependencies>      

    public JDBCSQLBuilderBase createExpression() {

        //

        // Parece ser que en versiones anteriores a SQL Server 2012 no esta

        // disponible la funcion ST_ExtentAggregate.

        // Habria que determinar si es necesario implementar una alternativa

        // para estos casos.

        //

        // https://alastaira.wordpress.com/2011/07/26/determining-the-geographic-extent-of-spatial-features-in-a-sql-server-table/

        //

import org.gvsig.fmap.dal.ExpressionEvaluator;

    public ExpressionEvaluator createExpression() {

    /**

     * Creates an instance of Evaluator to evaluate a expression.

     *

     * @return instance of ExpressionEvaluator representing the given expression.

     */

    public ExpressionEvaluator createExpresion();

package org.gvsig.fmap.dal;

import org.gvsig.tools.evaluator.Evaluator;

public interface ExpressionEvaluator extends ExpressionBuilder, Evaluator {

}

        /**

         * Return the first feature of the set.

         * If the set is empty return null.

         * 

         * This not is a good method to determine if the set is empty.

         * Use isEmpty instead.

         * 

         * This is a utility method that call iterator and retrieve the

         * first feature of the iterator.

         * 

         * @return the first fearure of the set or null. 

         */

        public Feature first();

import org.gvsig.fmap.dal.ExpressionEvaluator;

    public ExpressionEvaluator createExpression();

public class SQLBuilderBase extends ExpressionEvaluatorBase implements SQLBuilder {

import org.gvsig.fmap.dal.ExpressionEvaluator;

    public ExpressionEvaluator createExpression() {

package org.gvsig.fmap.dal.feature.spi;

import gnu.jel.CompilationException;

import gnu.jel.CompiledExpression;

import gnu.jel.DVMap;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.cresques.cts.IProjection;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.Find_SRID;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_AsBinary;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_AsEWKB;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_AsText;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_Contains;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_Crosses;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_Disjoint;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_Envelope;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_Equals;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_GeomFromEWKB;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_GeomFromText;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_GeomFromWKB;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_Intersects;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_IsClosed;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_Overlaps;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_SRID;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_Touches;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_Within;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.isNull;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.lcase;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.notIsNull;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_AND;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_EQ;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_GE;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_GT;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_ILIKE;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_LE;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_LIKE;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_LT;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_NE;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_OR;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_not;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ucase;

import org.gvsig.fmap.dal.ExpressionEvaluator;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryException;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.tools.evaluator.EvaluatorData;

import org.gvsig.tools.evaluator.EvaluatorException;

import org.gvsig.tools.evaluator.EvaluatorFieldsInfo;

public class ExpressionEvaluatorBase extends ExpressionBuilderBase implements ExpressionEvaluator {

    public class JELConfig extends ConfigBase {

        public JELConfig() {

            super();

            this.set(has_spatial_functions,true);

            this.set(constant_true, "true");

            this.set(constant_false, "false");

            this.set(quote_for_identifiers, "");

            this.set(quote_for_strings, "\"");

            this.set(geometry_type_support, GeometrySupportType.WKT);

            this.set(group, "( {0} )");

            this.set(Find_SRID , "Find_SRID(({0}), ({1}), ({2}))");

            this.set(ST_SRID , "ST_SRID({0})");

            this.set(ST_AsText , "ST_AsText({0})");

            this.set(ST_AsBinary, "ST_AsBinary({0})");

            this.set(ST_AsEWKB, "ST_AsWKB({0})");

            this.set(ST_Contains, "ST_Contains(({0}), ({1}))");            

            this.set(ST_Crosses,  "ST_Crosses(({0}), ({1}))");

            this.set(ST_Disjoint ,  "ST_Disjoint(({0}), ({1}))");

            this.set(ST_Equals ,  "ST_Equals(({0}), ({1}))");

            this.set(ST_IsClosed,  "ST_IsClosed({0})");

            this.set(ST_Overlaps,  "ST_Overlaps(({0}), ({1}))");

            this.set(ST_Touches,  "ST_Touches(({0}), ({1}))");

            this.set(ST_Within, "ST_Within(({0}), ({1}))");            

            this.set(ST_Envelope, "ST_Envelope({0})");

            this.set(ST_Intersects, "ST_Intersects(({0}), ({1}))");

            this.set(ST_GeomFromText, "ST_GeomFromText({0}, ({1}))");

            this.set(ST_GeomFromWKB, "ST_GeomFromWKB(({0}), ({1}))");

            this.set(ST_GeomFromEWKB, "ST_GeomFromEWKB(({0}), ({1}))");

            this.set(lcase, "LCASE({0})");

            this.set(ucase, "UCASE({0})");

            this.set(isNull, "( ({0}) == null )");

            this.set(notIsNull, "( ! (({0}) == null) )");

            this.set(operator_not, "( ! ({0}) )");

            this.set(operator_AND, "{0} && {1}");

            this.set(operator_OR, "{0} || {1}");

            this.set(operator_EQ, "( ({0}) == ({1}) )");

            this.set(operator_NE, "( ({0}) != ({1}) )");

            this.set(operator_GT, "( ({0}) > ({1}) )");

            this.set(operator_GE, "( ({0}) >= ({1}) )");

            this.set(operator_LT, "( ({0}) < ({1}) )");

            this.set(operator_LE, "( ({0}) <= ({1}) )");

            this.set(operator_LIKE, "LIKE( ({0}), ({1}) )");

            this.set(operator_ILIKE, "ILIKE( ({0}), ({1}) )");

            this.set(operator_add, "{0} + {1}");

            this.set(operator_subst, "{0} - {1}");

            this.set(operator_mult, "{0} * {1}");

            this.set(operator_div, "{0} / {1}");

            this.set(operator_concat, "{0} + {1}");

        }

    }

    public static class JELFunctions {

        public static String Find_SRID(Object a, Object b, Object c) {

            return null;

        }

        public static String ST_SRID(Geometry geom) {

            return null;

        }

        public static String ST_AsText(Geometry geom) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom.convertToWKT();

        }

        public static byte[] ST_AsBinary(Geometry geom) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom.convertToWKB();

        }

        public static byte[] ST_AsEWKB(Geometry geom) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom.convertToEWKB();

        }

        public static Envelope ST_Envelope(Geometry geom) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom.getEnvelope();

        }            

        public static boolean ST_Contains(Geometry geom1, Geometry geom2) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom1.contains(geom2);

        }            

        public static boolean ST_Crosses(Geometry geom1, Geometry geom2) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom1.crosses(geom2);

        }            

        public static boolean ST_Disjoint(Geometry geom1, Geometry geom2) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom1.disjoint(geom2);

        }            

        public static boolean ST_Overlaps(Geometry geom1, Geometry geom2) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom1.overlaps(geom2);

        }            

        public static boolean ST_Touches(Geometry geom1, Geometry geom2) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom1.touches(geom2);

        }            

        public static boolean ST_Within(Geometry geom1, Geometry geom2) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom1.within(geom2);

        }            

        public static boolean ST_Intersects(Geometry geom1, Geometry geom2) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom1.intersects(geom2);

        }            

        public static boolean ST_Equals(Geometry geom1, Geometry geom2) {

            return geom1.equals(geom2);

        }            

        public static boolean ST_IsClosed(Geometry geom1) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom1.isClossed();

        }            

        public static Geometry ST_GeomFromText(String geom, IProjection srs) throws GeometryException {

            GeometryManager manager = GeometryLocator.getGeometryManager();

            return manager.createFrom(geom,srs);

        }            

        public static Geometry ST_GeomFromWKB(byte[] geom, IProjection srs) throws GeometryException {

            GeometryManager manager = GeometryLocator.getGeometryManager();

            return manager.createFrom(geom,srs);

        }            

        public static Geometry ST_GeomFromEWKB(byte[] geom, IProjection srs) throws GeometryException {

            GeometryManager manager = GeometryLocator.getGeometryManager();

            return manager.createFrom(geom,srs);

        }            

        public static String LCASE(Object x) {

            if( x == null ) {

                return null;

            }

            return x.toString().toLowerCase();

        }            

        public static String UCASE(Object x) {

            if( x == null ) {

                return null;

            }

            return x.toString().toLowerCase();

        }            

        private static final Integer ZERO_OR_MORE_CHARS = 0;

        private static final Integer ONE_CHAR = 1;

        public static boolean LIKE(Object x1, Object x2) {

            if (x1 == null || x2 == null) {

                return false;

            }

            String source = x1.toString();

            String match = x2.toString();

            List<Object> format = new ArrayList<>();

            StringBuilder fill = new StringBuilder();

            final int plen = match.length();

            Character lastSymbol = null;

            for (int i = 0; i < plen; i++) {

                boolean f = false;

                char c = match.charAt(i);

                if (lastSymbol == '\\') {

                    lastSymbol = null;

                    fill.append(c);

                } else {

                    if (c == '%') {

                        if (fill.length() > 0) {

                            format.add(fill.toString());

                            fill.setLength(0);

                        }

                        format.add(ZERO_OR_MORE_CHARS);

                    } else if (c == '_') {

                        if (fill.length() > 0) {

                            format.add(fill.toString());

                            fill.setLength(0);

                        }

                        format.add(ONE_CHAR);

                    } else {

                        fill.append(c);

                    }

                    lastSymbol = c;

                }

                if (fill.length() > 0) {

                    format.add(fill.toString());

                }

            }

            StringBuilder repattern = new StringBuilder("^");

            for (Object o : format) {

                if (o == ZERO_OR_MORE_CHARS) {

                    repattern.append(".*?");

                } else if (o == ONE_CHAR) {

                    repattern.append(".?");

                } else {

                    repattern.append((String) o);

                }

            }

            Pattern pattern = Pattern.compile(repattern.toString());

            Matcher m = pattern.matcher(source);

            return m.find();

        }

        public static boolean ILIKE(Object x1, Object x2) {

            if (x1 == null || x2 == null) {

                return false;

            }

            x1 = x1.toString().toLowerCase();

            x2 = x2.toString().toLowerCase();

            return LIKE(x1, x2);

        }

    }

    protected class VariableProvider extends DVMap {

        private EvaluatorData data;

        public VariableProvider() {

        }

        public void setValues(EvaluatorData data) {

            this.data = data;

        }

        @Override

        public String getTypeName(String name) {

            Object value = this.data.getDataValue(name);

            return value.getClass().getSimpleName();

        }

        public double getDoubleProperty(String name) {

            Object value = this.data.getDataValue(name);

            return (double) value;

        }        

        public float getFloatProperty(String name) {

            Object value = this.data.getDataValue(name);

            return (float) (double) value;

        }        

        public int getIntegerProperty(String name) {

            Object value = this.data.getDataValue(name);

            return (int) (double) value;

        }        

        public long getLongProperty(String name) {

            Object value = this.data.getDataValue(name);

            return (long) (double) value;

        }        

        public String getStringProperty(String name) {

            Object value = this.data.getDataValue(name);

            return (String) value;

        }        

        public Date getDateProperty(String name) {

            Object value = this.data.getDataValue(name);

            return (Date) value;

        }        

    }

    protected VariableProvider jel_variables = null;

    protected Object[] jel_context = null;

    protected CompiledExpression jel_expression = null;

    protected Config jel_config = new JELConfig();

    protected EvaluatorFieldsInfo fieldsInfo = null; // For compatibility 

    public ExpressionEvaluatorBase() {

        super();

    }

    public void compile() {

        jel_variables = new VariableProvider();

        gnu.jel.Library lib = new gnu.jel.Library(

                new Class[]{ Math.class, JELFunctions.class }, 

                new Class[]{ jel_variables.getClass() }, 

                new Class[0],

                jel_variables,

                null

        );

        jel_context = new Object[] { jel_variables };

        Config config = this.config;

        try {

            this.config = jel_config;

            String expr = this.value.toString();

            jel_expression = gnu.jel.Evaluator.compile(expr, lib);

        } catch (CompilationException ex) {

            throw new RuntimeException("Can't compile expression.", ex);

        } finally {

            this.config = config;

        }

    }

    public void clear() {

        this.set(null);

        this.jel_expression = null;

    }

    @Override

    public Object evaluate(EvaluatorData data) throws EvaluatorException {

        try {

            if( jel_variables == null ) {

                this.compile();

            }

            jel_variables.setValues(data);

            return jel_expression.evaluate(jel_context);

        } catch (Throwable th) {

            throw new EvaluatorException(

                    "Can't evaluate expression", 

                    th, 

                    "ExpressionEvaluatorBase_evaluate_error", 

                    0

                );

        }

    }

    @Override

    public String getName() {

        return "Generic expression evaluator";

    }

    @Override

    public String getDescription() {

        return "";

    }

    @Override

    public String getSQL() {

        return this.value.toString();

    }

    @Override

    public EvaluatorFieldsInfo getFieldsInfo() {

        if( this.fieldsInfo==null ) {

            this.fieldsInfo = new EvaluatorFieldsInfo();

            for( Variable var : this.getVariables() ) {

                this.fieldsInfo.addFieldValue(var.getName());

            }

        }

        return this.fieldsInfo;

    }

}

import org.gvsig.fmap.dal.ExpressionEvaluator;

    public ExpressionEvaluator createExpression();

    <dependency>

        <groupId>org.gnu</groupId>

        <artifactId>jel</artifactId>

        <scope>compile</scope>

    </dependency>

            ExpressionBuilder builder = store.createExpression();

            ExpressionBuilder builder = store.createExpression();

            ExpressionBuilder builder = store.createExpression();

            ExpressionBuilder builder = store.createExpression();

            ExpressionBuilder builder = store.createExpression();

            ExpressionBuilder builder = store.createExpression();

            ExpressionBuilder builder = store.createExpression();

            ExpressionBuilder builder = store.createExpression();

            ExpressionBuilder builder = store.createExpression();

            ExpressionBuilder builder = store.createExpression();

            ExpressionBuilder builder = store.createExpression();

            ExpressionBuilder builder = store.createExpression();

        <groupId>commons-collections</groupId>

        <artifactId>commons-collections</artifactId>

        <scope>compile</scope>

    </dependency>

    <dependency>

        <groupId>org.gnu</groupId>

        <artifactId>jel</artifactId>

        <scope>compile</scope>

    </dependency>

    <dependency>

      <gvsig.package.info.state>devel</gvsig.package.info.state>

<h1>${gvsig.package.info.name}</h1>

<pre>${gvsig.package.info.description}</pre>

<ul>

    <li>Package <i>${gvsig.package.info.official.label}</i></li>

    <li>Organization:<br>

        &nbsp;&nbsp;<i>${gvsig.package.info.owner}</i><br>

        &nbsp;&nbsp;<i>${gvsig.package.info.webURL}</i>

    </li>

    <li>Categories: <i>${gvsig.package.info.categories}</i></li>

    <li>Sources:&nbsp;<i>${gvsig.package.info.sourcesURL}</i></li>

    <li>Code: <i>${gvsig.package.info.code}</i></li>

    <li>Dependencies: <i>${gvsig.package.info.dependencies}</i></li>

    <li>Version: <i>${gvsig.package.info.version}</i></li>

    <li>State: <i>${gvsig.package.info.state}</i></li>

    <li>Operating system: <i>${gvsig.package.info.operatingSystem}</i></li>

    <li>Architecture: <i>${gvsig.package.info.architecture}</i></li>

    <li>Required JVM: <i>${gvsig.package.info.javaVM}</i></li>

</ul>

<br>

<br>

<h1>${gvsig.package.info.name}</h1>

<pre>${gvsig.package.info.description}</pre>

<ul>

    <li>Paquete <i>${gvsig.package.info.official.label}</i></li>

    <li>Organizaci&oacute;n:<br>

        &nbsp;&nbsp;<i>${gvsig.package.info.owner}</i><br>

        &nbsp;&nbsp;<i>${gvsig.package.info.webURL}</i>

    </li>    

    <li>Categorias: <i>${gvsig.package.info.categories}</i></li>

    <li>Fuentes: <i>${gvsig.package.info.sourcesURL}</i></li>

    <li>Codigo:&nbsp;<i>${gvsig.package.info.code}</i></li>

    <li>Dependencias: <i>${gvsig.package.info.dependencies}</i></li>

    <li>Versi&oacute;n: <i>${gvsig.package.info.version}</i></li>

    <li>Estado: <i>${gvsig.package.info.state}</i></li>

    <li>Sistema operativo: <i>${gvsig.package.info.operatingSystem}</i></li>

    <li>Arquitectura: <i>${gvsig.package.info.architecture}</i></li>

    <li>Java requerida: <i>${gvsig.package.info.javaVM}</i></li>

</ul>

<br>

<br>

_select_the_folder_to_create_the_package_with=Selecciona el directorio con el que se crear\u00e1 el paquete

_the_package_index_file_folder_does_not_exist=La carpeta del paquete de \u00edndices no existe

_package_description=Descripci\u00f3n del paquete

_Creating_index=Creando \u00edndice

_create_package=Creaci\u00f3n del paquete

_select_symbol_folder=Selecciona carpeta de s\u00edmbolos

_typical_installation=Instalaci\u00f3n t\u00edpica

_advanced_installation=Instalaci\u00f3n avanzada

_fast_filter=Filtro r\u00e1pido

_categories=Categor\u00edas

_standard_installation=Instalaci\u00f3n est\u00e1ndar

_installation_from_file=Instalaci\u00f3n desde archivo

_installation_from_url=Instalaci\u00f3n desde URL

_version=Versi\u00f3n

_community_recommended=Comunidad, recomendado

_community=Comunidad

_do_you_want_to_continue=\u00bfDesea continuar?

_execute_adding_error=Error al a\u00f1adir

_There_are_no_packages_in_typical_installation_to_select=No hay paquetes en la instalaci\u00f3n t\u00edpica para seleccionar

_do_you_want_to_continue=\u00bfDesea continuar?

_do_you_want_to_continue_anyway=\u00bfDesea continuar de todas formas?

_it_is_not_possible_to_verify_if_any_additional_package_is_needed_to_install_the_selected_packages=No es posible verificar si precisa alg\u00fan paquete adicional para instalar los paquetes que ha seleccionado.

_do_you_want_to_continue_and_install_the_packages_you_already_have_selected=\u00bfDesea continuar instalando los paquetes que ya ha seleccionado?

_malformed_url=Direcci\u00f3n URL incorrecta.

_the_package_source_files_url_is_malformed._Please_review_it=La URL de los archivos fuente del paquete es incorrecta. Por favor, rev\u00edsala.

_the_owners_url_is_malformed._Please_review_it=La URL del propietario es incorrecta. Por favor, rev\u00edsala.

_advanced_mode=El modo avanzado permite copiar recursos que est\u00e1n alojados fuera del directorio del plugin. No se recomienda usar esta opci\u00f3n.

_description=Descripci\u00f3n

_version=Versi\u00f3n

_code=C\u00f3digo

_java_version=Versi\u00f3n java

_gvSIG_desktop_version=Versi\u00f3n gvSIG desktop

_sources_url=URL del c\u00f3digo fuente

_package_index_file=Archivo del \u00edndice del paquete

_create_package_index=Crear \u00edndice del paquete

_select_installation_source=Selecciona fuente de instalaci\u00f3n

_select_installation_mode=Selecciona modo de instalaci\u00f3n

_gvSIG_packages_and_packages_and_index_sets=Paquetes gvSIG y sets de paquetes e \u00edndices

_install_addons_in_gvsig_standard_dist=instalar complementos incluidos en la distribuci\u00f3n gvSIG standard

_Installing_devel_addons_may_cause_errors=Instalar complementos en desarrollo puede provocar errores de funcionamiento en la aplicaci\u00f3n

create_package_index=\u00bfDesea crear el indice para este paquete?

_Creating_index=Creating \u00edndex

_community_recommended=Community, recommended

_community=Community

            <value label="devel">devel</value>

          <availableValues>

            <value label="Official">true</value>

            <value label="Community">false</value>

          </availableValues>

          <description>The package is a community or an official package of gvSIG project</description>

		case COMMUNITY_RECOMMENDED:

					.getText("_community_recommended"));

		case COMMUNITY_NOT_RECOMMENDED:

							.getText("_community"));

		OFFICIAL_NOT_RECOMMENDED, OFFICIAL_RECOMMENDED, COMMUNITY_RECOMMENDED, COMMUNITY_NOT_RECOMMENDED

				return PackageOfficialRecommended.COMMUNITY_RECOMMENDED;

				return PackageOfficialRecommended.COMMUNITY_NOT_RECOMMENDED;

import java.io.IOException;

import java.io.InputStream;

import java.util.Locale;

import java.util.logging.Level;

import java.util.logging.Logger;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

		PackageInfo pkginfo = ((PackagesTableModel) pluginsTable.getModel()).getPackageInfoAt(row);

		descriptionTextEditor.setText(getFullDescriptionAsHTML(pkginfo));

        public String getFullDescriptionAsHTML(PackageInfo pkginfo) {

            String html = null;

            String lang = Locale.getDefault().getLanguage();

            InputStream res = this.getClass().getClassLoader().getResourceAsStream("org/gvsig/installer/swing/impl/pkg_description_"+lang+".html");

            if( res == null ) {

                res = this.getClass().getClassLoader().getResourceAsStream("org/gvsig/installer/swing/impl/pkg_description_en.html");

            }

            if( res != null ) {

                try {

                    List<String> lines = IOUtils.readLines(res);

                    html = StringUtils.join(lines,null);

                    res.close();

                } catch (Exception ex) {

                    // Do nothing

                }

            }

            if( html == null ) {

		HTMLCoder coder = new HTMLCoder();

		coder.addTitle(pkginfo.getName());

		coder.addParagraph(pkginfo.getDescription());

		coder.addBeginList();

		coder.addListItem("code", pkginfo.getCode());

		coder.addListItem("Organization", pkginfo.getOwner());

		coder.addListItem("Organization URL", pkginfo.getOwnerURL());

		coder.addListItem("Sources", pkginfo.getSourcesURL());

		coder.addListItem("Dependencies", pkginfo.getDependencies());

		coder.addListItem("Categories", pkginfo.getCategoriesAsString());

		coder.addListItem("Official", pkginfo.isOfficial());

		coder.addEndList();

                return coder.toString();

            }

            html = html.replace("${gvsig.package.info.name}",pkginfo.getName());

            html = html.replace("${gvsig.package.info.description}",pkginfo.getDescription());

            html = html.replace("${gvsig.package.info.official}",pkginfo.isOfficial()?"true":"false");

            html = html.replace("${gvsig.package.info.official.label}",pkginfo.isOfficial()?"official":"community");

            html = html.replace("${gvsig.package.info.owner}",pkginfo.getOwner());

            html = html.replace("${gvsig.package.info.webURL}",pkginfo.getWebURL()==null? "":pkginfo.getWebURL().toString());

            html = html.replace("${gvsig.package.info.categories}",pkginfo.getCategoriesAsString());

            html = html.replace("${gvsig.package.info.sourcesURL}",pkginfo.getSourcesURL()==null?"":pkginfo.getSourcesURL().toString());

            html = html.replace("${gvsig.package.info.code}",pkginfo.getCode());

            html = html.replace("${gvsig.package.info.dependencies}",pkginfo.getDependencies()==null?"":pkginfo.getDependencies().toString());

            html = html.replace("${gvsig.package.info.version}",pkginfo.getVersion()==null?"":pkginfo.getVersion().toString());

            html = html.replace("${gvsig.package.info.state}",pkginfo.getState());

            html = html.replace("${gvsig.package.info.operatingSystem}",pkginfo.getOperatingSystem());

            html = html.replace("${gvsig.package.info.architecture}",pkginfo.getArchitecture());

            html = html.replace("${gvsig.package.info.javaVM}",pkginfo.getJavaVM());

            return html;

        }

    private void buildPackageList(List<PackageInfo> packages) {

        this.packages = new ArrayList<>();

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

            PackageInfo pkg = packages.get(i);

            if (!pkg.isOfficial()) {

                this.packages.add(pkg.getName() + " ("

                        + swingInstallerManager.getText("_community") + ")");

            } else {

                if (InstallerManager.STATE.FINAL.equalsIgnoreCase(pkg.getState())) {

                    continue;

                } else if (InstallerManager.STATE.TESTING.equalsIgnoreCase(pkg.getState())) {

                    continue;

            }

        }

    }