org.apache.commons.validator.Form Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of commons-validator Show documentation
Show all versions of commons-validator Show documentation
Apache Commons Validator provides the building blocks for both client side validation and server side data validation.
It may be used standalone or with a framework like Struts.
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.validator;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.commons.collections.FastHashMap;// DEPRECATED
/**
*
*
* This contains a set of validation rules for a form/JavaBean. The information
* is contained in a list of Field objects. Instances of this class
* are configured with a <form> xml element.
*
* The use of FastHashMap is deprecated and will be replaced in a future
* release.
*
* @version $Revision: 1713331 $
*/
//TODO mutable non-private fields
public class Form implements Serializable {
private static final long serialVersionUID = 6445211789563796371L;
/** The name/key the set of validation rules is stored under. */
protected String name = null;
/**
* List of Fields. Used to maintain the order they were added
* in although individual Fields can be retrieved using Map
* of Fields.
*/
protected List lFields = new ArrayList();
/**
* Map of Fields keyed on their property value.
*
* @deprecated Subclasses should use getFieldMap() instead.
*/
protected FastHashMap hFields = new FastHashMap(); //
/**
* The name/key of the form which this form extends from.
*
* @since Validator 1.2.0
*/
protected String inherit = null;
/**
* Whether or not the this Form was processed for replacing
* variables in strings with their values.
*/
private boolean processed = false;
/**
* Gets the name/key of the set of validation rules.
*
* @return The name value
*/
public String getName() {
return name;
}
/**
* Sets the name/key of the set of validation rules.
*
* @param name The new name value
*/
public void setName(String name) {
this.name = name;
}
/**
* Add a Field to the Form.
*
* @param f The field
*/
public void addField(Field f) {
this.lFields.add(f);
getFieldMap().put(f.getKey(), f);
}
/**
* A List of Fields is returned as an unmodifiable
* List.
*
* @return The fields value
*/
public List getFields() {
return Collections.unmodifiableList(lFields);
}
/**
* Returns the Field with the given name or null if this Form has no such
* field.
*
* @param fieldName The field name
* @return The field value
* @since Validator 1.1
*/
public Field getField(String fieldName) {
return getFieldMap().get(fieldName);
}
/**
* Returns true if this Form contains a Field with the given name.
*
* @param fieldName The field name
* @return True if this form contains the field by the given name
* @since Validator 1.1
*/
public boolean containsField(String fieldName) {
return getFieldMap().containsKey(fieldName);
}
/**
* Merges the given form into this one. For any field in depends
* not present in this form, include it. depends has precedence
* in the way the fields are ordered.
*
* @param depends the form we want to merge
* @since Validator 1.2.0
*/
protected void merge(Form depends) {
List templFields = new ArrayList();
@SuppressWarnings("unchecked") // FastHashMap is not generic
Map temphFields = new FastHashMap();
Iterator dependsIt = depends.getFields().iterator();
while (dependsIt.hasNext()) {
Field defaultField = (Field) dependsIt.next();
if (defaultField != null) {
String fieldKey = defaultField.getKey();
if (!this.containsField(fieldKey)) {
templFields.add(defaultField);
temphFields.put(fieldKey, defaultField);
}
else {
Field old = getField(fieldKey);
getFieldMap().remove(fieldKey);
lFields.remove(old);
templFields.add(old);
temphFields.put(fieldKey, old);
}
}
}
lFields.addAll(0, templFields);
getFieldMap().putAll(temphFields);
}
/**
* Processes all of the Form's Fields.
*
* @param globalConstants A map of global constants
* @param constants Local constants
* @param forms Map of forms
* @since Validator 1.2.0
*/
protected void process(Map globalConstants, Map constants, Map forms) {
if (isProcessed()) {
return;
}
int n = 0;//we want the fields from its parent first
if (isExtending()) {
Form parent = forms.get(inherit);
if (parent != null) {
if (!parent.isProcessed()) {
//we want to go all the way up the tree
parent.process(constants, globalConstants, forms);
}
for (Iterator i = parent.getFields().iterator(); i.hasNext(); ) {
Field f = i.next();
//we want to be able to override any fields we like
if (getFieldMap().get(f.getKey()) == null) {
lFields.add(n, f);
getFieldMap().put(f.getKey(), f);
n++;
}
}
}
}
hFields.setFast(true);
//no need to reprocess parent's fields, we iterate from 'n'
for (Iterator i = lFields.listIterator(n); i.hasNext(); ) {
Field f = i.next();
f.process(globalConstants, constants);
}
processed = true;
}
/**
* Returns a string representation of the object.
*
* @return string representation
*/
public String toString() {
StringBuilder results = new StringBuilder();
results.append("Form: ");
results.append(name);
results.append("\n");
for (Iterator i = lFields.iterator(); i.hasNext(); ) {
results.append("\tField: \n");
results.append(i.next());
results.append("\n");
}
return results.toString();
}
/**
* Validate all Fields in this Form on the given page and below.
*
* @param params A Map of parameter class names to parameter
* values to pass into validation methods.
* @param actions A Map of validator names to ValidatorAction
* objects.
* @param page Fields on pages higher than this will not be
* validated.
* @return A ValidatorResults object containing all
* validation messages.
* @throws ValidatorException
*/
ValidatorResults validate(Map params, Map actions, int page)
throws ValidatorException {
return validate(params, actions, page, null);
}
/**
* Validate all Fields in this Form on the given page and below.
*
* @param params A Map of parameter class names to parameter
* values to pass into validation methods.
* @param actions A Map of validator names to ValidatorAction
* objects.
* @param page Fields on pages higher than this will not be
* validated.
* @return A ValidatorResults object containing all
* validation messages.
* @throws ValidatorException
* @since 1.2.0
*/
ValidatorResults validate(Map params, Map actions, int page, String fieldName)
throws ValidatorException {
ValidatorResults results = new ValidatorResults();
params.put(Validator.VALIDATOR_RESULTS_PARAM, results);
// Only validate a single field if specified
if (fieldName != null) {
Field field = getFieldMap().get(fieldName);
if (field == null) {
throw new ValidatorException("Unknown field "+fieldName+" in form "+getName());
}
params.put(Validator.FIELD_PARAM, field);
if (field.getPage() <= page) {
results.merge(field.validate(params, actions));
}
} else {
Iterator fields = this.lFields.iterator();
while (fields.hasNext()) {
Field field = fields.next();
params.put(Validator.FIELD_PARAM, field);
if (field.getPage() <= page) {
results.merge(field.validate(params, actions));
}
}
}
return results;
}
/**
* Whether or not the this Form was processed for replacing
* variables in strings with their values.
*
* @return The processed value
* @since Validator 1.2.0
*/
public boolean isProcessed() {
return processed;
}
/**
* Gets the name/key of the parent set of validation rules.
*
* @return The extends value
* @since Validator 1.2.0
*/
public String getExtends() {
return inherit;
}
/**
* Sets the name/key of the parent set of validation rules.
*
* @param inherit The new extends value
* @since Validator 1.2.0
*/
public void setExtends(String inherit) {
this.inherit = inherit;
}
/**
* Get extends flag.
*
* @return The extending value
* @since Validator 1.2.0
*/
public boolean isExtending() {
return inherit != null;
}
/**
* Returns a Map of String field keys to Field objects.
*
* @return The fieldMap value
* @since Validator 1.2.0
*/
@SuppressWarnings("unchecked") // FastHashMap is not generic
protected Map getFieldMap() {
return hFields;
}
}