Application: gvSIG desktop

package org.gvsig.data.datastores.vectorial.db.jdbc.h2;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.Statement;

import java.util.ConcurrentModificationException;

import java.util.Iterator;

import java.util.NoSuchElementException;

import org.gvsig.data.ReadException;

import org.gvsig.data.datastores.vectorial.db.DBDataFeatureCollection;

import org.gvsig.data.datastores.vectorial.db.DBFeatureType;

import org.gvsig.data.datastores.vectorial.db.jdbc.SQLException;

import org.gvsig.data.vectorial.FeatureManager;

import org.gvsig.data.vectorial.IFeature;

import org.gvsig.data.vectorial.IFeatureType;

import org.gvsig.exceptions.BaseException;

public class H2FeatureCollectionEditing extends DBDataFeatureCollection {

        protected DBFeatureType featureType;

        protected String totalFilter;

        protected H2Store store;

        private int numReg=-1;

        private String sql;

        private String sqlCount;

        private String totalOrder;

        private FeatureManager featureManager;

        H2FeatureCollectionEditing(FeatureManager fm,H2Store store,IFeatureType type) {

                this.featureManager=fm;

                this.store=store;

                this.featureType=(DBFeatureType)type;

                this.totalFilter =store.getBaseWhereClause();

                this.totalOrder = store.getBaseOrder();

                this.sql = this.store.getSqlSelectPart();

                this.sqlCount = "Select count(*) From "+ ((H2StoreParameters)this.store.getParameters()).tableID();

                if (!isStringEmpty(this.totalFilter)){

                        this.sql= this.sql + " Where " + this.totalFilter;

                        this.sqlCount= this.sqlCount + " Where " + this.totalFilter;

                }

                if (!isStringEmpty(this.totalOrder)){

                        this.sql= this.sql + " Order by " + this.totalOrder;

                }

//                if (this.filter!=null)

//                        parser = new FeatureFilterParser(filter,this.featureType);

        }

        private ResultSet getNewResulset(String aSql) throws ReadException{

                this.store.open();

                Connection conn = this.store.getConnection();

                try {

                        Statement st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY,ResultSet.CONCUR_READ_ONLY);

                        return st.executeQuery(aSql);

                } catch (java.sql.SQLException e) {

                        throw new SQLException(aSql,this.store.getName(),e);

                }

        }

        public int size() {

                checkModified();

                try {

                        if (this.numReg < 0){

                                ResultSet r=null;

                                r = this.getNewResulset(this.sqlCount);

                                try {

                                        r.next();

                                        numReg = r.getInt(1);

                                } catch (java.sql.SQLException e) {

                                        throw new ReadException(this.store.getName(),e);

                                } finally{

                                        try {

                                                r.close();

                                        } catch (java.sql.SQLException e) {

                                                throw new ReadException(this.store.getName(),e);

                                        }

                                }

                                numReg = numReg+featureManager.getNum();

                        }

                        return numReg;

                } catch (BaseException e){

                        throw new RuntimeException(e);

                }

        }

        public Iterator iterator() {

                checkModified();

                try{

                        ResultSet r=null;

                        r = this.getNewResulset(this.sql);

                        H2Iterator dbfIter=new H2Iterator(this.store,r,this.featureType);

                        return dbfIter;

                } catch (BaseException e){

                        throw new RuntimeException(e);

                }

        }

        protected class H2Iterator implements Iterator{

                protected long position=0;

                private boolean nextChecked=false;

                private IFeature feature;

                private ResultSet rs;

                private H2Store store;

                private DBFeatureType featureType;

                private boolean rsEOF=false;

                public H2Iterator(H2Store store, ResultSet rs, DBFeatureType featureType){

                        this.store = store;

                        this.rs = rs;

                        this.featureType = featureType;

                        position=0;

                }

                protected void checkModified(){

                        if (modified)

                                throw new ConcurrentModificationException("FeatureCollection modified");

                }

                public boolean hasNext(){

                        checkModified();

                        IFeature feature=null;

                        if (nextChecked){

                                return feature != null;

                        }

                        nextChecked=true;

                        while (true){

                                if (!rsEOF){

                                        try {

                                                if (rs.isLast()){

                                                        rs.close();

//                                                        rs.getStatement().close();

                                                        rsEOF=true;

                                                        continue;

                                                } else {

                                                        feature=nextH2Feature();

                                                }

                                        } catch (java.sql.SQLException e) {

                                                throw new RuntimeException(

                                                                new ReadException(this.store.getName(),e)

                                                );

                                        }

                                }else {

                                        if (position<featureManager.getNum()){

                                                try {

                                                        feature=featureManager.getFeature((int)position,store);

                                                } catch (ReadException e) {

                                                        throw new RuntimeException(

                                                                        new ReadException(this.store.getName(),e)

                                                        );

                                                }

                                                position++;

                                        }else{

                                                this.feature = null;

                                                return false;

                                        }

                                }

                                if(featureManager.isDeleted(feature))

                                        continue;

                                this.feature=feature;

                                return true;

                        }

                }

                public Object next() {

                        checkModified();

                        if (!nextChecked){

                                hasNext();

                        }

                        if (feature == null)

                                throw new NoSuchElementException();

                        nextChecked=false;

                        return feature;

                }

                private IFeature nextH2Feature() {

                        IFeature feature=null;

                        try {

                                if(rs.next()){

                                        feature=this.store.createFeatureFromResulset(this.rs, featureType);

                                }

                        } catch (java.sql.SQLException e) {

                                throw new RuntimeException(

                                                new ReadException("H2FeatureCollection",e)

                                        );

                        } catch (ReadException e) {

                                throw new RuntimeException(e);

                        }

                        return feature;

                }

                public void remove() {

                        throw new UnsupportedOperationException();

                }

        }

        public void dispose() {

                this.store.deleteObserver(this);

                this.store = null;

                this.featureManager = null;

                this.featureType = null;

        }

}