/ - Diff - Application: gvSIG desktop - gvSIG

Revision 43215

     			names.add(((FeatureAttributeDescriptor) iter.next()).getName());
+    		}
     		transform.initialize(store, store2,
     		transform.setValues(store, store2,
     				"NOMBRE", "NOMBRE",
     				null, null,
     				(String[]) names.toArray(new String[0]));

     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     public class JoinTransform extends AbstractFeatureStoreTransform {
     public class JoinTransform
         extends AbstractFeatureStoreTransform {
     	private static Logger logger = LoggerFactory.getLogger(JoinTransform.class);
         private static final Logger logger = LoggerFactory.getLogger(JoinTransform.class);
         public static final String PERSISTENCE_DEFINITION_NAME = "JoinTransform";
         /**
          * Store from which the join transform will get the additional attributes
          */
-...
         private String[] attrs;
         /**
          * Attribute names may change after transformation a prefix is applied.
          * This map keeps correspondence between store1 original names
          * and their transformed counterparts.
          * Attribute names may change after transformation a prefix is applied. This
          * map keeps correspondence between store1 original names and their
          * transformed counterparts.
          */
         private Map<String,String> store1NamesMap;
         private final Map<String, String> store1NamesMap;
         /**
          * Attribute names may change after transformation if they are repeated in
          * both stores or if a prefix is applied. This map keeps correspondence
          * between store2 original names and their transformed counterparts.
          */
         private Map<String,String> store2NamesMap;
         private final Map<String, String> store2NamesMap;
         private JoinTransformEvaluator evaluator = null;
-...
          * A default constructor
          */
         public JoinTransform() {
             store1NamesMap = new HashMap<String,String>();
             store2NamesMap = new HashMap<String,String>();
             store1NamesMap = new HashMap<>();
             store2NamesMap = new HashMap<>();
+        }
         /**
          * Initializes all the necessary data for this transform
+         *
          * @param store1
          *            store whose default feature type is the target of 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 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 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 keyAttr2 key attribute in store2 that matches keyAttr1 in store2
          * (foreign key), used for joining both stores.
          * @param prefix1
          * @param prefix2
+         *
          * @param attrs
          *            names of the attributes in store2 that will be joined to
          *            store1.
          * @param attrs names of the attributes in store2 that will be joined to
          * store1.
          */
         public void initialize(FeatureStore store1, FeatureStore store2,
         public void setValues(FeatureStore store1, FeatureStore store2,
             String keyAttr1, String keyAttr2, String prefix1, String prefix2,
             String[] attrs)
         throws DataException {
             String[] attrs) {
             if (store1 == store2) {
             if( store1 == store2 ) {
                 throw new IllegalArgumentException("store1 == store2");
+            }
             // Initialize needed data
             this.setFeatureStore(store1);
             this.store2 = store2;
             this.keyAttr1 = keyAttr1;
-...
             this.prefix2 = prefix2; // TODO
             this.attrs = attrs;
+        }
         @Override
         public void setUp() throws Exception {
             // calculate this transform resulting feature type
             // by adding all specified attrs from store2 to store1's default
             // feature type
             // FIXME for more than one FTypes ??
             this.originalFeatureType = this.getFeatureStore()
             .getDefaultFeatureType();
             this.originalFeatureType = this.getFeatureStore().getDefaultFeatureType();
             // keep index of geometry and att desc ==============
             int orig_geom_field_index =
                 this.originalFeatureType.getDefaultGeometryAttributeIndex();
             FeatureAttributeDescriptor orig_geom_field_att =
                 this.originalFeatureType.getDefaultGeometryAttribute();
             int orig_geom_field_index
                 = this.originalFeatureType.getDefaultGeometryAttributeIndex();
             FeatureAttributeDescriptor orig_geom_field_att
                 = this.originalFeatureType.getDefaultGeometryAttribute();
             // Create the feature type and copy the store 1 type
             EditableFeatureType editableFeatureType = this.getFeatureStore().getDefaultFeatureType().getEditable();
             FeatureAttributeDescriptor[] featureAttributeDescriptors = editableFeatureType.getAttributeDescriptors();
             for (int i=0 ; i<featureAttributeDescriptors.length ; i++){
                 editableFeatureType.remove(featureAttributeDescriptors[i].getName());
+            }
             for( int i = 0; i < featureAttributeDescriptors.length; i++ ) {
                 editableFeatureType.remove(featureAttributeDescriptors[i].getName());
+            }
             addFeatureType(editableFeatureType, featureAttributeDescriptors, prefix1, store1NamesMap);
             // =========== set the new geom field name and restore geometry values
             if (orig_geom_field_index >= 0) {
             if( orig_geom_field_index >= 0 ) {
                 EditableFeatureAttributeDescriptor ed_att = null;
                 ed_att = (EditableFeatureAttributeDescriptor)
                     editableFeatureType.getAttributeDescriptor(orig_geom_field_index);
                 ed_att = (EditableFeatureAttributeDescriptor) editableFeatureType.getAttributeDescriptor(orig_geom_field_index);
                 ed_att.setSRS(orig_geom_field_att.getSRS());
                 ed_att.setObjectClass(orig_geom_field_att.getObjectClass());
                 ed_att.setGeometryType(orig_geom_field_att.getGeomType());
-...
             FeatureType featureType2 = store2.getDefaultFeatureType();
             // Add the fields
             for (int i = 0; i < attrs.length; i++) {
                 addFeatureType(editableFeatureType, featureType2.getAttributeDescriptor(attrs[i]), prefix2, store2NamesMap);
             for( int i = 0; i < attrs.length; i++ ) {
                 addFeatureType(editableFeatureType, featureType2.getAttributeDescriptor(attrs[i]), prefix2, store2NamesMap);
+            }
             if (this.store2NamesMap.containsKey(keyAttr2)) {
             if( this.store2NamesMap.containsKey(keyAttr2) ) {
                 this.attrsForQuery = this.attrs;
             } else {
                 List<String> list = new ArrayList<String>(this.attrs.length + 1);
                 list.addAll(Arrays.asList(this.attrs));
                 list.add(keyAttr2);
                 this.attrsForQuery = (String[]) list.toArray(new String[] {});
                 this.attrsForQuery = (String[]) list.toArray(new String[]{});
+            }
             // assign calculated feature type as this transform's feature type
             FeatureType[] types = new FeatureType[] { editableFeatureType.getNotEditableCopy() };
             FeatureType[] types = new FeatureType[]{
                 editableFeatureType.getNotEditableCopy()};
             setFeatureTypes(Arrays.asList(types), types[0]);
+        }
         private void addFeatureType(EditableFeatureType targetFeatureType, FeatureAttributeDescriptor[] featureAttributeDescriptors,
             String prefix, Map<String, String> storeMap) throws DataException{
             String prefix, Map<String, String> storeMap) throws DataException {
             for (int i=0 ; i<featureAttributeDescriptors.length ; i++){
             for( int i = 0; i < featureAttributeDescriptors.length; i++ ) {
                 addFeatureType(targetFeatureType, featureAttributeDescriptors[i], prefix, storeMap);
+            }
+        }
         private void addFeatureType(EditableFeatureType targetFeatureType, FeatureAttributeDescriptor featureAttributeDescriptor,
             String prefix, Map<String, String> storeMap) throws DataException{
             String prefix, Map<String, String> storeMap) throws DataException {
             String attName = featureAttributeDescriptor.getName();
             if ((prefix != null) && (!prefix.equals(""))){
             if( (prefix != null) && (!prefix.equals("")) ) {
                 attName = prefix + "_" + attName;
+            }
             // If an attribute already exists, calculate an alternate name and add it to our type
             int j = 0;
             while (targetFeatureType.getIndex(attName) >= 0) {
             while( targetFeatureType.getIndex(attName) >= 0 ) {
                 attName = targetFeatureType.getAttributeDescriptor(attName).getName() + "_" + ++j;
+            }
             EditableFeatureAttributeDescriptor editableFeatureAttributeDescriptor =
                 targetFeatureType.add(attName, featureAttributeDescriptor.getType(),
             EditableFeatureAttributeDescriptor editableFeatureAttributeDescriptor
                 = targetFeatureType.add(attName, featureAttributeDescriptor.getType(),
                     featureAttributeDescriptor.getSize());
             editableFeatureAttributeDescriptor.setPrecision(featureAttributeDescriptor.getPrecision());
             // keep correspondence between original name and transformed name
             storeMap.put(featureAttributeDescriptor.getName(), attName);
+        }
+        }
         /**
+         *
-...
+         *
          * @throws DataException
          */
         @Override
         public void applyTransform(Feature source, EditableFeature target)
         throws DataException {
             throws DataException {
             // copy the data from store1 into the resulting feature
             this.copySourceToTarget(source, target);
-...
                 Feature feat;
                 itFeat = set.fastIterator();
                 if (itFeat.hasNext()) {
                 if( itFeat.hasNext() ) {
                     feat = (Feature) itFeat.next();
                     // copy all attributes from joined feature to target
                     this.copyJoinToTarget(feat, target);
+                }
             } finally {
                 if (itFeat != null) {
                 if( itFeat != null ) {
                     itFeat.dispose();
+                }
                 if (set != null) {
                 if( set != null ) {
                     set.dispose();
+                }
+            }
-...
          */
         private void copyJoinToTarget(Feature join, EditableFeature target) {
             Iterator<Entry<String, String>> iter = store2NamesMap.entrySet()
             .iterator();
                 .iterator();
             Entry<String, String> entry;
             FeatureType trgType = target.getType();
             FeatureAttributeDescriptor attr;
             while (iter.hasNext()) {
             while( iter.hasNext() ) {
                 entry = iter.next();
                 attr = trgType.getAttributeDescriptor((String) entry.getValue());
                 if (attr != null) {
                 if( attr != null ) {
                     target.set(attr.getIndex(), join.get((String) entry.getKey()));
+                }
+            }
-...
             FeatureType ftSrc = source.getType();
             FeatureType ftTrg = target.getType();
             for (int i = 0; i < source.getType().size(); i++) {
             for( int i = 0; i < source.getType().size(); i++ ) {
                 attr = ftSrc.getAttributeDescriptor(i);
                 attrTrg = ftTrg.getAttributeDescriptor(store1NamesMap.get(attr.getName()));
                 if (attrTrg != null) {
                 if( attrTrg != null ) {
                     try {
                         target.set(attrTrg.getIndex(), source.get(i));
                     } catch ( SetReadOnlyAttributeException e1) {
                     } catch (SetReadOnlyAttributeException e1) {
                         // Ignore, do nothing
                     } catch (IllegalArgumentException e) {
                         attrTrg = ftTrg.getAttributeDescriptor(attr.getName());
                         target.set(attrTrg.getIndex(), attrTrg.getDefaultValue());
-...
+        }
         private JoinTransformEvaluator getEvaluator() {
             if (this.evaluator == null){
             	FeatureType ft2 = null;
             	try {
     				ft2 = this.store2.getDefaultFeatureType();
     			} catch (DataException e) {
     				logger.error("While getting feat type.", e);
+    			}
             	FeatureAttributeDescriptor att2 = ft2.getAttributeDescriptor(keyAttr2);
             	boolean is_num = att2.getDataType().isNumeric();
             if( this.evaluator == null ) {
                 FeatureType ft2 = null;
                 try {
                     ft2 = this.store2.getDefaultFeatureType();
                 } catch (DataException e) {
                     logger.warn("Can't access to the feature type to build the evaluator.", e);
                     throw new RuntimeException("Can't access to the feature type to build the evaluator.", e);
+                }
                 FeatureAttributeDescriptor att2 = ft2.getAttributeDescriptor(keyAttr2);
                 boolean is_num = att2.getDataType().isNumeric();
                 this.evaluator = new JoinTransformEvaluator(keyAttr2, is_num);
+            }
             return evaluator;
+        }
         private class JoinTransformEvaluator implements Evaluator {
         private class JoinTransformEvaluator
             implements Evaluator {
             private String attribute;
             private boolean isNumeric = false;
-...
             private EvaluatorFieldsInfo info = null;
             //		private int attributeIndex;
             public JoinTransformEvaluator(String attribute, boolean is_numeric) {
                 this.attribute = attribute;
                 this.isNumeric = is_numeric;
-...
                 this.info.addMatchFieldValue(this.attribute, value);
+            }
             @Override
             public Object evaluate(EvaluatorData arg0) throws EvaluatorException {
                 Object curValue = arg0.getDataValue(attribute);
                 if (curValue == null) {
                 if( curValue == null ) {
                     return value == null;
+                }
                 return curValue.equals(value);
+            }
             @Override
             public String getSQL() {
                 return this.sql;
+            }
             @Override
             public String getDescription() {
                 return "Evaluates join transform match";
+            }
             @Override
             public String getName() {
                 return "JoinTransformEvaluator";
+            }
             @Override
             public EvaluatorFieldsInfo getFieldsInfo() {
                 return this.info;
+            }
+        }
+        }
         @SuppressWarnings("unchecked")
         @Override
         public FeatureType getSourceFeatureTypeFrom(FeatureType arg0) {
             return originalFeatureType;
+        }
         public boolean isTransformsOriginalValues() {
             return false;
+        }
         public static void registerPersistent() {
             PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();
-...
             DynStruct definition = persistenceManager.getDefinition(PERSISTENCE_DEFINITION_NAME);
             if (definition == null){
             if( definition == null ) {
                 definition = persistenceManager.addDefinition(
                     JoinTransform.class,
                     PERSISTENCE_DEFINITION_NAME,
                     "JoinTransform Persistence definition",
                     null,
                     null,
                     null
                 );
                 definition.extend(PersistenceManager.PERSISTENCE_NAMESPACE,
-...
+            }
+        }
         @Override
         public void saveToState(PersistentState state) throws PersistenceException {
             super.saveToState(state);
             state.set("store2", this.store2);
             state.set("keyAttr1", this.keyAttr1);
             state.set("keyAttr2", this.keyAttr2);
             state.set("prefix1", this.prefix1);
             state.set("prefix2", this.prefix2);
             state.set("prefix2", this.prefix2);
             state.set("attrs", this.attrs);
+        }
         @Override
         public void loadFromState(PersistentState state) throws PersistenceException {
             super.loadFromState(state);
             FeatureStore store2 = (FeatureStore) state.get("store2");
             String keyAttr1 = state.getString("keyAttr1");
             String keyAttr2 = state.getString("keyAttr2");
             String prefix1 =  state.getString("prefix1");
             String prefix2 =  state.getString("prefix2");
             String[] attrs = (String[]) state.getArray("attrs", String.class);
             try {
                 initialize(getFeatureStore(), store2, keyAttr1, keyAttr2, prefix1, prefix2, attrs);
             } catch (DataException e) {
                 throw new PersistenceException("Impossible to create the transform", e);
+            }
             store2 = (FeatureStore) state.get("store2");
             keyAttr1 = state.getString("keyAttr1");
             keyAttr2 = state.getString("keyAttr2");
             prefix1 = state.getString("prefix1");
             prefix2 = state.getString("prefix2");
             attrs = (String[]) state.getArray("attrs", String.class);
+        }
+    }

     	public FeatureStoreTransform createFeatureStoreTransform(
     			FeatureStore featureStore) throws DataException {
     		JoinTransform transform = new JoinTransform();
     		transform.initialize(featureStore,
     				secondDataStoreWizard.getSelectedFeatureStore(),
     				parametersWizard.getKeyAttr1(),
     				parametersWizard.getkeyAtrr2(),
     				parametersWizard.getPrefix1(),
     				parametersWizard.getPrefix2(),
     				parametersWizard.getAttributes()
     		transform.setValues(
                         featureStore,
                         secondDataStoreWizard.getSelectedFeatureStore(),
                         parametersWizard.getKeyAttr1(),
                         parametersWizard.getkeyAtrr2(),
                         parametersWizard.getPrefix1(),
                         parametersWizard.getPrefix2(),
                         parametersWizard.getAttributes()
     		);
     		return transform;
+    	}

     		FeatureStore store = (FeatureStore) dataManager.openStore("DBF",
     		    this.getDefaultDataStoreParameters());
     		EventThemeTransform transform = new EventThemeTransform();
     		transform.initialize(store, geometryFieldName, xFieldName, yFieldName,
     		transform.setValues(store, geometryFieldName, xFieldName, yFieldName,
     				CRSFactory.getCRS(projection));
     		return transform;
+    	}

     	public FeatureStoreTransform createFeatureStoreTransform(
     			FeatureStore featureStore) throws DataException {
     		EventThemeTransform transform = new EventThemeTransform();
     		transform.initialize(featureStore,
     				panel.getGeometryName(),
     				panel.getXName(),
     				panel.getYName(),
     				panel.getProjection());
     		transform.setValues(
                         featureStore,
                         panel.getGeometryName(),
                         panel.getXName(),
                         panel.getYName(),
                         panel.getProjection()
                     );
     		return transform;
+    	}

      * AUTHORS (In addition to CIT):
      * 2009 {Iver T.I.}   {Task}
      */
     package org.gvsig.app.eventtheme.dal.feature;
     import java.util.Arrays;
     import javax.swing.JOptionPane;
     import org.apache.commons.lang3.StringUtils;
     import org.cresques.cts.IProjection;
-...
     import org.slf4j.LoggerFactory;
     /**
      * This class implements a transformation for a events theme. The original
      * {@link DataStore} have to have a couple of attributes, one with the X
      * coordinate and the second one with the Y coordinate. The result of
      * the transformation is a {@link DataStore} that has a new geometric
      * attribute and its value is a point with the coordinates specified in
      * the original {@link DataStore}.
      * This class implements a transformation for a events theme. The original
      * {@link DataStore} have to have a couple of attributes, one with the X
      * coordinate and the second one with the Y coordinate. The result of the
      * transformation is a {@link DataStore} that has a new geometric attribute and
      * its value is a point with the coordinates specified in the original
      * {@link DataStore}.
+     *
      * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>
      */
     public class EventThemeTransform extends AbstractFeatureStoreTransform {
     public class EventThemeTransform
         extends AbstractFeatureStoreTransform {
     	private static Logger logger = LoggerFactory.getLogger(
     			EventThemeTransform.class);
         private static Logger logger = LoggerFactory.getLogger(
             EventThemeTransform.class);
         public static final String PERSISTENCE_DEFINITION_NAME = "EventThemeTransform";
         /**
          * Max number of features used for initial estimation
          * of extent. Many other features will be ignored
          * simply with "iter.next()"
          * Max number of features used for initial estimation of extent. Many other
          * features will be ignored simply with "iter.next()"
          */
         public static int MAX_INI_FEATURES = 200;
-...
         private String geometryFieldName = null;
         private IProjection projection = null;
         private FeatureType originalFeatureType;
         private GeometryManager geometryManager = GeometryLocator.getGeometryManager();
         private GeometryManager geometryManager = GeometryLocator.getGeometryManager();
         private Envelope envelope;
         public EventThemeTransform() {
-...
+        }
         /**
          * This method initializes the transformation, sets the name of the parameters and
          * sets the value of the {@link FeatureType} returned by the transformation.
          * @param store
          * The original store.
          * @param geometryFieldName
          * The field that contains the geometric attribute.
          * @param xFieldName
          * The field that contains the X coordinate.
          * @param yFieldName
          * The field that contains the Y coordinate.
          * This method initializes the transformation, sets the name of the
          * parameters and sets the value of the {@link FeatureType} returned by the
          * transformation.
+         *
          * @param store The original store.
          * @param geometryFieldName The field that contains the geometric attribute.
          * @param xFieldName The field that contains the X coordinate.
          * @param yFieldName The field that contains the Y coordinate.
          * @param projection
          * @throws DataException
          */
         public void initialize(
         		FeatureStore store,
         		String geometryFieldName,
         		String xFieldName,
         		String yFieldName,
         		IProjection projection) throws DataException{
         public void setValues(
             FeatureStore store,
             String geometryFieldName,
             String xFieldName,
             String yFieldName,
             IProjection projection) throws DataException {
             setFeatureStore(store);
             this.xFieldName = xFieldName;
             this.yFieldName = yFieldName;
             this.projection = projection;
             if ((geometryFieldName == null) || (geometryFieldName.equals(""))){
             if( StringUtils.isEmpty(geometryFieldName) ) {
                 this.geometryFieldName = "the_geom";
             }else{
             } else {
                 this.geometryFieldName = geometryFieldName;
+            }
+        }
         @Override
         public void setUp() throws Exception {
             this.originalFeatureType = this.getFeatureStore()
             .getDefaultFeatureType();
                 .getDefaultFeatureType();
             EditableFeatureType type = originalFeatureType.getEditable();
             if (type.get(this.geometryFieldName) == null){
                 EditableFeatureAttributeDescriptor attributeDescriptor = type.add(this.geometryFieldName,  DataTypes.GEOMETRY);
             if( type.get(this.geometryFieldName) == null ) {
                 EditableFeatureAttributeDescriptor attributeDescriptor = type.add(this.geometryFieldName, DataTypes.GEOMETRY);
                 try {
                     attributeDescriptor.setGeometryType(geometryManager.getGeometryType(TYPES.POINT, SUBTYPES.GEOM2D));
                 } catch (GeometryTypeNotSupportedException e) {
                     throw new InitializeException(e);
                 } catch (GeometryTypeNotValidException e) {
                     throw new InitializeException(e);
+                }
+                }
                 attributeDescriptor.setSRS(projection);
+            }
-...
                 /*
                  * creates and updates envelope with all features
                  */
                 initEnvelope(store, MAX_INI_FEATURES);
                 initEnvelope(this.getFeatureStore(), MAX_INI_FEATURES);
             } catch (CreateEnvelopeException e) {
                 throw new org.gvsig.fmap.dal.feature.exception.CreateGeometryException(e);
+            }
             type.setDefaultGeometryAttributeName(this.geometryFieldName);
             FeatureType[] types = new FeatureType[] { type.getNotEditableCopy() };
             FeatureType[] types = new FeatureType[]{type.getNotEditableCopy()};
             setFeatureTypes(Arrays.asList(types), types[0]);
+        }
         /**
          * creates and updates envelope with all features
+         *
+         *
          */
         private void initEnvelope(FeatureStore fsto, int max_feats) throws CreateEnvelopeException {
             envelope = geometryManager.createEnvelope(SUBTYPES.GEOM2D);
             FeatureSet fset = null;
             DisposableIterator diter = null;
-...
             try {
                 fset = fsto.getFeatureSet();
                 diter = fset.fastIterator();
                 // int count = 0;
                 int countused = 0;
                 int nextwait = 1;
                 int index = 0;
                 while (diter.hasNext() && (countused < max_feats)) {
                 while( diter.hasNext() && (countused < max_feats) ) {
                     feat = (Feature) diter.next();
                     /*
                      * This loop will use about 70 features from the first
-...
                      * so it's not very important.
                      */
                     index++;
                     if (index == nextwait) {
                     	index = 0;
                     	/*
                     if( index == nextwait ) {
                         index = 0;
                         /*
                     	 * This causes that the first 5 features
                     	 * will always be used.
                     	 */
                     	if (countused > 5) {
                         	nextwait++;
+                    	}
                     	this.updateEnvelope(feat);
                     	countused++;
                          */
                         if( countused > 5 ) {
                             nextwait++;
+                        }
                         this.updateEnvelope(feat);
                         countused++;
+                    }
                     // count++;
+                }
                 diter.dispose();
             } catch (Exception dex) {
                 throw new CreateEnvelopeException(SUBTYPES.GEOM2D, dex);
+            }
+        }
         public void setEnvelope(Envelope env) {
         	this.envelope = env;
             this.envelope = env;
+        }
         /*
          * Currently not used
          */
         private void launchFullExtentThread(DisposableIterator diter) {
         	ComputeExtentTask task = new ComputeExtentTask(diter, this);
         	task.start();
+    	}
     	/* (non-Javadoc)
          * @see org.gvsig.fmap.dal.feature.FeatureStoreTransform#applyTransform(org.gvsig.fmap.dal.feature.Feature, org.gvsig.fmap.dal.feature.EditableFeature)
          */
             ComputeExtentTask task = new ComputeExtentTask(diter, this);
             task.start();
+        }
         @Override
         public void applyTransform(Feature source, EditableFeature target)
         throws DataException {
             throws DataException {
             this.copySourceToTarget(source, target);
             try {
                 Geometry point = null;
                 Geometry point;
                 Object xval = source.get(xFieldName);
                 Object yval = source.get(yFieldName);
                 if (xval == null || yval == null) {
                 if( xval == null || yval == null ) {
                     logger.info("Found row with null coordinates in event theme (created null geometry)");
                     target.set(geometryFieldName, null);
                     target.setDefaultGeometry(null);
                     target.setDefaultGeometry(null);
                 } else {
                     point = geometryManager.createPoint(
                         new Double(xval.toString()),
                         new Double(yval.toString()),
                         SUBTYPES.GEOM2D);
                     target.set(geometryFieldName, point);
                     target.setDefaultGeometry(point);
                     target.setDefaultGeometry(point);
                     envelope.add(point.getEnvelope());
+                }
             } catch ( SetReadOnlyAttributeException e1) {
             } catch (SetReadOnlyAttributeException e1) {
                 // Do nothing
             } catch (Exception e) {
                 throw new org.gvsig.fmap.dal.feature.exception.CreateGeometryException(
                     TYPES.POINT, SUBTYPES.GEOM2D, e);
+            }
+            }
+        }
         /**
          * Used internally to initialize envelope
+         *
+         *
          */
         private void updateEnvelope(Feature feat) throws CreateGeometryException {
-...
             FeatureType ftSrc = source.getType();
             FeatureType ftTrg = target.getType();
             for (int i = 0; i < source.getType().size(); i++) {
             for( int i = 0; i < source.getType().size(); i++ ) {
                 attr = ftSrc.getAttributeDescriptor(i);
                 if (ftTrg.getIndex(attr.getName()) > -1) {
                 if( ftTrg.getIndex(attr.getName()) > -1 ) {
                     try {
                         target.set(attr.getName(), source.get(i));
                     } catch (IllegalArgumentException e) {
-...
+        }
         /* (non-Javadoc)
          * @see org.gvsig.fmap.dal.feature.FeatureStoreTransform#getSourceFeatureTypeFrom(org.gvsig.fmap.dal.feature.FeatureType)
          */
         @Override
         public FeatureType getSourceFeatureTypeFrom(FeatureType targetFeatureType) {
             return this.originalFeatureType;
+        }
         /* (non-Javadoc)
          * @see org.gvsig.fmap.dal.feature.FeatureStoreTransform#isTransformsOriginalValues()
          */
         @Override
         public boolean isTransformsOriginalValues() {
             return true;
+        }
-...
             DynStruct definition = persistenceManager.getDefinition(PERSISTENCE_DEFINITION_NAME);
             if (definition == null){
             if( definition == null ) {
                 definition = persistenceManager.addDefinition(
                     EventThemeTransform.class,
                     PERSISTENCE_DEFINITION_NAME,
                     "EventThemeTransform Persistence definition",
                     null,
                     null,
                     null
                 );
                 definition.extend(PersistenceManager.PERSISTENCE_NAMESPACE,
-...
+            }
+        }
         /* (non-Javadoc)
          * @see org.gvsig.tools.persistence.Persistent#saveToState(org.gvsig.tools.persistence.PersistentState)
          */
         @Override
         public void saveToState(PersistentState state) throws PersistenceException {
             super.saveToState(state);
             state.set("geometryFieldName", this.geometryFieldName);
             state.set("xFieldName", this.xFieldName);
             state.set("yFieldName", this.yFieldName);
             state.set("projection", this.projection);
             state.set("projection", this.projection);
+        }
         /* (non-Javadoc)
          * @see org.gvsig.tools.persistence.Persistent#loadFromState(org.gvsig.tools.persistence.PersistentState)
          */
         @Override
         public void loadFromState(PersistentState state)
         throws PersistenceException {
             super.loadFromState(state);
             String geometryFieldName = state.getString("geometryFieldName");
             String xFieldName = state.getString("xFieldName");
             String yFieldName = state.getString("yFieldName");
             IProjection projection =  (IProjection)state.get("projection");
             try {
                 initialize(getFeatureStore(), geometryFieldName, xFieldName, yFieldName, projection);
             } catch (DataException e) {
                 throw new PersistenceException("Impossible to create the transform", e);
+            }
             throws PersistenceException {
             super.loadFromState(state);
             geometryFieldName = state.getString("geometryFieldName");
             xFieldName = state.getString("xFieldName");
             yFieldName = state.getString("yFieldName");
             projection = (IProjection) state.get("projection");
+        }
         @Override
         public Object getDynValue(String name) throws DynFieldNotFoundException {
             if (DataStore.METADATA_CRS.equals(name)){
             if( DataStore.METADATA_CRS.equals(name) ) {
                 return projection;
             }else if(DataStore.METADATA_ENVELOPE.equals(name)){
             } else if( DataStore.METADATA_ENVELOPE.equals(name) ) {
                 return envelope;
+            }
             return null;
+        }
         @Override
         public boolean hasDynValue(String name) {
             return ((DataStore.METADATA_CRS.equals(name)) ||
                 (DataStore.METADATA_ENVELOPE.equals(name)));
+        }
             return ((DataStore.METADATA_CRS.equals(name))
                 || (DataStore.METADATA_ENVELOPE.equals(name)));
+        }
         /**
+         *
+         *
          * A thread to compute the true extent (in case it has a lot of features)
          * Currently not used.
+         *
+         *
          * @author jldominguez
+         *
+         *
          * @deprecated This is not used because it causes issues with
          * ConsurrentModificationException because the store is notified of
          * a change (the transformation). Anyway, this is not very important I think.
          * ConsurrentModificationException because the store is notified of a change
          * (the transformation). Anyway, this is not very important I think.
          */
         private class ComputeExtentTask extends AbstractMonitorableTask {
         	private DisposableIterator disp_iter = null;
         	private EventThemeTransform tra_toupdate = null;
         	public ComputeExtentTask(DisposableIterator diter, EventThemeTransform ettra) {
         		/*
         private class ComputeExtentTask
             extends AbstractMonitorableTask {
             private DisposableIterator disp_iter = null;
             private EventThemeTransform tra_toupdate = null;
             public ComputeExtentTask(DisposableIterator diter, EventThemeTransform ettra) {
                 /*
         		 * Auto-added by task manager
         		 */
         		super(Messages.getText("_Extent_of_event_theme"), true);
         		disp_iter = diter;
         		tra_toupdate = ettra;
+        	}
         	public void run() {
                  */
                 super(Messages.getText("_Extent_of_event_theme"), true);
                 disp_iter = diter;
                 tra_toupdate = ettra;
+            }
         		Envelope env = null;
         		Feature feat = null;
         		Point point = null;
         		int count = 99;
         		try {
                     while (disp_iter.hasNext()) {
             public void run() {
                 Envelope env = null;
                 Feature feat = null;
                 Point point = null;
                 int count = 99;
                 try {
                     while( disp_iter.hasNext() ) {
                         feat = (Feature) disp_iter.next();
                         point = geometryManager.createPoint(
                                 Double.parseDouble(feat.get(xFieldName).toString()),
                                 Double.parseDouble(feat.get(yFieldName).toString()),
                                 SUBTYPES.GEOM2D);
                         if (env == null) {
                         	env = (Envelope) point.getEnvelope().clone();
                             Double.parseDouble(feat.get(xFieldName).toString()),
                             Double.parseDouble(feat.get(yFieldName).toString()),
                             SUBTYPES.GEOM2D);
                         if( env == null ) {
                             env = (Envelope) point.getEnvelope().clone();
                         } else {
                         	env.add(point.getEnvelope());
                             env.add(point.getEnvelope());
+                        }
                         count++;
                         Thread.sleep(10);
                         if (count % 100 == 0) {
                         	System.out.println("COUNT = " + count);
                         if( count % 100 == 0 ) {
                             System.out.println("COUNT = " + count);
+                        }
+                    }
         		} catch (Exception exc) {
         			ApplicationLocator.getManager().message(
         					Messages.getText("_Error_while_getting_extent"),
         					JOptionPane.ERROR_MESSAGE);
         			logger.info("Error while getting extent in thread.", exc);
+        		}
         		disp_iter.dispose();
         		// =================
         		if (env != null) {
         			Envelope curr_env = (Envelope) tra_toupdate.getDynValue(
         					DataStore.METADATA_ENVELOPE);
         			curr_env.add(env);
+        		}
         		// =========== End
         		TaskStatusManager man = this.getTaskStatus().getManager();
         		man.remove(this.getTaskStatus());
+        	}
                 } catch (Exception exc) {
                     ApplicationLocator.getManager().message(
                         Messages.getText("_Error_while_getting_extent"),
                         JOptionPane.ERROR_MESSAGE);
                     logger.info("Error while getting extent in thread.", exc);
+                }
                 disp_iter.dispose();
                 // =================
                 if( env != null ) {
                     Envelope curr_env = (Envelope) tra_toupdate.getDynValue(
                         DataStore.METADATA_ENVELOPE);
                     curr_env.add(env);
+                }
                 // =========== End
                 TaskStatusManager man = this.getTaskStatus().getManager();
                 man.remove(this.getTaskStatus());
+            }
+        }
+    }

     	   	IconThemeHelper.registerIcon("layer", "layer-icon", ViewManager.class);
     	   	IconThemeHelper.registerIcon("layer", "layer-icon-group", ViewManager.class);
     	   	IconThemeHelper.registerIcon("layer", "layer-icon-vectorial", ViewManager.class);
     	   	IconThemeHelper.registerIcon("layer", "layer-icon-csv", ViewManager.class);
     	   	IconThemeHelper.registerIcon("layer", "layer-icon-dgn", ViewManager.class);
     	   	IconThemeHelper.registerIcon("layer", "layer-icon-dxf", ViewManager.class);
     	   	IconThemeHelper.registerIcon("layer", "layer-icon-postgresql", ViewManager.class);
-...
     	   	IconThemeHelper.registerIcon("legend", "legend-overview-vectorial-unique-value", ViewManager.class);
     	   	MapContextManager mapContextMgr = MapContextLocator.getMapContextManager();
     	   	mapContextMgr.registerIconLayer("CSV", "layer-icon-csv");
     	   	mapContextMgr.registerIconLayer("DGN", "layer-icon-dgn");
     	   	mapContextMgr.registerIconLayer("DXF", "layer-icon-dxf");
     	   	mapContextMgr.registerIconLayer("jdbc", "layer-icon-jdbc");

     import java.awt.event.ActionEvent;
     import java.awt.event.ActionListener;
     import java.util.ArrayList;
     import java.util.HashSet;
     import java.util.List;
     import java.util.Set;
     import org.apache.commons.lang3.exception.ExceptionUtils;
-...
     import org.gvsig.fmap.mapcontrol.swing.dynobject.DynObjectEditor;
     import org.gvsig.tools.ToolsLocator;
     import org.gvsig.tools.i18n.I18nManager;
     import org.gvsig.tools.util.impl.CallableException;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     public class LayerErrorsPanel extends LayerErrorsView {
     public class LayerErrorsPanel
         extends LayerErrorsView {
         private static final Logger logger = LoggerFactory.getLogger(LayerErrorsPanel.class);
         private static final long serialVersionUID = -5972995402218954892L;
-...
             this.setPreferredSize(new Dimension(550, 400));
+        }
         public void setName(String name){
         @Override
         public void setName(String name) {
             this.txtLayerName.setText(name);
+        }
         public void setError(Exception e){
             List<Exception> exs = new ArrayList<Exception>();
         public void setError(Throwable e) {
             List<Throwable> exs = new ArrayList<>();
             exs.add(e);
             this.txtMessage.setText(this.getMessageAsHTML(exs));
             this.txtMessage.setText(new MessageAsHTML(exs).toString());
             this.btnViewParameters.setEnabled(false);
+        }
         public void setLayer(FLayer layer) {
             this.layer = layer;
             setName(layer.getName());
             this.txtMessage.setText(this.getMessageAsHTML(layer.getErrors()));
             this.txtMessage.setText(new MessageAsHTML(layer.getErrors()).toString());
             this.btnViewParameters.setEnabled(this.layer instanceof SingleLayer);
+        }
         private String getMessageAsHTML(List<Exception> exs) {
             StringBuilder html = new StringBuilder();
             //html.append("<html>\n");
             for (Exception ex : exs) {
                 String lastmsg = "";
                 html.append("<ul>\n");
                 for( Throwable cause : ExceptionUtils.getThrowableList(ex) ) {
                     String message = cause.getMessage();
                     if (message != null) {
                         if (!message.equalsIgnoreCase(lastmsg)) {
                             lastmsg = message;
                             html.append("<li>");
                             html.append(message.replace("\n", "<br>\n"));
                             html.append("</li>\n");
         private class MessageAsHTML {
             StringBuilder html;
             Set<String> usedMsgs;
             public MessageAsHTML(List<Throwable> exs) {
                 this.clear();
                 this.build(exs);
+            }
             public MessageAsHTML() {
                 this.clear();
+            }
             public void clear() {
                 this.html = new StringBuilder();
                 this.usedMsgs = new HashSet<>();
+            }
             public void build(List<Throwable> exs) {
                 for( Throwable ex : exs ) {
     //                html.append("<ul>\n");
                     List<Throwable> causes = new ArrayList<>();
                     causes.addAll(ExceptionUtils.getThrowableList(ex));
                     if( ex instanceof List ) {
                         causes.addAll((List<Throwable>) ex);
+                    }
                     for( Throwable cause : causes ) {
                         if( cause instanceof List ) {
                             continue;
+                        }
                         if( cause instanceof CallableException ) {
                             cause = ((CallableException) cause).getCause();
+                        }
                         if( cause == null ) {
                             continue;
+                        }
                         String message = cause.getMessage();
                         if( message != null ) {
                             if( !this.usedMsgs.contains(message) ) {
                                 this.usedMsgs.add(message);
                                 html.append("<li>");
                                 html.append(message.replace("\n", "<br>\n"));
                                 if( cause.getCause() != null ) {
                                     this.build(ExceptionUtils.getThrowableList(
                                         cause.getCause()));
+                                }
                                 html.append("</li>\n");
+                            }
+                        }
+                    }
     //                html.append("</ul>\n");
+                }
                 html.append("</ul><br>\n");
+            }
             //html.append("</html>\n");
             return html.toString();
             @Override
             public String toString() {
                 return "<ul>\n" + html.toString() + "</ul>\n";
+            }
+        }
         private void translate() {
-...
         private void doViewParameters() {
             try {
                 DynObjectEditor editor = new DynObjectEditor( ((SingleLayer)layer).getDataStore().getParameters() );
                 DynObjectEditor editor = new DynObjectEditor(
                     ((SingleLayer) layer).getDataStore().getParameters()
                 );
                 editor.editObject(true);
             } catch (Throwable th) {
                 logger.warn("Can't show standard properties dialog for this parameters.",th);
                 logger.warn(
                     "Can't show standard properties dialog for this parameters.",
                     th);
+            }
+        }

      * For any additional information, do not hesitate to contact us
      * at info AT gvsig.com, or visit our website www.gvsig.com.
      */
     package org.gvsig.app.project.documents.view.legend.gui;
     import java.awt.BorderLayout;
-...
     import org.gvsig.symbology.swing.SymbologySwingManager;
     import org.gvsig.utils.swing.JComboBox;
     /**
+     *
      * @author jaume dominguez faus - jaume.dominguez@iver.es
+     *
      */
     public class LabelingManager extends AbstractThemeManagerPage implements ActionListener {
     	private static final long serialVersionUID = 856162295985695717L;
     public class LabelingManager
         extends AbstractThemeManagerPage
         implements ActionListener {
         private static final long serialVersionUID = 856162295985695717L;
     //	private static ArrayList<Class<? extends ILabelingStrategyPanel>> installedPanels = new ArrayList<Class<? extends ILabelingStrategyPanel>>();
     	private Comparator<Class<?>> comparator=new Comparator<Class<?>>(){
         private Comparator<Class<?>> comparator = new Comparator<Class<?>>() {
     		public int compare(Class<?> o1, Class<?> o2) {
     			return o1.getSimpleName().compareTo(o2.getSimpleName());
+    		}
             public int compare(Class<?> o1, Class<?> o2) {
                 return o1.getSimpleName().compareTo(o2.getSimpleName());
+            }
     	};
     	private TreeMap<Class<?>, ILabelingStrategyPanel> strategyPanels =
     			new TreeMap<Class<?>, ILabelingStrategyPanel>(comparator);
         };
         private TreeMap<Class<?>, ILabelingStrategyPanel> strategyPanels
             = new TreeMap<Class<?>, ILabelingStrategyPanel>(comparator);
     	private JCheckBox chkApplyLabels;
     	private ILabelable layer;
     	private JPanel content;
     	private JPanel pnlNorth;
     	private JComboBox cmbStrategy;
         private JCheckBox chkApplyLabels;
         private ILabelable layer;
         private JPanel content;
         private JPanel pnlNorth;
         private JComboBox cmbStrategy;
         public LabelingManager() {
             super();
             initialize();
+        }
     	public LabelingManager() {
     		super();
     		initialize();
+    	}
         private class LabelingStrategyItem {
     	private class LabelingStrategyItem {
     		private ILabelingStrategyPanel strategyPanel;
             private ILabelingStrategyPanel strategyPanel;
     		private LabelingStrategyItem(ILabelingStrategyPanel strategyPanel) {
     			this.strategyPanel = strategyPanel;
+    		}
             private LabelingStrategyItem(ILabelingStrategyPanel strategyPanel) {
                 this.strategyPanel = strategyPanel;
+            }
     		public String toString() {
     			return strategyPanel.getLabelingStrategyName();
+    		}
             public String toString() {
                 return strategyPanel.getLabelingStrategyName();
+            }
     		public boolean equals(Object obj) {
     			if (obj instanceof LabelingStrategyItem) {
     				LabelingStrategyItem item = (LabelingStrategyItem) obj;
     				return this.strategyPanel.getClass().equals(item.strategyPanel.getClass());
             public boolean equals(Object obj) {
                 if( obj instanceof LabelingStrategyItem ) {
                     LabelingStrategyItem item = (LabelingStrategyItem) obj;
                     return this.strategyPanel.getClass().equals(item.strategyPanel.getClass());
+    			}
     			return super.equals(obj);
+    		}
+                }
                 return super.equals(obj);
+            }
+    	}
+        }
     	 @Override
     	    public int getPriority() {
     	    	return 600;
+    	    }
         @Override
         public int getPriority() {
             return 600;
+        }
     	private void initialize() {
     		setLayout(new BorderLayout());
                     SymbologySwingManager symbologySwingManager = SymbologySwingLocator.getSwingManager();
         private void initialize() {
             setLayout(new BorderLayout());
             SymbologySwingManager symbologySwingManager = SymbologySwingLocator.getSwingManager();
                     Iterator<ILabelingStrategyPanel> it = symbologySwingManager.getLabelingEditors().iterator();
                     while( it.hasNext() ) {
                         ILabelingStrategyPanel pnl = it.next();
                         strategyPanels.put(pnl.getLabelingStrategyClass(), pnl);
+    		}
     		content = new JPanel(new BorderLayout());
     		content.setBorder(BorderFactory.createEtchedBorder());
     		add(getPnlNorth(), BorderLayout.NORTH);
     		add(content, BorderLayout.SOUTH);
             Iterator<ILabelingStrategyPanel> it = symbologySwingManager.getLabelingEditors().iterator();
             while( it.hasNext() ) {
                 ILabelingStrategyPanel pnl = it.next();
                 strategyPanels.put(pnl.getLabelingStrategyClass(), pnl);
+            }
             content = new JPanel(new BorderLayout());
             content.setBorder(BorderFactory.createEtchedBorder());
             add(getPnlNorth(), BorderLayout.NORTH);
             add(content, BorderLayout.SOUTH);
+    	}
+        }
     	private JPanel getPnlNorth() {
     		if (pnlNorth == null) {
     			pnlNorth = new JPanel(new BorderLayout(5,5));
     			JPanel aux = new JPanel(new FlowLayout(FlowLayout.LEFT));
         private JPanel getPnlNorth() {
             if( pnlNorth == null ) {
                 pnlNorth = new JPanel(new BorderLayout(5, 5));
                 JPanel aux = new JPanel(new FlowLayout(FlowLayout.LEFT));
     			aux.add(getChkApplyLabels());
     			pnlNorth.add(aux, BorderLayout.NORTH);
     			aux = new JPanel(new FlowLayout(FlowLayout.LEFT));
     			aux.add(new JLabel(PluginServices.getText(this, "general")+":"));
     			aux.add(getCmbStrategy());
     			pnlNorth.add(aux, BorderLayout.CENTER);
                 aux.add(getChkApplyLabels());
                 pnlNorth.add(aux, BorderLayout.NORTH);
                 aux = new JPanel(new FlowLayout(FlowLayout.LEFT));
                 aux.add(new JLabel(PluginServices.getText(this, "general") + ":"));
                 aux.add(getCmbStrategy());
                 pnlNorth.add(aux, BorderLayout.CENTER);
+    		}
     		return pnlNorth;
+    	}
+            }
             return pnlNorth;
+        }
     	private JComboBox getCmbStrategy() {
     		if (cmbStrategy == null) {
     			Iterator<ILabelingStrategyPanel> it = strategyPanels.values().iterator();
     			final ArrayList<LabelingStrategyItem> aux = new ArrayList<LabelingStrategyItem>();
     			while (it.hasNext()) {
     				aux.add(new LabelingStrategyItem(it.next()));
+    			}
     			final LabelingStrategyItem items[] = aux.toArray(new LabelingStrategyItem[aux.size()]);
         private JComboBox getCmbStrategy() {
             if( cmbStrategy == null ) {
                 Iterator<ILabelingStrategyPanel> it = strategyPanels.values().iterator();
                 final ArrayList<LabelingStrategyItem> aux = new ArrayList<LabelingStrategyItem>();
                 while( it.hasNext() ) {
                     aux.add(new LabelingStrategyItem(it.next()));
+                }
                 final LabelingStrategyItem items[] = aux.toArray(new LabelingStrategyItem[aux.size()]);
     			cmbStrategy = new JComboBox(items) {
     				private static final long serialVersionUID = 7506754097091500846L;
                 cmbStrategy = new JComboBox(items) {
                     private static final long serialVersionUID = 7506754097091500846L;
     				@Override
     				public void setSelectedItem(Object anObject) {
     					if (anObject == null)
     						return;
     					if (anObject instanceof ILabelingStrategy) {
     						ILabelingStrategy st = (ILabelingStrategy) anObject;
     						for (ILabelingStrategyPanel pnl : strategyPanels.values()) {
     							if (pnl.getLabelingStrategyClass() != null &&
     								pnl.getLabelingStrategyClass().equals(st.getClass())) {
     								super.setSelectedItem(new LabelingStrategyItem(pnl));
     								return;
+    							}
+    						}
     					} else {
     						super.setSelectedItem(anObject);
+    					}
+    				}
     			};
                     @Override
                     public void setSelectedItem(Object anObject) {
                         if( anObject == null ) {
                             return;
+                        }
                         if( anObject instanceof ILabelingStrategy ) {
                             ILabelingStrategy st = (ILabelingStrategy) anObject;
                             for( ILabelingStrategyPanel pnl : strategyPanels.values() ) {
                                 if( pnl.getLabelingStrategyClass() != null
                                     && pnl.getLabelingStrategyClass().equals(st.getClass()) ) {
                                     super.setSelectedItem(new LabelingStrategyItem(pnl));
                                     return;
+                                }
+                            }
                         } else {
                             super.setSelectedItem(anObject);
+                        }
+                    }
                 };
     			cmbStrategy.setName("CMBMODE");
     			cmbStrategy.addActionListener(this);
+    		}
                 cmbStrategy.setName("CMBMODE");
                 cmbStrategy.addActionListener(this);
+            }
     		return cmbStrategy;
+    	}
             return cmbStrategy;
+        }
     	private JCheckBox getChkApplyLabels() {
     		if (chkApplyLabels == null) {
     			chkApplyLabels = new JCheckBox(PluginServices.getText(this, "enable_labeling"));
     			chkApplyLabels.setName("CHKAPPLYLABELS");
     			chkApplyLabels.addActionListener(this);
+    		}
     		return chkApplyLabels;
+    	}
         private JCheckBox getChkApplyLabels() {
             if( chkApplyLabels == null ) {
                 chkApplyLabels = new JCheckBox(PluginServices.getText(this, "enable_labeling"));
                 chkApplyLabels.setName("CHKAPPLYLABELS");
                 chkApplyLabels.addActionListener(this);
+            }
             return chkApplyLabels;
+        }
             /**
+             *
              * @deprecated use {#SymbolSwingManger.

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff