| gvSIG desktop 1

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

*

* This program is free software; you can redistribute it and/or

* modify it under the terms of the GNU General Public License

* as published by the Free Software Foundation; either version 2

* of the License, or (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

* MA  02110-1301, USA.

*

*/

/*

* AUTHORS (In addition to CIT):

* ${year} IVER T.I. S.A.   {{Task}}

*/

package org.gvsig.data.datastores.vectorial.db.sde;

import java.util.ConcurrentModificationException;

import java.util.Iterator;

import java.util.NoSuchElementException;

import java.util.Vector;

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

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

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

import org.gvsig.data.exception.ReadException;

import org.gvsig.data.vectorial.FeatureManager;

import org.gvsig.data.vectorial.IFeature;

import org.gvsig.data.vectorial.IFeatureAttributeDescriptor;

import org.gvsig.data.vectorial.IFeatureType;

import com.esri.sde.sdk.client.SeException;

import com.esri.sde.sdk.client.SeLayer;

import com.esri.sde.sdk.client.SeQuery;

import com.esri.sde.sdk.client.SeRow;

import com.esri.sde.sdk.client.SeSqlConstruct;

/**

 * DOCUMENT ME!

 *

 * @author Vicente Caballero Navarro

 */

public class SDEFeatureCollectionEditing extends DBDataFeatureCollection {

    protected DBFeatureType featureType;

    protected String totalFilter;

    protected SDEStore store;

    private int numReg = -1;

    private String sql;

    private String sqlCount;

    private String totalOrder;

    private FeatureManager featureManager;

    private SeLayer layer;

    private SeQuery query;

    private SeRow row;

    private boolean bFirst = true;

    SDEFeatureCollectionEditing(FeatureManager fm, SDEStore 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 " +

            ((SDEStoreParameters) 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;

        }

    }

    /* (non-Javadoc)

     * @see java.util.Collection#size()

     */

    public int size() {

        checkModified();

        if (this.numReg < 0) {

            this.numReg = 0;

            try {

                Iterator iter = this.iterator();

                while (true) {

                    iter.next();

                    numReg++;

                }

            } catch (NoSuchElementException e) {

                //Normal condition exit

            }

        }

        return numReg;

    }

    /* (non-Javadoc)

     * @see java.lang.Iterable#iterator()

     */

    public Iterator iterator() {

        checkModified();

        try {

            // Debe ser forward only

            int size = featureType.size();

            String[] names = new String[size];

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

                names[i] = ((DBAttributeDescriptor) featureType.get(i)).getName();

            }

            Vector theLayers = store.getConnection().getLayers();

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

                SeLayer layer = (SeLayer) theLayers.elementAt(i);

                if (layer.getQualifiedName().compareToIgnoreCase(((SDEStoreParameters) this.store.getParameters()).tableID()) == 0) {

                    this.layer = layer;

                    break;

                }

            }

            SeSqlConstruct sqlCons = new SeSqlConstruct(layer.getQualifiedName());

            query = new SeQuery(store.getConnection(), names, sqlCons);

            query.prepareQuery();

            query.execute();

            row = query.fetch();

            if (row == null) {

                bFirst = true;

            } else {

                bFirst = true;

            }

        } catch (SeException e) {

            throw new RuntimeException(e);

        } catch (ReadException e) {

                 throw new RuntimeException(e);

                }

        SDEIterator dbfIter = new SDEIterator(this.store, this.featureType);

        return dbfIter;

    }

    /* (non-Javadoc)

     * @see org.gvsig.data.IDataCollection#dispose()

     */

    public void dispose() {

        this.store.deleteObserver(this);

        this.store = null;

        this.featureManager = null;

        this.featureType = null;

    }

    protected class SDEIterator implements Iterator {

        protected long position = 0;

        private boolean nextChecked = false;

        private IFeature feature;

        private SDEStore store;

        private DBFeatureType featureType;

        public SDEIterator(SDEStore store, DBFeatureType featureType) {

            this.store = store;

            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) {

                try {

                    if (bFirst) {

                        bFirst = false;

                    } else {

                        try {

                            row = query.fetch();

                        } catch (Exception e) {

                            query.close();

                            if (position < featureManager.getNum()) {

                                try {

                                    feature = featureManager.getFeature((int) position,

                                            store);

                                } catch (ReadException e1) {

                                    throw new RuntimeException(new ReadException(

                                            this.store.getName(), e1));

                                }

                                position++;

                            } else {

                                this.feature = null;

                                return false;

                            }

                        }

                    }

                    if (row == null) {

                        query.close();

                        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;

                        }

                    } else {

                        feature = nextFeature();

                    }

                } catch (SeException e) {

                    throw new RuntimeException(e);

                }

                if (featureManager.isDeleted(feature)) {

                    continue;

                }

                this.feature = feature;

                return true;

            }

        }

        /*

         *  (non-Javadoc)

         * @see java.util.Iterator#next()

         */

        public Object next() {

            checkModified();

            if (!nextChecked) {

                hasNext();

            }

            nextChecked = false;

            if (this.feature == null) {

                throw new NoSuchElementException();

            }

            IFeature feature = this.feature;

            this.feature = null;

            return feature;

        }

        private IFeature nextFeature() {

            SDEFeature feat = null;

            try {

                feat = new SDEFeature(featureType, store, row);

                feat.loading();

                Iterator iterator = featureType.iterator();

                while (iterator.hasNext()) {

                    IFeatureAttributeDescriptor descriptor = (IFeatureAttributeDescriptor) iterator.next();

                    feat.loadValueFromResulset(row, descriptor);

                }

            } catch (ReadException e) {

                throw new RuntimeException(e);

            }

            feat.stopLoading();

            return feat;

        }

        /*

         *  (non-Javadoc)

         * @see java.util.Iterator#remove()

         */

        public void remove() {

            throw new UnsupportedOperationException();

        }

    }

}