Java Examples for org.codehaus.jackson.type.TypeReference

public static void main(String[] args) throws Exception {
    String source = "{\"oid\":\"7788\",\"displayName\":\"张三\",\"position\":\"工程师\",\"unitName\":\"中国科学院\"}";
    Json json = JacksonSupportJson.buildNormalBinder();
    ObjectMapper mapper = (ObjectMapper) json.getMapper();
    TypeReference type = new TypeReference<Map<String, String>>() {
    };
    Map<String, String> result = mapper.readValue(source, type);
    System.out.println(result.size());
}

@Override
public ResponseParser<List<PushDetailResponse>> getResponseParser() {
    return new ResponseParser<List<PushDetailResponse>>() {

        @Override
        public List<PushDetailResponse> parse(String response) throws IOException {
            return ReportsObjectMapper.getInstance().readValue(response, new TypeReference<List<PushDetailResponse>>() {
            });
        }
    };
}

@Test
public void testParseCountry() throws Exception {
    String content = readResource("/weiboclient4j/model/country.json");
    List<Map<String, String>> result = JsonUtils.parseJsonObject(content, new TypeReference<List<Map<String, String>>>() {
    });
    assertNotNull(result);
    assertEquals(2, result.size());
    assertTrue(result.get(0).containsKey("001"));
    assertEquals("C1", result.get(0).get("001"));
    assertTrue(result.get(1).containsKey("002"));
    assertEquals("C2", result.get(1).get("002"));
}

public List<Object> mapperJson(boolean useCache) {
    List<Object> topCategorys = new ArrayList<Object>();
    tabs.clear();
    try {
        String resultNews = RequestCacheUtil.getRequestContent(mActivity, Urls.TOP_NEWS_URL + Utility.getScreenParams(mActivity), Constants.WebSourceType.Json, Constants.DBContentType.Content_list, useCache);
        NewsMoreResponse newsMoreResponse = mObjectMapper.readValue(resultNews, new TypeReference<NewsMoreResponse>() {
        });
        if (newsMoreResponse != null) {
            this.newsCategorys = newsMoreResponse.getResponse();
        }
        String resultBlogs = RequestCacheUtil.getRequestContent(mActivity, Urls.TOP_BLOG_URL + Utility.getScreenParams(mActivity), Constants.WebSourceType.Json, Constants.DBContentType.Content_list, useCache);
        BlogsMoreResponse blogsMoreResponse = mObjectMapper.readValue(resultBlogs, new TypeReference<BlogsMoreResponse>() {
        });
        if (blogsMoreResponse != null) {
            this.blogsCategorys = blogsMoreResponse.getResponse();
        }
        String resultWiki = RequestCacheUtil.getRequestContent(mActivity, Urls.TOP_WIKI_URL + Utility.getScreenParams(mActivity), Constants.WebSourceType.Json, Constants.DBContentType.Content_list, useCache);
        WikiMoreResponse wikiMoreResponse = mObjectMapper.readValue(resultWiki, new TypeReference<WikiMoreResponse>() {
        });
        if (wikiMoreResponse != null) {
            this.wikiCategorys = wikiMoreResponse.getResponse();
        }
        Collections.addAll(topCategorys, newsCategorys, blogsCategorys, wikiCategorys);
        return topCategorys;
    } catch (JsonParseException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

public List<Object> mapperJson(boolean useCache) {
    List<Object> topCategorys = new ArrayList<Object>();
    tabs.clear();
    try {
        String resultNews = RequestCacheUtil.getRequestContent(mActivity, Urls.TOP_NEWS_URL + Utility.getScreenParams(mActivity), Constants.WebSourceType.Json, Constants.DBContentType.Content_list, useCache);
        NewsMoreResponse newsMoreResponse = mObjectMapper.readValue(resultNews, new TypeReference<NewsMoreResponse>() {
        });
        if (newsMoreResponse != null) {
            this.newsCategorys = newsMoreResponse.getResponse();
        }
        String resultBlogs = RequestCacheUtil.getRequestContent(mActivity, Urls.TOP_BLOG_URL + Utility.getScreenParams(mActivity), Constants.WebSourceType.Json, Constants.DBContentType.Content_list, useCache);
        BlogsMoreResponse blogsMoreResponse = mObjectMapper.readValue(resultBlogs, new TypeReference<BlogsMoreResponse>() {
        });
        if (blogsMoreResponse != null) {
            this.blogsCategorys = blogsMoreResponse.getResponse();
        }
        String resultWiki = RequestCacheUtil.getRequestContent(mActivity, Urls.TOP_WIKI_URL + Utility.getScreenParams(mActivity), Constants.WebSourceType.Json, Constants.DBContentType.Content_list, useCache);
        WikiMoreResponse wikiMoreResponse = mObjectMapper.readValue(resultWiki, new TypeReference<WikiMoreResponse>() {
        });
        if (wikiMoreResponse != null) {
            this.wikiCategorys = wikiMoreResponse.getResponse();
        }
        Collections.addAll(topCategorys, newsCategorys, blogsCategorys, wikiCategorys);
        return topCategorys;
    } catch (JsonParseException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

@Test
public void testJsonParsing() throws IOException {
    jsonMapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    List<MetricData> metricList = jsonMapper.readValue(jsonOutput, new TypeReference<List<MetricData>>() {
    });
    assertEquals(1, metricList.size());
    MetricData resultData = metricList.get(0);
    assertEquals("TEN_MIN", resultData.getFrequency());
    assertEquals(2, resultData.getMetricValues().size());
    assertEquals(5, resultData.getMetricValues().get(1).getCurrent().intValue());
}

/*
	 * 
	 * new list json mapper
	 */
public ArrayList<NewsShort> mapperJson(boolean useCache, String type, String from, String size) {
    // 默认加载10�新闻
    if (size == null)
        size = "10";
    ArrayList<NewsShort> newsJson = null;
    try {
        String result;
        result = RequestCacheUtil.getRequestContentByGet(mActivity, String.format(Urls.NEWS_LIST, type, from, size) + Utility.getScreenParams(mActivity), Constants.WebSourceType.Json, Constants.DBContentType.Content_list, useCache);
        newsJson = mObjectMapper.readValue(result, new TypeReference<ArrayList<NewsShort>>() {
        });
        if (newsJson == null) {
            return null;
        }
        return newsJson;
    } catch (JsonParseException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

public BaseResponse post(BaseMessage request, TypeReference tr) throws IOException, IllegalStateException, UnsupportedEncodingException, RuntimeException {
    HttpPost postRequest = new HttpPost("http://" + host + ":" + port);
    ByteArrayEntity input = new ByteArrayEntity(MAPPER.writeValueAsBytes(request));
    input.setContentType("application/json");
    postRequest.setEntity(input);
    HttpResponse response = client.execute(postRequest);
    if (response.getStatusLine().getStatusCode() != 200) {
        throw new RuntimeException("Failed : HTTP error code : " + response.getStatusLine().getStatusCode());
    }
    BaseResponse r = MAPPER.readValue(response.getEntity().getContent(), tr);
    response.getEntity().getContent().close();
    return r;
}

@PostConstruct
void parse() throws IOException {
    final ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.setPropertyNamingStrategy(PropertyNamingStrategy.CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES);
    List<Container> parsedContainers = objectMapper.readValue(containerDirectoryLocationProvider.getUrl(), new TypeReference<List<Container>>() {
    });
    this.containers = Collections.unmodifiableList(parsedContainers);
}

public void collectFromMessageEvent(final String message) {
    try {
        final Map<String, RobotDryRunKeywordSource> keywordEntry = mapper.readValue(message, new TypeReference<Map<String, RobotDryRunKeywordSource>>() {
        });
        if (keywordEntry.containsKey(KEYWORD_KEY)) {
            keywordSources.add(keywordEntry.get(KEYWORD_KEY));
        }
    } catch (final IOException e) {
        e.printStackTrace();
    }
}

@Override
public Set<String> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    JsonToken token = jp.getCurrentToken();
    if (token.isScalarValue()) {
        String list = jp.getText();
        list = list.replaceAll("\\s+", ",");
        return new LinkedHashSet<String>(Arrays.asList(StringUtils.commaDelimitedListToStringArray(list)));
    }
    return jp.readValueAs(new TypeReference<Set<String>>() {
    });
}

@SuppressWarnings("unchecked")
private Map<String, Object> extractErrorDetailsFromResponse(ClientHttpResponse response) throws IOException {
    ObjectMapper mapper = new ObjectMapper(new JsonFactory());
    Map<String, Object> responseMap = mapper.<Map<String, Object>>readValue(response.getBody(), new TypeReference<Map<String, Object>>() {
    });
    if (responseMap.containsKey("meta")) {
        Map<String, Object> meta = (Map<String, Object>) responseMap.get("meta");
        if (Integer.valueOf(String.valueOf(meta.get("code"))).intValue() > 200) {
            return meta;
        }
    }
    return null;
}

@SuppressWarnings("unchecked")
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
    Map<String, Object> tweet = mapper.readValue(value.toString(), new TypeReference<HashMap<String, Object>>() {
    });
    Map<String, Object> entities = (Map<String, Object>) tweet.get("entities");
    List<Map<String, Object>> hashTagEntries = null;
    if (entities != null) {
        hashTagEntries = (List<Map<String, Object>>) entities.get("hashTags");
    }
    if (hashTagEntries != null && hashTagEntries.size() > 0) {
        for (Map<String, Object> hashTagEntry : hashTagEntries) {
            String hashTag = hashTagEntry.get("text").toString();
            context.write(new Text(hashTag), ONE);
        }
    }
}

/**
     * String => Object
     *
     * @param str
     * @param typeReference
     * @return
     */
public static <T> T string2Obj(String str, org.codehaus.jackson.type.TypeReference<T> typeReference) {
    if (str == null || typeReference == null) {
        return null;
    }
    try {
        return (T) (typeReference.getType().equals(String.class) ? str : objectMapper.readValue(str, typeReference));
    } catch (Exception e) {
        log.info("parse String to Object error, String:{}, TypeReference<T>:{}, error:{}", str, typeReference.getType(), e);
        return null;
    }
}

/**
     * Parses a key value pair map from simple json expression
     * @param value string representation of json object
     * @return parsed value or null for invalid input
     */
public static Map<String, Object> parseMap(String value) {
    JsonFactory factory = new JsonFactory();
    ObjectMapper mapper = new ObjectMapper(factory);
    TypeReference<HashMap<String, Object>> typeRef = new TypeReference<HashMap<String, Object>>() {
    };
    HashMap<String, Object> parsedMap;
    try {
        parsedMap = mapper.readValue(value, typeRef);
        return parsedMap;
    } catch (IOException e) {
        return null;
    }
}

public static <T> T readValueRefer(String jsonStr, Class<T> clazz) {
    try {
        return getInstance().readValue(jsonStr, new TypeReference<T>() {
        });
    } catch (JsonParseException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return null;
}

/**
     *
     * @return the dates of the purged datastream versions
     * @throws FedoraClientException
     */
public List<String> getPurgedDates() throws FedoraClientException {
    if (purgedDates == null) {
        try {
            purgedDates = mapper.readValue(getEntity(String.class), new TypeReference<Collection<String>>() {
            });
        } catch (Exception e) {
            throw new FedoraClientException(e.getMessage(), e);
        }
    }
    return purgedDates;
}

@Post("json")
public Map<String, Object> notify(String entity) throws Exception {
    List<StorageSourceNotification> notifications = null;
    ObjectMapper mapper = new ObjectMapper();
    notifications = mapper.readValue(entity, new TypeReference<List<StorageSourceNotification>>() {
    });
    IStorageSourceService storageSource = (IStorageSourceService) getContext().getAttributes().get(IStorageSourceService.class.getCanonicalName());
    storageSource.notifyListeners(notifications);
    HashMap<String, Object> model = new HashMap<String, Object>();
    model.put("output", "OK");
    return model;
}

@Post("json")
public Map<String, Object> notify(String entity) throws Exception {
    List<StorageSourceNotification> notifications = null;
    ObjectMapper mapper = new ObjectMapper();
    notifications = mapper.readValue(entity, new TypeReference<List<StorageSourceNotification>>() {
    });
    IStorageSourceService storageSource = (IStorageSourceService) getContext().getAttributes().get(IStorageSourceService.class.getCanonicalName());
    storageSource.notifyListeners(notifications);
    HashMap<String, Object> model = new HashMap<String, Object>();
    model.put("output", "OK");
    return model;
}

@Post("json")
public Map<String, Object> notify(String entity) throws Exception {
    List<StorageSourceNotification> notifications = null;
    ObjectMapper mapper = new ObjectMapper();
    notifications = mapper.readValue(entity, new TypeReference<List<StorageSourceNotification>>() {
    });
    IStorageSourceService storageSource = (IStorageSourceService) getContext().getAttributes().get(IStorageSourceService.class.getCanonicalName());
    storageSource.notifyListeners(notifications);
    HashMap<String, Object> model = new HashMap<String, Object>();
    model.put("output", "OK");
    return model;
}

@Post("json")
public Map<String, Object> notify(String entity) throws Exception {
    List<StorageSourceNotification> notifications = null;
    ObjectMapper mapper = new ObjectMapper();
    notifications = mapper.readValue(entity, new TypeReference<List<StorageSourceNotification>>() {
    });
    IStorageSourceService storageSource = (IStorageSourceService) getContext().getAttributes().get(IStorageSourceService.class.getCanonicalName());
    storageSource.notifyListeners(notifications);
    HashMap<String, Object> model = new HashMap<String, Object>();
    model.put("output", "OK");
    return model;
}

public static <T> T readValueRefer(String jsonStr, Class<T> clazz) {
    try {
        return getInstance().readValue(jsonStr, new TypeReference<T>() {
        });
    } catch (JsonParseException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return null;
}

@Test
public void testAllSettingsWhenNoneExist() throws IOException {
    String json = client().resource("/recommendation/settings").get(String.class);
    assertThat(json, notNullValue());
    List<RecommendationSettingsInfo> allSettings = Json.OBJECT_MAPPER.readValue(json, new TypeReference<List<RecommendationSettingsInfo>>() {
    });
    assertThat(allSettings, hasSize(0));
}

@Post("json")
public Map<String, Object> notify(String entity) throws Exception {
    List<StorageSourceNotification> notifications = null;
    ObjectMapper mapper = new ObjectMapper();
    notifications = mapper.readValue(entity, new TypeReference<List<StorageSourceNotification>>() {
    });
    IStorageSourceService storageSource = (IStorageSourceService) getContext().getAttributes().get(IStorageSourceService.class.getCanonicalName());
    storageSource.notifyListeners(notifications);
    HashMap<String, Object> model = new HashMap<String, Object>();
    model.put("output", "OK");
    return model;
}

// - PUBLIC
/**
     * Parse a encrypted String representation of a Token (the cookie value)
     * that was created via the toEncryptedString() method.
     *
     * @param cookieValue		The encrypted String to parse
     * @return					A SessionCookieData object parsed from the String
     */
public static Token fromEncryptedString(String cookieValue, String encryptionKey) throws UtilsException {
    logger.debug("Parsing encrypted session data:\n" + cookieValue);
    String unencryptedValue = EncryptUtil.decrypt(cookieValue, encryptionKey);
    ObjectMapper mapper = new ObjectMapper();
    Token data;
    try {
        data = mapper.readValue(unencryptedValue, new TypeReference<Token>() {
        });
    } catch (Exception e) {
        logger.error("Error reading token data from JSON '" + unencryptedValue + "'", e);
        throw new UtilsException("Unable to parse token data from cookie value", e);
    }
    return data;
}

public static Map<String, Object> jsonStringToMap(String data) {
    try {
        if (data == null)
            return null;
        ObjectMapper jsonMapper = new ObjectMapper();
        TypeReference<Map<String, Object>> type = new TypeReference<Map<String, Object>>() {
        };
        return jsonMapper.readValue(data, type);
    } catch (JsonMappingException e) {
        return null;
    } catch (RuntimeException e) {
        throw e;
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public List<Project> getProjectList() throws IOException {
    if (client == null)
        throw new IllegalStateException("HTTP Client not Initailized");
    client.setResourceName(Constants.JIRA_RESOURCE_PROJECT);
    ClientResponse response = client.get();
    String content = response.getEntity(String.class);
    ObjectMapper mapper = new ObjectMapper();
    mapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, true);
    TypeReference<List<Project>> ref = new TypeReference<List<Project>>() {
    };
    List<Project> prj = mapper.readValue(content, ref);
    return prj;
}

@Override
public List<Space> list(User user, Company company, Integer... depth) throws AlfrescoServiceException {
    if (depth.length > 0) {
        return fromJSON(new TypeReference<List<Space>>() {
        }, getTemplate().postForObject(getAlfrescoServerUrl() + REST_POST_LISTSPACE_DEPTH_OPTION, company, String.class, depth[0], user.getTicketAlfresco()));
    } else {
        return fromJSON(new TypeReference<List<Space>>() {
        }, getTemplate().postForObject(getAlfrescoServerUrl() + REST_POST_LISTSPACE, company, String.class, user.getTicketAlfresco()));
    }
}

@Override
public List<LdbcShortQuery7MessageRepliesResult> marshalResult(String serializedResult) throws SerializingMarshallingException {
    List<List<Object>> resultsAsList;
    try {
        resultsAsList = objectMapper.readValue(serializedResult, new TypeReference<List<List<Object>>>() {
        });
    } catch (IOException e) {
        throw new SerializingMarshallingException(format("Error while parsing serialized results\n%s", serializedResult), e);
    }
    List<LdbcShortQuery7MessageRepliesResult> results = new ArrayList<>();
    for (int i = 0; i < resultsAsList.size(); i++) {
        List<Object> resultAsList = resultsAsList.get(i);
        long commentId = ((Number) resultAsList.get(0)).longValue();
        String commentContent = (String) resultAsList.get(1);
        long commentCreationDate = ((Number) resultAsList.get(2)).longValue();
        long replyAuthorId = ((Number) resultAsList.get(3)).longValue();
        String replyAuthorFirstName = (String) resultAsList.get(4);
        String replyAuthorLastName = (String) resultAsList.get(5);
        boolean isReplyAuthorKnowsOriginalMessageAuthor = (Boolean) resultAsList.get(6);
        results.add(new LdbcShortQuery7MessageRepliesResult(commentId, commentContent, commentCreationDate, replyAuthorId, replyAuthorFirstName, replyAuthorLastName, isReplyAuthorKnowsOriginalMessageAuthor));
    }
    return results;
}

@Override
public String parseTicker(JsonNode node, Pair pair) throws IOException {
    TypeReference<List<JsonNode>> typeRef = new TypeReference<List<JsonNode>>() {
    };
    List<JsonNode> nodes = new ObjectMapper().readValue(node, typeRef);
    String id = BTC_CNY_ID;
    int pos = BTC_CNY_POS;
    if (pair.equals(LTC_CNY)) {
        id = LTC_CNY_ID;
        pos = LTC_CNY_POS;
    } else if (pair.equals(DOGE_CNY)) {
        id = DOGE_CNY_ID;
        pos = DOGE_CNY_POS;
    }
    return nodes.get(pos).get(id).asText();
}

@Override
public Map<String, String> verifyCode(String code) throws IOException, CodeNotFoundException {
    try {
        ExpiringCode expiringCode = uaaTemplate.getForObject(uaaBaseUrl + "/Codes/" + code, ExpiringCode.class);
        return objectMapper.readValue(expiringCode.getData(), new TypeReference<Map<String, String>>() {
        });
    } catch (HttpClientErrorException e) {
        throw new CodeNotFoundException();
    }
}

/**
     *  Load the stats from the local database.
     */
public void loadStats(String sensorId) {
    String statsJSON;
    try {
        statsJSON = SingleInstance.getDatabaseHelper().getValueForKey("stats_" + sensorId).getValue();
    } catch (NullPointerException e) {
        LOGE(TAG, "cannot load stats from local db", e);
        return;
    }
    ObjectMapper mapper = new ObjectMapper();
    try {
        // Read json
        stats = mapper.readValue(statsJSON, new TypeReference<List<StatDTO>>() {
        });
    } catch (IOException e) {
        EventBus.getDefault().post(new BuildAlertEvent(true));
    }
}

@Test
public void testMasterNodeInformationObject() throws IOException {
    String masterNodeInfo = "[{\"id\":\"8sZZWYmmQaeNUKMq1S1uow\",\"host\":\"es-test-useast1d-master-i-9e112345\",\"ip\":\"10.111.22.333\",\"node\":\"us-east-1d.i-9e112345\"}]";
    try {
        List<MasterNodeInformation> myObjs = mapper.readValue(masterNodeInfo, new TypeReference<ArrayList<MasterNodeInformation>>() {
        });
        assertEquals(1, myObjs.size());
        for (MasterNodeInformation key : myObjs) {
            assertEquals("8sZZWYmmQaeNUKMq1S1uow", key.getId());
            assertEquals("es-test-useast1d-master-i-9e112345", key.getHost());
            assertEquals("10.111.22.333", key.getIp());
            assertEquals("us-east-1d.i-9e112345", key.getNode());
        }
    } catch (JsonGenerationException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public static final RpcServer createRpcServer() {
    RequestHandler<Request, Response> handler = new RequestHandler<Request, Response>() {

        @Override
        public TypeReference<Request> getRequestType() {
            return new TypeReference<Request>() {
            };
        }

        @Override
        public Response handleRequest(Request request) throws Exception {
            Response response = new Response();
            response.greeting = "Hello " + request.name + "!";
            return response;
        }
    };
    BasicWorkerFactory factory = new BasicWorkerFactory(ExampleConstants.CONNECTOR, 2);
    factory.addHandler("HelloWorld", handler);
    /*
         * NOTE: The QueueDeclarator is optional.
         * You can set it to null and just create the queue manually.
         * by going to http://localhost:55672/#/queues
         */
    QueueDeclarator queueDeclarator = new QueueDeclarator() {

        @Override
        public void declareQueue(Channel channel, RpcWorker worker) throws IOException {
            Map<String, Object> queueArgs = null;
            QueueUtil.declarePermQueue(channel, worker.getQueueName(), queueArgs);
        }

        @Override
        public void bindQueue(Channel channel, RpcWorker worker) throws IOException {
            channel.exchangeDeclare(ROUTE.exchange, "topic");
            channel.queueBind(worker.getQueueName(), ROUTE.exchange, ROUTE.key);
        }
    };
    String queuePrefix = "RpcExample_";
    PostProcessors postProcessors = null;
    ReconnectLogger reconnectLogger = null;
    return new RpcServer(factory, queuePrefix, queueDeclarator, postProcessors, reconnectLogger);
}

@Test
public void canRegisterAdapterForGenericType() {
    AdapterMapper mapper = new DefaultAdapterMapper();
    mapper.register(new StringCollectionAdapter(), new TypeReference<Collection<String>>() {
    });
    SerializationAdapter<Collection<String>> adapter = mapper.resolveAdapter(new TypeReference<Collection<String>>() {
    });
    assertNotNull(adapter);
}

public void map(Object key, Text value, Context context) throws IOException, InterruptedException {
    Map<String, Object> tweet = jsonMapper.readValue(value.toString(), new TypeReference<HashMap<String, Object>>() {
    });
    Map<String, Object> entities = (Map<String, Object>) tweet.get("entities");
    List<Map<String, Object>> hashTagEntries = null;
    if (entities != null) {
        hashTagEntries = (List<Map<String, Object>>) entities.get("hashtags");
    }
    if (hashTagEntries != null && hashTagEntries.size() > 0) {
        for (Map<String, Object> hashTagEntry : hashTagEntries) {
            String hashTag = hashTagEntry.get("text").toString();
            context.write(new Text(hashTag), ONE);
        }
    }
}

@Post("json")
public Map<String, Object> notify(String entity) throws Exception {
    List<StorageSourceNotification> notifications = null;
    ObjectMapper mapper = new ObjectMapper();
    notifications = mapper.readValue(entity, new TypeReference<List<StorageSourceNotification>>() {
    });
    IStorageSourceService storageSource = (IStorageSourceService) getContext().getAttributes().get(IStorageSourceService.class.getCanonicalName());
    storageSource.notifyListeners(notifications);
    HashMap<String, Object> model = new HashMap<String, Object>();
    model.put("output", "OK");
    return model;
}

@Override
protected Map<String, String> _run() {
    Output.print(description);
    List<Member> members = RestTemplate.get(url, new TypeReference<List<Member>>() {
    });
    if ((members == null) || members.isEmpty()) {
        Output.print("  ^black^None^r^");
        return Collections.emptyMap();
    }
    return printMembers(members, 1);
}

public static <T> T readValueRefer(String jsonStr, Class<T> clazz) {
    try {
        return getInstance().readValue(jsonStr, new TypeReference<T>() {
        });
    } catch (JsonParseException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return null;
}

public static <T> T readValueRefer(String jsonStr, Class<T> clazz) {
    try {
        return getInstance().readValue(jsonStr, new TypeReference<T>() {
        });
    } catch (JsonParseException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return null;
}

/**
     * Process the JSON formatted string value of a signature question and return the string
     * representing the signatory. A blank string is returned
     *
     * @param value
     * @return
     */
public static String parseSignatory(String value) {
    String signatory = null;
    Map<String, String> signatureResponse = null;
    try {
        signatureResponse = JSON_OBJECT_MAPPER.readValue(value, new TypeReference<Map<String, String>>() {
        });
        signatory = signatureResponse.get("name");
    } catch (IOException e) {
    }
    return signatory;
}

@Post("json")
public Map<String, Object> notify(String entity) throws Exception {
    List<StorageSourceNotification> notifications = null;
    ObjectMapper mapper = new ObjectMapper();
    notifications = mapper.readValue(entity, new TypeReference<List<StorageSourceNotification>>() {
    });
    IStorageSourceService storageSource = (IStorageSourceService) getContext().getAttributes().get(IStorageSourceService.class.getCanonicalName());
    storageSource.notifyListeners(notifications);
    HashMap<String, Object> model = new HashMap<String, Object>();
    model.put("output", "OK");
    return model;
}

public static List<Container> getContainers() {
    if (containers != null) {
        return containers;
    }
    ObjectMapper objectMapper = new ObjectMapper();
    URL url = getUrl();
    if (url != null) {
        try {
            containers = objectMapper.readValue(url, new TypeReference<List<Container>>() {
            });
            return containers;
        } catch (Exception e) {
            ArquillianCoreActivator.log(e);
        }
    }
    return Collections.emptyList();
}

@SuppressWarnings("unchecked")
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
    Map<String, Object> tweet = jsonMapper.readValue(value.toString(), new TypeReference<HashMap<String, Object>>() {
    });
    Map<String, Object> entities = (Map<String, Object>) tweet.get("entities");
    List<Map<String, Object>> hashTagEntries = null;
    if (entities != null) {
        hashTagEntries = (List<Map<String, Object>>) entities.get("hashtags");
    }
    if (hashTagEntries != null && hashTagEntries.size() > 0) {
        for (Map<String, Object> hashTagEntry : hashTagEntries) {
            String hashTag = hashTagEntry.get("text").toString();
            context.write(new Text(hashTag), ONE);
        }
    }
}

@PostLoad
public void loadMessageDisplayCounters() {
    if (messageDisplayCountersStorage == null)
        return;
    JsonFactory factory = new JsonFactory();
    ObjectMapper mapper = new ObjectMapper(factory);
    TypeReference<HashMap<String, Object>> typeRef = new TypeReference<HashMap<String, Object>>() {
    };
    try {
        messageDisplayCounters = mapper.readValue(messageDisplayCountersStorage, typeRef);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

protected void map(Text jsonRecord, Text empty, Context context) throws java.io.IOException, InterruptedException {
    Map<String, Object> record;
    try {
        record = objectMapper.readValue(jsonRecord.getBytes(), new TypeReference<Map<String, Object>>() {
        });
    } catch (Exception e) {
        context.getCounter("ERROR:" + e.getClass().getSimpleName(), "BAD_RECORDS").increment(1);
        return;
    }
    try {
        storageModule.store(record);
        context.getCounter(storageModule.getClass().getSimpleName(), "RECORDS_STORED").increment(1);
    } catch (Exception e) {
        context.getCounter("ERROR:" + e.getClass().getSimpleName(), "FAILED_STORE:" + storageModule.getClass().getSimpleName()).increment(1);
    }
    context.getCounter("TOTAL", "RECORDS").increment(1);
    context.progress();
}

@Override
public void setupProvider(BlurConfiguration config) throws Exception {
    String securityFile = config.get("blur.console.authorization.provider.globaljson.file");
    if (securityFile != null) {
        JsonFactory factory = new JsonFactory();
        ObjectMapper mapper = new ObjectMapper(factory);
        File from = new File(securityFile);
        TypeReference<Map<String, Map<String, String>>> typeRef = new TypeReference<Map<String, Map<String, String>>>() {
        };
        try {
            Map<String, Map<String, String>> properties = mapper.readValue(from, typeRef);
            globalUserProperties = Collections.unmodifiableMap(properties);
        } catch (Exception e) {
            log.error("Unable to parse security file.  Search may not work right.", e);
            globalUserProperties = null;
        }
    }
}

@SuppressWarnings("unchecked")
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
    Map<String, Object> tweet = jsonMapper.readValue(value.toString(), new TypeReference<HashMap<String, Object>>() {
    });
    Map<String, Object> entities = (Map<String, Object>) tweet.get("entities");
    List<Map<String, Object>> hashTagEntries = null;
    if (entities != null) {
        hashTagEntries = (List<Map<String, Object>>) entities.get("hashtags");
    }
    if (hashTagEntries != null && hashTagEntries.size() > 0) {
        for (Map<String, Object> hashTagEntry : hashTagEntries) {
            String hashTag = hashTagEntry.get("text").toString();
            context.write(new Text(hashTag), ONE);
        }
    }
}

public static void main(String[] args) throws Exception {
    Configuration configuration = new Configuration();
    OAuthConsumer oAuthConsumer = new CommonsHttpOAuthConsumer(configuration.getProperty(ConfigurationProperty.CONSUMER_KEY), configuration.getProperty(ConfigurationProperty.CONSUMER_SECRET));
    oAuthConsumer.setTokenWithSecret(configuration.getProperty(ConfigurationProperty.TOKEN_VALUE), configuration.getProperty(ConfigurationProperty.TOKEN_SECRET));
    SSLContext sslcontext = SSLContexts.custom().loadTrustMaterial(null, new TrustAllStrategy()).build();
    SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext, new String[] { "TLSv1" }, null, SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
    CloseableHttpClient client = HttpClients.custom().setSSLSocketFactory(sslsf).build();
    try {
        HttpGet request = new HttpGet(BASE_URL + "/orders/1234567");
        oAuthConsumer.sign(request);
        CloseableHttpResponse httpResponse = client.execute(request);
        try {
            System.out.println("Code: " + httpResponse.getStatusLine().getStatusCode() + ',' + httpResponse.getStatusLine().getReasonPhrase());
            InputStream stream = httpResponse.getEntity().getContent();
            ObjectMapper mapper = new ObjectMapper();
            ResponseDT<List<OrderDT>> response = mapper.readValue(stream, new TypeReference<ResponseDT<OrderDT>>() {
            });
            System.out.println(response);
        } finally {
            httpResponse.close();
        }
    } finally {
        client.close();
    }
}

public List<Reminder> getReminders(MoonEvent event, boolean checkExpiration) {
    List<Reminder> reminders = this.<List<Reminder>>loadFromJson(getRemindersKey(event), "[]", new TypeReference<List<Reminder>>() {
    });
    if (checkExpiration && !reminders.isEmpty()) {
        long eventTime = event.getDate().getTime();
        long lastUpdated = _preferences.getLong(getRemindersLastUpdated(event.getType()), eventTime);
        Log.d("debug", "check expiration: " + lastUpdated + " / " + eventTime);
        if (Math.abs(eventTime - lastUpdated) > 1000 * 60 * 60 * 24) {
            Log.d("debug", "expire checked reminders for " + event.getType().getDisplayName());
            for (Reminder reminder : reminders) {
                reminder.setChecked(false);
            }
        }
    }
    return reminders;
}

@Override
public void store(WorkspaceMaterialField field, WorkspaceMaterialReply reply, String value) throws WorkspaceFieldIOException {
    Map<String, String> valueMap = null;
    try {
        valueMap = new ObjectMapper().readValue(value, new TypeReference<Map<String, String>>() {
        });
    } catch (IOException e) {
        throw new WorkspaceFieldIOException("Could not unmarshal field response", e);
    }
    QueryConnectField queryConnectField = (QueryConnectField) field.getQueryField();
    if (queryConnectField != null) {
        List<QueryConnectFieldTerm> terms = queryConnectFieldController.listConnectFieldTermsByField(queryConnectField);
        for (QueryConnectFieldTerm term : terms) {
            String parameterValue = valueMap.get(term.getName());
            QueryConnectFieldCounterpart counterpart = StringUtils.isNotEmpty(parameterValue) ? queryConnectFieldController.findQueryConnectFieldCounterpartByFieldAndName(queryConnectField, parameterValue) : null;
            WorkspaceMaterialConnectFieldAnswer connectFieldAnswer = workspaceMaterialFieldAnswerController.findWorkspaceMaterialConnectFieldAnswerByFieldAndReplyAndTerm(field, reply, term);
            if (connectFieldAnswer != null) {
                workspaceMaterialFieldAnswerController.updateWorkspaceMaterialConnectFieldAnswerCounterpart(connectFieldAnswer, counterpart);
            } else {
                if (counterpart != null) {
                    workspaceMaterialFieldAnswerController.createWorkspaceMaterialConnectFieldAnswer(field, reply, term, counterpart);
                }
            }
        }
    } else {
        throw new WorkspaceFieldIOException("Workspace material connect field #" + field.getId() + " points to non-existing field ");
    }
}

@Test
public void testToJson() throws IOException {
    inMemoryProvider.addMapping("app0", "user0.0", "pentaho0");
    inMemoryProvider.addMapping("app0", "user0.1", "pentaho1");
    inMemoryProvider.addMapping("app0", "user0.2", "pentaho2");
    inMemoryProvider.addMapping("app1", "user0.0", "pentaho3");
    inMemoryProvider.addMapping("app1", "user0.1", "pentaho4");
    String json = inMemoryProvider.toJson();
    System.out.println(json);
    ObjectMapper mapper = new ObjectMapper();
    Object result = mapper.readValue(json, new TypeReference<Map<String, ApplicationMappings>>() {
    });
    assertNotNull(result);
    @SuppressWarnings("unchecked") Map<String, ApplicationMappings> maps = (Map<String, ApplicationMappings>) result;
    InMemoryUsernameProvider checkProvider = new InMemoryUsernameProvider();
    checkProvider.setApplicationsMap(maps);
    String pentahoUser = checkProvider.getUsername("app0", "user0.0");
    assertNotNull(pentahoUser);
    assertEquals("pentaho0", pentahoUser);
    pentahoUser = checkProvider.getUsername("app1", "user0.1");
    assertNotNull(pentahoUser);
    assertEquals("pentaho4", pentahoUser);
}

/**
     * Restores a {@link LinkState} from its string representation.
     * 
     * @param serialized the string representation
     * @return the restored
     * @throws IOException on failure to parse the given string
     */
public static LinkState deserialize(String serialized) throws IOException {
    ObjectMapper mapper = JsonUtils.getDefaultObjectMapper();
    try {
        List<LinkStateJsonStub> stubList = mapper.readValue(serialized, new TypeReference<List<LinkStateJsonStub>>() {
        });
        List<Link> links = new ArrayList<Link>();
        for (LinkStateJsonStub stub : stubList) {
            links.add(stub.toLink());
        }
        return new LinkState(links);
    } catch (IOException e) {
        throw new IOException("Failed to parse link state data: linkStateData", e);
    }
}

@SuppressWarnings("unchecked")
public static <T> T deSer(String str, TypeReference<T> ref) throws JSONSerDeException {
    try {
        return (T) mapper.readValue(str, ref);
    } catch (JsonParseException e) {
        throw new JSONSerDeException(e);
    } catch (JsonMappingException e) {
        throw new JSONSerDeException(e);
    } catch (IOException e) {
        throw new JSONSerDeException(e);
    }
}

public static Map<String, Object> convertJsonToMap(String json) {
    Map<String, Object> retMap = new HashMap<String, Object>();
    if (json != null) {
        try {
            retMap = mapper.readValue(json, new TypeReference<Map<String, Object>>() {
            });
        } catch (IOException e) {
            logger.warn("Error while reading Java Map from JSON response: " + json, e);
        }
    }
    return retMap;
}

public List<ExperimentDescriptor> parseExperiments(String s) {
    ObjectMapper mapper = new ObjectMapper();
    LinkedHashMap<String, Object> map = new LinkedHashMap<String, Object>();
    try {
        map = mapper.readValue(s.getBytes(), new TypeReference<LinkedHashMap<String, Object>>() {
        });
    } catch (JsonParseException e1) {
        log.append(_("ERROR - JsonParseException while parsing the received message!\n"));
        logger.error("", e1);
    } catch (JsonMappingException e1) {
        log.append(_("ERROR - JsonMappingException while parsing the received message!\n"));
        logger.error("", e1);
    } catch (IOException e1) {
        log.append(_("ERROR - IOException while parsing the received message!\n"));
        logger.error("", e1);
    }
    if (map == null)
        return null;
    List<LinkedHashMap<String, Object>> list = (List<LinkedHashMap<String, Object>>) map.get(getExperimentsListFieldName());
    boolean errorAlreadyOcurred = false;
    List<ExperimentDescriptor> experiments = new ArrayList<ExperimentDescriptor>();
    for (LinkedHashMap<String, Object> exp : list) {
        try {
            ExperimentDescriptor descriptor = parseSingleExperiment(exp);
            descriptor.setCorrectlyRead(true);
            experiments.add(descriptor);
        } catch (Exception e) {
            if (!errorAlreadyOcurred) {
                log.append(_("ERROR - there was an error while parsing experiment data! (Bad message format?)\n"));
                errorAlreadyOcurred = true;
            }
            logger.error("There was an error parsing an experiment: " + e.getMessage());
            logger.error("", e);
        }
    }
    return experiments;
}

public Set<WharfResolverMetadata> getWharfMetadatas(File baseDir) {
    File resolversFile = new File(baseDir, RESOLVERS_FILE_PATH);
    if (resolversFile.exists()) {
        InputStream stream = null;
        try {
            stream = new FileInputStream(resolversFile);
            JsonParser jsonParser = JacksonFactory.createJsonParser(stream);
            return jsonParser.readValueAs(new TypeReference<Set<WharfResolverMetadata>>() {
            });
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if ((stream != null)) {
                try {
                    stream.close();
                } catch (IOException e) {
                }
            }
        }
    } else {
        return new HashSet<WharfResolverMetadata>();
    }
}

private HashMap<String, Object> from(String JSONString) {
    ObjectMapper mapper = new ObjectMapper();
    TypeReference<HashMap<String, Object>> typeRef = new TypeReference<HashMap<String, Object>>() {
    };
    try {
        return mapper.readValue(JSONString, typeRef);
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    }
}

@Deprecated
public <E> E deSerializeList(String jsonString, TypeReference<E> type) {
    ObjectMapper mapper = new ObjectMapper();
    mapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    try {
        if (jsonString != null) {
            E docList = mapper.readValue(jsonString, type);
            return docList;
        }
    } catch (Exception e) {
        logger.error("JSON deserialization exception", e);
    }
    return null;
}

private static Map<Resource.InternalType, Map<String, Map<String, PropertyInfo>>> readPropertyProviderIds(String filename) {
    ObjectMapper mapper = new ObjectMapper();
    try {
        Map<Resource.InternalType, Map<String, Map<String, Metric>>> resourceMetricMap = mapper.readValue(ClassLoader.getSystemResourceAsStream(filename), new TypeReference<Map<Resource.InternalType, Map<String, Map<String, Metric>>>>() {
        });
        Map<Resource.InternalType, Map<String, Map<String, PropertyInfo>>> resourceMetrics = new HashMap<Resource.InternalType, Map<String, Map<String, PropertyInfo>>>();
        for (Map.Entry<Resource.InternalType, Map<String, Map<String, Metric>>> resourceEntry : resourceMetricMap.entrySet()) {
            Map<String, Map<String, PropertyInfo>> componentMetrics = new HashMap<String, Map<String, PropertyInfo>>();
            for (Map.Entry<String, Map<String, Metric>> componentEntry : resourceEntry.getValue().entrySet()) {
                Map<String, PropertyInfo> metrics = new HashMap<String, PropertyInfo>();
                for (Map.Entry<String, Metric> metricEntry : componentEntry.getValue().entrySet()) {
                    String property = metricEntry.getKey();
                    Metric metric = metricEntry.getValue();
                    metrics.put(property, new PropertyInfo(metric.getMetric(), metric.isTemporal(), metric.isPointInTime()));
                }
                componentMetrics.put(componentEntry.getKey(), metrics);
            }
            resourceMetrics.put(resourceEntry.getKey(), componentMetrics);
        }
        return resourceMetrics;
    } catch (IOException e) {
        throw new IllegalStateException("Can't read properties file " + filename, e);
    }
}

/**
	 * Gets the object.
	 * 
	 * @return the object
	 */
@Transient
@JsonIgnore
public Object getObject() {
    Object object = null;
    ObjectMapper mapper = new ObjectMapper();
    String acv = this.confValue;
    try {
        object = mapper.readValue(acv, new TypeReference<Map<String, Object>>() {
        });
    } catch (Exception e) {
        logger.error(e.getMessage(), e);
    }
    return object;
}

/*
     * (non-Javadoc)
     * 
     * @see org.appwork.storage.JSONMapper#stringToObject(java.lang.String,
     * org.appwork.storage.TypeRef)
     */
@SuppressWarnings("unchecked")
@Override
public <T> T stringToObject(final String jsonString, final TypeRef<T> type) throws JSonMapperException {
    try {
        final TypeReference<T> tr = new TypeReference<T>() {

            @Override
            public Type getType() {
                return type.getType();
            }
        };
        // (compiles in eclipse, but not with javac)
        return (T) this.mapper.readValue(jsonString, tr);
    } catch (final JsonParseException e) {
        throw new JSonMapperException(e);
    } catch (final JsonMappingException e) {
        throw new JSonMapperException(e);
    } catch (final IOException e) {
        throw new JSonMapperException(e);
    }
}

public void deserialize() {
    ObjectMapper mapper = new ObjectMapper();
    File file = new File("synonymDictionary.json");
    try {
        file.createNewFile();
    } catch (IOException e) {
        e.printStackTrace();
    }
    try {
        TypeReference<HashMap<Word, ArrayList<Word>>> typeRef = new TypeReference<HashMap<Word, ArrayList<Word>>>() {
        };
        HashMap<Word, ArrayList<Word>> aux = mapper.readValue(file, typeRef);
        d.setDictionary(aux);
        System.out.println("?");
    } catch (JsonGenerationException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

/**
     * Searches for packages according to the attribute search query supplied to addQuery
     *
     * @return a list of packages that were returned by Bintray's search
     * @throws IOException
     * @throws BintrayCallException
     */
public List<Pkg> attributeSearch() throws IOException, BintrayCallException {
    ObjectMapper mapper = ObjectMapperHelper.get();
    StringWriter writer = new StringWriter();
    try {
        mapper.writeValue(writer, searchQuery);
    } catch (IOException e) {
        log.error("Error writing search query to json: ", e);
        throw e;
    }
    Map<String, String> headers = new HashMap<>();
    headers.put(HttpHeaders.CONTENT_TYPE, ContentType.APPLICATION_JSON.getMimeType());
    HttpResponse response = bintrayHandle.post("/search/attributes/" + owner.name() + "/" + name, headers, IOUtils.toInputStream(writer.toString()));
    List<PackageDetails> answer;
    answer = mapper.readValue(response.getEntity().getContent(), new TypeReference<List<PackageDetails>>() {
    });
    List<Pkg> packages = new ArrayList<>();
    for (PackageDetails pkgDetails : answer) {
        packages.add(new PackageImpl(pkgDetails));
    }
    searchQuery = null;
    return packages;
}

/**
	 * Uploads a file to the repository.
	 * 
	 * @param fileName
	 *            The name of the file to upload.
	 * @param file
	 *            The file to upload.
	 * @return upload response.
	 * @throws RestClientException .
	 */
public UploadResponse uploadInternal(final String fileName, final File file) throws RestClientException {
    validateFile(file);
    final String finalFileName = fileName == null ? file.getName() : fileName;
    final String uploadUrl = getFormattedUrl(versionedUploadControllerUrl, UPLAOD_INTERNAL_URL_FORMAT, finalFileName);
    final UploadResponse response = executor.postFile(uploadUrl, file, CloudifyConstants.UPLOAD_FILE_PARAM_NAME, new TypeReference<Response<UploadResponse>>() {
    });
    return response;
}

private Map<String, Object> getInfoMap(URL cloudControllerUrl) {
    if (infoCache.containsKey(cloudControllerUrl)) {
        return infoCache.get(cloudControllerUrl);
    }
    Map<String, Object> infoMap = new HashMap<String, Object>();
    @SuppressWarnings("unchecked") String s = restTemplate.getForObject(cloudControllerUrl + "/info", String.class);
    try {
        infoMap = objectMapper.readValue(s, new TypeReference<Map<String, Object>>() {
        });
    } catch (IOException e) {
        e.printStackTrace();
    }
    return infoMap;
}

@Override
public Object invoke(Object obj, Method method, Object[] arguments) throws Throwable {
    String mapperName = "features";
    String methodName = method.getName();
    Class returnType = method.getReturnType();
    Annotation[][] methodAnnotations = method.getParameterAnnotations();
    List<String> argNames = new ArrayList<String>();
    for (Annotation[] paramAnnotations : methodAnnotations) {
        for (Annotation paramAnnotation : paramAnnotations) {
            if (paramAnnotation instanceof RequestParam) {
                RequestParam requestParamAnnotation = (RequestParam) paramAnnotation;
                String argName = requestParamAnnotation.value();
                argNames.add(argName);
            }
        }
    }
    assert (argNames.size() == arguments.length);
    Map<String, String[]> parameters = new HashMap<String, String[]>();
    for (int i = 0; i < argNames.size(); i++) {
        String argName = argNames.get(i);
        Object value = arguments[i];
        List<String> valueStrings = new ArrayList<String>();
        Object[] valueArray = (Object[]) value;
        for (Object v : valueArray) {
            String vString = v.toString();
            valueStrings.add(vString);
        }
        parameters.put(argName, valueStrings.toArray(new String[valueStrings.size()]));
    }
    for (String url : urls) {
        CrawlClient client = new CrawlClient(url);
        String result = client.result(mapperName, methodName, parameters);
        TypeReference tr = new TypeReference<List>() {
        };
        JsonParser parser = jsonIzer.getParser(result);
    //                            jsonIzer.getMapper().readValue(
    //                                  result.toString(), 
    //                                  TypeFactory.collectionType(ArrayList.class, Object.class));
    //                            
    //                            
    //                            TypeFactory.fromCanonical("org.genedb.crawl.model.Feature");
    //                            
    //                            JavaType jt = TypeFactory.collectionType(ArrayList.class, returnType);
    //TypeFactory.
    //jsonIzer.getMapper().
    }
    // TODO Auto-generated method stub
    return null;
}

public synchronized <T> T getFromControlApps(String urlPrefix, TypeReference<?> typeRef) throws Exception {
    String result;
    try {
        String url = mkUrl(urlPrefix);
        result = restTemplate.getForObject(url, String.class);
        if (result == null)
            return null;
    } catch (Throwable e) {
        throw new Exception("Failed to communicate with controlapps. Is it up?");
    }
    try {
        T t = objMapper.readValue(result, typeRef);
        return t;
    } catch (Throwable e) {
        throw new RestClientException("Internal error parsing the result. Please try again later or restart controlapps.");
    }
}

/**
     * 获��功返回时的输出�数对象
     * 
     * @param json
     * @return
     */
protected OutParameter getSuccessOutParameter(String jsonString) {
    OutParameter outParameter = new OutParameter();
    try {
        ObjectMapper mapper = new ObjectMapper();
        Map<String, Object> params = mapper.readValue(jsonString, new TypeReference<HashMap<String, Object>>() {
        });
        String respCode = (String) params.get("RespCode");
        boolean success = Constants.RESP_CODE_SUCCESS.equals(respCode) ? true : false;
        outParameter.setSuccess(success);
        outParameter.setRespCode((String) params.get("RespCode"));
        outParameter.setRespDesc(URLDecoder.decode((String) params.get("RespDesc"), DEFAULT_CHARSET));
        outParameter.setTrxId((String) params.get("TrxId"));
        outParameter.setRetUrl((String) params.get("RetUrl"));
        outParameter.setBgRetUrl((String) params.get("BgRetUrl"));
        outParameter.setParams(params);
        return outParameter;
    } catch (IOException e) {
        logger.error(e.getMessage(), e);
        throw new RuntimeException("返回数�格�有误!");
    }
}

public static void main(String[] args) throws IOException {
    String inputPath = args[0];
    String profilesPath = args[1];
    String desiredLang = args[2];
    String outputPath = args[3];
    ObjectMapper jsonMapper = new ObjectMapper();
    BufferedReader reader = null;
    BufferedWriter writer = null;
    try {
        LanguageFilter langFilter = new LanguageFilter(profilesPath);
        reader = new BufferedReader(new InputStreamReader(new FileInputStream(inputPath), "UTF-8"));
        writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(outputPath), "UTF-8"));
        String line = null;
        Pattern tabPattern = Pattern.compile("\t");
        long total = 0;
        long passed = 0;
        while ((line = reader.readLine()) != null) {
            total++;
            String[] fields = tabPattern.split(line);
            // Skip if we have more tabs (work around this later)
            if (fields.length != 2)
                continue;
            Map<String, Object> jsonMap = jsonMapper.readValue(fields[1], new TypeReference<Map<String, Object>>() {
            });
            // !fields[6].toLowerCase().startsWith(desiredLang) && 
            if (!langFilter.isLanguage((String) jsonMap.get("text"), desiredLang))
                continue;
            // Write original line back to output
            writer.write(line);
            writer.write('\n');
            passed++;
            if (total % 1000 == 0) {
                System.out.printf("Processed %d lines\n", total);
            }
        }
        System.out.printf("Percentage that passed: %.2f%%\n", ((float) passed / (float) total) * 100.0f);
    } catch (LangDetectException e) {
        e.printStackTrace();
    } finally {
        if (writer != null) {
            try {
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (reader != null) {
            try {
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
   * @param value         json string
   * @param typeReference class type reference
   * @param <T>           type
   * @return deserialized  T object
   */
@SuppressWarnings("unchecked")
public static <T> T toObject(String value, final TypeReference<T> typeReference) throws IOException {
    try {
        return (T) jsonMapper.readValue(value, typeReference);
    } catch (JsonGenerationException e) {
        throw new SwiftJsonMarshallingException("Error generating response", e);
    } catch (JsonMappingException e) {
        throw new SwiftJsonMarshallingException("Error generating response", e);
    }
}

/**
   * @param value         json string
   * @param typeReference class type reference
   * @param <T>           type
   * @return deserialized  T object
   */
@SuppressWarnings("unchecked")
public static <T> T toObject(String value, final TypeReference<T> typeReference) throws IOException {
    try {
        return (T) jsonMapper.readValue(value, typeReference);
    } catch (JsonGenerationException e) {
        throw new SwiftJsonMarshallingException("Error generating response", e);
    } catch (JsonMappingException e) {
        throw new SwiftJsonMarshallingException("Error generating response", e);
    }
}

/**
   * @param value         json string
   * @param typeReference class type reference
   * @param <T>           type
   * @return deserialized  T object
   */
@SuppressWarnings("unchecked")
public static <T> T toObject(String value, final TypeReference<T> typeReference) throws IOException {
    try {
        return (T) jsonMapper.readValue(value, typeReference);
    } catch (JsonGenerationException e) {
        throw new SwiftJsonMarshallingException("Error generating response", e);
    } catch (JsonMappingException e) {
        throw new SwiftJsonMarshallingException("Error generating response", e);
    }
}

/**
   * @param value         json string
   * @param typeReference class type reference
   * @param <T>           type
   * @return deserialized  T object
   */
@SuppressWarnings("unchecked")
public static <T> T toObject(String value, final TypeReference<T> typeReference) throws IOException {
    try {
        return (T) jsonMapper.readValue(value, typeReference);
    } catch (JsonGenerationException e) {
        throw new SwiftJsonMarshallingException("Error generating response", e);
    } catch (JsonMappingException e) {
        throw new SwiftJsonMarshallingException("Error generating response", e);
    }
}

/**
   * @param value         json string
   * @param typeReference class type reference
   * @param <T>           type
   * @return deserialized  T object
   */
@SuppressWarnings("unchecked")
public static <T> T toObject(String value, final TypeReference<T> typeReference) throws IOException {
    try {
        return (T) jsonMapper.readValue(value, typeReference);
    } catch (JsonGenerationException e) {
        throw new SwiftJsonMarshallingException("Error generating response", e);
    } catch (JsonMappingException e) {
        throw new SwiftJsonMarshallingException("Error generating response", e);
    }
}

public static TopicCount parse(String consumerIdString, String jsonString) {
    try {
        Map<String, Integer> topicCountMap = mapper.readValue(jsonString, new TypeReference<Map<String, Integer>>() {
        });
        return new TopicCount(consumerIdString, topicCountMap);
    } catch (JsonParseException e) {
        throw new IllegalArgumentException("error parse consumer json string " + jsonString, e);
    } catch (JsonMappingException e) {
        throw new IllegalArgumentException("error parse consumer json string " + jsonString, e);
    } catch (IOException e) {
        throw new IllegalArgumentException("error parse consumer json string " + jsonString, e);
    }
}

public static TopicCount parse(String consumerIdString, String jsonString) {
    try {
        Map<String, Integer> topicCountMap = mapper.readValue(jsonString, new TypeReference<Map<String, Integer>>() {
        });
        return new TopicCount(consumerIdString, topicCountMap);
    } catch (JsonParseException e) {
        throw new IllegalArgumentException("error parse consumer json string " + jsonString, e);
    } catch (JsonMappingException e) {
        throw new IllegalArgumentException("error parse consumer json string " + jsonString, e);
    } catch (IOException e) {
        throw new IllegalArgumentException("error parse consumer json string " + jsonString, e);
    }
}

public void init() throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    if (cpaJsonFile != null && cpaJsonFile.exists()) {
        partnerAgreements = mapper.readValue(cpaJsonFile, new TypeReference<List<PartnerAgreement>>() {
        });
        LOG.info("Loaded " + partnerAgreements.size() + " partner agreement(s) into the CPA Repository");
    } else {
        LOG.warn("unable to load CPA Repository from " + cpaJsonFile);
    }
}

private void initInstances() {
    final Optional<File> instancesFile = Config.getInstancesFile();
    List<Instance> instances = Lists.newArrayList();
    if (instancesFile.isPresent()) {
        if (instancesFile.get().exists()) {
            try {
                instances = new ObjectMapper().readValue(instancesFile.get(), new TypeReference<List<Instance>>() {
                });
            } catch (IOException ioException) {
                ioException.printStackTrace();
            }
        }
    }
    this.instances = instances;
}

//TODO a bcp tester, liste vide, tout type de collection
//Si jamais pas de list mais un seul element (token == object), renvoyer une liste avec un elements
public <T> T nextObject(TypeReference<T> type) {
    if (parser == null)
        return null;
    try {
        if (parser.getCurrentToken() != null) {
            T result = parser.readValueAs(type);
            parser.nextToken();
            return result;
        }
    } catch (JsonProcessingException e) {
        if (log.isDebugEnabled())
            log.debug("Error parsing arguments of type " + type.toString(), e);
    } catch (IOException e) {
        if (log.isDebugEnabled())
            log.debug("Error parsing arguments of type " + type.toString(), e);
    }
    parser = null;
    return null;
}

@SuppressWarnings("unchecked")
public static List<Map<String, Object>> getDocuments(InputStream data) throws IOException {
    final Map<String, Object> rootNode = MAPPER.readValue(data, new TypeReference<Map<String, Object>>() {
    });
    final Object dataElements = rootNode.get(DOCUMENTS_ELEMENT);
    if (dataElements instanceof List) {
        return (List<Map<String, Object>>) dataElements;
    } else {
        throw new IllegalArgumentException("Array of documents are required.");
    }
}

@OperationMethod
public Blob run() throws IOException {
    validateCanManageDirectories(ctx);
    ObjectMapper mapper = new ObjectMapper();
    List<Map<String, Object>> entries = mapper.readValue(jsonEntries, new TypeReference<List<Map<String, Object>>>() {
    });
    List<String> ids = new ArrayList<String>();
    Directory directory = directoryService.getDirectory(directoryName);
    String idField = directory.getIdField();
    try (Session session = directoryService.open(directoryName)) {
        for (Map<String, Object> entry : entries) {
            if (entry.containsKey(idField)) {
                DocumentModel doc = session.getEntry((String) entry.get(idField));
                if (doc != null) {
                    doc.setProperties(directory.getSchema(), entry);
                    session.updateEntry(doc);
                    ids.add(doc.getId());
                }
            }
        }
    }
    StringWriter writer = new StringWriter();
    mapper.writeValue(writer, ids);
    return Blobs.createBlob(writer.toString(), "application/json");
}

private Collection<Job> parseJobs(HttpResponse response) throws ClientException {
    try (InputStream content = response.getContent()) {
        return mapper.readValue(content, new TypeReference<Collection<Job>>() {
        });
    } catch (JsonMappingException e) {
        throw new ClientException("Invalid response body", e);
    } catch (IOException e) {
        throw new ClientException(e);
    }
}

@Override
public void execute(ApplicationContext currentContext) throws CLIException {
    StringBuilder url = new StringBuilder();
    url.append("info/ProActiveResourceManager:name=RuntimeData?");
    QueryStringBuilder builder = new QueryStringBuilder();
    for (String attr : RUNTIME_DATA_ATTR) {
        builder.add("attr", attr);
    }
    url.append(builder.buildString());
    HttpGet request = new HttpGet(currentContext.getResourceUrl(url.toString()));
    HttpResponseWrapper response = execute(request, currentContext);
    if (statusCode(OK) == statusCode(response)) {
        List<MBeanInfoView> infoList = readValue(response, new TypeReference<List<MBeanInfoView>>() {
        }, currentContext);
        MBeanInfoView[] stats = infoList.toArray(new MBeanInfoView[infoList.size()]);
        resultStack(currentContext).push(stats);
        if (!currentContext.isSilent()) {
            writeLine(currentContext, "%s", StringUtility.mBeanInfoAsString(stats));
        }
    } else {
        handleError("An error occurred while retrieving stats:", response, currentContext);
    }
}

/**
   * @param value         json string
   * @param typeReference class type reference
   * @param <T>           type
   * @return deserialized  T object
   */
public static <T> T toObject(String value, final TypeReference<T> typeReference) throws IOException {
    try {
        return jsonMapper.readValue(value, typeReference);
    } catch (JsonGenerationException e) {
        throw new SwiftJsonMarshallingException("Error generating response", e);
    } catch (JsonMappingException e) {
        throw new SwiftJsonMarshallingException("Error generating response", e);
    }
}

@Override
public void execute(ApplicationContext currentContext) throws CLIException {
    StringBuilder url = new StringBuilder();
    url.append("info/ProActiveResourceManager:name=RuntimeData?");
    QueryStringBuilder builder = new QueryStringBuilder();
    for (String attr : RUNTIME_DATA_ATTR) {
        builder.add("attr", attr);
    }
    url.append(builder.buildString());
    HttpGet request = new HttpGet(currentContext.getResourceUrl(url.toString()));
    HttpResponseWrapper response = execute(request, currentContext);
    if (statusCode(OK) == statusCode(response)) {
        List<MBeanInfoView> infoList = readValue(response, new TypeReference<List<MBeanInfoView>>() {
        }, currentContext);
        MBeanInfoView[] stats = infoList.toArray(new MBeanInfoView[infoList.size()]);
        resultStack(currentContext).push(stats);
        if (!currentContext.isSilent()) {
            writeLine(currentContext, "%s", StringUtility.mBeanInfoAsString(stats));
        }
    } else {
        handleError("An error occurred while retrieving stats:", response, currentContext);
    }
}

@Test
@Ignore
public // TODO
void canIssue_GET_request() throws Exception {
    org.restlet.Response response = get("bundles/details/99");
    assertDefaults(response);
    Representation entity = response.getEntity();
    System.out.println(entity.getText());
    SkysailResponse<BundleDetails> skysailResponse = mapper.readValue(entity.getText(), new TypeReference<SkysailResponse<BundleDetails>>() {
    });
// assertThat(skysailResponse.getMessage(), skysailResponse.getSuccess(), is(true));
}

@Override
public MultiValueMap<String, String> read(Class<? extends MultiValueMap<String, ?>> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
    TypeReference<Map<String, ?>> mapType = new TypeReference<Map<String, ?>>() {
    };
    LinkedHashMap<String, ?> readValue = objectMapper.readValue(inputMessage.getBody(), mapType);
    LinkedMultiValueMap<String, String> result = new LinkedMultiValueMap<String, String>();
    for (Entry<String, ?> currentEntry : readValue.entrySet()) {
        result.add(currentEntry.getKey(), currentEntry.getValue().toString());
    }
    return result;
}

public static Map<String, String> getMapforJsonString(String mapJsonStr) {
    LOG.debug("Passed mapJsonStr ::" + mapJsonStr + " to parse");
    final Map<String, String> result;
    try {
        if (isEmptyJSON(mapJsonStr)) {
            result = Collections.emptyMap();
        } else {
            ObjectMapper mapper = new ObjectMapper();
            result = mapper.readValue(mapJsonStr, new TypeReference<HashMap<String, String>>() {
            });
        }
        return result;
    } catch (JsonParseException e) {
        LOG.error("JsonParseException:: Illegal json to parse into map :" + mapJsonStr + e.getMessage());
        throw new IllegalArgumentException("Illegal json to parse into map :" + mapJsonStr + e.getMessage(), e);
    } catch (JsonMappingException e) {
        LOG.error("JsonMappingException:: Illegal json to parse into map :" + mapJsonStr + e.getMessage());
        throw new IllegalArgumentException("Illegal json to parse into map :" + mapJsonStr + e.getMessage(), e);
    } catch (IOException e) {
        LOG.error("IOException while parsing json into map :" + mapJsonStr + e.getMessage());
        throw new IllegalArgumentException("IOException while parsing json into map :" + mapJsonStr + e.getMessage(), e);
    }
}

public static CitiesAndStations parseStationsAndCities(String theString) {
    ObjectMapper mapper = new ObjectMapper();
    try {
        Map<String, JsonNode> jsonNodes = mapper.readValue(theString, new TypeReference<HashMap<String, JsonNode>>() {
        });
        // GRRRRRRRRR WHY THE F DO THEY HAVE TO MIX OBJECTS IN A MAP????????
        Map<String, City> cityMap = mapper.readValue(jsonNodes.remove("cities"), new TypeReference<HashMap<String, City>>() {
        });
        Map<String, Station> stationMap = new HashMap<String, Station>();
        for (Map.Entry<String, JsonNode> entry : jsonNodes.entrySet()) {
            stationMap.put(entry.getKey(), mapper.readValue(entry.getValue(), Station.class));
        }
        return new CitiesAndStations(Collections.unmodifiableMap(stationMap), Collections.unmodifiableMap(cityMap));
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

/**
	 * Process single message type.
	 * @param message
	 * @throws IOException
	 * @throws JsonMappingException
	 * @throws JsonParseException
	 */
public void doProcess(String transactionId, String rawString) throws MessageException {
    try {
        ObjectMapper mapper = new ObjectMapper();
        Message message = mapper.readValue(rawString, new TypeReference<Message>() {
        });
        logger.debug("=======================[MESSAGES]=============================");
        logger.debug(message.toString());
        logger.debug("===========================================================");
    } catch (Exception e) {
        throw new MessageException("Error during processing message: " + e.getMessage());
    } finally {
    }
}

public Library createLibrary(final Library library) {
    // should not be this complicated, I suspect library API is returning wrong thing. See galaxy issue #802
    return createLibraryRequest(library).getEntity(Library.class);
//return readJson(createLibraryRequest(library).getEntity(String.class), new TypeReference<List<Library>>() {}).get(0);
}

public static Map<String, Object> convertJsonToMap(String json) {
    Map<String, Object> retMap = new HashMap<String, Object>();
    if (json != null) {
        try {
            retMap = mapper.readValue(json, new TypeReference<Map<String, Object>>() {
            });
        } catch (IOException e) {
            logger.warn("Error while reading Java Map from JSON response: " + json, e);
        }
    }
    return retMap;
}

public D loadConfigFromJson(Reader jsonReader) throws InvalidConfigException {
    D newConfig = null;
    try {
        ObjectMapper _jsonMapper = new ObjectMapper();
        Map<?, ?> jsonMap = _jsonMapper.readValue(jsonReader, new TypeReference<Map<?, ?>>() {
        });
        synchronized (_configBuilder) {
            fillBeanFromMap(_configBuilder, jsonMap);
        }
        newConfig = _configBuilder.build();
    } catch (Exception e) {
        throw new InvalidConfigException("Load from JSON failed", e);
    }
    return newConfig;
}

/**
   * Get JSON value
   *
   * @param <T> JSON type
   * @param conf Configuration
   * @param typeReference TypeReference for JSON type
   * @return JSON value
   */
public <T> T get(Configuration conf, TypeReference<T> typeReference) {
    String jsonStr = getRaw(conf);
    T value = null;
    if (jsonStr != null) {
        ObjectMapper mapper = new ObjectMapper();
        try {
            value = mapper.<T>readValue(jsonStr, typeReference);
        } catch (IOException e) {
            throw new IllegalStateException("Failed to read json from key " + getKey() + " with class " + typeReference);
        }
    }
    return value;
}

/**
   * Get JSON value
   *
   * @param <T> JSON type
   * @param conf Configuration
   * @param typeReference TypeReference for JSON type
   * @return JSON value
   */
public <T> T get(Configuration conf, TypeReference<T> typeReference) {
    String jsonStr = getRaw(conf);
    T value = null;
    if (jsonStr != null) {
        ObjectMapper mapper = new ObjectMapper();
        try {
            value = mapper.<T>readValue(jsonStr, typeReference);
        } catch (IOException e) {
            throw new IllegalStateException("Failed to read json from key " + getKey() + " with class " + typeReference);
        }
    }
    return value;
}

private Set<ReconciliationStanbolSite> retrieveReconciliations(String uri) throws IOException, JsonParseException, JsonMappingException {
    HttpEntity entity = HttpUtils.get(uri, JSON);
    ObjectMapper mapper = new ObjectMapper();
    Set<String> sites = mapper.readValue(entity.getContent(), new TypeReference<Set<String>>() {
    });
    Set<ReconciliationStanbolSite> reconciliations = new HashSet<ReconciliationStanbolSite>();
    for (String site : sites) {
        ReconciliationStanbolSite reconciliation = this.buildReconciliation(site);
        if (reconciliation != null) {
            reconciliations.add(reconciliation);
        } else {
            log.error("'" + site + "' can't be correctly retrieved, so not going to be registered");
        }
    }
    log.info("Retrieved " + reconciliations.size() + " suitable sites");
    return reconciliations;
}

static PruneCauses.BriefAndDetailedError extractPruneCause(LensException e) throws ClassNotFoundException {
    try {
        ErrorCollection errorCollection = new ErrorCollectionFactory().createErrorCollection();
        final LensError lensError = errorCollection.getLensError(e.getErrorCode());
        return new ObjectMapper().readValue(e.getFormattedErrorMsg(lensError).substring(e.getFormattedErrorMsg(lensError).indexOf("{"), e.getFormattedErrorMsg(lensError).length()), new TypeReference<PruneCauses.BriefAndDetailedError>() {
        });
    } catch (IOException e1) {
        throw new RuntimeException("!!!");
    }
}

@Override
public void reduce(Text key, Iterator<Text> values, OutputCollector<Text, Text> output, Reporter reporter) throws IOException {
    FSDataOutputStream out = null;
    try {
        int size = 0;
        FileSystem fs = FileSystem.get(conf);
        double averageIORate = 0;
        List<Float> list = new ArrayList<Float>();
        String output_dir = conf.get(OUTPUT_DIR_KEY);
        Path result_file = new Path(output_dir, "results");
        if (fs.exists(result_file)) {
            fs.delete(result_file);
        }
        out = fs.create(result_file, true);
        long nmaps = conf.getLong(NUMBER_OF_MAPS_KEY, NMAPS);
        long nthreads = conf.getLong(NUMBER_OF_THREADS_KEY, NTHREADS);
        out.writeChars("-----------------------------\n");
        out.writeChars("Number of mapper :\t\t\t" + nmaps + "\n");
        out.writeChars("Number of threads :\t\t\t" + nthreads + "\n");
        float min = Float.MAX_VALUE;
        float max = Float.MIN_VALUE;
        Class<?> clazz = conf.getClass(THREAD_CLASS_KEY, null);
        if (clazz == null) {
            throw new IOException("Class " + conf.get(THREAD_CLASS_KEY) + " not found");
        }
        GenThread t = (GenThread) ReflectionUtils.newInstance(clazz, conf);
        t.reset();
        long total_files = 0;
        long total_processed_size = 0;
        long total_num_errors = 0;
        String total_error = "";
        TypeReference<Map<String, String>> type = new TypeReference<Map<String, String>>() {
        };
        while (values.hasNext()) {
            Map<String, String> stat = mapper.readValue(values.next().toString(), type);
            size++;
            total_files += Long.parseLong(stat.get("files"));
            total_processed_size += Long.parseLong(stat.get("size"));
            total_num_errors += Long.parseLong(stat.get("nerrors"));
            total_error += stat.get("errors");
            double ioRate = Double.parseDouble(stat.get("rate"));
            if (ioRate > max)
                max = (float) ioRate;
            if (ioRate < min)
                min = (float) ioRate;
            list.add((float) ioRate);
            averageIORate += ioRate;
            t.analyze(stat);
        }
        out.writeChars("Number of files processed:\t\t" + total_files + "\n");
        out.writeChars("Number of size processed:\t\t" + total_processed_size + "\n");
        out.writeChars("Min IO Rate(MB/sec): \t\t\t" + min + "\n");
        out.writeChars("Max IO Rate(MB/sec): \t\t\t" + max + "\n");
        averageIORate /= size;
        float temp = (float) 0.0;
        for (int i = 0; i < list.size(); i++) {
            temp += Math.pow(list.get(i) - averageIORate, 2);
        }
        out.writeChars("Average(MB/sec): \t\t\t" + averageIORate + "\n");
        float dev = (float) Math.sqrt(temp / size);
        out.writeChars("Std. dev: \t\t\t\t" + dev + "\n");
        out.writeChars("Total number of errors:\t\t\t" + total_num_errors + "\n");
        out.writeChars(total_error);
        t.output(out);
    } catch (IOException e) {
        LOG.error("Error:", e);
        throw e;
    } finally {
        out.close();
    }
}

protected void setup(Mapper.Context context) throws IOException, InterruptedException {
    delimiter = context.getConfiguration().get(HIHOConf.INPUT_OUTPUT_DELIMITER);
    logger.debug("delimiter is: " + delimiter);
    String columnInfoJsonString = context.getConfiguration().get(HIHOConf.COLUMN_INFO);
    logger.debug("columnInfoJsonString is: " + columnInfoJsonString);
    ObjectMapper mapper = new ObjectMapper();
    tableInfo = mapper.readValue(columnInfoJsonString, new TypeReference<ArrayList<ColumnInfo>>() {
    });
}

private Map<String, Object> readParameters() {
    if (parameters == null || parameters.isEmpty()) {
        return new HashMap<>();
    }
    ObjectMapper mapper = new ObjectMapper();
    ByteArrayInputStream bis = new ByteArrayInputStream(parameters.getBytes());
    try {
        Map<String, Object> params = mapper.readValue(bis, new TypeReference<Map<String, Object>>() {
        });
        bis.close();
        return params;
    } catch (IOException e) {
        throw new RuntimeException("Error reading job parameters from string field.", e);
    }
}