Application: gvSIG desktop

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

    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 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 JoinTransformEvaluator evaluator = null;

     * A default constructor

     */

    public JoinTransform() {

    }

    /**

     * Initializes all the necessary data for this transform

     *

     *

     *

     *

     *

     */

        String keyAttr1, String keyAttr2, String prefix1, String prefix2,

            throw new IllegalArgumentException("store1 == store2");

        }

        this.setFeatureStore(store1);

        this.store2 = store2;

        this.keyAttr1 = keyAttr1;

        this.prefix2 = prefix2; // TODO

        this.attrs = attrs;

        // 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 ??

        // keep index of geometry and att desc ==============

        // Create the feature type and copy the store 1 type        

        EditableFeatureType editableFeatureType = this.getFeatureStore().getDefaultFeatureType().getEditable();

        FeatureAttributeDescriptor[] featureAttributeDescriptors = editableFeatureType.getAttributeDescriptors();

        addFeatureType(editableFeatureType, featureAttributeDescriptors, prefix1, store1NamesMap);

        // =========== set the new geom field name and restore geometry values

            EditableFeatureAttributeDescriptor ed_att = null;

            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       

        }

            this.attrsForQuery = this.attrs;

        } else {

            List<String> list = new ArrayList<String>(this.attrs.length + 1);

            list.addAll(Arrays.asList(this.attrs));

            list.add(keyAttr2);

        }

        // assign calculated feature type as this transform's feature type

        setFeatureTypes(Arrays.asList(types), types[0]);

    }

    private void addFeatureType(EditableFeatureType targetFeatureType, FeatureAttributeDescriptor[] featureAttributeDescriptors,

            addFeatureType(targetFeatureType, featureAttributeDescriptors[i], prefix, storeMap);

        }

    }

    private void addFeatureType(EditableFeatureType targetFeatureType, FeatureAttributeDescriptor featureAttributeDescriptor,

        String attName = featureAttributeDescriptor.getName();

            attName = prefix + "_" + attName;

        }

        // If an attribute already exists, calculate an alternate name and add it to our type

        int j = 0;

            attName = targetFeatureType.getAttributeDescriptor(attName).getName() + "_" + ++j;

        }

                featureAttributeDescriptor.getSize());

        editableFeatureAttributeDescriptor.setPrecision(featureAttributeDescriptor.getPrecision());

        // keep correspondence between original name and transformed name

        storeMap.put(featureAttributeDescriptor.getName(), attName);

    /**

     *

     *

     * @throws DataException

     */

    public void applyTransform(Feature source, EditableFeature target)

        // copy the data from store1 into the resulting feature

        this.copySourceToTarget(source, target);

            Feature feat;

            itFeat = set.fastIterator();

                feat = (Feature) itFeat.next();

                // copy all attributes from joined feature to target

                this.copyJoinToTarget(feat, target);

            }

        } finally {

                itFeat.dispose();

            }

                set.dispose();

            }

        }

     */

    private void copyJoinToTarget(Feature join, EditableFeature target) {

        Iterator<Entry<String, String>> iter = store2NamesMap.entrySet()

        Entry<String, String> entry;

        FeatureType trgType = target.getType();

        FeatureAttributeDescriptor attr;

            entry = iter.next();

            attr = trgType.getAttributeDescriptor((String) entry.getValue());

                target.set(attr.getIndex(), join.get((String) entry.getKey()));

            }

        }

        FeatureType ftSrc = source.getType();

        FeatureType ftTrg = target.getType();

            attr = ftSrc.getAttributeDescriptor(i);

            attrTrg = ftTrg.getAttributeDescriptor(store1NamesMap.get(attr.getName()));

                try {

                    target.set(attrTrg.getIndex(), source.get(i));

                    // Ignore, do nothing

                } catch (IllegalArgumentException e) {

                    attrTrg = ftTrg.getAttributeDescriptor(attr.getName());

                    target.set(attrTrg.getIndex(), attrTrg.getDefaultValue());

    }

    private JoinTransformEvaluator getEvaluator() {

            this.evaluator = new JoinTransformEvaluator(keyAttr2, is_num);

        }

        return 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);

        }

        public Object evaluate(EvaluatorData arg0) throws EvaluatorException {

            Object curValue = arg0.getDataValue(attribute);

                return value == null;

            }

            return curValue.equals(value);

        }

        public String getSQL() {

            return this.sql;

        }

        public String getDescription() {

            return "Evaluates join transform match";

        }

        public String getName() {

            return "JoinTransformEvaluator";

        }

        public EvaluatorFieldsInfo getFieldsInfo() {

            return this.info;

        }

    @SuppressWarnings("unchecked")

    public FeatureType getSourceFeatureTypeFrom(FeatureType arg0) {

        return originalFeatureType;

    }

    public static void registerPersistent() {

        PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

        DynStruct definition = persistenceManager.getDefinition(PERSISTENCE_DEFINITION_NAME);

            definition = persistenceManager.addDefinition(

                JoinTransform.class,

                PERSISTENCE_DEFINITION_NAME,

                "JoinTransform Persistence definition",

                null

            );

            definition.extend(PersistenceManager.PERSISTENCE_NAMESPACE,

        }

    }

    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("attrs", this.attrs);

    }

    public void loadFromState(PersistentState state) throws PersistenceException {

        super.loadFromState(state);

    }

}