Application: gvSIG desktop » gvSIG geoprocess

package org.gvsig.geoprocess.core;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.NoSuchElementException;

import com.vividsolutions.jts.geom.Geometry;

import es.unex.sextante.core.Sextante;

import es.unex.sextante.dataObjects.FeatureImpl;

import es.unex.sextante.dataObjects.IFeature;

import es.unex.sextante.dataObjects.IFeatureIterator;

import es.unex.sextante.dataObjects.vectorFilters.IVectorLayerFilter;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureSet;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.geom.operation.tojts.ToJTS;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.tools.dispose.DisposableIterator;

public class gvFeatureIterator implements IFeatureIterator {

    private final List<IVectorLayerFilter> m_Filters;

    private boolean m_bIsNextConsumed;

    private IFeature m_CurrentValue;

    private boolean m_bFinished;

    private DisposableIterator m_FeatureIterator;

    public gvFeatureIterator(final FLyrVect layer,

        final List<IVectorLayerFilter> filters) {

        m_bIsNextConsumed = true;

        m_Filters = filters;

        FeatureSet set = null;

        try {

            set = layer.getFeatureStore().getFeatureSet();

            m_FeatureIterator = set.fastIterator();

        } catch (final DataException e) {

            if (m_FeatureIterator != null) {

                m_FeatureIterator.dispose();

            }

            if (set != null) {

                set.dispose();

            }

        }

    }

    public gvFeatureIterator() {

        m_Filters = null;

    }

    private boolean accept(final IFeature value) {

        for (final IVectorLayerFilter filter : m_Filters) {

            if (!filter.accept(value, 0)) {

                return false;

            }

        }

        return true;

    }

    public boolean moveToNextValid() {

        if (m_FeatureIterator == null) {

            return false;

        }

        boolean bFound = false;

        ;

        while (!bFound && m_FeatureIterator.hasNext()) {

            try {

                final Feature f = (Feature) m_FeatureIterator.next();

                final org.gvsig.fmap.geom.Geometry geometry =

                    f.getDefaultGeometry();

                final Geometry geom =

                    (Geometry) geometry.invokeOperation(ToJTS.CODE, null);

                final FeatureType type = f.getType();

                @SuppressWarnings("unchecked")

                final Iterator<FeatureAttributeDescriptor> iter =

                    type.iterator();

                final ArrayList<Object> objects = new ArrayList<Object>();

                while (iter.hasNext()) {

                    final FeatureAttributeDescriptor descriptor = iter.next();

                    final String name = descriptor.getName();

                    // Comment this as if the geometry field is in the middle of

                    // the fields it will be problematic elsewhere

                    if (!type.getDefaultGeometryAttributeName().equals(name)) {

                        objects.add(f.get(name));

                    }

                }

                final FeatureImpl feature =

                    new FeatureImpl(geom, objects.toArray(new Object[0]));

                if (accept(feature)) {

                    bFound = true;

                    m_CurrentValue = feature;

                    m_bIsNextConsumed = false;

                }

            } catch (final Exception e) {

                Sextante.addErrorToLog(e);

                return false;

            }

        }

        if (!bFound) {

            m_bFinished = true;

        }

        return bFound;

    }

    public IFeature next() {

        if (!m_bIsNextConsumed) {

            m_bIsNextConsumed = true;

            return m_CurrentValue;

        }

        if (!m_bFinished) {

            if (moveToNextValid()) {

                m_bIsNextConsumed = true;

                return m_CurrentValue;

            }

        }

        throw new NoSuchElementException();

    }

    public boolean hasNext() {

        if (m_bFinished) {

            return false;

        }

        if (!m_bIsNextConsumed) {

            return true;

        }

        return moveToNextValid();

    }

    public void close() {

    }

}