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.validator.util; 018 019 import java.lang.reflect.InvocationTargetException; 020 import java.util.Collection; 021 import java.util.HashMap; 022 import java.util.Iterator; 023 import java.util.Map; 024 025 import org.apache.commons.beanutils.PropertyUtils; 026 import org.apache.commons.collections.FastHashMap; 027 import org.apache.commons.logging.Log; 028 import org.apache.commons.logging.LogFactory; 029 import org.apache.commons.validator.Arg; 030 import org.apache.commons.validator.Msg; 031 import org.apache.commons.validator.Var; 032 033 /** 034 * Basic utility methods. 035 * <p> 036 * The use of FastHashMap is deprecated and will be replaced in a future 037 * release. 038 * </p> 039 * 040 * @version $Revision: 658783 $ $Date: 2008-05-21 19:44:18 +0200 (Mi, 21. Mai 2008) $ 041 */ 042 public class ValidatorUtils { 043 044 /** 045 * <p>Replace part of a <code>String</code> with another value.</p> 046 * 047 * @param value <code>String</code> to perform the replacement on. 048 * @param key The name of the constant. 049 * @param replaceValue The value of the constant. 050 * 051 * @return The modified value. 052 */ 053 public static String replace(String value, String key, String replaceValue) { 054 055 if (value == null || key == null || replaceValue == null) { 056 return value; 057 } 058 059 int pos = value.indexOf(key); 060 061 if (pos < 0) { 062 return value; 063 } 064 065 int length = value.length(); 066 int start = pos; 067 int end = pos + key.length(); 068 069 if (length == key.length()) { 070 value = replaceValue; 071 072 } else if (end == length) { 073 value = value.substring(0, start) + replaceValue; 074 075 } else { 076 value = 077 value.substring(0, start) 078 + replaceValue 079 + replace(value.substring(end), key, replaceValue); 080 } 081 082 return value; 083 } 084 085 /** 086 * Convenience method for getting a value from a bean property as a 087 * <code>String</code>. If the property is a <code>String[]</code> or 088 * <code>Collection</code> and it is empty, an empty <code>String</code> 089 * "" is returned. Otherwise, property.toString() is returned. This method 090 * may return <code>null</code> if there was an error retrieving the 091 * property. 092 * 093 * @param bean The bean object. 094 * @param property The name of the property to access. 095 * 096 * @return The value of the property. 097 */ 098 public static String getValueAsString(Object bean, String property) { 099 Object value = null; 100 101 try { 102 value = PropertyUtils.getProperty(bean, property); 103 104 } catch(IllegalAccessException e) { 105 Log log = LogFactory.getLog(ValidatorUtils.class); 106 log.error(e.getMessage(), e); 107 } catch(InvocationTargetException e) { 108 Log log = LogFactory.getLog(ValidatorUtils.class); 109 log.error(e.getMessage(), e); 110 } catch(NoSuchMethodException e) { 111 Log log = LogFactory.getLog(ValidatorUtils.class); 112 log.error(e.getMessage(), e); 113 } 114 115 if (value == null) { 116 return null; 117 } 118 119 if (value instanceof String[]) { 120 return ((String[]) value).length > 0 ? value.toString() : ""; 121 122 } else if (value instanceof Collection) { 123 return ((Collection) value).isEmpty() ? "" : value.toString(); 124 125 } else { 126 return value.toString(); 127 } 128 129 } 130 131 /** 132 * Makes a deep copy of a <code>FastHashMap</code> if the values 133 * are <code>Msg</code>, <code>Arg</code>, 134 * or <code>Var</code>. Otherwise it is a shallow copy. 135 * 136 * @param map <code>FastHashMap</code> to copy. 137 * @return FastHashMap A copy of the <code>FastHashMap</code> that was 138 * passed in. 139 * @deprecated This method is not part of Validator's public API. Validator 140 * will use it internally until FastHashMap references are removed. Use 141 * copyMap() instead. 142 */ 143 public static FastHashMap copyFastHashMap(FastHashMap map) { 144 FastHashMap results = new FastHashMap(); 145 146 Iterator i = map.keySet().iterator(); 147 while (i.hasNext()) { 148 String key = (String) i.next(); 149 Object value = map.get(key); 150 151 if (value instanceof Msg) { 152 results.put(key, ((Msg) value).clone()); 153 } else if (value instanceof Arg) { 154 results.put(key, ((Arg) value).clone()); 155 } else if (value instanceof Var) { 156 results.put(key, ((Var) value).clone()); 157 } else { 158 results.put(key, value); 159 } 160 } 161 162 results.setFast(true); 163 return results; 164 } 165 166 /** 167 * Makes a deep copy of a <code>Map</code> if the values are 168 * <code>Msg</code>, <code>Arg</code>, or <code>Var</code>. Otherwise, 169 * it is a shallow copy. 170 * 171 * @param map The source Map to copy. 172 * 173 * @return A copy of the <code>Map</code> that was passed in. 174 */ 175 public static Map copyMap(Map map) { 176 Map results = new HashMap(); 177 178 Iterator iter = map.keySet().iterator(); 179 while (iter.hasNext()) { 180 String key = (String) iter.next(); 181 Object value = map.get(key); 182 183 if (value instanceof Msg) { 184 results.put(key, ((Msg) value).clone()); 185 } else if (value instanceof Arg) { 186 results.put(key, ((Arg) value).clone()); 187 } else if (value instanceof Var) { 188 results.put(key, ((Var) value).clone()); 189 } else { 190 results.put(key, value); 191 } 192 } 193 return results; 194 } 195 196 }