1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17 package org.apache.commons.configuration2.builder.combined;
18
19 import java.util.Collection;
20
21 import org.apache.commons.configuration2.builder.BuilderParameters;
22 import org.apache.commons.configuration2.builder.FileBasedBuilderParametersImpl;
23 import org.apache.commons.configuration2.ex.ConfigurationException;
24
25 /**
26 * <p>
27 * A specialized implementation of {@link ConfigurationBuilderProvider} which determines the name of the result
28 * configuration class based on the extension of the file to load.
29 * </p>
30 * <p>
31 * This class works analogously to its base class {@link BaseConfigurationBuilderProvider}; especially, the resulting
32 * builder is created based on reflection. It extends the super class's functionality by a specific mechanism for
33 * determining the resulting configuration class: At construction time two configuration class names and a file
34 * extension are passed in. If a file name is provided in the builder's initialization parameters and this file name has
35 * the specified extension, then the first configuration class name is used; otherwise the default configuration class
36 * name is selected.
37 * </p>
38 * <p>
39 * There are some tags for {@code CombinedConfigurationProvider} which can produce different results depending on the
40 * configuration files they have to load. This class can be used to implement this feature in a generic way.
41 * </p>
42 *
43 * @since 2.0
44 */
45 public class FileExtensionConfigurationBuilderProvider extends BaseConfigurationBuilderProvider {
46 /** Constant for the file extension separator. */
47 private static final char EXT_SEPARATOR = '.';
48
49 /** The matching configuration class. */
50 private final String matchingConfigurationClass;
51
52 /** The file extension. */
53 private final String extension;
54
55 /**
56 * Creates a new instance of {@code FileExtensionConfigurationBuilderProvider}.
57 *
58 * @param bldrCls the name of the builder class
59 * @param reloadBldrCls the name of a builder class to be used if reloading support is required (<b>null</b> if
60 * reloading is not supported)
61 * @param matchingConfigCls the name of the configuration class to be used if the provided file extension matches (must
62 * not be <b>null</b>)
63 * @param defConfigClass the name of the configuration class to be used if the provided file extension does not match
64 * (must not be <b>null</b>)
65 * @param ext the file extension to select the configuration class (must not be <b>null</b>)
66 * @param paramCls a collection with the names of parameters classes; an instance of a parameters object with basic
67 * properties is created automatically and does not need to be contained in this list; the collection can be
68 * <b>null</b> if no additional parameter objects are needed
69 * @throws IllegalArgumentException if a required parameter is missing
70 */
71 public FileExtensionConfigurationBuilderProvider(final String bldrCls, final String reloadBldrCls, final String matchingConfigCls,
72 final String defConfigClass, final String ext, final Collection<String> paramCls) {
73 super(bldrCls, reloadBldrCls, defConfigClass, paramCls);
74 if (matchingConfigCls == null) {
75 throw new IllegalArgumentException("Matching configuration class must not be null!");
76 }
77 if (ext == null) {
78 throw new IllegalArgumentException("File extension must not be null!");
79 }
80
81 matchingConfigurationClass = matchingConfigCls;
82 extension = ext;
83 }
84
85 /**
86 * Gets the name of the matching configuration class. This class is used if the file extension matches the extension
87 * of this provider.
88 *
89 * @return the matching configuration class
90 */
91 public String getMatchingConfigurationClass() {
92 return matchingConfigurationClass;
93 }
94
95 /**
96 * Gets the file extension of this provider.
97 *
98 * @return the file extension to match
99 */
100 public String getExtension() {
101 return extension;
102 }
103
104 /**
105 * {@inheritDoc} This implementation tries to find a {@link FileBasedBuilderParametersImpl} object in the parameter
106 * objects. If one is found, the extension of the file name is obtained and compared against the stored file extension.
107 * In case of a match, the matching configuration class is selected, otherwise the default one.
108 */
109 @Override
110 protected String determineConfigurationClass(final ConfigurationDeclaration decl, final Collection<BuilderParameters> params)
111 throws ConfigurationException {
112 final String currentExt = extractExtension(fetchCurrentFileName(params));
113 return getExtension().equalsIgnoreCase(currentExt) ? getMatchingConfigurationClass() : getConfigurationClass();
114 }
115
116 /**
117 * Tries to obtain the current file name from the given list of parameter objects.
118 *
119 * @param params the parameter objects
120 * @return the file name or <b>null</b> if unspecified
121 */
122 private static String fetchCurrentFileName(final Collection<BuilderParameters> params) {
123 for (final BuilderParameters p : params) {
124 if (p instanceof FileBasedBuilderParametersImpl) {
125 final FileBasedBuilderParametersImpl fp = (FileBasedBuilderParametersImpl) p;
126 return fp.getFileHandler().getFileName();
127 }
128 }
129 return null;
130 }
131
132 /**
133 * Extracts the extension from the given file name. The name can be <b>null</b>.
134 *
135 * @param fileName the file name
136 * @return the extension (<b>null</b> if there is none)
137 */
138 private static String extractExtension(final String fileName) {
139 if (fileName == null) {
140 return null;
141 }
142
143 final int pos = fileName.lastIndexOf(EXT_SEPARATOR);
144 return pos < 0 ? null : fileName.substring(pos + 1);
145 }
146 }