/ - Diff - Application: gvSIG desktop - gvSIG

             return null;
+        }
         @Override
         public JDBCConnectionParameters getConnectionParameters() {
             return connectionParameters;
+        }
-...
         @Override
         public void fetchFeature(FeatureProvider feature, ResultSetEntry rs) throws DataException {
             fetchFeature(feature, rs.get());
             fetchFeature(feature, rs.get(), rs.getColumns());
+        }
         @Override
         public void fetchFeature(FeatureProvider feature, ResultSet rs) throws DataException {
         public void fetchFeature(FeatureProvider feature, ResultSet rs, FeatureAttributeDescriptor[] columns) throws DataException {
             try {
                 int index;
                 Object value;
                 for (FeatureAttributeDescriptor attr : feature.getType()) {
                     index = attr.getIndex();
                     switch (attr.getType()) {
                 for (int index = 0; index < columns.length; index++) {
                     FeatureAttributeDescriptor column = columns[index];
                     switch (column.getType()) {
                         case DataTypes.GEOMETRY:
                             value = this.getGeometryFromColumn(rs, index + 1);
                             break;
                         default:
                             value = rs.getObject(index + 1);
+                    }
                     feature.set(index, value);
                     feature.set(column.getIndex(), value);
+                }
             } catch (Exception ex) {
                 throw new JDBCCantFetchValueException(ex);
-...
             try {
                 Object value;
                 switch (this.getGeometrySupportType()) {
                     case NATIVE:
                     case WKB:
                         value = rs.getBytes(index);
                         if (value == null) {
-...
             return new JDBCStoreParameters();
+        }
         @Override
         public JDBCServerExplorerParameters createServerExplorerParameters() {
             return new JDBCServerExplorerParameters();
+        }

     import java.sql.Connection;
     import java.util.ArrayList;
     import java.util.List;
     import org.apache.commons.lang3.ArrayUtils;
     import org.apache.commons.lang3.StringUtils;
     import org.gvsig.fmap.dal.ExpressionBuilder.Config;
     import org.gvsig.fmap.dal.exception.DataException;
-...
                 long offset,
                 int fetchSize
             ) throws DataException {
             List<FeatureAttributeDescriptor> columns = new ArrayList<>();
             double tolerance = -1 ; //query.getScale();
             JDBCSQLBuilderBase sqlbuilder = createSQLBuilder();
-...
                 // Ordenamos siempre por las claves primarias para garantizar
                 // un orden predecible. Ademas se precisa indicar un orden para
                 // usar OFFSET.
                 sqlbuilder.select().order_by().column(sqlbuilder.identifier(attrName));
                 sqlbuilder.select().order_by().column(sqlbuilder.identifier(attrName)).ascending();
+            }
             String[] constantsAttributeNames = null;
             if(query !=null && query.hasConstantsAttributeNames() ) {
                 constantsAttributeNames = query.getConstantsAttributeNames();
+            }
             for(FeatureAttributeDescriptor attr : setType ) {
                 if( ArrayUtils.contains(constantsAttributeNames, attr.getName()) ) {
                     continue;
+                }
                 if( attr.isPrimaryKey() ) {
                     primaryKeys.remove(attr.getName());
+                }
-...
+                            )
                         ).as_geometry();
+                    }
                     columns.add(attr);
                 } else {
                     sqlbuilder.select().column().name(attr.getName());
                     columns.add(attr);
+                }
+            }
             for(String attrName : primaryKeys ) {
                 sqlbuilder.select().column().name(attrName);
                 columns.add(setType.getAttributeDescriptor(attrName));
+            }
             if( StringUtils.isEmpty(subquery)  ) {
-...
             String sql = sqlbuilder.toString();
             ResultSetEntry resultSetEntry = this.helper.getResulSetControler().create(
                     sql, fetchSize
                     sql, fetchSize, columns.toArray(new FeatureAttributeDescriptor[columns.size()])
             );
             return resultSetEntry;
+        }

     import java.sql.PreparedStatement;
     import java.sql.ResultSet;
     import java.sql.SQLException;
     import java.util.ArrayList;
     import java.util.List;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
     import org.gvsig.fmap.dal.feature.FeatureType;
-...
                 String schema,
                 String table
             ) throws DataException {
             List<FeatureAttributeDescriptor> columns = new ArrayList<>();
             // FeatureAttributeDescriptor[] primaryKey = storeType.getPrimaryKey();
             String[] primaryKeys = reference.getKeyNames();
-...
             for (FeatureAttributeDescriptor attr : featureType) {
                 if( attr.getType()==DataTypes.GEOMETRY ) {
                     sqlbuilder.select().column().name(attr.getName()).as_geometry();
                     columns.add(attr);
                 } else {
                     sqlbuilder.select().column().name(attr.getName());
                     columns.add(attr);
+                }
+            }
             sqlbuilder.select().from().table().database(database).schema(schema).name(table);
             for (String name : primaryKeys )  {
                 if( !sqlbuilder.select().has_column(name) ) {
                     sqlbuilder.select().column().name(name);
                     columns.add(featureType.getAttributeDescriptor(name));
+                }
                 Object value = reference.getKeyValue(name);
                 if( value == null ) {
-...
                     return null;
+                }
                 FeatureProvider data = this.helper.createFeature(featureType);
                 this.helper.fetchFeature(data, rs);
                 this.helper.fetchFeature(data, rs, columns.toArray(new FeatureAttributeDescriptor[columns.size()]));
                 return data;
             } catch (SQLException ex) {

     import java.sql.SQLException;
     import java.util.List;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
     public interface ResulSetControler extends AutoCloseable {
-...
             public int getID();
             public boolean isZombie();
             public String getSQL();
             public FeatureAttributeDescriptor[] getColumns();
             public Object getObject(int columnIndex) throws SQLException;
             public byte[] getBytes(int columnIndex) throws SQLException;
             public boolean next() throws SQLException;
-...
         public long getTimeToZombie();
         public ResultSetEntry create(String sql, int fetchSize) throws DataException;
         public ResultSetEntry create(String sql, int fetchSize, FeatureAttributeDescriptor[] columns ) throws DataException;
         public ResultSetEntry create(String sql, List<Object> values, int fetchSize) throws DataException;
         public ResultSetEntry create(String sql, List<Object> values, int fetchSize, FeatureAttributeDescriptor[] columns ) throws DataException;
         public int getOpenCount();

             return isEmpty;
+        }
         protected JDBCIterator createFastIterator(long index) throws DataException {
             return createFastIterator(index, 0);
+        }
         @Override
         protected JDBCIterator createFastIterator(long index) throws DataException {
         protected JDBCIterator createFastIterator(long index, long elements) throws DataException {
             if( BooleanUtils.isTrue(isEmpty) ) {
                 return new EmptyJDBCIterator(this.getJDBCStore());
+            }
-...
                         this.getQuery(),
                         storeType,
                         this.getFeatureType(),
                         -1,
                         elements,
                         index,
                         this.getDefaultFetchSize()
                 );
-...
         @Override
         protected JDBCIterator createIterator(long index) throws DataException {
             return createIterator(index, -1);
+        }
         @Override
         protected JDBCIterator createIterator(long index, long elements) throws DataException {
             if( BooleanUtils.isTrue(isEmpty) ) {
                 return new EmptyJDBCIterator(this.getJDBCStore());
+            }
-...
                         this.getQuery(),
                         storeType,
                         this.getFeatureType(),
                         -1,
                         elements,
                         index,
                         this.getDefaultFetchSize()
                 );

     import java.util.List;
     import java.util.Map;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
     import org.gvsig.fmap.dal.store.jdbc.exception.JDBCExecutePreparedSQLException;
     import org.gvsig.fmap.dal.store.jdbc2.JDBCHelper;
     import org.gvsig.fmap.dal.store.jdbc2.JDBCUtils;
-...
             private final int id;
             private long lastUse = 0;
             private String sql;
             private final FeatureAttributeDescriptor[] columns;
             public ResultSetEntryBase(ResultSet resulSet) {
                 this(resulSet,null);
             public ResultSetEntryBase(ResultSet resulSet, FeatureAttributeDescriptor[] columns) {
                 this(resulSet,null, columns);
+            }
             public ResultSetEntryBase(ResultSet resulSet, String sql) {
             public ResultSetEntryBase(ResultSet resulSet, String sql, FeatureAttributeDescriptor[] columns) {
                 this.resultSet = resulSet;
                 this.id = nextid++;
                 this.sql = sql;
                 this.columns = columns;
                 used();
                 resulSets.put(this.getID(), this);
+            }
-...
                 return this.sql;
+            }
             public FeatureAttributeDescriptor[] getColumns() {
                 return this.columns;
+            }
             @Override
             public Object getObject(int columnIndex) throws SQLException {
                 used();
-...
+        }
         @Override
         public ResultSetEntryBase create(String sql, int fetchSize) throws DataException {
             return create(sql, null, fetchSize);
         public ResultSetEntryBase create(
                 String sql,
                 int fetchSize,
                 FeatureAttributeDescriptor[] columns) throws DataException {
             return create(sql, null, fetchSize, columns);
+        }
         @Override
         public synchronized ResultSetEntryBase create(
                 final String sql,
                 final List values,
                 final int fetchSize) throws DataException {
                 final int fetchSize,
                 FeatureAttributeDescriptor[] columns) throws DataException {
             this.pack();
             ResultSet rs = null;
-...
                 JDBCUtils.setObjects(st, values, helper.getGeometrySupportType());
                 if (fetchSize > 0) {
                     // See parameter "SelectMethod" of SQL Server Connection Properties
                     // https://docs.oracle.com/cd/E13157_01/wlevs/docs30/jdbc_drivers/mssqlserver.html
                     st.setFetchSize(fetchSize);
+                }
                 rs = JDBCUtils.executeQuery(st, sql);
-...
                 JDBCUtils.closeQuietly(conn);
                 throw new JDBCExecutePreparedSQLException(sql, values, e);
+            }
             ResultSetEntryBase rsentry = new ResultSetEntryBase(rs, sql);
             ResultSetEntryBase rsentry = new ResultSetEntryBase(rs, sql, columns);
             return rsentry;
+        }

     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.exception.InitializeException;
     import org.gvsig.fmap.dal.ExpressionBuilder.GeometrySupportType;
     import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
     import org.gvsig.fmap.dal.feature.FeatureType;
     import org.gvsig.fmap.dal.feature.spi.FeatureProvider;
     import org.gvsig.fmap.dal.resource.exception.AccessResourceException;
-...
         public void fetchFeature(
                 FeatureProvider feature,
                 ResultSet rs
                 ResultSet rs,
                 FeatureAttributeDescriptor[] columns
         ) throws DataException;
         public void fetchFeature(
                 FeatureProvider feature,
                 ResultSetEntry rs

trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.db/org.gvsig.fmap.dal.db.jdbc/src/main/java/org/gvsig/fmap/dal/store/jdbc2/JDBCUtils.java
111	111	value = ((Geometry) value).convertToWKT();
112	112	st.setObject(columnIndex, value);
113	113	break;
	114	case NATIVE:
114	115	case WKB:
115	116	bytes = ((Geometry) value).convertToWKB();
116	117	st.setBytes(columnIndex, bytes);

     import java.awt.event.ActionEvent;
     import java.awt.event.ActionListener;
     import java.util.logging.Level;
     import javax.swing.ListSelectionModel;
     import javax.swing.event.EventListenerList;
     import javax.swing.event.ListSelectionEvent;
-...
             try {
                 FeatureSelection selection = getFeatureSelection();
                 if (!selection.isEmpty()) {
                     FeatureStore store = getFeatureStore();
                 	FeatureQuery query = this.featureTableModel.getFeatureQuery();
                 	if(query!= null){
                 		fs = getFeatureStore().getFeatureSet(query);
                 	if(query== null){
                         query = store.createFeatureQuery();
                 	}else{
                 		fs = getFeatureStore().getFeatureSet();
                         try {
                             query = (FeatureQuery) query.clone();
                         } catch (CloneNotSupportedException ex) {
+                        }
+                	}
                     query.addEssentialAttributeNames(store);
                     fs = store.getFeatureSet(query);
                     diter = fs.fastIterator();
                     Feature feat = null;
                     Feature feat;
                     while (diter.hasNext()) {
                         ind++;
                         feat = (Feature) diter.next();

         public enum GeometrySupportType {
             WKT,
             WKB,
             EWKB
             EWKB,
             NATIVE
+        }
         public enum ParameterType {

     	 */
     	void addAttributeName(String attributeName);
             /**
              * Return true if has set attribute names
+             *
              * @return true if has attribute names, otherwise false
              */
             boolean hasAttributeNames();
         public void addPrimaryKeyAttributeNames(FeatureStore store);
             /**
              * Remove all the attribute names specifieds.
              */
             void clearAttributeNames();
         public void addEssentialAttributeNames(FeatureStore store);
             /**
         /**
          * Return true if has set attribute names
+         *
          * @return true if has attribute names, otherwise false
          */
         boolean hasAttributeNames();
         /**
          * Remove all the attribute names specifieds.
          */
         void clearAttributeNames();
         /**
     	 * Returns the names of the attributes that are constants in each {@link Feature}.
     	 * These attributes will not be charged.
+             *
-...
     	boolean hasOrder();
     	/**
          * @return
     	 * @deprecated to be removed in gvSIG 2.0
     	 * @see #clone()
     	 */

     	/**
     	 * Returns an Array of the FeatureAttributeDescriptor that compounds the
     	 * primary key
     	 * primary key. If not have primary keys return a empty array.
+    	 *
     	 * @return
     	 */

      */
     package org.gvsig.fmap.dal.feature;
     import java.util.Iterator;
     import java.util.List;
     import org.gvsig.fmap.dal.DataSet;
-...
          */
     	DisposableIterator iterator(long index) throws DataException;
         DisposableIterator iterator(long index, long elements) throws DataException;
         /**
          * Returns an iterator over the elements in this collection, in the order
          * (if any) defined when the collection was obtained.
-...
          *         sequence).
+         *
          * @deprecated use fastiterator. In next versions the signature of this
          * method will be changed to "Iterator<Feature> iterator()".
          * method will be changed to "Iterator&lt;Feature&gt; iterator()".
          */
          DisposableIterator iterator();
-...
          */
     	public DisposableIterator fastIterator(long index) throws DataException;
         public DisposableIterator fastIterator(long index, long elemets) throws DataException;
     	/**
     	 * Indicates whether this FeatureSet contains zero features.
+    	 *
-...
          * @exception BaseException
          *                if there is an error while performing the visit
          */
         @Override
         void accept(Visitor visitor, long firstValueIndex) throws BaseException;
         void accept(Visitor visitor, long firstValueIndex, long elements) throws BaseException;
+    }

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/FeatureStoreProviderFactory.java
96	96	* @return
97	97	*/
98	98	public int getMaxAttributeNameSize();
	99
	100	public boolean supportNumericOID();
99	101
100	102	}

         /**
          * Returns the current {@link FeatureSelection}.
          * Create a empty selection if not exits.
+         *
          * Manage of the selection can be slow on some data sources.
          * Use with care.
          * In data sources that do not support position access to records,
          * it may be slow to retrieve items from the selection. In some data
          * sources it may be necessary to access to this to retrieve each
          * item in the selection.
+         *
          * @return
          *         current {@link FeatureSelection}.

trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.spi/src/main/java/org/gvsig/fmap/dal/feature/spi/AbstractFeatureStoreProviderFactory.java
90	90	public int getMaxAttributeNameSize() {
91	91	return -1;
92	92	}
	93
	94	@Override
	95	public boolean supportNumericOID() {
	96	return false;
	97	}
	98
	99
93	100	}

trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.spi/src/main/java/org/gvsig/fmap/dal/feature/spi/ExpressionBuilderBase.java
363	363	switch (config.getGeometryTypeSupport()) {
364	364	case EWKB:
365	365	return bytearray(((Geometry) this.value).convertToEWKB());
	366	case NATIVE:
366	367	case WKB:
367	368	return bytearray(((Geometry) this.value).convertToWKB());
368	369	case WKT:

     		return featureType;
+    	}
         @Override
     	public final DisposableIterator fastIterator() throws DataException {
     		return fastIterator(0);
+    	}
-...
     		return createFastIterator(index);
+    	}
         @Override
         public final DisposableIterator fastIterator(long index, long elements) throws DataException {
     		return createFastIterator(index, elements);
+    	}
         @Override
     	public final DisposableIterator iterator() throws DataException {
     		return iterator(0);
+    	}
-...
     		return createIterator(index);
+    	}
         @Override
     	public final DisposableIterator iterator(long index, long elements) throws DataException {
     		return createIterator(index, elements);
+    	}
     	/**
     	 * Creates a new {@link Iterator}, begginning at the specified data index.
+    	 *
-...
     	protected abstract AbstractFeatureProviderIterator createIterator(long index)
     			throws DataException;
     	/**
     	protected AbstractFeatureProviderIterator createIterator(long index, long elements)
     			throws DataException {
                 return createIterator(index);
+        }
         /**
     	 * Creates a new fast {@link Iterator}, begginning at the specified data
     	 * index. By fast this means the object instances of data (
     	 * {@link FeatureProvider}) may be reused between the
-...
     	 */
     	protected abstract AbstractFeatureProviderIterator createFastIterator(
     			long index) throws DataException;
     	protected AbstractFeatureProviderIterator createFastIterator(
     			long index, long elements) throws DataException {
                 return createFastIterator(index);
+            }
+    }

          * @param index
          *            index of first element to be returned from the iterator (by a
          *            call to the <tt>next</tt> method).
          * @param elements
          * @return an iterator of the elements in this collection (in proper
          *         sequence).
+         *
-...
+         *
          * @deprecated use {@link #fastIterator()} instead
          */
     	DisposableIterator iterator(long index) throws DataException;
     	DisposableIterator iterator(long index, long elements) throws DataException;
         /**
          * Returns an iterator over the elements in this set, in the order
-...
          * Returns an iterator over the elements in this set, in the order
          * (if any) defined when the collection was obtained.
+         *
          * @param elements
          * @see #fastIterator()
          * @see #fastIterator(long)
+         *
-...
          * @throws DataException
          *             if there is an error getting the iterator
          */
     	DisposableIterator fastIterator(long index) throws DataException;
     	DisposableIterator fastIterator(long index, long elements) throws DataException;
+    }

     import org.gvsig.tools.visitor.VisitCanceledException;
     import org.gvsig.tools.visitor.Visitor;
     import org.gvsig.tools.visitor.impl.AbstractIndexedVisitable;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     public abstract class AbstractFeatureSet
         extends AbstractIndexedVisitable
         implements FeatureSet {
         protected static final Logger LOG = LoggerFactory.getLogger(AbstractFeatureSet.class);
         public abstract FeatureStore getFeatureStore();
         @Override
         public final void accept(Visitor visitor, long firstValueIndex, long elements) throws BaseException {
             try {
                 doAccept(visitor, firstValueIndex, elements);
             } catch (VisitCanceledException ex) {
                 // The visit has been cancelled by the visitor, so we finish here.
                 LOG.debug(
                         "The visit, beggining on position {}, has been cancelled "
                         + "by the visitor: {}", new Long(firstValueIndex),
                         visitor);
+            }
+        }
         @Override
         protected void doAccept(Visitor visitor, long firstValueIndex)
             throws VisitCanceledException, BaseException {
             DisposableIterator iterator = fastIterator(firstValueIndex);
             if( iterator != null ) {
                 try {
                     while (iterator.hasNext()) {
                         Feature feature = (Feature) iterator.next();
                         visitor.visit(feature);
+                    }
                 } finally {
                     DisposeUtils.disposeQuietly(iterator);
             doAccept(visitor, firstValueIndex, 0);
+        }
         protected void doAccept(Visitor visitor, long firstValueIndex, long elements)
             throws VisitCanceledException, BaseException {
             DisposableIterator iterator = fastIterator(firstValueIndex, elements);
             try {
                 while (iterator.hasNext()) {
                     Feature feature = (Feature) iterator.next();
                     visitor.visit(feature);
+                }
             } finally {
                 iterator.dispose();
+            }
+        }
         @Override
         public Feature first() {
             DisposableIterator it = null;

                 return;
+            }
+        }
         protected void checkSourceStoreModified() {
             if (sourceStoreModified) {
     			throw new ConcurrentDataModificationException(store == null ? ""
-...
+            }
+        }
         @Override
         public DisposableIterator fastIterator(long index) throws DataException {
             return fastIterator(index, 0);
+        }
         @Override
         public DisposableIterator fastIterator(long index, long elements) throws DataException {
             if (index < 0) {
                 throw new IndexOutOfBoundsException("The index (" + index
                     + ") is less than 0");
-...
             switch (mode) {
             case DEFAULT:
                 return new FastDefaultIterator(this, index);
                 return new FastDefaultIterator(this, index, elements);
             case FILTERED:
                 return new FastFilteredIterator(this, index);
-...
                 if (this.orderedData != null) {
                     return new FastOrderedIterator(this, index);
                 } else {
                     return new FastOrderedIterator(this, new FastDefaultIterator(
                         this, 0), index);
                     return new FastOrderedIterator(this, new FastDefaultIterator(this, 0, elements), index);
+                }
             case ORDERED_FILTERED:
-...
+        }
         @Override
         public DisposableIterator iterator(long index) throws DataException {
             return iterator(index,0);
+        }
         @Override
         public DisposableIterator iterator(long index, long elements) throws DataException {
             if (index < 0) {
                 throw new IndexOutOfBoundsException("The index (" + index
                     + ") is less than 0");
-...
             switch (mode) {
             case DEFAULT:
                 return new DefaultIterator(this, index);
                 return new DefaultIterator(this, index, elements);
             case FILTERED:
                 return new FilteredIterator(this, index);
-...
                     return new OrderedIterator(this, index);
                 } else {
                     return new OrderedIterator(this, new DefaultIterator(this, 0),
                         index);
                     return new OrderedIterator(this, new DefaultIterator(this, 0, elements),index);
+                }
             case ORDERED_FILTERED:
-...
         public FeatureStore getFeatureStore() {
             return store;
+        }
+    }

     	DefaultFeature myFeature;
     	public FastDefaultIterator(DefaultFeatureSet featureSet, long index)
     	public FastDefaultIterator(DefaultFeatureSet featureSet, long index, long elements)
     			throws DataException {
     		super(featureSet);
     		this.initializeFeature();
     		if (index > 0) {
     		if (index > 0 || elements>0 ) {
     			if (featureSet.provider.canIterateFromIndex()) {
     				try {
     					this.iterator = featureSet.provider.fastIterator(index);
     					this.iterator = featureSet.provider.fastIterator(index,elements);
     				} catch (UnsupportedOperationException e) {
     					this.iterator = featureSet.provider.fastIterator();
     					skypto(index);

     		this.fset = featureSet;
+    	}
     	public DefaultIterator(DefaultFeatureSet featureSet, long index)
     	public DefaultIterator(DefaultFeatureSet featureSet, long index, long elements)
     			throws DataException {
     		this.fset = featureSet;
     		if (index > 0) {
     			if (featureSet.provider.canIterateFromIndex()) {
     				try {
     					this.iterator = featureSet.provider.iterator(index);
     					this.iterator = featureSet.provider.iterator(index, elements);
     				} catch (UnsupportedOperationException e) {
     					this.iterator = featureSet.provider.iterator();
     					skypto(index);

     import org.gvsig.fmap.dal.feature.FeatureSet;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.fmap.dal.feature.FeatureStoreNotification;
     import org.gvsig.fmap.dal.feature.FeatureStoreProviderFactory;
     import org.gvsig.fmap.dal.feature.FeatureStoreTransforms;
     import org.gvsig.fmap.dal.feature.FeatureType;
     import org.gvsig.fmap.dal.feature.NewFeatureStoreParameters;
-...
     import org.gvsig.fmap.dal.spi.DataStoreInitializer2;
     import org.gvsig.fmap.dal.spi.DataStoreProvider;
     import org.gvsig.fmap.dal.spi.DataStoreProviderServices;
     import org.gvsig.fmap.geom.GeometryLocator;
     import org.gvsig.fmap.geom.GeometryManager;
     import org.gvsig.fmap.geom.SpatialIndex;
     import org.gvsig.fmap.geom.primitive.Envelope;
     import org.gvsig.metadata.MetadataLocator;
     import org.gvsig.metadata.MetadataManager;

     package org.gvsig.fmap.dal.feature.impl;
     import java.lang.ref.WeakReference;
     import java.text.MessageFormat;
     import java.util.ArrayList;
     import java.util.Arrays;
     import java.util.Iterator;
     import java.util.List;
     import org.apache.commons.lang3.ArrayUtils;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.feature.Feature;
-...
+    	}
     	private void calculatePK(FeatureProvider fdata) {
     		ArrayList keys = new ArrayList();
     		ArrayList keyNames = new ArrayList();
     		FeatureType type = fdata.getType();
     		Iterator it = type.iterator();
     		while (it.hasNext()) {
     			FeatureAttributeDescriptor attr = (FeatureAttributeDescriptor) it
     					.next();
     			if (attr.isPrimaryKey()) {
     				keys.add(fdata.get(attr.getIndex()));
     				keyNames.add(attr.getName());
+    			}
+    		}
     		if (keys.size() < 1) {
     			pk = null;
     			pkNames = null;
     		} else {
     			pk = keys.toArray();
                 pkNames = (String[]) keyNames.toArray(new String[keyNames.size()]);
+    		}
+    	}
                 FeatureAttributeDescriptor[] pkattrs = fdata.getType().getPrimaryKey();
                 if( ArrayUtils.isEmpty(pkattrs) ) {
                     this.pk = null;
                     this.pkNames = null;
                     return ;
+                }
                 this.pk = new Object[pkattrs.length];
                 this.pkNames = new String[pkattrs.length];
                 int n = 0;
                 for (FeatureAttributeDescriptor pkattr : pkattrs) {
                     this.pk[n] = fdata.get(pkattr.getIndex());
                     this.pkNames[n] = pkattr.getName();
                     n++;
+                }
+        }
         @Override
     	public Feature getFeature() throws DataException {
     		return this.getStore().getFeatureByReference(this);
+    	}
         @Override
     	public Feature getFeature(FeatureType featureType) throws DataException {
     		return this.getStore().getFeatureByReference(this, featureType);
+    	}
         @Override
     	public Object getOID() {
     		return this.oid;
+    	}
         @Override
     	public boolean isNewFeature() {
     		return this.isNewFeature;
+    	}
         @Override
     	public boolean equals(Object obj) {
     		if (!(obj instanceof DefaultFeatureReference)) {
     			return false;
-...
     		return true;
+    	}
         @Override
     	public int hashCode() {
     		if (this.oid != null) {
     			return this.oid.hashCode();
+    		}
     		if (myHashCode == null) {
     			StringBuffer buff = new StringBuffer();
     			StringBuilder buff = new StringBuilder();
     			for (int i = 0; i < this.pk.length; i++) {
     				buff.append(this.pk[i].hashCode());
     				buff.append("##");
+    			}
     			myHashCode = new Integer(buff.toString().hashCode());
     			myHashCode = buff.toString().hashCode();
+    		}
     		return myHashCode.intValue();
     		return myHashCode;
+    	}
         @Override
     	public String[] getKeyNames() {
     		return pkNames;
+    	}
         @Override
     	public Object getKeyValue(String name) {
     		for (int i = 0; i < pkNames.length; i++) {
     			if (pkNames[i].equalsIgnoreCase(name)) {
-...
     		return null;
+    	}
         @Override
     	public String getFeatureTypeId() {
     		return featureTypeId;
+    	}
     	// *** Persistence ***
         @Override
     	public void loadFromState(PersistentState state)
     			throws PersistenceException {
     		this.oid = state.get("oid");
-...
+    		}
+    	}
         @Override
     	public void saveToState(PersistentState state) throws PersistenceException {
     		state.set("oid", oid);
     		state.set("myHashCode", myHashCode);

     import java.util.Map;
     import java.util.logging.Level;
     import java.util.logging.Logger;
     import org.apache.commons.lang3.ArrayUtils;
     import org.gvsig.fmap.dal.DALLocator;
     import org.gvsig.fmap.dal.DataTypes;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.exception.InitializeException;
     import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
     import org.gvsig.fmap.dal.feature.FeatureQuery;
     import org.gvsig.fmap.dal.feature.FeatureQueryOrder;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.fmap.dal.feature.FeatureType;
     import org.gvsig.tools.ToolsLocator;
     import org.gvsig.tools.dynobject.DynStruct;
-...
         /**
          * Creates a FeatureQuery which will load all available Features of a type.
+         *
          * @param featureType
          *            the type of Features of the query
          */
         public DefaultFeatureQuery() {
             super();
-...
          *            the type of Features of the query
          * @param filter
          *            based on the properties of the Features
          * @param order
          *            for the result
          */
         public DefaultFeatureQuery(FeatureType featureType, Evaluator filter) {
             super();
-...
          *            the type of Features of the query
          * @param filter
          *            based on the properties of the Features
          * @param order
          *            for the result
          * @param scale
          *            to view the Features.
          */
-...
          *            the list of attribute names to load
          * @param filter
          *            based on the properties of the Features
          * @param order
          *            for the result
          */
         public DefaultFeatureQuery(String[] attributeNames, Evaluator filter) {
             super();
-...
          *            the list of attribute names to load
          * @param filter
          *            based on the properties of the Features
          * @param order
          *            for the result
          * @param scale
          *            to view the Features.
          */
-...
             this.setScale(scale);
+        }
         @Override
         public double getScale() {
             Double scale = (Double) this.getQueryParameter(SCALE_PARAM_NAME);
             if (scale == null) {
                 return 0;
+            }
             return scale.doubleValue();
             return scale;
+        }
         @Override
         public void setScale(double scale) {
             this.setQueryParameter(SCALE_PARAM_NAME, new Double(scale));
             this.setQueryParameter(SCALE_PARAM_NAME, scale);
+        }
         @Override
         public Object getQueryParameter(String name) {
             return queryParameters.get(name);
+        }
         @Override
         public void setQueryParameter(String name, Object value) {
             queryParameters.put(name, value);
+        }
         @Override
         public void setFeatureType(FeatureType featureType) {
             this.featureTypeId = featureType.getId();
+        }
         @Override
         public String[] getAttributeNames() {
             return (String[])attributeNames.toArray(new String[attributeNames.size()]);
+        }
         @Override
         public void setAttributeNames(String[] attributeNames) {
             this.attributeNames.clear();
             if (attributeNames != null){
-...
+            }
+        }
         @Override
         public void addAttributeName(String attributeName){
             //If the attribute exists finish the method
             for (int i=0 ; i<attributeNames.size() ; i++){
-...
             this.attributeNames.add(attributeName);
+        }
         @Override
         public void addEssentialAttributeNames(FeatureStore store) {
             FeatureType storeType;
             try {
                 storeType = store.getDefaultFeatureType();
             } catch (DataException ex) {
                 throw new RuntimeException("Can't access to the default feature type of tghe store", ex);
+            }
             FeatureAttributeDescriptor[] pks = storeType.getPrimaryKey();
             if( storeType.hasOID() || ArrayUtils.isEmpty(pks) ) {
                 FeatureAttributeDescriptor attrInt = null;
                 FeatureAttributeDescriptor attrStr = null;
                 FeatureAttributeDescriptor attrNotGeom = null;
                 for (FeatureAttributeDescriptor attr : storeType) {
                     if( attrInt == null && (attr.getType()==DataTypes.INT || attr.getType()==DataTypes.LONG) ) {
                         attrInt = attr;
                     } else if( attrStr == null && attr.getType()==DataTypes.STRING ) {
                         attrStr = attr;
                     } else if( attrNotGeom == null && attr.getType()!=DataTypes.GEOMETRY ) {
                         attrNotGeom = attr;
+                    }
+                }
                 if( attrInt != null ) {
                     this.addAttributeName(attrInt.getName());
                 } else if( attrStr != null ) {
                     this.addAttributeName(attrStr.getName());
                 } else if( attrNotGeom != null ) {
                     this.addAttributeName(attrNotGeom.getName());
                 } else {
                     this.addAttributeName(storeType.getAttributeDescriptor(0).getName());
+                }
             } else {
                 for(FeatureAttributeDescriptor attr : pks ) {
                     this.addAttributeName(attr.getName());
+                }
+            }
+        }
         @Override
         public void addPrimaryKeyAttributeNames(FeatureStore store) {
             FeatureType storeType;
             try {
                 storeType = store.getDefaultFeatureType();
             } catch (DataException ex) {
                 throw new RuntimeException("Can't access to the default feature type of tghe store", ex);
+            }
             for(FeatureAttributeDescriptor attr : storeType.getPrimaryKey() ) {
                 this.addAttributeName(attr.getName());
+            }
+        }
         @Override
         public boolean hasAttributeNames() {
             return !this.attributeNames.isEmpty();
+        }
         @Override
         public void clearAttributeNames() {
             this.attributeNames = new ArrayList();
+        }
         @Override
         public Evaluator getFilter() {
             return filter;
+        }
-...
+            }
+        }
         @Override
         public void setFilter(Evaluator filter) {
             this.filter = filter;
             addFilterAttributes(filter);
-...
     //        isAddFilter = true;
+        }
         @Override
         public void clearFilter() {
           this.filter = null;
+        }
-...
+            }
+        }
         @Override
         public FeatureQueryOrder getOrder() {
             return order;
+        }
         @Override
         public void setOrder(FeatureQueryOrder order) {
             this.order = order;
+        }
         @Override
         public boolean hasFilter() {
             return this.filter != null;
+        }
         @Override
         public boolean hasOrder() {
             return this.order != null && this.order.size() > 0;
+        }
         @Override
         public Object clone() throws CloneNotSupportedException {
             DefaultFeatureQuery clone = (DefaultFeatureQuery) super.clone();
-...
             return clone;
+        }
         @Override
         public FeatureQuery getCopy() {
             try {
                 return (FeatureQuery) clone();
-...
             // return aCopy;
+        }
         @Override
         public String getFeatureTypeId() {
             return featureTypeId;
+        }
         @Override
         public void setFeatureTypeId(String featureTypeId) {
             this.featureTypeId = featureTypeId;
+        }
         @Override
         public void saveToState(PersistentState state) throws PersistenceException {
             // FIXME: falta por terminar de implementar
             state.set("queryParameters", this.queryParameters);
-...
+        }
         @Override
         public void loadFromState(PersistentState state) throws PersistenceException {
             // FIXME: falta por terminar de implementar
             this.queryParameters = (Map) state.get("queryParameters");
-...
+        }
         @Override
         public long getLimit() {
             return limit;
+        }
         @Override
         public long getPageSize() {
             return pageSize;
+        }
         @Override
         public void setLimit(long limit) {
             this.limit = limit;
+        }
         @Override
         public void setPageSize(long pageSize) {
             this.pageSize = pageSize;
+        }
         @Override
         public String[] getConstantsAttributeNames() {
             return (String[])constantsAttributeNames.toArray(new String[constantsAttributeNames.size()]);
+        }
         @Override
         public void setConstantsAttributeNames(String[] constantsAttributeNames) {
             this.constantsAttributeNames.clear();
             if (constantsAttributeNames != null){
-...
+            }
+        }
         @Override
         public void addConstantAttributeName(String attributeName) {
             //If the attribute exists finish the method
             for (int i=0 ; i<constantsAttributeNames.size() ; i++){
-...
             this.constantsAttributeNames.add(attributeName);
+        }
         @Override
         public boolean hasConstantsAttributeNames() {
             return !this.constantsAttributeNames.isEmpty();
+        }
         @Override
         public void clearConstantsAttributeNames() {
             this.constantsAttributeNames = new ArrayList();
+        }

     import java.util.Iterator;
     import java.util.List;
     import org.gvsig.fmap.dal.DataStore;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.exception.ReadRuntimeException;
     import org.gvsig.fmap.dal.feature.EditableFeature;
-...
     import org.gvsig.fmap.dal.feature.FeatureSet;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.fmap.dal.feature.FeatureType;
     import org.gvsig.fmap.dal.feature.impl.dynobjectutils.DynObjectSetFeatureSetFacade;
     import org.gvsig.fmap.dal.feature.impl.featureset.AbstractFeatureSet;
     import org.gvsig.fmap.dal.feature.spi.FeatureProvider;
     import org.gvsig.fmap.dal.feature.spi.FeatureReferenceProviderServices;
-...
     import org.gvsig.fmap.dal.feature.spi.LongList;
     import org.gvsig.fmap.dal.feature.spi.index.FeatureIndexProviderServices;
     import org.gvsig.tools.dispose.DisposableIterator;
     import org.gvsig.tools.dynobject.DynObjectSet;
     import org.gvsig.tools.exception.BaseException;
     import org.gvsig.tools.visitor.Visitor;
     public class IndexFeatureSet
         extends AbstractFeatureSet
-...
     		return false;
+    	}
     	public DisposableIterator fastIterator(long index) throws DataException {
     		if (store.getFeatureStore().isEditing()) {
     			return this.iterator(index);
+    		}
     		return new FastIndexIterator(this.featureReferences.iterator(index));
+    	}
         public DisposableIterator fastIterator(long index) throws DataException {
             return fastIterator(index, 0);
+        }
         public DisposableIterator fastIterator(long index, long elements) throws DataException {
             if (store.getFeatureStore().isEditing()) {
                 return this.iterator(index, elements);
+            }
             return new FastIndexIterator(this.featureReferences.iterator(index));
+        }
     	public long getSize() throws DataException {
     		return featureReferences.getSize();
+    	}
-...
     		return new IndexIterator(this.featureReferences.iterator(index));
+    	}
     	public DisposableIterator iterator(long index, long elements) throws DataException {
     		return new IndexIterator(this.featureReferences.iterator(index));
+    	}
     	public void delete(Feature feature) throws DataException {
     		index.delete(feature);
     		store.getFeatureStore().delete(feature);

     import java.util.Iterator;
     import java.util.List;
     import java.util.Set;
     import org.apache.commons.lang3.ArrayUtils;
     import org.cresques.cts.IProjection;
-...
+    	}
     	public FeatureType getSubtype(String[] names, String[] constantsNames) throws DataException {
                     if( (names==null || names.length <1) && (constantsNames==null || constantsNames.length <1) ) {
                         return (FeatureType) this.clone();
+                    }
             if( ArrayUtils.isEmpty(names) && ArrayUtils.isEmpty(constantsNames) ) {
                 return (FeatureType) this.clone();
+            }
     		return new SubtypeFeatureType(this, names,constantsNames);
+    	}
-...
                         super(parent, false);
                         DefaultFeatureAttributeDescriptor attrcopy;
                         DefaultFeatureAttributeDescriptor attr;
                         Set attrnames = null;
                         List attrnames = null;
                         // Copy attributes
                         if ( names != null && names.length > 0 ) {
                             attrnames = new HashSet();
                             attrnames = new ArrayList();
                             attrnames.addAll(Arrays.asList(names));
                             if ( parent.hasEmulators ) {
                                 for ( int i = 0; i < parent.size(); i++ ) {
-...
+                        }
                         // Set the consttants attributes.
                         if ( constantsNames != null && constantsNames.length > 0 ) {
                         if ( !ArrayUtils.isEmpty(constantsNames) ) {
                             for ( int i = 0; i < constantsNames.length; i++ ) {
                                 if ( attrnames != null && attrnames.contains(constantsNames[i]) ) {
                                     continue;
-...
     	public FeatureAttributeDescriptor[] getPrimaryKey() {
     		if (pk == null) {
     			List pkList = new ArrayList();
     			List pks = new ArrayList();
     			Iterator iter = super.iterator();
     			FeatureAttributeDescriptor attr;
     			while (iter.hasNext()){
     				attr = (FeatureAttributeDescriptor) iter.next();
     				if (attr.isPrimaryKey()){
     					pkList.add(attr);
     					pks.add(attr);
+    				}
+    			}
     			pk = (FeatureAttributeDescriptor[]) pkList
     					.toArray(new FeatureAttributeDescriptor[pkList.size()]);
                 if( pks.isEmpty() ) {
                     pk = new FeatureAttributeDescriptor[0];
                 } else {
                     pk = (FeatureAttributeDescriptor[])pks.toArray(new FeatureAttributeDescriptor[pks.size()]);
+                }
+    		}
     		return pk;
+    	}

Application: gvSIG desktop

Revision 43358