Application: gvSIG desktop

import java.lang.ref.WeakReference;

import java.util.Arrays;

import java.util.List;

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

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

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

import org.gvsig.tools.persistence.PersistenceException;

import org.gvsig.tools.persistence.PersistentState;

	private ExpansionAdapter expansionAdapter;

	private ArrayList deleted = new ArrayList();// <FeatureID>

	private int deltaSize = 0;

	private HashMap added = new HashMap();

	private HashMap modifiedFromOriginal = new HashMap();

	private FeatureType originalType = null;

	private boolean first = true;

	private FeatureTypeManagerFeatureStoreTransforms transforms;

	private FeatureStore store;

	public FeatureTypeManager(FeatureStore store,

			ExpansionAdapter expansionAdapter) {

		this.expansionAdapter = expansionAdapter;

		this.store = store;

		this.transforms = new FeatureTypeManagerFeatureStoreTransforms();

		this.transforms.setFeatureStore(store);

	}

	public void dispose() {

		this.expansionAdapter.close();

		this.expansionAdapter = null;

		this.deleted.clear();

		this.deleted = null;

		this.transforms.clear();

	}

	// public FeatureType delete(String id) {

	// deleted.add(id);

	// FeatureType type=(FeatureType)added.remove(id);

	// if (type==null) {

	// type=(FeatureType)modifiedFromOriginal.remove(id);

	// }

	// deltaSize--;

	// return type;

	// }

	/**

	 * DOCUMENT ME!

	 *

	 * @param feature

	 *            DOCUMENT ME!

	 */

	// public void add(FeatureType type) {

	// int pos = expansionAdapter.addObject(type);

	// added.put(type.getId(),new Integer(pos));

	// deltaSize++;

	// }

	/**

	 * DOCUMENT ME!

	 *

	 * @param id

	 *            DOCUMENT ME!

	 */

	// public void deleteLastFeatureType() {

	// expansionAdapter.deleteLastObject();

	// FeatureType

	// type=(FeatureType)expansionAdapter.getObject(expansionAdapter.getSize()-1);

	// added.remove(type.getId());

	// modifiedFromOriginal.remove(type.getId());

	// deltaSize--;

	// }

	/**

	 * DOCUMENT ME!

	 *

	 * @param id

	 *            DOCUMENT ME!

	 *

	 * @return DOCUMENT ME!

	 * @throws IsNotFeatureSettingException

	 */

	public FeatureType getType(String id) throws DataException {

		Integer intNum = ((Integer) added.get(id));

		if (intNum == null) {

			intNum = ((Integer) modifiedFromOriginal.get(id));

			if (intNum == null) {

				return null;

			}

		}

		int num = intNum.intValue();

		FeatureType type = (FeatureType) expansionAdapter.getObject(num);

		return type;

	}

	/**

	 * DOCUMENT ME!

	 *

	 * @param feature

	 *            DOCUMENT ME!

	 * @param oldFeature

	 *            DOCUMENT ME!

	 * @throws DataException

	 */

	public int update(FeatureType type, FeatureType oldType) {

		// deleted.add(oldType.getId());

		if (first) {

			originalType = oldType;

			first = false;

		}

		int oldNum = -1;

		int num = expansionAdapter.addObject(type);

		String id = type.getId();

		if (added.containsKey(id)) {

			oldNum = ((Integer) added.get(id)).intValue();

			added.put(id, new Integer(num));

		} else {

			if (modifiedFromOriginal.get(id) != null) {

				oldNum = ((Integer) modifiedFromOriginal.get(id)).intValue();

			}

			modifiedFromOriginal.put(id, new Integer(num));

		}

		try {

			this.transforms.add(new UpdateFeatureTypeTransform(this.store,

					type, oldType));

		} catch (DataException e) {

			throw new RuntimeException(); // FIXME (pero esto no deberia de

											// pasar nunca)

		}

		return oldNum;

	}

	class UpdateFeatureTypeTransform implements FeatureStoreTransform {

		private FeatureType ftSource;

		private FeatureType ftTarget;

		private WeakReference wkRefStore;

		private List ftypes = null;

		private List attrToUse;

		public UpdateFeatureTypeTransform(FeatureStore featureStore,

				FeatureType ftSource, FeatureType ftTarget) {

			this.ftSource = ftSource;

			this.ftTarget = ftTarget;

			this.wkRefStore = new WeakReference(featureStore);

			this.initializeAttributesToUse();

		}

		private void initializeAttributesToUse() {

			attrToUse = new ArrayList(ftTarget.size());

			Iterator iter = ftTarget.iterator();

			FeatureAttributeDescriptor tAttr, sAttr;

			while (iter.hasNext()) {

				tAttr = (FeatureAttributeDescriptor) iter.next();

				sAttr = this.ftSource.getAttributeDescriptor(tAttr.getName());

				if (sAttr == null){

					continue;

				}

				if (tAttr.getDataType() != sAttr.getDataType()){

					continue;

				}

				attrToUse.add(tAttr.getName());

			}

		}

		public void applyTransform(Feature source, EditableFeature target)

				throws DataException {

			Iterator iter = target.getType().iterator();

			FeatureAttributeDescriptor tAttr;

			String name;

			while (iter.hasNext()) {

				tAttr = (FeatureAttributeDescriptor) iter.next();

				name = tAttr.getName();

				if (this.attrToUse.contains(name)) {

					target.set(name, source.get(name));

				} else {

					target.set(name, tAttr.getDefaultValue());

				}

			}

		}

		public FeatureType getDefaultFeatureType() throws DataException {

			return this.ftTarget;

		}

		public FeatureStore getFeatureStore() {

			return (FeatureStore) this.wkRefStore.get();

		}

		public List getFeatureTypes() throws DataException {

			if (this.ftypes == null) {

				this.ftypes = Arrays

						.asList(new FeatureType[] { this.ftTarget });

			}

			return this.ftypes;

		}

		public FeatureType getSourceFeatureTypeFrom(

				FeatureType targetFeatureType) {

			EditableFeatureType orgType = ftSource.getEditable();

			Iterator iter = orgType.iterator();

			FeatureAttributeDescriptor attr;

			while (iter.hasNext()) {

				attr = (FeatureAttributeDescriptor) iter.next();

				if (!attrToUse.contains(attr.getName())) {

					iter.remove();

				}

			}

			return orgType.getNotEditableCopy();

		}

		public void setFeatureStore(FeatureStore featureStore) {

			this.wkRefStore = new WeakReference(featureStore);

		}

		public PersistentState getState() throws PersistenceException {

			// FIXME

			throw new UnsupportedOperationException();

		}

		public void loadState(PersistentState state)

				throws PersistenceException {

			// FIXME

			throw new UnsupportedOperationException();

		}

		public void setState(PersistentState state) throws PersistenceException {

			// FIXME

			throw new UnsupportedOperationException();

		}

	}

	 * DOCUMENT ME!

	 *

	 * @param id

	 *            DOCUMENT ME!

	 */

	public void restore(String id) {

		deleted.remove(id);

		deltaSize++;

	}

	public void restore(String id, int num) {

		if (added.containsKey(id)) {

			added.put(id, new Integer(num));

		} else {

			modifiedFromOriginal.put(id, new Integer(num));

		}

	}

	public boolean isDeleted(FeatureType type) {

		return deleted.contains(type.getId());

	}

	public boolean isDeleted(String id) {

		expansionAdapter.close();

		deleted.clear();// <FeatureID>

		deltaSize = 0;

		return added.size() > 0 || modifiedFromOriginal.size() > 0

				|| deleted.size() > 0;

	public DefaultFeatureStoreTransforms getTransforms() {

		return this.transforms;

	}

	class FeatureTypeManagerFeatureStoreTransforms extends

			DefaultFeatureStoreTransforms {

		protected void checkEditingMode() {

			return;

		}

		protected void notifyChangeToStore() {

			return;

		}

		public PersistentState getState() throws PersistenceException {

			// FIXME

			throw new UnsupportedOperationException();

		}

		public void loadState(PersistentState state)

				throws PersistenceException {

			// FIXME

			throw new UnsupportedOperationException();

		}

		public void setState(PersistentState state) throws PersistenceException {

			// FIXME

			throw new UnsupportedOperationException();

		}

	}