Application: gvSIG desktop

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

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

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

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

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

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

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

import org.gvsig.tools.persistence.AbstractPersistenceManager;

import org.gvsig.tools.persistence.PersistenceException;

import org.gvsig.tools.persistence.PersistentState;

public class DefaultFeatureStoreTransforms implements FeatureStoreTransforms,

                FeatureStoreTransform {

        private DefaultFeatureStore store;

        private List transforms;

        public DefaultFeatureStoreTransforms() {

                this.store = null;

                this.transforms = new ArrayList();

        }

        public DefaultFeatureStoreTransforms(DefaultFeatureStore store) {

                this.store = store;

                this.transforms = new ArrayList();

        }

        private void checkEditingMode() {

                if (store == null || store.getMode() != FeatureStore.MODE_QUERY) {

                        throw new IllegalStateException();

                }

        }

        public FeatureStoreTransform add(FeatureStoreTransform transform) throws DataException {

                checkEditingMode();

                if( ! transform.getFeatureTypes().contains(transform.getDefaultFeatureType())) {

                        throw new IllegalArgumentException(); // FIXME: A?adir tipo especifico.

                }

                this.transforms.add(transform);

                this.store.notifyChange(FeatureStoreNotification.TRANSFORM_CHANGE);

                return transform;

        }

        public void clear() {

                checkEditingMode();

                this.transforms.clear();

                this.store.notifyChange(FeatureStoreNotification.TRANSFORM_CHANGE);

        }

        public FeatureStoreTransform getTransform(int index) {

                return (FeatureStoreTransform) this.transforms.get(index);

        }

        public Iterator iterator() {

                return Collections.unmodifiableList(transforms).iterator();

        }

        public Object remove(int index) {

                checkEditingMode();

                Object trans = this.transforms.remove(index);

                if (trans != null) {

                        this.store.notifyChange(FeatureStoreNotification.TRANSFORM_CHANGE);

                }

                return trans;

        }

        public boolean remove(FeatureStoreTransform transform) {

                checkEditingMode();

                boolean removed = this.transforms.remove(transform);

                if (removed) {

                        this.store.notifyChange(FeatureStoreNotification.TRANSFORM_CHANGE);

                }

                return removed;

        }

        public int size() {

                return this.transforms.size();

        }

        public boolean isEmpty() {

                return this.transforms.isEmpty();

        }

        public void applyTransform(Feature source, EditableFeature target)

                        throws DataException {

                Iterator it = this.transforms.iterator();

                while (it.hasNext()) {

                        FeatureStoreTransform transform = (FeatureStoreTransform) it.next();

                        transform.applyTransform(source, target);

                        source = target.getCopy();

                }

        }

        public FeatureType getDefaultFeatureType() throws DataException {

                if (this.transforms.isEmpty()) {

                        return null;

                }

                FeatureStoreTransform transform = (FeatureStoreTransform) this.transforms

                                .get(this.transforms.size() - 1);

                return transform.getDefaultFeatureType();

        }

        public List getFeatureTypes() throws DataException {

                if (this.transforms.isEmpty()) {

                        return null;

                }

                FeatureStoreTransform transform = (FeatureStoreTransform) this.transforms

                                .get(this.transforms.size() - 1);

                return transform.getFeatureTypes();

        }

        public PersistentState getState() throws PersistenceException {

                return AbstractPersistenceManager.getState(this);

        }

        public void loadState(PersistentState state) throws PersistenceException {

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

                Iterator iter = this.iterator();

                while (iter.hasNext()) {

                        ((FeatureStoreTransform) iter.next()).setFeatureStore(store);

                }

        }

        public void setState(PersistentState state) throws PersistenceException {

                // TODO

        }

        public FeatureStore getFeatureStore() {

                return this.store;

        }

        public void setFeatureStore(FeatureStore featureStore) {

                if (this.store != null) {

                        throw new IllegalStateException();// FIXME: A?adir tipo especifico.

                }

                this.store = (DefaultFeatureStore) featureStore;

        }

}