package org.hibernate.validator.internal.engine.groups;
import java.lang.invoke.MethodHandles;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import javax.validation.GroupSequence;
import javax.validation.groups.Default;
import org.hibernate.validator.internal.util.logging.Log;
import org.hibernate.validator.internal.util.logging.LoggerFactory;
public class ValidationOrderGenerator {
private static final Log LOG = LoggerFactory.make( MethodHandles.lookup() );
private final ConcurrentMap<Class<?>, Sequence> resolvedSequences = new ConcurrentHashMap<Class<?>, Sequence>();
public ValidationOrder getValidationOrder(Class<?> group, boolean expand) {
if ( Default.class.equals( group ) ) {
return ValidationOrder.DEFAULT_GROUP;
}
if ( expand ) {
return getValidationOrder( Collections.<Class<?>>singletonList( group ) );
}
else {
DefaultValidationOrder validationOrder = new DefaultValidationOrder();
validationOrder.insertGroup( new Group( group ) );
return validationOrder;
}
}
public ValidationOrder getValidationOrder(Collection<Class<?>> groups) {
if ( groups == null || groups.size() == 0 ) {
throw LOG.getAtLeastOneGroupHasToBeSpecifiedException();
}
if ( groups.size() == 1 && groups.contains( Default.class ) ) {
return ValidationOrder.DEFAULT_GROUP;
}
for ( Class<?> clazz : groups ) {
if ( !clazz.isInterface() ) {
throw LOG.getGroupHasToBeAnInterfaceException( clazz );
}
}
DefaultValidationOrder validationOrder = new DefaultValidationOrder();
for ( Class<?> clazz : groups ) {
if ( Default.class.equals( clazz ) ) {
validationOrder.insertGroup( Group.DEFAULT_GROUP );
}
else if ( isGroupSequence( clazz ) ) {
insertSequence( clazz, clazz.getAnnotation( GroupSequence.class ).value(), true, validationOrder );
}
else {
Group group = new Group( clazz );
validationOrder.insertGroup( group );
insertInheritedGroups( clazz, validationOrder );
}
}
return validationOrder;
}
public ValidationOrder getDefaultValidationOrder(Class<?> clazz, List<Class<?>> defaultGroupSequence) {
DefaultValidationOrder validationOrder = new DefaultValidationOrder();
insertSequence( clazz, defaultGroupSequence.toArray( new Class<?>[defaultGroupSequence.size()] ), false, validationOrder );
return validationOrder;
}
private boolean isGroupSequence(Class<?> clazz) {
return clazz.getAnnotation( GroupSequence.class ) != null;
}
private void insertInheritedGroups(Class<?> clazz, DefaultValidationOrder chain) {
for ( Class<?> inheritedGroup : clazz.getInterfaces() ) {
Group group = new Group( inheritedGroup );
chain.insertGroup( group );
insertInheritedGroups( inheritedGroup, chain );
}
}
private void insertSequence(Class<?> sequenceClass, Class<?>[] sequenceElements, boolean cache, DefaultValidationOrder validationOrder) {
Sequence sequence = cache ? resolvedSequences.get( sequenceClass ) : null;
if ( sequence == null ) {
sequence = resolveSequence( sequenceClass, sequenceElements, new ArrayList<Class<?>>() );
sequence.expandInheritedGroups();
if ( cache ) {
final Sequence cachedResolvedSequence = resolvedSequences.putIfAbsent( sequenceClass, sequence );
if ( cachedResolvedSequence != null ) {
sequence = cachedResolvedSequence;
}
}
}
validationOrder.insertSequence( sequence );
}
private Sequence resolveSequence(Class<?> sequenceClass, Class<?>[] sequenceElements, List<Class<?>> processedSequences) {
if ( processedSequences.contains( sequenceClass ) ) {
throw LOG.getCyclicDependencyInGroupsDefinitionException();
}
else {
processedSequences.add( sequenceClass );
}
List<Group> resolvedSequenceGroups = new ArrayList<Group>();
for ( Class<?> clazz : sequenceElements ) {
if ( isGroupSequence( clazz ) ) {
Sequence tmpSequence = resolveSequence( clazz, clazz.getAnnotation( GroupSequence.class ).value(), processedSequences );
addGroups( resolvedSequenceGroups, tmpSequence.getComposingGroups() );
}
else {
List<Group> list = new ArrayList<Group>();
list.add( new Group( clazz ) );
addGroups( resolvedSequenceGroups, list );
}
}
return new Sequence( sequenceClass, resolvedSequenceGroups );
}
private void addGroups(List<Group> resolvedGroupSequence, List<Group> groups) {
for ( Group tmpGroup : groups ) {
if ( resolvedGroupSequence.contains( tmpGroup ) && resolvedGroupSequence.indexOf( tmpGroup ) < resolvedGroupSequence
.size() - 1 ) {
throw LOG.getUnableToExpandGroupSequenceException();
}
resolvedGroupSequence.add( tmpGroup );
}
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder();
sb.append( "ValidationOrderGenerator" );
sb.append( "{resolvedSequences=" ).append( resolvedSequences );
sb.append( '}' );
return sb.toString();
}
}