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.store.simplereader;

import java.util.Iterator;

import java.util.List;

import java.util.NoSuchElementException;

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.SpatialIndex;

import org.gvsig.tools.exception.BaseException;

/**

 * @author jjdelcerro

 *

 */

public class SimpleReaderSetProvider extends AbstractFeatureSetProvider {

    private static class SimpleReaderFeatureProvider extends AbstractFeatureProviderLoadedOnDemand {

        protected SimpleReaderStoreProvider store;

        public SimpleReaderFeatureProvider(SimpleReaderStoreProvider store, FeatureType type) {

            super(type);

            this.store = store;

        }

        @Override

        protected void doLoad() {

            long index=-1;

            try {

                index = this.getOID();

                SimpleReaderStoreProvider.RowToFeatureTranslator translator = this.store.getRowToFeatureTranslator();

                List<String> row = this.store.getRowByIndex(index);

                translator.translate(index, row, this);

            } catch (Throwable ex) {

                throw new ReadRuntimeException(getStoreFullName(), index, ex);

            }

        }

        @Override

        public Long getOID() {

            return (Long) super.getOID();

        }

        public void setOID(long oid) {

            super.setOID(oid); 

        }

        private String getStoreFullName() {

            try {

                return this.store.getFullName();

            } catch (Exception ex) {

                return "unknown";

            }

        }

        @Override

        protected void warn(String message, Throwable t) {

            this.store.getTimedLogger().warn(message, t);

        }

    }

    private class SimpleReaderIterator extends AbstractFeatureProviderIterator {

        protected long index;

        protected FeatureType type;

        protected long count;

        protected final FeatureQuery query;

        protected Iterator spatialIndexIt;

        public SimpleReaderIterator(SimpleReaderStoreProvider store, FeatureQuery query, FeatureType type,

                long startOn) throws DataException {

            super(store);

            this.index = startOn;

            this.type = type;

            this.query = query;

            this.count = store.getFeatureCount();

            if( this.query!=null ) {

                this.spatialIndexIt = createSpatialIterator(

                        store.getFeatureStore().getDefaultFeatureTypeQuietly(), 

                        query

                );

            }

        }

        @Override

        protected SimpleReaderStoreProvider getFeatureStoreProvider() {

            return (SimpleReaderStoreProvider) super.getFeatureStoreProvider(); 

        }

        @Override

        protected boolean internalHasNext() {

            if( this.spatialIndexIt != null ) {

                return this.spatialIndexIt.hasNext();

            }

            return this.count > index;

        }

        @Override

        protected FeatureProvider internalNext() {

            SimpleReaderFeatureProvider data = new SimpleReaderFeatureProvider(getStore(), type);

            if( this.spatialIndexIt != null ) {

                Object oid = this.spatialIndexIt.next();                

                data.setOID(oid);

            } else {

                if (index >= this.count) {

                    throw new NoSuchElementException();

                }

                data.setOID(index++);

            }   

            return data;

        }

        @Override

        public void remove() {

            throw new UnsupportedOperationException();

        }

        protected void internalDispose() {

            type = null;

        }

        @Override

        protected void doDispose() throws BaseException {

            // Nothing to do

        }

    }

    private class FastCSVIterator extends SimpleReaderIterator {

        protected FeatureProvider data;

        public FastCSVIterator(SimpleReaderStoreProvider store, FeatureQuery query, FeatureType type,

                long startOn) throws DataException {

            super(store, query, type, startOn);

            this.data = new SimpleReaderFeatureProvider(store, type);

        }

        @Override

        protected FeatureProvider internalNext() {

            if( this.spatialIndexIt != null ) {

                Object oid = this.spatialIndexIt.next();                

                data.setOID(oid);

            } else {

                if (index >= this.count) {

                    throw new NoSuchElementException();

                }

                data.setOID(index++);

            }   

            return data;            

        }

        @Override

        protected void internalDispose() {

            super.internalDispose();

            data = null;

        }

    }

    public SimpleReaderSetProvider(SimpleReaderStoreProvider store, FeatureQuery query,

            FeatureType providerFeatureType, FeatureType featureType)

            throws DataException {

        super(store, query, providerFeatureType, featureType);

    }

    @Override

    protected SimpleReaderStoreProvider getStore() {

        return (SimpleReaderStoreProvider) super.getStore();

    }

    @Override

    protected SpatialIndex getSpatialIndex(String name) {

        return getStore().getSpatialIndex(name);

    }

    protected String getStoreFullName() {

        try {

            return this.getStore().getFullName();

        } catch (Throwable th) {

            return "unknown";

        }

    }

    @Override

    public boolean canFilter() {

        return false;

    }

    @Override

    public boolean canIterateFromIndex() {

        return true;

    }

    @Override

    public boolean canOrder() {

        return false;

    }

    @Override

    public long getSize() throws DataException {

        return getStore().getFeatureCount();

    }

    @Override

    public boolean isEmpty() throws DataException {

        return getSize() == 0;

    }

    @Override

    protected void doDispose() throws BaseException {

    }

    @Override

    protected AbstractFeatureProviderIterator createIterator(long index)

            throws DataException {

        return new SimpleReaderIterator(

                getStore(),

                getQuery(),

                getProviderFeatureType(),

                index

        );

    }

    @Override

    protected AbstractFeatureProviderIterator createFastIterator(long index)

            throws DataException {

        return new FastCSVIterator(

                getStore(),

                getQuery(),

                getProviderFeatureType(),

                index

        );

    }

}