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 * Creates a new instance of {@code AbstractYAMLBasedConfiguration}. 047 */ 048 protected AbstractYAMLBasedConfiguration() { 049 initLogger(new ConfigurationLogger(getClass())); 050 } 051 052 /** 053 * Creates a new instance of {@code AbstractYAMLBasedConfiguration} as a copy of the specified configuration. 054 * 055 * @param c the configuration to be copied 056 */ 057 protected AbstractYAMLBasedConfiguration(final HierarchicalConfiguration<ImmutableNode> c) { 058 super(c); 059 initLogger(new ConfigurationLogger(getClass())); 060 } 061 062 /** 063 * Loads this configuration from the content of the specified map. The data in the map is transformed into a hierarchy 064 * of {@link ImmutableNode} objects. 065 * 066 * @param map the map to be processed 067 */ 068 protected void load(final Map<String, Object> map) { 069 final List<ImmutableNode> roots = constructHierarchy("", map); 070 getNodeModel().setRootNode(roots.get(0)); 071 } 072 073 /** 074 * Constructs a YAML map, i.e. String -> Object from a given configuration node. 075 * 076 * @param node The configuration node to create a map from. 077 * @return A Map that contains the configuration node information. 078 */ 079 protected Map<String, Object> constructMap(final ImmutableNode node) { 080 final Map<String, Object> map = new HashMap<>(node.getChildren().size()); 081 node.forEach(cNode -> addEntry(map, cNode.getNodeName(), cNode.getChildren().isEmpty() ? cNode.getValue() : constructMap(cNode))); 082 return map; 083 } 084 085 /** 086 * Adds a key value pair to a map, taking list structures into account. If a key is added which is already present in 087 * the map, this method ensures that a list is created. 088 * 089 * @param map the map 090 * @param key the key 091 * @param value the value 092 */ 093 private static void addEntry(final Map<String, Object> map, final String key, final Object value) { 094 final Object oldValue = map.get(key); 095 if (oldValue == null) { 096 map.put(key, value); 097 } else if (oldValue instanceof Collection) { 098 // safe case because the collection was created by ourselves 099 @SuppressWarnings("unchecked") 100 final Collection<Object> values = (Collection<Object>) oldValue; 101 values.add(value); 102 } else { 103 final Collection<Object> values = new ArrayList<>(); 104 values.add(oldValue); 105 values.add(value); 106 map.put(key, values); 107 } 108 } 109 110 /** 111 * Creates a part of the hierarchical nodes structure of the resulting configuration. The passed in element is converted 112 * into one or multiple configuration nodes. (If list structures are involved, multiple nodes are returned.) 113 * 114 * @param key the key of the new node(s) 115 * @param elem the element to be processed 116 * @return a list with configuration nodes representing the element 117 */ 118 private static List<ImmutableNode> constructHierarchy(final String key, final Object elem) { 119 if (elem instanceof Map) { 120 return parseMap((Map<String, Object>) elem, key); 121 } 122 if (elem instanceof Collection) { 123 return parseCollection((Collection<Object>) elem, key); 124 } 125 return Collections.singletonList(new ImmutableNode.Builder().name(key).value(elem).create()); 126 } 127 128 /** 129 * Parses a map structure. The single keys of the map are processed recursively. 130 * 131 * @param map the map to be processed 132 * @param key the key under which this map is to be stored 133 * @return a node representing this map 134 */ 135 private static List<ImmutableNode> parseMap(final Map<String, Object> map, final String key) { 136 final ImmutableNode.Builder subtree = new ImmutableNode.Builder().name(key); 137 map.forEach((k, v) -> constructHierarchy(k, v).forEach(subtree::addChild)); 138 return Collections.singletonList(subtree.create()); 139 } 140 141 /** 142 * Parses a collection structure. The elements of the collection are processed recursively. 143 * 144 * @param col the collection to be processed 145 * @param key the key under which this collection is to be stored 146 * @return a node representing this collection 147 */ 148 private static List<ImmutableNode> parseCollection(final Collection<Object> col, final String key) { 149 return col.stream().flatMap(elem -> constructHierarchy(key, elem).stream()).collect(Collectors.toList()); 150 } 151 152 /** 153 * Internal helper method to wrap an exception in a {@code ConfigurationException}. 154 * 155 * @param e the exception to be wrapped 156 * @throws ConfigurationException the resulting exception 157 */ 158 static void rethrowException(final Exception e) throws ConfigurationException { 159 if (e instanceof ClassCastException) { 160 throw new ConfigurationException("Error parsing", e); 161 } 162 throw new ConfigurationException("Unable to load the configuration", e); 163 } 164}