Module dev.metaschema.core

Package dev.metaschema.core.model.constraint

Class FindingCollectingConstraintValidationHandler

java.lang.Object

dev.metaschema.core.model.constraint.AbstractConstraintValidationHandler

dev.metaschema.core.model.constraint.FindingCollectingConstraintValidationHandler

All Implemented Interfaces:

IConstraintValidationHandler, IValidationResult

public class FindingCollectingConstraintValidationHandler
extends AbstractConstraintValidationHandler
implements IValidationResult

A validation result handler that collects the resulting findings for later retrieval using the getFindings() method.

This class is thread-safe and can be used with parallel constraint validation.

Field Summary

Fields inherited from interface dev.metaschema.core.model.validation.IValidationResult

PASSING_RESULT

Constructor Summary

Constructors

Constructor	Description
FindingCollectingConstraintValidationHandler()

Method Summary

Modifier and Type	Method	Description
protected void	addFinding(ConstraintValidationFinding finding)	Add a finding to the collection of findings maintained by this instance.
List<ConstraintValidationFinding>	getFindings()	Get the list of validation findings, which may be empty.
IConstraint.Level	getHighestSeverity()	Get the highest finding severity level for the validation.
void	handleAllowedValuesViolation(List<IAllowedValuesConstraint> failedConstraints, INodeItem target, DynamicContext dynamicContext)	Handle an allowed values constraint violation.
void	handleCardinalityMaximumViolation(ICardinalityConstraint constraint, INodeItem target, ISequence<? extends INodeItem> testedItems, DynamicContext dynamicContext)	Handle a cardinality constraint maximum violation.
void	handleCardinalityMinimumViolation(ICardinalityConstraint constraint, INodeItem target, ISequence<? extends INodeItem> testedItems, DynamicContext dynamicContext)	Handle a cardinality constraint minimum violation.
void	handleError(IConstraint constraint, INodeItem node, String message, Throwable exception, DynamicContext dynamicContext)	Handle a constraint that whose evaluation resulted in an unexpected error during validation.
void	handleExpectViolation(IExpectConstraint constraint, INodeItem node, INodeItem target, DynamicContext dynamicContext)	Handle an expect test violation.
void	handleIndexDuplicateKeyViolation(IIndexConstraint constraint, INodeItem node, INodeItem oldItem, INodeItem target, DynamicContext dynamicContext)	Handle an index duplicate key violation.
void	handleIndexDuplicateViolation(IIndexConstraint constraint, INodeItem node, DynamicContext dynamicContext)	Handle a duplicate index violation.
void	handleIndexMiss(IIndexHasKeyConstraint constraint, INodeItem node, INodeItem target, List<String> key, DynamicContext dynamicContext)	Handle an index lookup key miss violation.
void	handleKeyMatchError(IKeyConstraint constraint, INodeItem node, INodeItem target, MetapathException cause, DynamicContext dynamicContext)	Handle an error that occurred while generating a key.
void	handleMatchDatatypeViolation(IMatchesConstraint constraint, INodeItem node, INodeItem target, String value, IDataTypeAdapter<?> adapter, IllegalArgumentException cause, DynamicContext dynamicContext)	Handle a match data type violation.
void	handleMatchPatternViolation(IMatchesConstraint constraint, INodeItem node, INodeItem target, String value, Pattern pattern, DynamicContext dynamicContext)	Handle a match pattern violation.
void	handleMissingIndexViolation(IIndexHasKeyConstraint constraint, INodeItem node, INodeItem target, String message, DynamicContext dynamicContext)	Handle a missing index violation.
void	handlePass(IConstraint constraint, INodeItem node, INodeItem target, DynamicContext dynamicContext)	Handle a constraint that has passed validation.
void	handleReportViolation(IReportConstraint constraint, INodeItem node, INodeItem target, DynamicContext dynamicContext)	Handle a report test finding.
void	handleUniqueKeyViolation(IUniqueConstraint constraint, INodeItem node, INodeItem oldItem, INodeItem target, DynamicContext dynamicContext)	Handle an unique key violation.

Methods inherited from class dev.metaschema.core.model.constraint.AbstractConstraintValidationHandler

getPathFormatter, newAllowedValuesViolationMessage, newCardinalityMaximumViolationMessage, newCardinalityMinimumViolationMessage, newExpectViolationMessage, newIndexDuplicateKeyViolationMessage, newIndexDuplicateViolationMessage, newIndexMissMessage, newMatchDatatypeViolationMessage, newMatchPatternViolationMessage, newMissingIndexViolationMessage, newReportViolationMessage, newUniqueKeyViolationMessage, setPathFormatter, toPath

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface dev.metaschema.core.model.validation.IValidationResult

isPassing

Constructor Details

FindingCollectingConstraintValidationHandler

public FindingCollectingConstraintValidationHandler()

Method Details

getFindings

@NonNull
public List<ConstraintValidationFinding> getFindings()

Description copied from interface: IValidationResult

Get the list of validation findings, which may be empty.

Specified by:

getFindings in interface IValidationResult

Returns:

the list

getHighestSeverity

@NonNull
public IConstraint.Level getHighestSeverity()

Description copied from interface: IValidationResult

Get the highest finding severity level for the validation. The level IConstraint.Level.INFORMATIONAL will be returned if no validation findings were identified.

Specified by:

getHighestSeverity in interface IValidationResult

Returns:

the highest finding severity level

addFinding

protected void addFinding(@NonNull
 ConstraintValidationFinding finding)

Add a finding to the collection of findings maintained by this instance.

Parameters:

finding - the finding to add

handleCardinalityMinimumViolation

public void handleCardinalityMinimumViolation(@NonNull
 ICardinalityConstraint constraint,
 @NonNull
 INodeItem target,
 @NonNull
 ISequence<? extends INodeItem> testedItems,
 @NonNull
 DynamicContext dynamicContext)
                                       throws ConstraintValidationException

Description copied from interface: IConstraintValidationHandler

Handle a cardinality constraint minimum violation.

Specified by:

handleCardinalityMinimumViolation in interface IConstraintValidationHandler

Parameters:

constraint - the constraint that was evaluated

target - the node used as the evaluation focus to determine the items to test

testedItems - the items tested

dynamicContext - the Metapath dynamic execution context to use for Metapath evaluation

Throws:

ConstraintValidationException - if the constraint has a custom message that contains a Metapath expression that is invalid or if the expression failed to evaluate

handleCardinalityMaximumViolation

public void handleCardinalityMaximumViolation(@NonNull
 ICardinalityConstraint constraint,
 @NonNull
 INodeItem target,
 @NonNull
 ISequence<? extends INodeItem> testedItems,
 @NonNull
 DynamicContext dynamicContext)
                                       throws ConstraintValidationException

Description copied from interface: IConstraintValidationHandler

Handle a cardinality constraint maximum violation.

Specified by:

handleCardinalityMaximumViolation in interface IConstraintValidationHandler

Parameters:

constraint - the constraint that was evaluated

target - the node used as the evaluation focus to determine the items to test

testedItems - the items tested

dynamicContext - the Metapath dynamic execution context to use for Metapath evaluation

Throws:

ConstraintValidationException - if the constraint has a custom message that contains a Metapath expression that is invalid or if the expression failed to evaluate

handleIndexDuplicateKeyViolation

public void handleIndexDuplicateKeyViolation(@NonNull
 IIndexConstraint constraint,
 @NonNull
 INodeItem node,
 @NonNull
 INodeItem oldItem,
 @NonNull
 INodeItem target,
 @NonNull
 DynamicContext dynamicContext)
                                      throws ConstraintValidationException

Description copied from interface: IConstraintValidationHandler

Handle an index duplicate key violation.

This happens when two target nodes have the same key.

Specified by:

handleIndexDuplicateKeyViolation in interface IConstraintValidationHandler

Parameters:

constraint - the constraint that was evaluated

node - the node used as the evaluation focus to determine constraint targets

oldItem - the node that exists in the index for the related key

target - the target of evaluation

dynamicContext - the Metapath dynamic execution context to use for Metapath evaluation

Throws:

ConstraintValidationException - if the constraint has a custom message that contains a Metapath expression that is invalid or if the expression failed to evaluate

handleUniqueKeyViolation

public void handleUniqueKeyViolation(@NonNull
 IUniqueConstraint constraint,
 @NonNull
 INodeItem node,
 @NonNull
 INodeItem oldItem,
 @NonNull
 INodeItem target,
 @NonNull
 DynamicContext dynamicContext)
                              throws ConstraintValidationException

Description copied from interface: IConstraintValidationHandler

Handle an unique key violation.

This happens when two target nodes have the same key.

Specified by:

handleUniqueKeyViolation in interface IConstraintValidationHandler

Parameters:

constraint - the constraint that was evaluated

node - the node used as the evaluation focus to determine constraint targets

oldItem - the other node with the same key

target - the target of evaluation

dynamicContext - the Metapath dynamic execution context to use for Metapath evaluation

Throws:

ConstraintValidationException - if the constraint has a custom message that contains a Metapath expression that is invalid or if the expression failed to evaluate

handleKeyMatchError

public void handleKeyMatchError(@NonNull
 IKeyConstraint constraint,
 @NonNull
 INodeItem node,
 @NonNull
 INodeItem target,
 @NonNull
 MetapathException cause,
 @NonNull
 DynamicContext dynamicContext)

Description copied from interface: IConstraintValidationHandler

Handle an error that occurred while generating a key.

Specified by:

handleKeyMatchError in interface IConstraintValidationHandler

Parameters:

constraint - the constraint that was evaluated

node - the node used as the evaluation focus to determine constraint targets

target - the target of evaluation

cause - the resulting Metapath exception

dynamicContext - the Metapath dynamic execution context to use for Metapath evaluation

handleMatchPatternViolation

public void handleMatchPatternViolation(@NonNull
 IMatchesConstraint constraint,
 @NonNull
 INodeItem node,
 @NonNull
 INodeItem target,
 @NonNull
 String value,
 @NonNull
 Pattern pattern,
 @NonNull
 DynamicContext dynamicContext)
                                 throws ConstraintValidationException

Description copied from interface: IConstraintValidationHandler

Handle a match pattern violation.

This happens when the target value does not match the specified pattern.

Specified by:

handleMatchPatternViolation in interface IConstraintValidationHandler

Parameters:

constraint - the constraint that was evaluated

node - the node used as the evaluation focus to determine constraint targets

target - the target of evaluation

value - the value used for pattern matching

pattern - the pattern used for pattern matching

dynamicContext - the Metapath dynamic execution context to use for Metapath evaluation

Throws:

ConstraintValidationException - if the constraint has a custom message that contains a Metapath expression that is invalid or if the expression failed to evaluate

handleMatchDatatypeViolation

public void handleMatchDatatypeViolation(@NonNull
 IMatchesConstraint constraint,
 @NonNull
 INodeItem node,
 @NonNull
 INodeItem target,
 @NonNull
 String value,
 @NonNull
 IDataTypeAdapter<?> adapter,
 @NonNull
 IllegalArgumentException cause,
 @NonNull
 DynamicContext dynamicContext)
                                  throws ConstraintValidationException

Description copied from interface: IConstraintValidationHandler

Handle a match data type violation.

This happens when the target value does not conform to the specified data type.

Specified by:

handleMatchDatatypeViolation in interface IConstraintValidationHandler

Parameters:

constraint - the constraint that was evaluated

node - the node used as the evaluation focus to determine constraint targets

target - the target of evaluation

value - the value used for data type matching

adapter - the data type used for data type matching

cause - the data type exception related to this violation

dynamicContext - the Metapath dynamic execution context to use for Metapath evaluation

Throws:

ConstraintValidationException - if the constraint has a custom message that contains a Metapath expression that is invalid or if the expression failed to evaluate

handleExpectViolation

public void handleExpectViolation(@NonNull
 IExpectConstraint constraint,
 @NonNull
 INodeItem node,
 @NonNull
 INodeItem target,
 @NonNull
 DynamicContext dynamicContext)
                           throws ConstraintValidationException

Description copied from interface: IConstraintValidationHandler

Handle an expect test violation.

This happens when the test does not evaluate to true.

Specified by:

handleExpectViolation in interface IConstraintValidationHandler

Parameters:

constraint - the constraint that was evaluated

node - the node used as the evaluation focus to determine constraint targets

target - the target of evaluation

dynamicContext - the Metapath dynamic execution context to use for Metapath evaluation

Throws:

ConstraintValidationException - if the constraint has a custom message that contains a Metapath expression that is invalid or if the expression failed to evaluate

handleReportViolation

public void handleReportViolation(@NonNull
 IReportConstraint constraint,
 @NonNull
 INodeItem node,
 @NonNull
 INodeItem target,
 @NonNull
 DynamicContext dynamicContext)
                           throws ConstraintValidationException

Description copied from interface: IConstraintValidationHandler

Handle a report test finding.

This happens when the report test expression evaluates to true. Unlike expect constraints which generate violations when false, report constraints generate findings when true.

Specified by:

handleReportViolation in interface IConstraintValidationHandler

Parameters:

constraint - the constraint that was evaluated

node - the node used as the evaluation focus to determine constraint targets

target - the target of evaluation

dynamicContext - the Metapath dynamic execution context to use for Metapath evaluation

Throws:

ConstraintValidationException - if the constraint has a custom message that contains a Metapath expression that is invalid or if the expression failed to evaluate

handleAllowedValuesViolation

public void handleAllowedValuesViolation(@NonNull
 List<IAllowedValuesConstraint> failedConstraints,
 @NonNull
 INodeItem target,
 @NonNull
 DynamicContext dynamicContext)

Description copied from interface: IConstraintValidationHandler

Handle an allowed values constraint violation.

Specified by:

handleAllowedValuesViolation in interface IConstraintValidationHandler

Parameters:

failedConstraints - the allowed values constraints that did not match.

target - the target of evaluation

dynamicContext - the Metapath dynamic execution context to use for Metapath evaluation

handleIndexDuplicateViolation

public void handleIndexDuplicateViolation(IIndexConstraint constraint,
 INodeItem node,
 @NonNull
 DynamicContext dynamicContext)

Description copied from interface: IConstraintValidationHandler

Handle a duplicate index violation.

Specified by:

handleIndexDuplicateViolation in interface IConstraintValidationHandler

Parameters:

constraint - the constraint that was evaluated

node - the node used as the evaluation focus to determine constraint targets

dynamicContext - the Metapath dynamic execution context to use for Metapath evaluation

handleIndexMiss

public void handleIndexMiss(@NonNull
 IIndexHasKeyConstraint constraint,
 @NonNull
 INodeItem node,
 @NonNull
 INodeItem target,
 @NonNull
 List<String> key,
 @NonNull
 DynamicContext dynamicContext)
                     throws ConstraintValidationException

Description copied from interface: IConstraintValidationHandler

Handle an index lookup key miss violation.

This happens when another node references an expected member of an index that does not actually exist in the index.

Specified by:

handleIndexMiss in interface IConstraintValidationHandler

Parameters:

constraint - the constraint that was evaluated

node - the node used as the evaluation focus to determine constraint targets

target - the target of evaluation

key - the key that was used to lookup the index entry

dynamicContext - the Metapath dynamic execution context to use for Metapath evaluation

Throws:

ConstraintValidationException - if the constraint has a custom message that contains a Metapath expression that is invalid or if the expression failed to evaluate

handleMissingIndexViolation

public void handleMissingIndexViolation(@NonNull
 IIndexHasKeyConstraint constraint,
 @NonNull
 INodeItem node,
 @NonNull
 INodeItem target,
 @NonNull
 String message,
 @NonNull
 DynamicContext dynamicContext)

Description copied from interface: IConstraintValidationHandler

Handle a missing index violation.

This happens when an index-has-key constraint references a missing index.

Specified by:

handleMissingIndexViolation in interface IConstraintValidationHandler

Parameters:

constraint - the constraint that was evaluated

node - the node used as the evaluation focus to determine constraint targets

target - the target of evaluation

message - the error message

dynamicContext - the Metapath dynamic execution context to use for Metapath evaluation

handlePass

public void handlePass(@NonNull
 IConstraint constraint,
 @NonNull
 INodeItem node,
 @NonNull
 INodeItem target,
 @NonNull
 DynamicContext dynamicContext)

Description copied from interface: IConstraintValidationHandler

Handle a constraint that has passed validation.

Specified by:

handlePass in interface IConstraintValidationHandler

Parameters:

constraint - the constraint that was evaluated

node - the node used as the evaluation focus to determine constraint targets

target - the target of evaluation

dynamicContext - the Metapath dynamic execution context to use for Metapath evaluation

handleError

public void handleError(@NonNull
 IConstraint constraint,
 @NonNull
 INodeItem node,
 @NonNull
 String message,
 @NonNull
 Throwable exception,
 @NonNull
 DynamicContext dynamicContext)

Description copied from interface: IConstraintValidationHandler

Handle a constraint that whose evaluation resulted in an unexpected error during validation.

Specified by:

handleError in interface IConstraintValidationHandler

Parameters:

constraint - the constraint that was evaluated

node - the node used as the evaluation focus to determine constraint targets

message - the error message

exception - the causing exception

dynamicContext - the Metapath dynamic execution context to use for Metapath evaluation