Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   *      Copyright (C) 2012-2014 DataStax Inc.
   *
   *   Licensed under the Apache License, Version 2.0 (the "License");
   *   you may not use this file except in compliance with the License.
   *   You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
  *   Unless required by applicable law or agreed to in writing, software
  *   distributed under the License is distributed on an "AS IS" BASIS,
  *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
 package com.datastax.driver.mapping;
 
 import java.util.*;
 
 
An EntityMapper implementation that use reflection to read and write fields of an entity.
 
 class ReflectionMapper<T> extends EntityMapper<T> {
 
     private static ReflectionFactory factory = new ReflectionFactory();
 
     private ReflectionMapper(Class<T> entityClassString keyspaceString tableConsistencyLevel writeConsistencyConsistencyLevel readConsistency) {
         super(entityClasskeyspacetablewriteConsistencyreadConsistency);
     }
 
     public static Factory factory() {
         return ;
     }
 
     @Override
     public T newEntity() {
         try {
             return .newInstance();
         } catch (Exception e) {
             throw new RuntimeException("Can't create an instance of " + .getName());
         }
     }
 
     private static class LiteralMapper<T> extends ColumnMapper<T> {
 
         private final Method readMethod;
         private final Method writeMethod;
 
         private LiteralMapper(Field fieldint positionPropertyDescriptor pd) {
             this(fieldextractType(field), positionpd);
         }
 
         private LiteralMapper(Field fieldDataType typeint positionPropertyDescriptor pd) {
             super(fieldtypeposition);
             this. = pd.getReadMethod();
             this. = pd.getWriteMethod();
         }
 
         @Override
         public Object getValue(T entity) {
             try {
                 return .invoke(entity);
             } catch (IllegalArgumentException e) {
                 throw new IllegalArgumentException("Could not get field '" +  + "'");
             } catch (Exception e) {
                 throw new IllegalStateException("Unable to access getter for '" +  + "' in " + entity.getClass().getName(), e);
             }
         }
 
         @Override
         public void setValue(Object entityObject value) {
             try {
                 .invoke(entityvalue);
             } catch (IllegalArgumentException e) {
                 throw new IllegalArgumentException("Could not set field '" +  + "' to value '" + value + "'");
             } catch (Exception e) {
                 throw new IllegalStateException("Unable to access setter for '" +  + "' in " + entity.getClass().getName(), e);
             }
         }
     }
 
     private static class EnumMapper<T> extends LiteralMapper<T> {
 
         private final EnumType enumType;
        private final Map<StringObjectfromString;
        private EnumMapper(Field fieldint positionPropertyDescriptor pdEnumType enumType) {
            super(fieldenumType == . ? DataType.text() : DataType.cint(), positionpd);
            this. = enumType;
            if (enumType == .) {
                 = new HashMap<StringObject>(.getEnumConstants().length);
                for (Object constant : .getEnumConstants())
                    .put(constant.toString().toLowerCase(), constant);
            } else {
                 = null;
            }
        }
        @SuppressWarnings("rawtypes")
        public Object getValue(T entity) {
            Object value = super.getValue(entity);
            switch () {
                case :
                    return (value == null) ? null : value.toString();
                case :
                    return (value == null) ? null : ((Enum)value).ordinal();
            }
            throw new AssertionError();
        }
        @Override
        public void setValue(Object entityObject value) {
            Object converted = null;
            switch () {
                case :
                    converted = .get(value.toString().toLowerCase());
                    break;
                case :
                    converted = .getEnumConstants()[(Integer)value];
                    break;
            }
            super.setValue(entityconverted);
        }
    }
    private static class UDTColumnMapper<T, U> extends LiteralMapper<T> {
        private final UDTMapper<U> udtMapper;
        private UDTColumnMapper(Field fieldint positionPropertyDescriptor pdUDTMapper<U> udtMapper) {
            super(fieldudtMapper.getUserType(), positionpd);
            this. = udtMapper;
        }
        @Override
        public Object getValue(T entity) {
            @SuppressWarnings("unchecked")
            U udtEntity = (U) super.getValue(entity);
            return udtEntity == null ? null : .toUDT(udtEntity);
        }
        @Override
        public void setValue(Object entityObject value) {
            assert value instanceof UDTValue;
            UDTValue udtValue = (UDTValuevalue;
            assert udtValue.getType().equals(.getUserType());
            super.setValue(entity.toEntity((udtValue)));
        }
    }
    private static class UDTListMapper<T, V> extends LiteralMapper<T> {
        private final UDTMapper<V> valueMapper;
        UDTListMapper(Field fieldint positionPropertyDescriptor pdUDTMapper<V> valueMapper) {
            super(field, DataType.list(valueMapper.getUserType()), positionpd);
            this. = valueMapper;
        }
        @Override
        public Object getValue(T entity) {
            @SuppressWarnings("unchecked")
            List<V> entities = (List<V>) super.getValue(entity);
            return .toUDTValues(entities);
        }
        @Override
        public void setValue(Object entityObject value) {
            @SuppressWarnings("unchecked")
            List<UDTValueudtValues = (List<UDTValue>) value;
            super.setValue(entity.toEntities(udtValues));
        }
    }
    private static class UDTSetMapper<T, V> extends LiteralMapper<T> {
        private final UDTMapper<V> valueMapper;
        UDTSetMapper(Field fieldint positionPropertyDescriptor pdUDTMapper<V> valueMapper) {
            super(field, DataType.set(valueMapper.getUserType()), positionpd);
            this. = valueMapper;
        }
        @Override
        public Object getValue(T entity) {
            @SuppressWarnings("unchecked")
            Set<V> entities = (Set<V>) super.getValue(entity);
            return .toUDTValues(entities);
        }
        @Override
        public void setValue(Object entityObject value) {
            @SuppressWarnings("unchecked")
            Set<UDTValueudtValues = (Set<UDTValue>) value;
            super.setValue(entity.toEntities(udtValues));
        }
    }

    
A map field that contains UDT values.

UDTs may be used either as keys, or as values, or both. This is reflected in keyMapper and valueMapper being null or non-null.

    private static class UDTMapMapper<T, K, V> extends LiteralMapper<T> {
        private final UDTMapper<K> keyMapper;
        private final UDTMapper<V> valueMapper;
        UDTMapMapper(Field fieldint positionPropertyDescriptor pdUDTMapper<K> keyMapperUDTMapper<V> valueMapperClass<?> keyClassClass<?> valueClass) {
            super(fieldbuildDataType(fieldkeyMappervalueMapperkeyClassvalueClass), positionpd);
            this. = keyMapper;
            this. = valueMapper;
        }
        @Override
        public Object getValue(T entity) {
            @SuppressWarnings("unchecked")
            Map<K, V> entities = (Map<K, V>) super.getValue(entity);
            return UDTMapper.toUDTValues(entities);
        }
        @Override
        @SuppressWarnings("unchecked")
        public void setValue(Object entityObject fieldValue) {
            Map<ObjectObjectudtValues = (Map<ObjectObject>) fieldValue;
            super.setValue(entity, UDTMapper.toEntities(udtValues));
        }
        private static <K, V> DataType buildDataType(Field fieldUDTMapper<K> keyMapperUDTMapper<V> valueMapperClass<?> keyClassClass<?> valueClass) {
            assert keyMapper != null || valueMapper != null;
            DataType keyType = (keyMapper != null) ?
                                                  keyMapper.getUserType() :
                                                  getSimpleType(keyClassfield);
            DataType valueType = (valueMapper != null) ?
                                                  valueMapper.getUserType() :
                                                  getSimpleType(valueClassfield);
            return DataType.map(keyTypevalueType);
        }
    }
    static DataType extractType(Field f) {
        Type type = f.getGenericType();
        if (type instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType)type;
            Type raw = pt.getRawType();
            if (!(raw instanceof Class))
                throw new IllegalArgumentException(String.format("Cannot map class %s for field %s"typef.getName()));
            Class<?> klass = (Class<?>)raw;
            if (List.class.isAssignableFrom(klass)) {
                return DataType.list(getSimpleType(ReflectionUtils.getParam(pt, 0, f.getName()), f));
            }
            if (Set.class.isAssignableFrom(klass)) {
                return DataType.set(getSimpleType(ReflectionUtils.getParam(pt, 0, f.getName()), f));
            }
            if (Map.class.isAssignableFrom(klass)) {
                return DataType.map(getSimpleType(ReflectionUtils.getParam(pt, 0, f.getName()), f), getSimpleType(ReflectionUtils.getParam(pt, 1, f.getName()), f));
            }
            throw new IllegalArgumentException(String.format("Cannot map class %s for field %s"typef.getName()));
        }
        if (!(type instanceof Class))
            throw new IllegalArgumentException(String.format("Cannot map class %s for field %s"typef.getName()));
        return getSimpleType((Class<?>)typef);
    }
    static DataType getSimpleType(Class<?> klassField f) {
        if (ByteBuffer.class.isAssignableFrom(klass))
            return DataType.blob();
        if (klass == int.class || Integer.class.isAssignableFrom(klass))
                return DataType.cint();
        if (klass == long.class || Long.class.isAssignableFrom(klass))
            return DataType.bigint();
        if (klass == float.class || Float.class.isAssignableFrom(klass))
            return DataType.cfloat();
        if (klass == double.class || Double.class.isAssignableFrom(klass))
            return DataType.cdouble();
        if (klass == boolean.class || Boolean.class.isAssignableFrom(klass))
            return DataType.cboolean();
        if (BigDecimal.class.isAssignableFrom(klass))
            return DataType.decimal();
        if (BigInteger.class.isAssignableFrom(klass))
            return DataType.varint();
        if (String.class.isAssignableFrom(klass))
            return DataType.text();
        if (InetAddress.class.isAssignableFrom(klass))
            return DataType.inet();
        if (Date.class.isAssignableFrom(klass))
            return DataType.timestamp();
        if (UUID.class.isAssignableFrom(klass))
            return DataType.uuid();
        if (Collection.class.isAssignableFrom(klass))
            throw new IllegalArgumentException(String.format("Cannot map non-parametrized collection type %s for field %s; Please use a concrete type parameter"klass.getName(), f.getName()));
        throw new IllegalArgumentException(String.format("Cannot map unknown class %s for field %s"klass.getName(), f));
    }
    private static class ReflectionFactory implements Factory {
        public <T> EntityMapper<T> create(Class<T> entityClassString keyspaceString tableConsistencyLevel writeConsistencyConsistencyLevel readConsistency) {
            return new ReflectionMapper<T>(entityClasskeyspacetablewriteConsistencyreadConsistency);
        }
        @SuppressWarnings({ "unchecked""rawtypes" })
        public <T> ColumnMapper<T> createColumnMapper(Class<T> entityClassField fieldint positionMappingManager mappingManager) {
            String fieldName = field.getName();
            try {
                PropertyDescriptor pd = new PropertyDescriptor(fieldNamefield.getDeclaringClass());
                if (field.getType().isEnum()) {
                    return new EnumMapper<T>(fieldpositionpd, AnnotationParser.enumType(field));
                }
                if (field.getType().isAnnotationPresent(UDT.class)) {
                    UDTMapper<?> udtMapper = mappingManager.getUDTMapper(field.getType());
                    return (ColumnMapper<T>) new UDTColumnMapper(fieldpositionpdudtMapper);
                }
                if (field.getGenericType() instanceof ParameterizedType) {
                    ParameterizedType pt = (ParameterizedTypefield.getGenericType();
                    Type raw = pt.getRawType();
                    if (!(raw instanceof Class))
                        throw new IllegalArgumentException(String.format("Cannot map class %s for field %s"fieldfield.getName()));
                    Class<?> klass = (Class<?>)raw;
                    Class<?> firstTypeParam = ReflectionUtils.getParam(pt, 0, field.getName());
                    if (List.class.isAssignableFrom(klass) && firstTypeParam.isAnnotationPresent(UDT.class)) {
                        UDTMapper<?> valueMapper = mappingManager.getUDTMapper(firstTypeParam);
                        return (ColumnMapper<T>) new UDTListMapper(fieldpositionpdvalueMapper);
                    }
                    if (Set.class.isAssignableFrom(klass) && firstTypeParam.isAnnotationPresent(UDT.class)) {
                        UDTMapper<?> valueMapper = mappingManager.getUDTMapper(firstTypeParam);
                        return (ColumnMapper<T>) new UDTSetMapper(fieldpositionpdvalueMapper);
                    }
                    if (Map.class.isAssignableFrom(klass)) {
                        Class<?> secondTypeParam = ReflectionUtils.getParam(pt, 1, field.getName());
                        UDTMapper<?> keyMapper = firstTypeParam.isAnnotationPresent(UDT.class) ? mappingManager.getUDTMapper(firstTypeParam) : null;
                        UDTMapper<?> valueMapper = secondTypeParam.isAnnotationPresent(UDT.class) ? mappingManager.getUDTMapper(secondTypeParam) : null;
                        if (keyMapper != null || valueMapper != null) {
                            return (ColumnMapper<T>) new UDTMapMapper(fieldpositionpdkeyMappervalueMapperfirstTypeParamsecondTypeParam);
                        }
                    }
                }
                return new LiteralMapper<T>(fieldpositionpd);
            } catch (IntrospectionException e) {
                throw new IllegalArgumentException("Cannot find matching getter and setter for field '" + fieldName + "'");
            }
        }
    }
New to GrepCode? Check out our FAQ X