View Javadoc

    1   package net.sourceforge.pmd.lang.rule.properties.factories;
    2
    3   import java.util.ArrayList;
    4   import java.util.Collections;
    5   import java.util.HashMap;
    6   import java.util.List;
    7   import java.util.Map;
    8   import net.sourceforge.pmd.PropertyDescriptor;
    9   import net.sourceforge.pmd.PropertyDescriptorFactory;
    10  import net.sourceforge.pmd.util.CollectionUtil;
    11  import net.sourceforge.pmd.util.StringUtil;
    12  import static net.sourceforge.pmd.PropertyDescriptorFields.*;
    13
    14  /**
    15   *
    16   * @author Brian Remedios
    17   *
    18   * @param <T>
    19   */
    20  public class BasicPropertyDescriptorFactory<T> implements PropertyDescriptorFactory {
    21
    22  	private final Class<?> valueType;
    23  	private final Map<String, Boolean> fieldTypesByKey;
    24
    25  	protected static final Map<String, Boolean> coreFieldTypesByKey = CollectionUtil.mapFrom(
    26  			new String[]  { NAME, 		DESC, 	DEFAULT_VALUE},
    27  			new Boolean[] { Boolean.TRUE,  Boolean.TRUE, Boolean.TRUE}
    28  			);
    29
    30  	public BasicPropertyDescriptorFactory(Class<?> theValueType) {
    31  		valueType = theValueType;
    32  		fieldTypesByKey = Collections.unmodifiableMap(coreFieldTypesByKey);
    33  	}
    34
    35  //	public interface WrapperBuilder<T> {
    36  //		T[] newArray(int size);
    37  //		T itemFrom(String txt);
    38  //	}
    39  //
    40  //	protected WrapperBuilder intBuilder = new WrapperBuilder<Integer>() {
    41  //		public Integer[] newArray(int size) { return new Integer[size]; }
    42  //		public Integer itemFrom(String txt) { return Integer.parseInt(txt); }
    43  //	};
    44
    45  	public BasicPropertyDescriptorFactory(Class<?> theValueType, Map<String, Boolean> additionalFieldTypesByKey) {
    46
    47  		valueType = theValueType;
    48  		Map<String, Boolean> temp = new HashMap<String, Boolean>(coreFieldTypesByKey.size() + additionalFieldTypesByKey.size());
    49  		temp.putAll(coreFieldTypesByKey);
    50  		temp.putAll(additionalFieldTypesByKey);
    51
    52  		fieldTypesByKey = Collections.unmodifiableMap(temp);
    53  	}
    54
    55  	public Class<?> valueType() {
    56  		return valueType;
    57  	}
    58
    59  	public PropertyDescriptor<?> createWith(Map<String, String> valuesById) {
    60  		throw new RuntimeException("Unimplemented createWith() method in subclass");
    61  	}
    62
    63  	public Map<String, Boolean> expectedFields() {
    64  		return fieldTypesByKey;
    65  	}
    66
    67  	protected String nameIn(Map<String, String> valuesById) {
    68  		return valuesById.get(NAME);
    69  	}
    70
    71  	protected String descriptionIn(Map<String, String> valuesById) {
    72  		return valuesById.get(DESC);
    73  	}
    74
    75  	protected String defaultValueIn(Map<String, String> valuesById) {
    76  		return valuesById.get(DEFAULT_VALUE);
    77  	}
    78
    79  	protected String numericDefaultValueIn(Map<String, String> valuesById) {
    80  		String number = defaultValueIn(valuesById);
    81  		return StringUtil.isEmpty(number) ? "0" : number;	// TODO is 0 reasonable if undefined?
    82  	}
    83
    84  	protected static String minValueIn(Map<String, String> valuesById) {
    85  		return valuesById.get(MIN);
    86  	}
    87
    88  	protected static String maxValueIn(Map<String, String> valuesById) {
    89  		return valuesById.get(MAX);
    90  	}
    91
    92  //	protected static T[] primitivesFrom(String text, WrapperBuilder<T> builder) {
    93  //
    94  //		String[] values = text.split(",");	// TODO
    95  //		List items = new ArrayList(values.length);
    96  //		for (String value : values) {
    97  //			try {
    98  //				Object newIten = builder.itemFrom(value);
    99  //				items.add(newIten);
    100 //			} catch (Exception ex) {
    101 //
    102 //			}
    103 //		}
    104 //		return items.toArray(builder.newArray(items.size()));
    105 //	}
    106
    107 	protected static Integer[] integersIn(String numberString) {
    108 		String[] values = numberString.split(",");	// TODO
    109 		List<Integer> ints = new ArrayList<Integer>(values.length);
    110 		for (String value : values) {
    111 			try {
    112 				Integer newInt = Integer.parseInt(value);
    113 				ints.add(newInt);
    114 			} catch (Exception ex) {
    115
    116 			}
    117 		}
    118 		return ints.toArray(new Integer[ints.size()]);
    119 	}
    120
    121 	protected static Long[] longsIn(String numberString) {
    122 		String[] values = numberString.split(",");	// TODO
    123 		List<Long> longs = new ArrayList<Long>(values.length);
    124 		for (String value : values) {
    125 			try {
    126 				Long newLong = Long.parseLong(value);
    127 				longs.add(newLong);
    128 			} catch (Exception ex) {
    129
    130 			}
    131 		}
    132 		return longs.toArray(new Long[longs.size()]);
    133 	}
    134
    135 	protected static Float[] floatsIn(String numberString) {
    136 		String[] values = numberString.split(",");	// TODO
    137 		List<Float> floats = new ArrayList<Float>(values.length);
    138 		for (String value : values) {
    139 			try {
    140 				Float newFloat = Float.parseFloat(value);
    141 				floats.add(newFloat);
    142 			} catch (Exception ex) {
    143
    144 			}
    145 		}
    146 		return floats.toArray(new Float[floats.size()]);
    147 	}
    148
    149 	protected static Double[] doublesIn(String numberString) {
    150 		String[] values = numberString.split(",");	// TODO
    151 		List<Double> doubles = new ArrayList<Double>(values.length);
    152 		for (String value : values) {
    153 			try {
    154 				Double newDouble = Double.parseDouble(value);
    155 				doubles.add(newDouble);
    156 			} catch (Exception ex) {
    157
    158 			}
    159 		}
    160 		return doubles.toArray(new Double[doubles.size()]);
    161 	}
    162
    163 	protected static String[] labelsIn(Map<String, String> valuesById) {
    164 		return null;	// TODO
    165 	}
    166
    167 	protected static Object[] choicesIn(Map<String, String> valuesById) {
    168 		return null;	// TODO
    169 	}
    170
    171 	protected static int indexIn(Map<String, String> valuesById) {
    172 		return 0;	// TODO
    173 	}
    174
    175 	protected static int[] indiciesIn(Map<String, String> valuesById) {
    176 		return null;	// TODO
    177 	}
    178
    179 	protected static char delimiterIn(Map<String, String> valuesById) {
    180 		String characterStr = valuesById.get(DELIMITER).trim();
    181 		return characterStr.charAt(0);
    182 	}
    183
    184 	protected static String[] minMaxFrom(Map<String, String> valuesById) {
    185 		String min = minValueIn(valuesById);
    186 		String max = maxValueIn(valuesById);
    187 		if (StringUtil.isEmpty(min) || StringUtil.isEmpty(max)) {
    188 			throw new RuntimeException("min and max values must be specified");
    189 		}
    190 		return new String[] { min, max };
    191 	}
    192
    193 	protected static String[] legalPackageNamesIn(Map<String, String> valuesById) {
    194 		String names = valuesById.get(LEGAL_PACKAGES);
    195 		if (StringUtil.isEmpty(names)) {
    196 			return null;
    197 		}
    198 		return StringUtil.substringsOf(names, '|');	// TODO - get const
    199 	}
    200
    201 	public static Map<String, Boolean> expectedFieldTypesWith(String[] otherKeys, Boolean[] otherValues) {
    202 		Map<String, Boolean> largerMap = new HashMap<String, Boolean>(otherKeys.length + coreFieldTypesByKey.size());
    203 		largerMap.putAll(coreFieldTypesByKey);
    204 		for (int i=0; i<otherKeys.length; i++) {
    205 			largerMap.put(otherKeys[i], otherValues[i]);
    206 		}
    207 		return largerMap;
    208 	}
    209
    210 //	protected static Map<String, PropertyDescriptorFactory> factoriesByTypeIdFrom(PropertyDescriptorFactory[] factories) {
    211 //		Map<String, PropertyDescriptorFactory> factoryMap = new HashMap<String, PropertyDescriptorFactory>(factories.length);
    212 //		for (PropertyDescriptorFactory factory : factories) factoryMap.put(factory.typeId(), factory);
    213 //		return factoryMap;
    214 //	}
    215 //
    216 }