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.AbstractMap; 021import java.util.AbstractSet; 022import java.util.Iterator; 023import java.util.Map; 024import java.util.Set; 025 026/** 027 * <p> 028 * The {@code ConfigurationMap} wraps a configuration-collection {@link org.apache.commons.configuration2.Configuration} 029 * instance to provide a {@code Map} interface. 030 * </p> 031 * 032 * <p> 033 * <em>Note:</em> This implementation is incomplete. 034 * </p> 035 * 036 * @since 1.0 037 */ 038public class ConfigurationMap extends AbstractMap<Object, Object> { 039 /** 040 * The {@code Configuration} wrapped by this class. 041 */ 042 private final Configuration configuration; 043 044 /** 045 * Creates a new instance of a {@code ConfigurationMap} that wraps the specified {@code Configuration} instance. 046 * 047 * @param configuration {@code Configuration} instance. 048 */ 049 public ConfigurationMap(final Configuration configuration) { 050 this.configuration = configuration; 051 } 052 053 /** 054 * Gets the wrapped {@code Configuration} object. 055 * 056 * @return the wrapped configuration 057 * @since 1.2 058 */ 059 public Configuration getConfiguration() { 060 return configuration; 061 } 062 063 /** 064 * Returns a set with the entries contained in this configuration-based map. 065 * 066 * @return a set with the contained entries 067 * @see java.util.Map#entrySet() 068 */ 069 @Override 070 public Set<Map.Entry<Object, Object>> entrySet() { 071 return new ConfigurationSet(configuration); 072 } 073 074 /** 075 * Stores the value for the specified key. The value is stored in the underlying configuration. 076 * 077 * @param key the key (will be converted to a string) 078 * @param value the value 079 * @return the old value of this key or <b>null</b> if it is new 080 * @see java.util.Map#put(Object, Object) 081 */ 082 @Override 083 public Object put(final Object key, final Object value) { 084 final String strKey = String.valueOf(key); 085 final Object old = configuration.getProperty(strKey); 086 configuration.setProperty(strKey, value); 087 return old; 088 } 089 090 /** 091 * Gets the value of the specified key. The key is converted to a string and then passed to the underlying 092 * configuration. 093 * 094 * @param key the key 095 * @return the value of this key 096 * @see java.util.Map#get(Object) 097 */ 098 @Override 099 public Object get(final Object key) { 100 return configuration.getProperty(String.valueOf(key)); 101 } 102 103 /** 104 * Set of entries in the map. 105 */ 106 static class ConfigurationSet extends AbstractSet<Map.Entry<Object, Object>> { 107 /** The configuration mapped to this entry set. */ 108 private final Configuration configuration; 109 110 /** 111 * A Map entry in the ConfigurationMap. 112 */ 113 private final class Entry implements Map.Entry<Object, Object> { 114 /** The key of the map entry. */ 115 private final Object key; 116 117 private Entry(final Object key) { 118 this.key = key; 119 } 120 121 @Override 122 public Object getKey() { 123 return key; 124 } 125 126 @Override 127 public Object getValue() { 128 return configuration.getProperty((String) key); 129 } 130 131 @Override 132 public Object setValue(final Object value) { 133 final Object old = getValue(); 134 configuration.setProperty((String) key, value); 135 return old; 136 } 137 } 138 139 /** 140 * Iterator over the entries in the ConfigurationMap. 141 */ 142 private final class ConfigurationSetIterator implements Iterator<Map.Entry<Object, Object>> { 143 /** An iterator over the keys in the configuration. */ 144 private final Iterator<String> keys; 145 146 private ConfigurationSetIterator() { 147 keys = configuration.getKeys(); 148 } 149 150 @Override 151 public boolean hasNext() { 152 return keys.hasNext(); 153 } 154 155 @Override 156 public Map.Entry<Object, Object> next() { 157 return new Entry(keys.next()); 158 } 159 160 @Override 161 public void remove() { 162 keys.remove(); 163 } 164 } 165 166 ConfigurationSet(final Configuration configuration) { 167 this.configuration = configuration; 168 } 169 170 /** 171 * @see java.util.Collection#size() 172 */ 173 @Override 174 public int size() { 175 // Ouch. Now _that_ one is expensive... 176 int count = 0; 177 for (final Iterator<String> iterator = configuration.getKeys(); iterator.hasNext();) { 178 iterator.next(); 179 count++; 180 } 181 return count; 182 } 183 184 /** 185 * @see java.util.Collection#iterator() 186 */ 187 @Override 188 public Iterator<Map.Entry<Object, Object>> iterator() { 189 return new ConfigurationSetIterator(); 190 } 191 } 192}