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.List;
 import java.util.Map;
 import java.util.Set;
 
 
 
 // TODO: we probably should make that an abstract class and move some bit in a "ReflexionMethodMapper"
 // subclass for consistency with the rest, but we can see to that later
 class MethodMapper {
 
     public final Method method;
     public final String queryString;
     public final ParamMapper[] paramMappers;
 
     private final ConsistencyLevel consistency;
     private final int fetchSize;
     private final boolean tracing;
 
     private Session session;
     private PreparedStatement statement;
 
     private boolean returnStatement;
     private Mapper<?> returnMapper;
     private boolean mapOne;
     private boolean async;
 
     MethodMapper(Method methodString queryStringParamMapper[] paramMappersConsistencyLevel consistencyint fetchSizeboolean enableTracing) {
         this. = method;
         this. = queryString;
         this. = paramMappers;
         this. = consistency;
         this. = fetchSize;
         this. = enableTracing;
     }
 
     public void prepare(MappingManager managerPreparedStatement ps) {
         this. = manager.getSession();
         this. = ps;
 
         if (.isVarArgs())
             throw new IllegalArgumentException(String.format("Invalid varargs method %s in @Accessor interface"));
         if (ps.getVariables().size() != .getParameterTypes().length)
             throw new IllegalArgumentException(String.format("The number of arguments for method %s (%d) does not match the number of bind parameters in the @Query (%d)",
                                                               .getName(), .getParameterTypes().lengthps.getVariables().size()));
 
         // TODO: we should also validate the types of the parameters...
 
         Class<?> returnType = .getReturnType();
         if (Void.class.isAssignableFrom(returnType) || ResultSet.class.isAssignableFrom(returnType))
             return;
 
         if (Statement.class.isAssignableFrom(returnType)) {
              = true;
             return;
         }
 
         if (ResultSetFuture.class.isAssignableFrom(returnType)) {
             this. = true;
             return;
         }
 
         if (ListenableFuture.class.isAssignableFrom(returnType)) {
             this. = true;
             Type k = ((ParameterizedType).getGenericReturnType()).getActualTypeArguments()[0];
             if (k instanceof Class && ResultSet.class.isAssignableFrom((Class<?>)k))
                 return;
 
             mapType(managerreturnTypek);
         } else {
             mapType(managerreturnType.getGenericReturnType());
         }
     }
 
     @SuppressWarnings("rawtypes")
 	private void mapType(MappingManager managerClass<?> fullReturnTypeType type) {
 
        if (type instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType)type;
            Type raw = pt.getRawType();
            if (raw instanceof Class && Result.class.isAssignableFrom((Class)raw)) {
                type = pt.getActualTypeArguments()[0];
            } else {
                 = true;
            }
        } else {
             = true;
        }
        if (!(type instanceof Class))
            throw new RuntimeException(String.format("Cannot map return of method %s to unsupported type %s"type));
        try {
            this. = (Mapper<?>)manager.mapper((Class<?>)type);
        } catch (Exception e) {
            throw new RuntimeException("Cannot map return to class " + fullReturnTypee);
        }
    }
    public Object invoke(Object[] args) {
        BoundStatement bs = .bind();
        for (int i = 0; i < args.lengthi++) {
            [i].setValue(bsargs[i], protocolVersion);
        }
        if ( != null)
            bs.setConsistencyLevel();
        if ( > 0)
            bs.setFetchSize();
        if ()
            bs.enableTracing();
        if ()
            return bs;
        if () {
            ListenableFuture<ResultSetfuture = .executeAsync(bs);
            if ( == null)
                return future;
            return 
                 ? Futures.transform(future.)
                 : Futures.transform(future.);
        } else {
            ResultSet rs = .execute(bs);
            if ( == null)
                return rs;
            Result<?> result = .map(rs);
            return  ? result.one() : result;
        }
    }
    static class ParamMapper {
        // We'll only set one of the other. If paramName is null, then paramIdx is used.
        private final String paramName;
        private final int paramIdx;
        public ParamMapper(String paramNameint paramIdx) {
            this. = paramName;
            this. = paramIdx;
        }
        void setValue(BoundStatement boundStatementObject argProtocolVersion protocolVersion) {
            if (arg != null) {
                if ( == null)
                    boundStatement.setBytesUnsafe(, DataType.serializeValue(argprotocolVersion));
                else
                    boundStatement.setBytesUnsafe(, DataType.serializeValue(argprotocolVersion));
            }
        }
    }
    static class UDTParamMapper<V> extends ParamMapper {
        private final UDTMapper<V> udtMapper;
        UDTParamMapper(String paramNameint paramIdxUDTMapper<V> udtMapper) {
            super(paramNameparamIdx);
            this. = udtMapper;
        }
        @Override
        void setValue(BoundStatement boundStatementObject argProtocolVersion protocolVersion) {
            @SuppressWarnings("unchecked")
            V entity = (V) arg;
            super.setValue(boundStatement.toUDT(entity), protocolVersion);
        }
    }
    static class UDTListParamMapper<V> extends ParamMapper {
        private final UDTMapper<V> valueMapper;
        UDTListParamMapper(String paramNameint paramIdxUDTMapper<V> valueMapper) {
            super(paramNameparamIdx);
            this. = valueMapper;
        }
        @Override
        void setValue(BoundStatement boundStatementObject argProtocolVersion protocolVersion) {
            @SuppressWarnings("unchecked")
            List<V> entities = (List<V>) arg;
            super.setValue(boundStatement.toUDTValues(entities), protocolVersion);
        }
    }
    static class UDTSetParamMapper<V> extends ParamMapper {
        private final UDTMapper<V> valueMapper;
        UDTSetParamMapper(String paramNameint paramIdxUDTMapper<V> valueMapper) {
            super(paramNameparamIdx);
            this. = valueMapper;
        }
        @Override
        void setValue(BoundStatement boundStatementObject argProtocolVersion protocolVersion) {
            @SuppressWarnings("unchecked")
            Set<V> entities = (Set<V>) arg;
            super.setValue(boundStatement.toUDTValues(entities), protocolVersion);
        }
    }
    static class UDTMapParamMapper<K, V> extends ParamMapper {
        private final UDTMapper<K> keyMapper;
        private final UDTMapper<V> valueMapper;
        UDTMapParamMapper(String paramNameint paramIdxUDTMapper<K> keyMapperUDTMapper<V> valueMapper) {
            super(paramNameparamIdx);
            this. = keyMapper;
            this. = valueMapper;
        }
        @Override
        void setValue(BoundStatement boundStatementObject argProtocolVersion protocolVersion) {
            @SuppressWarnings("unchecked")
            Map<K, V> entities = (Map<K, V>) arg;
            super.setValue(boundStatement, UDTMapper.toUDTValues(entities), protocolVersion);
        }
    }
    static class EnumParamMapper extends ParamMapper {
        private final EnumType enumType;
        public EnumParamMapper(String paramNameint paramIdxEnumType enumType) {
            super(paramNameparamIdx);
            this. = enumType;
        }
        @Override
        void setValue(BoundStatement boundStatementObject argProtocolVersion protocolVersion) {
            super.setValue(boundStatementconvert(arg), protocolVersion);
        }
        @SuppressWarnings("rawtypes")
        private Object convert(Object arg) {
            switch () {
            case :
                return arg.toString();
            case :
                return ((Enumarg).ordinal();
            }
            throw new AssertionError();
        }
    }
New to GrepCode? Check out our FAQ X