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

 * 2008 {DiSiD Technologies}  {Create a JTable TableModel for a FeatureCollection}

 */

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.impl.featureset.DynObjectFeatureFacade;

import org.gvsig.fmap.dal.feature.paging.FeaturePagingHelper;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.impl.DefaultDynObjectPagingHelper;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

/**

 * Helper class to access the values of a FeatureCollection by position. Handles

 * pagination automatically to avoid filling the memory in case of big

 * collections.

 *

 * TODO: evaluate if its more convenient to read values in the background when

 * the returned value is near the end of the page, instead of loading a page on

 * demand.

 *

 * @author gvSIG Team

 */

public class FeaturePagingHelperImpl extends DefaultDynObjectPagingHelper

    implements FeaturePagingHelper {

    private static final Logger LOG = LoggerFactory

        .getLogger(FeaturePagingHelperImpl.class);

    private FeatureQuery query;

    private FeatureSet featureSet;

    private FeatureStore featureStore;

    /** If the selected Features must be returned as the first ones. **/

    private boolean selectionUp = false;

    private FeatureSelection initialSelection = null;

    private Feature[] features = null;

    /**

     * Constructs a FeaturePagingHelperImpl from data of a FeatureStore.

     *

     * @param featureStore

     *            to extract data from

     * @throws DataException

     *             if there is an error initializing the helper

     */

    public FeaturePagingHelperImpl(FeatureStore featureStore)

        throws BaseException {

        this(featureStore, DEFAULT_PAGE_SIZE);

    }

    /**

     * Constructs a FeaturePagingHelperImpl from data of a FeatureStore.

     *

     * @param featureStore

     *            to extract data from

     * @param pageSize

     *            the number of elements per page data

     * @throws DataException

     *             if there is an error initializing the helper

     */

    public FeaturePagingHelperImpl(FeatureStore featureStore, int pageSize)

        throws BaseException {

        this(featureStore, null, pageSize);

    }

    /**

     * Constructs a FeaturePagingHelperImpl from data of a FeatureStore.

     *

     * @param featureStore

     *            to extract data from

     * @throws DataException

     *             if there is an error initializing the helper

     */

    public FeaturePagingHelperImpl(FeatureStore featureStore,

        FeatureQuery featureQuery) throws BaseException {

        this(featureStore, featureQuery, DEFAULT_PAGE_SIZE);

    }

    /**

     * Constructs a FeaturePagingHelperImpl from data of a FeatureStore.

     *

     * @param featureSet

     *            to extract data from

     * @param pageSize

     *            the number of elements per page data

     * @throws DataException

     *             if there is an error initializing the helper

     */

    public FeaturePagingHelperImpl(FeatureStore featureStore,

        FeatureQuery featureQuery, int pageSize) throws BaseException {

        super();

        FeatureQuery query = featureQuery;

        if (featureQuery == null) {

            query = featureStore.createFeatureQuery();

            query.setFeatureType(featureStore.getDefaultFeatureType());

        }

        this.featureStore = featureStore;

        this.query = query;

        this.query.setPageSize(pageSize);

        loadFeatureSet();

        if (LOG.isDebugEnabled()) {

            LOG.debug("FeaturePagingHelperImpl created with {} pages, "

                + "and a page size of {}", new Long(getCalculator()

                .getNumPages()), new Integer(pageSize));

        }

    }

    /**

     * @return the selectionUp status

     */

    protected boolean isSelectionUp() {

        return selectionUp;

    }

    public void setSelectionUp(boolean selectionUp) {

        this.selectionUp = selectionUp;

        try {

            if (selectionUp) {

                initialSelection =

                    (FeatureSelection) getFeatureStore().getFeatureSelection()

                        .clone();

                setCalculator(new OneSubsetOneSetPagingCalculator(

                    new FeatureSetSizeableDelegate(initialSelection),

                    new FeatureSetSizeableDelegate(getFeatureSet()),

                    getMaxPageSize()));

            } else {

                if (initialSelection != null) {

                    initialSelection.dispose();

                    initialSelection = null;

                }

                setDefaultCalculator(new FeatureSetSizeableDelegate(

                    getFeatureSet()), getMaxPageSize());

            }

        } catch (BaseException e) {

            LOG.error("Error setting the selection up setting to: "

                + selectionUp, e);

        } catch (CloneNotSupportedException e) {

            LOG.error("Error cloning the selection "

                + "while setting the selection up", e);

        }

    }

    public Feature getFeatureAt(long index) throws BaseException {

        // Check if we have currently loaded the viewed page data,

        // or we need to load a new one

        long pageForIndex = (long) Math.floor(index / getMaxPageSize());

        if (pageForIndex != getCurrentPage()) {

            setCurrentPage(pageForIndex);

        }

        long positionForIndex = index - (getCurrentPage() * getMaxPageSize());

        return features[(int) positionForIndex];

    }

    public Feature[] getCurrentPageFeatures() {

        return features;

    }

    public FeatureSet getFeatureSet() {

        return featureSet;

    }

    public void reloadCurrentPage() throws BaseException {

        setSelectionUp(false);

        if (getCalculator().getCurrentPage() > -1) {

            loadCurrentPageData();

        }

    }

    public void reload() throws BaseException {

        loadFeatureSet();

        reloadCurrentPage();

    }

    public FeatureStore getFeatureStore() {

        return featureStore;

    }

    public FeatureQuery getFeatureQuery() {

        return query;

    }

    /**

     * Loads all the Features of the current page.

     */

    protected void loadCurrentPageData() throws BaseException {

        final int currentPageSize = getCalculator().getCurrentPageSize();

        final Feature[] values = new Feature[currentPageSize];

        long t1 = 0;

        if (LOG.isTraceEnabled()) {

            t1 = System.currentTimeMillis();

        }

        if (selectionUp) {

            loadCurrentPageDataWithSelectionUp(values);

        } else {

            loadCurrentPageDataNoSelection(values);

        }

        if (LOG.isTraceEnabled()) {

            long t2 = System.currentTimeMillis();

            LOG.trace("Time to load {} features: {} ms", new Integer(

                currentPageSize), new Long(t2 - t1));

        }

        this.features = values;

    }

    private void loadCurrentPageDataWithSelectionUp(final Feature[] values)

        throws BaseException {

        FeatureSelection selection = initialSelection;

        OneSubsetOneSetPagingCalculator twoSetsCalculator = null;

        if (getCalculator() instanceof OneSubsetOneSetPagingCalculator) {

            twoSetsCalculator =

                (OneSubsetOneSetPagingCalculator) getCalculator();

        } else {

            twoSetsCalculator =

                new OneSubsetOneSetPagingCalculator(

                    new FeatureSetSizeableDelegate(selection),

                    new FeatureSetSizeableDelegate(getFeatureSet()),

                    getMaxPageSize(), getCalculator().getCurrentPage());

            setCalculator(twoSetsCalculator);

        }

        // First load values from the selection, if the current page has

        // elements from it

        if (twoSetsCalculator.hasCurrentPageAnyValuesInFirstSet()) {

            loadDataFromFeatureSet(values, 0, selection,

                twoSetsCalculator.getFirstSetInitialIndex(),

                twoSetsCalculator.getFirstSetHowMany(), null);

        }

        // Next, load values from the FeatureSet if the current page has values

        // from it

        if (twoSetsCalculator.hasCurrentPageAnyValuesInSecondSet()) {

            loadDataFromFeatureSet(

                values,

                // The cast will work as that size will be <= maxpagesize,

                // which is an int

                (int) twoSetsCalculator.getFirstSetHowMany(), getFeatureSet(),

                twoSetsCalculator.getSecondSetInitialIndex(),

                twoSetsCalculator.getSecondSetHowMany(), selection);

        }

    }

    private void loadCurrentPageDataNoSelection(final Feature[] values)

        throws DataException {

        long firstPosition = getCalculator().getInitialIndex();

        if (LOG.isDebugEnabled()) {

            LOG.debug("Loading {} Features starting at position {}",

                new Integer(getCalculator().getCurrentPageSize()), new Long(

                    firstPosition));

        }

        loadDataFromFeatureSet(values, 0, getFeatureSet(), firstPosition,

            getCalculator().getCurrentPageSize(), null);

    }

    private void loadDataFromFeatureSet(final Feature[] values,

        final int valuesPosition, FeatureSet set, long initialIndex,

        final long howMany, final FeatureSelection selectedFeaturesToSkip)

        throws DataException {

        try {

            set.accept(new Visitor() {

                private int i = valuesPosition;

                public void visit(Object obj) throws VisitCanceledException,

                    BaseException {

                    if (i >= valuesPosition + howMany) {

                        throw new VisitCanceledException();

                    }

                    Feature current = (Feature) obj;

                    // Add the current Feature only if we don't skip selected

                    // features or the feature is not selected

                    if (selectedFeaturesToSkip == null

                        || !selectedFeaturesToSkip.isSelected(current)) {

                        values[i] = current.getCopy();

                        i++;

                    }

                }

            }, initialIndex);

        } catch (BaseException e) {

            if (e instanceof DataException) {

                throw ((DataException) e);

            } else {

                LOG.error("Error loading the data starting at position {}",

                    new Long(initialIndex), e);

            }

        }

    }

    private void loadFeatureSet() throws BaseException {

        if (featureSet != null) {

            featureSet.dispose();

        }

        featureSet = getFeatureStore().getFeatureSet(getFeatureQuery());

        setDynObjectSet(featureSet.getDynObjectSet(), getMaxPageSize());

    }

    public void delete(Feature feature) throws BaseException {

        if (featureSet == null) {

            // FIXME change to RuntimeDalException

            throw new IllegalStateException();

        }

        featureSet.delete(feature);

        reloadCurrentPage();

    }

    public void insert(EditableFeature feature) throws BaseException {

        if (featureSet == null) {

            // FIXME change to RuntimeDalException

            throw new IllegalStateException();

        }

        featureSet.insert(feature);

        reloadCurrentPage();

    }

    public void update(EditableFeature feature) throws BaseException {

        if (featureSet == null) {

            // FIXME change to RuntimeDalException

            throw new IllegalStateException();

        }

        featureSet.update(feature);

        reloadCurrentPage();

    }

    public FeatureType getFeatureType() {

        return featureSet.getDefaultFeatureType();

    }

    protected void doDispose() throws BaseException {

        initialSelection.dispose();

        featureSet.dispose();

    }

    public DynObject[] getCurrentPageDynObjects() {

        Feature[] features = getCurrentPageFeatures();

        DynObject[] dynobjects = new DynObject[features.length];

        for (int i = 0; i < dynobjects.length; i++) {

            dynobjects[i] = new DynObjectFeatureFacade(features[i]);

        }

        return dynobjects;

    }

    public DynObject getDynObjectAt(long index) throws BaseException {

        return new DynObjectFeatureFacade(getFeatureAt(index));

    }

}