/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided
* that the following conditions are met:
*
* 1. Redistributions of source code must retain copyright
* statements and notices. Redistributions must also contain a
* copy of this document.
*
* 2. Redistributions in binary form must reproduce the
* above copyright notice, this list of conditions and the
* following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. The name "Exolab" must not be used to endorse or promote
* products derived from this Software without prior written
* permission of Intalio, Inc. For written permission,
* please contact info@exolab.org.
*
* 4. Products derived from this Software may not be called "Exolab"
* nor may "Exolab" appear in their names without prior written
* permission of Intalio, Inc. Exolab is a registered
* trademark of Intalio, Inc.
*
* 5. Due credit should be given to the Exolab Project
* (http://www.exolab.org/).
*
* THIS SOFTWARE IS PROVIDED BY INTALIO, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
* NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* INTALIO, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2000-2004 (C) Intalio, Inc. All Rights Reserved.
*
* $Id$
*/
package org.exolab.castor.xml;
import java.lang.reflect.Array;
import java.text.MessageFormat;
import java.util.Enumeration;
import java.util.List;
import java.util.Vector;
import org.exolab.castor.mapping.FieldHandler;
import org.exolab.castor.xml.location.XPathLocation;
/**
* Handles field validation.
*
* @author <a href="mailto:kvisco-at-intalio.com">Keith Visco</a>
* @version $Revision$ $Date: 2004-10-08 22:58:55 -0600 (Fri, 08 Oct 2004) $
*/
public class FieldValidator extends Validator {
/** Default value for descriptor names. If a Descriptor XML name value is
* set to this, then no name has been assigned yet. */
private static final String ERROR_NAME = "-error-if-this-is-used-";
/** Default minimum occurrance. */
private static final int DEFAULT_MIN = 0;
/** Default maximum occurrance. */
private static final int DEFAULT_MAX = -1;
/** Minimum number of occurrences for this element to pass validation. */
private int _minOccurs = DEFAULT_MIN;
/** Maximum number of occurrences for this element to pass validation. */
private int _maxOccurs = DEFAULT_MAX;
/** The Field Descriptor describing the field we validate. */
private XMLFieldDescriptor _descriptor = null;
/** The actual type validator which is used to validate single instances of
* the field. */
private TypeValidator _validator = null;
/**
* Creates a default FieldValidator.
*/
public FieldValidator() {
super();
}
/**
* Creates a new FieldValidator using the given TypeValidator.
* @param validator the TypeValidator to delegate validation to
*/
public FieldValidator(final TypeValidator validator) {
super();
this._validator = validator;
}
/**
* Returns the mimimum number of occurances for a given object.
*
* @return The mimimum number of occurances for a given object. A zero value
* denotes no lower bound (ie. the object is optional).
*/
public int getMinOccurs() {
return _minOccurs;
}
/**
* Returns the maximum number of occurances for a given object.
*
* @return The maximum number of occurances for a given object. A negative
* value denotes no upper bound.
*/
public int getMaxOccurs() {
return _maxOccurs;
}
/**
* Returns the TypeValidator.
* @return the TypeValidator.
*/
public TypeValidator getTypeValidator() {
return _validator;
}
/**
* Returns true if a TypeValidator has been set.
* @return true if a TypeValidator has been set.
*/
public boolean hasTypeValidator() {
return _validator != null;
}
/**
* Sets the mimimum number of occurances for a given object. A zero, or
* negative value denotes no lower bound (i.e., the object is optional).
*
* @param minOccurs the minimum number of times an object must occur in
* order to be valid.
*/
public void setMinOccurs(final int minOccurs) {
this._minOccurs = (minOccurs < 0) ? 0 : minOccurs;
}
/**
* Sets the maximum number of occurances for a given object. A negative
* value denotes no upper bound.
*
* @param maxOccurs the maximum number of times an object may occur.
*/
public void setMaxOccurs(final int maxOccurs) {
this._maxOccurs = maxOccurs;
}
/**
* Sets the field descriptor to use for obtaining information about the
* field to validate, such as the field name, the field handler, etc.
*
* @param descriptor the field descriptor for the field to validate
*/
public void setDescriptor(final XMLFieldDescriptor descriptor) {
this._descriptor = descriptor;
}
public void setValidator(final TypeValidator validator) {
this._validator = validator;
}
/**
* Validates the given Object.
*
* @param object the Object that contains the field to validate
* @param context the ValidationContext
* @throws ValidationException if validation fails
*/
public void validate(final Object object, final ValidationContext context)
throws ValidationException {
if (_descriptor == null || object == null || context.isValidated(object)) {
return;
}
// Don't validate "transient" fields.
if (_descriptor.isTransient()) {
return;
}
FieldHandler handler = _descriptor.getHandler();
if (handler == null) {
return;
}
// Get the value of the field
Object value = handler.getValue(object);
if (value == null) {
if (!_descriptor.isRequired() || _descriptor.isNillable()) {
return;
}
// deal with lenient id/idref validation accordingly, skipping exception handling
// in this case
if (_descriptor.isRequired()
&& _descriptor.getSchemaType() != null
&& _descriptor.getSchemaType().equals("IDREF")
&& context.getInternalContext().getLenientIdValidation()) {
return;
}
StringBuffer buff = new StringBuffer();
if (!ERROR_NAME.equals(_descriptor.getXMLName())) {
buff.append(MessageFormat.format(resourceBundle.getString("validatorField.error.required.field.whose"),
new Object[] {_descriptor.getFieldName(), object.getClass().getName(), _descriptor.getXMLName()}));
}
else {
buff.append(MessageFormat.format(resourceBundle.getString("validatorField.error.required.field"),
new Object[] {_descriptor.getFieldName(), object.getClass().getName()}));
}
throw new ValidationException(buff.toString());
}
if (_descriptor.isReference()) {
if (_validator != null) {
_validator.validate(value, context);
}
return;
}
// Prevent endless loop! Have we seen this object yet?
if (context != null) {
if (context.isValidated(object)) {
return;
}
//-- mark object as processed
context.addValidated(object);
}
// We are now ready to do actual validation
Class type = value.getClass();
int size = 1;
long occurence = -1;
try {
if (type.isArray()) {
// We don't validate Byte array types
if (type.getComponentType() != Byte.TYPE) {
size = Array.getLength(value);
if (_validator != null) {
for (int i = 0; i < size; i++) {
occurence = i + 1;
_validator.validate(Array.get(value, i), context);
}
} else {
for (int i = 0; i < size; i++) {
super.validate(Array.get(value, i), context);
}
}
}
} else if (value instanceof Enumeration) {
// <NOTE>
// The following code should be changed to use CollectionHandler
// </NOTE>
size = 0;
for (Enumeration enumeration = (Enumeration) value;
enumeration.hasMoreElements(); ) {
++size;
validateInstance(context, enumeration.nextElement());
}
} else if (value instanceof Vector) {
Vector vector = (Vector) value;
size = vector.size();
for (int i = 0; i < size; i++) {
occurence = i + 1;
validateInstance(context, vector.elementAt(i));
}
} else if (value instanceof List) {
List list = (List) value;
size = list.size();
for (int i = 0; i < size; i++) {
occurence = i + 1;
validateInstance(context, list.get(i));
}
} else {
validateInstance(context, value);
}
} catch (ValidationException vx) {
//-- add additional validation information
String err = MessageFormat.format(resourceBundle.getString("validatorField.error.exception"),
new Object[] { _descriptor.getFieldName(), object.getClass().getName()});
ValidationException validationException = new ValidationException(err, vx);
addLocationInformation(_descriptor, validationException, occurence);
throw validationException;
}
// Check sizes of collection
// Check minimum.
// If any items exist (size != 0) or the descriptor is marked as
// required then we need to report the error. Otherwise size == 0 and
// field is not required, so no error.
if (size < _minOccurs && (size != 0 || _descriptor.isRequired())) {
StringBuffer buff = new StringBuffer();
if (!ERROR_NAME.equals(_descriptor.getXMLName())) {
buff.append(MessageFormat.format(resourceBundle.getString("validatorField.error.exception.min.occurs.whose"),
new Object[] { _minOccurs, _descriptor.getFieldName(), object.getClass().getName(),
_descriptor.getXMLName()}));
} else {
buff.append(MessageFormat.format(resourceBundle.getString("validatorField.error.exception.min.occurs"),
new Object[] { _minOccurs, _descriptor.getFieldName(), object.getClass().getName()}));
}
throw new ValidationException(buff.toString());
}
// Check maximum.
if (_maxOccurs >= 0 && size > _maxOccurs) {
StringBuffer buff = new StringBuffer();
if (!ERROR_NAME.equals(_descriptor.getXMLName())) {
buff.append(MessageFormat.format(resourceBundle.getString("validatorField.error.exception.max.occurs.whose"),
new Object[] { _maxOccurs, _descriptor.getFieldName(), object.getClass().getName(), _descriptor.getXMLName()}));
} else {
buff.append(MessageFormat.format(resourceBundle.getString("validatorField.error.exception.max.occurs"),
new Object[] { _maxOccurs, _descriptor.getFieldName(), object.getClass().getName()}));
}
throw new ValidationException(buff.toString());
}
if (context != null) {
context.removeValidated(object);
}
}
/**
* Validate an individual instance.
* @param context the validation context.
* @param value The instance to validate.
* @throws ValidationException if validation fails
*/
private void validateInstance(final ValidationContext context, final Object value)
throws ValidationException {
if (_validator != null) {
_validator.validate(value, context);
} else {
super.validate(value, context);
}
}
/**
* Adds location information to the {@link ValidationException} instance.
* @param fieldDescriptor The {@link XMLFieldDescriptor} instance whose has been responsible for
* generating the error.
* @param e The {@link ValidationException} to enrich.
* @param occurence If greater than 0, denotes the position of the invalid collection value.
*/
private void addLocationInformation(final XMLFieldDescriptor fieldDescriptor,
final ValidationException e, final long occurence) {
XPathLocation loc = (XPathLocation) e.getLocation();
if (loc == null) {
loc = new XPathLocation();
e.setLocation(loc);
String xmlName = fieldDescriptor.getXMLName();
if (occurence > 0) {
xmlName += "[" + occurence + "]";
}
if (fieldDescriptor.getNodeType() == NodeType.Attribute) {
loc.addAttribute(xmlName);
} else {
loc.addChild(xmlName);
}
}
}
}