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.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import java.util.NoSuchElementException;

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.FeatureQueryOrder.FeatureQueryOrderMember;

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

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

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

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

import org.gvsig.fmap.dal.feature.exception.ConcurrentDataModificationException;

import org.gvsig.fmap.dal.feature.exception.FeatureSetInitializeException;

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

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

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

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

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

public class DefaultFeatureSet extends AbstractFeatureSet implements

    FeatureSet, Observer {

    protected static final int NO_CHECKED = -1;

    protected static final int DEFAULT = 0;

    protected static final int FILTERED = 1;

    protected static final int ORDERED = 2;

    protected static final int ORDERED_FILTERED = 3;

    protected static final int EDITED = 4;

    protected static final int EDITED_FILTERED = 5;

    protected static final int ORDERD_EDITED = 6;

    protected static final int ORDERED_EDITED_FILTER = 7;

    protected boolean sourceStoreModified;

    protected boolean ownFeaturesModified;

    protected DefaultFeatureStore store;

    protected List featureTypes;

    protected FeatureQuery query;

    protected FeatureSetProvider provider;

    protected long size;

    protected int iteratorMode;

    protected List orderedData;

    protected Feature featureToIgnoreNotification;

    protected DefaultFeatureStoreTransforms transform;

    protected FeatureQuery queryForProvider;

    protected FeatureType defaultFeatureType;

    protected FeatureType defatulFeatureTypeForProvider;

    protected boolean ignoreChanges;

    public DefaultFeatureSet(DefaultFeatureStore store, FeatureQuery query)

        throws DataException {

        this.featureToIgnoreNotification = null;

        this.iteratorMode = NO_CHECKED;

        this.sourceStoreModified = false;

        this.ownFeaturesModified = false;

        this.size = -1;

        this.orderedData = null;

        this.store = store;

        if (this.store.isEditing()) {

            this.transform = this.store.getFeatureTypeManager().getTransforms();

        } else {

            this.transform =

                (DefaultFeatureStoreTransforms) store.getTransforms();

        }

        this.query = query;

        try {

            this.queryForProvider = (FeatureQuery) query.clone();

        } catch (CloneNotSupportedException e) {

            throw new FeatureSetInitializeException(e);

        }

        this.featureTypes = new ArrayList();

        if (this.query.getFeatureTypeId() == null

            && this.query.getAttributeNames() == null) {

            this.defaultFeatureType = this.store.getDefaultFeatureType();

            this.featureTypes.addAll(this.store.getFeatureTypes());

        } else {

            this.defaultFeatureType = this.store.getFeatureType(this.query);

            List<EditableFeatureAttributeDescriptor> cols = this.query.getExtraColumn().getColumns();

            if (this.query!=null && cols!=null && !cols.isEmpty()) {

                DefaultFeatureType featureTypeExtraCols = (DefaultFeatureType) this.defaultFeatureType.getCopy();

                featureTypeExtraCols.setExtraColumn(this.query.getExtraColumn());

                this.defaultFeatureType = featureTypeExtraCols;

            }

            this.featureTypes.add(this.defaultFeatureType);

        }

        if (this.transform != null && !this.transform.isEmpty()) {

            this.fixQueryForProvider(this.queryForProvider, this.transform);

        } else {

            this.defatulFeatureTypeForProvider = this.defaultFeatureType;

        }

        FeatureIndexes indexes = store.getIndexes();

        if (this.queryForProvider.hasFilter() && indexes != null

            && indexes.areValid()) {

            this.provider =

                (FeatureSetProvider) indexes

                    .getFeatureSet(this.queryForProvider.getFilter());

        }

        if (this.provider == null) {

            this.provider =

                this.store.getProvider().createSet(this.queryForProvider,

                    this.defatulFeatureTypeForProvider);

        }

        this.store.addObserver(this);

    }

    private void fixQueryForProvider(FeatureQuery theQueryForProvider,

        DefaultFeatureStoreTransforms transformsToUse) throws DataException {

        theQueryForProvider.clearAttributeNames();

        FeatureType ftype =

            transformsToUse.getSourceFeatureTypeFrom(this.defaultFeatureType);

        theQueryForProvider.setFeatureTypeId(ftype.getId());

        this.defatulFeatureTypeForProvider = ftype;

        if (transformsToUse.isTransformsOriginalValues()) {

            theQueryForProvider.clearFilter();

            FeatureQueryOrder fqo = theQueryForProvider.getOrder();

            if (fqo != null) {

                fqo.clear();

            }

            return;

        }

        // Filter

        Evaluator filter = theQueryForProvider.getFilter();

        if (filter != null) {

            boolean canUseFilter;

            if (filter.getFieldsInfo() == null) {

                canUseFilter = false;

            } else {

                canUseFilter = areEvaluatorFieldsInAttributes(filter, ftype);

            }

            if (!canUseFilter) {

                theQueryForProvider.clearFilter();

            }

        }

        // Order

        if (theQueryForProvider.hasOrder()) {

            boolean canUseOrder = true;

            Iterator iter = theQueryForProvider.getOrder().iterator();

            FeatureQueryOrderMember item;

            while (iter.hasNext()) {

                item = (FeatureQueryOrderMember) iter.next();

                if (item.hasEvaluator()) {

                    if (!areEvaluatorFieldsInAttributes(item.getEvaluator(),

                        ftype)) {

                        canUseOrder = false;

                        break;

                    }

                } else {

                    if (ftype.get(item.getAttributeName()) == null) {

                        canUseOrder = false;

                        break;

                    }

                }

            }

            if (!canUseOrder) {

                theQueryForProvider.getOrder().clear();

            }

        }

    }

    private boolean areEvaluatorFieldsInAttributes(Evaluator evaluator,

        FeatureType fType) {

        if (evaluator.getFieldsInfo() == null) {

            return false;

        }

        String[] fieldNames = evaluator.getFieldsInfo().getFieldNames();

        if (fieldNames.length == 0) {

            return false;

        } else {

            for (String fieldName : fieldNames) {

                if (fType.get(fieldName) == null) {

                    return false;

                }

            }

        }

        return true;

    }

    public FeatureType getDefaultFeatureType() {

        return this.defaultFeatureType;

    }

    public List getFeatureTypes() {

        return Collections.unmodifiableList(this.featureTypes);

    }

    public long getSize() throws DataException {

        this.checkSourceStoreModified();

        if (size < 0) {

            size = calculateSize();

        }

        return size;

    }

    private long calculateSize() throws DataException {

        long limit = this.query.getLimit();

        long mySize = 0;

        int mode = this.getIteratorMode();

        switch (mode) {

        case DEFAULT:

        case ORDERED:

            if (this.provider.isEmpty()) {

                return 0;

            }

            mySize = provider.getSize();

            return (limit>0 && mySize>limit)? limit:mySize;

        case FILTERED:

        case ORDERED_FILTERED:

            DisposableIterator iter = null;

            try {

                iter = this.fastIterator();

                while ((limit>0 && (mySize<limit)) || limit==0 ) {

                    iter.next();

                    mySize++;

                }

            } catch (NoSuchElementException e) {

            } finally {

                DisposeUtils.disposeQuietly(iter);

            }

            return mySize;

        case EDITED:

        case EDITED_FILTERED:

        case ORDERD_EDITED:

        case ORDERED_EDITED_FILTER:

            mySize = provider.getSize()

                + store.getFeatureManager().getDeltaSize();

            return (limit>0 && mySize>limit)? limit:mySize;

        default:

            throw new IllegalArgumentException();

        }

    }

    public void dispose() {

        if( this.store!=null ) {

            this.store.deleteObserver(this);

            this.store = null;

        }

        if( this.provider!=null ) {

            this.provider.dispose();

            this.provider = null;

        }

        if (orderedData != null) {

            orderedData.clear();

            this.orderedData = null;

        }

        this.featureToIgnoreNotification = null;

        this.transform = null;

        this.query = null;

        this.queryForProvider = null;

        this.featureTypes = null;

        this.defaultFeatureType = null;

        this.defatulFeatureTypeForProvider = null;

    }

    public void update(Observable obsevable, Object notification) {

        if (sourceStoreModified) {

            return;

        }

        String type = ((FeatureStoreNotification) notification).getType();

        if (type.equalsIgnoreCase(FeatureStoreNotification.AFTER_INSERT)

            || type.equalsIgnoreCase(FeatureStoreNotification.AFTER_DELETE)

            || type.equalsIgnoreCase(FeatureStoreNotification.AFTER_UPDATE)) {

            if (this.featureToIgnoreNotification == ((FeatureStoreNotification) notification)

                .getFeature()) {

                return;

            }

            sourceStoreModified = true;

            return;

        }

        if (type.equalsIgnoreCase(FeatureStoreNotification.AFTER_UPDATE_TYPE)

            || type.equalsIgnoreCase(FeatureStoreNotification.AFTER_REDO)

            || type.equalsIgnoreCase(FeatureStoreNotification.AFTER_UNDO)

            || type.equalsIgnoreCase(FeatureStoreNotification.AFTER_REFRESH)

            || type

                .equalsIgnoreCase(FeatureStoreNotification.COMPLEX_NOTIFICATION)

            || type.equalsIgnoreCase(FeatureStoreNotification.AFTER_CLOSE)

            || type.equalsIgnoreCase(FeatureStoreNotification.AFTER_DISPOSE)

            || type.equalsIgnoreCase(FeatureStoreNotification.TRANSFORM_CHANGE)) {

            sourceStoreModified = true;

            return;

        }

        if (type.equalsIgnoreCase(FeatureStoreNotification.RESOURCE_CHANGED)) {

            if(!this.ignoreChanges) {

                sourceStoreModified = true;

                return;

            }

        }

        if (type.equalsIgnoreCase(FeatureStoreNotification.AFTER_CANCELEDITING)) {

            if (ownFeaturesModified) {

                sourceStoreModified = true;

                return;

            }

        }

    }

    protected void checkSourceStoreModified() {

        if (sourceStoreModified) {

                        throw new ConcurrentDataModificationException(store == null ? ""

                                        : store.getName());

        }

    }

    @Override

    public DisposableIterator fastIterator(long index) throws DataException {

        return fastIterator(index, 0);

    }

    @Override

    public DisposableIterator fastIterator(long index, long elements) throws DataException {

        if (index < 0) {

            throw new IndexOutOfBoundsException("The index (" + index

                + ") is less than 0");

        }

        DisposableIterator it;

        int mode = this.getIteratorMode();

        switch (mode) {

        case DEFAULT:

            it = new FastDefaultIterator(this, index, elements);

            break;

        case FILTERED:

            it = new FastFilteredIterator(this, index);

            break;

        case ORDERED:

            if (this.orderedData != null) {

                it = new FastOrderedIterator(this, index);

            } else {

                it = new FastOrderedIterator(this, new FastDefaultIterator(this, 0, elements), index);

            }

            break;

        case ORDERED_FILTERED:

            if (this.orderedData != null) {

                it = new FastOrderedIterator(this, index);

            } else {

                it = new FastOrderedIterator(this, new FastFilteredIterator(

                    this, 0), index);

            }

            break;

        case EDITED:

            it = new FastEditedIterator(this, index);

            break;

        case EDITED_FILTERED:

            it = new FastEditedFilteredIterator(this, index);

            break;

        case ORDERD_EDITED:

            if (this.orderedData != null) {

                it = new FastOrderedIterator(this, index);

            } else {

                it = new FastOrderedIterator(this, new FastEditedIterator(

                    this, 0), index);

            }

            break;

        case ORDERED_EDITED_FILTER:

            if (this.orderedData != null) {

                it = new FastOrderedIterator(this, index);

            } else {

                it = new FastOrderedIterator(this,

                    new FastEditedFilteredIterator(this, 0), index);

            }

            break;

        default:

            throw new IllegalArgumentException();

        }

        if( this.query!=null && this.query.getLimit()>0 ) {

            it = new LimitIterator(it,this.query.getLimit());

        }

        return it;

    }

    private class LimitIterator implements DisposableIterator {

        private final DisposableIterator it;

        private final long limit;

        private int count;

        private LimitIterator(DisposableIterator it, long limit) {

            this.it = it;

            this.limit = limit;

            this.count = 0;

        }

        @Override

        public void dispose() {

            this.it.dispose();

        }

        @Override

        public boolean hasNext() {

            if( this.count>=this.limit ) {

                return false;

            }

            return this.it.hasNext();

        }

        @Override

        public Object next() {

            if( this.count>=this.limit ) {

                return null;

            }

            this.count++;

            return this.it.next();

        }

        @Override

        public void remove() {

            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

        }

    }

    @Override

    public DisposableIterator iterator(long index) throws DataException {

        return iterator(index,0);

    }

    @Override

    public DisposableIterator iterator(long index, long elements) throws DataException {        

        if (index < 0) {

            throw new IndexOutOfBoundsException("The index (" + index

                + ") is less than 0");

        }

        DisposableIterator it;

        int mode = this.getIteratorMode();

        switch (mode) {

        case DEFAULT:

            it = new DefaultIterator(this, index, elements);

            break;

        case FILTERED:

            it = new FilteredIterator(this, index);

            break;

        case ORDERED:

            if (orderedData != null) {

                it = new OrderedIterator(this, index);

            } else {

                it = new OrderedIterator(this, new DefaultIterator(this, 0, elements),index);

            }

            break;

        case ORDERED_FILTERED:

            it = new OrderedIterator(this, new FilteredIterator(this, 0),

                index);

            break;

        case EDITED:

            it = new EditedIterator(this, index);

            break;

        case EDITED_FILTERED:

            it = new EditedFilteredIterator(this, index);

            break;

        case ORDERD_EDITED:

            it = new OrderedIterator(this, new EditedIterator(this, 0), index);

            break;

        case ORDERED_EDITED_FILTER:

            it = new OrderedIterator(this,

                new EditedFilteredIterator(this, 0), index);

            break;

        default:

            throw new IllegalArgumentException();

        }

        if( this.query!=null && this.query.getLimit()>0 ) {

            it = new LimitIterator(it,this.query.getLimit());

        }

        return it;

    }

    private boolean providerCanOrder() {

        return this.provider.canOrder();

    }

    private boolean providerCanFilter() {

        return this.provider.canFilter();

    }

    private int getIteratorMode() {

        if (this.iteratorMode != NO_CHECKED) {

            return this.iteratorMode;

        }

        // TODO Tener en cuenta las transformaciones ???

        if (store.isEditing() && (store.getFeatureTypeManager().hasChanges() || store.getFeatureManager().hasChanges())) {

            if (this.query.hasOrder()) { // En edicion siempre ordeno yo.

                if (this.query.hasFilter()) {

                    return ORDERED_EDITED_FILTER;

                } else {

                    return ORDERD_EDITED;

                }

            } else {

                if (this.query.hasFilter()) {

                    return EDITED_FILTERED;

                } else {

                    return EDITED;

                }

            }

        } else {

            boolean useMyFilter = this.query.hasFilter();

            boolean useMyOrder = this.query.hasOrder();

            if (this.providerCanOrder() && this.transform.isEmpty()) {

                useMyOrder = false;

            }

            if (this.providerCanFilter() && this.transform.isEmpty()) {

                useMyFilter = false;

            }

            if (useMyOrder) {

                if (useMyFilter) {

                    return ORDERED_FILTERED;

                } else {

                    return ORDERED;

                }

            } else {

                if (useMyFilter) {

                    return FILTERED;

                } else {

                    return DEFAULT;

                }

            }

        }

    }

    public void delete(Feature feature) throws DataException {

        this.featureToIgnoreNotification = feature;

        this.store.delete(feature);

        if (this.size > 0) {

            this.size--;

        }

        this.featureToIgnoreNotification = null;

        this.ownFeaturesModified = true;

    }

    public void insert(EditableFeature feature) throws DataException {

        this.featureToIgnoreNotification = feature;

        this.store.insert(feature);

        if (this.size >= 0) {

            this.size++;

        }

        this.featureToIgnoreNotification = null;

        this.ownFeaturesModified = true;

    }

    public void update(EditableFeature feature) throws DataException {

        this.featureToIgnoreNotification = feature;

        this.store.update(feature);

        this.featureToIgnoreNotification = null;

        this.ownFeaturesModified = true;

    }

    public void commitChanges() throws DataException {

        this.ignoreChanges = true;

        this.store.commitChanges();

        this.ignoreChanges = false;

    }

    public FeatureStore getFeatureStore() {

        return store;

    }

}