View Javadoc

1   /*
2    * $Id: ValidatorUtils.java 384656 2006-03-10 00:36:37Z niallp $
3    * $Rev: 384656 $
4    * $Date: 2006-03-10 00:36:37 +0000 (Fri, 10 Mar 2006) $
5    *
6    * ====================================================================
7    * Copyright 2001-2006 The Apache Software Foundation
8    *
9    * Licensed under the Apache License, Version 2.0 (the "License");
10   * you may not use this file except in compliance with the License.
11   * You may obtain a copy of the License at
12   *
13   *     http://www.apache.org/licenses/LICENSE-2.0
14   *
15   * Unless required by applicable law or agreed to in writing, software
16   * distributed under the License is distributed on an "AS IS" BASIS,
17   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18   * See the License for the specific language governing permissions and
19   * limitations under the License.
20   */
21  
22  package org.apache.commons.validator.util;
23  
24  import java.lang.reflect.InvocationTargetException;
25  import java.util.Collection;
26  import java.util.HashMap;
27  import java.util.Iterator;
28  import java.util.Map;
29  
30  import org.apache.commons.beanutils.PropertyUtils;
31  import org.apache.commons.collections.FastHashMap;
32  import org.apache.commons.logging.Log;
33  import org.apache.commons.logging.LogFactory;
34  import org.apache.commons.validator.Arg;
35  import org.apache.commons.validator.Msg;
36  import org.apache.commons.validator.Var;
37  
38  /***
39   * Basic utility methods.
40   * <p>
41   * The use of FastHashMap is deprecated and will be replaced in a future
42   * release.
43   * </p>
44   */
45  public class ValidatorUtils {
46  
47      /***
48       * <p>Replace part of a <code>String</code> with another value.</p>
49       *
50       * @param value <code>String</code> to perform the replacement on.
51       * @param key The name of the constant.
52       * @param replaceValue The value of the constant.
53       *
54       * @return The modified value.
55       */
56      public static String replace(String value, String key, String replaceValue) {
57  
58          if (value == null || key == null || replaceValue == null) {
59              return value;
60          }
61  
62          int pos = value.indexOf(key);
63  
64          if (pos < 0) {
65              return value;
66          }
67  
68          int length = value.length();
69          int start = pos;
70          int end = pos + key.length();
71  
72          if (length == key.length()) {
73              value = replaceValue;
74  
75          } else if (end == length) {
76              value = value.substring(0, start) + replaceValue;
77  
78          } else {
79              value =
80                      value.substring(0, start)
81                      + replaceValue
82                      + replace(value.substring(end), key, replaceValue);
83          }
84  
85          return value;
86      }
87  
88      /***
89       * Convenience method for getting a value from a bean property as a
90       * <code>String</code>.  If the property is a <code>String[]</code> or
91       * <code>Collection</code> and it is empty, an empty <code>String</code>
92       * "" is returned.  Otherwise, property.toString() is returned.  This method
93       * may return <code>null</code> if there was an error retrieving the
94       * property.
95       *
96       * @param bean The bean object.
97       * @param property The name of the property to access.
98       *
99       * @return The value of the property.
100      */
101     public static String getValueAsString(Object bean, String property) {
102         Object value = null;
103 
104         try {
105             value = PropertyUtils.getProperty(bean, property);
106 
107         } catch(IllegalAccessException e) {
108             Log log = LogFactory.getLog(ValidatorUtils.class);
109             log.error(e.getMessage(), e);
110         } catch(InvocationTargetException e) {
111             Log log = LogFactory.getLog(ValidatorUtils.class);
112             log.error(e.getMessage(), e);
113         } catch(NoSuchMethodException e) {
114             Log log = LogFactory.getLog(ValidatorUtils.class);
115             log.error(e.getMessage(), e);
116         }
117 
118         if (value == null) {
119             return null;
120         }
121 
122         if (value instanceof String[]) {
123             return ((String[]) value).length > 0 ? value.toString() : "";
124 
125         } else if (value instanceof Collection) {
126             return ((Collection) value).isEmpty() ? "" : value.toString();
127 
128         } else {
129             return value.toString();
130         }
131 
132     }
133 
134     /***
135      * Makes a deep copy of a <code>FastHashMap</code> if the values
136      * are <code>Msg</code>, <code>Arg</code>,
137      * or <code>Var</code>.  Otherwise it is a shallow copy.
138      *
139      * @param map <code>FastHashMap</code> to copy.
140      * @return FastHashMap A copy of the <code>FastHashMap</code> that was
141      * passed in.
142      * @deprecated This method is not part of Validator's public API.  Validator
143      * will use it internally until FastHashMap references are removed.  Use
144      * copyMap() instead.
145      */
146     public static FastHashMap copyFastHashMap(FastHashMap map) {
147         FastHashMap results = new FastHashMap();
148 
149         Iterator i = map.keySet().iterator();
150         while (i.hasNext()) {
151             String key = (String) i.next();
152             Object value = map.get(key);
153 
154             if (value instanceof Msg) {
155                 results.put(key, ((Msg) value).clone());
156             } else if (value instanceof Arg) {
157                 results.put(key, ((Arg) value).clone());
158             } else if (value instanceof Var) {
159                 results.put(key, ((Var) value).clone());
160             } else {
161                 results.put(key, value);
162             }
163         }
164 
165         results.setFast(true);
166         return results;
167     }
168     
169     /***
170      * Makes a deep copy of a <code>Map</code> if the values are 
171      * <code>Msg</code>, <code>Arg</code>, or <code>Var</code>.  Otherwise, 
172      * it is a shallow copy.
173      *
174      * @param map The source Map to copy.
175      *
176      * @return A copy of the <code>Map</code> that was passed in.
177      */
178     public static Map copyMap(Map map) {
179         Map results = new HashMap();
180 
181         Iterator iter = map.keySet().iterator();
182         while (iter.hasNext()) {
183             String key = (String) iter.next();
184             Object value = map.get(key);
185 
186             if (value instanceof Msg) {
187                 results.put(key, ((Msg) value).clone());
188             } else if (value instanceof Arg) {
189                 results.put(key, ((Arg) value).clone());
190             } else if (value instanceof Var) {
191                 results.put(key, ((Var) value).clone());
192             } else {
193                 results.put(key, value);
194             }
195         }
196         return results;
197     }
198 
199 }