@Override protected <A, B> ClassMapBuilder<A, B> newClassMapBuilder( Type<A> aType, Type<B> bType, MapperFactory mapperFactory, PropertyResolverStrategy propertyResolver, DefaultFieldMapper[] defaults) { return new CaseInsensitiveClassMapBuilder<A,B>(aType, bType, mapperFactory, propertyResolver, defaults); } }
/** * @param aType * @param bType * @param mapperFactory * @param propertyResolver * @param defaults */ protected CaseInsensitiveClassMapBuilder(Type<A> aType, Type<B> bType, MapperFactory mapperFactory, PropertyResolverStrategy propertyResolver, DefaultFieldMapper[] defaults) { super(aType, bType, mapperFactory, propertyResolver, defaults); lowercasePropertiesForA = lowercasePropertiesFor(getAType()); lowercasePropertiesForB = lowercasePropertiesFor(getBType()); initialized = true; }
@Override public ClassMapBuilder<A, B> byDefault(MappingDirection direction, DefaultFieldMapper... withDefaults) { super.byDefault(direction, withDefaults); for (final String propertyNameA : getPropertiesForTypeA()) { if (!getMappedPropertiesForTypeA().contains(propertyNameA)) { String lowercaseName = propertyNameA.toLowerCase(); if (lowercasePropertiesForB.containsKey(lowercaseName)) { String propertyNameB = lowercasePropertiesForB.get(lowercaseName); if (!getMappedPropertiesForTypeB().contains(propertyNameB)) { /* * Don't include the default mapping of Class to Class; this * property is resolved for all types, but can't be mapped * in either direction. */ if (!propertyNameA.equals("class")) { fieldMap(propertyNameA, propertyNameB, true).direction(direction).add(); } } } } } return this; }
private Map<String, String> lowercasePropertiesFor(Type type) { final LinkedHashMap<String, String> properties = new LinkedHashMap<String, String>(); for (String property : this.getPropertyExpressions(type).keySet()) { properties.put(property.toLowerCase(), property); } return properties; }
/** * Resolves a property for the particular type, based on the provided property expression * * @param type the type to resolve * @param expr the property expression to resolve * @return the Property referenced by the provided expression */ @Override protected Property resolveProperty(java.lang.reflect.Type type, String expr) { String expression = expr; if (initialized) { Map<String, String> lowercaseProps = type.equals(getAType()) ? lowercasePropertiesForA : lowercasePropertiesForB; String resolvedExpression = lowercaseProps.get(expr.toLowerCase()); if (resolvedExpression != null) { expression = resolvedExpression; } } return super.resolveProperty(type, expression); }