private void initCols(Schema schema) throws SchemaChangeException { ImmutableList.Builder<ProjectedColumnInfo> pciBuilder = ImmutableList.builder(); for (int i = 0; i < schema.getColumnCount(); i++) { ColumnDTO column = schema.getColumnByIndex(i); final String name = column.getColumnName(); final OpenTSDBTypes type = column.getColumnType(); TypeProtos.MinorType minorType = TYPES.get(type); if (isMinorTypeNull(minorType)) { String message = String.format( "A column you queried has a data type that is not currently supported by the OpenTSDB storage plugin. " + "The column's name was %s and its OpenTSDB data type was %s. ", name, type.toString()); throw UserException.unsupportedError() .message(message) .build(log); } ProjectedColumnInfo pci = getProjectedColumnInfo(column, name, minorType); pciBuilder.add(pci); } projectedCols = pciBuilder.build(); }
private void initCols(Schema schema) throws SchemaChangeException { ImmutableList.Builder<ProjectedColumnInfo> pciBuilder = ImmutableList.builder();
/** * Wraps a collection of tasks. * * @throws NullPointerException if any element of {@code tasks} is null */ private final <T> ImmutableList<Callable<T>> wrapTasks(Collection<? extends Callable<T>> tasks) { ImmutableList.Builder<Callable<T>> builder = ImmutableList.builder(); for (Callable<T> task : tasks) { builder.add(wrapTask(task)); } return builder.build(); }
private ImmutableList<TypeToken<? super T>> boundsAsInterfaces(Type[] bounds) { ImmutableList.Builder<TypeToken<? super T>> builder = ImmutableList.builder(); for (Type bound : bounds) { @SuppressWarnings("unchecked") // upper bound of T TypeToken<? super T> boundType = (TypeToken<? super T>) of(bound); if (boundType.getRawType().isInterface()) { builder.add(boundType); } } return builder.build(); }
@Override ImmutableList<K> collectTypes(Iterable<? extends K> types) { ImmutableList.Builder<K> builder = ImmutableList.builder(); for (K type : types) { if (!getRawType(type).isInterface()) { builder.add(type); } } return super.collectTypes(builder.build()); } };
final ImmutableList<Type> usedInGenericType(Type[] types) { ImmutableList.Builder<Type> builder = ImmutableList.builder(); for (Type type : types) { builder.add(usedInGenericType(type)); } return builder.build(); } }
/** Returns all declared exception types of this {@code Invokable}. */ public final ImmutableList<TypeToken<? extends Throwable>> getExceptionTypes() { ImmutableList.Builder<TypeToken<? extends Throwable>> builder = ImmutableList.builder(); for (Type type : getGenericExceptionTypes()) { // getGenericExceptionTypes() will never return a type that's not exception @SuppressWarnings("unchecked") TypeToken<? extends Throwable> exceptionType = (TypeToken<? extends Throwable>) TypeToken.of(type); builder.add(exceptionType); } return builder.build(); }
ImmutableList.Builder<Object> valuesBuilder = ImmutableList.builder(); for (int j = 0; j < valueCount; j++) { valuesBuilder.add(stream.readObject());
private ImmutableList<ProjectedColumnInfo> initCols(final Schema schema) { ImmutableList.Builder<ProjectedColumnInfo> pciBuilder = ImmutableList.builder(); ColumnDto column; for (int i = 0; i < schema.getNumberOfColumns(); i++) { column = schema.getColumnByIndex(i); final String name = column.getColumnName().toLowerCase(); final PcapTypes type = column.getColumnType(); TypeProtos.MinorType minorType = TYPES.get(type); ProjectedColumnInfo pci = getProjectedColumnInfo(column, name, minorType); pciBuilder.add(pci); } return pciBuilder.build(); }
/** * Returns the generic interfaces that this type directly {@code implements}. This method is * similar but different from {@link Class#getGenericInterfaces()}. For example, {@code new * TypeToken<List<String>>() {}.getGenericInterfaces()} will return a list that contains * {@code new TypeToken<Iterable<String>>() {}}; while {@code List.class.getGenericInterfaces()} * will return an array that contains {@code Iterable<T>}, where the {@code T} is the type * variable declared by interface {@code Iterable}. * * <p>If this type is a type variable or wildcard, its upper bounds are examined and those that * are either an interface or upper-bounded only by interfaces are returned. This means that the * returned types could include type variables too. */ final ImmutableList<TypeToken<? super T>> getGenericInterfaces() { if (runtimeType instanceof TypeVariable) { return boundsAsInterfaces(((TypeVariable<?>) runtimeType).getBounds()); } if (runtimeType instanceof WildcardType) { return boundsAsInterfaces(((WildcardType) runtimeType).getUpperBounds()); } ImmutableList.Builder<TypeToken<? super T>> builder = ImmutableList.builder(); for (Type interfaceType : getRawType().getGenericInterfaces()) { @SuppressWarnings("unchecked") // interface of T TypeToken<? super T> resolvedInterface = (TypeToken<? super T>) resolveSupertype(interfaceType); builder.add(resolvedInterface); } return builder.build(); }
/** * Returns all declared parameters of this {@code Invokable}. Note that if this is a constructor * of a non-static inner class, unlike {@link Constructor#getParameterTypes}, the hidden * {@code this} parameter of the enclosing class is excluded from the returned parameters. */ public final ImmutableList<Parameter> getParameters() { Type[] parameterTypes = getGenericParameterTypes(); Annotation[][] annotations = getParameterAnnotations(); ImmutableList.Builder<Parameter> builder = ImmutableList.builder(); for (int i = 0; i < parameterTypes.length; i++) { builder.add(new Parameter(this, i, TypeToken.of(parameterTypes[i]), annotations[i])); } return builder.build(); }
public RexNode go(RexNode rex) { if (rex instanceof RexCall) { ImmutableList.Builder<RexNode> builder = ImmutableList.builder(); final RexCall call = (RexCall) rex; for (RexNode operand : call.operands) { builder.add(go(operand)); } return call.clone(call.getType(), builder.build()); } else if (rex instanceof RexInputRef) { RexInputRef var = (RexInputRef) rex; int index = var.getIndex(); return rexBuilder.makeInputRef(var.getType(), inputRefMap.get(index)); } else { return rex; } } }
/** * Helper method to create {@link FunctionExprNode} from {@code List<String>}. * @param fieldName Name of the filed on which the like expression is applied. * @param valuesFilter a list of values * @return {@link FunctionExprNode} for given arguments. Null if the <code>valuesFilter</code> is null. */ private static FunctionExprNode createInFunctionExprNode(String fieldName, List<String> valuesFilter) { if (valuesFilter == null) { return null; } ImmutableList.Builder<ExprNode> nodes = ImmutableList.builder(); nodes.add(new FieldExprNode(fieldName)); for(String type: valuesFilter) { nodes.add(new ConstantExprNode(type)); } return new FunctionExprNode(IN_FUNCTION, nodes.build()); }
collection.toArray(new ListenableFuture[collection.size()]); final InCompletionOrderState<T> state = new InCompletionOrderState<>(copy); ImmutableList.Builder<AbstractFuture<T>> delegatesBuilder = ImmutableList.builder(); for (int i = 0; i < copy.length; i++) { delegatesBuilder.add(new InCompletionOrderFuture<T>(state));
private static final Iterable<ConvertSupport> getSupportedConvertOps() { // A set would be more appropriate but it's not possible to produce // duplicates, and an iterable is all we need. ImmutableList.Builder<ConvertSupport> supportedConvertedOps = ImmutableList.builder(); for(MinorType from: MinorType.values()) { for(MinorType to: MinorType.values()) { if (TypeCastRules.isCastable(from, to)) { supportedConvertedOps.add(ConvertSupport.newBuilder().setFrom(from).setTo(to).build()); } } } return supportedConvertedOps.build(); } /**
@Override public void onMatch(RelOptRuleCall call) { final DrillWindowRel oldWinRel = (DrillWindowRel) call.rels[0]; final ImmutableList.Builder<Window.Group> builder = ImmutableList.builder();