Java MappingIterator類代碼示例

import com.fasterxml.jackson.databind.MappingIterator; //導入依賴的package包/類
/**
 * Uses a {@link CsvMapper} to reading a String representing a CSV representation of a PDF
 * Chart, returning a list of {@link ChartCharacter}s
 */
static List<ChartCharacter> readChartCsv(String csvChart) throws ChartParserException {
    CsvSchema schema = CsvSchema.emptySchema()
            .withHeader()
            .withColumnSeparator('|')
            .withoutQuoteChar();

    try {
        MappingIterator<ChartCharacter> mappingIterator =
                getCsvMapper().readerFor(ChartCharacter.class)
                        .with(schema)
                        .readValues(csvChart);
        return mappingIterator.readAll();
    } catch (Exception e) {
        throw new ChartParserException("Error deserializing the Chart CSV data", e);
    }
}
 

import com.fasterxml.jackson.databind.MappingIterator; //導入依賴的package包/類
private MappingIterator<TruckEvent> readTruckEventsFromCsv(InputStream csvStream) throws IOException {
        CsvSchema bootstrap = CsvSchema.builder()
// driverId,truckId,eventTime,eventType,longitude,latitude,eventKey,correlationId,driverName,routeId,routeName,eventDate
                .addColumn("driverId", CsvSchema.ColumnType.NUMBER)
                .addColumn("truckId", CsvSchema.ColumnType.NUMBER)
                .addColumn("eventTime", CsvSchema.ColumnType.STRING)
                .addColumn("eventType", CsvSchema.ColumnType.STRING)
                .addColumn("longitude", CsvSchema.ColumnType.NUMBER)
                .addColumn("latitude", CsvSchema.ColumnType.NUMBER)
                .addColumn("eventKey", CsvSchema.ColumnType.STRING)
                .addColumn("correlationId", CsvSchema.ColumnType.NUMBER)
                .addColumn("driverName", CsvSchema.ColumnType.STRING)
                .addColumn("routeId", CsvSchema.ColumnType.NUMBER)
                .addColumn("routeName", CsvSchema.ColumnType.STRING)
                .addColumn("eventDate", CsvSchema.ColumnType.STRING)
//                .addColumn("miles", CsvSchema.ColumnType.NUMBER)
                .build().withHeader();

        CsvMapper csvMapper = new CsvMapper();
        return csvMapper.readerFor(TruckEvent.class).with(bootstrap).readValues(csvStream);
    }
 

import com.fasterxml.jackson.databind.MappingIterator; //導入依賴的package包/類
protected List<PackageMetadata> deserializeFromIndexFiles(List<File> indexFiles) {
	List<PackageMetadata> packageMetadataList = new ArrayList<>();
	YAMLMapper yamlMapper = new YAMLMapper();
	yamlMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
	for (File indexFile : indexFiles) {
		try {
			MappingIterator<PackageMetadata> it = yamlMapper.readerFor(PackageMetadata.class).readValues(indexFile);
			while (it.hasNextValue()) {
				PackageMetadata packageMetadata = it.next();
				packageMetadataList.add(packageMetadata);
			}
		}
		catch (IOException e) {
			throw new IllegalArgumentException("Can't parse Release manifest YAML", e);
		}
	}
	return packageMetadataList;
}
 

import com.fasterxml.jackson.databind.MappingIterator; //導入依賴的package包/類
public boolean checkCaptcha(String captcha) {
    if (isBlank(captcha)) {
        throw new ErrorCheckCaptcha("error.captcha.required", "Captcha is blank");
    }

    String url = getReCaptcha().getUrl() + "?secret=" + getReCaptcha().getSecretKey() + "&response=" + captcha;
    log.debug("Check captcha by url {}", url);

    final ObjectReader reader = new ObjectMapper().readerFor(Map.class);
    try {
        final MappingIterator<Map<String, Object>> result = reader.readValues(new URL(url));
        Map<String, Object> resultMap = result.nextValue();
        log.info("Captacha result map {}", resultMap);
        Boolean success = (Boolean) resultMap.get("success");
        return success;
    } catch (IOException e) {
        throw new ErrorCheckCaptcha(e);
    }
}
 

import com.fasterxml.jackson.databind.MappingIterator; //導入依賴的package包/類
private void processForkFile(File f, Set<String> users, Set<String> projects) {
	logger.info("Processing "+f);

	try(InputStream in = new FileInputStream(f);) {
		CsvMapper mapper = new CsvMapper();
		CsvSchema schema = mapper.schemaWithHeader().withNullValue("None");
		MappingIterator<GitHubForkEvent> it = mapper.readerFor(GitHubForkEvent.class).with(schema).readValues(in);
		while (it.hasNextValue()) {
			GitHubForkEvent cde = it.next();
			converterService.mapUserForkEvent(cde,
					users, projects);
		}
	}catch(Exception e){
		logger.error("Could not parse data file "+f, e);
	}    		
	
	
}
 

import com.fasterxml.jackson.databind.MappingIterator; //導入依賴的package包/類
private void processCreateDeleteEntity(File f, Set<String> users, Set<String> projects) {
	logger.info("Processing "+f);

	try(InputStream in = new FileInputStream(f);) {
		CsvMapper mapper = new CsvMapper();
		CsvSchema schema = mapper.schemaWithHeader().withNullValue("None");
		MappingIterator<GitHubCreateDeleteEvent> it = mapper.readerFor(GitHubCreateDeleteEvent.class).with(schema).readValues(in);
		while (it.hasNextValue()) {
			GitHubCreateDeleteEvent cde = it.next();
			converterService.mapUserCreateDeleteEvent(cde,
					users, projects);
		}
	}catch(Exception e){
		logger.error("Could not parse data file "+f, e);
	}    		
	
}
 

import com.fasterxml.jackson.databind.MappingIterator; //導入依賴的package包/類
private void processPushEvents(File f, Set<String> users, Set<String> projects) {
	try(InputStream in = new FileInputStream(f);) {
		CsvMapper mapper = new CsvMapper();
		CsvSchema schema = mapper.schemaWithHeader().withNullValue("None");
		long rows = 0;
		MappingIterator<GitHubPushEvent> it = mapper.readerFor(GitHubPushEvent.class).with(schema).readValues(in);
		while (it.hasNextValue()) {
			GitHubPushEvent pe = it.next();
			if (pe.getShas() != null && pe.getShas().length() > 0) {
				String [] shas = pe.getShas().split(";");
				converterService.mapPushEvent(pe, users, projects, commit_shas, shas);
			}
			rows += 1;
			if (rows%10000 == 0) {
				logger.info("....read " + rows + " rows of push_events.csv");
				
			}
		}
	}catch(Exception e){
		logger.error("Could not parse data file "+f, e);
	}    	
			
}
 

import com.fasterxml.jackson.databind.MappingIterator; //導入依賴的package包/類
private void processCommitCommentEvents(File f, Set<String> users, Set<String> projects, Map<String,Long> commit_shas) {
	logger.info("Processing "+f + ", first for Commit messages... ");

	try(InputStream in = new FileInputStream(f);) {
		CsvMapper mapper = new CsvMapper();
		CsvSchema schema = mapper.schemaWithHeader().withNullValue("None");
		MappingIterator<GitHubCommitCommentEvent> it = mapper.readerFor(GitHubCommitCommentEvent.class).with(schema).readValues(in);
		while (it.hasNextValue()) {
			GitHubCommitCommentEvent cde = it.next();
			converterService.mapCommitCommentEvent(cde,
					users, projects, commit_shas.get(cde.getProject() + "#" + cde.getSha()));
		}
	}catch(Exception e){
		logger.error("Could not parse data file "+f, e);
	}    		
}
 

import com.fasterxml.jackson.databind.MappingIterator; //導入依賴的package包/類
/**
 * Parses a pypi_versions.csv file and calls converterService to process it.  
 * 
 * Example header plus one row:
 * 
 * project_owner,project_name,pypi_name,pypi_rawname,version,upload_time,python_version,filename
 * skwashd,python-acquia-cloud,acapi,acapi,0.4.1,2015-11-21 09:30:17,source,acapi-0.4.1.tar.gz
 * 
 * @param filename to process
 */
private void processVersionHistoryFile(File file) {
	logger.info("Processing " + file);
	try(InputStream in = new FileInputStream(file);) {
		CsvMapper mapper = new CsvMapper();
		CsvSchema schema = mapper.schemaWithHeader().withNullValue("None");
		MappingIterator<RevisionEvent> it = mapper.readerFor(RevisionEvent.class).with(schema).readValues(in);
		boolean first = true;
		while (it.hasNextValue()) {
			RevisionEvent revision = it.next();
			//logger.info("Version: " + revision.getProjectFullName() + ", " + revision.getPypiName() + "/" + revision.getVersion() + " " + revision.getUploadTime());
			converterService.mapVersionInfo(
					revision.getProjectFullName(),
					revision.getPypiName(),
					revision.getVersion(), revision.getFilename() + "?" + revision.getPythonVersion(),
					revision.getUploadTime()
					);
		}
	} catch(Exception e){
		logger.error("Could not parse data file "+file, e);
	}  
}
 

import com.fasterxml.jackson.databind.MappingIterator; //導入依賴的package包/類
/**
 * Parses a CSV file listing who watched what project when, 
 * binds its contents to a GitHubWatcherList object,
 * and passes it on to the DiscourseDB converter
 *
 * File format example:
 * 
 * actor,project,created_at
 * F21,danielstjules/Stringy,2015-01-01T00:01:53Z
    * radlws,tomchristie/django-rest-framework,2015-01-01T00:05:29Z
    * 
 * @param file a dataset file to process
 */
private void processWatchEvent(File file, Set<String> users, Set<String> projects){
	logger.info("Processing "+file);

	try(InputStream in = new FileInputStream(file);) {
		CsvMapper mapper = new CsvMapper();
		CsvSchema schema = mapper.schemaWithHeader().withNullValue("None");
		MappingIterator<GitHubWatchEvent> it = mapper.readerFor(GitHubWatchEvent.class).with(schema).readValues(in);
		while (it.hasNextValue()) {
			GitHubWatchEvent gwl = it.next();
			converterService.mapUserRepoEvent(
					gwl.getActor(), gwl.getProject(), gwl.getCreatedAt(),
					DiscoursePartInteractionTypes.WATCH,
					users, projects);
		}
	}catch(Exception e){
		logger.error("Could not parse data file "+file, e);
	}    		
	
}
 

import com.fasterxml.jackson.databind.MappingIterator; //導入依賴的package包/類
/**
 * Parses a CSV file listing which pull requests contained which
 * commits (by SHA),
 * and passes it on to the DiscourseDB converter
 *
 * File format example:
 * 
 * (fix me)
    * 
 * @param file a dataset file to process
 */
private void processPullShasFile(File file, Set<String> users, Set<String> projects, Map<String,Long> commit_shas){
	logger.info("Processing "+file);

	try(InputStream in = new FileInputStream(file);) {
		CsvMapper mapper = new CsvMapper();
		CsvSchema schema = mapper.schemaWithHeader().withNullValue("None");
		MappingIterator<GitHubPullReqCommits> it = mapper.readerFor(GitHubPullReqCommits.class).with(schema).readValues(in);
		long row=0;
		while (it.hasNextValue()) {
			GitHubPullReqCommits prc = it.next();
			converterService.mapPullRequestCommits(prc, users, projects, commit_shas);
			row += 1;
			if (row%10000 == 0) {
				logger.info("pullShasFile row " + row + " out of about 46,000,000");
			}					
		}
	}catch(Exception e){
		logger.error("Could not parse data file "+file, e);
	}    		
	
}
 

import com.fasterxml.jackson.databind.MappingIterator; //導入依賴的package包/類
/**
 * Parses a dataset file, binds its contents to a POJO and passes it on to the DiscourseDB converter
 * 
 * @param file an dataset file to process
 */
private void reprocessForumFileForRelationships(File file){
	// project_owner,project_name,outside_forum_id,unique_message_id,date,author_email,author_name,
	//    title,body,response_to_message_id,thread_path,message_path

	logger.info("Processing "+file);

	CsvMapper mapper = new CsvMapper();
	CsvSchema schema = mapper.schemaWithHeader().withNullValue("None");
	try(InputStream in = new FileInputStream(file);) {

		MappingIterator<MailingListComment> it = mapper.readerFor(MailingListComment.class).with(schema).readValues(in);
		while (it.hasNextValue()) {
			MailingListComment currentPost = it.next();	
			converterService.mapForumPostRelation(currentPost, "GOOGLE_GROUPS");        			
		}

	}catch(Exception e){
		logger.error("Could not parse data file "+file, e);
	}    		
}
 

import com.fasterxml.jackson.databind.MappingIterator; //導入依賴的package包/類
private Iterable<Map<String,String>> csvIteratorExistingHeaders(String filename, char escapeChar) throws JsonProcessingException, IOException {
	//InputStream in = new FileInputStream(filename, "UTF-8");
	InputStreamReader in = new InputStreamReader(new FileInputStream(filename), "ISO-8859-1");
       MappingIterator<Map<String, String>> iterator = new CsvMapper()
               .readerFor(Map.class)
               .with(CsvSchema.emptySchema().withColumnSeparator(',').withHeader().withEscapeChar(escapeChar))
               .readValues(in);
       List<Map<String,String>> sortable = iterator.readAll();
       if (sortable.get(0).containsKey("discussion_answer_created_ts")) {
       		sortable.sort(new Comparator<Map<String,String>>() {
       		    @Override
       		    public int compare(Map<String,String> lhs, Map<String,String> rhs) {
       		        return lhs.get("discussion_answer_created_ts").compareTo(rhs.get("discussion_answer_created_ts"));
       		    }
       		} );
       }
       return () -> sortable.iterator();
}
 

import com.fasterxml.jackson.databind.MappingIterator; //導入依賴的package包/類
public static List<Map<String, Object>> loadValuesFromFile(String filePath) {

		List<Map<String, Object>> result = new ArrayList<>();

		File csvFile = new File(filePath);
		if (!csvFile.exists()) {
			throw new FileLibraryException("Cannot find file " + csvFile.getAbsolutePath());
		}

		try {
			CsvMapper mapper = new CsvMapper();
			CsvSchema schema = CsvSchema.emptySchema().withHeader();
			MappingIterator<Map<String, Object>> it = mapper.readerFor(Map.class).with(schema).readValues(csvFile);
			while (it.hasNext()) {
				result.add(it.next());
			}
			return result;
		} catch (Exception e) {
			throw new FileLibraryException(e);
		}
	}
 

import com.fasterxml.jackson.databind.MappingIterator; //導入依賴的package包/類
public static void main(String[] args) throws IOException {
    CsvParam csvParam = new CsvParam();
    csvParam.setUp();

    CsvMapper csvMapper = new CsvMapper();

    csvMapper.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true);

    CsvSchema bootstrapSchema = CsvSchema.emptySchema().withHeader();

    try(Reader reader = csvParam.getReader()) {
        MappingIterator<City> iterator = csvMapper.readerFor(City.class).with(bootstrapSchema).readValues(reader);

        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}