Fixed sonar issues
[sdc.git] / common / onap-common-configuration-management / onap-configuration-management-core / src / main / java / org / onap / config / ConfigurationUtils.java
1 /*
2  * Copyright © 2016-2018 European Support Limited
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  * Modifications Copyright (c) 2019 Samsung
17  *
18  */
19
20 package org.onap.config;
21
22 import com.virtlink.commons.configuration2.jackson.JsonConfiguration;
23 import net.sf.corn.cps.CPScanner;
24 import net.sf.corn.cps.ResourceFilter;
25 import org.apache.commons.configuration2.Configuration;
26 import org.apache.commons.configuration2.CompositeConfiguration;
27 import org.apache.commons.configuration2.FileBasedConfiguration;
28 import org.apache.commons.configuration2.PropertiesConfiguration;
29 import org.apache.commons.configuration2.XMLConfiguration;
30 import org.apache.commons.configuration2.builder.BasicConfigurationBuilder;
31 import org.apache.commons.configuration2.builder.FileBasedConfigurationBuilder;
32 import org.apache.commons.configuration2.builder.ReloadingFileBasedConfigurationBuilder;
33 import org.apache.commons.configuration2.builder.fluent.Configurations;
34 import org.apache.commons.configuration2.builder.fluent.Parameters;
35 import org.apache.commons.configuration2.convert.DefaultListDelimiterHandler;
36 import org.apache.commons.configuration2.ex.ConfigurationException;
37 import org.apache.commons.io.IOUtils;
38 import org.onap.config.api.Config;
39 import org.onap.config.api.ConfigurationManager;
40 import org.onap.config.impl.YamlConfiguration;
41 import org.onap.config.type.ConfigurationMode;
42 import org.onap.config.type.ConfigurationType;
43 import org.slf4j.Logger;
44 import org.slf4j.LoggerFactory;
45
46 import java.io.File;
47 import java.io.IOException;
48 import java.lang.reflect.Array;
49 import java.lang.reflect.Field;
50 import java.lang.reflect.ParameterizedType;
51 import java.lang.reflect.Type;
52 import java.net.MalformedURLException;
53 import java.net.URL;
54 import java.nio.charset.Charset;
55 import java.nio.file.Files;
56 import java.nio.file.FileVisitResult;
57 import java.nio.file.Path;
58 import java.nio.file.SimpleFileVisitor;
59 import java.nio.file.attribute.BasicFileAttributes;
60 import java.util.ArrayDeque;
61 import java.util.ArrayList;
62 import java.util.Arrays;
63 import java.util.Collection;
64 import java.util.Collections;
65 import java.util.Deque;
66 import java.util.HashMap;
67 import java.util.HashSet;
68 import java.util.List;
69 import java.util.Map;
70 import java.util.Objects;
71 import java.util.Optional;
72 import java.util.Queue;
73 import java.util.Set;
74 import java.util.SortedSet;
75 import java.util.TreeSet;
76 import java.util.concurrent.BlockingQueue;
77 import java.util.concurrent.ConcurrentLinkedQueue;
78 import java.util.concurrent.LinkedBlockingQueue;
79 import java.util.concurrent.LinkedTransferQueue;
80 import java.util.concurrent.TransferQueue;
81 import java.util.function.Predicate;
82 import java.util.regex.Matcher;
83 import java.util.regex.Pattern;
84 import java.util.stream.Collectors;
85
86 import static java.util.Optional.ofNullable;
87 import static org.onap.config.api.Hint.EXTERNAL_LOOKUP;
88 import static org.onap.config.api.Hint.LATEST_LOOKUP;
89 import static org.onap.config.api.Hint.NODE_SPECIFIC;
90
91 public class ConfigurationUtils {
92
93     private static final Logger LOGGER = LoggerFactory.getLogger(ConfigurationUtils.class);
94
95     private static final String CONFIGURATION_TYPE_NOT_SUPPORTED = "Configuration type not supported:";
96
97     private static final Map<Class<?>, Class<?>> ARRAY_CLASS_MAP;
98
99     private static final String CONFIG_REGEX_TPL_OPT_1 = "CONFIG(-\\w*){0,1}(-(%s|%s|%s)){0,1}\\.(%s|%s|%s|%s)$";
100
101     private static final String CONFIG_REGEX_TPL_OPT_2 = "CONFIG(.)*\\.(%s|%s|%s|%s)$";
102
103     static {
104         Map<Class<?>, Class<?>> arrayTypes = new HashMap<>();
105         arrayTypes.put(Byte.class, Byte[].class);
106         arrayTypes.put(Short.class, Short[].class);
107         arrayTypes.put(Integer.class, Integer[].class);
108         arrayTypes.put(Long.class, Long[].class);
109         arrayTypes.put(Float.class, Float[].class);
110         arrayTypes.put(Double.class, Double[].class);
111         arrayTypes.put(Boolean.class, Boolean[].class);
112         arrayTypes.put(Character.class, Character[].class);
113         arrayTypes.put(String.class, String[].class);
114         ARRAY_CLASS_MAP = Collections.unmodifiableMap(arrayTypes);
115     }
116
117     private ConfigurationUtils() {
118         // prevent instantiation
119     }
120
121     public static Collection<File> getAllFiles(File file, boolean recursive, boolean onlyDirectory) {
122         ArrayList<File> collection = new ArrayList<>();
123         Path rootPath = file.toPath();
124         try {
125             Files.walkFileTree(rootPath, new SimpleFileVisitor<Path>() {
126                 @Override
127                 public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
128                     super.preVisitDirectory(dir,attrs);
129                     if (rootPath.equals(dir)) {
130                         return FileVisitResult.CONTINUE;
131                     }
132                     collection.add(dir.toFile());
133                     return recursive? FileVisitResult.CONTINUE : FileVisitResult.SKIP_SUBTREE;
134                 }
135
136                 @Override
137                 public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
138                     super.visitFile(file, attrs);
139                     if (!onlyDirectory) {
140                         collection.add(file.toFile());
141                     }
142                     return FileVisitResult.CONTINUE;
143                 }
144             });
145         } catch (IOException e) {
146             LOGGER.error("Failed to walk through directories starting from: {}.", file.toString(), e);
147         }
148         return collection;
149     }
150
151     public static String getCommaSeparatedList(String[] list) {
152         return (list == null) || (list.length == 0) ? "" : getCommaSeparatedList(Arrays.asList(list));
153     }
154
155     public static String getCommaSeparatedList(List<?> list) {
156
157         if ((list == null) || list.isEmpty()) {
158             return "";
159         }
160
161         return list.stream().filter(o -> o != null && !o.toString().trim().isEmpty())
162                 .map(o -> o.toString().trim()).collect(Collectors.joining(","));
163     }
164
165     public static boolean isConfig(URL url) {
166         return isConfig(url.getFile());
167     }
168
169     public static boolean isConfig(String file) {
170         file = file.toUpperCase().substring(file.lastIndexOf('!') + 1);
171         file = file.substring(file.lastIndexOf('/') + 1);
172         return file.matches(
173                 String.format(
174                         CONFIG_REGEX_TPL_OPT_1,
175                         ConfigurationMode.OVERRIDE,
176                         ConfigurationMode.MERGE,
177                         ConfigurationMode.UNION,
178                         ConfigurationType.PROPERTIES.name(),
179                         ConfigurationType.XML.name(),
180                         ConfigurationType.JSON.name(),
181                         ConfigurationType.YAML.name()
182                 )
183         ) || file.matches(
184                 String.format(
185                         CONFIG_REGEX_TPL_OPT_2,
186                         ConfigurationType.PROPERTIES.name(),
187                         ConfigurationType.XML.name(),
188                         ConfigurationType.JSON.name(),
189                         ConfigurationType.YAML.name()
190                 )
191         );
192     }
193
194     public static boolean isConfig(File file) {
195         return file != null && file.exists() && isConfig(file.getName());
196     }
197
198     private static Optional<String> readNamespace(Configuration config) {
199         return ofNullable(config).flatMap(configuration -> ofNullable(configuration.getString(Constants.NAMESPACE_KEY)))
200                 .map(String::toUpperCase);
201     }
202
203     private static Optional<String> readMergeStrategy(Configuration config) {
204         return ofNullable(config).flatMap(configuration -> ofNullable(configuration.getString(Constants.MODE_KEY)))
205                 .map(String::toUpperCase);
206     }
207
208     public static ConfigurationMode getMergeStrategy(File file) {
209         Optional<ConfigurationMode> configurationMode =
210                 getConfiguration(file).flatMap(ConfigurationUtils::readMergeStrategy)
211                         .flatMap(ConfigurationUtils::convertConfigurationMode);
212         return configurationMode.orElseGet(() -> getMergeStrategy(file.getName().toUpperCase()));
213     }
214
215     public static ConfigurationMode getMergeStrategy(URL url) {
216         Optional<ConfigurationMode> configurationMode =
217                 getConfiguration(url).flatMap(ConfigurationUtils::readMergeStrategy)
218                         .flatMap(ConfigurationUtils::convertConfigurationMode);
219         return configurationMode.orElseGet(() -> getMergeStrategy(url.getFile().toUpperCase()));
220     }
221
222     public static ConfigurationMode getMergeStrategy(String file) {
223
224         file = file.toUpperCase().substring(file.lastIndexOf('!') + 1);
225         file = file.substring(file.lastIndexOf('/') + 1);
226         Pattern pattern = Pattern.compile(
227                 String.format(
228                         CONFIG_REGEX_TPL_OPT_1,
229                         ConfigurationMode.OVERRIDE,
230                         ConfigurationMode.MERGE,
231                         ConfigurationMode.UNION,
232                         ConfigurationType.PROPERTIES.name(),
233                         ConfigurationType.XML.name(),
234                         ConfigurationType.JSON.name(),
235                         ConfigurationType.YAML.name()
236                 )
237         );
238         Matcher matcher = pattern.matcher(file);
239         boolean b1 = matcher.matches();
240         if (b1) {
241             for (int i = 1; i <= matcher.groupCount(); i++) {
242                 String modeName = matcher.group(i);
243                 if (modeName != null) {
244                     modeName = modeName.substring(1);
245                 }
246                 try {
247                     return Enum.valueOf(ConfigurationMode.class, modeName);
248                 } catch (Exception exception) {
249                     LOGGER.debug("Configuration mode for merge strategy '{}' not found", modeName, exception);
250                 }
251             }
252         }
253
254         return null;
255     }
256
257     public static Optional<FileBasedConfiguration> getConfiguration(URL url) {
258
259         try {
260
261             ConfigurationType configType = ConfigurationUtils.getConfigType(url);
262             switch (configType) {
263                 case PROPERTIES:
264                     return Optional.of(new Configurations().fileBased(PropertiesConfiguration.class, url));
265                 case XML:
266                     return Optional.of(new Configurations().fileBased(XMLConfiguration.class, url));
267                 case JSON:
268                     return Optional.of(new Configurations().fileBased(JsonConfiguration.class, url));
269                 case YAML:
270                     return Optional.of(new Configurations().fileBased(YamlConfiguration.class, url));
271                 default:
272                     throw new ConfigurationException(CONFIGURATION_TYPE_NOT_SUPPORTED + configType);
273             }
274         } catch (ConfigurationException exception) {
275             LOGGER.error("Error reading configuration at {}.", url.toString(), exception);
276         }
277
278         return Optional.empty();
279     }
280
281     public static Optional<FileBasedConfiguration> getConfiguration(File file) {
282
283         try {
284             return getConfiguration(file.getAbsoluteFile().toURI().toURL());
285         } catch (MalformedURLException e) {
286             throw new IllegalStateException("Malformed URL: " + file.getAbsolutePath());
287         }
288     }
289
290     public static ConfigurationType getConfigType(File file) {
291         Objects.requireNonNull(file, "File cannot be null");
292         return Enum.valueOf(ConfigurationType.class,
293                 file.getAbsolutePath().substring(file.getAbsolutePath().lastIndexOf('.') + 1).toUpperCase());
294     }
295
296     public static ConfigurationType getConfigType(URL url) {
297         Objects.requireNonNull(url, "URL cannot be null");
298         return Enum.valueOf(ConfigurationType.class,
299                 url.getFile().substring(url.getFile().lastIndexOf('.') + 1).toUpperCase());
300     }
301
302     private static Optional<ConfigurationMode> convertConfigurationMode(String configMode) {
303         ConfigurationMode configurationMode = null;
304         try {
305             configurationMode = ConfigurationMode.valueOf(configMode);
306         } catch (Exception exception) {
307             LOGGER.error("Could not find convert {} into configuration mode.", configMode, exception);
308         }
309         return Optional.ofNullable(configurationMode);
310     }
311
312     public static Class<?> getCollectionGenericType(Field field) {
313         Type type = field.getGenericType();
314
315         if (type instanceof ParameterizedType) {
316
317             ParameterizedType paramType = (ParameterizedType) type;
318             Type[] arr = paramType.getActualTypeArguments();
319             if (arr.length > 0) {
320                 Class<?> clazz = (Class<?>) arr[0];
321                 if (isWrapperClass(clazz)) {
322                     return clazz;
323                 } else {
324                     throw new IllegalArgumentException("Collection of type " + clazz.getName() + " not supported.");
325                 }
326             }
327         }
328
329         return String[].class;
330     }
331
332     public static boolean isWrapperClass(Class<?> clazz) {
333         Predicate<Class<?>> predicateWrapper = type -> type == String.class || type == Boolean.class || type == Character.class
334                 || Number.class.isAssignableFrom(type);
335         return isA(predicateWrapper, clazz);
336     }
337
338     public static boolean isAPrimitive(Class<?> clazz) {
339         return isA(Class::isPrimitive, clazz);
340     }
341
342     /**
343      * Check if clazz implementing Map iface
344      */
345     public static boolean isAMap(Class<?> clazz) {
346         Predicate<Class<?>> predicateMap = Map.class::isAssignableFrom;
347         return isA(predicateMap, clazz);
348     }
349
350     /**
351      * Check if clazz implementing Collection iface
352      */
353     public static boolean isACollection(Class<?> clazz) {
354         Predicate<Class<?>> predicateCollection = Collection.class::isAssignableFrom;
355         return isA(predicateCollection, clazz);
356     }
357
358     /**
359      * Check if clazz is a primitive or primitive wrapper
360      */
361     public static boolean isAPrimitiveOrWrapper(Class<?> clazz) {
362         Predicate<Class<?>> predicatePrimitive = Class::isPrimitive;
363         Predicate<Class<?>> predicateWrapper = ConfigurationUtils::isWrapperClass;
364         return isA(predicatePrimitive.or(predicateWrapper), clazz);
365     }
366
367     /**
368      * Check if clazz is array of primitives or array of primitives wrappers
369      */
370     public static boolean isAPrimitivesOrWrappersArray(Class<?> clazz) {
371         Predicate<Class<?>> predicatePrimitivesOrWrappersArray =
372                 type -> ConfigurationUtils.isAWrappersArray(type) || ConfigurationUtils.isAPrimitivesArray(type);
373         return isA(predicatePrimitivesOrWrappersArray, clazz);
374
375     }
376
377     /**
378      * Check is clazz is array of primitives
379      */
380     public static boolean isAPrimitivesArray(Class<?> clazz) {
381         Predicate<Class<?>> predicateArray = Class::isArray;
382         Predicate<Class<?>> predicateComponentPrimitive = type -> type.getComponentType().isPrimitive();
383         return isA(predicateArray.and(predicateComponentPrimitive), clazz);
384     }
385
386     /**
387      * Check is clazz is array of primitives wrappers
388      */
389     public static boolean isAWrappersArray(Class<?> clazz) {
390         Predicate<Class<?>> predicateArray = Class::isArray;
391         Predicate<Class<?>> predicateComponentWrapper = type -> isWrapperClass(type.getComponentType());
392         return isA(predicateArray.and(predicateComponentWrapper), clazz);
393     }
394
395     private static boolean isA(Predicate<Class<?>> predicate, Class<?> clazz) {
396         return predicate.test(clazz);
397     }
398
399     public static Class<?> getArrayClass(Class<?> clazz) {
400         return ARRAY_CLASS_MAP.getOrDefault(clazz, null);
401     }
402
403     public static List<URL> getAllClassPathResources() {
404         return CPScanner.scanResources(new ResourceFilter());
405     }
406
407     public static BasicConfigurationBuilder<FileBasedConfiguration> getConfigurationBuilder(File file) {
408         FileBasedConfigurationBuilder<FileBasedConfiguration> builder;
409         ConfigurationType configType = ConfigurationUtils.getConfigType(file);
410         builder = getFileBasedConfigurationBuilder(configType);
411         builder.configure(new Parameters().fileBased().setFile(file)
412                 .setListDelimiterHandler(new DefaultListDelimiterHandler(',')));
413         return builder;
414     }
415
416     public static BasicConfigurationBuilder<FileBasedConfiguration> getConfigurationBuilder(URL url) {
417         ConfigurationType configType = ConfigurationUtils.getConfigType(url);
418         ReloadingFileBasedConfigurationBuilder<FileBasedConfiguration> builder =
419                 getFileBasedConfigurationBuilder(configType);
420         builder.configure(
421                 new Parameters().fileBased().setURL(url).setListDelimiterHandler(new DefaultListDelimiterHandler(',')));
422         return builder;
423     }
424
425     private static ReloadingFileBasedConfigurationBuilder<FileBasedConfiguration> getFileBasedConfigurationBuilder(
426             ConfigurationType configType) {
427
428         ReloadingFileBasedConfigurationBuilder<FileBasedConfiguration> builder;
429         switch (configType) {
430             case PROPERTIES:
431                 builder = new ReloadingFileBasedConfigurationBuilder<>(PropertiesConfiguration.class);
432                 break;
433             case XML:
434                 builder = new ReloadingFileBasedConfigurationBuilder<>(XMLConfiguration.class);
435                 break;
436             case JSON:
437                 builder = new ReloadingFileBasedConfigurationBuilder<>(JsonConfiguration.class);
438                 break;
439             case YAML:
440                 builder = new ReloadingFileBasedConfigurationBuilder<>(YamlConfiguration.class);
441                 break;
442             default:
443                 throw new IllegalArgumentException(CONFIGURATION_TYPE_NOT_SUPPORTED + configType);
444         }
445         return builder;
446     }
447
448     public static <T> T read(Configuration config, Class<T> clazz, String keyPrefix) throws Exception {
449         Config confAnnotation = clazz.getAnnotation(Config.class);
450         if (confAnnotation != null) {
451             keyPrefix += (confAnnotation.key() + ".");
452         }
453         T objToReturn = clazz.newInstance();
454         for (Field field : clazz.getDeclaredFields()) {
455             Config fieldAnnotation = field.getAnnotation(Config.class);
456             if (fieldAnnotation != null) {
457                 field.setAccessible(true);
458                 field.set(objToReturn, config.getProperty(keyPrefix + fieldAnnotation.key()));
459             } else if (field.getType().getAnnotation(Config.class) != null) {
460                 field.set(objToReturn, read(config, field.getType(), keyPrefix));
461             }
462         }
463         return objToReturn;
464     }
465
466     public static Object getPrimitiveArray(Collection<?> collection, Class<?> clazz) {
467         switch (clazz.getName()) {
468             case "int":
469                 return getIntsPrimitiveArray(collection);
470             case "byte":
471                 return getBytesPrimitiveArray(collection);
472             case "short":
473                 return getShortsPrimitiveArray(collection);
474             case "long":
475                 return getLongsPrimitiveArray(collection);
476             case "float":
477                 return getFloatsPrimitiveArray(collection);
478             case "double":
479                 return getDoublesPrimitiveArray(collection);
480             case "boolean":
481                 return getBooleansPrimitiveArray(collection);
482             case "char":
483                 return getCharsPrimitiveArray(collection);
484             default:
485                 return null;
486         }
487     }
488
489     public static Object getWrappersArray(Collection<?> collection, Class<?> clazz) {
490         Object array = null;
491         if (isWrapperClass(clazz)){
492             int collectionSize = collection.size();
493             array = Array.newInstance(clazz, collection.size());
494             Object[] objArray = collection.toArray();
495             System.arraycopy(objArray, 0, array, 0, collectionSize);
496         }
497         return array;
498     }
499
500     public static String getCollectionString(String input) {
501         Pattern pattern = Pattern.compile("^\\[(.*)\\]$");
502         Matcher matcher = pattern.matcher(input);
503         if (matcher.matches()) {
504             input = matcher.group(1);
505         }
506         return input;
507     }
508
509     public static String processVariablesIfPresent(String tenant, String namespace, String data) {
510         Pattern pattern = Pattern.compile("^.*\\$\\{(.*)\\}.*");
511         Matcher matcher = pattern.matcher(data);
512         if (matcher.matches()) {
513             final int substringStartIndex = 4;
514             String key = matcher.group(1);
515             String value;
516             if (key.toUpperCase().startsWith("ENV:")) {
517                 value = System.getenv(key.substring(substringStartIndex));
518             } else if (key.toUpperCase().startsWith("SYS:")) {
519                 value = System.getProperty(key.substring(substringStartIndex));
520             } else {
521                 value = ConfigurationUtils.getCollectionString(
522                         ConfigurationManager.lookup().getAsStringValues(tenant, namespace, key).toString());
523             }
524             return processVariablesIfPresent(tenant, namespace, data.replaceAll("\\$\\{" + key + "}",
525                     value == null ? "" : value.replace("\\", "\\\\")));
526         } else {
527             return data;
528         }
529     }
530
531     public static String getFileContents(String path) {
532         try {
533             if (path != null) {
534                 return IOUtils.toString(new URL(path), Charset.defaultCharset());
535             }
536         } catch (Exception exception) {
537             LOGGER.error("Error while getting '{}' content", path, exception);
538         }
539         return null;
540     }
541
542     public static String getFileContents(Path path) {
543         try {
544             if (path != null) {
545                 return new String(Files.readAllBytes(path));
546             }
547         } catch (Exception exception) {
548             LOGGER.error("Error while getting '{}' content", path.toString(), exception);
549         }
550         return null;
551     }
552
553     public static Object getDefaultFor(Class<?> clazz) {
554         if (byte.class == clazz) {
555             return new Byte("0");
556         } else if (short.class == clazz) {
557             return new Short("0");
558         } else if (int.class == clazz) {
559             return new Integer("0");
560         } else if (float.class == clazz) {
561             return new Float("0");
562         } else if (long.class == clazz) {
563             return new Long("0");
564         } else if (double.class == clazz) {
565             return new Double("0");
566         } else if (boolean.class == clazz) {
567             return Boolean.FALSE;
568         }
569         return (char) 0;
570     }
571
572     public static Collection getCompatibleCollectionForAbstractDef(Class<?> clazz) {
573         if (TransferQueue.class.isAssignableFrom(clazz)) {
574             return getConcreteCollection(TransferQueue.class);
575         }
576         if (BlockingQueue.class.isAssignableFrom(clazz)) {
577             return getConcreteCollection(BlockingQueue.class);
578         }
579         if (Deque.class.isAssignableFrom(clazz)) {
580             return getConcreteCollection(Deque.class);
581         }
582         if (Queue.class.isAssignableFrom(clazz)) {
583             return getConcreteCollection(Queue.class);
584         }
585         if (SortedSet.class.isAssignableFrom(clazz)) {
586             return getConcreteCollection(SortedSet.class);
587         }
588         if (Set.class.isAssignableFrom(clazz)) {
589             return getConcreteCollection(Set.class);
590         }
591         if (List.class.isAssignableFrom(clazz)) {
592             return getConcreteCollection(List.class);
593         }
594         throw new IllegalArgumentException("Only corresponding array classes and any are allowed as argument."
595                 + "assignable from TransferQueue, BlockingQueue, Deque, Queue, SortedSet, Set, List class");
596     }
597
598     public static Collection getConcreteCollection(Class<?> clazz) {
599         switch (clazz.getName()) {
600             case "java.util.Collection":
601             case "java.util.List":
602                 return new ArrayList<>();
603             case "java.util.Set":
604                 return new HashSet<>();
605             case "java.util.SortedSet":
606                 return new TreeSet<>();
607             case "java.util.Queue":
608                 return new ConcurrentLinkedQueue<>();
609             case "java.util.Deque":
610                 return new ArrayDeque<>();
611             case "java.util.concurrent.TransferQueue":
612                 return new LinkedTransferQueue<>();
613             case "java.util.concurrent.BlockingQueue":
614                 return new LinkedBlockingQueue<>();
615             default:
616                 throw new IllegalArgumentException("Only corresponding array classes and any are allowed as argument."
617                         + "assignable from TransferQueue, BlockingQueue, Deque, Queue, SortedSet, Set, List class");
618         }
619     }
620
621     public static String getConfigurationRepositoryKey(File file) {
622         return getConfigurationRepositoryKey(
623                 ConfigurationUtils.getNamespace(file).split(Constants.TENANT_NAMESPACE_SEPARATOR));
624     }
625
626     public static String getConfigurationRepositoryKey(URL url) {
627         return getConfigurationRepositoryKey(
628                 ConfigurationUtils.getNamespace(url).split(Constants.TENANT_NAMESPACE_SEPARATOR));
629     }
630
631     public static String getConfigurationRepositoryKey(String[] array) {
632         Deque<String> stack = new ArrayDeque<>();
633         stack.push(Constants.DEFAULT_TENANT);
634         for (String element : array) {
635             stack.push(element);
636         }
637         String toReturn = stack.pop();
638         return stack.pop() + Constants.KEY_ELEMENTS_DELIMITER + toReturn;
639     }
640
641     public static String getNamespace(File file) {
642         Optional<String> namespace =
643                 getConfiguration(file).flatMap(ConfigurationUtils::readNamespace).map(String::toUpperCase);
644         return namespace.orElseGet(() -> getNamespace(file.getName().toUpperCase()));
645     }
646
647     public static String getNamespace(String file) {
648         file = file.toUpperCase().substring(file.lastIndexOf('!') + 1);
649         file = file.substring(file.lastIndexOf('/') + 1);
650         Pattern pattern = Pattern.compile(
651                 String.format(
652                         CONFIG_REGEX_TPL_OPT_1,
653                         ConfigurationMode.OVERRIDE,
654                         ConfigurationMode.MERGE,
655                         ConfigurationMode.UNION,
656                         ConfigurationType.PROPERTIES.name(),
657                         ConfigurationType.XML.name(),
658                         ConfigurationType.JSON.name(),
659                         ConfigurationType.YAML.name()
660                 )
661         );
662         Matcher matcher = pattern.matcher(file);
663         boolean b1 = matcher.matches();
664         if (b1) {
665             if (matcher.group(1) != null) {
666                 String moduleName = matcher.group(1).substring(1);
667                 return moduleName.equalsIgnoreCase(ConfigurationMode.OVERRIDE.name()) || moduleName.equalsIgnoreCase(
668                         ConfigurationMode.UNION.name()) || moduleName.equalsIgnoreCase(ConfigurationMode.MERGE.name())
669                         ? Constants.DEFAULT_NAMESPACE : moduleName;
670             } else {
671                 return Constants.DEFAULT_NAMESPACE;
672             }
673         } else if (isConfig(file)) {
674             return Constants.DEFAULT_NAMESPACE;
675         }
676
677         return null;
678     }
679
680     public static String getNamespace(URL url) {
681
682         Optional<String> namespace =
683                 getConfiguration(url).flatMap(ConfigurationUtils::readNamespace).map(String::toUpperCase);
684
685         return namespace.orElseGet(() -> getNamespace(url.getFile().toUpperCase()));
686     }
687
688     public static Object getProperty(Configuration config, String key, int processingHints) {
689         if (!isDirectLookup(processingHints) && isNodeSpecific(processingHints) && (config instanceof CompositeConfiguration)) {
690             CompositeConfiguration conf = (CompositeConfiguration) config;
691             for (int i = 0; i < conf.getNumberOfConfigurations(); i++) {
692                 Object obj = conf.getConfiguration(i).getProperty(key);
693                 if (obj != null) {
694                     return obj;
695                 }
696             }
697         }
698         return config.getProperty(key);
699     }
700
701     public static boolean isCollection(String input) {
702         Pattern pattern = Pattern.compile("^\\[(.*)\\]$");
703         Matcher matcher = pattern.matcher(input);
704         return matcher.matches();
705     }
706
707     public static boolean isDirectLookup(int hints) {
708         return (hints & LATEST_LOOKUP.value()) == LATEST_LOOKUP.value();
709     }
710
711     public static boolean isNodeSpecific(int hints) {
712         return (hints & NODE_SPECIFIC.value()) == NODE_SPECIFIC.value();
713     }
714
715     public static boolean isExternalLookup(int hints) {
716         return (hints & EXTERNAL_LOOKUP.value()) == EXTERNAL_LOOKUP.value();
717     }
718
719     public static boolean isZeroLengthArray(Class<?> clazz, Object obj) {
720         if (isAPrimitivesArray(clazz)) {
721             if (clazz.getComponentType() == int.class) {
722                 return ((int[]) obj).length == 0;
723             } else if (clazz.getComponentType() == byte.class) {
724                 return ((byte[]) obj).length == 0;
725             } else if (clazz.getComponentType() == short.class) {
726                 return ((short[]) obj).length == 0;
727             } else if (clazz.getComponentType() == float.class) {
728                 return ((float[]) obj).length == 0;
729             } else if (clazz.getComponentType() == boolean.class) {
730                 return ((boolean[]) obj).length == 0;
731             } else if (clazz.getComponentType() == double.class) {
732                 return ((double[]) obj).length == 0;
733             } else if (clazz.getComponentType() == long.class) {
734                 return ((long[]) obj).length == 0;
735             } else {
736                 return ((Object[]) obj).length == 0;
737             }
738         }
739
740         return false;
741     }
742
743     public static boolean isBlank(String value) {
744         return value == null || value.trim().isEmpty();
745     }
746
747     // private methods section starts here
748
749     private static int[] getIntsPrimitiveArray(Collection<?> collection) {
750         int collectionSize = collection.size();
751         int[] array = new int[collectionSize];
752         Object[] objArray = collection.toArray();
753         for (int i = 0; i < collectionSize; i++) {
754             array[i] = (int) objArray[i];
755         }
756         return array;
757     }
758
759     private static byte[] getBytesPrimitiveArray(Collection<?> collection) {
760         int collectionSize = collection.size();
761         byte[] array = new byte[collectionSize];
762         Object[] objArray = collection.toArray();
763         for (int i = 0; i < collectionSize; i++) {
764             array[i] = (byte) objArray[i];
765         }
766         return array;
767     }
768
769     private static short[] getShortsPrimitiveArray(Collection<?> collection) {
770         int collectionSize = collection.size();
771         short[] array = new short[collectionSize];
772         Object[] objArray = collection.toArray();
773         for (int i = 0; i < collectionSize; i++) {
774             array[i] = (short) objArray[i];
775         }
776         return array;
777     }
778
779     private static long[] getLongsPrimitiveArray(Collection<?> collection) {
780         int collectionSize = collection.size();
781         long[] array = new long[collectionSize];
782         Object[] objArray = collection.toArray();
783         for (int i = 0; i < collectionSize; i++) {
784             array[i] = (long) objArray[i];
785         }
786         return array;
787     }
788
789     private static float[] getFloatsPrimitiveArray(Collection<?> collection) {
790         int collectionSize = collection.size();
791         float[] array = new float[collectionSize];
792         Object[] objArray = collection.toArray();
793         for (int i = 0; i < collectionSize; i++) {
794             array[i] = (float) objArray[i];
795         }
796         return array;
797     }
798
799     private static double[] getDoublesPrimitiveArray(Collection<?> collection) {
800         int collectionSize = collection.size();
801         double[] array = new double[collectionSize];
802         Object[] objArray = collection.toArray();
803         for (int i = 0; i < collectionSize; i++) {
804             array[i] = (double) objArray[i];
805         }
806         return array;
807     }
808
809     private static boolean[] getBooleansPrimitiveArray(Collection<?> collection) {
810         int collectionSize = collection.size();
811         boolean[] array = new boolean[collectionSize];
812         Object[] objArray = collection.toArray();
813         for (int i = 0; i < collectionSize; i++) {
814             array[i] = (boolean) objArray[i];
815         }
816         return array;
817     }
818
819     private static char[] getCharsPrimitiveArray(Collection<?> collection) {
820         int collectionSize = collection.size();
821         char[] array = new char[collectionSize];
822         Object[] objArray = collection.toArray();
823         for (int i = 0; i < collectionSize; i++) {
824             array[i] = (char) objArray[i];
825         }
826         return array;
827     }
828
829 }