/*
* Copyright 2012 Google Inc.
*
* Licensed 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 com.google.gwt.validation.client.impl.metadata;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Stack;
import javax.validation.groups.Default;
/**
* Contains all the information known about the inheritance information for validation groups.
*/
public class ValidationGroupsMetadata {
/**
* Builder for {@link ValidationGroupsMetadata}
*/
public static class Builder {
private final Map<Class<?>, Set<Class<?>>> inheritanceinheritanceMap;
private final Map<Class<?>, List<Class<?>>> sequenceMap;
private Builder() {
inheritanceinheritanceMap = new HashMap<Class<?>, Set<Class<?>>>();
sequenceMap = new HashMap<Class<?>, List<Class<?>>>();
addGroup(Default.class);
}
/**
* Adds a group to the inheritance map. May optionally include parents of the group.
* @param group The validation group to add.
* @param parents A list of validation groups which {@code group} extends. Can be empty if the
* group contains no parents.
*/
public Builder addGroup(Class<?> group, Class<?>... parents) {
inheritanceinheritanceMap.put(group, new HashSet<Class<?>>(Arrays.asList(parents)));
return this;
}
/**
* Adds a group sequence to the sequence map.
* @param groupSequence The class representing the sequence (annotated with @GroupSequence)
* @param sequenceGroups The groups in the sequence.
*/
public Builder addSequence(Class<?> groupSequence, Class<?>... sequenceGroups) {
sequenceMap.put(groupSequence, Arrays.asList(sequenceGroups));
return this;
}
public ValidationGroupsMetadata build() {
return new ValidationGroupsMetadata(inheritanceinheritanceMap, sequenceMap);
}
}
/**
* Creates a builder populated only with the {@link Default} group.
*/
public static Builder builder() {
return new Builder();
}
private final Map<Class<?>, Set<Class<?>>> inheritanceMapping;
private final Map<Class<?>, List<Class<?>>> sequenceMapping;
private ValidationGroupsMetadata(Map<Class<?>, Set<Class<?>>> inheritanceinheritanceMap,
Map<Class<?>, List<Class<?>>> sequenceMap) {
this.inheritanceMapping = Collections.unmodifiableMap(inheritanceinheritanceMap);
this.sequenceMapping = Collections.unmodifiableMap(sequenceMap);
}
/**
* Checks if a given group has been added to the inheritance map.
*/
public boolean containsGroup(Class<?> group) {
return inheritanceMapping.containsKey(group);
}
@Override
public boolean equals(Object other) {
if (this == other) {
return true;
}
if (!(other instanceof ValidationGroupsMetadata)) {
return false;
}
ValidationGroupsMetadata otherObj = (ValidationGroupsMetadata)other;
return inheritanceMapping.equals(otherObj.inheritanceMapping)
&& sequenceMapping.equals(otherObj.sequenceMapping);
}
/**
* Finds all of the validation groups extended by an intial set of groups.
* @param baseGroups The initial set of groups to find parents of. These groups must have been
* added to the inheritance map already.
* @return A unified set of groups and their parents.
* @throws IllegalArgumentException If an initial group has not been added to the map before
* calling this method.
*/
public Set<Class<?>> findAllExtendedGroups(Collection<Class<?>> baseGroups)
throws IllegalArgumentException {
Set<Class<?>> found = new HashSet<Class<?>>();
Stack<Class<?>> remaining = new Stack<Class<?>>();
// initialize
for (Class<?> group : baseGroups) {
if (!inheritanceMapping.containsKey(group)) {
throw new IllegalArgumentException("The collection of groups contains a group which" +
" was not added to the map. Be sure to call addGroup() for all groups first.");
}
remaining.push(group);
}
// traverse
Class<?> current;
Set<Class<?>> superInterfaces;
while (!remaining.isEmpty()) {
current = remaining.pop();
found.add(current);
superInterfaces = inheritanceMapping.get(current);
for (Class<?> parent : superInterfaces) {
if (!found.contains(parent)) {
remaining.push(parent);
}
}
}
return found;
}
/**
* Recursively gets all of the groups and sequence groups in the map (children and parents alike)
* in one flat set.
*/
public Set<Class<?>> getAllGroupsAndSequences() {
Set<Class<?>> allGroups = new HashSet<Class<?>>();
for (Map.Entry<Class<?>, Set<Class<?>>> entry : inheritanceMapping.entrySet()) {
allGroups.add(entry.getKey());
allGroups.addAll(entry.getValue());
}
allGroups.addAll(sequenceMapping.keySet());
return allGroups;
}
/**
* Returns all the known group sequence classes.
*/
public Set<Class<?>> getGroupSequences() {
return sequenceMapping.keySet();
}
/**
* If the group has been added to the map then its parent groups (of one level above) are
* retrieved. Otherwise null is returned.
*
* @see #containsGroup(Class)
* @see #findAllExtendedGroups(Collection)
*/
public Set<Class<?>> getParentsOfGroup(Class<?> group) {
return inheritanceMapping.get(group);
}
/**
* Returns all of the groups added to the map (but not their parents).
*/
public Set<Class<?>> getRootGroups() {
return inheritanceMapping.keySet();
}
/**
* If the sequence class has been added to the map then the actual sequence list is retrieved.
* Otherwise null is returned.
*/
public List<Class<?>> getSequenceList(Class<?> sequence) {
return sequenceMapping.get(sequence);
}
@Override
public int hashCode() {
int result = inheritanceMapping.hashCode();
result = 31 * result + sequenceMapping.hashCode();
return result;
}
/**
* Checks if a group extends other groups (has parents).
*/
public boolean hasParents(Class<?> group) {
Set<Class<?>> possibleParents = getParentsOfGroup(group);
return possibleParents != null && !possibleParents.isEmpty();
}
public boolean isInheritanceMapEmpty() {
return inheritanceMapping.isEmpty();
}
/**
* Checks if a given class is a group sequence map.
*/
public boolean isSeqeuence(Class<?> sequence) {
return sequenceMapping.containsKey(sequence);
}
public boolean isSequenceMapEmpty() {
return sequenceMapping.isEmpty();
}
@Override
public String toString() {
return "ValidationGroupsMetaData{inheritanceMap=" + inheritanceMapping + ", " +
"sequenceMap=" + sequenceMapping + "}";
}
}