| gvSIG desktop 1

 * 2008 IVER T.I. S.A.   {{Task}}

 */

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

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

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

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

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

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

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

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

import org.gvsig.metadata.MetadataManager;

import org.gvsig.metadata.exceptions.MetadataException;

import org.gvsig.timesupport.Interval;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dispose.impl.AbstractDisposable;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.undo.RedoException;

import org.gvsig.tools.undo.UndoException;

import org.gvsig.tools.undo.command.Command;

import org.gvsig.tools.visitor.Visitor;

public final class DefaultFeatureStore extends AbstractDisposable implements

    private static final String PERSISTENCE_DEFINITION_NAME = "FeatureStore";

    private FeatureSelection selection;

    private FeatureLocks locks;

    private FeatureCommandsStack commands;

    private FeatureTypeManager featureTypeManager;

    /*

     * 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

        DynObjectManager dynManager = ToolsLocator.getDynObjectManager();

        this.dataManager = dataManager;

        this.parameters = parameters;

    public void open() throws OpenException {

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

        this.provider.open();

    }

    public void refresh() throws OpenException, InitializeException {

    public void close() throws CloseException {

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

        this.featureCount = null;

        this.provider.close();

    }

    protected void doDispose() throws BaseException {

        this.provider.dispose();

        if (this.selection != null) {

            this.selection.dispose();

        this.commands = null;

        this.featureCount = null;

        if (this.locks != null) {

            this.locks = null;

        }

        this.spatialManager = null;

        this.parameters = null;

        if (delegateObservable != null) {

            this.delegateObservable.deleteObservers();

            this.delegateObservable = null;

    }

    public DataServerExplorer getExplorer() throws ReadException,

        return this.provider.getExplorer();

    }

    /*

     */

    public Envelope getEnvelope() throws DataException {

    }

    public FeatureSelection createDefaultFeatureSelection()

        return new DefaultFeatureSelection(this);

    }

    public FeatureProvider createDefaultFeatureProvider(FeatureType type)

        }

        return new DefaultFeatureProvider(type);

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        }

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

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

            iterAttr = type.iterator();

            while (iterAttr.hasNext()) {

                attr = (DefaultFeatureAttributeDescriptor) iterAttr.next();

                    attrs.add(attr);

                }

            }

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

            }

        }

        if (evaluatedAttr.isEmpty()) {

    }

        if (this.provider != null) {

            throw new PersistenceStoreAlreadyLoadedException(this.getName());

        }

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

        }

        try {

            this.dataManager.intializeDataStore(this, params);

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

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

                List attrs;

                Entry entry;

                    entry = (Entry) iterEntries.next();

                    attrs = (List) entry.getValue();

                        continue;

                    }

                    int fTypePos = -1;

                    DefaultFeatureType type = null;

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

                            fTypePos = i;

                            break;

                        }

                    }

                    }

                    Iterator iterAttr = attrs.iterator();

                    FeatureAttributeDescriptor attr;

                    while (iterAttr.hasNext()) {

                }

            }

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

                ftype = getFeatureType(defFTypeid);

                if (ftype == null) {

                }

                this.defaultFeatureType = ftype;

            }

        } catch (InitializeException e) {

            throw new PersistenceException(e);

        } catch (DataException e) {

    public static void registerPersistenceDefinition() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        }

    }

    public static void registerMetadataDefinition() throws MetadataException {

        MetadataManager manager = MetadataLocator.getMetadataManager();

        }

    }

    // Gestion de la seleccion

    //

        this.setSelection((FeatureSet) selection);

    }

     *            if the action must be undoable

     */

    public void setSelection(FeatureSet selection, boolean undoable)

        if (selection == null) {

            if (undoable) {

                throw new SelectionNotAllowedException(getName());

                commands.startComplex("_selectionSet");

            }

            if (selection instanceof DefaultFeatureSelection) {

                defSelection.deselectAll(undoable);

                defSelection.select(selection, undoable);

            } else {

    public void notifyChange(String notification) {

        if (delegateObservable != null) {

        }

    }

    public void notifyChange(String notification, Feature feature) {

    }

    public void notifyChange(String notification, Command command) {

    }

    public void notifyChange(String notification, EditableFeatureType type) {

    }

    public void notifyChange(String notification, Resource resource) {

    }

    //

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

    // Gestion de bloqueos

    public void update(Observable observable, Object notification) {

        if (observable instanceof FeatureSet) {

            if (observable == this.selection) {

    }

    //

        return this.versionOfUpdate;

    }

        if (mode != MODE_FULLEDIT) {

            throw new NeedEditingModeException(this.getName());

        }

    }

    private void checkIsOwnFeature(Feature feature)

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

            throw new IllegalFeatureException(this.getName());

        }

    synchronized public void edit(int mode) throws DataException {

        try {

                throw new AlreadyEditingException(this.getName());

            }

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

                    throw new IllegalStateException(this.getName());

                }

                notifyChange(FeatureStoreNotification.BEFORE_STARTEDITING);

                this.mode = MODE_FULLEDIT;

                hasStrongChanges = false;

                hasInserts = false;

    }

    synchronized public void update(EditableFeatureType type)

        try {

            checkInEditingMode();

            if (type == null) {

    private static EditableFeature lastChangedFeature = null;

    synchronized public void insert(EditableFeature feature)

        try {

            switch (mode) {

            case MODE_QUERY:

                }

                notifyChange(FeatureStoreNotification.BEFORE_INSERT, feature);

                newVersionOfUpdate();

                    lastChangedFeature = feature;

                    feature.validate(Feature.UPDATE);

                    lastChangedFeature = null;

    }

    synchronized public void update(EditableFeature feature)

        try {

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

                insert(feature);

            checkIsOwnFeature(feature);

            notifyChange(FeatureStoreNotification.BEFORE_UPDATE, feature);

            newVersionOfUpdate();

                lastChangedFeature = feature;

                feature.validate(Feature.UPDATE);

                lastChangedFeature = null;

    }

    public List getRedoInfos() {

            return commands.getRedoInfos();

        } else {

            return null;

    }

    public List getUndoInfos() {

            return commands.getUndoInfos();

        } else {

            return null;

    }

    public synchronized FeatureCommandsStack getCommandsStack()

        checkInEditingMode();

        return commands;

    }

                    validateFeatures(Feature.FINISH_EDITING);

                    provider.performChanges(featureManager.getDeleted(),

                        featureManager.getInserted(), featureManager

                }

                exitEditingMode();

                notifyChange(FeatureStoreNotification.AFTER_FINISHEDITING);

    }

    public void beginEditingGroup(String description)

        checkInEditingMode();

        commands.startComplex(description);

    }

        return this.provider.supportsAppendMode();

    }

        if (this.getFeatureTypes().size() != 1) {

            throw new NotYetImplemented(

        }

        FeatureStore target = null;

        FeatureSet features = null;

        DisposableIterator iterator = null;

        try {

            FeatureType type = this.getDefaultFeatureType();

                params.setDefaultFeatureType(type.getEditable());

            }

            target.edit(MODE_APPEND);

            FeatureAttributeDescriptor[] pk = type.getPrimaryKey();

                features = this.getFeatureSelection();

                    FeatureQuery query = createFeatureQuery();

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

                        query.getOrder().add(pk[i].getName(), true);

    public DataSet getDataSet() throws DataException {

        checkNotInAppendMode();

        return new DefaultFeatureSet(this, query);

    }

        checkNotInAppendMode();

        return new DefaultFeatureSet(this, (FeatureQuery) dataQuery);

    }

    }

    public void getDataSet(DataQuery dataQuery, Observer observer)

        checkNotInAppendMode();

        this.getFeatureSet((FeatureQuery) dataQuery, observer);

    }

    public FeatureSet getFeatureSet() throws DataException {

        checkNotInAppendMode();

        return new DefaultFeatureSet(this, query);

    }

    public FeatureSet getFeatureSet(FeatureQuery featureQuery)

        checkNotInAppendMode();

        return new DefaultFeatureSet(this, featureQuery);

    }

    }

    public void accept(Visitor visitor, DataQuery dataQuery)

        FeatureSet set = getFeatureSet((FeatureQuery) dataQuery);

        try {

            set.accept(visitor);

    }

    public FeatureType getFeatureType(FeatureQuery featureQuery)

            return fType.getSubtype(featureQuery.getAttributeNames());

        }

        return fType;

    }

        checkNotInAppendMode();

        this.getFeatureSet(null, observer);

    }

    public void getFeatureSet(FeatureQuery query, Observer observer)

        class LoadInBackGround implements Runnable {

            private FeatureStore store;

            private FeatureQuery query;

            private Observer observer;

            public LoadInBackGround(FeatureStore store, FeatureQuery query,

                this.store = store;

                this.query = query;

                this.observer = observer;

            }

            void notify(FeatureStoreNotification theNotification) {

            }

            public void run() {

        if (query == null) {

            query = new DefaultFeatureQuery(this.getDefaultFeatureType());

        }

        Thread thread = new Thread(task);

        thread.run();

    }

        checkNotInAppendMode();

        DefaultFeatureReference ref = (DefaultFeatureReference) reference;

        FeatureType featureType;

        return this.getFeatureByReference(reference, featureType);

    }

        checkNotInAppendMode();

        featureType = fixFeatureType((DefaultFeatureType) featureType);

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

        }

        // TODO comprobar que el id es de este store

        if (this.mode == MODE_FULLEDIT) {

            Feature f = featureManager.get(reference, this, featureType);

                return f;

            }

        }

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

            return this.transforms.applyTransform(feature, featureType);

    //

    private FeatureType fixFeatureType(DefaultFeatureType type)

        FeatureType original = this.getDefaultFeatureType();

            return original;

        } else {

            if (!type.isSubtypeOf(original)) {

                    if (type.equals(tmpType)) {

                        return type;

                }

                if (!found) {

        // else add the missing attributes at the end.

        if (!original.hasOID()) {

            // Gets original pk attributes

            FeatureAttributeDescriptor orgAttr;

            Iterator edOriginalIter = edOriginal.iterator();

            while (edOriginalIter.hasNext()) {

            // add missing pk attributes if any

            if (edOriginal.size() > 0) {

                boolean isEditable = type instanceof DefaultEditableFeatureType;

                edType.clear();

                edType.addAll(type);

                edType.addAll(edOriginal);

        }

        return type;

    }

    public FeatureType getDefaultFeatureType() throws DataException {

        try {

            if (isEditing()) {

                    return auxFeatureType;

                }

            }

    }

    public FeatureType getFeatureType(String featureTypeId)

        if (featureTypeId == null) {

            return this.getDefaultFeatureType();

        }

        try {

            if (isEditing()) {

                if (auxFeatureType != null) {

                    return auxFeatureType;

                }

                return type;

            }

            Iterator iter = this.featureTypes.iterator();

                type = (FeatureType) iter.next();

                if (type.getId().equals(featureTypeId)) {

                    return type;

        }

    }

    public FeatureType getProviderDefaultFeatureType() {

        return defaultFeatureType;

    }

        try {

            List types;

            if (isEditing()) {

                while (it.hasNext()) {

                    FeatureType type = (FeatureType) it.next();

                        types.add(typeaux);

                        types.add(type);

                    }

                }

        return Collections.unmodifiableList(this.featureTypes);

    }

        DefaultFeature feature = new DefaultFeature(this, data);

        return feature;

    }

    public Feature createFeature(FeatureProvider data, FeatureType type)

        // FIXME: falta por implementar

        // Comprobar si es un subtipo del feature de data

        // y construir un feature usando el subtipo.

    }

    public EditableFeature createNewFeature(FeatureType type,

        try {

            FeatureProvider data = createNewFeatureProvider(type);

            feature.initializeValues(defaultValues);

            return feature;

        } catch (Exception e) {

    }

    private FeatureProvider createNewFeatureProvider(FeatureType type)

        type = this.fixFeatureType((DefaultFeatureType) type);

        FeatureProvider data = this.provider.createFeatureProvider(type);

        data.setNew(true);

            data.setOID(this.provider.createNewOID());

        } else {

            data.setOID(this.getTemporalOID());

    }

    public EditableFeature createNewFeature(FeatureType type,

        try {

            FeatureProvider data = createNewFeatureProvider(type);

            if (defaultValues) {

                feature.initializeValues();

            }

    }

    public EditableFeature createNewFeature(boolean defaultValues)

    }

    public EditableFeature createNewFeature() throws DataException {

        return ftype;

    }

    //

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

    // Index related methods

    }

    public FeatureIndex createIndex(FeatureType featureType,

        checkNotInAppendMode();

        FeatureIndexProviderServices index = null;

        try {

            index.fill();

        } catch (FeatureIndexException e) {

    public FeatureIndex createIndex(FeatureType featureType,

        String attributeName, String indexName, Observer observer) {

        // TODO Implement observer interaction

        throw new UnsupportedOperationException();

    }

    }

    public Object getDynValue(String name) throws DynFieldNotFoundException {

        }

            return this.provider.getProviderName();

        return this.metadata.getDynValue(name);

    }

    }

    public Object invokeDynMethod(String name, DynObject context)

        return this.metadata.invokeDynMethod(this, name, context);

    }

    public Object invokeDynMethod(int code, DynObject context)

        return this.metadata.invokeDynMethod(this, code, context);

    }

    public void setDynValue(String name, Object value)

        this.metadata.setDynValue(name, value);

    }

    /*

     * (non-Javadoc)

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

     */

    public Set getMetadataChildren() {

    /*

     * (non-Javadoc)

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

     */

    public String getMetadataName() {

        }

        if (this.isEditing() && !this.isAppending()) {

            return featureCount.longValue()

        }

        return featureCount.longValue();

    }

    }

    public void createCache(String name, DynObject parameters)

        cache = dataManager.createFeatureCacheProvider(name, parameters);

            throw new CreateException("FeaureCacheProvider", null);

        }

        cache.apply(this, provider);

        return this.provider.getRetrievedFeaturesLimit();

    }

        return provider.getInterval();

    }