Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * 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 3

 * 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.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.dal.feature.impl.featureset;

import java.util.Iterator;

import java.util.NoSuchElementException;

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

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

import org.gvsig.fmap.dal.feature.impl.DefaultFeature;

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.exception.BaseException;

@SuppressWarnings("UseSpecificCatch")

public class FilteredIterator extends DefaultIterator {

        protected boolean nextChecked;

        protected DefaultFeature current;

        protected Evaluator filter;

        protected FilteredIterator(DefaultFeatureSet featureSet) {

                super(featureSet);

                this.current = null;

                this.nextChecked = false;

                this.filter = featureSet.query.getFilter();

        }

        FilteredIterator(DefaultFeatureSet featureSet, long index, long elements)

                        throws DataException {

                this(featureSet);

                if(featureSet.provider.canFilter() && featureSet.provider.canIterateFromIndex()){

                    this.iterator = featureSet.provider.iterator(index, elements);

                } else {

                    this.iterator = featureSet.provider.iterator();

                    if (index > 0) {

                            this.skypto(index);

                    }

                }

        }

        @Override

        @SuppressWarnings("empty-statement")

        protected void skypto(long index) {

                // TODO: Comprobar si esta bien la condicion de n<=

                for (long n = 0; n < index && this.hasNext(); n++, this.next()) {

                        ;

                }

        }

        @Override

        protected void doNext() throws DataException {

                nextChecked = true;

                DefaultFeature feature;

                FeatureProvider data;

                Object obj;

                while (this.getIterator().hasNext()) {

                        obj =this.getIterator().next();

                        if(obj == null){

                            continue;

                        }

                        if (obj instanceof FeatureProvider){

                                data = (FeatureProvider)obj;

                                if (skipFeature(data)) {

                                        continue;

                                }

                                feature = this.createFeature(data);

                        } else {

                                feature = (DefaultFeature)obj;

                                if (skipFeature(feature.getData())) {

                                        continue;

                                }

                        }

                        if (this.match(feature)) {

                                this.current = feature;

                                return;

                        }

                }

                this.current = null;

        }

        @Override

        protected Iterator getIterator() {

                return this.iterator;

        }

        @Override

        public boolean hasNext() {

                if( fset == null ) {

                    return false;

                }

                fset.checkSourceStoreModified();

                if (nextChecked) {

                        return this.current != null;

                }

                try {

                        doNext();

                } catch( DataException e) {

                        NullPointerException ex = new NullPointerException();

                        ex.initCause(e);

                        throw ex;

                }

                return this.current != null;

        }

        protected boolean toBooleanMatch(Object x) {

            if( x == null ) {

                return false;

            } else if( x instanceof Boolean ) {

                return ((Boolean) x);

            } else {

                return true;

            }

        }

        public boolean match(DefaultFeature feature) throws DataException {

                try {

                        if (filter==null) {

                            return true;

                        }

                        Object x = this.filter.evaluate(feature);

                        return toBooleanMatch(x);

                } catch (Exception e) {

                        throw new DataEvaluatorException(e);

                }

        }

        @Override

        public Object next() {

                fset.checkSourceStoreModified();

                if (!nextChecked) {

                        hasNext();

                }

                if (this.current == null) {

                        throw new NoSuchElementException();

                }

                this.lastFeature = null;

                nextChecked = false;

                DefaultFeature feature = this.current;

                this.current = null;

                this.lastFeature = feature;

                return feature;

        }

        @Override

        protected void doDispose() throws BaseException {

                super.doDispose();

                current = null;

                filter = null;

        }

}