1 /*
2  * Hibernate Validator, declare and validate application constraints
3  *
4  * License: Apache License, Version 2.0
5  * See the license.txt file in the root directory or <http://www.apache.org/licenses/LICENSE-2.0>.
6  */
7 package org.hibernate.validator.internal.xml.config;
8
9 import java.util.Collections;
10 import java.util.EnumSet;
11 import java.util.HashMap;
12 import java.util.HashSet;
13 import java.util.Map;
14 import java.util.Set;
15
16 import javax.validation.BootstrapConfiguration;
17 import javax.validation.executable.ExecutableType;
18
19 import org.hibernate.validator.internal.util.CollectionHelper;
20 import org.hibernate.validator.internal.util.stereotypes.Immutable;
21
22 /**
23  * Wrapper class for the bootstrap parameters defined in <i>validation.xml</i>
24  *
25  * @author Hardy Ferentschik
26  */
27 class BootstrapConfigurationImpl implements BootstrapConfiguration {
28
29     /**
30      * The executable types validated by default.
31      */
32     @Immutable
33     private static final Set<ExecutableType> DEFAULT_VALIDATED_EXECUTABLE_TYPES =
34             Collections.unmodifiableSet(
35                     EnumSet.of( ExecutableType.CONSTRUCTORS, ExecutableType.NON_GETTER_METHODS )
36             );
37
38     /**
39      * The validated executable types, when ALL is given.
40      */
41     @Immutable
42     private static final Set<ExecutableType> ALL_VALIDATED_EXECUTABLE_TYPES =
43             Collections.unmodifiableSet(
44                     EnumSet.complementOf(
45                             EnumSet.of(
46                                     ExecutableType.ALL,
47                                     ExecutableType.NONE,
48                                     ExecutableType.IMPLICIT
49                             )
50                     )
51             );
52
53     private static final BootstrapConfiguration DEFAULT_BOOTSTRAP_CONFIGURATION = new BootstrapConfigurationImpl();
54
55     private final String defaultProviderClassName;
56     private final String constraintValidatorFactoryClassName;
57     private final String messageInterpolatorClassName;
58     private final String traversableResolverClassName;
59     private final String parameterNameProviderClassName;
60     private final String clockProviderClassName;
61     private final Set<String> valueExtractorClassNames;
62     private final Set<String> constraintMappingResourcePaths;
63     private final Map<String, String> properties;
64     private final Set<ExecutableType> validatedExecutableTypes;
65     private final boolean isExecutableValidationEnabled;
66
67     private BootstrapConfigurationImpl() {
68         this.defaultProviderClassName = null;
69         this.constraintValidatorFactoryClassName = null;
70         this.messageInterpolatorClassName = null;
71         this.traversableResolverClassName = null;
72         this.parameterNameProviderClassName = null;
73         this.clockProviderClassName = null;
74         this.valueExtractorClassNames = new HashSet<>();
75         this.validatedExecutableTypes = DEFAULT_VALIDATED_EXECUTABLE_TYPES;
76         this.isExecutableValidationEnabled = true;
77         this.constraintMappingResourcePaths = new HashSet<>();
78         this.properties = new HashMap<>();
79     }
80
81     public BootstrapConfigurationImpl(String defaultProviderClassName,
82                                       String constraintValidatorFactoryClassName,
83                                       String messageInterpolatorClassName,
84                                       String traversableResolverClassName,
85                                       String parameterNameProviderClassName,
86                                       String clockProviderClassName,
87                                       Set<String> valueExtractorClassNames,
88                                       EnumSet<ExecutableType> validatedExecutableTypes,
89                                       boolean isExecutableValidationEnabled,
90                                       Set<String> constraintMappingResourcePaths,
91                                       Map<String, String> properties) {
92         this.defaultProviderClassName = defaultProviderClassName;
93         this.constraintValidatorFactoryClassName = constraintValidatorFactoryClassName;
94         this.messageInterpolatorClassName = messageInterpolatorClassName;
95         this.traversableResolverClassName = traversableResolverClassName;
96         this.parameterNameProviderClassName = parameterNameProviderClassName;
97         this.clockProviderClassName = clockProviderClassName;
98         this.valueExtractorClassNames = valueExtractorClassNames;
99         this.validatedExecutableTypes = prepareValidatedExecutableTypes( validatedExecutableTypes );
100         this.isExecutableValidationEnabled = isExecutableValidationEnabled;
101         this.constraintMappingResourcePaths = constraintMappingResourcePaths;
102         this.properties = properties;
103     }
104
105     public static BootstrapConfiguration getDefaultBootstrapConfiguration() {
106         return DEFAULT_BOOTSTRAP_CONFIGURATION;
107     }
108
109     private Set<ExecutableType> prepareValidatedExecutableTypes(EnumSet<ExecutableType> validatedExecutableTypes) {
110         if ( validatedExecutableTypes == null ) {
111             return DEFAULT_VALIDATED_EXECUTABLE_TYPES;
112         }
113
114         if ( validatedExecutableTypes.contains( ExecutableType.ALL ) ) {
115             return ALL_VALIDATED_EXECUTABLE_TYPES;
116         }
117
118         if ( validatedExecutableTypes.contains( ExecutableType.NONE ) ) {
119             if ( validatedExecutableTypes.size() == 1 ) {
120                 return Collections.emptySet();
121             }
122             else {
123                 EnumSet<ExecutableType> preparedValidatedExecutableTypes = EnumSet.copyOf( validatedExecutableTypes );
124                 preparedValidatedExecutableTypes.remove( ExecutableType.NONE );
125                 return CollectionHelper.toImmutableSet( preparedValidatedExecutableTypes );
126             }
127         }
128
129         return CollectionHelper.toImmutableSet( validatedExecutableTypes );
130     }
131
132     @Override
133     public String getDefaultProviderClassName() {
134         return defaultProviderClassName;
135     }
136
137     @Override
138     public String getConstraintValidatorFactoryClassName() {
139         return constraintValidatorFactoryClassName;
140     }
141
142     @Override
143     public String getMessageInterpolatorClassName() {
144         return messageInterpolatorClassName;
145     }
146
147     @Override
148     public String getTraversableResolverClassName() {
149         return traversableResolverClassName;
150     }
151
152     @Override
153     public String getParameterNameProviderClassName() {
154         return parameterNameProviderClassName;
155     }
156
157     @Override
158     public String getClockProviderClassName() {
159         return clockProviderClassName;
160     }
161
162     @Override
163     public Set<String> getValueExtractorClassNames() {
164         return new HashSet<>( valueExtractorClassNames );
165     }
166
167     @Override
168     public Set<String> getConstraintMappingResourcePaths() {
169         return new HashSet<>( constraintMappingResourcePaths );
170     }
171
172     @Override
173     public boolean isExecutableValidationEnabled() {
174         return isExecutableValidationEnabled;
175     }
176
177     @Override
178     public Set<ExecutableType> getDefaultValidatedExecutableTypes() {
179         return new HashSet<>( validatedExecutableTypes );
180     }
181
182     @Override
183     public Map<String, String> getProperties() {
184         return new HashMap<>( properties );
185     }
186
187     @Override
188     public String toString() {
189         final StringBuilder sb = new StringBuilder();
190         sb.append( "BootstrapConfigurationImpl" );
191         sb.append( "{defaultProviderClassName='" ).append( defaultProviderClassName ).append( '\'' );
192         sb.append( ", constraintValidatorFactoryClassName='" )
193                 .append( constraintValidatorFactoryClassName )
194                 .append( '\'' );
195         sb.append( ", messageInterpolatorClassName='" ).append( messageInterpolatorClassName ).append( '\'' );
196         sb.append( ", traversableResolverClassName='" ).append( traversableResolverClassName ).append( '\'' );
197         sb.append( ", parameterNameProviderClassName='" ).append( parameterNameProviderClassName ).append( '\'' );
198         sb.append( ", clockProviderClassName='" ).append( clockProviderClassName ).append( '\'' );
199         sb.append( ", validatedExecutableTypes='" ).append( validatedExecutableTypes ).append( '\'' );
200         sb.append( ", constraintMappingResourcePaths=" ).append( constraintMappingResourcePaths ).append( '\'' );
201         sb.append( ", properties=" ).append( properties );
202         sb.append( '}' );
203         return sb.toString();
204     }
205 }
206