Java PairFunction.call方法代码示例

import org.apache.spark.api.java.function.PairFunction; //导入方法依赖的package包/类
private void assertMaptoPairFunction(PairFunction<Tuple2<String, Tuple2<Citation, String>>, String, Citation> function) throws Exception {
    
    Citation inputCitation = new Citation("source-id", 1, null);
    String inputExternalId = "external-id";
    Tuple2<String, Tuple2<Citation, String>> inputTuple = new Tuple2<String, Tuple2<Citation,String>>("groupedId", 
            new Tuple2<Citation, String>(inputCitation, inputExternalId));
    
    Tuple2<String, Citation> result = function.call(inputTuple);
    
    assertEquals(inputExternalId, result._1);
    assertEquals(inputCitation, result._2);
}
 

import org.apache.spark.api.java.function.PairFunction; //导入方法依赖的package包/类
private void assertRelationMapToPair(PairFunction<DocumentToProject, CharSequence, Object> function) throws Exception {
    String docId = "docId";
    String projId = "projId";
    
    Tuple2<CharSequence, Object> result = function.call(DocumentToProject.newBuilder().setDocumentId(docId)
            .setProjectId(projId).setConfidenceLevel(1).build());
    
    assertEquals(docId, result._1);
    assertNull(result._2);
}
 

import org.apache.spark.api.java.function.PairFunction; //导入方法依赖的package包/类
private void assertEntityMapToPair(PairFunction<DocumentText, CharSequence, CharSequence> function) throws Exception {
    String id = "docId";
    String text = "some text";
    
    Tuple2<CharSequence, CharSequence> result = function
            .call(DocumentText.newBuilder().setId(id).setText(text).build());
    
    assertEquals(id, result._1);
    assertEquals(text, result._2);
}
 

import org.apache.spark.api.java.function.PairFunction; //导入方法依赖的package包/类
private void assertRelationMapToPair(PairFunction<DocumentToDataSet, CharSequence, Object> function) throws Exception {
    String docId = "docId";
    String datasetId = "datasetId";
    
    Tuple2<CharSequence, Object> result = function.call(DocumentToDataSet.newBuilder().setDocumentId(docId)
            .setDatasetId(datasetId).setConfidenceLevel(1).build());
    
    assertEquals(datasetId, result._1);
    assertNull(result._2);
}
 

import org.apache.spark.api.java.function.PairFunction; //导入方法依赖的package包/类
private void assertEntityMapToPair(PairFunction<DocumentText, CharSequence, CharSequence> function) throws Exception {
    String id = "datasetId";
    String text = "some text";
    
    Tuple2<CharSequence, CharSequence> result = function
            .call(DocumentText.newBuilder().setId(id).setText(text).build());
    
    assertEquals(id, result._1);
    assertEquals(text, result._2);
}
 

import org.apache.spark.api.java.function.PairFunction; //导入方法依赖的package包/类
private void assertMapToPairFunction(PairFunction<String, AvroKey<String>, NullWritable> mapToPairFunction) throws Exception {
    Tuple2<AvroKey<String>, NullWritable> tuple = mapToPairFunction.call("xyz");
    assertEquals(new AvroKey<String>("xyz"), tuple._1());
    assertEquals(NullWritable.get(), tuple._2());
}
 

import org.apache.spark.api.java.function.PairFunction; //导入方法依赖的package包/类
private void assertAffHashFunction(PairFunction<AffMatchAffiliation, String, AffMatchAffiliation> function) throws Exception {
    
    // given
    
    AffMatchAffiliation aff = new AffMatchAffiliation("DOC1", 1);
    when(affiliationBucketHasher.hash(aff)).thenReturn("HASH");
    
    
    // execute
    
    Tuple2<String, AffMatchAffiliation> hashAff = function.call(aff);
    
    
    // assert
    
    assertEquals("HASH", hashAff._1());
    assertTrue(aff == hashAff._2());
}
 

import org.apache.spark.api.java.function.PairFunction; //导入方法依赖的package包/类
private void assertOrgHashFunction(PairFunction<AffMatchOrganization, String, AffMatchOrganization> function) throws Exception {
    
    // given
    
    AffMatchOrganization org = new AffMatchOrganization("ORG1");
    when(organizationBucketHasher.hash(org)).thenReturn("HASH");
    
    
    // execute
    
    Tuple2<String, AffMatchOrganization> hashOrg = function.call(org);
    
    
    // assert
    
    assertEquals("HASH", hashOrg._1());
    assertTrue(org == hashOrg._2());
}
 

import org.apache.spark.api.java.function.PairFunction; //导入方法依赖的package包/类
private void assertAttachIdFunction(PairFunction<DocumentMetadata, String, DocumentMetadata> function) throws Exception {

        DocumentMetadata docMetadata = DocumentMetadata.newBuilder()
                .setId("someId")
                .setBasicMetadata(new BasicMetadata())
                .setReferences(Lists.newArrayList())
                .build();


        Tuple2<String, DocumentMetadata> retDocWithId = function.call(docMetadata);


        assertEquals("doc_someId", retDocWithId._1);
        assertTrue(retDocWithId._2 == docMetadata);

    }
 

import org.apache.spark.api.java.function.PairFunction; //导入方法依赖的package包/类
private void assertConvertMatchedCitationFunction(PairFunction<Tuple2<MatchableEntity, IdWithSimilarity>, Citation, NullWritable> function) throws Exception {

        MatchableEntity entity = mock(MatchableEntity.class);
        IdWithSimilarity idWithSimilarity = mock(IdWithSimilarity.class);
        Citation citation = mock(Citation.class);

        when(converter.convertToCitation(entity, idWithSimilarity)).thenReturn(citation);


        Tuple2<Citation, NullWritable> retConverted = function.call(new Tuple2<>(entity, idWithSimilarity));


        assertTrue(retConverted._1 == citation);
        verify(converter).convertToCitation(entity, idWithSimilarity);
    }
 

import org.apache.spark.api.java.function.PairFunction; //导入方法依赖的package包/类
private void assertConvertDocumentFunction(PairFunction<Tuple2<String, DocumentMetadata>, String, MatchableEntity> function) throws Exception {
    DocumentMetadata documentMetadata = mock(DocumentMetadata.class);
    MatchableEntity matchableEntity = mock(MatchableEntity.class);

    when(converter.convertToMatchableEntity("doc_someId", documentMetadata)).thenReturn(matchableEntity);


    Tuple2<String, MatchableEntity> retDocument = function.call(new Tuple2<>("doc_someId", documentMetadata));


    assertTrue(retDocument._2 == matchableEntity);
    assertEquals("doc_someId", retDocument._1);
}
 

import org.apache.spark.api.java.function.PairFunction; //导入方法依赖的package包/类
private void assertAvroDocumentToAvroKeyValueFunction(PairFunction<Document, AvroKey<GenericRecord>, NullWritable> function) throws Exception {
	Document document = new Document(5, "doc_title");
	
	Tuple2<AvroKey<GenericRecord>, NullWritable> retTuple = function.call(document);
	
	assertEquals(document, retTuple._1.datum());
}