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 */ 017package org.apache.commons.validator.util; 018 019import java.util.Collection; 020import java.util.HashMap; 021import java.util.Map; 022 023import org.apache.commons.beanutils.PropertyUtils; 024import org.apache.commons.collections.FastHashMap; // DEPRECATED 025import org.apache.commons.logging.Log; 026import org.apache.commons.logging.LogFactory; 027import org.apache.commons.validator.Arg; 028import org.apache.commons.validator.Msg; 029import org.apache.commons.validator.Var; 030 031/** 032 * Basic utility methods. 033 * <p> 034 * The use of FastHashMap is deprecated and will be replaced in a future 035 * release. 036 * </p> 037 */ 038public class ValidatorUtils { 039 040 private static final Log LOG = LogFactory.getLog(ValidatorUtils.class); 041 042 /** 043 * Makes a deep copy of a <code>FastHashMap</code> if the values 044 * are <code>Msg</code>, <code>Arg</code>, 045 * or <code>Var</code>. Otherwise it is a shallow copy. 046 * 047 * @param fastHashMap <code>FastHashMap</code> to copy. 048 * @return FastHashMap A copy of the <code>FastHashMap</code> that was 049 * passed in. 050 * @deprecated This method is not part of Validator's public API. Validator 051 * will use it internally until FastHashMap references are removed. Use 052 * copyMap() instead. 053 */ 054 @Deprecated 055 public static FastHashMap copyFastHashMap(final FastHashMap fastHashMap) { 056 final FastHashMap results = new FastHashMap(); 057 @SuppressWarnings("unchecked") // FastHashMap is not generic 058 final HashMap<String, ?> map = fastHashMap; 059 map.forEach((key, value) -> { 060 if (value instanceof Msg) { 061 results.put(key, ((Msg) value).clone()); 062 } else if (value instanceof Arg) { 063 results.put(key, ((Arg) value).clone()); 064 } else if (value instanceof Var) { 065 results.put(key, ((Var) value).clone()); 066 } else { 067 results.put(key, value); 068 } 069 }); 070 results.setFast(true); 071 return results; 072 } 073 074 /** 075 * Makes a deep copy of a <code>Map</code> if the values are 076 * <code>Msg</code>, <code>Arg</code>, or <code>Var</code>. Otherwise, 077 * it is a shallow copy. 078 * 079 * @param map The source Map to copy. 080 * 081 * @return A copy of the <code>Map</code> that was passed in. 082 */ 083 public static Map<String, Object> copyMap(final Map<String, Object> map) { 084 final Map<String, Object> results = new HashMap<>(); 085 map.forEach((key, value) -> { 086 if (value instanceof Msg) { 087 results.put(key, ((Msg) value).clone()); 088 } else if (value instanceof Arg) { 089 results.put(key, ((Arg) value).clone()); 090 } else if (value instanceof Var) { 091 results.put(key, ((Var) value).clone()); 092 } else { 093 results.put(key, value); 094 } 095 }); 096 return results; 097 } 098 099 /** 100 * Convenience method for getting a value from a bean property as a 101 * <code>String</code>. If the property is a <code>String[]</code> or 102 * <code>Collection</code> and it is empty, an empty <code>String</code> 103 * "" is returned. Otherwise, property.toString() is returned. This method 104 * may return <code>null</code> if there was an error retrieving the 105 * property. 106 * 107 * @param bean The bean object. 108 * @param property The name of the property to access. 109 * 110 * @return The value of the property. 111 */ 112 public static String getValueAsString(final Object bean, final String property) { 113 Object value = null; 114 115 try { 116 value = PropertyUtils.getProperty(bean, property); 117 118 } catch (ReflectiveOperationException e) { 119 LOG.error(e.getMessage(), e); 120 } 121 122 if (value == null) { 123 return null; 124 } 125 126 if (value instanceof String[]) { 127 return ((String[]) value).length > 0 ? value.toString() : ""; 128 129 } 130 if (value instanceof Collection) { 131 return ((Collection<?>) value).isEmpty() ? "" : value.toString(); 132 133 } 134 return value.toString(); 135 136 } 137 138 /** 139 * <p>Replace part of a <code>String</code> with another value.</p> 140 * 141 * @param value <code>String</code> to perform the replacement on. 142 * @param key The name of the constant. 143 * @param replaceValue The value of the constant. 144 * 145 * @return The modified value. 146 */ 147 public static String replace(String value, final String key, final String replaceValue) { 148 if (value == null || key == null || replaceValue == null) { 149 return value; 150 } 151 return value.replace(key, replaceValue); 152 } 153 154}