001/* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 018package org.apache.commons.configuration2; 019 020import java.util.ArrayList; 021import java.util.Collection; 022import java.util.Collections; 023import java.util.HashMap; 024import java.util.List; 025import java.util.Map; 026import java.util.stream.Collectors; 027 028import org.apache.commons.configuration2.ex.ConfigurationException; 029import org.apache.commons.configuration2.io.ConfigurationLogger; 030import org.apache.commons.configuration2.tree.ImmutableNode; 031 032/** 033 * <p> 034 * A base class for configuration implementations based on YAML structures. 035 * </p> 036 * <p> 037 * This base class offers functionality related to YAML-like data structures based on maps. Such a map has strings as 038 * keys and arbitrary objects as values. The class offers methods to transform such a map into a hierarchy of 039 * {@link ImmutableNode} objects and vice versa. 040 * </p> 041 * 042 * @since 2.2 043 */ 044public class AbstractYAMLBasedConfiguration extends BaseHierarchicalConfiguration { 045 /** 046 * Adds a key value pair to a map, taking list structures into account. If a key is added which is already present in 047 * the map, this method ensures that a list is created. 048 * 049 * @param map the map 050 * @param key the key 051 * @param value the value 052 */ 053 private static void addEntry(final Map<String, Object> map, final String key, final Object value) { 054 final Object oldValue = map.get(key); 055 if (oldValue == null) { 056 map.put(key, value); 057 } else if (oldValue instanceof Collection) { 058 // safe case because the collection was created by ourselves 059 @SuppressWarnings("unchecked") 060 final Collection<Object> values = (Collection<Object>) oldValue; 061 values.add(value); 062 } else { 063 final Collection<Object> values = new ArrayList<>(); 064 values.add(oldValue); 065 values.add(value); 066 map.put(key, values); 067 } 068 } 069 070 /** 071 * Creates a part of the hierarchical nodes structure of the resulting configuration. The passed in element is converted 072 * into one or multiple configuration nodes. (If list structures are involved, multiple nodes are returned.) 073 * 074 * @param key the key of the new node(s) 075 * @param elem the element to be processed 076 * @return a list with configuration nodes representing the element 077 */ 078 private static List<ImmutableNode> constructHierarchy(final String key, final Object elem) { 079 if (elem instanceof Map) { 080 return parseMap((Map<String, Object>) elem, key); 081 } 082 if (elem instanceof Collection) { 083 return parseCollection((Collection<Object>) elem, key); 084 } 085 return Collections.singletonList(new ImmutableNode.Builder().name(key).value(elem).create()); 086 } 087 088 /** 089 * Parses a collection structure. The elements of the collection are processed recursively. 090 * 091 * @param col the collection to be processed 092 * @param key the key under which this collection is to be stored 093 * @return a node representing this collection 094 */ 095 private static List<ImmutableNode> parseCollection(final Collection<Object> col, final String key) { 096 return col.stream().flatMap(elem -> constructHierarchy(key, elem).stream()).collect(Collectors.toList()); 097 } 098 099 /** 100 * Parses a map structure. The single keys of the map are processed recursively. 101 * 102 * @param map the map to be processed 103 * @param key the key under which this map is to be stored 104 * @return a node representing this map 105 */ 106 private static List<ImmutableNode> parseMap(final Map<String, Object> map, final String key) { 107 final ImmutableNode.Builder subtree = new ImmutableNode.Builder().name(key); 108 map.forEach((k, v) -> constructHierarchy(k, v).forEach(subtree::addChild)); 109 return Collections.singletonList(subtree.create()); 110 } 111 112 /** 113 * Internal helper method to wrap an exception in a {@code ConfigurationException}. 114 * 115 * @param e the exception to be wrapped 116 * @throws ConfigurationException the resulting exception 117 */ 118 static void rethrowException(final Exception e) throws ConfigurationException { 119 if (e instanceof ClassCastException) { 120 throw new ConfigurationException("Error parsing", e); 121 } 122 throw new ConfigurationException("Unable to load the configuration", e); 123 } 124 125 /** 126 * Creates a new instance of {@code AbstractYAMLBasedConfiguration}. 127 */ 128 protected AbstractYAMLBasedConfiguration() { 129 initLogger(new ConfigurationLogger(getClass())); 130 } 131 132 /** 133 * Creates a new instance of {@code AbstractYAMLBasedConfiguration} as a copy of the specified configuration. 134 * 135 * @param c the configuration to be copied 136 */ 137 protected AbstractYAMLBasedConfiguration(final HierarchicalConfiguration<ImmutableNode> c) { 138 super(c); 139 initLogger(new ConfigurationLogger(getClass())); 140 } 141 142 /** 143 * Constructs a YAML map, i.e. String -> Object from a given configuration node. 144 * 145 * @param node The configuration node to create a map from. 146 * @return A Map that contains the configuration node information. 147 */ 148 protected Map<String, Object> constructMap(final ImmutableNode node) { 149 final Map<String, Object> map = new HashMap<>(node.getChildren().size()); 150 node.forEach(cNode -> addEntry(map, cNode.getNodeName(), cNode.getChildren().isEmpty() ? cNode.getValue() : constructMap(cNode))); 151 return map; 152 } 153 154 /** 155 * Loads this configuration from the content of the specified map. The data in the map is transformed into a hierarchy 156 * of {@link ImmutableNode} objects. 157 * 158 * @param map the map to be processed 159 */ 160 protected void load(final Map<String, Object> map) { 161 final List<ImmutableNode> roots = constructHierarchy("", map); 162 getNodeModel().setRootNode(roots.get(0)); 163 } 164}