| /* | |
| * 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; | |
| import java.util.ArrayList; | |
| import java.util.Collection; | |
| import java.util.HashMap; | |
| import java.util.Iterator; | |
| import java.util.List; | |
| import java.util.Map; | |
| import javax.validation.GroupDefinitionException; | |
| import javax.validation.groups.Default; | |
| /** | |
| * An instance of {@code GroupChain} defines the group order during one full validation call. | |
| * <p> | |
| * Modified from the Hibernate validator for use with GWT. | |
| */ | |
| public final class GroupChain { | |
| /** | |
| * The list of single groups to be used this validation. | |
| */ | |
| private final List<Group> groupList = new ArrayList<Group>(); | |
| /** | |
| * The different sequences for this validation. The map contains the list of groups mapped to | |
| * their sequence name. | |
| */ | |
| private final Map<Class<?>, List<Group>> sequenceMap = new HashMap<Class<?>, List<Group>>(); | |
| public void checkDefaultGroupSequenceIsExpandable(List<Class<?>> defaultGroupSequence) | |
| throws GroupDefinitionException { | |
| for (Map.Entry<Class<?>, List<Group>> entry : sequenceMap.entrySet()) { | |
| Class<?> sequence = entry.getKey(); | |
| List<Group> groups = entry.getValue(); | |
| List<Group> defaultGroupList = buildTempGroupList(defaultGroupSequence, sequence); | |
| int defaultGroupIndex = containsDefaultGroupAtIndex(sequence, groups); | |
| if (defaultGroupIndex != -1) { | |
| ensureDefaultGroupSequenceIsExpandable(groups, defaultGroupList, defaultGroupIndex); | |
| } | |
| } | |
| } | |
| public Collection<Group> getAllGroups() { | |
| return groupList; | |
| } | |
| public Iterator<Group> getGroupIterator() { | |
| return groupList.iterator(); | |
| } | |
| public Iterator<List<Group>> getSequenceIterator() { | |
| return sequenceMap.values().iterator(); | |
| } | |
| public void insertGroup(Group group) { | |
| if (!groupList.contains(group)) { | |
| groupList.add(group); | |
| } | |
| } | |
| public void insertSequence(List<Group> groups) { | |
| if (groups != null && groups.size() != 0) { | |
| if (!sequenceMap.containsValue(groups)) { | |
| sequenceMap.put(groups.get(0).getSequence(), groups); | |
| } | |
| } | |
| } | |
| @Override | |
| public String toString() { | |
| return "GroupChain{" + | |
| "groupList=" + groupList + | |
| ", sequenceMap=" + sequenceMap + | |
| "}"; | |
| } | |
| private List<Group> buildTempGroupList(List<Class<?>> defaultGroupSequence, Class<?> sequence) { | |
| List<Group> groups = new ArrayList<Group>(); | |
| for (Class<?> clazz : defaultGroupSequence) { | |
| Group g = new Group(clazz, sequence); | |
| groups.add(g); | |
| } | |
| return groups; | |
| } | |
| private int containsDefaultGroupAtIndex(Class<?> sequence, List<Group> groupList) { | |
| Group defaultGroup = new Group(Default.class, sequence); | |
| return groupList.indexOf(defaultGroup); | |
| } | |
| private void ensureDefaultGroupSequenceIsExpandable(List<Group> groupList, | |
| List<Group> defaultGroupList, int defaultGroupIndex) throws GroupDefinitionException { | |
| for (int i = 0; i < defaultGroupList.size(); i++) { | |
| Group group = defaultGroupList.get(i); | |
| if (group.getGroup().equals(Default.class)) { | |
| // we don't have to consider the default group since it is the one we want to replace | |
| continue; | |
| } | |
| // check whether the sequence contains group of the default group sequence | |
| int index = groupList.indexOf(group); | |
| if (index == -1) { | |
| continue; // if the group is not in the sequence we can continue | |
| } | |
| if ((i == 0 && index == defaultGroupIndex - 1) | |
| || (i == defaultGroupList.size() - 1 && index == defaultGroupIndex + 1)) { | |
| // if we are at the beginning or end of he defaultGroupSequence and the matches are either | |
| // directly before resp after we can continue as well, since we basically have two groups | |
| continue; | |
| } | |
| throw new GroupDefinitionException("Unable to expand default group list " + defaultGroupList + | |
| " into sequence " + groupList); | |
| } | |
| } | |
| } |