/ - Diff - Application: gvSIG desktop - gvSIG

                 if( startServer && server == null ) {
                     String port = "9123";
                     try {
                         Server theServer = Server.createTcpServer("-tcpPort", port, /*"-tcpAllowOthers",*/ "-ifExists");
                         Server theServer;
                         String s = System.getProperty("H2Port");
                         if( s!=null ) {
                             try {
                                 int n = Integer.parseInt(s);
                                 port = String.valueOf(n);
                             } catch(Throwable th) {
                                 // Ignore port number, use default.
+                            }
+                        }
                         if( System.getProperty("H2AllowOthers")!=null ) {
                             theServer = Server.createTcpServer("-tcpPort", port, "-tcpAllowOthers", "-ifExists");
                         } else {
                             theServer = Server.createTcpServer("-tcpPort", port, "-ifExists");
+                        }
                         theServer.start();
                         server = theServer;
                         LOGGER.info("H2 Server started" );
                         LOGGER.info("  port  :"+ server.getPort());
                         LOGGER.info("  URL  :"+ server.getURL());
                         LOGGER.info("  status:"+ server.getStatus());
                     } catch (SQLException ex) {
                         LOGGER.warn("H2 Server not started",ex);

                     ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();
                     String filter = builder.eq(
                             builder.column(FIELD_RESOURCES_NAME),
                             builder.constant(this.tableName+"/"+this.name)
                             builder.constant(this.tableName+"."+this.name)
                     ).toString();
                     Feature feature = store.findFirst(filter);
                     return feature!=null;
-...
                     ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();
                     String filter = builder.eq(
                             builder.column(FIELD_RESOURCES_NAME),
                             builder.constant(this.tableName+"/"+this.name)
                             builder.constant(this.tableName+"."+this.name)
                     ).toString();
                     Feature feature = store.findFirst(filter);
                     if (feature == null) {
-...
                         ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();
                         String filter = builder.eq(
                                 builder.column(FIELD_RESOURCES_NAME),
                                 builder.constant(this.tableName+"/"+this.name)
                                 builder.constant(this.tableName+"."+this.name)
                         ).toString();
                         Feature feature = store.findFirst(filter);
                         EditableFeature efeature;
                         if (feature == null) {
                             efeature = store.createNewFeature();
                             efeature.set(FIELD_RESOURCES_NAME, this.tableName+"/"+this.name);
                             efeature.set(FIELD_RESOURCES_NAME, this.tableName+"."+this.name);
                             efeature.set(FIELD_RESOURCES_RESOURCE, this.out.toByteArray());
                             store.insert(efeature);
                         } else {
-...
+            }
+        }
         private final ResourcesStorage alternativeStorge;
         private final JDBCStoreParameters resourcesStoreParameters;
         private final String tableName;
         public JDBCResourcesStorage(JDBCStoreParameters resourcesStoreParameters, String tableName) {
         public JDBCResourcesStorage(ResourcesStorage alternativeStorge, JDBCStoreParameters resourcesStoreParameters, String tableName) {
             this.alternativeStorge = alternativeStorge;
             if( StringUtils.equals(TABLE_RESOURCES_NAME, tableName) ) {
                 // No podemos buscar recursos de la tabla de recursos, ya que si no
                 // al abrise la tabla de recursos entraria en bucle.
-...
         @Override
         public Resource getResource(String name) {
             if( this.alternativeStorge!=null ) {
                 Resource r = this.alternativeStorge.getResource(name);
                 if( r.exists() ) {
                     return r;
+                }
+            }
             if (this.resourcesStoreParameters == null) {
                 return null;
+            }
-...
             if (this.resourcesStoreParameters == null) {
                 return null;
+            }
             if( this.alternativeStorge!=null ) {
                 List<Resource> r = this.alternativeStorge.getResources(name);
                 if( r!=null && !r.isEmpty() ) {
                     return r;
+                }
+            }
             FeatureStore store = null;
             try {
                 DataManager dataManager = DALLocator.getDataManager();
-...
                     if (n == 0) {
                         multiresourceName = name;
                     } else {
                         multiresourceName = name + "." + String.valueOf(n);
                         multiresourceName = String.valueOf(n) + "." + name ;
+                    }
                     String filter = builder.eq(
                             builder.column(FIELD_RESOURCES_NAME),
                             builder.constant(this.tableName+"/"+multiresourceName)
                             builder.constant(this.tableName+"."+multiresourceName)
                     ).toString();
                     Feature feature = store.findFirst(filter);
                     if( feature==null ) {

     import org.gvsig.fmap.dal.DataManager;
     import org.gvsig.fmap.dal.DataStore;
     import org.gvsig.fmap.dal.DataStoreParameters;
     import org.gvsig.fmap.dal.DatabaseWorkspaceManager;
     import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.TABLE_RESOURCES_NAME;
     import org.gvsig.fmap.dal.NewDataStoreParameters;
     import org.gvsig.fmap.dal.exception.CloseException;
-...
     import org.gvsig.fmap.dal.store.jdbc2.spi.operations.UpdateTableStatisticsOperation;
     import org.gvsig.tools.exception.BaseException;
     import org.gvsig.tools.resourcesstorage.EmptyResourcesStorage;
     import org.gvsig.tools.resourcesstorage.FilesResourcesStorage;
     import org.gvsig.tools.resourcesstorage.ResourcesStorage;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
-...
+        }
         private ResourcesStorage getResourcesStorage(DataStoreParameters parameters, String storeName) {
             try {
                 List<JDBCStoreParameters> tables = this.list();
                 for (JDBCStoreParameters params : tables) {
                     String theTableName = params.getTable();
                     if (StringUtils.equals(theTableName, TABLE_RESOURCES_NAME)) {
                         JDBCResourcesStorage theResourcesStorage = new JDBCResourcesStorage(
                                 params,
                                 storeName
                         );
                         return theResourcesStorage;
             if( !DatabaseWorkspaceManager.isInternalTable(storeName) ) {
                 ResourcesStorage alternateResourcesStorage = null;
                 try {
                     DataManager dataManager = DALLocator.getDataManager();
                     DatabaseWorkspaceManager workspace = dataManager.getDatabaseWorkspace(parameters);
                     if( workspace != null ) {
                         alternateResourcesStorage = workspace.getAlternativeResourcesStorage();
+                    }
                 } catch(Throwable th) {
                     alternateResourcesStorage = null;
+                }
             } catch (Throwable ex) {
                 LOG.warn("Can't retrieve reources storage from table '" + TABLE_RESOURCES_NAME + "' in '"+this.getParameters().getUrl()+"'.", ex);
                 try {
                     List<JDBCStoreParameters> tables = this.list();
                     for (JDBCStoreParameters params : tables) {
                         String theTableName = params.getTable();
                         if (StringUtils.equals(theTableName, TABLE_RESOURCES_NAME)) {
                             JDBCResourcesStorage theResourcesStorage = new JDBCResourcesStorage(
                                     alternateResourcesStorage,
                                     params,
                                     storeName
                             );
                             return theResourcesStorage;
+                        }
+                    }
                 } catch (Throwable ex) {
                     LOG.warn("Can't retrieve reources storage from table '" + TABLE_RESOURCES_NAME + "' in '"+this.getParameters().getUrl()+"'.", ex);
+                }
+            }
             EmptyResourcesStorage theResourcesStorage = new EmptyResourcesStorage();
             return theResourcesStorage;

             @Override
             public void update(Observable observable, Object notification) {
                 if( store == null || formset==null ) {
                     return;
+                }
                 if( notification instanceof FeatureStoreNotification ) {
                     FeatureStoreNotification n =  (FeatureStoreNotification) notification;
                     switch( n.getType() )  {
-...
             @Override
             public void update(Observable observable, Object notification) {
                 if( store == null || formset==null ) {
                     return;
+                }
                 if( notification instanceof FeatureStoreNotification ) {
                     FeatureStoreNotification n =  (FeatureStoreNotification) notification;
                     switch( n.getType() )  {
-...
+        }
         private void saveChanges(JDynFormSet dynformSet) {
             I18nManager i18n = ToolsLocator.getI18nManager();
             if( dynformSet.isInNewState() ) {
                 Feature feat = null;
                 try {
-...
                 } catch(Exception ex) {
                     LOGGER.warn("Can't reload form data after insert.",ex);
+                }
                 this.formset.message(i18n.getTranslation("_Record_saved"));
             } else {
                 int index = dynformSet.getCurrentIndex();
                 DynObject dynObject = dynformSet.get(index);
                 if ( !(dynObject instanceof FacadeOfAFeature) ) {
                     LOGGER.warn("Can't get the associated feature index " + index);
                     I18nManager i18nManager = ToolsLocator.getI18nManager();
                     dynformSet.message(i18nManager.getTranslation("error_saving_data_will_not_save"));
                     dynformSet.message(i18n.getTranslation("error_saving_data_will_not_save"));
                     throw new RuntimeException("Can't save values");
+                }
                 dynformSet.getFormValues(dynObject);

     import java.text.DateFormat;
     import java.util.List;
     import java.util.Objects;
     import org.cresques.cts.IProjection;
     import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
     import org.gvsig.fmap.dal.feature.FeatureAttributeEmulator;
-...
             return ((DynField_v2)field).getLocalizedLabel();
+        }
         @Override
         public String getLabelOfValue(Object value) {
             return Objects.toString(value, "");
+        }
+    }

         @Override
         public void copyTo(FeatureStore target) {
+        }
         @Override
         public FeatureQuery createFeatureQuery(String filter, String sortBy, boolean asc) {
             return null;
+        }
         @Override
         public FeatureQuery createFeatureQuery(Expression filter, String sortBy, boolean asc) {
             return null;
+        }
+    }

     import java.text.DateFormat;
     import java.util.List;
     import java.util.Objects;
     import org.cresques.cts.IProjection;
     import org.gvsig.fmap.geom.type.GeometryType;
     import org.gvsig.timesupport.Interval;
-...
             return this.getLabel();
+        }
         @Override
         public String getLabelOfValue(Object value) {
             return Objects.toString(value, "");
+        }
+    }

         public void add(String name, DataStoreParameters parameters);
         public boolean contains(DataStoreParameters parameters);
         public void remove(String name);
         public DataStore getStore(String name);

         public void remove(String name) {
             throw new UnsupportedOperationException();
+        }
         @Override
         public boolean contains(DataStoreParameters parameters) {
             for (DataStoreParameters currentParameters : this) {
                 if( parameters.equals(currentParameters) ) {
                     return true;
+                }
+            }
             return false;
+        }
         @Override
         public String getID() {

         public DatabaseWorkspaceManager createDatabaseWorkspaceManager(DataServerExplorerParameters connection);
         public void addDatabaseWorkspace(DatabaseWorkspaceManager DatabaseWorkspace);
         public DatabaseWorkspaceManager getDatabaseWorkspace(String name);
         public DatabaseWorkspaceManager getDatabaseWorkspace(DataStoreParameters params);
         public void writeDALResource(ResourcesStorage resources, DataStore store);
         public void writeDALResource(ResourcesStorage resources, FeatureType featureType);

     package org.gvsig.fmap.dal;
     import org.apache.commons.lang3.StringUtils;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.tools.resourcesstorage.ResourcesStorage;
     /**
+     *
-...
         public static final String CONFIG_NAME_STORESREPOSITORYID = "StoresRepository.id";
         public static final String CONFIG_NAME_STORESREPOSITORYLABEL = "StoresRepository.label";
         /**
          * Check if the indicated name corresponds to one of the configuration tables of the workspace.
+         *
          * @param name to check.
          * @return true if the name is that of a configuration table.
          */
         public static boolean isInternalTable(String name) {
             if( StringUtils.isBlank(name) ) {
                 return false;
+            }
             String[] internalNames = new String[] {
                 TABLE_REPOSITORY_NAME,
                 TABLE_RESOURCES_NAME,
                 TABLE_CONFIGURATION_NAME
             };
             for (String internalName : internalNames) {
                 if( name.equalsIgnoreCase(internalName) ) {
                     return true;
+                }
+            }
             return false;
+        }
         /**
          * Returns the identifier of this workspace.
+         *
          * @return the id.
          */
         public String getId();
         /**
          * Returns the label of this workspace.
+         *
          * @return the label value.
          */
         public String getLabel();
         /**
          * Gets the value of a configuration variable associated with
          * this work space.
+         *
          * @param name of the variable to consult
          * @return the value of the variable
          */
         public String get(String name);
         /**
          * Assigns the indicated value to the configuration variable.
+         *
          * @param name of the variable.
          * @param value value to set.
          * @return true if can assign the value.
          */
         public boolean set(String name, String value);
         /**
          * Gets the repository of data stores associated with this workspace.
+         *
          * @return the data stores repository.
          */
         public StoresRepository getStoresRepository();
         public boolean storesRepositoryWriteEntry(String name, DataStoreParameters parameters);
         /**
          * Add a new data store to the workspace.
+         *
          * @param name of the data store.
          * @param parameters to open the data store.
          * @return true if ok.
          */
         public boolean writeStoresRepositoryEntry(String name, DataStoreParameters parameters);
         public boolean canAnonymousUserWriteInTheTables();
         /**
          * Check if the indicated configuration table exists in the workspace.
+         *
          * @param tableid
          * @return true if the table exists.
          */
         public boolean existsTable(int tableid);
         public FeatureStore getTable(int tableid);
         /**
          * Create the configuration table indicated in the workspace.
+         *
          * @param tableid identifier of the configuration table to create.
          */
         public void createTable(int tableid);
         /**
          * Remove the indicated configuration table from the workspace.
+         *
          * @param tableid identifier of the configuration table to remove.
          */
         public void dropTable(int tableid);
         /**
          * Gets the data store associated with the indicated configuration table.
+         *
          * @param tableid identifier of the configuration table to get.
          * @return the FeatureStore of the configuration table.
          */
         public FeatureStore getTable(int tableid);
         /**
          * Returns true if the connection associated with this object refers
          * to a valid workspace.
          * At least the repositories table must exist and the variable
          * "StoresRepository.id" must be defined.
+         *
          * @return
          */
         public boolean isValidStoresRepository();
         /**
          * If the workspace has an alternate resource storage defined, return it.
          * If don't have it, return null.
+         *
          * @return the alternate resource storage.
          */
         public ResourcesStorage getAlternativeResourcesStorage();
         /**
          * Create and initialize the tables associated with a gvSIG workspace.
+         *
          * @param id of the workspace
          * @param description of the workspace
          */
         public void create(String id, String description);
+    }

     import org.gvsig.tools.observer.Observer;
     import org.gvsig.tools.undo.UndoRedoStack;
     import org.gvsig.tools.resourcesstorage.ResourcesStorage;
     import org.gvsig.tools.util.UnmodifiableBasicList64;
     /**
      * <p>
-...
+         *
          * Query related services
          */
         /**
          * Create a {@link FeatureQuery} with the restrictions indicateds.
+         *
          * "filter" will be null or a valid filter expression for the store.
+         *
          * "sortBy" can be null to use the store's default order.
+         *
          * The parameter sortBy can be an attribute name or a comma separated list.
          * Each attribute name can be preceded or followed by "+" or "-" to indicate
          * the order to use to sort by that attribute.
+         *
          * If no "+" or "-" is indicated, the "asc" parameter will be used to
          * determine if the order is ascending, "true" or decent, "false".
+         *
          * @param filter an {@link String} expression used to filter the features in the store.
          * @param sortBy Attribute names separated by commas used to sort the list to return.
          * @param asc use order ascending, true, or descending, false.
          * @return a {@link FeatureQuery} with the restrictions.
          * @see {@link FeatureQuery}
          */
         public FeatureQuery createFeatureQuery(String filter, String sortBy, boolean asc);
         /**
          * Create a {@link FeatureQuery} with the restrictions indicateds.
+         *
          * "filter" will be null or {@link Expression} valid for the store.
+         *
          * "sortBy" can be null to use the store's default order.
+         *
          * The parameter sortBy can be an attribute name or a comma separated list.
          * Each attribute name can be preceded or followed by "+" or "-" to indicate
          * the order to use to sort by that attribute.
+         *
          * If no "+" or "-" is indicated, the "asc" parameter will be used to
          * determine if the order is ascending, "true" or decent, "false".
+         *
          * @param filter an {@link String} expression used to filter the features in the store.
          * @param sortBy Attribute names separated by commas used to sort the list to return.
          * @param asc use order ascending, true, or descending, false.
          * @return a {@link FeatureQuery} with the restrictions.
          * @see {@link FeatureQuery}
          */
         public FeatureQuery createFeatureQuery(Expression filter, String sortBy, boolean asc);
         /**
          * Returns all available features in the store.
          * <p>
          * <em>
          * <strong>NOTE:</strong> if you use this method to get a
          * {@link FeatureSet}, you  must get sure it is disposed
          * (@see {@link DisposableIterator#dispose()}) in any case, even if an
          * error occurs while getting the data. It is recommended to use the
          * <code>accept</code> methods instead, which handle everything for you.
          * Take into account the accept methods may use a fast iterator to
          * get the features.
          * </em>
          * </p>
+         *
          * @see #accept(org.gvsig.tools.visitor.Visitor)
+         *
          * @return a collection of features
          * @throws ReadException
          *             if there is any error while reading the features
          * It is a utility method that calls {@link #getFeatureSet(FeatureQuery)}
+         *
          * @return the {@link FeatureSet}
          * @throws ReadException if there is any error while reading the features
          * @see {@link #accept(org.gvsig.tools.visitor.Visitor)}, {@link #getFeatureSet(FeatureQuery)}
          */
         FeatureSet getFeatureSet() throws DataException;
         /**
          * Return a subset of features.
+         *
          * It is a utility method that calls {@link #getFeatureSet(FeatureQuery)}
+         *
          * @param filter an {@link String} expression used to filter the features in the store.
          * @return the {@link FeatureSet}
          * @throws ReadException if there is any error while reading the features
          * @see {@link #createFeatureQuery(Expression,String,boolean)}, {@link #getFeatureSet(FeatureQuery)}
          */
         FeatureSet getFeatureSet(String filter) throws DataException;
         /**
          * Return a subset of features.
+         *
          * It is a utility method that calls {@link #getFeatureSet(FeatureQuery)}
+         *
          * The sort order used is ascending.
+         *
          * @param filter an {@link String} expression used to filter the features in the store.
          * @param sortBy Attribute names separated by commas used to sort the list to return.
          * @return the {@link FeatureSet}
          * @throws ReadException if there is any error while reading the features
          * @see {@link #createFeatureQuery(Expression,String,boolean)}, {@link #getFeatureSet(FeatureQuery)}
          */
         FeatureSet getFeatureSet(String filter, String sortBy) throws DataException;
         /**
          * Return a subset of features.
+         *
          * It is a utility method that calls {@link #getFeatureSet(FeatureQuery)}
+         *
          * @param filter an {@link String} expression used to filter the features in the store.
          * @param sortBy Attribute names separated by commas used to sort the list to return.
          * @param asc use order ascending, true, or descending, false.
          * @return the {@link FeatureSet}
          * @throws ReadException if there is any error while reading the features
          * @see {@link #createFeatureQuery(Expression,String,boolean)}, {@link #getFeatureSet(FeatureQuery)}
          */
         FeatureSet getFeatureSet(String filter, String sortBy, boolean asc) throws DataException;
         /**
          * Return a subset of features.
+         *
          * It is a utility method that calls {@link #getFeatureSet(FeatureQuery)}
+         *
          * @param filter an {@link Expression} used to filter the features in the store.
          * @return the {@link FeatureSet}
          * @throws DataException
          * @see {@link #createFeatureQuery(Expression,String,boolean)}, {@link #getFeatureSet(FeatureQuery)}
          */
         FeatureSet getFeatureSet(Expression filter) throws DataException;
         /**
          * Return a subset of features.
+         *
          * It is a utility method that calls {@link #getFeatureSet(FeatureQuery)}
+         *
          * The sort order used is ascending.
+         *
          * @param filter an {@link Expression} used to filter the features in the store.
          * @param sortBy Attribute names separated by commas used to sort the list to return.
          * @return the {@link FeatureSet}
          * @throws ReadException if there is any error while reading the features
          * @see {@link #createFeatureQuery(Expression,String,boolean)}, {@link #getFeatureSet(FeatureQuery)}
          */
         FeatureSet getFeatureSet(Expression filter, String sortBy) throws DataException;
         /**
          * Return a subset of features.
+         *
          * It is a utility method that calls {@link #getFeatureSet(FeatureQuery)}
+         *
          * @param filter an {@link Expression} used to filter the features in the store.
          * @param sortBy Attribute names separated by commas used to sort the list to return.
          * @param asc use order ascending, true, or descending, false.
          * @return the {@link FeatureSet}
          * @throws DataException
          * @see {@link #createFeatureQuery(Expression,String,boolean)}, {@link #getFeatureSet(FeatureQuery)}
          */
         FeatureSet getFeatureSet(Expression filter, String sortBy, boolean asc) throws DataException;
         /**
          * Returns a subset of features taking into account the properties and
          * restrictions of the FeatureQuery.
          * restrictions of the {@link FeatureQuery}.
+         *
          * If {@link FeatureQuery} is null, return al features in the store.
+         *
          * <p>
          * <em>
          * <strong>NOTE:</strong> if you use this method to get a
-...
          * </em>
          * </p>
+         *
          * @see #accept(org.gvsig.tools.visitor.Visitor,
          *      org.gvsig.fmap.dal.DataQuery)
+         *
          * @param featureQuery
          *            defines the characteristics of the features to return
          * @return a collection of features
          * @throws ReadException
          *             if there is any error while reading the features
          * @param featureQuery defines the characteristics of the features to return.
          * @return the {@link FeatureSet}
          * @throws ReadException if there is any error while reading the features.
          * @see #accept(org.gvsig.tools.visitor.Visitor, org.gvsig.fmap.dal.DataQuery)
          */
         FeatureSet getFeatureSet(FeatureQuery featureQuery) throws DataException;
         /**
          * Loads a subset of features taking into account the properties and
          * restrictions of the FeatureQuery. Feature loading is performed by calling
          * the Observer, once each loaded Feature.
          * restrictions of the FeatureQuery.
          * When feature loading is finished call the Observer passing the
          * {@link FeatureSet}  loaded.
+         *
          * @param featureQuery
          *            defines the characteristics of the features to return
          * @param observer
          *            to be notified of each loaded Feature
          * @throws DataException
          *             if there is any error while loading the features
          * @param featureQuery defines the characteristics of the features to return.
          * @param observer to be notified when loading is finished.
          * @throws DataException if there is any error while loading the features
          */
         void getFeatureSet(FeatureQuery featureQuery, Observer observer)
             throws DataException;
         void getFeatureSet(FeatureQuery featureQuery, Observer observer) throws DataException;
         /**
          * Loads all available feature in the store. The loading of Features is
          * performed by calling the Observer, once each loaded Feature.
+         *
          * @param observer
          *            to be notified of each loaded Feature
          * @throws DataException
          *             if there is any error while loading the features
          * @param observer to be notified of each loaded Feature
          * @throws DataException if there is any error while loading the features
          */
         void getFeatureSet(Observer observer) throws DataException;
         /**
          * Return a paginated list of Features filtered by the query.
+         *
          * If the query  is null, return all features in the store sorteds
          * by default order.
+         *
          * The return value implements {@link List} and {@link UnmodifiableBasicList64}
          * to support large list of features.
+         *
          * The returned list of Features is paginated, and the page size
          * used is "pageSize".
+         *
          * If the page size is less than or equal to 0, the default page size of
          * 100 will be used.
+         *
          * The returned List of Features is paginated, and the page size
          * used is "pageSize".
+         *
          * @param query to filter the returned feature list
          * @param query to filter and sort the returned feature list
          * @param pageSize the page size of the list
          * @return the list of features
          * @return the {@link List}/{@link UnmodifiableBasicList64} of features
          */
         public List<Feature> getFeatures(FeatureQuery query, int pageSize);
         /**
          * Return a paginated list of Features.
+         *
          * It is a utility method that calls {@link #getFeatures(FeatureQuery, int)}
          * using the default page size.
+         *
          * @param query to filter and sort the returned feature list
          * @return the {@link List}/{@link UnmodifiableBasicList64} of features
          * @see {@link #getFeatures(FeatureQuery, int)}
          */
         public List<Feature> getFeatures(FeatureQuery query);
         /**
          * Return a paginated list with al Features in the store.
+         *
          * It is a utility method that calls {@link #getFeatures(FeatureQuery, int)}
          * using the default page size.
+         *
          * @return the {@link List}/{@link UnmodifiableBasicList64} of features
          * @see {@link #getFeatures(FeatureQuery, int)}
          */
         public List<Feature> getFeatures();
         /**
          * Return a paginated list of Features
+         *
          * It is a utility method that calls {@link #getFeatures(FeatureQuery, int)}
+         *
          * @param filter used to filter the features in the store.
          * @return the List of Features
          * @see {@link #getFeatures(FeatureQuery, int)}, {@link #createFeatureQuery(String,String,boolean)}
          */
         public List<Feature> getFeatures(String filter);
         /**
          * Return a paginated list of Features.
+         *
          * It is a utility method that calls {@link #getFeatures(FeatureQuery, int)}
          * using the default page size.
+         *
          * @param filter used to filter the features in the store.
          * @param sortBy Attribute names separated by commas used to sort the list to return.
          * @return the {@link List}/{@link UnmodifiableBasicList64} of features
          * @see {@link #getFeatures(FeatureQuery, int)}, {@link #createFeatureQuery(String,String,boolean)}
          */
         public List<Feature> getFeatures(String filter, String sortBy);
         /**
          * Return a paginated list of Features.
+         *
          * It is a utility method that calls {@link #getFeatures(FeatureQuery, int)}
          * using the default page size.
+         *
          * @param filter an {@link String} expression used to filter the features in the store.
          * @param sortBy Attribute names separated by commas used to sort the list to return.
          * @param asc use order ascending, true, or descending, false.
          * @return the {@link List}/{@link UnmodifiableBasicList64} of features
          * @see {@link #getFeatures(FeatureQuery, int)}, {@link #createFeatureQuery(String,String,boolean)}
          */
         public List<Feature> getFeatures(String filter, String sortBy, boolean asc);
         /**
          * Return a paginated list of Features
+         *
          * It is a utility method that calls {@link #getFeatures(FeatureQuery, int)}
          * using the default page size.
+         *
          * @param filter an {@link Expression} used to filter the features in the store.
          * @return the List of Features
          * @see {@link #getFeatures(FeatureQuery, int)}, {@link #createFeatureQuery(Expression,String,boolean)}
          */
         public List<Feature> getFeatures(Expression filter);
         /**
          * Return a paginated list of Features
+         *
          * It is a utility method that calls {@link #getFeatures(FeatureQuery, int)}
          * using the default page size.
+         *
          * @param filter an {@link Expression} used to filter the features in the store.
          * @param sortBy Attribute names separated by commas used to sort the list to return.
          * @return the {@link List}/{@link UnmodifiableBasicList64} of features
          * @see {@link #getFeatures(FeatureQuery, int)}, {@link #createFeatureQuery(Expression,String,boolean)}
          */
         public List<Feature> getFeatures(Expression filter, String sortBy);
         /**
          * Return a paginated list of Features
+         *
          * It is a utility method that calls {@link #getFeatures(FeatureQuery, int)}
          * using the default page size.
+         *
          * @param filter an {@link Expression} used to filter the features in the store.
          * @param sortBy Attribute names separated by commas used to sort the list to return.
          * @param asc use order ascending, true, or descending, false.
          * @return the {@link List}/{@link UnmodifiableBasicList64} of features
          * @see {@link #getFeatures(FeatureQuery, int)}, {@link #createFeatureQuery(Expression,String,boolean)}
          */
         public List<Feature> getFeatures(Expression filter, String sortBy, boolean asc);
         /**
          * Return the first {@link Feature} of the store.
+         *
          * @return the first {@link Feature} or null if the store is empty.
          * @throws DataException
          */
         public Feature first() throws DataException;
         /**
          * Returns the first {@link Feature} that meets the criteria indicated.
+         *
          * It is a utility method that calls {@link #findFirst(FeatureQuery)}.
+         *
          * @param filter {@link String} expression used to filter the features.
          * @return the first {@link Feature} or null if the filter don't return any feature.
          * @throws DataException
          * @see {@link #findFirst(FeatureQuery)}, {@link #createFeatureQuery(String,String,boolean)}
          */
         public Feature findFirst(String filter) throws DataException;
         /**
          * Returns the first {@link Feature} that meets the criteria indicated.
+         *
          * It is a utility method that calls {@link #findFirst(FeatureQuery)}.
+         *
          * @param filter {@link String} expression used to filter the features.
          * @param sortBy Attribute names separated by commas used to sort the list to return.
          * @return the first {@link Feature} or null if the filter don't return any feature.
          * @throws DataException
          * @see {@link #findFirst(FeatureQuery)}, {@link #createFeatureQuery(String,String,boolean)}
          */
         public Feature findFirst(String filter, String sortBy) throws DataException;
         /**
          * Returns the first {@link Feature} that meets the criteria indicated.
+         *
          * It is a utility method that calls {@link #findFirst(FeatureQuery)}.
+         *
          * @param filter {@link String} expression used to filter the features.
          * @param sortBy Attribute names separated by commas used to sort the list to return.
          * @param asc use order ascending, true, or descending, false.
          * @return the first {@link Feature} or null if the filter don't return any feature.
          * @throws DataException
          * @see {@link #findFirst(FeatureQuery)}, {@link #createFeatureQuery(String,String,boolean)}
          */
         public Feature findFirst(String filter, String sortBy, boolean asc) throws DataException;
         /**
          * Returns the first {@link Feature} that meets the criteria indicated.
+         *
          * It is a utility method that calls {@link #findFirst(FeatureQuery)}.
+         *
          * @param filter {@link String} expression used to filter the features.
          * @return the first {@link Feature} or null if the filter don't return any feature.
          * @throws DataException
          * @see {@link #findFirst(FeatureQuery)}, {@link #createFeatureQuery(Expession,String,boolean)}
          */
         public Feature findFirst(Expression filter) throws DataException;
         /**
          * Returns the first {@link Feature} that meets the criteria indicated.
+         *
          * It is a utility method that calls {@link #findFirst(FeatureQuery)}.
+         *
          * @param filter {@link String} expression used to filter the features.
          * @param sortBy Attribute names separated by commas used to sort the list to return.
          * @return the first {@link Feature} or null if the filter don't return any feature.
          * @throws DataException
          * @see {@link #findFirst(FeatureQuery)}, {@link #createFeatureQuery(Expession,String,boolean)}
          */
         public Feature findFirst(Expression filter, String sortBy) throws DataException;
         /**
          * Returns the first {@link Feature} that meets the criteria indicated.
+         *
          * It is a utility method that calls {@link #findFirst(FeatureQuery)}.
+         *
          * @param filter {@link String} expression used to filter the features.
          * @param sortBy Attribute names separated by commas used to sort the list to return.
          * @param asc use order ascending, true, or descending, false.
          * @return the first {@link Feature} or null if the filter don't return any feature.
          * @throws DataException
          * @see {@link #findFirst(FeatureQuery)}, {@link #createFeatureQuery(Expession,String,boolean)}
          */
         public Feature findFirst(Expression filter, String sortBy, boolean asc) throws DataException;
         /**
          * Returns the first {@link Feature} that meets the criteria indicated.
+         *
          * It is a utility method that calls {@link #findFirst(FeatureQuery)}.
+         *
          * @param query to filter and sort the returned feature list
          * @return the first {@link Feature} or null if the filter don't return any feature.
          * @throws DataException
          * @see {@link #findFirst(FeatureQuery)}, {@link #createFeatureQuery(Expession,String,boolean)}
          */
         public Feature findFirst(FeatureQuery query) throws DataException;
         /**
          * Returns the feature given its reference.
+         *
          * @param reference
          *            a unique FeatureReference
          * @return
          *         The Feature
+         *
          * @param reference a unique FeatureReference
          * @return
          * @returnThe Feature
          * @throws DataException
+         *
          */
         public Feature getFeatureByReference(FeatureReference reference)
             throws DataException;
         public Feature getFeatureByReference(FeatureReference reference) throws DataException;
         /**
          * Returns the feature given its reference and feature type.

             public void recentUsed();
             @Override
             public String getLocalizedShortLabel();
             @Override
             public String getLocalizedLabel();
             public String getLabelOfValue(Object value);
+    }

trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.api/src/main/java/org/gvsig/fmap/dal/feature/Feature.java
501	501	* @return the FeatureStore of the feature.
502	502	*/
503	503	public FeatureStore getStore();
	504
	505	public String getLabelOfValue(String name);
504	506	}

                 return null;
+            }
+        }
         @Override
         public boolean equals(Object obj) {
             if( !(obj instanceof DynObject) ) {
                 return false;
+            }
             DynObjectManager manager = ToolsLocator.getDynObjectManager();
             return manager.equals(this, (DynObject) obj);
+        }
         @Override
         public int hashCode() {
             DynObjectManager manager = ToolsLocator.getDynObjectManager();
             return manager.hashCode(this);
+        }
         /**
          * Returns an instance of the {@link DynObject} to delegate to.
+         *

     import org.gvsig.fmap.dal.DataFactory;
     import org.gvsig.fmap.dal.DataManager;
     import org.gvsig.fmap.dal.DataParameters;
     import org.gvsig.fmap.dal.DataServerExplorer;
     import org.gvsig.fmap.dal.DataServerExplorerFactory;
     import org.gvsig.fmap.dal.DataServerExplorerParameters;
-...
         private List<DataProfile> dataProfiles;
         private final Map<String, DatabaseWorkspaceManager> databaseWorkspaces = new HashMap<>();
         public DefaultDataManager() {
             this.registers = new Registers();
             this.defaultDataIndexProviders = new HashMap<>();
-...
             DatabaseWorkspaceManager workspace = new DefaultDatabaseWorkspaceManager(connection);
             return workspace;
+        }
         @Override
         public void addDatabaseWorkspace(DatabaseWorkspaceManager databaseWorkspace) {
             this.databaseWorkspaces.put(databaseWorkspace.getId(),databaseWorkspace);
             StoresRepository repo = databaseWorkspace.getStoresRepository();
             this.getStoresRepository().addRepository(repo);
+        }
         @Override
         public DatabaseWorkspaceManager getDatabaseWorkspace(String name) {
             return this.databaseWorkspaces.get(name);
+        }
         @Override
         public DatabaseWorkspaceManager getDatabaseWorkspace(DataStoreParameters params) {
             for (DatabaseWorkspaceManager databaseWorkspace : this.databaseWorkspaces.values()) {
                 if( databaseWorkspace.getStoresRepository().contains(params) ) {
                     return databaseWorkspace;
+                }
+            }
             return null;
+        }
         @Override
         public void writeDALResource(ResourcesStorage resources, DataStore store) {
             ResourcesStorage.Resource resource = null;
             try {

     package org.gvsig.fmap.dal.impl;
     import java.io.File;
     import org.gvsig.fmap.dal.DatabaseWorkspaceManager;
     import org.apache.commons.lang3.StringUtils;
     import org.apache.commons.lang3.mutable.Mutable;
     import org.apache.commons.lang3.mutable.MutableObject;
     import org.gvsig.expressionevaluator.ExpressionBuilder;
     import org.gvsig.expressionevaluator.ExpressionUtils;
     import org.gvsig.fmap.dal.DALLocator;
-...
     import org.gvsig.fmap.dal.DataServerExplorerParameters;
     import org.gvsig.fmap.dal.DataStoreParameters;
     import org.gvsig.fmap.dal.DataTypes;
     import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.CONFIG_NAME_STORESREPOSITORYID;
     import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.CONFIG_NAME_STORESREPOSITORYLABEL;
     import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.FIELD_CONFIGURATION_NAME;
     import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.FIELD_CONFIGURATION_VALUE;
     import org.gvsig.fmap.dal.StoresRepository;
     import org.gvsig.fmap.dal.feature.EditableFeature;
     import org.gvsig.fmap.dal.feature.EditableFeatureType;
     import org.gvsig.fmap.dal.feature.Feature;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     //import org.gvsig.fmap.dal.store.jdbc.JDBCNewStoreParameters;
     //import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorer;
     //import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;
     //import org.gvsig.fmap.dal.store.jdbc.JDBCStoreParameters;
     import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.FIELD_REPOSITORY_NAME;
     import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.FIELD_REPOSITORY_PARAMETERS;
     import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.FIELD_RESOURCES_NAME;
     import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.FIELD_RESOURCES_RESOURCE;
     import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.TABLE_CONFIGURATION;
     import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.TABLE_CONFIGURATION_NAME;
     import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.TABLE_REPOSITORY;
     import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.TABLE_REPOSITORY_NAME;
     import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.TABLE_RESOURCES;
     import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.TABLE_RESOURCES_NAME;
     import org.gvsig.fmap.dal.feature.NewFeatureStoreParameters;
     import org.gvsig.tools.resourcesstorage.FilesResourcesStorage;
     import org.gvsig.tools.resourcesstorage.ResourcesStorage;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
-...
      * @author jjdelcerro
      */
     @SuppressWarnings("UseSpecificCatch")
     public class DefaultDatabaseWorkspaceManager implements DatabaseWorkspaceManager {
     public class DefaultDatabaseWorkspaceManager
             implements DatabaseWorkspaceManager
+        {
         private static final Logger LOGGER = LoggerFactory.getLogger(DefaultDatabaseWorkspaceManager.class);
         private final DataServerExplorerParameters connection;
         private final DataServerExplorerParameters serverParameters;
         private Boolean existsConfiguration = null;
         private StoresRepository storesRepository;
         private Mutable<ResourcesStorage> alternativeResourcesStorage = null;
         public DefaultDatabaseWorkspaceManager(DataServerExplorerParameters connection) {
             this.connection = connection;
         public DefaultDatabaseWorkspaceManager(DataServerExplorerParameters serverParameters) {
             this.serverParameters = serverParameters;
+        }
         @Override
         public String getId() {
             String id = this.get(CONFIG_NAME_STORESREPOSITORYID);
             return id;
+        }
         @Override
         public String getLabel() {
             String label = this.get(CONFIG_NAME_STORESREPOSITORYLABEL);
             return label;
+        }
         @Override
         public boolean existsTable(int tableid) {
             switch(tableid) {
                 case TABLE_RESOURCES:
-...
             try {
                 DataManager dataManager = DALLocator.getDataManager();
                 DataServerExplorer server = dataManager.openServerExplorer(
                         this.connection.getProviderName(),
                         this.connection
                         this.serverParameters.getProviderName(),
                         this.serverParameters
                 );
                 for (DataStoreParameters params : server.list()) {
                     String theTableName = (String) params.getDynValue("Table");
-...
             try {
                 DataManager dataManager = DALLocator.getDataManager();
                 DataServerExplorer server = dataManager.openServerExplorer(
                         this.connection.getProviderName(),
                         this.connection
                         this.serverParameters.getProviderName(),
                         this.serverParameters
                 );
                 DataStoreParameters params = server.get(tableName);
                 if( params!=null ) {
-...
             try {
                 DataManager dataManager = DALLocator.getDataManager();
                 DataServerExplorer server = dataManager.openServerExplorer(
                         this.connection.getProviderName(),
                         this.connection
                         this.serverParameters.getProviderName(),
                         this.serverParameters
                 );
                 DataStoreParameters params = server.get(tableName);
                 if( params!=null ) {
-...
             try {
                 DataManager dataManager = DALLocator.getDataManager();
                 DataServerExplorer server = dataManager.openServerExplorer(
                         this.connection.getProviderName(),
                         this.connection
                         this.serverParameters.getProviderName(),
                         this.serverParameters
                 );
                 NewFeatureStoreParameters params = (NewFeatureStoreParameters) server.getAddParameters(tableName);
                 EditableFeatureType ft = params.getDefaultFeatureType();
-...
             try {
                 DataManager dataManager = DALLocator.getDataManager();
                 DataServerExplorer server = dataManager.openServerExplorer(
                         this.connection.getProviderName(),
                         this.connection
                         this.serverParameters.getProviderName(),
                         this.serverParameters
                 );
                 NewFeatureStoreParameters params = (NewFeatureStoreParameters) server.getAddParameters(tableName);
                 EditableFeatureType ft = params.getDefaultFeatureType();
-...
             try {
                 DataManager dataManager = DALLocator.getDataManager();
                 DataServerExplorer server = dataManager.openServerExplorer(
                         this.connection.getProviderName(),
                         this.connection
                         this.serverParameters.getProviderName(),
                         this.serverParameters
                 );
                 NewFeatureStoreParameters params = (NewFeatureStoreParameters) server.getAddParameters(tableName);
                 EditableFeatureType ft = params.getDefaultFeatureType();
-...
                 this.storesRepository = new DatabaseWorkspaceStoresRepository(
                         id,
                         label,
                         this.connection
                         this.serverParameters
                 );
+            }
             return this.storesRepository;
+        }
         public boolean contains(DataStoreParameters parameters) {
             boolean c = this.getStoresRepository().contains(parameters);
             return c;
+        }
         @Override
         public boolean canAnonymousUserWriteInTheTables() {
-...
+        }
         @Override
         public boolean storesRepositoryWriteEntry(String name, DataStoreParameters parameters) {
         public boolean writeStoresRepositoryEntry(String name, DataStoreParameters parameters) {
             try {
                 byte[] data = parameters.toByteArray();
                 if( data == null ) {
-...
             return true;
+        }
         @Override
         public ResourcesStorage getAlternativeResourcesStorage() {
             if( this.alternativeResourcesStorage==null ) {
                 this.alternativeResourcesStorage = new MutableObject<>(null);
                 String resourcesPath = this.get("ALTERNATIVE_RESOURCES_PATH");
                 if( !StringUtils.isBlank(resourcesPath) ) {
                     try {
                         resourcesPath = (String) ExpressionUtils.evaluate(resourcesPath);
                     } catch(Throwable th) {
                         // Do nothing
+                    }
                     File f = new File(resourcesPath);
                     if( f.exists() ) {
                         ResourcesStorage resources = new FilesResourcesStorage(resourcesPath);
                         this.alternativeResourcesStorage.setValue(resources);
+                    }
+                }
+            }
             return this.alternativeResourcesStorage.getValue();
+        }
         public void create(String id, String description) {
             if( !this.existsTable(TABLE_RESOURCES) ) {
                 this.createTable(TABLE_RESOURCES);
+            }
             if( !this.existsTable(TABLE_CONFIGURATION) ) {
                 this.createTable(TABLE_CONFIGURATION);
+            }
             if( !this.existsTable(TABLE_REPOSITORY) ) {
                 this.createTable(TABLE_REPOSITORY);
+            }
             this.set(CONFIG_NAME_STORESREPOSITORYID,id);
             this.set(CONFIG_NAME_STORESREPOSITORYLABEL,description);
             this.set(CONFIG_CAN_ANONYMOUS_USER_WRITE_IN_THE_TABLES,"true");
             this.set("ALTERNATIVE_RESOURCES_PATH","");
+        }
+    }

         public boolean containsKey(String key) {
             return this.data.getType().get(key)!=null;
+        }
         @Override
         public String getLabelOfValue(String name) {
             FeatureAttributeDescriptor attrdesc = this.data.getType().getAttributeDescriptor(name);
             if( attrdesc==null ) {
                 throw new IllegalArgumentException("Attribute name '"+name+"' not found in the feature.");
+            }
             Object value = this.get(attrdesc.getIndex());
             String label = attrdesc.getLabelOfValue(value);
             return label;
+        }
+    }

     import org.gvsig.expressionevaluator.Expression;
     import org.gvsig.expressionevaluator.ExpressionBuilder;
     import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;
     import org.gvsig.expressionevaluator.ExpressionUtils;
     import org.gvsig.fmap.dal.BaseStoresRepository;
     import org.gvsig.fmap.dal.DALLocator;
-...
         @Override
         public List<Feature> getFeatures(String filter, String sortBy, boolean asc)  {
             FeatureQuery query = this.createFeatureQuery(filter, sortBy, asc);
             return this.getFeatures(query, 100);
             return this.getFeatures(query, 0);
+        }
         @Override
-...
         @Override
         public List<Feature> getFeatures(Expression filter, String sortBy, boolean asc)  {
             FeatureQuery query = this.createFeatureQuery(filter, sortBy, asc);
             return this.getFeatures(query, 100);
             return this.getFeatures(query, 0);
+        }
         @Override
         public List<Feature> getFeatures(FeatureQuery query)  {
             return this.getFeatures(query, 100);
             return this.getFeatures(query, 0);
+        }
         @Override
         public List<Feature> getFeatures(FeatureQuery query, int pageSize)  {
             try {
                 if( pageSize<=0 ) {
                     pageSize = 100;
+                }
                 FeaturePagingHelper pager = this.dataManager.createFeaturePagingHelper(this, query, pageSize);
                 return pager.asList();
             } catch (BaseException ex) {
-...
         @Override
         public List<Feature> getFeatures() {
             return this.getFeatures(null, 500);
             return this.getFeatures(null, 0);
+        }
         @Override
-...
             return new DefaultFeatureQuery();
+        }
         private FeatureQuery createFeatureQuery(Expression filter, String sortBy, boolean asc) {
         public FeatureQuery createFeatureQuery(Expression filter, String sortBy, boolean asc) {
             FeatureQuery query = null;
             if( filter!=null ) {
                 query = this.createFeatureQuery();
-...
                 if( query == null ) {
                     query = this.createFeatureQuery();
+                }
                 query.getOrder().add(sortBy, asc);
                 String[] attrnames;
                 if( sortBy.contains(",") ) {
                     attrnames = StringUtils.split(sortBy, ",");
                 } else {
                     attrnames = new String[] { sortBy };
+                }
                 for (String attrname : attrnames) {
                     attrname = attrname.trim();
                     if( attrname.startsWith("-") ) {
                         query.getOrder().add(sortBy.substring(1).trim(), false);
                     } else if( attrname.endsWith("-") ) {
                         query.getOrder().add(sortBy.substring(0,sortBy.length()-1).trim(), false);
                     } else if( attrname.startsWith("+") ) {
                         query.getOrder().add(sortBy.substring(1).trim(), true);
                     } else if( attrname.endsWith("-") ) {
                         query.getOrder().add(sortBy.substring(0,sortBy.length()-1).trim(), true);
                     } else {
                         query.getOrder().add(sortBy, asc);
+                    }
+                }
+            }
             if( query != null ) {
                 query.retrievesAllAttributes();
-...
             return query;
+        }
         private FeatureQuery createFeatureQuery(String filter, String sortBy, boolean asc) {
             FeatureQuery query = null;
             if( !StringUtils.isEmpty(filter) ) {
                 query = this.createFeatureQuery();
                 query.setFilter(filter);
         public FeatureQuery createFeatureQuery(String filter, String sortBy, boolean asc) {
             if( StringUtils.isBlank(filter) ) {
                 return this.createFeatureQuery(
                         (Expression)null,
                         sortBy,
                         asc
                 );
             } else {
                 return this.createFeatureQuery(
                         ExpressionUtils.createExpression(filter),
                         sortBy,
                         asc
                 );
+            }
             if( !StringUtils.isEmpty(sortBy) ) {
                 if( query == null ) {
                     query = this.createFeatureQuery();
+                }
                 query.getOrder().add(sortBy, asc);
+            }
             if( query != null ) {
                 query.retrievesAllAttributes();
+            }
             return query;
+        }
         @Override

         protected boolean allowIndexDuplicateds = true;
         protected DynObjectValueItem[] availableValues;
         private Map<Object,String> labelOfValueMap; // No persistente
         protected String description;
         protected Object minValue;
         protected Object maxValue;
-...
+        }
         @Override
         public String getLabelOfValue(Object value) {
             if( this.labelOfValueMap != null ) {
                 String theLabel = this.labelOfValueMap.get(value);
                 if( theLabel == null ) {
                     theLabel = Objects.toString(value, "");
+                }
                 return theLabel;
+            }
             DynObjectValueItem[] values = this.getAvailableValues();
             if( values == null ) {
                 return Objects.toString(value, "");
+            }
             Map<Object, String> map = new HashMap<>();
             for (DynObjectValueItem theValue : values) {
                 map.put(theValue.getValue(), theValue.getLabel());
+            }
             this.labelOfValueMap = map;
             String theLabel = this.labelOfValueMap.get(value);
             if( theLabel == null ) {
                 theLabel = Objects.toString(value, "");
+            }
             return theLabel;
+        }
         @Override

Application: gvSIG desktop

Revision 44346