Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   *      Copyright (C) 2012-2015 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.List;
 
 
Static metods that facilitates parsing class annotations into the corresponding EntityMapper.
 
 class AnnotationParser {
 
     private static final Comparator<FieldfieldComparator = new Comparator<Field>() {
         public int compare(Field f1Field f2) {
             return position(f1) - position(f2);
         }
     };
 
     private AnnotationParser() {}
 
     public static <T> EntityMapper<T> parseEntity(Class<T> entityClassEntityMapper.Factory factoryMappingManager mappingManager) {
         Table table = AnnotationChecks.getTypeAnnotation(Table.classentityClass);
 
         String ksName = table.caseSensitiveKeyspace() ? table.keyspace() : table.keyspace().toLowerCase();
         String tableName = table.caseSensitiveTable() ? table.name() : table.name().toLowerCase();
 
         ConsistencyLevel writeConsistency = table.writeConsistency().isEmpty() ? null : ConsistencyLevel.valueOf(table.writeConsistency().toUpperCase());
         ConsistencyLevel readConsistency = table.readConsistency().isEmpty() ? null : ConsistencyLevel.valueOf(table.readConsistency().toUpperCase());
 
         if (Strings.isNullOrEmpty(table.keyspace())) {
             ksName = mappingManager.getSession().getLoggedKeyspace();
             if (Strings.isNullOrEmpty(ksName))
                 throw new IllegalArgumentException(String.format(
                     "Error creating mapper for class %s, the @%s annotation declares no default keyspace, and the session is not currently logged to any keyspace",
                     entityClass.getSimpleName(),
                     Table.class.getSimpleName()
                 ));
         }
 
         EntityMapper<T> mapper = factory.create(entityClassksNametableNamewriteConsistencyreadConsistency);
 
         List<Fieldpks = new ArrayList<Field>();
         List<Fieldccs = new ArrayList<Field>();
         List<Fieldrgs = new ArrayList<Field>();
 
         for (Field field : entityClass.getDeclaredFields()) {
             if(field.isSynthetic() || (field.getModifiers() & .) == .)
                 continue;
 
             if (mappingManager.isCassandraV1 && field.getAnnotation(Computed.class) != null)
                 throw new UnsupportedOperationException("Computed fields are not supported with native protocol v1");
 
             AnnotationChecks.validateAnnotations(field"entity",
                                                  Column.classClusteringColumn.classEnumerated.classFrozen.classFrozenKey.class,
                                                  FrozenValue.classPartitionKey.classTransient.classComputed.class);
 
             if (field.getAnnotation(Transient.class) != null)
                 continue;
 
             switch (kind(field)) {
                 case :
                     pks.add(field);
                     break;
                 case :
                     ccs.add(field);
                     break;
                 default:
                     rgs.add(field);
                     break;
             }
         }
        AtomicInteger columnCounter = mappingManager.isCassandraV1 ? null : new AtomicInteger(0);
        Collections.sort(pks);
        Collections.sort(ccs);
        validateOrder(pks"@PartitionKey");
        validateOrder(ccs"@ClusteringColumn");
        mapper.addColumns(convert(pksfactorymapper.entityClassmappingManagercolumnCounter),
                          convert(ccsfactorymapper.entityClassmappingManagercolumnCounter),
                          convert(rgsfactorymapper.entityClassmappingManagercolumnCounter));
        return mapper;
    }
    public static <T> EntityMapper<T> parseUDT(Class<T> udtClassEntityMapper.Factory factoryMappingManager mappingManager) {
        UDT udt = AnnotationChecks.getTypeAnnotation(UDT.classudtClass);
        String ksName = udt.caseSensitiveKeyspace() ? udt.keyspace() : udt.keyspace().toLowerCase();
        String udtName = udt.caseSensitiveType() ? udt.name() : udt.name().toLowerCase();
        if (Strings.isNullOrEmpty(udt.keyspace())) {
            ksName = mappingManager.getSession().getLoggedKeyspace();
            if (Strings.isNullOrEmpty(ksName))
                throw new IllegalArgumentException(String.format(
                    "Error creating UDT mapper for class %s, the @%s annotation declares no default keyspace, and the session is not currently logged to any keyspace",
                    udtClass.getSimpleName(),
                    UDT.class.getSimpleName()
                ));
        }
        EntityMapper<T> mapper = factory.create(udtClassksNameudtNamenullnull);
        List<Fieldcolumns = new ArrayList<Field>();
        for (Field field : udtClass.getDeclaredFields()) {
            if(field.isSynthetic() || (field.getModifiers() & .) == .)
                continue;
            
            AnnotationChecks.validateAnnotations(field"UDT",
                                                 com.datastax.driver.mapping.annotations.Field.classFrozen.classFrozenKey.class,
                                                 FrozenValue.classEnumerated.classTransient.class);
            if (field.getAnnotation(Transient.class) != null)
                continue;
            switch (kind(field)) {
                case :
                    throw new IllegalArgumentException("Annotation @PartitionKey is not allowed in a class annotated by @UDT");
                case :
                    throw new IllegalArgumentException("Annotation @ClusteringColumn is not allowed in a class annotated by @UDT");
                default:
                    columns.add(field);
                    break;
            }
        }
        mapper.addColumns(convert(columnsfactoryudtClassmappingManagernull));
        return mapper;
    }
    private static <T> List<ColumnMapper<T>> convert(List<FieldfieldsEntityMapper.Factory factoryClass<T> klassMappingManager mappingManagerAtomicInteger columnCounter) {
        List<ColumnMapper<T>> mappers = new ArrayList<ColumnMapper<T>>(fields.size());
        for (int i = 0; i < fields.size(); i++) {
            Field field = fields.get(i);
            int pos = position(field);
            mappers.add(factory.createColumnMapper(klassfieldpos < 0 ? i : posmappingManagercolumnCounter));
        }
        return mappers;
    }
    private static void validateOrder(List<FieldfieldsString annotation) {
        for (int i = 0; i < fields.size(); i++) {
            Field field = fields.get(i);
            int pos = position(field);
            if (pos != i)
                throw new IllegalArgumentException(String.format("Invalid ordering value %d for annotation %s of column %s, was expecting %d",
                                                                 posannotationfield.getName(), i));
        }
    }
    private static int position(Field field) {
        switch (kind(field)) {
            case :
                return field.getAnnotation(PartitionKey.class).value();
            case :
                return field.getAnnotation(ClusteringColumn.class).value();
            default:
                return -1;
        }
    }
    public static ColumnMapper.Kind kind(Field field) {
        PartitionKey pk = field.getAnnotation(PartitionKey.class);
        ClusteringColumn cc = field.getAnnotation(ClusteringColumn.class);
        Computed comp = field.getAnnotation(Computed.class);
        if (pk != null && cc != null)
            throw new IllegalArgumentException("Field " + field.getName() + " cannot have both the @PartitionKey and @ClusteringColumn annotations");
        if (pk != null) {
            return ..;
        }
        if (cc != null) {
            return ..;
        }
        if (comp != null) {
            return ..;
        }
        return ..;
    }
    public static EnumType enumType(Field field) {
        Class<?> type = field.getType();
        if (!type.isEnum())
            return null;
        Enumerated enumerated = field.getAnnotation(Enumerated.class);
        return (enumerated == null) ? . : enumerated.value();
    }
    public static String columnName(Field field) {
        Column column = field.getAnnotation(Column.class);
        Computed computedField = field.getAnnotation(Computed.class);
        if (column != null && !column.name().isEmpty()) {
            if (computedField != null){
                throw new IllegalArgumentException("Cannot use @Column and @Computed on the same field");
            }
            return column.caseSensitive() ? column.name() : column.name().toLowerCase();
        }
        if (udtField != null && !udtField.name().isEmpty()) {
            return udtField.caseSensitive() ? udtField.name() : udtField.name().toLowerCase();
        }
        if (computedField != null) {
            return computedField.value();
        }
        return field.getName().toLowerCase();
    }
    public static String newAlias(Field fieldint columnNumber) {
        return "col" + columnNumber;
    }
    public static <T> AccessorMapper<T> parseAccessor(Class<T> accClassAccessorMapper.Factory factoryMappingManager mappingManager) {
        if (!accClass.isInterface())
            throw new IllegalArgumentException("@Accessor annotation is only allowed on interfaces");
        AnnotationChecks.getTypeAnnotation(Accessor.classaccClass);
        List<MethodMappermethods = new ArrayList<MethodMapper>();
        for (Method m : accClass.getDeclaredMethods()) {
            Query query = m.getAnnotation(Query.class);
            if (query == null)
                continue;
            String queryString = query.value();
            Annotation[][] paramAnnotations = m.getParameterAnnotations();
            Type[] paramTypes = m.getGenericParameterTypes();
            ParamMapper[] paramMappers = new ParamMapper[paramAnnotations.length];
            Boolean hasParamAnnotation = null;
            for (int i = 0; i < paramMappers.lengthi++) {
                String paramName = null;
                for (Annotation a : paramAnnotations[i]) {
                    if (a.annotationType().equals(Param.class)) {
                        paramName = ((Parama).value();
                        break;
                    }
                }
                if (hasParamAnnotation == null)
                    hasParamAnnotation = (paramName != null);
                if (hasParamAnnotation != (paramName != null))
                    throw new IllegalArgumentException(String.format("For method '%s', either all or none of the paramaters of a method must have a @Param annotation"m.getName()));
                paramMappers[i] = newParamMapper(accClass.getName(), m.getName(), iparamNameparamTypes[i], paramAnnotations[i], mappingManager);
            }
            ConsistencyLevel cl = null;
            int fetchSize = -1;
            boolean tracing = false;
            QueryParameters options = m.getAnnotation(QueryParameters.class);
            if (options != null) {
                cl = options.consistency().isEmpty() ? null : ConsistencyLevel.valueOf(options.consistency().toUpperCase());
                fetchSize = options.fetchSize();
                tracing = options.tracing();
            }
            methods.add(new MethodMapper(mqueryStringparamMappersclfetchSizetracing));
        }
        return factory.create(accClassmethods);
    }
    @SuppressWarnings({ "unchecked""rawtypes" })
    private static ParamMapper newParamMapper(String classNameString methodNameint idxString paramNameType paramTypeAnnotation[] paramAnnotationsMappingManager mappingManager) {
        if (paramType instanceof Class) {
            Class<?> paramClass = (Class<?>) paramType;
            if (paramClass.isAnnotationPresent(UDT.class)) {
                UDTMapper<?> udtMapper = mappingManager.getUDTMapper(paramClass);
                return new UDTParamMapper(paramNameidxudtMapper);
            } else if (paramClass.isEnum()) {
                EnumType enumType = .;
                for (Annotation annotation : paramAnnotations) {
                    if (annotation instanceof Enumerated) {
                        enumType = ((Enumeratedannotation).value();
                    }
                }
                return new EnumParamMapper(paramNameidxenumType);
            }
            return new ParamMapper(paramNameidx);
        } if (paramType instanceof ParameterizedType) {
            InferredCQLType inferredCQLType = InferredCQLType.from(classNamemethodNameidxparamNameparamTypemappingManager);
            if (inferredCQLType.containsMappedUDT) {
                // We need a specialized mapper to convert UDT instances in the hierarchy.
                return new NestedUDTParamMapper(paramNameidxinferredCQLType);
            } else {
                // Use the default mapper but provide the extracted type
                return new ParamMapper(paramNameidxinferredCQLType.dataType);
            }
        } else {
            throw new IllegalArgumentException(String.format("Cannot map class %s for parameter %s of %s.%s"paramTypeparamNameclassNamemethodName));
        }
    }
New to GrepCode? Check out our FAQ X