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 package org.apache.commons.beanutils; 018 019 /** 020 * <p>DynaClass which implements the <code>MutableDynaClass</code> interface.</p> 021 * 022 * <p>A <code>MutableDynaClass</code> is a specialized extension to <code>DynaClass</code> 023 * that allows properties to be added or removed dynamically.</p> 024 * 025 * <p>This implementation has one slightly unusual default behaviour - calling 026 * the <code>getDynaProperty(name)</code> method for a property which doesn't 027 * exist returns a <code>DynaProperty</code> rather than <code>null</code>. The 028 * reason for this is that <code>BeanUtils</code> calls this method to check if 029 * a property exists before trying to set the value. This would defeat the object 030 * of the <code>LazyDynaBean</code> which automatically adds missing properties 031 * when any of its <code>set()</code> methods are called. For this reason the 032 * <code>isDynaProperty(name)</code> method has been added to this implementation 033 * in order to determine if a property actually exists. If the more <i>normal</i> 034 * behaviour of returning <code>null</code> is required, then this can be achieved 035 * by calling the <code>setReturnNull(true)</code>.</p> 036 * 037 * <p>The <code>add(name, type, readable, writable)</code> method is not implemented 038 * and always throws an <code>UnsupportedOperationException</code>. I believe 039 * this attributes need to be added to the <code>DynaProperty</code> class 040 * in order to control read/write facilities.</p> 041 * 042 * @see LazyDynaBean 043 * @author Niall Pemberton 044 */ 045 public class LazyDynaClass extends BasicDynaClass implements MutableDynaClass { 046 047 /** 048 * Controls whether changes to this DynaClass's properties are allowed. 049 */ 050 protected boolean restricted; 051 052 /** 053 * <p>Controls whether the <code>getDynaProperty()</code> method returns 054 * null if a property doesn't exist - or creates a new one.</p> 055 * 056 * <p>Default is <code>false</code>. 057 */ 058 protected boolean returnNull = false; 059 060 /** 061 * Construct a new LazyDynaClass with default parameters. 062 */ 063 public LazyDynaClass() { 064 this(null, (DynaProperty[])null); 065 } 066 067 /** 068 * Construct a new LazyDynaClass with the specified name. 069 * 070 * @param name Name of this DynaBean class 071 */ 072 public LazyDynaClass(String name) { 073 this(name, (DynaProperty[])null); 074 } 075 076 /** 077 * Construct a new LazyDynaClass with the specified name and DynaBean class. 078 * 079 * @param name Name of this DynaBean class 080 * @param dynaBeanClass The implementation class for new instances 081 */ 082 public LazyDynaClass(String name, Class dynaBeanClass) { 083 this(name, dynaBeanClass, null); 084 } 085 086 /** 087 * Construct a new LazyDynaClass with the specified name and properties. 088 * 089 * @param name Name of this DynaBean class 090 * @param properties Property descriptors for the supported properties 091 */ 092 public LazyDynaClass(String name, DynaProperty[] properties) { 093 this(name, LazyDynaBean.class, properties); 094 } 095 096 /** 097 * Construct a new LazyDynaClass with the specified name, DynaBean class and properties. 098 * 099 * @param name Name of this DynaBean class 100 * @param dynaBeanClass The implementation class for new intances 101 * @param properties Property descriptors for the supported properties 102 */ 103 public LazyDynaClass(String name, Class dynaBeanClass, DynaProperty properties[]) { 104 super(name, dynaBeanClass, properties); 105 } 106 107 /** 108 * <p>Is this DynaClass currently restricted.</p> 109 * <p>If restricted, no changes to the existing registration of 110 * property names, data types, readability, or writeability are allowed.</p> 111 * @return <code>true</code> if this {@link MutableDynaClass} cannot be changed 112 * otherwise <code>false</code> 113 */ 114 public boolean isRestricted() { 115 return restricted; 116 } 117 118 /** 119 * <p>Set whether this DynaClass is currently restricted.</p> 120 * <p>If restricted, no changes to the existing registration of 121 * property names, data types, readability, or writeability are allowed.</p> 122 * @param restricted <code>true</code> if this {@link MutableDynaClass} cannot 123 * be changed otherwise <code>false</code> 124 */ 125 public void setRestricted(boolean restricted) { 126 this.restricted = restricted; 127 } 128 129 /** 130 * Should this DynaClass return a <code>null</code> from 131 * the <code>getDynaProperty(name)</code> method if the property 132 * doesn't exist. 133 * 134 * @return <code>true<code> if a <code>null</code> {@link DynaProperty} 135 * should be returned if the property doesn't exist, otherwise 136 * <code>false</code> if a new {@link DynaProperty} should be created. 137 */ 138 public boolean isReturnNull() { 139 return returnNull; 140 } 141 142 /** 143 * Set whether this DynaClass should return a <code>null</code> from 144 * the <code>getDynaProperty(name)</code> method if the property 145 * doesn't exist. 146 * @param returnNull <code>true<code> if a <code>null</code> {@link DynaProperty} 147 * should be returned if the property doesn't exist, otherwise 148 * <code>false</code> if a new {@link DynaProperty} should be created. 149 */ 150 public void setReturnNull(boolean returnNull) { 151 this.returnNull = returnNull; 152 } 153 154 /** 155 * Add a new dynamic property with no restrictions on data type, 156 * readability, or writeability. 157 * 158 * @param name Name of the new dynamic property 159 * 160 * @exception IllegalArgumentException if name is null 161 * @exception IllegalStateException if this DynaClass is currently 162 * restricted, so no new properties can be added 163 */ 164 public void add(String name) { 165 add(new DynaProperty(name)); 166 } 167 168 /** 169 * Add a new dynamic property with the specified data type, but with 170 * no restrictions on readability or writeability. 171 * 172 * @param name Name of the new dynamic property 173 * @param type Data type of the new dynamic property (null for no 174 * restrictions) 175 * 176 * @exception IllegalArgumentException if name is null 177 * @exception IllegalStateException if this DynaClass is currently 178 * restricted, so no new properties can be added 179 */ 180 public void add(String name, Class type) { 181 if (type == null) { 182 add(name); 183 } else { 184 add(new DynaProperty(name, type)); 185 } 186 } 187 188 /** 189 * <p>Add a new dynamic property with the specified data type, readability, 190 * and writeability.</p> 191 * 192 * <p><strong>N.B.</strong>Support for readable/writeable properties has not been implemented 193 * and this method always throws a <code>UnsupportedOperationException</code>.</p> 194 * 195 * <p>I'm not sure the intention of the original authors for this method, but it seems to 196 * me that readable/writable should be attributes of the <code>DynaProperty</code> class 197 * (which they are not) and is the reason this method has not been implemented.</p> 198 * 199 * @param name Name of the new dynamic property 200 * @param type Data type of the new dynamic property (null for no 201 * restrictions) 202 * @param readable Set to <code>true</code> if this property value 203 * should be readable 204 * @param writeable Set to <code>true</code> if this property value 205 * should be writeable 206 * 207 * @exception UnsupportedOperationException anytime this method is called 208 */ 209 public void add(String name, Class type, boolean readable, boolean writeable) { 210 throw new java.lang.UnsupportedOperationException("readable/writable properties not supported"); 211 } 212 213 /** 214 * Add a new dynamic property. 215 * 216 * @param property Property the new dynamic property to add. 217 * 218 * @exception IllegalArgumentException if name is null 219 * @exception IllegalStateException if this DynaClass is currently 220 * restricted, so no new properties can be added 221 */ 222 protected void add(DynaProperty property) { 223 224 if (property.getName() == null) { 225 throw new IllegalArgumentException("Property name is missing."); 226 } 227 228 if (isRestricted()) { 229 throw new IllegalStateException("DynaClass is currently restricted. No new properties can be added."); 230 } 231 232 // Check if property already exists 233 if (propertiesMap.get(property.getName()) != null) { 234 return; 235 } 236 237 // Create a new property array with the specified property 238 DynaProperty[] oldProperties = getDynaProperties(); 239 DynaProperty[] newProperties = new DynaProperty[oldProperties.length+1]; 240 System.arraycopy(oldProperties, 0, newProperties, 0, oldProperties.length); 241 newProperties[oldProperties.length] = property; 242 243 // Update the properties 244 setProperties(newProperties); 245 246 } 247 248 /** 249 * Remove the specified dynamic property, and any associated data type, 250 * readability, and writeability, from this dynamic class. 251 * <strong>NOTE</strong> - This does <strong>NOT</strong> cause any 252 * corresponding property values to be removed from DynaBean instances 253 * associated with this DynaClass. 254 * 255 * @param name Name of the dynamic property to remove 256 * 257 * @exception IllegalArgumentException if name is null 258 * @exception IllegalStateException if this DynaClass is currently 259 * restricted, so no properties can be removed 260 */ 261 public void remove(String name) { 262 263 if (name == null) { 264 throw new IllegalArgumentException("Property name is missing."); 265 } 266 267 if (isRestricted()) { 268 throw new IllegalStateException("DynaClass is currently restricted. No properties can be removed."); 269 } 270 271 // Ignore if property doesn't exist 272 if (propertiesMap.get(name) == null) { 273 return; 274 } 275 276 277 // Create a new property array of without the specified property 278 DynaProperty[] oldProperties = getDynaProperties(); 279 DynaProperty[] newProperties = new DynaProperty[oldProperties.length-1]; 280 int j = 0; 281 for (int i = 0; i < oldProperties.length; i++) { 282 if (!(name.equals(oldProperties[i].getName()))) { 283 newProperties[j] = oldProperties[i]; 284 j++; 285 } 286 } 287 288 // Update the properties 289 setProperties(newProperties); 290 291 } 292 293 /** 294 * <p>Return a property descriptor for the specified property.</p> 295 * 296 * <p>If the property is not found and the <code>returnNull</code> indicator is 297 * <code>true</code>, this method always returns <code>null</code>.</p> 298 * 299 * <p>If the property is not found and the <code>returnNull</code> indicator is 300 * <code>false</code> a new property descriptor is created and returned (although 301 * its not actually added to the DynaClass's properties). This is the default 302 * beahviour.</p> 303 * 304 * <p>The reason for not returning a <code>null</code> property descriptor is that 305 * <code>BeanUtils</code> uses this method to check if a property exists 306 * before trying to set it - since these <i>Lazy</i> implementations automatically 307 * add any new properties when they are set, returning <code>null</code> from 308 * this method would defeat their purpose.</p> 309 * 310 * @param name Name of the dynamic property for which a descriptor 311 * is requested 312 * @return The dyna property for the specified name 313 * 314 * @exception IllegalArgumentException if no property name is specified 315 */ 316 public DynaProperty getDynaProperty(String name) { 317 318 if (name == null) { 319 throw new IllegalArgumentException("Property name is missing."); 320 } 321 322 DynaProperty dynaProperty = (DynaProperty)propertiesMap.get(name); 323 324 // If it doesn't exist and returnNull is false 325 // create a new DynaProperty 326 if (dynaProperty == null && !isReturnNull() && !isRestricted()) { 327 dynaProperty = new DynaProperty(name); 328 } 329 330 return dynaProperty; 331 332 } 333 334 /** 335 * <p>Indicate whether a property actually exists.</p> 336 * 337 * <p><strong>N.B.</strong> Using <code>getDynaProperty(name) == null</code> 338 * doesn't work in this implementation because that method might 339 * return a DynaProperty if it doesn't exist (depending on the 340 * <code>returnNull</code> indicator).</p> 341 * 342 * @param name The name of the property to check 343 * @return <code>true<code> if there is a property of the 344 * specified name, otherwise <code>false</code> 345 * @exception IllegalArgumentException if no property name is specified 346 */ 347 public boolean isDynaProperty(String name) { 348 349 if (name == null) { 350 throw new IllegalArgumentException("Property name is missing."); 351 } 352 353 return propertiesMap.get(name) == null ? false : true; 354 355 } 356 357 }