/ - Diff - | gvSIG desktop 1 - gvSIG

+    	}
     	public Iterator iterator() {
     		return new LongIterator(list.iterator());
     		return list.iterator();
+    	}
     	public Iterator iterator(long index) {
-...
+    		}
     		return list.listIterator((int) index);
+    	}
     	class LongIterator implements Iterator{
     		private Iterator iterator;
     		public LongIterator(Iterator iterator) {
     			this.iterator=iterator;
+    		}
     		public boolean hasNext() {
     			return iterator.hasNext();
+    		}
     		public Object next() {
     			Object obj=iterator.next();
     			if (obj instanceof Integer){
     				return new Long(((Integer)obj).longValue());
+    			}
     			return obj;
+    		}
     		public void remove() {
     			iterator.remove();
+    		}
+    	}
+    }

+    *
     * Copyright (C) 2007-2008 Infrastructures and Transports Department
     * of the Valencian Government (CIT)
+    *
+    *
     * This program is free software; you can redistribute it and/or
     * modify it under the terms of the GNU General Public License
     * as published by the Free Software Foundation; either version 2
     * of the License, or (at your option) any later version.
+    *
+    *
     * This program is distributed in the hope that it will be useful,
     * but WITHOUT ANY WARRANTY; without even the implied warranty of
     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     * GNU General Public License for more details.
+    *
+    *
     * You should have received a copy of the GNU General Public License
     * along with this program; if not, write to the Free Software
     * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
     * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
     * MA  02110-1301, USA.
+    *
+    *
     */
     /*
     * AUTHORS (In addition to CIT):
     * 2008 {{Company}}   {{Task}}
     */
     package org.gvsig.fmap.dal.feature.spi.index;
     import java.util.ArrayList;
     import java.util.Collection;
     import java.util.Iterator;
     import java.util.List;
     import java.util.ListIterator;
     import org.gvsig.fmap.dal.exception.InitializeException;
     public abstract class AbstractFeatureIndexProvider implements FeatureIndexProvider {
     	private FeatureIndexProviderServices services = null;
     	public void initialize() throws InitializeException {
+    	}
-...
     			FeatureIndexProviderServices services) {
     		this.services = services;
+    	}
     	public FeatureIndexProviderServices getFeatureIndexProviderServices() {
     		return services;
+    	}
     	protected class LongList implements java.util.List{
     		private ArrayList list;
     		public LongList(java.util.List list) {
     			this.list=(ArrayList)list;
+    		}
     		public void add(int arg0, Object arg1) {
     			list.add(arg0, arg1);
+    		}
     		public boolean add(Object arg0) {
     			return list.add(arg0);
+    		}
     		public Object set(int arg0, Object arg1) {
     			return list.set(arg0, arg1);
+    		}
     		public boolean addAll(Collection arg0) {
     			return list.addAll(arg0);
+    		}
     		public boolean addAll(int arg0, Collection arg1) {
     			return list.addAll(arg0, arg1);
+    		}
     		public void clear() {
     			list.clear();
+    		}
     		public boolean contains(Object o) {
     			return list.contains(o);
+    		}
     		public boolean containsAll(Collection arg0) {
     			return list.containsAll(arg0);
+    		}
     		public Object get(int index) {
     			Object obj=list.get(index);
     			if (obj instanceof Integer){
     				return new Long(((Integer)obj).longValue());
+    			}
     			return obj;
+    		}
     		public int indexOf(Object o) {
     			return list.indexOf(o);
+    		}
     		public boolean isEmpty() {
     			return list.isEmpty();
+    		}
     		public Iterator iterator() {
     			return new LongIterator(list.iterator());
+    		}
     		public int lastIndexOf(Object o) {
     			return list.lastIndexOf(o);
+    		}
     		public ListIterator listIterator() {
     			return list.listIterator();
+    		}
     		public ListIterator listIterator(int index) {
     			return list.listIterator(index);
+    		}
     		public boolean remove(Object o) {
     			return list.remove(o);
+    		}
     		public Object remove(int index) {
     			return list.remove(index);
+    		}
     		public boolean removeAll(Collection arg0) {
     			return list.removeAll(arg0);
+    		}
     		public boolean retainAll(Collection arg0) {
     			return list.retainAll(arg0);
+    		}
     		public int size() {
     			return list.size();
+    		}
     		public List subList(int fromIndex, int toIndex) {
     			return list.subList(fromIndex, toIndex);
+    		}
     		public Object[] toArray() {
     			return list.toArray();
+    		}
     		public Object[] toArray(Object[] arg0) {
     			return list.toArray(arg0);
+    		}
     		class LongIterator implements Iterator{
     			private Iterator iterator;
     			public LongIterator(Iterator it) {
     				iterator=it;
+    			}
     			public boolean hasNext() {
     				return iterator.hasNext();
+    			}
     			public Object next() {
     				Object obj=iterator.next();
     				if (obj instanceof Integer){
     					return new Long(((Integer)obj).longValue());
+    				}
     				return obj;
+    			}
     			public void remove() {
     				iterator.remove();
+    			}
+    		}
+    	}
+    }

     			throw new NotYetImplemented(
     					"export whith more than one type not yet implemented");
+    		}
     		FeatureSelection featureSelection=(FeatureSelection)getSelection();
     		try {
     			FeatureType type = this.getDefaultFeatureType();
     			if (params.getDefaultFeatureType() == null) {
-...
     			FeatureStore target = (FeatureStore) manager
     					.createStore(params);
     			target.edit(MODE_APPEND);
     			FeatureSet features = this.getFeatureSet();
     			FeatureSet features=null;
     			if (featureSelection.getSize()>0){
     				features = this.getFeatureSelection();
     			}else{
     				features = this.getFeatureSet();
+    			}
     			Iterator it1 = features.iterator();
     			while (it1.hasNext()) {
     				Feature feature = (Feature) it1.next();

     package org.gvsig.fmap.dal.feature.impl.join;
     import java.util.HashMap;
     import java.util.Iterator;
     import java.util.Map;
     import org.gvsig.fmap.dal.DALLocator;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.feature.AbstractFeatureStoreTransform;
     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.FeatureQuery;
     import org.gvsig.fmap.dal.feature.FeatureSet;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.tools.evaluator.Evaluator;
     import org.gvsig.tools.persistence.PersistenceException;
     import org.gvsig.tools.persistence.PersistentState;
     public class JoinTransform extends AbstractFeatureStoreTransform {
     	/**
     	 * Store from which the join transform will get the additional attributes
     	 */
     	private FeatureStore store2;
     	/**
     	 * name of the key attr in store1 that will be used to match features in
     	 * store2
     	 */
     	private String keyAttr1;
     	/**
     	 * name of the key attr in store2 that will be used to match features in
     	 * store1
     	 */
     	private String keyAttr2;
     	/**
     	 * names of the attributes to join from store2 to store1
     	 */
     	private String[] attrs;
     	/**
     	 * Attribute names may change after transformation if they are repeated in
     	 * both stores. This map keeps correspondence between store2 original names
     	 * and their transformed counterparts.
     	 */
     	private Map targetNamesMap;
     	/**
     	 * A default constructor
     	 */
     	public JoinTransform() {
     		targetNamesMap = new HashMap();
+    	}
     	/**
     	 * Initializes all the necessary data for this transform
+    	 *
     	 * @param store1
     	 *            store whose default feature type is the target of this
     	 *            transform
+    	 *
     	 * @param store2
     	 *            store whose default feature type will provide the new
     	 *            attributes to join
+    	 *
     	 * @param keyAttr1
     	 *            key attribute in store1 that matches keyAttr2 in store2
     	 *            (foreign key), used for joining both stores.
+    	 *
     	 * @param keyAttr2
     	 *            key attribute in store2 that matches keyAttr1 in store2
     	 *            (foreign key), used for joining both stores.
+    	 *
     	 * @param attrs
     	 *            names of the attributes in store2 that will be joined to
     	 *            store1.
     	 */
     	public void initialize(FeatureStore store1, FeatureStore store2,
     			String keyAttr1, String keyAttr2, String[] attrs)
     			throws DataException {
     		// Initialize needed data
     		this.setFeatureStore(store1);
     		this.store2 = store2;
     		this.keyAttr1 = keyAttr1;
     		this.keyAttr2 = keyAttr2;
     		this.attrs = attrs;
     		// calculate this transform resulting feature type
     		// by adding all specified attrs from store2 to store1's default
     		// feature type
     		EditableFeatureType type = this.getFeatureStore().getDefaultFeatureType().getEditable();
     		for (int i = 0; i < attrs.length; i++) {
     			String name = attrs[i];
     			// If an attribute already exists with the same name in store1's
     			// default feature type,
     			// calculate an alternate name and add it to our type
     			int j = 0;
     			while (type.get(name) != null) {
     				name = attrs[i] + "_" + ++j;
+    			}
     			type.add(name, store2.getDefaultFeatureType()
     					.getAttributeDescriptor(attrs[i]).getDataType());
     			// keep correspondence between original name and transformed name
     			this.targetNamesMap.put(attrs[i], name);
+    		}
     		// assign calculated feature type as this transform's feature type
     		setDefaultFeatureType(type.getNotEditableCopy());
+    	}
     	/**
+    	 *
+    	 *
     	 * @param source
+    	 *
     	 * @param target
+    	 *
     	 * @throws DataException
     	 */
     	public void applyTransform(Feature source, EditableFeature target)
     			throws DataException {
     		// copy the data from store1 into the resulting feature
     		target.copyFrom(source);
     		// ask store2 for the specified attributes, filtering by the key
     		// attribute value
     		// from the source feature
     		Evaluator eval = DALLocator.getDataManager().createExpresion(
     				keyAttr2 + "=" + source.get(keyAttr1));
     		FeatureQuery query = new FeatureQuery(attrs, eval);
     		FeatureSet set = store2.getFeatureSet(query);
     		// In this join implementation, we will take only the first matching
     		// feature found in store2
     		Iterator it = set.iterator();
     		if (it.hasNext()) {
     			Feature feat = (Feature) it.next();
     			// copy all attributes from joined feature to target
     			Iterator it2 = feat.getType().iterator();
     			while (it2.hasNext()) {
     				FeatureAttributeDescriptor attr = (FeatureAttributeDescriptor) it2
     						.next();
     				// find original attribute name
     				String targetName = (String) this.targetNamesMap.get(attr
     						.getName());
     				// copy its value to target feature attribute
     				target.set(targetName, feat.get(attr.getName()));
+    			}
+    		}
     		set.dispose();
+    	}
     	public void loadState(PersistentState state) throws PersistenceException {
     		// TODO Auto-generated method stub
+    	}
     	public void setState(PersistentState state) throws PersistenceException {
     		// TODO Auto-generated method stub
+    	}
+    }

     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.fmap.dal.feature.FeatureType;
     import org.gvsig.fmap.dal.feature.impl.expansionadapter.ExpansionAdapter;
     import org.gvsig.fmap.dal.feature.spi.FeatureData;
     import org.gvsig.fmap.geom.Geometry;
-...
          * @param feature DOCUMENT ME!
          */
         public void add(Feature feature) {
             int pos = expansionAdapter.addObject(((DefaultFeature)feature).getData());
             int pos = expansionAdapter.addObject(feature);
             added.put(feature.getReference(),new Integer(pos));
             deltaSize++;
+        }
-...
+        	}
             int num = intNum.intValue();
             FeatureData featureData=(FeatureData)expansionAdapter.getObject(num);
             Feature feature=(Feature)expansionAdapter.getObject(num);
             if (featureType== null){
             	featureType = store.getDefaultFeatureType();
+            }
            	return getCorrectFeature(featureData, store,featureType);
            	return getCorrectFeature(feature, store,featureType);
+        }
         private Feature getCorrectFeature(FeatureData featureData, FeatureStore store,
         private Feature getCorrectFeature(Feature feature, FeatureStore store,
     			FeatureType featureType) throws DataException {
         	 Iterator iterator=featureType.iterator();
              EditableFeature newFeature=store.createNewFeature(featureType, false);
              FeatureType orgType = featureData.getType();
              EditableFeature newFeature=feature.getEditable();//store.createNewFeature(featureType, false);
              FeatureType orgType = feature.getType();
              int orgIndex;
              while (iterator.hasNext()) {
      			FeatureAttributeDescriptor fad = (FeatureAttributeDescriptor) iterator.next();
-...
+     			}
      			if (featureType.getDefaultGeometryAttributeName().equals(
     									fad.getName())){
      				newFeature.setGeometry(fad.getIndex(), (Geometry)featureData.get(orgIndex));
      				newFeature.setGeometry(fad.getIndex(), (Geometry)feature.get(orgIndex));
      			} else{
      				newFeature.set(fad.getIndex(), featureData.get(orgIndex));
      				newFeature.set(fad.getIndex(), feature.get(orgIndex));
+     			}
+     		}
              return newFeature.getNotEditableCopy();
-...
     		hasnext=true;
     		if (size > pos){
     			pos++;
     			if (deleted.contains(expansionAdapter.getObject(pos))){
     			DefaultFeature obj=(DefaultFeature)expansionAdapter.getObject(pos);
     			if (deleted.contains(obj.getReference())){
     				return true;
     			}else{
     				return hasNext();
-...
     			hasnext=false;
+    		}
     		if (size > pos){
     			if (deleted.contains(expansionAdapter.getObject(pos))){
     				Object obj=expansionAdapter.getObject(pos);
     				return obj;
     			DefaultFeature obj=(DefaultFeature)expansionAdapter.getObject(pos);
     			if (deleted.contains(obj.getReference())){
     				return obj.getData();
     			}else{
     				if (hasNext()){
     					return next();
-...
     			hasnext=true;
     			pos++;
     			if (size > pos){
     				if (deleted.contains(expansionAdapter.getObject(pos))){
     				DefaultFeature obj=(DefaultFeature)expansionAdapter.getObject(pos);
     				if (deleted.contains(obj.getReference())){
     					return hasNext();
     				}else if (!added.containsValue(new Integer(pos))){
     					return hasNext();
-...
     				hasnext=false;
+    			}
     			if (size > pos){
     				if (deleted.contains(expansionAdapter.getObject(pos))){
     				DefaultFeature obj=(DefaultFeature)expansionAdapter.getObject(pos);
     				if (deleted.contains(obj.getReference())){
     					if (hasNext()){
     						return next();
+    					}
-...
     						return next();
+    					}
     				}else {
     					Object obj=expansionAdapter.getObject(pos);
     					return obj;
     					return obj.getData();
+    				}
+    			}
     			return null;
-...
     			hasnext=true;
     			if (size > pos){
     				pos++;
     				if (deleted.contains(expansionAdapter.getObject(pos))){
     				DefaultFeature obj=(DefaultFeature)expansionAdapter.getObject(pos);
     				if (deleted.contains(obj.getReference())){
     					return hasNext();
     				}else if (!modifiedFromOriginal.containsValue(new Integer(pos))){
     					return hasNext();
-...
     				hasnext=false;
+    			}
     			if (size > pos){
     				if (deleted.contains(expansionAdapter.getObject(pos))){
     				DefaultFeature obj=(DefaultFeature)expansionAdapter.getObject(pos);
     				if (deleted.contains(obj.getReference())){
     					if (hasNext()){
     						return next();
+    					}
-...
     						return next();
+    					}
     				}else {
     					Object obj=expansionAdapter.getObject(pos);
     					return obj;
     					return obj.getData();
+    				}
+    			}
     			return null;

     import org.gvsig.fmap.dal.exception.DataEvaluatorException;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.feature.Feature;
     import org.gvsig.fmap.dal.feature.impl.DefaultFeature;
     import org.gvsig.fmap.dal.feature.spi.FeatureData;
     import org.gvsig.tools.evaluator.Evaluator;
-...
     		DefaultFeature feature;
     		FeatureData data;
     		while (this.getIterator().hasNext()) {
     			data = (FeatureData) this.getIterator().next();
     			data = (FeatureData)this.getIterator().next();
     			if (isDeleted(data)) {
     				continue;
+    			}
-...
     	public boolean match(DefaultFeature feature) throws DataException {
     		try {
     			if (filter==null)
     				return true;
     			return ((Boolean) this.filter.evaluate(feature)).booleanValue();
     		} catch (EvaluatorException e) {
     			throw new DataEvaluatorException(e);

| gvSIG desktop 1

Revision 25751