Java Examples for com.fasterxml.jackson.core.type.TypeReference

public static void main(final String... args) throws IOException {
    // Register the AutoMatterModule to handle deserialization
    ObjectMapper mapper = new ObjectMapper().registerModule(new AutoMatterModule());
    ComplexGenericFoobar<String, Integer, List<Integer>, ComparableList<Integer>> foobar = new ComplexGenericFoobarBuilder<String, Integer, List<Integer>, ComparableList<Integer>>().foo("foo").bar(17).baz(asList(13, 4711)).quux(ComparableList.of(1, 2, 3)).name("generics").build();
    String json = mapper.writeValueAsString(foobar);
    out.println("json: " + json);
    ComplexGenericFoobar<String, Integer, List<Integer>, ComparableList<Integer>> parsed = mapper.readValue(json, new TypeReference<ComplexGenericFoobar<String, Integer, List<Integer>, ComparableList<Integer>>>() {
    });
    out.println("parsed: " + parsed);
    out.println("equals: " + foobar.equals(parsed));
}

public static Map<String, Object> convertToMap(String json) {
    ObjectMapper mapper = new ObjectMapper();
    Map<String, Object> map = null;
    // convert JSON string to Map
    try {
        map = mapper.readValue(json, new TypeReference<LinkedHashMap<String, Object>>() {
        });
    } catch (IOException e) {
        e.printStackTrace();
    }
    return map;
}

@Override
public Map<String, Object> getJsonMap(String json) {
    HashMap<String, Object> result = null;
    TypeReference<HashMap<String, Object>> typeRef = new TypeReference<HashMap<String, Object>>() {
    };
    try {
        result = JSON.getDefaultObjectMapper().readValue(json, typeRef);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return result;
}

public static List<RoleRepresentation> fromJson(String roleJson) {
    List<RoleRepresentation> roles = null;
    try {
        ObjectMapper mapper = new ObjectMapper();
        roles = mapper.readValue(roleJson, new TypeReference<List<RoleRepresentation>>() {
        });
    } catch (JsonMappingException e) {
        throw new IllegalArgumentException("Error mapping json for " + roleJson, e);
    } catch (JsonParseException e) {
        throw new IllegalArgumentException("Error parsing json for " + roleJson, e);
    } catch (IOException e) {
        throw new IllegalArgumentException("Error reading json for " + roleJson, e);
    }
    return roles;
}

@Provides
@Singleton
public Map<Integer, DiskConfiguration> diskConfigurations(ObjectMapper objectMapper, @Named("blobkeeper.disk.configuration") String value) {
    try {
        List<DiskConfiguration> config = objectMapper.readValue(value, new TypeReference<List<DiskConfiguration>>() {
        });
        return config.stream().collect(toImmutableMap(DiskConfiguration::getDisk, identity()));
    } catch (IOException e) {
        log.error("Can't read disk configuration");
        throw new IllegalArgumentException(e);
    }
}

public static void main(String[] args) {
    try {
        TestHttpClient productClient = new TestHttpClient(SERVER_RESOURCE).init();
        // Add products
        String productJson = Resources.toString(getResource(DEFAULT_PATH), UTF_8);
        TypeReference<List<ProductDto>> listOfProductRequests = new TypeReference<List<ProductDto>>() {
        };
        List<ProductDto> products = OBJECT_MAPPER.readValue(productJson, listOfProductRequests);
        for (ProductDto product : products) {
            productClient.post(OBJECT_MAPPER.writeValueAsString(product));
        }
        System.out.println("Imported [" + products.size() + "] products...");
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public void writeMetrics(String msg) throws Exception {
    log.debug(msg);
    List<EmitMetricsAnalyzer.MetricInfo> rawInfos = Resources.jsonMapper.readValue(msg, new TypeReference<List<EmitMetricsAnalyzer.MetricInfo>>() {
    });
    List<Event> points = EmitMetricsAnalyzer.fetchReceivedInfos(rawInfos);
    if (log.isDebugEnabled()) {
        log.debug(Resources.jsonMapper.writeValueAsString(points));
    }
    saveMetrics(points);
    if (rawInfos.size() > 0) {
        log.debug("writeMetrics host: [%s]", rawInfos.get(0).host);
    }
}

@Override
protected Void execute0(PushImageCmd command, ResultCallback<PushResponseItem> resultCallback) {
    WebTarget webResource = getBaseResource().path("/images/" + name(command) + "/push").queryParam("tag", command.getTag());
    final String registryAuth = registryAuth(command.getAuthConfig());
    LOGGER.trace("POST: {}", webResource);
    InvocationBuilder builder = webResource.request().header("X-Registry-Auth", registryAuth).accept(MediaType.APPLICATION_JSON);
    builder.post(null, new TypeReference<PushResponseItem>() {
    }, resultCallback);
    return null;
}

@Test
public void read_from_json() throws Exception {
    ObjectMapper om = new ObjectMapper();
    TypeReference<List<DocumentOperationResult>> tr = new TypeReference<List<DocumentOperationResult>>() {
    };
    List<DocumentOperationResult> result;
    InputStream resourceAsStream = null;
    try {
        resourceAsStream = getClass().getResourceAsStream("document_operation_response.json");
        result = om.readValue(resourceAsStream, tr);
    } finally {
        IOUtils.closeQuietly(resourceAsStream);
    }
    assertEquals(3, result.size());
    assertTrue(result.get(0).isErroneous());
    assertEquals("0", result.get(0).getId());
    assertEquals("conflict", result.get(0).getError());
    assertEquals("Document update conflict.", result.get(0).getReason());
    assertEquals("1", result.get(1).getId());
    assertEquals("2-1579510027", result.get(1).getRevision());
    assertEquals("2", result.get(2).getId());
    assertEquals("2-3978456339", result.get(2).getRevision());
}

public void testWithBuilder() throws Exception {
    final ObjectMapper mapper = new ObjectMapper();
    final String json = aposToQuotes("{ 'data': [ { 'x': 'x', 'y': 'y' } ] }");
    final MyGenericPOJO<MyPOJO> deserialized = mapper.readValue(json, new TypeReference<MyGenericPOJO<MyPOJO>>() {
    });
    assertEquals(1, deserialized.data.size());
    Object ob = deserialized.data.get(0);
    assertNotNull(ob);
    assertEquals(MyPOJO.class, ob.getClass());
}

@Override
public Payload deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
    Map<String, JsonNode> tree = p.getCodec().readValue(p, new TypeReference<Map<String, JsonNode>>() {
    });
    if (tree == null) {
        throw new JWTDecodeException("Parsing the Payload's JSON resulted on a Null map");
    }
    String issuer = getString(tree, PublicClaims.ISSUER);
    String subject = getString(tree, PublicClaims.SUBJECT);
    List<String> audience = getStringOrArray(tree, PublicClaims.AUDIENCE);
    Date expiresAt = getDateFromSeconds(tree, PublicClaims.EXPIRES_AT);
    Date notBefore = getDateFromSeconds(tree, PublicClaims.NOT_BEFORE);
    Date issuedAt = getDateFromSeconds(tree, PublicClaims.ISSUED_AT);
    String jwtId = getString(tree, PublicClaims.JWT_ID);
    return new PayloadImpl(issuer, subject, audience, expiresAt, notBefore, issuedAt, jwtId, tree);
}

@Override
public void initialize() {
    isInitialized = true;
    super.initialize();
    String columns = conf.getProperty("sortColumns");
    String ascending = conf.getProperty("ascending");
    String arithm = conf.getProperty("arithmetic");
    ObjectMapper mapper = new ObjectMapper();
    try {
        sortColumns = mapper.readValue(columns, new TypeReference<List<Column>>() {
        });
        isAscending = mapper.readValue(ascending, new TypeReference<List<Boolean>>() {
        });
        arithmetic = mapper.readValue(arithm, new TypeReference<List<Boolean>>() {
        });
    } catch (IOException e) {
        e.printStackTrace();
    }
    output = conf.getProperty("keysName");
}

public static <T extends AbstractConfig> T fromJSON(String json, Class<? extends AbstractConfig> configTypeClass) throws Exception {
    if (configTypeClass.getName().equals(DashboardConfig.class.getName())) {
        TypeReference<DashboardConfig> typeRef = new TypeReference<DashboardConfig>() {
        };
        T value = OBJECT_MAPPER.readValue(json, typeRef);
        return value;
    } else if (configTypeClass.getName().equals(CollectionSchema.class.getName())) {
        TypeReference<CollectionSchema> typeRef = new TypeReference<CollectionSchema>() {
        };
        T value = OBJECT_MAPPER.readValue(json, typeRef);
        return value;
    } else if (configTypeClass.getName().equals(CollectionConfig.class.getName())) {
        TypeReference<CollectionConfig> typeRef = new TypeReference<CollectionConfig>() {
        };
        T value = OBJECT_MAPPER.readValue(json, typeRef);
        return value;
    }
    return null;
}

@Test
public void testParamsWithDot() {
    String param = this.request("dot/with.dot").jsonGet().resource(new TypeReference<String>() {
    });
    Assertions.assertThat(param).isNotNull();
    Assertions.assertThat(param).isEqualTo("with");
    param = this.request("dot/with.dot.json").jsonGet().resource(String.class);
    Assertions.assertThat(param).isNotNull();
    Assertions.assertThat(param).isEqualTo("with.dot");
    param = this.request("dot/with.dot.xml").xmlGet().getBody();
    Assertions.assertThat(param).isNotNull();
    Assertions.assertThat(param).contains("<String>with.dot</String>");
}

public List<CallbackDescriptor> readConfig(String filename) {
    try {
        InputStream stream = getClass().getResourceAsStream(filename);
        return mapper.readValue(stream, new TypeReference<List<CallbackDescriptor>>() {
        });
    } catch (Exception ioe) {
        logger.error("problem reading file '{}' from jar", filename);
        ioe.printStackTrace();
        return Collections.emptyList();
    }
}

@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>>() {
    });
}

@Override
public List<Violation> parse(String output) {
    List<Violation> result = new ArrayList<>();
    try {
        List<FileViolations> fileViolations = objectMapper.readValue(output, new TypeReference<List<FileViolations>>() {
        });
        for (FileViolations violation : fileViolations) {
            for (Message message : violation.getMessages()) {
                result.add(new Violation(violation.getFilePath(), message.getLine(), message.getMessage(), mapSeverity(message.getSeverity())));
            }
        }
    } catch (IOException e) {
        throw new ESLintException("Error when converting from json format", e);
    }
    return result;
}

@Test
public void testRegexFilter() throws Exception {
    String desc = "{\n" + "  \"type\":\"regex\",\n" + "  \"regex\":\"abcd\"\n" + "}";
    ObjectMapper jsonMapper = injector.getInstance(ObjectMapper.class);
    Filter filter = jsonMapper.readValue(desc, new TypeReference<Filter>() {
    });
    assertTrue(filter.doFilter(StringMessage.from(null, "abcdefg")));
    assertFalse(filter.doFilter(StringMessage.from(null, "zcb")));
    assertTrue(filter.doFilter(StringMessage.from("routingKey", "abcdefg")));
    assertFalse(filter.doFilter(StringMessage.from("routingKey", "zcb")));
}

@Override
public WebhookInfo deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<WebhookInfo> result = OBJECT_MAPPER.readValue(answer, new TypeReference<ApiResponse<WebhookInfo>>() {
        });
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error getting webhook info", result);
        }
    } catch (IOException e2) {
        throw new TelegramApiRequestException("Unable to deserialize response", e2);
    }
}

@Override
public WebhookInfo deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<WebhookInfo> result = OBJECT_MAPPER.readValue(answer, new TypeReference<ApiResponse<WebhookInfo>>() {
        });
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error getting webhook info", result);
        }
    } catch (IOException e2) {
        throw new TelegramApiRequestException("Unable to deserialize response", e2);
    }
}

@Test
public void testSserializeUser() throws Exception {
    User user = new User(1L, "Foo Bar", "foo", "foo", "hash");
    String expected = MAPPER.writeValueAsString(MAPPER.readValue(fixture("fixtures/user-nopassword.json"), new TypeReference<LinkedHashMap<String, Object>>() {
    }));
    assertEquals(expected, MAPPER.writeValueAsString(user));
}

@Test
public void testUnmarshal() throws IOException {
    // Read in the JSON from the example resources
    InputStream is = UserOrdersJSONTest.class.getResourceAsStream("/trade/example-userorders.json");
    // Use Jackson to parse it
    ObjectMapper mapper = new ObjectMapper();
    MercadoBitcoinBaseTradeApiResult<MercadoBitcoinUserOrders> apiResult = mapper.readValue(is, new TypeReference<MercadoBitcoinBaseTradeApiResult<MercadoBitcoinUserOrders>>() {
    });
    MercadoBitcoinUserOrders userOrders = apiResult.getTheReturn();
    // Verify that the example data was unmarshalled correctly
    assertThat(userOrders.get("1212").getStatus()).isEqualTo("completed");
    assertThat(userOrders.get("1212").getCreated()).isEqualTo(1378929161L);
    assertThat(userOrders.get("1212").getPrice()).isEqualTo(new BigDecimal("6.00000"));
    assertThat(userOrders.get("1212").getVolume()).isEqualTo(new BigDecimal("165.47309607"));
    assertThat(userOrders.get("1212").getPair()).isEqualTo("ltc_brl");
    assertThat(userOrders.get("1212").getType()).isEqualTo("sell");
    assertThat(userOrders.get("1212").getOperations().get("442").getVolume()).isEqualTo(new BigDecimal("30.00000000"));
    assertThat(userOrders.get("1212").getOperations().get("442").getPrice()).isEqualTo(new BigDecimal("6.00000"));
    assertThat(userOrders.get("1212").getOperations().get("442").getRate()).isEqualTo(new BigDecimal("0.70"));
    assertThat(userOrders.get("1212").getOperations().get("442").getCreated()).isEqualTo(1378929161L);
}

@Test
public void testRoundTripOnClassUsingCustomSerializer() throws Exception {
    ObjectMapper om = new ObjectMapper();
    // Note: round-tripping floating point numbers through JSON is dangerous.  These values seem to work, though.
    DOSensorData dosd = new DOSensorData(6.00, 99.9, "test_device", Time.now());
    String json = om.writeValueAsString(dosd);
    DOSensorData dosd2 = om.readValue(json, new TypeReference<DOSensorData>() {
    });
    assertEquals("Original and serialized/deserialized objects match.", dosd, dosd2);
}

@SuppressWarnings("unchecked")
@Override
public List<Tag> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    ObjectMapper mapper = BeanResolver.getInstance().resolve(ObjectMapper.class);
    jp.setCodec(mapper);
    if (jp.hasCurrentToken()) {
        JsonNode dataNode = (JsonNode) jp.readValueAs(JsonNode.class).get("data");
        return (List<Tag>) mapper.reader(new TypeReference<List<Tag>>() {
        }).readValue(dataNode);
    }
    return null;
}

@SuppressWarnings("unchecked")
@Override
public List<PersonActivity> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    ObjectMapper mapper = BeanResolver.getInstance().resolve(ObjectMapper.class);
    jp.setCodec(mapper);
    if (jp.hasCurrentToken()) {
        JsonNode dataNode = (JsonNode) jp.readValueAs(JsonNode.class).get("values");
        return (List<PersonActivity>) mapper.reader(new TypeReference<List<PersonActivity>>() {
        }).readValue(dataNode);
    }
    return null;
}

@Override
public SimilarPlacesResponse deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    ObjectMapper mapper = BeanResolver.getInstance().resolve(ObjectMapper.class);
    jp.setCodec(mapper);
    JsonNode node = jp.readValueAs(JsonNode.class);
    JsonNode resultNode = node.get("result");
    String token = resultNode.get("token").textValue();
    JsonNode placesNode = resultNode.get("places");
    @SuppressWarnings("unchecked") List<Place> places = (List<Place>) mapper.reader(new TypeReference<List<Place>>() {
    }).readValue(placesNode);
    return new SimilarPlacesResponse(places, token);
}

@Deprecated
public <E> E deSerializeList(String jsonString, TypeReference<E> type) {
    ObjectMapper mapper = new ObjectMapper();
    mapper.setSerializationInclusion(Include.NON_NULL);
    try {
        if (jsonString != null) {
            E docList = mapper.readValue(jsonString, type);
            return docList;
        }
    } catch (IOException e) {
        logger.error("JSON deserialization exception", e);
    }
    return null;
}

/**
     * @see com.fasterxml.jackson.databind.JsonDeserializer#deserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext)
     */
@Override
public HeaderMap deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    HeaderMap map = new HeaderMap();
    List<Entry<String, String>> entries = p.readValueAs(new TypeReference<List<Entry<String, String>>>() {
    });
    for (Entry<String, String> entry : entries) {
        String key = entry.getKey();
        String val = entry.getValue();
        map.add(key, val);
    }
    return map;
}

/**
     * Test if all the machinery is correct.
     *
     */
@Test
public void testDeserializeConcrete() throws RestException {
    List<? extends Tuple_if> l = BaseAriAction.deserializeJson(STR_TUPLE, new TypeReference<List<Tuple_impl>>() {
    });
    List<Tuple_if> x2 = (List<Tuple_if>) l;
    assertEquals("Size", 2, l.size());
    assertEquals("El 1 A", "x1", l.get(0).getA());
    assertEquals("El 2 B", "y2", l.get(1).getB());
}

/**
     * Create an Email Verification Ticket. A token with scope create:user_tickets is needed.
     * See https://auth0.com/docs/api/management/v2#!/Tickets/post_email_verification
     *
     * @param emailVerificationTicket the email verification ticket data to set.
     * @return a Request to execute.
     */
public Request<EmailVerificationTicket> requestEmailVerification(EmailVerificationTicket emailVerificationTicket) {
    Asserts.assertNotNull(emailVerificationTicket, "email verification ticket");
    String url = baseUrl.newBuilder().addPathSegments("api/v2/tickets/email-verification").build().toString();
    CustomRequest<EmailVerificationTicket> request = new CustomRequest<>(client, url, "POST", new TypeReference<EmailVerificationTicket>() {
    });
    request.addHeader("Authorization", "Bearer " + apiToken);
    request.setBody(emailVerificationTicket);
    return request;
}

public List<Book> loadSourceData(String fileName) {
    final String fullFileName = "jsonData/source/" + fileName;
    try {
        return mapper.readValue(ClassLoader.getSystemResource(fullFileName), new TypeReference<List<Book>>() {
        });
    } catch (Exception e) {
        final String errorMessage = String.format("Exception while loading file [%s] as a list of Book", fullFileName);
        throw new IllegalStateException(errorMessage, e);
    }
}

@Override
public boolean initIfNotExist() {
    boolean result = false;
    log.info("Persisting locations in Elasticsearch");
    ClassPathResource json = new ClassPathResource(JSON);
    if (json.exists() && json.isReadable()) {
        try {
            List<Location> locations = objectMapper.readValue(json.getInputStream(), new TypeReference<List<Location>>() {
            });
            log.info(String.format("Persisting %d locations", locations.size()));
            searchIndexingService.indexLocations(locations);
            result = true;
        } catch (IOException e) {
            log.error(e.getMessage(), e);
        }
    } else {
        log.warn(String.format("Could not access '%s'", JSON));
    }
    return result;
}

public static void jsonToMap1() throws IOException {
    System.out.println("===================================================== jsonToMap1 111");
    String json = "{\"string\" : \"aaa\",\"date\" : 1450245761324,\"html\" : \"aaa<>\\\"'&\\u4E2D\\u6587111\"}";
    ObjectMapper mapper = new ObjectMapper();
    Map<String, Object> map;
    map = mapper.readValue(json, new TypeReference<Map<String, Object>>() {
    });
    System.out.println(map);
    System.out.println(map.get("date").getClass());
}

public void loadDefaultUsers() {
    if (!defaultUserFixtures.exists() || !defaultUserFixtures.isReadable()) {
        LOG.warn("Fixtures file at {} does not exists or is not accessible. Skipping creation of default users.", defaultUserFixtures.getPath());
        return;
    }
    try {
        List<UserEntity> users = objectMapper.readValue(defaultUserFixtures.getInputStream(), new TypeReference<List<UserEntity>>() {
        });
        users.stream().forEach(this::createUser);
        LOG.info("Finished creating or updating {} users without errors.", users.size());
    } catch (IOException e) {
        LOG.error("IO Exception occured while parsing fixtures file from classpath location {}", defaultUserFixtures.getPath(), e);
        throw new IllegalStateException(e);
    }
}

@SuppressWarnings("unchecked")
@Test
public void testNthParserSpecCompliance() throws Exception {
    ObjectMapper objectMapper = new ObjectMapper();
    TypeReference<List<Object>> typeRef = new TypeReference<List<Object>>() {
    };
    List<Object> list = objectMapper.readValue(getClass().getResource("/An+B.json"), typeRef);
    String args = null;
    Tokenizer tokenizer = null;
    int n = 0;
    for (Object obj : list) {
        if (n % 2 == 0) {
            args = (String) obj;
            tokenizer = new Tokenizer(args + ")");
        } else {
            if (obj == null) {
                try {
                    NthParser.parse(tokenizer);
                    fail("Expected error for nth argument " + args + " at index " + n);
                } catch (ParserException e) {
                }
            } else {
                List<Integer> expected = (List<Integer>) obj;
                Pair<Integer, Integer> nth = NthParser.parse(tokenizer);
                assertEquals("Value mismatch for A: " + args, expected.get(0), nth.first);
                assertEquals("Value mismatch for B: " + args, expected.get(1), nth.second);
            }
        }
        ++n;
    }
}

@Override
public Chapter deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    JsonNode node = jp.getCodec().readTree(jp);
    String _id = null;
    JsonNode _idNode = node.get("_id");
    if (_idNode != null && !(_idNode instanceof NullNode)) {
        _id = _idNode.get("$oid").asText();
    }
    Integer number = null;
    JsonNode numberNode = node.get("number");
    if (numberNode != null && !(numberNode instanceof NullNode)) {
        number = numberNode.asInt();
    }
    Date created_at = null;
    JsonNode created_atNode = node.get("created_at");
    if (created_atNode != null && !(created_atNode instanceof NullNode)) {
        try {
            created_at = Dates.sdf.parse(created_atNode.asText());
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
    Chapter chapter = new Chapter(_id, number, created_at, null);
    JsonNode pagesNode = node.get("pages");
    if (pagesNode != null && !(pagesNode instanceof NullNode)) {
        chapter.pages = App.getInstance().mMapper.readValue(pagesNode.toString(), new TypeReference<Collection<Page>>() {
        });
        if (chapter.pages != null) {
            Iterator<Page> it = chapter.pages.iterator();
            while (it.hasNext()) {
                it.next().chapter = chapter;
            }
        }
    }
    return chapter;
}

@Test
public void load() {
    try {
        String path = "/Users/swsong/TEST_HOME/taobao-sample.json";
        File f = new File(path);
        JsonFactory jsonFactory = new JsonFactory();
        ObjectMapper mapper = new ObjectMapper(jsonFactory);
        TypeReference<List<HashMap<String, Object>>> typeRef = new TypeReference<List<HashMap<String, Object>>>() {
        };
        Object docs = mapper.readValue(f, typeRef);
        //			HashMap<String, Object> map = (HashMap<String, Object>) docs;
        List<HashMap<String, Object>> items = (List<HashMap<String, Object>>) docs;
        //System.out.println(items.getClass().getCanonicalName());
        for (HashMap<String, Object> o : items) {
            System.out.println(o.get("nid"));
            System.out.println(o.get("category"));
            System.out.println(o.get("title"));
            System.out.println(o.get("pic_url"));
            System.out.println(o.get("detail_url"));
            System.out.println(o.get("view_price"));
            System.out.println(o.get("nick"));
            System.out.println("--------------");
        }
    } catch (IOException ex) {
        ex.printStackTrace();
    }
}

@Override
public ClusterConfig getConfig() throws SyncException {
    if (!config.containsKey("nodes") || !config.containsKey("thisNodeId"))
        throw new SyncException("Configuration properties nodes or " + "thisNode not set");
    String keyStorePath = config.get("keyStorePath");
    String keyStorePassword = config.get("keyStorePassword");
    AuthScheme authScheme = AuthScheme.NO_AUTH;
    try {
        authScheme = AuthScheme.valueOf(config.get("authScheme"));
    } catch (Exception e) {
    }
    Short thisNodeId;
    try {
        thisNodeId = Short.parseShort(config.get("thisNodeId"));
    } catch (NumberFormatException e) {
        throw new SyncException("Failed to parse thisNode " + "node ID: " + config.get("thisNodeId"), e);
    }
    try {
        ObjectMapper mapper = new ObjectMapper();
        List<Node> nodes = mapper.readValue(config.get("nodes"), new TypeReference<List<Node>>() {
        });
        return new ClusterConfig(nodes, thisNodeId, authScheme, keyStorePath, keyStorePassword);
    } catch (Exception e) {
        e.printStackTrace();
        throw new SyncException("Could not update " + "configuration", e);
    }
}

@Override
public ClusterConfig getConfig() throws SyncException {
    if (!config.containsKey("nodes") || !config.containsKey("thisNode"))
        throw new SyncException("Configuration properties nodes or " + "thisNode not set");
    String keyStorePath = config.get("keyStorePath");
    String keyStorePassword = config.get("keyStorePassword");
    AuthScheme authScheme = AuthScheme.NO_AUTH;
    try {
        authScheme = AuthScheme.valueOf(config.get("authScheme"));
    } catch (Exception e) {
    }
    Short thisNodeId;
    try {
        thisNodeId = Short.parseShort(config.get("thisNode"));
    } catch (NumberFormatException e) {
        throw new SyncException("Failed to parse thisNode " + "node ID: " + config.get("thisNode"), e);
    }
    try {
        ObjectMapper mapper = new ObjectMapper();
        List<Node> nodes = mapper.readValue(config.get("nodes"), new TypeReference<List<Node>>() {
        });
        return new ClusterConfig(nodes, thisNodeId, authScheme, keyStorePath, keyStorePassword);
    } catch (Exception e) {
        throw new SyncException("Could not update " + "configuration", e);
    }
}

@Override
public ClusterConfig getConfig() throws SyncException {
    if (!config.containsKey("nodes") || !config.containsKey("thisNode"))
        throw new SyncException("Configuration properties nodes or " + "thisNode not set");
    String keyStorePath = config.get("keyStorePath");
    String keyStorePassword = config.get("keyStorePassword");
    AuthScheme authScheme = AuthScheme.NO_AUTH;
    try {
        authScheme = AuthScheme.valueOf(config.get("authScheme"));
    } catch (Exception e) {
    }
    Short thisNodeId;
    try {
        thisNodeId = Short.parseShort(config.get("thisNode"));
    } catch (NumberFormatException e) {
        throw new SyncException("Failed to parse thisNode " + "node ID: " + config.get("thisNode"), e);
    }
    try {
        ObjectMapper mapper = new ObjectMapper();
        List<Node> nodes = mapper.readValue(config.get("nodes"), new TypeReference<List<Node>>() {
        });
        return new ClusterConfig(nodes, thisNodeId, authScheme, keyStorePath, keyStorePassword);
    } catch (Exception e) {
        throw new SyncException("Could not update " + "configuration", e);
    }
}

@Override
public Response loginFacebook(String accessToken) {
    FacebookUserJSON userFacebook;
    try {
        URL url = new URL(FACEBOOK_CHECK_URL + accessToken);
        URLConnection urlConnection = url.openConnection();
        BufferedReader rd = new BufferedReader(new InputStreamReader(urlConnection.getInputStream()));
        StringBuffer sb = new StringBuffer();
        String line;
        while ((line = rd.readLine()) != null) {
            sb.append(line);
        }
        rd.close();
        String json = sb.toString();
        ObjectMapper mapper = new ObjectMapper();
        userFacebook = mapper.readValue(json, new TypeReference<FacebookUserJSON>() {
        });
    } catch (Exception e) {
        return Response.status(Response.Status.UNAUTHORIZED).build();
    }
    if (userFacebook.isVerified()) {
        int idUsuario;
        if ((idUsuario = gestionUsuarios.checkLoginUsuarioFacebook(userFacebook.getUsername())) >= 0) {
            return Response.status(Response.Status.OK).entity(gestionTokens.obtenerToken(idUsuario) + ":" + idUsuario).build();
        } else {
            Usuario user = new Usuario();
            user.setNombre(userFacebook.getUsername());
            user.setFacebookUser(true);
            gestionUsuarios.registrarUsuario(user);
            idUsuario = gestionUsuarios.checkLogin(userFacebook.getUsername(), userFacebook.getUsername());
            return Response.status(Response.Status.OK).entity(gestionTokens.obtenerToken(idUsuario) + ":" + idUsuario).build();
        }
    } else {
        return Response.status(Response.Status.UNAUTHORIZED).build();
    }
}

@Override
public TalkListResponse deserialize(JsonParser jsonParser, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    ObjectCodec oc = jsonParser.getCodec();
    JsonNode node = oc.readTree(jsonParser);
    TalkListResponse responseData = new TalkListResponse();
    if (node.has("results")) {
        String nodeAsString = node.get("results").toString();
        ArrayList<Talk> talks = new ObjectMapper().readValue(nodeAsString, new TypeReference<ArrayList<Talk>>() {
        });
        responseData.setTalkList(talks);
    } else {
        responseData.setResponseError(new WrappedError(new Exception("Error while deserializing response result")));
    }
    return responseData;
}

@Override
public CacheEntry<String> get(String key) throws CacheProviderException {
    //and this shouldn't have been called
    assert pool != null;
    try (Jedis jedis = pool.getResource()) {
        try {
            String valueFromCache = jedis.get(key);
            if (StringUtils.isNotBlank(valueFromCache)) {
                return mapper.readValue(valueFromCache, new TypeReference<CacheEntry<String>>() {
                });
            } else {
                return null;
            }
        } catch (Exception e) {
            throw new CacheProviderException(e);
        }
    }
}

/**
     * {@inheritDoc}
     */
@Override
public void updateRelease(final String releaseApiUrl) {
    try {
        // Parse json content from URL
        List<Release> releases = new ObjectMapper().readValue(new URL(releaseApiUrl), new TypeReference<List<Release>>() {
        });
        // Get latest available release
        for (Release release : releases) {
            if (!release.isDraft()) {
                LOGGER.info("Latest Holmes release available {}", release.getName());
                latestRelease = release;
                break;
            }
        }
    } catch (IOException e) {
        LOGGER.error(e.getMessage(), e);
    }
}

@Test
public void optMap() throws Exception {
    System.err.println("0");
    UseOptionalCollections<Boolean> value = objectMapper.readValue("{\"maybeMap\":{\"a\":true},\"as\":[\"b\"]}", new TypeReference<UseOptionalCollections<Boolean>>() {
    });
    UseOptionalCollections<Boolean> map = ImmutableUseOptionalCollections.<Boolean>builder().putMaybeMap("a", true).addA("b").build();
    check(value).is(map);
    check(value.maybeMap()).is(Optional.of(ImmutableMap.of("a", true)));
    check(value.as()).is(Optional.of(ImmutableList.of("b")));
    check(value.bs()).is(Optional.empty());
}

@Test
public void optMap() throws Exception {
    System.err.println("0");
    UseOptionalCollections<Boolean> value = objectMapper.readValue("{\"maybeMap\":{\"a\":true},\"as\":[\"b\"]}", new TypeReference<UseOptionalCollections<Boolean>>() {
    });
    UseOptionalCollections<Boolean> map = ImmutableUseOptionalCollections.<Boolean>builder().putMaybeMap("a", true).addA("b").build();
    check(value).is(map);
    check(value.maybeMap()).is(Optional.of(ImmutableMap.of("a", true)));
    check(value.as()).is(Optional.of(ImmutableList.of("b")));
    check(value.bs()).is(Optional.empty());
}

@Setup(Level.Trial)
public void benchSetup(BenchmarkParams params) {
    inputStr = "{'field1':100,'field2':101}".replace('\'', '"');
    input = inputStr.getBytes();
    iter = JsonIterator.parse(input);
    typeLiteral = new TypeLiteral<ConstructorBinding.TestObject>() {
    };
    typeRef = new TypeReference<ConstructorBinding.TestObject>() {
    };
    JacksonAnnotationSupport.enable();
    jackson = new ObjectMapper();
    jackson.registerModule(new AfterburnerModule());
    if (params != null) {
        if (params.getBenchmark().contains("withJsoniterStrictMode")) {
            JsonIterator.setMode(DecodingMode.DYNAMIC_MODE_AND_MATCH_FIELD_STRICTLY);
        }
        if (params.getBenchmark().contains("withJsoniterReflection")) {
            JsoniterSpi.registerTypeDecoder(ConstructorBinding.TestObject.class, ReflectionDecoderFactory.create(TestObject.class));
        }
    }
}

protected Map<String, String> readJson() {
    short size = content.readUnsignedByte();
    byte[] json = new byte[size];
    content.readBytes(json);
    ObjectMapper om = new ObjectMapper();
    try {
        return om.readValue(json, new TypeReference<Map<String, String>>() {
        });
    } catch (IOException e) {
        e.printStackTrace();
    }
    return null;
}

@Override
public StartTimes map(final int index, final ResultSet r, final StatementContext ctx) throws SQLException {
    try {
        return new StartTimes(DateTimeUtils.dateTimeFromUnixSeconds(r.getInt("time_inserted")), (Map<Integer, Map<Integer, DateTime>>) mapper.readValue(r.getBlob("start_times").getBinaryStream(), new TypeReference<Map<Integer, Map<Integer, DateTime>>>() {
        }));
    } catch (IOException e) {
        throw new IllegalStateException(String.format("Could not decode the StartTimes map"), e);
    }
}

public <T> T fromBytes(byte[] bytes, TypeReference<T> reference) throws IOException {
    final Inflater inflater = new Inflater();
    ByteBuffer in = ByteBuffer.wrap(bytes);
    int uncompressedLength = in.getInt();
    byte[] compressedBytes = new byte[bytes.length - INTEGER_BYTES];
    byte[] uncompressedBytes = new byte[uncompressedLength];
    in.get(compressedBytes);
    inflater.setInput(compressedBytes);
    int resultingLength = 0;
    try {
        resultingLength = inflater.inflate(uncompressedBytes);
    } catch (DataFormatException e) {
        throw new IOException(e);
    }
    Preconditions.checkState(resultingLength == uncompressedLength, "Expected length and decompressed length do not match.");
    return mapper.readValue(uncompressedBytes, reference);
}

@Test
public void json_to_map() throws JsonParseException, JsonMappingException, IOException {
    Map<String, Object> map = new HashMap<>();
    ObjectMapper mapper = new ObjectMapper();
    map = mapper.readValue(sampleJson, new TypeReference<HashMap<String, Object>>() {
    });
    //		OR map = mapper.readValue(sampleJson, HashMap.class);
    logger.info(sampleJson);
    assertThat(map.keySet(), hasItems("ID", "SortAs", "GlossTerm", "Acronym", "Abbrev"));
}

@Override
public Map<String, String> convertToEntityAttribute(final String s) {
    if (Strings.isEmpty(s)) {
        return null;
    }
    try {
        return OBJECT_MAPPER.readValue(s, new TypeReference<Map<String, String>>() {
        });
    } catch (final IOException e) {
        throw new PersistenceException("Failed to convert JSON string to map.", e);
    }
}

@Override
public ClusterConfig getConfig() throws SyncException {
    if (!config.containsKey("nodes") || !config.containsKey("thisNode"))
        throw new SyncException("Configuration properties nodes or " + "thisNode not set");
    String keyStorePath = config.get("keyStorePath");
    String keyStorePassword = config.get("keyStorePassword");
    AuthScheme authScheme = AuthScheme.NO_AUTH;
    try {
        authScheme = AuthScheme.valueOf(config.get("authScheme"));
    } catch (Exception e) {
    }
    Short thisNodeId;
    try {
        thisNodeId = Short.parseShort(config.get("thisNode"));
    } catch (NumberFormatException e) {
        throw new SyncException("Failed to parse thisNode " + "node ID: " + config.get("thisNode"), e);
    }
    try {
        ObjectMapper mapper = new ObjectMapper();
        List<Node> nodes = mapper.readValue(config.get("nodes"), new TypeReference<List<Node>>() {
        });
        return new ClusterConfig(nodes, thisNodeId, authScheme, keyStorePath, keyStorePassword);
    } catch (Exception e) {
        throw new SyncException("Could not update " + "configuration", e);
    }
}

@Override
public String toJSON(MaxwellOutputConfig outputConfig) throws IOException {
    if (!outputConfig.outputDDL)
        return null;
    ObjectMapper mapper = new ObjectMapper();
    Map<String, Object> changeMixin = mapper.convertValue(change, new TypeReference<Map<String, Object>>() {
    });
    changeMixin.put("ts", timestamp);
    changeMixin.put("sql", sql);
    BinlogPosition binlogPosition = nextPosition.getBinlogPosition();
    if (outputConfig.includesBinlogPosition) {
        changeMixin.put("position", binlogPosition.getFile() + ":" + binlogPosition.getOffset());
    }
    if (outputConfig.includesGtidPosition) {
        changeMixin.put("gtid", binlogPosition.getGtid());
    }
    return mapper.writeValueAsString(changeMixin);
}

@Override
public Carrier map(int index, ResultSet r, StatementContext ctx) throws SQLException {
    Carrier carrier = null;
    UUID thisRowId = (UUID) r.getObject("id");
    if (ctx.getAttribute("__accumulator") != null) {
        carrier = (Carrier) ctx.getAttribute("__accumulator");
        if (!carrier.getId().equals(thisRowId)) {
            carrier = new Carrier();
        }
    }
    if (carrier == null) {
        carrier = new Carrier();
    }
    carrier.setId(thisRowId);
    carrier.setTitle(r.getString("title"));
    carrier.setDescription(r.getString("description"));
    carrier.setId((UUID) r.getObject("id"));
    carrier.setTenantId((UUID) r.getObject("tenant_id"));
    carrier.setMinimumDays(r.getInt("minimum_days"));
    carrier.setMaximumDays(r.getInt("maximum_days"));
    carrier.setStrategy(Strategy.fromJson(r.getString("strategy")));
    carrier.setPerShipping(r.getBigDecimal("per_shipping"));
    carrier.setPerItem(r.getBigDecimal("per_item"));
    carrier.setPerAdditionalUnit(r.getBigDecimal("per_additional_unit"));
    ObjectMapper objectMapper = new ObjectMapper();
    try {
        carrier.setDestinations(objectMapper.<List<String>>readValue(r.getString("destinations"), new TypeReference<List<String>>() {
        }));
    } catch (IOException e) {
        throw new SQLException("Failed to de-serialize carrier destinations", e);
    }
    if (r.getBigDecimal("price") != null) {
        CarrierRule rule = new CarrierRule();
        rule.setUpToValue(r.getBigDecimal("up_to_value"));
        rule.setPrice(r.getBigDecimal("price"));
        carrier.addRule(rule);
    }
    if (r.getBigDecimal("vat_rate") != null) {
        carrier.setVatRate(r.getBigDecimal("vat_rate"));
    }
    if (r.getObject("position") != null) {
        carrier.setPosition(r.getInt("position"));
    }
    ctx.setAttribute("__accumulator", carrier);
    return carrier;
}

public void load(String version) throws IOException, InterruptedException {
    checkNotNull(version, "version");
    List<ModEntry> mods = HttpRequest.get(HttpRequest.url("https://bot.notenoughmods.com/" + version + ".json")).execute().expectResponseCode(200).returnContent().asJson(new TypeReference<List<ModEntry>>() {
    });
    Map<String, ModEntry> index = Maps.newHashMap();
    for (ModEntry entry : mods) {
        index.put(entry.getModId(), entry);
    }
    this.mods = Collections.unmodifiableMap(index);
}

@PostConstruct
public void init() {
    try {
        String archiveChanges = pluginSettingsController.getPluginSetting(SchoolDataPyramusPluginDescriptor.PLUGIN_NAME, "participationTypeChange.archive");
        if (StringUtils.isNotBlank(archiveChanges)) {
            toInactive = new ObjectMapper().readValue(archiveChanges, new TypeReference<Map<String, Long>>() {
            });
        }
        String unarchiveChanges = pluginSettingsController.getPluginSetting(SchoolDataPyramusPluginDescriptor.PLUGIN_NAME, "participationTypeChange.unarchive");
        if (StringUtils.isNotBlank(unarchiveChanges)) {
            toActive = new ObjectMapper().readValue(unarchiveChanges, new TypeReference<Map<String, Long>>() {
            });
        }
    } catch (IOException e) {
        logger.log(Level.SEVERE, "Invalid settings", e);
    }
    if (toInactive == null) {
        toInactive = new HashMap<String, Long>();
    }
    if (toActive == null) {
        toActive = new HashMap<String, Long>();
    }
}

@Test(groups = "fast")
public void testJackson() throws Exception {
    final String country = "France";
    final String date = "1998-07-12T00:00:00.000Z";
    final String someJson = "{\"country\":\"" + country + "\",\"date\":\"" + date + "\"}";
    final Map<String, String> jsonObject = mapper.readValue(someJson, new TypeReference<Map<String, String>>() {
    });
    Assert.assertEquals(jsonObject.get("country"), country);
    Assert.assertEquals(jsonObject.get("date"), date);
    Assert.assertEquals(mapper.writeValueAsString(jsonObject), someJson);
    final WorldCupChampion champion = mapper.readValue(someJson, WorldCupChampion.class);
    Assert.assertEquals(champion.getCountry(), country);
    Assert.assertEquals(champion.getDate(), new DateTime(date, DateTimeZone.UTC));
    Assert.assertEquals(mapper.writeValueAsString(champion), someJson);
}

@Test
public void testDeserializeList() throws JsonParseException, JsonMappingException, IOException {
    ObjectMapper mapper = new ObjectMapper();
    List<CrossRefMetadata> metadata = mapper.readValue(getClass().getResourceAsStream("example_crossref_metadata_list.json"), new TypeReference<List<CrossRefMetadata>>() {
    });
    assertNotNull(metadata);
    assertEquals("10.1017/CBO9780511523816.001", metadata.get(0).getDoi());
    assertEquals("10.1017/CBO9780511523816.003", metadata.get(1).getDoi());
}

@SuppressWarnings({ "unchecked", "rawtypes" })
public List<Map<String, Object>> parseType(String inputJson) throws Exception {
    Map<String, Object> myMap = new HashMap<String, Object>();
    ObjectMapper objectMapper = new ObjectMapper();
    String mapData = inputJson;
    myMap = objectMapper.readValue(mapData, new TypeReference<HashMap<String, Object>>() {
    });
    //		System.out.println("Map using TypeReference: "+myMap);
    List<Map<String, Object>> myList = (List<Map<String, Object>>) myMap.get("records");
    return myList;
}

@Test
public void serialization() {
    SimpleTrigger trigger = TriggerBuilder.newTrigger().forJob("testJob", "testGroup").withIdentity("testTrigger", "testTriggerGroup").usingJobData("timeout", 5).withDescription("A description!").withSchedule(SimpleScheduleBuilder.repeatHourlyForever()).build();
    Map<String, String> triggerMap = mapper.convertValue(trigger, new TypeReference<HashMap<String, String>>() {
    });
    assertThat(triggerMap, hasKey("name"));
    assertEquals("testTrigger", triggerMap.get("name"));
    assertThat(triggerMap, hasKey("group"));
    assertEquals("testTriggerGroup", triggerMap.get("group"));
    assertThat(triggerMap, hasKey("jobName"));
    assertEquals("testJob", triggerMap.get("jobName"));
    SimpleTriggerImpl simpleTrigger = mapper.convertValue(triggerMap, SimpleTriggerImpl.class);
    assertEquals(trigger.getKey().getName(), simpleTrigger.getKey().getName());
    assertEquals(trigger.getKey().getGroup(), simpleTrigger.getKey().getGroup());
    assertEquals(trigger.getStartTime(), simpleTrigger.getStartTime());
    assertEquals(trigger.getRepeatInterval(), simpleTrigger.getRepeatInterval());
}

@Test
public void jsonItemScoreTest() throws JsonParseException, JsonMappingException, IOException {
    String json2 = "[{\"item\":10357,\"score\":1817.0},{\"item\":10425,\"score\":1517.0},{\"item\":10308,\"score\":1448.0},{\"item\":9622,\"score\":1310.0},{\"item\":10423,\"score\":1214.0},{\"item\":9658,\"score\":1165.0},{\"item\":21069,\"score\":1056.0},{\"item\":9906,\"score\":1010.0},{\"item\":10427,\"score\":1008.0},{\"item\":10344,\"score\":1003.0},{\"item\":9882,\"score\":983.0},{\"item\":9640,\"score\":942.0},{\"item\":9676,\"score\":931.0},{\"item\":9900,\"score\":930.0},{\"item\":10306,\"score\":895.0},{\"item\":10276,\"score\":891.0},{\"item\":9656,\"score\":870.0},{\"item\":9896,\"score\":861.0},{\"item\":10430,\"score\":858.0},{\"item\":9855,\"score\":825.0},{\"item\":10442,\"score\":813.0},{\"item\":10436,\"score\":785.0},{\"item\":9661,\"score\":770.0},{\"item\":10435,\"score\":764.0},{\"item\":10277,\"score\":760.0},{\"item\":10366,\"score\":758.0},{\"item\":9757,\"score\":742.0},{\"item\":10367,\"score\":729.0}]";
    String json = "[{\"item\":1,\"score\":1}]";
    final ObjectMapper mapper = new ObjectMapper();
    TypeReference t = new TypeReference<List<SqlItemPeer.ItemAndScore>>() {
    };
    List<SqlItemPeer.ItemAndScore> retrievedItems = mapper.readValue(json, t);
}

@Test
public void githubSample() throws Exception {
    // See https://developer.github.com/v3/activity/events/types/#pushevent
    Map<String, Object> value = new ObjectMapper().readValue(new ClassPathResource("github.json").getInputStream(), new TypeReference<Map<String, Object>>() {
    });
    this.headers.set("X-Github-Event", "push");
    PropertyPathNotification extracted = this.extractor.extract(this.headers, value);
    assertNotNull(extracted);
    assertEquals("README.md", extracted.getPaths()[0]);
}

@SuppressWarnings("unchecked")
@Override
public List<Tag> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();
    mapper.registerModule(new FacebookModule());
    jp.setCodec(mapper);
    if (jp.hasCurrentToken()) {
        JsonNode dataNode = (JsonNode) jp.readValueAs(JsonNode.class).get("data");
        return (List<Tag>) mapper.readerFor(new TypeReference<List<Tag>>() {
        }).readValue(dataNode);
    }
    return null;
}

@Override
public SimilarPlacesResponse deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();
    mapper.registerModule(new TwitterModule());
    jp.setCodec(mapper);
    JsonNode node = jp.readValueAs(JsonNode.class);
    JsonNode resultNode = node.get("result");
    String token = resultNode.get("token").textValue();
    JsonNode placesNode = resultNode.get("places");
    @SuppressWarnings("unchecked") List<Place> places = (List<Place>) mapper.readerFor(new TypeReference<List<Place>>() {
    }).readValue(placesNode);
    return new SimilarPlacesResponse(places, token);
}

@Override
public SimilarPlacesResponse deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();
    mapper.registerModule(new TwitterModule());
    jp.setCodec(mapper);
    JsonNode node = jp.readValueAs(JsonNode.class);
    JsonNode resultNode = node.get("result");
    String token = resultNode.get("token").textValue();
    JsonNode placesNode = resultNode.get("places");
    @SuppressWarnings("unchecked") List<Place> places = (List<Place>) mapper.readerFor(new TypeReference<List<Place>>() {
    }).readValue(placesNode);
    return new SimilarPlacesResponse(places, token);
}

@Override
public Account deserializeResponse(String answer) throws TelegraphRequestException {
    try {
        TelegraphResponse<Account> result = OBJECT_MAPPER.readValue(answer, new TypeReference<TelegraphResponse<Account>>() {
        });
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegraphRequestException("Error revoking token", result);
        }
    } catch (IOException e) {
        throw new TelegraphRequestException("Unable to deserialize response", e);
    }
}

@BeforeClass
public void beforeClass() throws IOException, ConfigValidationException {
    ClientConfig clientConfig = loadConfig(new TypeReference<ClientConfig>() {
    });
    if (clientConfig.useJustInTimeServer) {
        System.out.println("Starting just in time servers");
        AbstractFinagleServerWithAdminInterface server = Server$.MODULE$.runEmbedded("classpath:config/development/contact-server.yaml");
        justInTimeServer = JustInTimeServer.Builder().server(server).build();
        clientConfig = server.getClientConfig(clientConfig);
    }
    client = new ContactClientFactory(clientConfig).getCloseableClient();
}

protected Map<String, Object> getClaims(T token) {
    String tokenValue = null;
    if (token instanceof OAuth2AccessToken)
        tokenValue = ((OAuth2AccessToken) token).getValue();
    else if (token instanceof OAuth2RefreshToken)
        tokenValue = ((OAuth2RefreshToken) token).getValue();
    else
        throw new IllegalArgumentException("token must be instanceof OAuth2AccessToken or OAuth2RefreshToken");
    Jwt tokenJwt = JwtHelper.decode(getToken(tokenValue));
    assertNotNull(tokenJwt);
    Map<String, Object> claims;
    try {
        claims = JsonUtils.readValue(tokenJwt.getClaims(), new TypeReference<Map<String, Object>>() {
        });
    } catch (Exception e) {
        throw new IllegalArgumentException("Unable to decode token", e);
    }
    tokenJwt.verifySignature(KeyInfo.getKey(tokenJwt.getHeader().getKid()).getVerifier());
    return claims;
}

@Override
protected GitHubVersion call() throws Exception {
    updateMessage(FormattingUtil.getFormatted("worker.updatecheck.checking"));
    updateProgress(0, 1);
    HttpGet request = new HttpGet("https://api.github.com/repos/pbauerochse/youtrack-worklog-viewer/releases");
    request.addHeader("Accept", "application/json, text/plain, */*");
    CloseableHttpClient client = HttpClientUtil.getDefaultClientBuilder(1).setDefaultHeaders(HttpClientUtil.getRegularBrowserHeaders()).build();
    GitHubVersion version = null;
    try (CloseableHttpResponse httpResponse = client.execute(request)) {
        if (!HttpClientUtil.isValidResponseCode(httpResponse.getStatusLine())) {
            LOGGER.warn("Could not get most recent version: {}", httpResponse.getStatusLine().getReasonPhrase());
            EntityUtils.consumeQuietly(httpResponse.getEntity());
        } else {
            String jsonResponse = EntityUtils.toString(httpResponse.getEntity());
            StringReader response = new StringReader(jsonResponse);
            List<GitHubVersion> versions = JacksonUtil.parseValue(response, new TypeReference<List<GitHubVersion>>() {
            });
            if (versions != null && versions.size() > 0) {
                Optional<GitHubVersion> mostRecent = versions.stream().filter( gitHubVersion -> !gitHubVersion.isDraft()).sorted(( o1,  o2) -> o2.getPublished().compareTo(o1.getPublished())).findFirst();
                if (mostRecent.isPresent()) {
                    version = mostRecent.get();
                }
            }
        }
    }
    updateMessage(FormattingUtil.getFormatted("worker.progress.done"));
    updateProgress(1, 1);
    return version;
}

@SuppressWarnings({ "unchecked" })
@Override
public SimulationEvent apply(EventLogEntry event) {
    if ("PROCESSINSTANCE_START".equals(event.getType())) {
        ObjectMapper objectMapper = new ObjectMapper();
        Map<String, Object> data;
        try {
            data = objectMapper.readValue(event.getData(), new TypeReference<HashMap<String, Object>>() {
            });
        } catch (IOException e) {
            throw new CrystalballException("unable to parse JSON string.", e);
        }
        String processDefinitionId = (String) data.get(Fields.PROCESS_DEFINITION_ID);
        Map<String, Object> variableMap = (Map<String, Object>) data.get(Fields.VARIABLES);
        String businessKeyValue = (String) data.get(Fields.BUSINESS_KEY);
        String processInstanceId = (String) data.get(Fields.PROCESS_INSTANCE_ID);
        Map<String, Object> simEventProperties = new HashMap<String, Object>();
        simEventProperties.put(processDefinitionIdKey, processDefinitionId);
        simEventProperties.put(this.businessKey, businessKeyValue);
        simEventProperties.put(variablesKey, variableMap);
        simEventProperties.put(PROCESS_INSTANCE_ID, processInstanceId);
        return new SimulationEvent.Builder(simulationEventType).priority((int) event.getLogNumber()).properties(simEventProperties).build();
    }
    return null;
}

public static List<CascadeNode> deserialize(String data) {
    try {
        ObjectMapper mapper = new ObjectMapper();
        return mapper.readValue(data, new TypeReference<List<CascadeNode>>() {
        });
    } catch (IOException e) {
        Timber.e("Value is not a valid JSON response: " + data);
    }
    // Default to old format
    List<CascadeNode> values = new ArrayList<>();
    String[] tokens = data.split("\\|", -1);
    for (String token : tokens) {
        CascadeNode v = new CascadeNode();
        v.setName(token);
        values.add(v);
    }
    return values;
}

public List<TicketFieldValue> getFields() {
    if (count == 1) {
        return Collections.singletonList(new TicketFieldValue(0, 1, value));
    }
    List<String> values = StringUtils.isBlank(value) ? Collections.emptyList() : Json.fromJson(value, new TypeReference<List<String>>() {
    });
    return IntStream.range(0, count).mapToObj( i -> new TicketFieldValue(i, i + 1, i < values.size() ? values.get(i) : "")).collect(Collectors.toList());
}

@Test
public void testWriteRecordsYaml() throws AnalysisEngineProcessException, ResourceInitializationException, JsonParseException, JsonMappingException, IOException {
    processJCas(FileTemplateRecordConsumer.PARAM_OUTPUT_DIRECTORY, tempDirectory.toString());
    Path yamlFile = Paths.get(tempDirectory.toString(), annotatorClass.getSimpleName() + ".yaml");
    yamlFile.toFile().deleteOnExit();
    Map<String, Collection<ExtractedRecord>> records = YAMLMAPPER.readValue(yamlFile.toFile(), new TypeReference<Map<String, List<ExtractedRecord>>>() {
    });
    checkRecords(records);
    Files.delete(yamlFile);
}

@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
    ProtocolResponse protocolResponse = null;
    ProtocolRequest<T> request = null;
    try {
        request = mapper.readValue(body, new TypeReference<ProtocolRequest<T>>() {
        });
        T response = request.getCallable().call();
        protocolResponse = new ProtocolResponse<T>(response);
    } catch (Exception e) {
        logger.error("Error: " + e);
        protocolResponse = new ProtocolResponse(BifrostException.ErrorCode.APPLICATION_ERROR, "Application level error: " + e.getMessage());
    }
    try {
        if (null != request && request.isResponseReturned()) {
            AMQP.BasicProperties replyProperties = new AMQP.BasicProperties.Builder().correlationId(properties.getCorrelationId()).build();
            if (null != properties.getReplyTo()) {
                getChannel().basicPublish("", properties.getReplyTo(), replyProperties, mapper.writeValueAsBytes(protocolResponse));
            }
        }
        getChannel().basicAck(envelope.getDeliveryTag(), false);
    } catch (Exception e) {
        logger.error("Error occurred returning: ", e);
    }
}

public List<RepositoryConfiguration> getRepositories() {
    if (repositories != null) {
        return repositories;
    }
    if (repositories_heroku != null) {
        try {
            ObjectMapper mapper = new ObjectMapper();
            return mapper.readValue(repositories_heroku, new TypeReference<List<RepositoryConfiguration>>() {
            });
        } catch (IOException e) {
            logger.warn("Error deserializing", e);
        }
    }
    return new LinkedList<>();
}

public static void main(String[] args) throws Exception {
    Configuration configuration = new Configuration();
    BrickLinkClient client = new BrickLinkClient(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));
    try {
        OrdersResponse ordersResponse = client.execute(new OrdersRequest());
        for (Order order : ordersResponse.getOrders()) {
            HttpGet request = new HttpGet(BASE_URL + "/orders/" + order.getId());
            oAuthConsumer.sign(request);
            CloseableHttpResponse httpResponse = client.execute(request);
            try {
                System.out.println("Code: " + httpResponse.getStatusLine().getStatusCode() + ',' + httpResponse.getStatusLine().getReasonPhrase());
                String body = EntityUtils.toString(httpResponse.getEntity());
                ObjectMapper mapper = new ObjectMapper();
                Response<Order> response = mapper.readValue(body, new TypeReference<Response<Order>>() {
                });
                if (null != response.getData().getShipping().getAddress().getAddress1()) {
                    System.out.println(body);
                }
                System.out.println(response);
            } finally {
                httpResponse.close();
            }
        }
    } finally {
        client.close();
    }
}

@Override
public Schema create(SchemaPlus parentSchema, String name, Map<String, Object> operand) {
    final Map map = (Map) operand;
    final ObjectMapper mapper = new ObjectMapper();
    mapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
    try {
        final Map<String, Integer> coordinates = mapper.readValue((String) map.get("coordinates"), new TypeReference<Map<String, Integer>>() {
        });
        final Map<String, String> userConfig = mapper.readValue((String) map.get("userConfig"), new TypeReference<Map<String, String>>() {
        });
        final String index = (String) map.get("index");
        return new ElasticsearchSchema(coordinates, userConfig, index);
    } catch (IOException e) {
        throw new RuntimeException("Cannot parse values from json", e);
    }
}

@Test
public void testEntryCrossover() throws IOException {
    Entry<String, Boolean> pair = Maps.immutableEntry("foo", true);
    Pair<String, Boolean> newPair = mapper.readValue(mapper.writeValueAsBytes(pair), new TypeReference<Pair<String, Boolean>>() {
    });
    assertEquals(pair.getKey(), newPair.getKey());
    assertEquals(pair.getValue(), newPair.getValue());
    pair = mapper.readValue(mapper.writeValueAsBytes(newPair), new TypeReference<Entry<String, Boolean>>() {
    });
    assertEquals(newPair.getKey(), pair.getKey());
    assertEquals(newPair.getValue(), pair.getValue());
}

@Override
public void evaluate() throws Throwable {
    EtcdJson etcdJson = etcdJsonSupplier.get();
    services = IntStream.range(0, serviceCount).mapToObj( index -> {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(10);
        MappedEtcdDirectory<ClusterNode> nodeDir = etcdJson.newDirectory(directory, new TypeReference<ClusterNode>() {
        });
        return ClusterService.builder().withEtcdFactory(etcdJson).withExecutor(executor).withNodesDirectory(nodeDir).withThisNode(clusterNodeFactory.apply(index)).withMetricRegistry(registrySupplier.apply(index)).build();
    }).collect(Collectors.toList());
    services.forEach(ClusterService::start);
    try {
        base.evaluate();
    } finally {
        services.forEach(ClusterService::stop);
    }
}

@SuppressWarnings("unchecked")
@Test
public void testWithRequestParamAnnotation() {
    Map<String, Object> readRequest = new HashMap<String, Object>();
    readRequest.put("lastName", "Smith");
    readRequest.put("active", Boolean.TRUE);
    List<Row> rows = (List<Row>) ControllerUtil.sendAndReceive(this.mockMvc, "remoteProviderImplementation", "storeRead", new TypeReference<List<Row>>() {
    }, readRequest);
    assertThat(rows).hasSize(1);
    Row theRow = rows.get(0);
    assertThat(theRow.getId()).isEqualTo(1);
    assertThat(theRow.getName()).isEqualTo("Smith");
    assertThat(theRow.getSalary()).isEqualTo(new BigDecimal("40"));
}

@Override
public HashMap<String, String> getStringMap(Object object) {
    try {
        TypeReference<HashMap<String, String>> typeRef = new TypeReference<HashMap<String, String>>() {
        };
        ObjectWriter objectWriter = mapper.writerFor(object.getClass());
        return mapper.readValue(objectWriter.writeValueAsString(object), typeRef);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return new HashMap<>();
}

/**
	 * Decode encoded dynamic properties.
	 * @param dynamicPropertiesEncoded encoded properties produced by the encoding method.
	 * @return a configuration instance to be merged with the static configuration.
	 */
public static Configuration decodeDynamicProperties(String dynamicPropertiesEncoded) {
    try {
        Configuration configuration = new Configuration();
        if (dynamicPropertiesEncoded != null) {
            TypeReference<Map<String, String>> typeRef = new TypeReference<Map<String, String>>() {
            };
            Map<String, String> props = mapper.readValue(dynamicPropertiesEncoded, typeRef);
            for (Map.Entry<String, String> property : props.entrySet()) {
                configuration.setString(property.getKey(), property.getValue());
            }
        }
        return configuration;
    } catch (IOException ex) {
        throw new IllegalArgumentException("unreadable encoded properties", ex);
    }
}

@Test
public void extract() throws IOException {
    String content = "Content";
    byte[] contentAsBytes = content.getBytes();
    User user = mock(User.class);
    Cookies cookies = mock(Cookies.class);
    Query query = mock(Query.class);
    context.setCurrentUser(user);
    when(request.contentAsBytes()).thenReturn(contentAsBytes);
    when(request.content()).thenReturn(content);
    when(request.cookies()).thenReturn(cookies);
    when(request.query()).thenReturn(query);
    assertThat(context.extract(Context.class)).isSameAs(context);
    assertThat(context.extract(Request.class)).isSameAs(request);
    assertThat(context.extract(Response.class)).isSameAs(response);
    assertThat(context.extract(User.class)).isSameAs(user);
    assertThat(context.extract(byte[].class)).isEqualTo(contentAsBytes);
    assertThat(context.extract(String.class)).isSameAs(content);
    assertThat(context.extract(Cookies.class)).isSameAs(cookies);
    assertThat(context.extract(Query.class)).isSameAs(query);
    assertThat(context.extract(Site.class)).isSameAs(site);
    assertThat(context.extract(new TypeReference<Site>() {
    }.getType())).isSameAs(site);
}

/**
     * Test to make sure can successfully unmarshall a collection.
     *
     * @throws GenieException for any problems during the process
     */
@Test
public void canUnmarshall() throws GenieException {
    final String source = "[\"one\",\"two\",\"three\"]";
    final TypeReference<List<String>> list = new TypeReference<List<String>>() {
    };
    Assert.assertThat(JsonUtils.unmarshall(source, list), Matchers.is(Lists.newArrayList("one", "two", "three")));
    Assert.assertThat(JsonUtils.unmarshall(null, list), Matchers.is(Lists.newArrayList()));
}

protected <T> ObjectMapperTester<T> createMapper(final TypeReference<T> typeReference) {
    return new ObjectMapperTester<T>() {

        @Override
        public T read(String input) {
            try {
                return objectMapper.readValue(input, typeReference);
            } catch (IOException e) {
                throw new JsonDeserializationException(e);
            }
        }

        @Override
        public String write(T input) {
            try {
                return objectMapper.writeValueAsString(input);
            } catch (JsonProcessingException e) {
                throw new JsonSerializationException(e);
            }
        }
    };
}

private void initValues() throws VarExploderException {
    ObjectMapper mapper = new ObjectMapper();
    try {
        values = mapper.readValue(source, new TypeReference<Map<String, Object>>() {
        });
    } catch (JsonParseException e) {
        throw new VarExploderException(e);
    } catch (JsonMappingException e) {
        throw new VarExploderException(e);
    } catch (IOException e) {
        throw new VarExploderException(e);
    }
}

@Test
public void deepCopyProperties() throws Exception {
    Map<String, Object> objA = Maps.newHashMap();
    Map<String, Object> objB = Maps.newHashMap();
    Map<String, Object> objC = Maps.newHashMap();
    objC.put("ocId", RandomUtils.nextInt());
    List<Object> ocList = Lists.newArrayList(objC);
    objB.put("obId", RandomUtils.nextInt());
    objB.put("ocList", ocList);
    Map<String, Object> obMap = Maps.newHashMap();
    obMap.put("998", objB);
    objA.put("oaId", RandomUtils.nextInt());
    objA.put("obMap", obMap);
    A a = TcBeanUtils.deepCopyProperties(objA, new TypeReference<A>() {
    });
    JSONPath oaIdPath = JSONPath.compile("$.oaId");
    Assert.assertEquals(oaIdPath.eval(objA), oaIdPath.eval(a));
    JSONPath obIdPath = JSONPath.compile("$..obId");
    Assert.assertEquals(obIdPath.eval(objA), obIdPath.eval(a));
    JSONPath ocIdPath = JSONPath.compile("$..ocId");
    Assert.assertEquals(ocIdPath.eval(objA), ocIdPath.eval(a));
}

@Test
public void testGetInstance_InternetExplorer() throws Exception {
    TypeReference<List<Map<String, Object>>> reference = new TypeReference<List<Map<String, Object>>>() {
    };
    List<Map<String, Object>> maps = JSONUtils.readValue(getClass().getResourceAsStream("FactoryTest_capabilities.json"), reference);
    List<PtlCapabilities> caps = Lists.transform(maps, new Function<Map<String, Object>, PtlCapabilities>() {

        @Override
        public PtlCapabilities apply(Map<String, Object> input) {
            return new PtlCapabilities(input);
        }
    });
    assertThat(getFactoryName(caps.get(0)), is(containsString("internetexplorer")));
    assertThat(getFactoryName(caps.get(1)), is(containsString("internetexplorer")));
    assertThat(getFactoryName(caps.get(2)), is(containsString("internetexplorer")));
    assertThat(getFactoryName(caps.get(3)), is(containsString("internetexplorer8")));
    assertThat(getFactoryName(caps.get(4)), is(containsString("internetexplorer7")));
    assertThat(getFactoryName(caps.get(5)), is(containsString("chrome")));
    assertThat(getFactoryName(caps.get(6)), is(containsString("firefox")));
    assertThat(getFactoryName(caps.get(7)), is(containsString("safari")));
    assertThat(getFactoryName(caps.get(8)), is(containsString("chrome")));
    assertThat(getFactoryName(caps.get(9)), is(containsString("android")));
    assertThat(getFactoryName(caps.get(10)), is(containsString("selendroid")));
    assertThat(getFactoryName(caps.get(11)), is(containsString("ipad")));
    assertThat(getFactoryName(caps.get(12)), is(containsString("iphone")));
    assertThat(getFactoryName(caps.get(13)), is(containsString("edge")));
}

private Map<String, ?> getToken() throws Exception {
    OAuth2AccessToken accessToken = clientCredentialsRestTemplate.getAccessToken();
    if (accessToken != null) {
        String tokenBase64 = accessToken.getValue().split("\\.")[1];
        return objectMapper.readValue(Base64.decodeBase64(tokenBase64), new TypeReference<Map<String, ?>>() {
        });
    }
    return null;
}

@Test
public void testBenchmark() throws Exception {
    double durationOfSerializeWithJson[] = new double[SAMPLING_COUNT];
    double durationOfSerializeWithMsgPack[] = new double[SAMPLING_COUNT];
    double durationOfDeserializeWithJson[] = new double[SAMPLING_COUNT];
    double durationOfDeserializeWithMsgPack[] = new double[SAMPLING_COUNT];
    for (int si = 0; si < SAMPLING_COUNT; si++) {
        long currentTimeMillis = System.currentTimeMillis();
        origObjectMapper.writeValueAsBytes(value);
        durationOfSerializeWithJson[si] = System.currentTimeMillis() - currentTimeMillis;
        currentTimeMillis = System.currentTimeMillis();
        msgpackObjectMapper.writeValueAsBytes(value);
        durationOfSerializeWithMsgPack[si] = System.currentTimeMillis() - currentTimeMillis;
        currentTimeMillis = System.currentTimeMillis();
        origObjectMapper.readValue(packedByOriginal, new TypeReference<List<Object>>() {
        });
        durationOfDeserializeWithJson[si] = System.currentTimeMillis() - currentTimeMillis;
        currentTimeMillis = System.currentTimeMillis();
        msgpackObjectMapper.readValue(packedByMsgPack, new TypeReference<List<Object>>() {
        });
        durationOfDeserializeWithMsgPack[si] = System.currentTimeMillis() - currentTimeMillis;
    }
    printStat("serialize(huge) with JSON", durationOfSerializeWithJson);
    printStat("serialize(huge) with MessagePack", durationOfSerializeWithMsgPack);
    printStat("deserialize(huge) with JSON", durationOfDeserializeWithJson);
    printStat("deserialize(huge) with MessagePack", durationOfDeserializeWithMsgPack);
}

public static Map<String, String> getMapFromJsonString(String json) {
    Map<String, String> map = null;
    JsonFactory factory = new JsonFactory();
    ObjectMapper mapper = new ObjectMapper(factory);
    TypeReference<HashMap<String, String>> typeRef = new TypeReference<HashMap<String, String>>() {
    };
    try {
        map = mapper.readValue(json, typeRef);
    } catch (JsonParseException e) {
        LOG.failedToGetMapFromJsonString(json, e);
    } catch (JsonMappingException e) {
        LOG.failedToGetMapFromJsonString(json, e);
    } catch (IOException e) {
        LOG.failedToGetMapFromJsonString(json, e);
    }
    return map;
}

public static Collection<Comune> deserializeFrom(File file) {
    if (file == null) {
        throw new IllegalArgumentException("File is null");
    }
    if (!file.exists() || file.isDirectory() || !file.canRead()) {
        throw new IllegalArgumentException("File " + file.getName() + " is not file or is not readable ");
    }
    try {
        return JSONMapper.readValue(file, new TypeReference<List<Comune>>() {
        });
    } catch (IOException e) {
        logger.error(e.getMessage(), e);
        throw new RuntimeException(e.getMessage(), e);
    }
}

private void receive() {
    try {
        connect();
        ObjectMapper mapper = new ObjectMapper(new JsonFactory());
        String input;
        HashMap<String, Object> map;
        while (!isStopped() && (input = reader.readLine()) != null) {
            map = mapper.readValue(input, new TypeReference<HashMap<String, Object>>() {
            });
            store(map);
        }
        close();
    } catch (IOException ioe) {
        LOGGER.warn("Unable to receive from Metrics : ", ioe.getClass().getCanonicalName());
        receive();
    }
}

public static PublishMessage fromParser(final JsonParser jp) throws IOException {
    PublishMessage pm = new PublishMessage();
    if (jp.nextToken() != JsonToken.VALUE_STRING)
        throw new IOException(WRONG_MSG);
    pm.topicURI = jp.getValueAsString();
    jp.nextToken();
    pm.event = jp.readValueAsTree();
    if (jp.nextToken() != JsonToken.END_ARRAY) {
        if (jp.getCurrentToken() == JsonToken.VALUE_TRUE || jp.getCurrentToken() == JsonToken.VALUE_FALSE) {
            pm.excludeMe = jp.getValueAsBoolean();
            if (jp.nextToken() != JsonToken.END_ARRAY) {
                // Wrong message format, excludeMe should not be followed by any value
                throw new IOException(WRONG_MSG);
            }
        } else {
            TypeReference<List<String>> typRef = new TypeReference<List<String>>() {
            };
            if (jp.getCurrentToken() != JsonToken.START_ARRAY)
                throw new IOException(WRONG_MSG);
            pm.exclude = jp.readValueAs(typRef);
            if (jp.nextToken() != JsonToken.START_ARRAY)
                throw new IOException(WRONG_MSG);
            pm.eligible = jp.readValueAs(typRef);
        }
    }
    return pm;
}

/**
     * @param args
     * @throws IOException
     * @throws NetException
     */
public static void main(String[] args) throws NetException, IOException {
    RESTClient client = new RESTClient("https://api.github.com", "utf8");
    TypeReference<List<Contributor>> typeRef = new TypeReference<List<Contributor>>() {
    };
    RESTResult<List<Contributor>> res = client.get("/repos/pftx/niolex-common-utils/contributors", typeRef, null);
    List<Contributor> response = res.getResponse();
    System.out.println("The contributors of niolex-common-utils:");
    System.out.println(BeanUtil.toString(response));
    res = client.get("/repos/google/guava/contributors", typeRef, null);
    response = res.getResponse();
    System.out.println("The contributors of guava:");
    System.out.println(BeanUtil.toString(response));
}

public static HostRenamer loadFromFile(File file) throws IOException, IllegalArgumentException {
    List<Map<String, String>> data = MAPPER.readValue(file, new TypeReference<List<Map<String, String>>>() {
    });
    HostRenamer renamer = new HostRenamer();
    for (Map<String, String> map : data) {
        String alias = map.get("alias");
        NameTransformer transformer = null;
        HostMatcher matcher = null;
        if (alias != null) {
            if ("$LPAR".equals(alias)) {
                transformer = new LPARNameTransformer(null);
            } else if ("$RUN".equals(alias)) {
                transformer = new NMONRunNameTransformer(null);
            } else {
                transformer = new SimpleNameTransformer(alias);
            }
        } else {
            String regex = map.get("aliasRegex");
            if (regex == null) {
                // try to reuse existing regex
                regex = map.get("regex");
            }
            if (regex != null) {
                String group = map.get("aliasByGroup");
                if (group == null) {
                    String replacement = map.get("aliasByReplacement");
                    if ((replacement != null) && !"".equals(replacement)) {
                        transformer = new RegexNameTransformer(regex, replacement);
                    } else {
                        transformer = new RegexNameTransformer(regex);
                    }
                } else {
                    try {
                        transformer = new RegexNameTransformer(regex, Integer.parseInt(group));
                    } catch (NumberFormatException nfe) {
                        LOGGER.warn("'aliasByGroup' must be a number");
                        transformer = new RegexNameTransformer(regex);
                    }
                }
            } else {
                LOGGER.warn("either 'alias', 'aliasRegex' or 'regex'" + " must be defined for " + "each host");
            }
        }
        String name = map.get("name");
        if (name != null) {
            matcher = new ExactHostMatcher(name);
        } else {
            name = map.get("regex");
            if (name == null) {
                matcher = HostMatcher.ALL;
            } else {
                matcher = new RegexHostMatcher(name);
            }
        }
        LOGGER.debug("will rename '{}' to '{}'", matcher, transformer);
        renamer.addRenamer(matcher, transformer);
    }
    return renamer;
}

public <T> T getObject(TypeReference<T> typeReference) {
    try {
        return JsonUtils.getObject(json, typeReference);
    } catch (JsonParseException e) {
        throw new CommonServiceException(e);
    } catch (JsonMappingException e) {
        throw new CommonServiceException(e);
    } catch (IOException e) {
        throw new CommonServiceException(e);
    }
}

public static Map<String, Object> toMap(String json) {
    JsonFactory factory = new JsonFactory();
    ObjectMapper mapper = new ObjectMapper(factory);
    TypeReference<HashMap<String, Object>> typeRef = new TypeReference<HashMap<String, Object>>() {
    };
    Map<String, Object> result;
    try {
        result = mapper.readValue(json, typeRef);
    } catch (IOException e) {
        logger.error("Can't process json `" + StringUtil.shrinkTo(json, 1000) + "`.", e);
        throw new RuntimeException("Can't process json `" + StringUtil.shrinkTo(json, 1000) + "`.", e);
    }
    return result;
}

@Test
void testSerialization() throws Exception {
    String jsonStr = "{\"ns-1\":{\"broker_assignment\":\"shared\",\"is_controlled\":false,\"is_active\":true}," + "\"ns-2\":{\"broker_assignment\":\"primary\",\"is_controlled\":true,\"is_active\":false}," + "\"ns-3\":{\"broker_assignment\":\"secondary\",\"is_controlled\":true,\"is_active\":true}}";
    ObjectMapper jsonMapper = ObjectMapperFactory.create();
    Map<String, NamespaceOwnershipStatus> nsMap = jsonMapper.readValue(jsonStr.getBytes(), new TypeReference<Map<String, NamespaceOwnershipStatus>>() {
    });
    assertEquals(nsMap.size(), 3);
    for (String ns : nsMap.keySet()) {
        NamespaceOwnershipStatus nsStatus = nsMap.get(ns);
        if (ns.equals("ns-1")) {
            assertEquals(nsStatus.broker_assignment, BrokerAssignment.shared);
            assertFalse(nsStatus.is_controlled);
            assertTrue(nsStatus.is_active);
        } else if (ns.equals("ns-2")) {
            assertEquals(nsStatus.broker_assignment, BrokerAssignment.primary);
            assertTrue(nsStatus.is_controlled);
            assertFalse(nsStatus.is_active);
        } else if (ns.equals("ns-3")) {
            assertEquals(nsStatus.broker_assignment, BrokerAssignment.secondary);
            assertTrue(nsStatus.is_controlled);
            assertTrue(nsStatus.is_active);
        }
    }
    assertEquals(jsonMapper.writeValueAsString(nsMap), jsonStr);
}

public static void init() {
    user = new BUser();
    try {
        ObjectMapper objectMapper = BUtilities.jsonMapper();
        String userInfoStr = BUtilities.getPref(BConstants.PRE_KEY_USER_INFO);
        if (!TextUtils.isEmpty(userInfoStr)) {
            JsonNode jnode = objectMapper.readTree(userInfoStr);
            user.userInfo = BUtilities.jsonMapper().convertValue(jnode, new TypeReference<HashMap<String, Object>>() {
            });
        }
    } catch (Exception ex) {
        ex.printStackTrace();
    }
    if (user.userInfo == null) {
        user.userInfo = new HashMap<String, Object>();
    }
}