Java ValidationEvent.ERROR属性代码示例

public boolean handleEvent( ValidationEvent event ) {
    events.add(event);

    boolean retVal = true;
    switch( event.getSeverity() ) {
        case ValidationEvent.WARNING:
            retVal = true; // continue validation
            break;
        case ValidationEvent.ERROR:
            retVal = true; // continue validation
            break;
        case ValidationEvent.FATAL_ERROR:
            retVal = false; // halt validation
            break;
        default:
            _assert( false,
                     Messages.format( Messages.UNRECOGNIZED_SEVERITY,
                             event.getSeverity() ) );
            break;
    }

    return retVal;
}
 

private List<String> checkForValidationErrors(ValidationEvent... events)
{

	List<String> errors = new ArrayList<>();

	for (ValidationEvent event : events)
	{
		if (event.getSeverity() != ValidationEvent.WARNING)
		{
			String severity = (event.getSeverity() == ValidationEvent.ERROR) ? "[ERROR]: " : "[FATAL_ERROR]: ";
			String location = JaxbUtil.getErrorLocation(event);
			String message = String.format("%s %s Location: %s", severity, event.getMessage(), location);
			errors.add(message);

		}
	}

	return errors;
}
 

@Override
public boolean handleEvent(ValidationEvent event) {
	events.add(event);

	boolean retVal = true;
	switch (event.getSeverity()) {
	case ValidationEvent.WARNING:
		retVal = true; // continue validation
		break;
	case ValidationEvent.ERROR:
		retVal = true; // continue validation
		break;
	case ValidationEvent.FATAL_ERROR:
		retVal = true; // continue validation
		break;

	}

	return retVal;
}
 

/**
 * Get the error level matching the passed JAXB severity.
 *
 * @param nSeverity
 *        The JAXB severity.
 * @return The matching {@link IErrorLevel}. Never <code>null</code>.
 */
@Nonnull
@OverrideOnDemand
protected IErrorLevel getErrorLevel (final int nSeverity)
{
  switch (nSeverity)
  {
    case ValidationEvent.WARNING:
      return EErrorLevel.WARN;
    case ValidationEvent.ERROR:
      return EErrorLevel.ERROR;
    case ValidationEvent.FATAL_ERROR:
      return EErrorLevel.FATAL_ERROR;
    default:
      s_aLogger.warn ("Unknown JAXB validation severity: " + nSeverity + "; defaulting to error");
      return EErrorLevel.ERROR;
  }
}
 

/**
 * Set the severity field of this event.
 *
 * @param _severity Must be one of ValidationEvent.WARNING,
 * ValidationEvent.ERROR, or ValidationEvent.FATAL_ERROR.
 * @throws IllegalArgumentException if an illegal severity field is supplied
 */
public void setSeverity( int _severity ) {

    if( _severity != ValidationEvent.WARNING &&
        _severity != ValidationEvent.ERROR &&
        _severity != ValidationEvent.FATAL_ERROR ) {
            throw new IllegalArgumentException(
                Messages.format( Messages.ILLEGAL_SEVERITY ) );
    }

    this.severity = _severity;
}
 

private String severityToString(int severity) {
  switch (severity) {
    case ValidationEvent.WARNING:
      return "WARN ";
    case ValidationEvent.ERROR:
      return "ERROR";
    default:
      return "FATAL";
  }
}
 

public boolean handleEvent(ValidationEvent event) {
	if ((event.getSeverity() == ValidationEvent.FATAL_ERROR)
			|| (event.getSeverity() == ValidationEvent.ERROR)) {
		return false;
	} else if (event.getSeverity() == ValidationEvent.WARNING) {
		log.debug("Validation warning: " + event.getMessage() + ".");
		return true;
	} else {
		log.warn("Unknown validation event type.");
		return false;
	}
}
 

/**
 * Reports a print conversion error while marshalling.
 */
public static void handlePrintConversionException(
    Object caller, Exception e, XMLSerializer serializer ) throws SAXException {

    if( e instanceof SAXException )
        // assume this exception is not from application.
        // (e.g., when a marshaller aborts the processing, this exception
        //        will be thrown)
        throw (SAXException)e;

    ValidationEvent ve = new PrintConversionEventImpl(
        ValidationEvent.ERROR, e.getMessage(),
        new ValidationEventLocatorImpl(caller), e );
    serializer.reportError(ve);
}
 

/**
 * Reports that the type of an object in a property is unexpected.
 */
public static void handleTypeMismatchError( XMLSerializer serializer,
        Object parentObject, String fieldName, Object childObject ) throws SAXException {

     ValidationEvent ve = new ValidationEventImpl(
        ValidationEvent.ERROR, // maybe it should be a fatal error.
         Messages.TYPE_MISMATCH.format(
            getTypeName(parentObject),
            fieldName,
            getTypeName(childObject) ),
        new ValidationEventLocatorExImpl(parentObject,fieldName) );

    serializer.reportError(ve);
}
 

@Override
public boolean handleEvent(ValidationEvent event) {
	StringBuilder msg = new StringBuilder();
	LogLevel type = LogLevel.ERROR;

	switch (event.getSeverity()) {
	case ValidationEvent.FATAL_ERROR:
	case ValidationEvent.ERROR:
		msg.append("Invalid XML content");
		type = LogLevel.ERROR;
		isValid = false;
		break;
	case ValidationEvent.WARNING:
		msg.append("Warning");
		type = LogLevel.WARN;
		break;
	}

	if (event.getLocator() != null) {
		msg.append(" at [").append(event.getLocator().getLineNumber())
		.append(", ").append(event.getLocator().getColumnNumber()).append("]");
	}

	msg.append(": ").append(event.getMessage());		
	log.log(type, msg.toString());
	
	if (!isValid)
		cause = msg.toString();
	
	return isValid;
}
 

private static String getSeverity(int severity) {
    switch (severity) {
    case ValidationEvent.FATAL_ERROR:
        return "FATAL";
    case ValidationEvent.ERROR:
        return "FATAL";
    case ValidationEvent.WARNING:
        return "WARNING";
    default:
        return "";
    }
}
 

@Override
public boolean handleEvent(ValidationEvent ve)
{
	if (ve.getSeverity() == ValidationEvent.FATAL_ERROR
		|| ve.getSeverity() == ValidationEvent.ERROR)
	{
		ValidationEventLocator locator = ve.getLocator();
		log.error("{}: {} at line={}, column={}", locator.getURL(),
			ve.getMessage(), locator.getLineNumber(),
			locator.getColumnNumber());
		foundErrors = true;
	}
	return true;
}
 

@Override
public boolean handleEvent(ValidationEvent event) {
    switch(event.getSeverity()) {
    case ValidationEvent.WARNING:
        return warning(event);
    case ValidationEvent.ERROR:
        return error(event);
    case ValidationEvent.FATAL_ERROR:
        return fatalError(event);
    }
    
    throw new IllegalArgumentException("Unsupported ValidationEvent severity: " + event.getSeverity());
}
 

/**
 * Report an error found as an exception.
 *
 * @param fieldName
 *      the name of the property being processed when an error is found.
 */
public final void reportError(String fieldName, Throwable t) throws SAXException {
    ValidationEvent ve = new ValidationEventImpl(ValidationEvent.ERROR,
        t.getMessage(), getCurrentLocation(fieldName), t);
    reportError(ve);
}