private String toFilteredString(MultivaluedMap<String, Object> headers) { return FluentIterable.from(headers.entrySet()).transform(new HeaderToFilteredString()).join(Joiner.on(",\n")); }
private String toString(MultivaluedMap<String, String> headers) { return FluentIterable.from(headers.entrySet()).transform(new HeaderToString()).join(Joiner.on(",\n")); }
private String interpolateCode(String simpleName, Collection<String> attributeNames) { // The implementation is pretty dumb, sorry: no regex, parsing or fancy libraries String c = info.code; if (c.isEmpty()) { return "(" + ATTR_JOINER.join(literals) + ")"; } if (c.contains(P_ALL)) { c = c.replace(P_ALL, ATTR_JOINER.join(literals)); } c = c.replace(P_SIMPLE_NAME, simpleName); if (c.contains(P_ALL_NAMES)) { String literals = FluentIterable.from(attributeNames) .transform(ToLiteral.FUNCTION) .join(COMMA_JOINER); c = c.replace(P_ALL_NAMES, "{" + literals + "}"); } for (Entry<String, String> e : literals.entrySet()) { c = c.replace(P_L + e.getKey() + P_R, e.getValue()); } return c; }
public void testJoin_empty() { assertEquals("", fluent().join(Joiner.on(","))); }
public void testJoin() { assertEquals("2,1,3,4", fluent(2, 1, 3, 4).join(Joiner.on(","))); }
/** Deletes the given exceptions from a method's throws clause. */ public static Fix deleteExceptions( MethodTree tree, final VisitorState state, List<ExpressionTree> toDelete) { List<? extends ExpressionTree> trees = tree.getThrows(); if (toDelete.size() == trees.size()) { return SuggestedFix.replace( getThrowsPosition(tree, state) - 1, state.getEndPosition(getLast(trees)), ""); } String replacement = FluentIterable.from(tree.getThrows()) .filter(Predicates.not(Predicates.in(toDelete))) .transform( new Function<ExpressionTree, String>() { @Override @Nullable public String apply(ExpressionTree input) { return state.getSourceForNode(input); } }) .join(Joiner.on(", ")); return SuggestedFix.replace( ((JCTree) tree.getThrows().get(0)).getStartPosition(), state.getEndPosition(getLast(tree.getThrows())), replacement); }
private String formatTypeParameters(Function<Type, String> function) { if (typeArguments.isEmpty()) { return ""; } String qualifiedTypeParameters = from(typeArguments) .transform(function) .join(Joiner.on(", ")); return "<" + qualifiedTypeParameters + ">"; } }
private String buildEquals(List<FieldSpec> fields) { return FluentIterable.from(fields).transform(new Function<FieldSpec, String>() { @Nullable @Override public String apply(@Nullable FieldSpec fieldSpec) { if ( fieldSpec.type.isPrimitive()) { return CodeBlock.builder().add("(this.$L == other.$L)", fieldSpec.name, fieldSpec.name).build().toString(); } else { return CodeBlock.builder().add("$T.equals(this.$L, other.$L)", Objects.class, fieldSpec.name, fieldSpec.name).build().toString(); } } }).join(Joiner.on(" && ")); }
public static String quotedCompound(List<String> strings){ return FluentIterable.from(strings).transform(QUOTER).join(Joiner.on('.')); }
private String buildEquals(List<FieldSpec> fields) { return FluentIterable.from(fields).transform(new Function<FieldSpec, String>() { @Nullable @Override public String apply(@Nullable FieldSpec fieldSpec) { if ( fieldSpec.type.isPrimitive()) { return CodeBlock.builder().add("(this.$L == other.$L)", fieldSpec.name, fieldSpec.name).build().toString(); } else { return CodeBlock.builder().add("$T.equals(this.$L, other.$L)", Objects.class, fieldSpec.name, fieldSpec.name).build().toString(); } } }).join(Joiner.on(" && ")); }
static String getTypeExpressionFor(ParsedType currentParsedType) { if(currentParsedType.parameters.isEmpty()) { // We're on a raw type return String.format("%s.class", currentParsedType.className); } else { // We're on a parameterized type return String.format("Types.newParameterizedType(%s.class, %s)", currentParsedType.className, FluentIterable.from(currentParsedType.parameters) .transform(new Function<ParsedType, String>() { @Override public String apply(ParsedType param) { return getTypeExpressionFor(param); } }).join(Joiner.on(", ")) ); } }
static String actualTypeParametersString(TypeElement type) { List<? extends TypeParameterElement> typeParameters = type.getTypeParameters(); if (typeParameters.isEmpty()) { return ""; } else { return "<" + FluentIterable.from(typeParameters) .transform(SimpleNameFunction.INSTANCE) .join(Joiner.on(", ")) + ">"; } }
static String actualTypeParametersString(TypeElement type) { List<? extends TypeParameterElement> typeParameters = type.getTypeParameters(); if (typeParameters.isEmpty()) { return ""; } else { return "<" + FluentIterable.from(typeParameters) .transform(SimpleNameFunction.INSTANCE) .join(Joiner.on(", ")) + ">"; } }
static String actualTypeParametersString(TypeElement type) { List<? extends TypeParameterElement> typeParameters = type.getTypeParameters(); if (typeParameters.isEmpty()) { return ""; } else { return "<" + FluentIterable.from(typeParameters) .transform(SimpleNameFunction.INSTANCE) .join(Joiner.on(", ")) + ">"; } }
static String actualTypeParametersString(TypeElement type) { List<? extends TypeParameterElement> typeParameters = type.getTypeParameters(); if (typeParameters.isEmpty()) { return ""; } else { return "<" + FluentIterable.from(typeParameters) .transform(SimpleNameFunction.INSTANCE) .join(Joiner.on(", ")) + ">"; } }
private void onCycle() { String joinedServiceNames = FluentIterable.from(nodes) .filter(Node::notStarted) .transform(n -> n.service.getName()) .join(Joiner.on(", ")); failureRef.set(new StartupFailureException("dependency cycle detected involving the following services: [" + joinedServiceNames + "]")); startLatch.countDown(); }
@Override public FunctionRender render(final FunctionRenderer renderer, RexCall call) { String script = FluentIterable.from(call.getOperands()).transform(new Function<RexNode, String>(){ @Override public String apply(RexNode input) { FunctionRender render = input.accept(renderer.getVisitor()); String notNullScript = getNotNullScript(render.getNulls()); if(notNullScript == null){ return render.getScript(); } return String.format("(%s && %s)", notNullScript, render.getScript()); }}).join(Joiner.on(" || ")); return new FunctionRender(script, EMPTY); }
@Override public String apply(String input) { RelDataTypeField field = type.getField(input, false, false); if(field == null){ throw UserException.validationError() .message("Unable to find field %s in table %s. Available fields were: %s.", input, SqlUtils.quotedCompound(path), FluentIterable.from(type.getFieldNames()).transform(SqlUtils.QUOTER).join(Joiner.on(", ")) ).build(logger); } return field.getName(); }
private static List<NameAndGranularity> qualifyColumnsWithGranularity(DremioTable table, List<NameAndGranularity> strings){ final RelDataType type = table.getRowType(JavaTypeFactoryImpl.INSTANCE); return strings.stream().map(input -> { RelDataTypeField field = type.getField(input.getName(), false, false); if(field == null){ throw UserException.validationError() .message("Unable to find field %s in table %s. Available fields were: %s.", input.getName(), SqlUtils.quotedCompound(table.getPath().getPathComponents()), FluentIterable.from(type.getFieldNames()).transform(SqlUtils.QUOTER).join(Joiner.on(", ")) ).build(logger); } return new NameAndGranularity(field.getName(), input.getGranularity()); }).collect(Collectors.toList()); }
public void testJoin_empty() { assertEquals("", fluent().join(Joiner.on(","))); }