Application: gvSIG desktop

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

import org.gvsig.fmap.dal.feature.impl.expansionadapter.MemoryExpansionAdapter;

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

import org.gvsig.fmap.dal.feature.impl.undo.DefaultFeatureCommandsStack;

import org.gvsig.fmap.dal.feature.impl.undo.FeatureCommandsStack;

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

    private DefaultFeatureStoreTransforms transforms;

    DelegatedDynObject metadata;

    private Set metadataChildren;

    private Long featureCount = null;

    /*

     * TODO:

     * - Comprobar que solo se pueden a�adir reglas de validacion sobre un

     * EditableFeatureType. - Comprobar que solo se puede hacer un update con un

     * featureType al que se le han cambiado las reglas de validacion cuando

     * // TODO:

     * // Si el provider devuelbe null habria que ver de construir aqui

     * // los metadatos basicos, como el Envelope y el SRS.

     * // TODO: Estando en edicion el Envelope deberia de

     * // actualizarse usando el spatialManager

     * return this.provider.getMetadata();

    public Envelope getEnvelope() throws DataException {

        if (this.mode == MODE_FULLEDIT) {

        	// Just in case another thread tries to write in the store

        		return this.spatialManager.getEnvelope();

			}

        }

            String defFTypeid = state.getString("defaultFeatureTypeId");

            FeatureType ftype = null;

            if (this.defaultFeatureType == null ||

                this.defaultFeatureType.getId() == null ||

                !this.defaultFeatureType.getId().equals(

        }

    }

        this.commands.delete(feature);

    }

    synchronized public void doDelete(Feature feature) throws DataException {

        try {

            checkInEditingMode();

            if (feature instanceof EditableFeature) {

                throw new StoreDeleteEditableFeatureException(getName());

            }

            //Update the featureManager and the spatialManager

            featureManager.delete(feature.getReference());

            spatialManager.deleteFeature(feature);

            newVersionOfUpdate();

            hasStrongChanges = true;

            notifyChange(FeatureStoreNotification.AFTER_DELETE, feature);

    private static EditableFeature lastChangedFeature = null;

        throws DataException {

        LOG.debug("In editing mode {}, insert feature: {}", new Integer(mode),

            feature);

                notifyChange(FeatureStoreNotification.AFTER_INSERT, feature);

                break;

                if (feature.getSource() != null) {

                    throw new NoNewFeatureInsertException(this.getName());

                }

            }

        } catch (Exception e) {

            throw new StoreInsertFeatureException(e, this.getName());

        }

    }

    synchronized public void doInsert(EditableFeature feature)

        throws DataException {

        checkIsOwnFeature(feature);

        waitForIndexes();

        notifyChange(FeatureStoreNotification.BEFORE_INSERT, feature);

        //Update the featureManager and the spatialManager

        ((DefaultEditableFeature) feature).setInserted(true);

        DefaultFeature newFeature = (DefaultFeature) feature.getNotEditableCopy();

        featureManager.add(newFeature);

        spatialManager.insertFeature(newFeature);

        hasStrongChanges = true;

        hasInserts = true;

    }

    public void update(EditableFeature feature)

        if ((feature).getSource() == null) {

            insert(feature);

            return;

    synchronized public void doUpdate(EditableFeature feature, Feature oldFeature)

        throws DataException {

            checkInEditingMode();

            checkIsOwnFeature(feature);

            notifyChange(FeatureStoreNotification.BEFORE_UPDATE, feature);

                feature.validate(Feature.UPDATE);

                lastChangedFeature = null;

            }

            //Update the featureManager and the spatialManager

            Feature newf = feature.getNotEditableCopy();

            featureManager.update(newf, oldFeature);

            spatialManager.updateFeature(newf, oldFeature);

            hasStrongChanges = true;

            notifyChange(FeatureStoreNotification.AFTER_UPDATE, feature);

        } catch (Exception e) {

    synchronized public void finishEditing() throws DataException {

        LOG.debug("finish editing of mode: {}", new Integer(mode));

        try {

            /*

             * Selection needs to be cleared when editing stops

             * to prevent conflicts with selection remaining from

             * editing mode.

             */

            ((FeatureSelection) this.getSelection()).deselectAll();

            switch (mode) {

            case MODE_QUERY:

                throw new NeedEditingModeException(this.getName());

                notifyChange(FeatureStoreNotification.BEFORE_FINISHEDITING);

                if (hasStrongChanges) {

                    validateFeatures(Feature.FINISH_EDITING);

                    /*

                     * This will throw a PerformEditingExceptionif the provider

                     * does not accept the changes (for example, an invalid field name)

    	default:

        case MODE_QUERY:

        	return false;

        case MODE_APPEND:

        	return true;

        case MODE_FULLEDIT:

            List types = this.getFeatureTypes();

            for( int i=0; i<types.size(); i++ ) {

            return true;

    	}

    }

    public void beginEditingGroup(String description)

        throws NeedEditingModeException {

        checkInEditingMode();

                return f;

            }

        }

        DefaultFeature feature =

            new DefaultFeature(this,

                this.provider.getFeatureProviderByReference(

    public FeatureType getDefaultFeatureType() throws DataException {

        try {

            if (isEditing()) {

                FeatureType auxFeatureType =

                    featureTypeManager.getType(defaultFeatureType.getId());

            if (type != null) {

                return avoidEditable(type);

            }

            return avoidEditable(defaultFeatureType);

        } catch (Exception e) {

            throw new GetFeatureTypeException(e, getName());

        }

    }

    private FeatureType avoidEditable(FeatureType ft) {

        if (ft instanceof EditableFeatureType) {

            return ((EditableFeatureType) ft).getNotEditableCopy();

                new DefaultEditableFeature(this, data);

            feature.initializeValues(defaultValues);

            data.setNew(true);

            return feature;

        } catch (Exception e) {

            throw new CreateFeatureException(e, getName());

    /*

     * (non-Javadoc)

     * @see org.gvsig.metadata.Metadata#getMetadataChildren()

     */

    public Set getMetadataChildren() {

    /*

     * (non-Javadoc)

     * @see org.gvsig.metadata.Metadata#getMetadataName()

     */

    public String getMetadataName() {

        return this.provider.getRetrievedFeaturesLimit();

    }

        return this.provider.getInterval();

    }

        return this.provider.getTimes();

    }

        return this.provider.getTimes(interval);

    }

    /* (non-Javadoc)

     * @see java.lang.Object#clone()

     */

    public Object clone() throws CloneNotSupportedException {

        DataStoreParameters dsp = getParameters();

        DefaultFeatureStore cloned_store = null;

        try {

            cloned_store = (DefaultFeatureStore) DALLocator.getDataManager().

                openStore(this.getProviderName(), dsp);

            }

        } catch (Exception e) {

            throw new CloneException(e);

        return cloned_store;

    }

}