Java Tuple2类代码示例

import org.jooq.lambda.tuple.Tuple2; //导入依赖的package包/类
private ImmutableSet<Pipeline> selectPipelines(InterpreterListener interpreterListener,
                                               Set<Tuple2<String, String>> processingBlacklist,
                                               Message message,
                                               Set<String> initialStreamIds,
                                               ImmutableSetMultimap<String, Pipeline> streamConnection) {
    final String msgId = message.getId();

    // if a message-stream combination has already been processed (is in the set), skip that execution
    final Set<String> streamsIds = initialStreamIds.stream()
            .filter(streamId -> !processingBlacklist.contains(tuple(msgId, streamId)))
            .filter(streamConnection::containsKey)
            .collect(Collectors.toSet());
    final ImmutableSet<Pipeline> pipelinesToRun = streamsIds.stream()
            .flatMap(streamId -> streamConnection.get(streamId).stream())
            .collect(ImmutableSet.toImmutableSet());
    interpreterListener.processStreams(message, pipelinesToRun, streamsIds);
    log.debug("[{}] running pipelines {} for streams {}", msgId, pipelinesToRun, streamsIds);
    return pipelinesToRun;
}
 

import org.jooq.lambda.tuple.Tuple2; //导入依赖的package包/类
@Override
public boolean processLine(@Nonnull String line) throws IOException {
    final String[] strings = csvParser.parseLine(line);
    if (strings == null) {
        return false;
    }
    if (firstLine) {
        fieldNames = strings;
        firstLine = false;
        return true;
    }

    final Map<String, Object> fields = Seq.of(fieldNames)
            .zipWithIndex()
            .map(nameAndIndex -> nameAndIndex.map2(index -> strings[Math.toIntExact(index)]))
            .collect(Collectors.toMap(Tuple2::v1, Tuple2::v2));
    fields.put(Message.FIELD_ID, new UUID().toString());
    messages.add(new Message(fields));
    return true;
}
 

import org.jooq.lambda.tuple.Tuple2; //导入依赖的package包/类
@Test
public void testGetIdentityToken() throws Exception {
    EndpointDescription endpoint = new EndpointDescription(
        null, null, null, null, null,
        new UserTokenPolicy[]{
            new UserTokenPolicy(
                "anonymous",
                UserTokenType.Anonymous,
                null, null, null)
        },
        null, null
    );

    AnonymousProvider p = new AnonymousProvider();

    Tuple2<UserIdentityToken, SignatureData> t2 =
        p.getIdentityToken(endpoint, ByteString.NULL_VALUE);

    assertEquals(t2.v1().getPolicyId(), "anonymous");
    assertTrue(t2.v1() instanceof AnonymousIdentityToken);
}
 

import org.jooq.lambda.tuple.Tuple2; //导入依赖的package包/类
@Test
public void testGetIdentityToken_EmptyPolicyId() throws Exception {
    EndpointDescription endpoint = new EndpointDescription(
        null, null, null, null, null,
        new UserTokenPolicy[]{
            new UserTokenPolicy(
                "",
                UserTokenType.Anonymous,
                null, null, null)
        },
        null, null
    );

    AnonymousProvider p = new AnonymousProvider();

    Tuple2<UserIdentityToken, SignatureData> t2 =
        p.getIdentityToken(endpoint, ByteString.NULL_VALUE);

    assertEquals(t2.v1().getPolicyId(), "");
    assertTrue(t2.v1() instanceof AnonymousIdentityToken);
}
 

import org.jooq.lambda.tuple.Tuple2; //导入依赖的package包/类
@Test
public void testGetIdentityToken_NullPolicyId() throws Exception {
    EndpointDescription endpoint = new EndpointDescription(
        null, null, null, null, null,
        new UserTokenPolicy[]{
            new UserTokenPolicy(
                null,
                UserTokenType.Anonymous,
                null, null, null)
        },
        null, null
    );

    AnonymousProvider p = new AnonymousProvider();

    Tuple2<UserIdentityToken, SignatureData> t2 =
        p.getIdentityToken(endpoint, ByteString.NULL_VALUE);

    assertNull(t2.v1().getPolicyId());
    assertTrue(t2.v1() instanceof AnonymousIdentityToken);
}
 

import org.jooq.lambda.tuple.Tuple2; //导入依赖的package包/类
/**
 * GetMonitoredItems is used to get information about monitored items of a subscription.
 *
 * @param subscriptionId identifier of the subscription.
 * @return a {@link Tuple2} containing the output arguments.
 * <p>
 * serverHandles (UInt32[]) - array of serverHandles for all MonitoredItems of the subscription identified by
 * subscriptionId.
 * <p>
 * clientHandles (UInt32[]) - array of clientHandles for all MonitoredItems of the subscription identified by
 * subscriptionId.
 */
public CompletableFuture<Tuple2<UInteger[], UInteger[]>> invoke(UInteger subscriptionId) {
    Variant[] inputArguments = new Variant[]{
        new Variant(subscriptionId)
    };

    return invoke(inputArguments).thenCompose(outputArguments -> {
        try {
            UInteger[] v0 = (UInteger[]) outputArguments[0].getValue();
            UInteger[] v1 = (UInteger[]) outputArguments[1].getValue();

            return CompletableFuture.completedFuture(new Tuple2<>(v0, v1));
        } catch (Throwable t) {
            CompletableFuture<Tuple2<UInteger[], UInteger[]>> f = new CompletableFuture<>();
            f.completeExceptionally(new UaException(t));
            return f;
        }
    });
}
 

import org.jooq.lambda.tuple.Tuple2; //导入依赖的package包/类
@Override
public Tuple2<UserIdentityToken, SignatureData> getIdentityToken(
    EndpointDescription endpoint,
    ByteString serverNonce) throws Exception {

    List<UserTokenPolicy> userIdentityTokens = l(endpoint.getUserIdentityTokens());

    return userIdentityTokens.stream()
        .filter(t -> t.getTokenType() == UserTokenType.Anonymous)
        .findFirst()
        .map(policy -> {
            UserIdentityToken token = new AnonymousIdentityToken(policy.getPolicyId());

            return new Tuple2<>(token, new SignatureData());
        })
        .orElseThrow(() -> new Exception("no anonymous token policy found"));
}
 

import org.jooq.lambda.tuple.Tuple2; //导入依赖的package包/类
@Override
public Tuple2<UserIdentityToken, SignatureData> getIdentityToken(EndpointDescription endpoint,
                                                                 ByteString serverNonce) throws Exception {

    Iterator<IdentityProvider> iterator = providers.iterator();

    while (iterator.hasNext()) {
        IdentityProvider provider = iterator.next();

        try {
            return provider.getIdentityToken(endpoint, serverNonce);
        } catch (Exception e) {
            if (!iterator.hasNext()) {
                throw e;
            }

            logger.debug("IdentityProvider={} failed, trying next...", provider.toString());
        }
    }

    throw new Exception("no sufficient UserTokenPolicy found");
}
 

import org.jooq.lambda.tuple.Tuple2; //导入依赖的package包/类
@Override
public Observable<JsonObject> bulkInsert(String type,
    List<Tuple2<String, JsonObject>> documents) {
  String uri = "/" + index + "/" + type + "/_bulk";
  
  // prepare the whole body now because it's much faster to send
  // it at once instead of using HTTP chunked mode.
  StringBuilder body = new StringBuilder();
  for (Tuple2<String, JsonObject> e : documents) {
    String id = e.v1;
    String source = e.v2.encode();
    JsonObject subject = new JsonObject().put("_id", id);
    body.append("{\"index\":" + subject.encode() + "}\n" + source + "\n");
  }
  
  return performRequestRetry(HttpMethod.POST, uri, body.toString());
}
 

import org.jooq.lambda.tuple.Tuple2; //导入依赖的package包/类
/**
 * Test if the client can insert multiple documents in one request
 * @param context the test context
 */
@Test
public void bulkInsert(TestContext context) {
  String url = "/" + INDEX + "/" + TYPE + "/_bulk";
  
  stubFor(post(urlEqualTo(url))
      .willReturn(aResponse()
          .withStatus(200)
          .withBody("{}")));
  
  List<Tuple2<String, JsonObject>> documents = new ArrayList<>();
  documents.add(Tuple.tuple("A", new JsonObject().put("name", "Elvis")));
  documents.add(Tuple.tuple("B", new JsonObject().put("name", "Max")));
  
  Async async = context.async();
  client.bulkInsert(TYPE, documents).subscribe(res -> {
    verify(postRequestedFor(urlEqualTo(url))
        .withRequestBody(equalToJson("{\"index\":{\"_id\":\"A\"}}\n" + 
            "{\"name\":\"Elvis\"}\n" + 
            "{\"index\":{\"_id\":\"B\"}}\n" + 
            "{\"name\":\"Max\"}\n")));
    context.assertEquals(0, res.size());
    async.complete();
  }, context::fail);
}
 

import org.jooq.lambda.tuple.Tuple2; //导入依赖的package包/类
private List<Tuple2<GeoJsonChunkMeta, JsonObject>> split(String file)
    throws IOException {
  byte[] json = IOUtils.toByteArray(GeoJsonSplitterTest.class.getResource(file));
  List<Tuple2<GeoJsonChunkMeta, JsonObject>> chunks = new ArrayList<>();
  StringWindow window = new StringWindow();
  GeoJsonSplitter splitter = new GeoJsonSplitter(window);
  Observable.just(json)
    .map(Buffer::buffer)
    .doOnNext(window::append)
    .lift(new JsonParserOperator())
    .flatMap(splitter::onEventObservable)
    .toBlocking()
    .forEach(result -> {
      JsonObject o = new JsonObject(result.getChunk());
      chunks.add(Tuple.tuple((GeoJsonChunkMeta)result.getMeta(), o));
    });
  return chunks;
}
 

import org.jooq.lambda.tuple.Tuple2; //导入依赖的package包/类
/**
 * Test if a Feature can be split correctly
 * @throws IOException if the test file could not be read
 */
@Test
public void feature() throws IOException {
  String filename = "feature.json";
  long size = getFileSize(filename);
  
  List<Tuple2<GeoJsonChunkMeta, JsonObject>> chunks = split(filename);
  assertEquals(1, chunks.size());
  
  Tuple2<GeoJsonChunkMeta, JsonObject> t1 = chunks.get(0);
  
  GeoJsonChunkMeta m1 = t1.v1;
  assertNull(m1.getParentFieldName());
  assertEquals(0, m1.getStart());
  assertEquals(size, m1.getEnd());
  assertEquals("Feature", m1.getType());
  
  JsonObject o1 = t1.v2;
  assertEquals("Feature", o1.getString("type"));
  assertEquals("Fraunhofer IGD", o1.getJsonObject("properties").getString("name"));
}
 

import org.jooq.lambda.tuple.Tuple2; //导入依赖的package包/类
/**
 * Test if a LineString can be split correctly
 * @throws IOException if the test file could not be read
 */
@Test
public void lineString() throws IOException {
  String filename = "linestring.json";
  long size = getFileSize(filename);
  
  List<Tuple2<GeoJsonChunkMeta, JsonObject>> chunks = split(filename);
  assertEquals(1, chunks.size());
  
  Tuple2<GeoJsonChunkMeta, JsonObject> t1 = chunks.get(0);
  
  GeoJsonChunkMeta m1 = t1.v1;
  assertNull(m1.getParentFieldName());
  assertEquals(0, m1.getStart());
  assertEquals(size, m1.getEnd());
  assertEquals("LineString", m1.getType());
  
  JsonObject o1 = t1.v2;
  assertEquals("LineString", o1.getString("type"));
  assertEquals(13, o1.getJsonArray("coordinates").size());
}
 

import org.jooq.lambda.tuple.Tuple2; //导入依赖的package包/类
/**
 * Test if a MultiLineString can be split correctly
 * @throws IOException if the test file could not be read
 */
@Test
public void muliLineString() throws IOException {
  String filename = "multilinestring.json";
  long size = getFileSize(filename);
  
  List<Tuple2<GeoJsonChunkMeta, JsonObject>> chunks = split(filename);
  assertEquals(1, chunks.size());
  
  Tuple2<GeoJsonChunkMeta, JsonObject> t1 = chunks.get(0);
  
  GeoJsonChunkMeta m1 = t1.v1;
  assertNull(m1.getParentFieldName());
  assertEquals(0, m1.getStart());
  assertEquals(size, m1.getEnd());
  assertEquals("MultiLineString", m1.getType());
  
  JsonObject o1 = t1.v2;
  assertEquals("MultiLineString", o1.getString("type"));
  assertEquals(3, o1.getJsonArray("coordinates").size());
}
 

import org.jooq.lambda.tuple.Tuple2; //导入依赖的package包/类
/**
 * Test if a MultiPoint can be split correctly
 * @throws IOException if the test file could not be read
 */
@Test
public void multiPoint() throws IOException {
  String filename = "multipoint.json";
  long size = getFileSize(filename);
  
  List<Tuple2<GeoJsonChunkMeta, JsonObject>> chunks = split(filename);
  assertEquals(1, chunks.size());
  
  Tuple2<GeoJsonChunkMeta, JsonObject> t1 = chunks.get(0);
  
  GeoJsonChunkMeta m1 = t1.v1;
  assertNull(m1.getParentFieldName());
  assertEquals(0, m1.getStart());
  assertEquals(size, m1.getEnd());
  assertEquals("MultiPoint", m1.getType());
  
  JsonObject o1 = t1.v2;
  assertEquals("MultiPoint", o1.getString("type"));
  assertEquals(2, o1.getJsonArray("coordinates").size());
}