public SetPropertiesRule() 
{
        // nothing to set up
}

Base constructor.

 public SetPropertiesRule(Digester digester) 
{
        this();
}

Default constructor sets only the the associated Digester.

Parameters:

digester - The digester with which this rule is associated

 public SetPropertiesRule(String attributeName,
    String propertyName) 
{
        
        attributeNames = new String[1];
        attributeNames[0] = attributeName;
        propertyNames = new String[1];
        propertyNames[0] = propertyName;
}

Convenience constructor overrides the mapping for just one property.

For details about how this works, see #SetPropertiesRule(String[] attributeNames, String[] propertyNames) .

Parameters:

attributeName - map this attribute

propertyName - to a property with this name

 public SetPropertiesRule(String[] attributeNames,
    String[] propertyNames) 
{
        // create local copies
        this.attributeNames = new String[attributeNames.length];
        for (int i=0, size=attributeNames.length; i< size; i++) {
            this.attributeNames[i] = attributeNames[i];
        }
        this.propertyNames = new String[propertyNames.length];
        for (int i=0, size=propertyNames.length; i< size; i++) {
            this.propertyNames[i] = propertyNames[i];
        }
}

Constructor allows attribute->property mapping to be overriden.

Two arrays are passed in. One contains the attribute names and the other the property names. The attribute name / property name pairs are match by position In order words, the first string in the attribute name list matches to the first string in the property name list and so on.

If a property name is null or the attribute name has no matching property name, then this indicates that the attibute should be ignored.

Example One

The following constructs a rule that maps the alt-city attribute to the city property and the alt-state to the state property. All other attributes are mapped as usual using exact name matching.

SetPropertiesRule(
new String[] {"alt-city", "alt-state"},
new String[] {"city", "state"});

Example Two

The following constructs a rule that maps the class attribute to the className property. The attribute ignore-me is not mapped. All other attributes are mapped as usual using exact name matching.

SetPropertiesRule(
new String[] {"class", "ignore-me"},
new String[] {"className"});

Parameters:

attributeNames - names of attributes to map

propertyNames - names of properties mapped to

 public  void addAlias(String attributeName,
    String propertyName) 
{
        
        // this is a bit tricky.
        // we'll need to resize the array.
        // probably should be synchronized but digester's not thread safe anyway
        if (attributeNames == null) {
            attributeNames = new String[1];
            attributeNames[0] = attributeName;
            propertyNames = new String[1];
            propertyNames[0] = propertyName;        
        } else {
            int length = attributeNames.length;
            String [] tempAttributes = new String[length + 1];
            for (int i=0; i< length; i++) {
                tempAttributes[i] = attributeNames[i];
            }
            tempAttributes[length] = attributeName;
            String [] tempProperties = new String[length + 1];
            for (int i=0; i< length && i<  propertyNames.length; i++) {
                tempProperties[i] = propertyNames[i];
            }
            tempProperties[length] = propertyName;
            propertyNames = tempProperties;
            attributeNames = tempAttributes;
        }
}

Add an additional attribute name to property name mapping. This is intended to be used from the xml rules.

 public  void begin(Attributes attributes) throws Exception 
{
    // --------------------------------------------------------- Public Methods
        // Build a set of attribute names and corresponding values
        HashMap values = new HashMap();
        // set up variables for custom names mappings
        int attNamesLength = 0;
        if (attributeNames != null) {
            attNamesLength = attributeNames.length;
        }
        int propNamesLength = 0;
        if (propertyNames != null) {
            propNamesLength = propertyNames.length;
        }
        for (int i = 0; i <  attributes.getLength(); i++) {
            String name = attributes.getLocalName(i);
            if ("".equals(name)) {
                name = attributes.getQName(i);
            }
            String value = attributes.getValue(i);
            // we'll now check for custom mappings
            for (int n = 0; n< attNamesLength; n++) {
                if (name.equals(attributeNames[n])) {
                    if (n <  propNamesLength) {
                        // set this to value from list
                        name = propertyNames[n];
                    } else {
                        // set name to null
                        // we'll check for this later
                        name = null;
                    }
                    break;
                }
            } 
            if (digester.log.isDebugEnabled()) {
                digester.log.debug("[SetPropertiesRule]{" + digester.match +
                        "} Setting property '" + name + "' to '" +
                        value + "'");
            }
            if ((!ignoreMissingProperty) && (name != null)) {
                // The BeanUtils.populate method silently ignores items in
                // the map (ie xml entities) which have no corresponding
                // setter method, so here we check whether each xml attribute
                // does have a corresponding property before calling the
                // BeanUtils.populate method.
                //
                // Yes having the test and set as separate steps is ugly and 
                // inefficient. But BeanUtils.populate doesn't provide the 
                // functionality we need here, and changing the algorithm which 
                // determines the appropriate setter method to invoke is 
                // considered too risky.
                //
                // Using two different classes (PropertyUtils vs BeanUtils) to
                // do the test and the set is also ugly; the codepaths
                // are different which could potentially lead to trouble.
                // However the BeanUtils/ProperyUtils code has been carefully 
                // compared and the PropertyUtils functionality does appear 
                // compatible so we'll accept the risk here.
                Object top = digester.peek();
                boolean test =  PropertyUtils.isWriteable(top, name);
                if (!test)
                    throw new NoSuchMethodException("Property " + name + " can't be set");
            }
            if (name != null) {
                values.put(name, value);
            } 
        }
        // Populate the corresponding properties of the top object
        Object top = digester.peek();
        if (digester.log.isDebugEnabled()) {
            if (top != null) {
                digester.log.debug("[SetPropertiesRule]{" + digester.match +
                                   "} Set " + top.getClass().getName() +
                                   " properties");
            } else {
                digester.log.debug("[SetPropertiesRule]{" + digester.match +
                                   "} Set NULL properties");
            }
        }
        BeanUtils.populate(top, values);
}

Process the beginning of this element.

 public boolean isIgnoreMissingProperty() 
{
        return this.ignoreMissingProperty;
}

Are attributes found in the xml without matching properties to be ignored?

If false, the parsing will interrupt with an NoSuchMethodException if a property specified in the XML is not found. The default is true.

 public  void setIgnoreMissingProperty(boolean ignoreMissingProperty) 
{
        this.ignoreMissingProperty = ignoreMissingProperty;
}

Sets whether attributes found in the xml without matching properties should be ignored. If set to false, the parsing will throw an NoSuchMethodException if an unmatched attribute is found. This allows to trap misspellings in the XML file.

 public String toString() 
{
        StringBuffer sb = new StringBuffer("SetPropertiesRule[");
        sb.append("]");
        return (sb.toString());
}

Render a printable version of this Rule.