Application: gvSIG desktop

        public boolean isKnownEnvelope() {

            // TODO Auto-generated method stub

            return false;

        }

        public boolean hasRetrievedFeaturesLimit() {

            // TODO Auto-generated method stub

            return false;

        }

        public int getRetrievedFeaturesLimit() {

            // TODO Auto-generated method stub

            return 0;

        }

        public boolean isKnownEnvelope() {

            // TODO Auto-generated method stub

            return false;

        }

        public boolean hasRetrievedFeaturesLimit() {

            // TODO Auto-generated method stub

            return false;

        }

        public int getRetrievedFeaturesLimit() {

            // TODO Auto-generated method stub

            return 0;

        }

    public boolean isKnownEnvelope() {

        // TODO Auto-generated method stub

        return false;

    }

    public boolean hasRetrievedFeaturesLimit() {

        // TODO Auto-generated method stub

        return false;

    }

    public int getRetrievedFeaturesLimit() {

        // TODO Auto-generated method stub

        return 0;

    }

    public boolean isKnownEnvelope() {

        // TODO Auto-generated method stub

        return false;

    }

    public boolean hasRetrievedFeaturesLimit() {

        // TODO Auto-generated method stub

        return false;

    }

    public int getRetrievedFeaturesLimit() {

        // TODO Auto-generated method stub

        return 0;

    }

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

import org.gvsig.tools.dispose.DisposableIterator;

	 /**

     * Return if the provider knows the real envelope of a layer. If not,

     * the {@link FeatureStoreProvider#getEnvelope()} method doesn't return

     * the full envelope.

     * 

     * @return

     * <true> if it knows the real envelope.

     */

    public boolean isKnownEnvelope(); 

    /**

     * Return if the maximum number of features provided by the

     * provider are limited.

     * 

     * @return

     * <true> if there is a limit of features.

     */

    public boolean hasRetrievedFeaturesLimit();

    /**

     * If the {@link FeatureStoreProvider#hasRetrievedFeaturesLimit()} returns true,

     * it returns the limit of features retrieved from the provider.

     * @return

     * The limit of the retrieved features.

     */

    public int getRetrievedFeaturesLimit();

DataStoreImplementation, FeatureStoreProviderServices, FeatureStore,

Observer {

    final static private Logger logger = LoggerFactory

    .getLogger(DefaultFeatureStore.class);

    private static final String PERSISTENCE_DEFINITION_NAME = "FeatureStore";

    private DataStoreParameters parameters = null;

    private FeatureSelection selection;

    private FeatureLocks locks;

    private DelegateWeakReferencingObservable delegateObservable = new DelegateWeakReferencingObservable(this);

    private FeatureCommandsStack commands;

    private FeatureTypeManager featureTypeManager;

    private FeatureManager featureManager;

    private SpatialManager spatialManager;

    private FeatureType defaultFeatureType = null;

    private List featureTypes = new ArrayList();

    private int mode = MODE_QUERY;

    private long versionOfUpdate = 0;

    private boolean hasStrongChanges = true;

    private boolean hasInserts = true;

    private DefaultDataManager dataManager = null;

    private FeatureStoreProvider provider = null;

    private DefaultFeatureIndexes indexes;

    private DefaultFeatureStoreTransforms transforms;

    private DelegatedDynObject metadata;

    private Set metadataChildren;

    private Long featureCount = null;

    private long temporalOid = 0;

    private FeatureCacheProvider cache;

    /*

     * 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

     * hasStrongChanges=false.

     */

    }

    public void intializePhase1(DefaultDataManager dataManager,

        DataStoreParameters parameters) throws InitializeException {

        DynObjectManager dynManager = ToolsLocator.getDynObjectManager();

        this.metadata = (DelegatedDynObject) dynManager

        .createDynObject(

            METADATA_DEFINITION_NAME,

            MetadataManager.METADATA_NAMESPACE

        );

        this.dataManager = dataManager;

        this.parameters = parameters;

        this.transforms = new DefaultFeatureStoreTransforms(this);

        try {

            indexes = new DefaultFeatureIndexes(this);

        } catch (DataException e) {

            throw new InitializeException(e);

        }

    }

    public void intializePhase2(DataStoreProvider provider) {

        this.provider = (FeatureStoreProvider) provider;

        this.delegate(provider);

        this.metadataChildren = new HashSet();

        this.metadataChildren.add(provider);

    }

    public DataStoreParameters getParameters() {

        return parameters;

    }

    public int getMode() {

        return this.mode;

    }

    public DataManager getManager() {

        return this.dataManager;

    }

    public Iterator getChildren() {

        return this.provider.getChilds();

    }

    public FeatureStoreProvider getProvider() {

        return this.provider;

    }

    public FeatureManager getFeatureManager() {

        return this.featureManager;

    }

    public void setFeatureTypes(List types, FeatureType defaultType) {

        this.featureTypes = types;

        this.defaultFeatureType = defaultType;

    }

    public void open() throws OpenException {

        // TODO: Se puede hacer un open estando en edicion ?

        this.notifyChange(FeatureStoreNotification.BEFORE_OPEN);

        this.provider.open();

        this.notifyChange(FeatureStoreNotification.AFTER_OPEN);

    }

    public void refresh() throws OpenException, InitializeException {

        if (this.mode != MODE_QUERY) {

            throw new IllegalStateException();

        }

        this.notifyChange(FeatureStoreNotification.BEFORE_REFRESH);

        this.featureCount = null;

        this.provider.refresh();

        this.notifyChange(FeatureStoreNotification.AFTER_REFRESH);

    }

    public void close() throws CloseException {

        // TODO: Se puede hacer un close estando en edicion ?

        this.notifyChange(FeatureStoreNotification.BEFORE_CLOSE);

        this.featureCount = null;

        this.provider.close();

        this.notifyChange(FeatureStoreNotification.AFTER_CLOSE);

    }

    protected void doDispose() throws BaseException {

        this.notifyChange(FeatureStoreNotification.BEFORE_DISPOSE);

        this.provider.dispose();

        if (this.selection != null) {

            this.selection.dispose();

            this.selection = null;

        }

        this.commands = null;

        this.featureCount = null;

        if (this.locks != null) {

            //this.locks.dispose();

            this.locks = null;

        }

        if (this.featureTypeManager != null) {

            this.featureTypeManager.dispose();

            this.featureTypeManager = null;

        }

        this.featureManager = null;

        this.spatialManager = null;

        this.parameters = null;

        this.notifyChange(FeatureStoreNotification.AFTER_DISPOSE);

        if (delegateObservable != null) {

            this.delegateObservable.deleteObservers();

            this.delegateObservable = null;

        }

    }

    public boolean allowWrite() {

        return this.provider.allowWrite();

    }

    public boolean canWriteGeometry(int geometryType) throws DataException {

        return this.provider.canWriteGeometry(geometryType, 0);

    }

    public DataServerExplorer getExplorer() throws ReadException,

    ValidateDataParametersException {

        return this.provider.getExplorer();

    }

    /*

     */

    public Envelope getEnvelope() throws DataException {

        if (this.mode == MODE_FULLEDIT) {

            return this.spatialManager.getEnvelope();

        }

        return this.provider.getEnvelope();

    }

    /**

     * @deprecated use getDefaultFeatureType().getDefaultSRS()

     */

    public IProjection getSRSDefaultGeometry() throws DataException {

        return this.getDefaultFeatureType().getDefaultSRS();

    }

    public FeatureSelection createDefaultFeatureSelection()

    throws DataException {

        return new DefaultFeatureSelection(this);

    }

    public FeatureProvider createDefaultFeatureProvider(FeatureType type)

    throws DataException {

        if( type.hasOID() ) {

            return new DefaultFeatureProvider(type, this.provider.createNewOID());

        }

        return new DefaultFeatureProvider(type);

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        if (this.mode != FeatureStore.MODE_QUERY){

            throw new PersistenceException(

                new IllegalStateException(this

                    .getName()));

        }

        state.set("dataStoreName", this.getName());

        state.set("parameters", this.parameters);

        state.set("selection", this.selection);

        state.set("transforms", this.transforms);

        // TODO locks persistence

        // state.set("locks", this.locks);

        // TODO indexes persistence

        // state.set("indexes", this.indexes);

        Map evaluatedAttr = new HashMap(1);

        Iterator iterType = featureTypes.iterator();

        Iterator iterAttr;

        FeatureType type;

        DefaultFeatureAttributeDescriptor attr;

        List attrs;

        while (iterType.hasNext()) {

            type = (FeatureType) iterType.next();

            attrs = new ArrayList();

            iterAttr = type.iterator();

            while (iterAttr.hasNext()) {

                attr = (DefaultFeatureAttributeDescriptor) iterAttr.next();

                if (attr.getEvaluator() != null

                    && attr.getEvaluator() instanceof Persistent) {

                    attrs.add(attr);

                }

            }

            if (!attrs.isEmpty()) {

                evaluatedAttr.put(type.getId(), attrs);

            }

        }

        if (evaluatedAttr.isEmpty()) {

            evaluatedAttr = null;

        }

        state.set("evaluatedAttributes", evaluatedAttr);

        state.set("defaultFeatureTypeId", defaultFeatureType.getId());

    }

    public void loadFromState(PersistentState state) throws PersistenceException {

        if (this.provider != null) {

            throw new PersistenceStoreAlreadyLoadedException(this.getName());

        }

        if (this.getManager() == null) {

            this.dataManager = (DefaultDataManager) DALLocator.getDataManager();

        }

        DataStoreParameters params = (DataStoreParameters) state.get("parameters");

        try {

            this.dataManager.intializeDataStore(this, params);

            this.selection = (FeatureSelection) state.get("selection");

            this.transforms = (DefaultFeatureStoreTransforms) state.get("transforms");

            Map evaluatedAttributes = (Map) state.get("evaluatedAttributes");

            if (evaluatedAttributes != null && !evaluatedAttributes.isEmpty()) {

                List attrs;

                Iterator iterEntries = evaluatedAttributes.entrySet().iterator();

                Entry entry;

                while (iterEntries.hasNext()){

                    entry = (Entry) iterEntries.next();

                    attrs = (List) entry.getValue();

                    if (attrs.isEmpty()){

                        continue;

                    }

                    int fTypePos = -1;

                    DefaultFeatureType type = null;

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

                        type = (DefaultFeatureType) featureTypes.get(i);

                        if (type.getId().equals(entry.getKey())){

                            fTypePos = i;

                            break;

                        }

                    }

                    if (fTypePos < 0){

                        throw new PersistenceCantFindFeatureTypeException(this.getName(), (String)entry.getKey());

                    }

                    DefaultEditableFeatureType eType = (DefaultEditableFeatureType) type

                    .getEditable();

                    Iterator iterAttr = attrs.iterator();

                    FeatureAttributeDescriptor attr;

                    while (iterAttr.hasNext()) {

                        attr = (FeatureAttributeDescriptor) iterAttr.next();

                        eType.addLike(attr);

                    }

                    featureTypes.set(fTypePos, eType.getNotEditableCopy());

                }

            }

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

            FeatureType ftype = null;

            if (!this.defaultFeatureType.getId().equals(

                state.getString("defaultFeatureTypeId"))) {

                ftype = getFeatureType(defFTypeid);

                if (ftype == null) {

                    throw new PersistenceCantFindDefaultFeatureTypeException(this.getName(), defFTypeid);

                }

                this.defaultFeatureType = ftype;

            }

        } catch (InitializeException e) {

            throw new PersistenceException(e);

        } catch (DataException e) {

            throw new PersistenceException(e);

        }

    }

    public static void registerPersistenceDefinition() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if( manager.getDefinition(PERSISTENCE_DEFINITION_NAME)==null ) {

            DynStruct definition = manager.addDefinition(

                DefaultFeatureStore.class, 

                PERSISTENCE_DEFINITION_NAME, 

                PERSISTENCE_DEFINITION_NAME+" Persistent definition",

                null, 

                null

            );

            definition.addDynFieldString("dataStoreName")

            .setMandatory(true)

            .setPersistent(true);

            definition.addDynFieldObject("parameters")

            .setClassOfValue(DynObject.class)

            .setMandatory(true)

            .setPersistent(true);

            definition.addDynFieldObject("selection")

            .setClassOfValue(FeatureSelection.class)

            .setMandatory(false)

            .setPersistent(true);

            definition.addDynFieldObject("transforms")

            .setClassOfValue(DefaultFeatureStoreTransforms.class)

            .setMandatory(true)

            .setPersistent(true);

            definition.addDynFieldMap("evaluatedAttributes")

            .setClassOfItems(List.class) // List<DefaultFeatureAttributeDescriptor>

            .setMandatory(false)

            .setPersistent(true);

            definition.addDynFieldString("defaultFeatureTypeId")

            .setMandatory(true)

            .setPersistent(true);

        }

    }

    public static void registerMetadataDefinition() throws MetadataException {

        MetadataManager manager = MetadataLocator.getMetadataManager();

        if( manager.getDefinition(METADATA_DEFINITION_NAME)==null ) {

            DynStruct metadataDefinition = manager.addDefinition(

                METADATA_DEFINITION_NAME,

                null

            );

            metadataDefinition.extend(

                manager.getDefinition(

                    DataStore.METADATA_DEFINITION_NAME

                )

            );

        }

    }

    //

    // ====================================================================

    // Gestion de la seleccion

    //

    public void setSelection(DataSet selection)

    throws DataException {

        this.setSelection((FeatureSet) selection);

    }

    public DataSet createSelection() throws DataException {

        return createFeatureSelection();

    }

    public DataSet getSelection() throws DataException {

        return this.getFeatureSelection();

    }

    throws DataException {

        if (selection == null) {

            if (undoable) {

                throw new SelectionNotAllowedException(getName());

            }

        } else {

            if (selection.equals(this.selection)) {

                return;

            }

            if (!selection.isFromStore(this)) {

                throw new SelectionNotAllowedException(getName());

            }

        }

        if (this.selection != null) {

            this.selection.deleteObserver(this);

        }

        if (selection == null) {

            if (this.selection != null) {

                this.selection.dispose();

            }

            this.selection = null;

            return;

        }

        if (selection instanceof FeatureSelection) {

            if (undoable && isEditing()) {

                commands.selectionSet(this, this.selection,

                    (FeatureSelection) selection);

            }

            if (this.selection != null) {

                this.selection.dispose();

            }

            this.selection = (FeatureSelection) selection;

        } else {

            if (undoable && isEditing()) {

                commands.startComplex("_selectionSet");

            }

            if (selection instanceof DefaultFeatureSelection) {

            if (undoable && isEditing()) {

                commands.endComplex();

            }

        }

        this.selection.addObserver(this);

        this.notifyChange(DataStoreNotification.SELECTION_CHANGE);

    }

    public FeatureSelection createFeatureSelection() throws DataException {

        return this.provider.createFeatureSelection();

    }

    public FeatureSelection getFeatureSelection() throws DataException {

        if (selection == null) {

            this.selection = createFeatureSelection();

            this.selection.addObserver(this);

        }

        return selection;

    }

    //

    // ====================================================================

    // Gestion de notificaciones

    //

    public void notifyChange(String notification) {

        if (delegateObservable != null) {

            delegateObservable.notifyObservers(new DefaultFeatureStoreNotification(

                this, notification));

        }

    }

    public void notifyChange(String notification, Feature feature) {

        delegateObservable.notifyObservers(new DefaultFeatureStoreNotification(

            this, notification, feature));

    }

    public void notifyChange(String notification, Command command) {

        delegateObservable.notifyObservers(new DefaultFeatureStoreNotification(

            this, notification, command));

    }

    public void notifyChange(String notification, EditableFeatureType type) {

        delegateObservable.notifyObservers(new DefaultFeatureStoreNotification(this,

            notification, type));

    }

    /*

     * (non-Javadoc)

     *

     * @see

     * org.gvsig.fmap.dal.feature.spi.FeatureStoreProviderServices#notifyChange

     * (java.lang.String, org.gvsig.fmap.dal.resource.Resource)

     */

    public void notifyChange(String notification, Resource resource) {

        delegateObservable.notifyObservers(new DefaultFeatureStoreNotification(this,

            FeatureStoreNotification.RESOURCE_CHANGED));

    }

    //

    // ====================================================================

    // Gestion de bloqueos

    //

    public boolean isLocksSupported() {

        return this.provider.isLocksSupported();

    }

    public FeatureLocks getLocks() throws DataException {

        if (!this.provider.isLocksSupported()) {

            logger.warn("Locks not supporteds");

            return null;

        }

        if (locks == null) {

            this.locks = this.provider.createFeatureLocks();

        }

        return locks;

    }

    //

    // ====================================================================

    // Interface Observable

    //

    public void disableNotifications() {

        this.delegateObservable.disableNotifications();

    }

    public void enableNotifications() {

        this.delegateObservable.enableNotifications();

    }

    public void beginComplexNotification() {

        this.delegateObservable.beginComplexNotification();

    }

    public void endComplexNotification() {

        this.delegateObservable.endComplexNotification();

    }

    public void addObserver(Observer observer) {

        this.delegateObservable.addObserver(observer);

    }

    public void deleteObserver(Observer observer) {

        if (delegateObservable != null) {

            this.delegateObservable.deleteObserver(observer);

        }

    }

    public void deleteObservers() {

        this.delegateObservable.deleteObservers();

    }

    //

    // ====================================================================

    // Interface Observer

    //

    // Usado para observar:

    // - su seleccion

    // - sus bloqueos

    // - sus recursos

    //

    public void update(Observable observable, Object notification) {

        if (observable instanceof FeatureSet) {

            if (observable == this.selection) {

                this.notifyChange(FeatureStoreNotification.SELECTION_CHANGE);

            } else if (observable == this.locks) {

                this.notifyChange(FeatureStoreNotification.LOCKS_CHANGE);

            }

        } else if (observable instanceof FeatureStoreProvider) {

            if (observable == this.provider) {

            }

        }

    }

    //

    // ====================================================================

    // Edicion

    //

    private void newVersionOfUpdate() {

        this.versionOfUpdate++;

    }

    private long currentVersionOfUpdate() {

        return this.versionOfUpdate;

    }

    private void checkInEditingMode()

    throws NeedEditingModeException {

        if (mode != MODE_FULLEDIT) {

            throw new NeedEditingModeException(this.getName());

        }

    }

    private void checkNotInAppendMode() throws IllegalStateException {

        if (mode == MODE_APPEND) {

            throw new IllegalStateException(this.getName());

        }

    }

    private void checkIsOwnFeature(Feature feature)

    throws IllegalFeatureException {

        if (((DefaultFeature) feature).getStore() != this) {

            throw new IllegalFeatureException(this.getName());

        }

        // FIXME: fixFeatureType no vale para el checkIsOwnFeature

        // fixFeatureType((DefaultFeatureType) feature.getType());

    }

    private void exitEditingMode() {

        if (commands != null) {

            commands.clear();

            commands = null;

        }

        if (featureTypeManager != null) {

            featureTypeManager.dispose();

            featureTypeManager = null;

        }

        // TODO implementar un dispose para estos dos

        featureManager = null;

        spatialManager = null;

        featureCount = null;

        mode = MODE_QUERY;

        hasStrongChanges = true; // Lo deja a true por si las moscas

        hasInserts = true;

    }

    synchronized public void edit() throws DataException {

        edit(MODE_FULLEDIT);

    }

    synchronized public void edit(int mode) throws DataException {

        try {

            if ( this.mode != MODE_QUERY ) {

                throw new AlreadyEditingException(this.getName());

            }

            if (!this.provider.supportsAppendMode()) {

                mode = MODE_FULLEDIT;

            }

            switch (mode) {

            case MODE_QUERY:

                throw new IllegalStateException(this.getName());

            case MODE_FULLEDIT:

                if (!this.transforms.isEmpty()) {

                    throw new IllegalStateException(this.getName());

                }

                notifyChange(FeatureStoreNotification.BEFORE_STARTEDITING);

                featureManager = new FeatureManager(new MemoryExpansionAdapter());

                featureTypeManager = new FeatureTypeManager(this,

                    new MemoryExpansionAdapter());

                spatialManager = new SpatialManager(this, provider

                    .getEnvelope());