/ - Diff - | gvSIG desktop 1 - gvSIG

     package org.gvsig.fmap.data.feature.db;
     import java.util.ArrayList;
     import java.util.Collection;
     import java.util.Comparator;
     import java.util.Iterator;
     import java.util.TreeSet;
     import java.util.*;
     import org.gvsig.fmap.data.DataManager;
     import org.gvsig.fmap.data.DataStore;
     import org.gvsig.fmap.data.ReadException;
     import org.gvsig.fmap.data.feature.AbstractFeatureIDIterator;
     import org.gvsig.fmap.data.feature.Feature;
     import org.gvsig.fmap.data.feature.FeatureCollection;
     import org.gvsig.fmap.data.feature.FeatureManager;
     import org.gvsig.fmap.data.feature.FeatureType;
     import org.gvsig.fmap.data.feature.*;
     import org.gvsig.fmap.data.feature.expressionevaluator.Filter;
     public abstract class DBDataFeatureCollectionWithFeatureID extends
-...
     				this.featureType);
     		return dbfIter;
+    	}
     	protected Iterator internalIterator(int index) {
             checkModified();
             FIDIterator dbfIter;
             if (featureIDs instanceof List) {
                 dbfIter = new FIDIterator(((List) featureIDs).listIterator(index),
                         featureType);
             } else {
                 // TODO: If featureIDs is not a Collection of type List (actually,
                 // only when ordering is applied), we are not able
                 // to get a listIterator with an index, so we have to move the
                 // iterator to the required position. This option will be probably
                 // a lot slower, so an option would be to order with a List
                 // instead of a TreeSet.
                 Iterator iter = featureIDs.iterator();
                 for (int i = 0; i < index; i++) {
                     iter.next();
+                }
                 dbfIter = new FIDIterator(iter, featureType);
+            }
             return dbfIter;
+    	}
     	public class FIDIterator extends AbstractFeatureIDIterator {
     		public FIDIterator(Iterator iter, FeatureType featureType) {

     	public AbstractPostgresqlDBIterator(PostgresqlStore store,
     			DBFeatureType featureType, String sql, int fetchSize,
     			FeatureManager featureManager, Filter featureFilter)
     			FeatureManager featureManager, Filter featureFilter,
                 int initialPosition)
     			throws ReadException {
     		super(store, featureType, sql, fetchSize, featureManager, featureFilter);
     		super(store, featureType, sql, fetchSize, featureManager,
                     featureFilter, initialPosition);
+    	}
     	protected String getFinalResulsetSQL() {

     import java.util.Iterator;
     import java.util.NoSuchElementException;
     import org.gvsig.tools.exception.BaseException;
     import org.gvsig.fmap.data.DataManager;
     import org.gvsig.fmap.data.DataStore;
     import org.gvsig.fmap.data.ReadException;
-...
     import org.gvsig.fmap.data.feature.db.DBDataFeatureCollection;
     import org.gvsig.fmap.data.feature.db.DBFeatureType;
     import org.gvsig.fmap.data.feature.expressionevaluator.Filter;
     import org.gvsig.tools.exception.BaseException;
     public class PostgresqlFeatureCollectionEditingFiltered extends DBDataFeatureCollection {
     	protected DBFeatureType featureType;
-...
+    	}
     	public Iterator iterator() {
     		checkModified();
     		try{
     			PostgresIterator dbIter = new PostgresIterator(this.store,
     					this.featureType, this.sql, this.fetchSize,
     					this.featureManager, this.parser);
     			return dbIter;
     		} catch (BaseException e){
     			throw new RuntimeException(e);
+    		}
+    	}
         protected Iterator internalIterator(int index) {
             checkModified();
             try {
                 PostgresIterator dbIter = new PostgresIterator(this.store,
                         this.featureType, this.sql, this.fetchSize,
                         this.featureManager, this.parser, index + 1);
                 return dbIter;
             } catch (BaseException e) {
                 throw new RuntimeException(e);
+            }
+        }
     	protected class PostgresIterator extends AbstractPostgresqlDBIterator {
     		public PostgresIterator(PostgresqlStore store,
     				DBFeatureType featureType, String sql, int fetchSize,
     				FeatureManager featureManager, Filter featureFilter)
     				FeatureManager featureManager, Filter featureFilter,
                     int initialPosition)
     				throws ReadException {
     			super(store, featureType, sql, fetchSize, featureManager,
     					featureFilter);
     					featureFilter, initialPosition);
+    		}
     		protected void checkModified() {

     import java.util.ConcurrentModificationException;
     import java.util.Iterator;
     import org.gvsig.tools.exception.BaseException;
     import org.gvsig.fmap.data.DataStore;
     import org.gvsig.fmap.data.ReadException;
     import org.gvsig.fmap.data.feature.Feature;
-...
     import org.gvsig.fmap.data.feature.db.DBStore;
     import org.gvsig.fmap.data.feature.db.jdbc.JDBCStore;
     import org.gvsig.fmap.data.feature.db.jdbc.SQLException;
     import org.gvsig.tools.exception.BaseException;
     public class PostgresqlFeatureCollection extends DBDataFeatureCollection {
     	protected DBFeatureType featureType;
-...
+    		}
+    	}
     	protected Iterator internalIterator(int index) {
             checkModified();
             PostgresqlIterator dbIter;
             try {
                 dbIter = new PostgresqlIterator((PostgresqlStore) this.store,
                         this.featureType, this.sql, this.fetchSize, index + 1);
             } catch (ReadException e) {
                 throw new RuntimeException(e);
+            }
     	public Iterator iterator() {
     		checkModified();
     		PostgresqlIterator dbIter;
     		try {
     			dbIter=new PostgresqlIterator((PostgresqlStore)this.store,this.featureType,this.sql,this.fetchSize);
     		} catch (ReadException e) {
     			throw new RuntimeException(e);
+    		}
             return dbIter;
+        }
     		return dbIter;
+    	}
     	protected class PostgresqlIterator extends AbstractPostgresqlDBIterator {
     		public PostgresqlIterator(PostgresqlStore store,DBFeatureType featureType ,String sql,int fetchSize) throws ReadException{
     			super(store, featureType, sql, fetchSize, null, null);
     		public PostgresqlIterator(PostgresqlStore store,
                     DBFeatureType featureType, String sql, int fetchSize,
                     int initialPosition) throws ReadException {
                 super(store, featureType, sql, fetchSize, null, null,
                         initialPosition);
+    		}
     		protected void createResulset() throws ReadException{

     import java.util.ConcurrentModificationException;
     import java.util.Iterator;
     import org.gvsig.tools.exception.BaseException;
     import org.gvsig.fmap.data.DataStore;
     import org.gvsig.fmap.data.ReadException;
     import org.gvsig.fmap.data.feature.FeatureManager;
-...
     import org.gvsig.fmap.data.feature.db.DBDataFeatureCollection;
     import org.gvsig.fmap.data.feature.db.DBFeatureType;
     import org.gvsig.fmap.data.feature.db.jdbc.SQLException;
     import org.gvsig.tools.exception.BaseException;
     public class PostgresqlFeatureCollectionEditing extends DBDataFeatureCollection {
     	protected DBFeatureType featureType;
-...
+    	}
     	public Iterator iterator() {
     		checkModified();
     		try{
     			ResultSet r=null;
     			r = this.getNewResulset(this.sql);
     			PostgresIterator dbIter = new PostgresIterator(this.store,
     					this.featureType, this.sql, this.fetchSize,
     					this.featureManager);
     			return dbIter;
     		} catch (BaseException e){
     			throw new RuntimeException(e);
+    		}
+    	}
         protected Iterator internalIterator(int index) {
             checkModified();
             try {
                 ResultSet r = null;
                 r = this.getNewResulset(this.sql);
                 PostgresIterator dbIter = new PostgresIterator(this.store,
                         this.featureType, this.sql, this.fetchSize,
                         this.featureManager, index + 1);
                 return dbIter;
             } catch (BaseException e) {
                 throw new RuntimeException(e);
+            }
+        }
     	protected class PostgresIterator extends AbstractPostgresqlDBIterator {
     		public PostgresIterator(PostgresqlStore store,
     				DBFeatureType featureType, String sql, int fetchSize,
     				FeatureManager featureManager) throws ReadException {
     			super(store, featureType, sql, fetchSize, featureManager, null);
     				FeatureManager featureManager, int initialPosition)
                     throws ReadException {
                 super(store, featureType, sql, fetchSize, featureManager, null,
                         initialPosition);
+    		}
     		protected void checkModified() {

     import java.util.Iterator;
     import java.util.NoSuchElementException;
     import org.gvsig.tools.exception.BaseException;
     import org.gvsig.fmap.data.DataManager;
     import org.gvsig.fmap.data.DataStore;
     import org.gvsig.fmap.data.ReadException;
-...
     import org.gvsig.fmap.data.feature.db.DBDataFeatureCollection;
     import org.gvsig.fmap.data.feature.db.DBFeatureType;
     import org.gvsig.fmap.data.feature.expressionevaluator.Filter;
     import org.gvsig.tools.exception.BaseException;
     public class H2FeatureCollectionEditingFiltered extends DBDataFeatureCollection {
     	protected DBFeatureType featureType;
-...
+    	}
     	public Iterator iterator() {
         protected Iterator internalIterator(int index) {
     		checkModified();
     		try{
     			H2Iterator dbIter = new H2Iterator(this.store, this.featureType,
     					this.sql, this.fetchSize, this.featureManager, this.parser);
     					this.sql, this.fetchSize, this.featureManager, this.parser,
                         index + 1);
     			return dbIter;
     		} catch (BaseException e){
     			throw new RuntimeException(e);
-...
     		public H2Iterator(H2Store store, DBFeatureType featureType,
     				String sql,
     				int fetchSize, FeatureManager featureManager,
     				Filter featureFilter)
     				Filter featureFilter, int initialPosition)
     				throws ReadException {
     			super(store, featureType, sql, fetchSize, featureManager,
     					featureFilter);
     					featureFilter, initialPosition);
+    		}
     		protected Feature createFeatureFromTheResulset() throws ReadException {

     import java.util.ConcurrentModificationException;
     import java.util.Iterator;
     import org.gvsig.tools.exception.BaseException;
     import org.gvsig.fmap.data.DataStore;
     import org.gvsig.fmap.data.ReadException;
     import org.gvsig.fmap.data.feature.Feature;
-...
     import org.gvsig.fmap.data.feature.db.DBFeatureType;
     import org.gvsig.fmap.data.feature.db.jdbc.AbstractJDBCIterator;
     import org.gvsig.fmap.data.feature.db.jdbc.SQLException;
     import org.gvsig.tools.exception.BaseException;
     public class H2FeatureCollection extends DBDataFeatureCollection {
     	protected DBFeatureType featureType;
-...
+    		}
+    	}
     	protected Iterator internalIterator(int index) {
             checkModified();
             AbstractJDBCIterator dbfIter = null;
             try {
                 dbfIter = new H2Iterator(this.store, this.featureType, this.sql,
                         this.fetchSize, index + 1);
             } catch (ReadException e) {
                 throw new RuntimeException(e);
+            }
             return dbfIter;
+        }
     	public Iterator iterator() {
     		checkModified();
     		AbstractJDBCIterator dbfIter = null;
     		try {
     			dbfIter = new H2Iterator(this.store, this.featureType, this.sql,
     					this.fetchSize);
     		} catch (ReadException e) {
     			throw new RuntimeException(e);
+    		}
     		return dbfIter;
+    	}
     	public class H2Iterator extends AbstractH2DBIterator {
     		public H2Iterator(H2Store store,
     				DBFeatureType featureType, String sql,
     				int fetchSize) throws ReadException {
     			super(store, featureType, sql, fetchSize, null, null);
+    		}
     		public H2Iterator(H2Store store, DBFeatureType featureType, String sql,
                     int fetchSize, int initialPosition) throws ReadException {
                 super(store, featureType, sql, fetchSize, null, null,
                         initialPosition);
+            }
     		protected void checkModified() {
     			if (modified) {
     				throw new ConcurrentModificationException(

     import java.util.ConcurrentModificationException;
     import java.util.Iterator;
     import org.gvsig.tools.exception.BaseException;
     import org.gvsig.fmap.data.DataStore;
     import org.gvsig.fmap.data.ReadException;
     import org.gvsig.fmap.data.feature.Feature;
-...
     import org.gvsig.fmap.data.feature.db.DBDataFeatureCollection;
     import org.gvsig.fmap.data.feature.db.DBFeatureType;
     import org.gvsig.fmap.data.feature.db.jdbc.SQLException;
     import org.gvsig.tools.exception.BaseException;
     public class H2FeatureCollectionEditing extends DBDataFeatureCollection {
     	protected DBFeatureType featureType;
-...
+    	}
     	public Iterator iterator() {
     		checkModified();
     		try{
     			H2Iterator dbfIter = new H2Iterator(this.store, this.featureType,
     					this.sql, this.fetchSize, this.featureManager);
     			return dbfIter;
     		} catch (BaseException e){
     			throw new RuntimeException(e);
+    		}
     	protected Iterator internalIterator(int index) {
             checkModified();
             try {
                 H2Iterator dbfIter = new H2Iterator(this.store, this.featureType,
                         this.sql, this.fetchSize, this.featureManager, index + 1);
                 return dbfIter;
             } catch (BaseException e) {
                 throw new RuntimeException(e);
+            }
+    	}
     	protected class H2Iterator extends AbstractH2DBIterator {
     	protected class H2Iterator extends AbstractH2DBIterator {
     		public H2Iterator(H2Store store, DBFeatureType featureType, String sql,
     				int fetchSize, FeatureManager featureManager)
     				throws ReadException {
     			super(store, featureType, sql, fetchSize, featureManager, null);
+    		}
                     int fetchSize, FeatureManager featureManager,
                     int initialPosition) throws ReadException {
                 super(store, featureType, sql, fetchSize, featureManager, null,
                         initialPosition);
+            }
     		protected Feature createFeatureFromTheResulset() throws ReadException {
     			return ((H2Store) this.store).createFeatureFromResulset(this.rs,

     	public AbstractH2DBIterator(H2Store store, DBFeatureType featureType,
     			String sql, int fetchSize, FeatureManager featureManager,
     			Filter featureFilter) throws ReadException {
     		super(store, featureType, sql, fetchSize, featureManager, featureFilter);
+    	}
                 String sql, int fetchSize, FeatureManager featureManager,
                 Filter featureFilter) throws ReadException {
             super(store, featureType, sql, fetchSize, featureManager, featureFilter);
+        }
         public AbstractH2DBIterator(H2Store store, DBFeatureType featureType,
                 String sql, int fetchSize, FeatureManager featureManager,
                 Filter featureFilter, int initialPosition) throws ReadException {
             super(store, featureType, sql, fetchSize, featureManager,
                     featureFilter, initialPosition);
+        }
     	protected String getFinalResulsetSQL() {
     		return H2Utils.addLimitsToSQL(this.sql, this.fetchSize,
     				this.page);

     public abstract class AbstractJDBCIterator implements Iterator {
     	public AbstractJDBCIterator(JDBCStore store, DBFeatureType featureType,
     			String sql, int fetchSize, FeatureManager featureManager,
     			Filter featureFilter) throws ReadException {
     		this.store = store;
     		this.featureType = featureType;
     		this.fetchSize = fetchSize;
     		this.sql = sql;
     		this.page = 0;
     		this.index = 0;
     		this.featureManager = featureManager;
     		this.featureFilter = featureFilter;
     		this.createResulset();
+    	}
     	protected boolean nextChecked = false;
     	protected Feature feature;
     	protected ResultSet rs;
-...
     	protected int index;
     	protected FeatureManager featureManager = null;
     	protected Filter featureFilter = null;
     	private int initialPosition = 1;
         public AbstractJDBCIterator(JDBCStore store, DBFeatureType featureType,
                 String sql, int fetchSize, FeatureManager featureManager,
                 Filter featureFilter, int initialPosition) throws ReadException {
             this.store = store;
             this.featureType = featureType;
             this.fetchSize = fetchSize;
             this.sql = sql;
             this.page = 0;
             this.index = 0;
             this.featureManager = featureManager;
             this.featureFilter = featureFilter;
             this.initialPosition = initialPosition;
             this.createResulset();
+        }
     	public AbstractJDBCIterator(JDBCStore store, DBFeatureType featureType,
                 String sql, int fetchSize, FeatureManager featureManager,
                 Filter featureFilter) throws ReadException {
     	    this(store, featureType, sql, fetchSize, featureManager, featureFilter,
 );
+        }
     	protected Feature nextDBFeature() {
     		Feature feature = null;
     		while (true) {
-...
     			Statement st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY,
     					ResultSet.CONCUR_READ_ONLY);
     			this.rs = st.executeQuery(mSql);
     			if (initialPosition > 1) {
                     rs.absolute(initialPosition);
+                }
     		} catch (java.sql.SQLException e) {
     			throw new SQLException(mSql, this.store.getName(), e);

     import java.util.ConcurrentModificationException;
     import java.util.Iterator;
     import org.gvsig.tools.exception.BaseException;
     import org.gvsig.fmap.data.DataStore;
     import org.gvsig.fmap.data.ReadException;
     import org.gvsig.fmap.data.feature.Feature;
-...
     import org.gvsig.fmap.data.feature.db.DBFeatureType;
     import org.gvsig.fmap.data.feature.db.jdbc.AbstractJDBCIterator;
     import org.gvsig.fmap.data.feature.db.jdbc.SQLException;
     import org.gvsig.tools.exception.BaseException;
     public class PostgresqlBinFeatureCollection extends DBDataFeatureCollection {
     	protected DBFeatureType featureType;
-...
+    	}
     	public Iterator iterator() {
     	protected Iterator internalIterator(int index) {
             PostgresqlIterator dbfIter;
             try {
                 dbfIter = new PostgresqlIterator(this.store, this.featureType,
                         this.sql, this.fetchSize, index + 1);
             } catch (ReadException e) {
                 throw new RuntimeException(e);
+            }
     		PostgresqlIterator dbfIter;
     		try {
     			dbfIter = new PostgresqlIterator(this.store, this.featureType,
     					this.sql, this.fetchSize);
     		} catch (ReadException e) {
     			throw new RuntimeException(e);
+    		}
             return dbfIter;
+        }
     		return dbfIter;
+    	}
     	protected class PostgresqlIterator extends AbstractJDBCIterator {
     		private String cursorName = null;
     		public PostgresqlIterator(PostgresqlBinStore store,
     				DBFeatureType featureType, String sql, int fetchSize)
     				DBFeatureType featureType, String sql, int fetchSize,
                     int initialPosition)
     				throws ReadException {
     			super(store, featureType, sql, fetchSize, null, null);
     			super(store, featureType, sql, fetchSize, null, null,
                         initialPosition);
+    		}
     		protected void createResulset() throws ReadException {

     	<dependencies>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>libFMap_data</artifactId>
     			<version>2.0-SNAPSHOT</version>
     		</dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>libFMap_data</artifactId>
     			<version>2.0-SNAPSHOT</version>
     			<classifier>tests</classifier>
     			<scope>test</scope>
     		</dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>libFMap_dataFile</artifactId>
     			<version>2.0-SNAPSHOT</version>
     		</dependency>

| gvSIG desktop 1

Revision 23680