Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package de.zalando.typemapper.core;
  
  import static de.zalando.typemapper.postgres.PgTypeHelper.getDatabaseFieldDescriptor;
  
  
 import java.util.List;
 import java.util.Map;
 
 
 
 
 public class Mapping {
 
     private final String name;
     private final Class<? extends ValueTransformer<?, ?>> valueTransformer;
     private final Field field;
     private final boolean embed;
     private final Field embedField;
     private FieldMapper fieldMapper;
     private Map<FieldMethodsetter = new ConcurrentHashMap<>();
 
     private static final Map<ClassList<Mapping>> cache = new ConcurrentHashMap<>();
 
     public static List<MappinggetMappingsForClass(@SuppressWarnings("rawtypes"final Class clazz) {
         List<Mappingresult = .get(clazz);
         if (result == null) {
             synchronized (Mapping.class) {
 
                 result = .get(clazz);
                 if (result == null) {
                     result = getMappingsForClass(clazzfalsenull);
 
                     @SuppressWarnings("rawtypes")
                     Class parentClass = clazz.getSuperclass();
                     while (parentClass != null) {
                         result.addAll(Mapping.getMappingsForClass(parentClass));
                         parentClass = parentClass.getSuperclass();
                     }
 
                     .put(clazzresult);
                 }
             }
         }
 
         return result;
     }
 
     @SuppressWarnings("rawtypes")
     static List<MappinggetMappingsForClass(final Class clazzfinal boolean embedfinal Field embedField) {
         final List<Mappingresult = new ArrayList<Mapping>();
         final List<Fieldfields = new LinkedList<Field>();
         for (final Field field : clazz.getDeclaredFields()) {
             fields.add(field);
         }
 
         Class parentClass = clazz.getSuperclass();
         while (parentClass != null) {
             for (final Field field : parentClass.getDeclaredFields()) {
                 fields.add(field);
             }
 
             parentClass = parentClass.getSuperclass();
         }
 
         for (final Field field : fields) {
             final DatabaseFieldDescriptor annotation = getDatabaseFieldDescriptor(field);
             if (annotation != null) {
                 final String databaseFieldName = getDatabaseFieldName(fieldannotation.getName());
                 result.add(new Mapping(fielddatabaseFieldNameembedembedFieldannotation.getTransformer()));
             }
 
             if (!embed) {
                 final Embed embedAnnotation = field.getAnnotation(Embed.class);
                 if (embedAnnotation != null) {
                     result.addAll(getMappingsForClass(field.getType(), truefield));
                 }
             }
         }
 
         return result;
     }
 
     Mapping(final Field fieldfinal String namefinal boolean embedfinal Field embedField,
             final Class<? extends ValueTransformer<?, ?>> valueTransformer) {
        this. = name;
        this. = field;
        this. = embed;
        this. = embedField;
        this. = valueTransformer;
    }
    @SuppressWarnings("rawtypes")
    public Class getFieldClass() {
        if (isOptionalField()) {
            return (Class) ((ParameterizedType.getGenericType()).getActualTypeArguments()[0];
        } else {
            return .getType();
        }
    }
    public boolean isOptionalField() {
        return Optional.class.isAssignableFrom(.getType());
    }
    public Class<? extends ValueTransformer<?, ?>> getValueTransformer() {
        return ;
    }
    public Method getSetter(final Field field) {
        Method method = .get(field);
        if (method == null) {
            final String setterName = "set" + capitalize(field.getName());
            try {
                method = field.getDeclaringClass().getDeclaredMethod(setterNamefield.getType());
                .put(fieldmethod);
            } catch (final Exception e) {
                // ignore and return null
            }
        }
        return method;
    }
    public Method getSetter() {
        return getSetter();
    }
    public Method getGetter(final Field field) {
        final String getterName = "get" + capitalize(field.getName());
        try {
            return field.getDeclaringClass().getDeclaredMethod(getterName);
        } catch (final Exception e) {
            return null;
        }
    }
    public String getName() {
        return ;
    }
    private static String capitalize(final String name) {
        if ((name == null) || (name.length() == 0)) {
            return name;
        }
        if (Character.isUpperCase(name.charAt(0))) {
            return name;
        }
        final char[] chars = name.toCharArray();
        chars[0] = Character.toUpperCase(chars[0]);
        return new String(chars);
    }
    public static final String getDatabaseFieldName(final Field fieldfinal String annotationName) {
        if ((annotationName != null) && !annotationName.isEmpty()) {
            return annotationName;
        }
        return NameUtils.camelCaseToUnderscore(field.getName());
    }
    public Field getField() {
        return ;
    }
        IllegalAccessException {
        if ( == null) {
            final DatabaseFieldDescriptor databaseFieldDescriptor = getDatabaseFieldDescriptor();
            if ((databaseFieldDescriptor != null) && (databaseFieldDescriptor.getTransformer() != null)) {
                if (!AnyTransformer.class.equals(getValueTransformer())) {
                     = new ValueTransformerFieldMapper(getValueTransformer());
                    return ;
                }
            }
             = FieldMapperRegister.getMapperForClass(getFieldClass());
            if ( == null) {
                throw new NotsupportedTypeException("Could not find mapper for type " + getFieldClass());
            }
        }
        return ;
    }
    public void map(final Object targetObject valuethrows IllegalArgumentExceptionIllegalAccessException,
        if (isOptionalField()) {
            value = Optional.fromNullable(value);
        }
        if () {
            Object embedValue = getEmbedFieldValue(target);
            if (embedValue == null) {
                embedValue = initEmbed(target);
            }
            final Method setter = getSetter();
            if (setter != null) {
                setter.invoke(embedValuevalue);
            } else {
                getField().setAccessible(true);
                getField().set(embedValuevalue);
            }
        } else {
            final Method setter = getSetter();
            if (setter != null) {
                setter.invoke(targetvalue);
            } else {
                getField().setAccessible(true);
                getField().set(targetvalue);
            }
        }
    }
    private Object initEmbed(final Object targetthrows InstantiationExceptionIllegalAccessException,
        final Method setter = getSetter();
        final Object value = .getType().newInstance();
        if (setter != null) {
            setter.invoke(targetvalue);
        } else {
            getField().set(targetvalue);
        }
        return value;
    }
        InvocationTargetException {
        final Method setter = getGetter();
        Object result = null;
        if (setter != null) {
            result = setter.invoke(target);
        } else {
            result = .get(target);
        }
        return result;
    }
    @Override
    public String toString() {
        return "Mapping [name=" +  + ", field=" +  + ", embed=" +  + ", embedField=" +  + "]";
    }
New to GrepCode? Check out our FAQ X