Java Examples for javax.json.Json

public void process() {
    try {
        System.out.println("ES JSON Container Called");
        File file = new File("ESJsonResponse.json");
        FileInputStream inputStream = new FileInputStream(file);
        JsonReader jsonReader = Json.createReader((InputStream) inputStream);
        this.jsonArray = jsonReader.readArray();
    } catch (Exception e) {
        System.out.println("Error in process() in JsonContainer:" + e.toString());
    }
}

public JsonObjectBuilder asJsonObjectBuilder() {
    JsonObjectBuilder jsonPageInfo = Json.createObjectBuilder();
    jsonPageInfo.add("isNecessary", this.isPagerNecessary()).add("numResults", this.numResults).add("docsPerPage", this.docsPerPage).add("selectedPageNumber", this.selectedPageNumber).add("pageCount", this.pageCount).add("hasPreviousPageNumber", this.hasPreviousPageNumber()).add("previousPageNumber", this.previousPageNumber).add("hasNextPageNumber", this.hasNextPageNumber()).add("nextPageNumber", this.nextPageNumber).add("startCardNumber", this.startCardNumber).add("endCardNumber", this.endCardNumber).add("remainingCards", this.remainingCards).add("numberNextResults", this.numberNextResults);
    // --------------------
    // pageNumberList
    // --------------------
    JsonArrayBuilder jsonPageNumberArrayBuilder = Json.createArrayBuilder();
    for (int pg : this.pageNumberList) {
        jsonPageNumberArrayBuilder.add(pg);
    }
    jsonPageInfo.add("pageNumberList", jsonPageNumberArrayBuilder);
    return jsonPageInfo;
}

/**
	 * Creates the JSON serialized form of the accessory for use over the Homekit Accessory Protocol.
	 * 
	 * @param instanceId the static id of the accessory.
	 * @return a future that will complete with the JSON builder for the object.
	 */
protected CompletableFuture<JsonObjectBuilder> makeBuilder(int instanceId) {
    return getValue().exceptionally( t -> {
        logger.error("Could not retrieve value " + this.getClass().getName(), t);
        return null;
    }).thenApply( value -> {
        JsonArrayBuilder perms = Json.createArrayBuilder();
        if (isWritable) {
            perms.add("pw");
        }
        if (isReadable) {
            perms.add("pr");
        }
        if (isEventable) {
            perms.add("ev");
        }
        JsonObjectBuilder builder = Json.createObjectBuilder().add("iid", instanceId).add("type", type).add("perms", perms.build()).add("format", format).add("events", false).add("bonjour", false).add("description", description);
        setJsonValue(builder, value);
        return builder;
    });
}

@Override
public String encode(MatchMessage m) throws EncodeException {
    StringWriter swriter = new StringWriter();
    try (JsonWriter jsonWrite = Json.createWriter(swriter)) {
        JsonObjectBuilder builder = Json.createObjectBuilder();
        builder.add("match", Json.createObjectBuilder().add("serve", m.getMatch().getServe()).add("title", m.getMatch().getTitle()).add("players", Json.createArrayBuilder().add(Json.createObjectBuilder().add("name", m.getMatch().getPlayerOneName()).add("country", m.getMatch().getP1Country()).add("games", m.getMatch().getP1CurrentGame()).add("sets", m.getMatch().getP1Sets()).add("points", m.getMatch().getPlayer1Score()).add("set1", m.getMatch().getP1Set1()).add("set2", m.getMatch().getP1Set2()).add("set3", m.getMatch().getP1Set3())).add(Json.createObjectBuilder().add("name", m.getMatch().getPlayerTwoName()).add("games", m.getMatch().getP2CurrentGame()).add("country", m.getMatch().getP2Country()).add("sets", m.getMatch().getP2Sets()).add("points", m.getMatch().getPlayer2Score()).add("set1", m.getMatch().getP2Set1()).add("set2", m.getMatch().getP2Set2()).add("set3", m.getMatch().getP2Set3()))).add("comments", m.getMatch().getLiveComments()).add("finished", m.getMatch().isFinished()));
        jsonWrite.writeObject(builder.build());
    }
    return swriter.toString();
}

protected String generateStringResponse() {
    Set<Entry<String, Object>> entrySet = viewAttributes.getAsMap().entrySet();
    StringWriter stringWriter = new StringWriter();
    JsonGenerator generator = Json.createGenerator(stringWriter);
    generator.writeStartObject();
    for (Entry<String, Object> entry : entrySet) {
        String attrName = entry.getKey();
        ObjectToJsonConverter objectToJsonConverter = converters.get(attrName);
        objectToJsonConverter = objectToJsonConverter == null ? new DefaultObjectToJsonConverter() : objectToJsonConverter;
        Object value = entry.getValue();
        if (isSimpleValue(value)) {
            writeSimpleValueEntry(entry, generator);
        } else {
            JsonObject jsonObject = objectToJsonConverter.converter(value);
            generator.write(entry.getKey(), jsonObject);
        }
    }
    generator.writeEnd();
    generator.flush();
    return stringWriter.toString();
}

public JsonObject osInfo() {
    OperatingSystemMXBean osBean = ManagementFactory.getOperatingSystemMXBean();
    return Json.createObjectBuilder().add("System Load Average", osBean.getSystemLoadAverage()).add("Available CPUs", osBean.getAvailableProcessors()).add("Architecture", osBean.getArch()).add("OS Name", osBean.getName()).add("Version", osBean.getVersion()).build();
}

@GET
@Path("{id}")
@Produces("application/json")
public JsonArray getDepartmentProducts(@PathParam("id") Short categoryId) {
    JsonArrayBuilder jb = Json.createArrayBuilder();
    Category selectedCategory = categoryFacade.find(categoryId);
    if (selectedCategory != null) {
        for (Product p : selectedCategory.getProductCollection()) {
            JsonObjectBuilder jpb = Json.createObjectBuilder().add("id", p.getId()).add("name", p.getName()).add("price", p.getPrice());
            jb.add(jpb);
        }
    }
    return jb.build();
}

private JsonObject createAirplaneObject(String id, Double fuelCapacity) {
    JsonObjectBuilder airplaneBuilder = Json.createObjectBuilder();
    JsonObjectBuilder airplaneObjectBuilder = Json.createObjectBuilder();
    airplaneObjectBuilder.add("id", id);
    airplaneObjectBuilder.add("actFuelLevel", fuelCapacity.toString());
    airplaneBuilder.add("Airplane", airplaneObjectBuilder);
    JsonObject obj = airplaneBuilder.build();
    return obj;
}

public List<String> getToolVsnNames() {
    List<String> toolNames = new ArrayList<String>();
    InputStream is = null;
    try {
        is = getClass().getResourceAsStream(ToolsUnderTestHelper.TOOLS_TESTED);
        JsonReader reader = Json.createReader(new InputStreamReader(is));
        JsonObject rootObj = reader.readObject();
        JsonArray toolsArr = rootObj.getJsonArray("tools");
        for (JsonValue v : toolsArr) {
            JsonObject tool = (JsonObject) v;
            String toolFolderName = tool.getString("tool") + " " + tool.getString("version");
            toolNames.add(toolFolderName);
        }
    } catch (Exception e) {
        System.err.println(e.getClass().getName() + ":" + e.getMessage());
        throw e;
    }
    return toolNames;
}

@Test
public void testGeneratorWIthJsonValue() {
    JsonArray array = Json.createArrayBuilder().add(1).add(Json.createObjectBuilder().add("key", "value").addNull("nullValue")).add(2.2).build();
    w.writeStartObject().write("jsonArray", array).writeEnd().close();
    assertEquals("{\"jsonArray\":[1,{\"key\":\"value\",\"nullValue\":null},2.2]}", sw.toString());
}

/*-----------------------------------------------------------
	 * Performance Results Methods ------------------------------
	 * ----------------------------------------------------------
	 * */
public JsonArray addPerfResults(String perfResults) {
    DBCollection coll = db.getCollection("performance");
    BasicDBObject newPerfResults = (BasicDBObject) JSON.parse(perfResults);
    newPerfResults.append("_id", newPerfResults.getString("name"));
    BasicDBObject query = new BasicDBObject();
    query.append("name", newPerfResults.getString("name"));
    BasicDBObject removeId = new BasicDBObject("_id", 0);
    DBCursor cursor = coll.find(query, removeId);
    JsonObjectBuilder objBuild = Json.createObjectBuilder();
    JsonArrayBuilder arrBuild = Json.createArrayBuilder();
    JsonObject json = objBuild.build();
    if (cursor.count() > 0) {
        LOG.info("Performance Results Found: ");
        BasicDBObject found = (BasicDBObject) cursor.next();
        json = Json.createReader(new StringReader(found.toString())).readObject();
        arrBuild.add(json);
    } else {
        LOG.info("New Performance Results Created: " + coll.insert(newPerfResults));
        json = Json.createReader(new StringReader(newPerfResults.toString())).readObject();
        arrBuild.add(json);
    }
    LOG.info("----------------------------------- ARR BUILD -------------------------------------------------\n" + arrBuild.build().toString());
    return arrBuild.build();
}

@GET
@Path("{id}")
public JsonObject getOrder(@PathParam("id") UUID orderId) {
    final CoffeeOrder order = queryService.getOrder(orderId);
    if (order == null)
        throw new NotFoundException();
    return Json.createObjectBuilder().add("status", order.getState().name().toLowerCase()).add("type", order.getOrderInfo().getType().name().toLowerCase()).add("beanOrigin", order.getOrderInfo().getBeanOrigin()).build();
}

@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    final AsyncContext ctx = request.startAsync();
    HttpSession session = request.getSession(true);
    InputStream is = (InputStream) session.getAttribute("inputStreamFile");
    session.removeAttribute("inputStreamFile");
    byte[] byteArray = IOUtils.toByteArray(is);
    InputStream input1 = new ByteArrayInputStream(byteArray);
    InputStream input2 = new ByteArrayInputStream(byteArray);
    ZipInputStream zis = new ZipInputStream(input1);
    ZipEntry ze = zis.getNextEntry();
    StringBuilder s = new StringBuilder();
    byte[] buffer = new byte[1024];
    int read = 0;
    while (ze != null) {
        String name = ze.getName();
        if (name.contains(nameConfigFile)) {
            while ((read = zis.read(buffer, 0, 1024)) >= 0) {
                s.append(new String(buffer, 0, read));
            }
            break;
        }
        ze = zis.getNextEntry();
    }
    JsonObject jsonConfig = null;
    try (JsonReader reader = Json.createReader(new StringReader(s.toString()))) {
        jsonConfig = reader.readObject();
    } catch (Exception e) {
        e.printStackTrace();
    }
    session.setAttribute("inputStreamFile", input2);
    session.setAttribute("jsonConfig", jsonConfig);
    ctx.dispatch("/configuration/ConfigurationDriver");
}

@Test
public void testResolution() {
    JsonValueResolver resolver = new JsonValueResolver();
    ResolutionContext ctx = new DummyResolutionContext();
    // Init the resolver
    MustacheEngineBuilder.newBuilder().omitServiceLoaderConfigurationExtensions().addResolver(resolver).setProperty(JsonValueResolver.ENABLED_KEY, true).build();
    assertNull(resolver.resolve(null, "foo", ctx));
    assertNull(resolver.resolve("bar", "foo", ctx));
    assertEquals(Boolean.TRUE, resolver.resolve(JsonValue.TRUE, "unwrapThis", ctx));
    assertNull(resolver.resolve(JsonValue.TRUE, "whatever", ctx));
    assertEquals(Placeholder.NULL, resolver.resolve(JsonValue.NULL, "unwrapThis", ctx));
    JsonObject jsonObject = Json.createObjectBuilder().add("foo", "bar").add("baz", true).build();
    assertEquals("bar", resolver.resolve(jsonObject, "foo", ctx));
    assertEquals(Boolean.TRUE, resolver.resolve(jsonObject, "baz", ctx));
    JsonArray jsonArray = Json.createArrayBuilder().add(true).add(1).build();
    assertEquals(true, resolver.resolve(jsonArray, "0", ctx));
    assertEquals(BigDecimal.ONE, resolver.resolve(jsonArray, "1", ctx));
}

//@org.junit.Test
public void test1() {
    String json = "{\"id\":\"1\",\"name\":\"foo\",\"isMarried\":true}";
    InputStream is = new ByteArrayInputStream(json.getBytes());
    JsonParser p1 = Json.createParser(is);
    p1.next();
    JsonParser p2 = Json.createParser(is);
/*

         javax.json.JsonException: Cannot auto-detect encoding, not enough chars
            at org.glassfish.json.UnicodeDetectingInputStream.detectEncoding(UnicodeDetectingInputStream.java:131)
            at org.glassfish.json.UnicodeDetectingInputStream.<init>(UnicodeDetectingInputStream.java:76)
            at org.glassfish.json.JsonParserImpl.<init>(JsonParserImpl.java:76)
            at org.glassfish.json.JsonProviderImpl.createParser(JsonProviderImpl.java:83)
            at javax.json.Json.createParser(Json.java:104)
            at org.easybatch.json.JsonFactoryTest.testJsonParserCreation(JsonFactoryTest.java:25)

        */
}

@Override
protected Integer call() throws Exception {
    final URL apiEndpoint = new URL(String.format("%s/bikes/%d/milages", JsonRetrievalTask.BASE_URL, bike.getId()));
    logger.log(Level.FINE, "Calling {0}...", new Object[] { apiEndpoint.toExternalForm() });
    // Prepare connection
    final HttpURLConnection connection = (HttpURLConnection) apiEndpoint.openConnection();
    // It's a post request
    connection.setRequestMethod("POST");
    // With json as content
    connection.setRequestProperty("Content-Type", "application/json; charset=utf-8");
    // that needs to be authorized
    connection.setRequestProperty("Authorization", String.format("Basic %s", Base64.getEncoder().encodeToString(String.format("%s:%s", "biking2", password).getBytes())));
    connection.setDoInput(true);
    connection.setDoOutput(true);
    // Write the actuall request body
    try (final JsonWriter jsonWriter = Json.createWriter(connection.getOutputStream())) {
        jsonWriter.write(Json.createObjectBuilder().add("recordedOn", recordedOn.atStartOfDay().toEpochSecond(ZoneOffset.UTC) * 1000).add("amount", newValue).build());
    }
    final int code = connection.getResponseCode();
    Integer rv = null;
    // Wrong password
    if (code == HttpURLConnection.HTTP_UNAUTHORIZED) {
        // Delete the wrong password
        passwordConsumer.accept(Optional.empty());
        logger.log(Level.WARNING, "Unauthorized request, maybe wrong password?");
        throw new RuntimeException(resources.getString("common.wrongPassword"));
    } else // Bad request (invalid milage, date etc.)
    if (code == HttpURLConnection.HTTP_BAD_REQUEST) {
        final StringBuilder errorMessage = new StringBuilder();
        try (final InputStreamReader reader = new InputStreamReader(connection.getErrorStream())) {
            final char[] buffer = new char[2048];
            int len;
            while ((len = reader.read(buffer, 0, buffer.length)) > 0) {
                errorMessage.append(buffer, 0, len);
            }
        }
        logger.log(Level.WARNING, "Bad request: {0}", new Object[] { errorMessage });
        throw new RuntimeException(errorMessage.toString());
    } else // Dont check the other http states, assume everything else must be ok (like in the angular app ;) )
    {
        // At this point we can be safe that the password is correct
        passwordConsumer.accept(Optional.of(password));
        try (final JsonReader reader = Json.createReader(connection.getInputStream())) {
            final JsonObject jsonObject = reader.readObject();
            final LocalDate recordedOn = LocalDateTime.ofInstant(ofEpochMilli(jsonObject.getJsonNumber("recordedOn").longValue()), systemDefault()).toLocalDate();
            rv = jsonObject.getInt("amount");
            logger.log(Level.INFO, "Stored new mileage {0} recored on {1} for {2}", new Object[] { rv, recordedOn, bike.getName() });
        }
    }
    return rv;
}

public void onCargoInspected(@Observes @CargoInspected Cargo cargo) {
    Writer writer = new StringWriter();
    try (JsonGenerator generator = Json.createGenerator(writer)) {
        generator.writeStartObject().write("trackingId", cargo.getTrackingId().getIdString()).write("origin", cargo.getOrigin().getName()).write("destination", cargo.getRouteSpecification().getDestination().getName()).write("lastKnownLocation", cargo.getDelivery().getLastKnownLocation().getName()).write("transportStatus", cargo.getDelivery().getTransportStatus().toString()).writeEnd();
    }
    String jsonValue = writer.toString();
    for (Session session : sessions) {
        try {
            session.getBasicRemote().sendText(jsonValue);
        } catch (IOException ex) {
            logger.log(Level.WARNING, "Unable to publish WebSocket message", ex);
        }
    }
}

public void onCargoInspected(@Observes @CargoInspected Cargo cargo) {
    Writer writer = new StringWriter();
    try (JsonGenerator generator = Json.createGenerator(writer)) {
        generator.writeStartObject().write("trackingId", cargo.getTrackingId().getIdString()).write("origin", cargo.getOrigin().getName()).write("destination", cargo.getRouteSpecification().getDestination().getName()).write("lastKnownLocation", cargo.getDelivery().getLastKnownLocation().getName()).write("transportStatus", cargo.getDelivery().getTransportStatus().toString()).writeEnd();
    }
    String jsonValue = writer.toString();
    for (Session session : sessions) {
        try {
            session.getBasicRemote().sendText(jsonValue);
        } catch (IOException ex) {
            logger.log(Level.WARNING, "Unable to publish WebSocket message", ex);
        }
    }
}

@Override
public void update(Observable o, Object arg) {
    Socket objSocket = (Socket) arg;
    int intSeq = -1;
    try {
        JsonParser objParser = Json.createParser(objSocket.getInputStream());
        int intTempSeq = -1;
        while (objParser.hasNext()) {
            Event objEvent = objParser.next();
            if (objEvent == Event.KEY_NAME) {
                switch(objParser.getString()) {
                    case "message":
                        objParser.next();
                        String strMessage = objParser.getString();
                        System.out.println(strMessage);
                        CSocialMediaFactory.getTwitter().postMessage(strMessage);
                        CSocialMediaFactory.getFacebook().postMessage(strMessage);
                        intSeq = intTempSeq;
                        break;
                    case "id":
                        objParser.next();
                        intTempSeq = objParser.getInt();
                        break;
                }
            }
        }
    } catch (Exception ex) {
        System.out.println(ex);
    } finally {
        try (Writer objWriter = Channels.newWriter(Channels.newChannel(objSocket.getOutputStream()), StandardCharsets.US_ASCII.name())) {
            objWriter.write(intSeq + "");
            objWriter.flush();
        } catch (IOException ex) {
            System.out.println(ex);
        }
    }
}

public JsonVTypeBuilder addListColumnType(String string, List<Class<?>> ls) {
    JsonArrayBuilder b = Json.createArrayBuilder();
    for (Class<?> element : ls) {
        if (element.equals(String.class)) {
            b.add("String");
        } else if (element.equals(double.class)) {
            b.add("double");
        } else if (element.equals(float.class)) {
            b.add("float");
        } else if (element.equals(long.class)) {
            b.add("long");
        } else if (element.equals(int.class)) {
            b.add("int");
        } else if (element.equals(short.class)) {
            b.add("short");
        } else if (element.equals(byte.class)) {
            b.add("byte");
        } else if (element.equals(Instant.class)) {
            b.add("Timestamp");
        } else {
            throw new IllegalArgumentException("Column type " + element + " not supported");
        }
    }
    add(string, b);
    return this;
}

@Test
public void crud() {
    JsonArray allEntries = this.mainTarget.request(MediaType.APPLICATION_JSON).get(JsonArray.class);
    assertNotNull(allEntries);
    System.out.println("-- " + allEntries);
    final String createdUri = "http://localhost" + System.currentTimeMillis();
    //creation
    JsonObject newEntry = Json.createObjectBuilder().add("command", "everything").add("uri", createdUri).build();
    Response postResponse = this.mainTarget.request().post(Entity.entity(newEntry, MediaType.APPLICATION_JSON));
    assertThat(postResponse.getStatus(), is(201));
    List<Object> locationValues = postResponse.getHeaders().get("Location");
    assertThat(locationValues.size(), is(1));
    String uri = (String) locationValues.get(0);
    System.out.println("---------> " + uri);
    //fetch
    Response fetchResponse = this.client.target(uri).request(MediaType.APPLICATION_JSON).get(Response.class);
    assertThat(fetchResponse.getStatus(), is(200));
    JsonObject value = fetchResponse.readEntity(JsonObject.class);
    assertThat(value.getString("uri"), is(createdUri));
    long id = value.getJsonNumber("id").longValue();
    System.out.println("id --->" + id);
    //removal
    Response deleteResponse = this.mainTarget.path(String.valueOf(id)).request(MediaType.APPLICATION_JSON).delete();
    assertThat(deleteResponse.getStatus(), is(204));
    //empty fetch
    Response emptyFetchResponse = this.mainTarget.path(String.valueOf(id)).request(MediaType.APPLICATION_JSON).get(Response.class);
    assertThat(emptyFetchResponse.getStatus(), is(204));
}

public void marshalToObjectBuilderResult() throws Exception {
    JsonObjectBuilder jsonObjectBuilder = Json.createObjectBuilder();
    JsonObjectBuilderResult result = new JsonObjectBuilderResult(jsonObjectBuilder);
    jsonMarshaller.marshal(getWriteControlObject(), result);
    JsonObject jsonObject = jsonObjectBuilder.build();
    StringWriter sw = new StringWriter();
    JsonWriter writer = Json.createWriter(sw);
    writer.writeObject(jsonObject);
    writer.close();
    log(sw.toString());
    compareStringToControlFile("**testJSONMarshalToBuilderResult**", sw.toString());
}

@POST
@Path("/get")
public Response commandGet(String command) {
    try {
        final JsonObject jsonCommand = Json.createReader(new StringReader(command)).readObject();
        Item item = items.findItem(jsonCommand.getString("id"));
        BC.setId(jsonCommand.getString("id"));
        if (item != null) {
            String coords = Integer.toString(item.getCoorX()) + ";" + Integer.toString(item.getCoorY()) + ";" + Integer.toString(item.getDirection().ordinal());
            JsonObject order = Json.createObjectBuilder().add("command", "get").add("data", coords).build();
            BC.sendCommand(order.toString());
            return Response.ok(order).build();
        } else {
            return Response.ok(Status.BAD_REQUEST).build();
        }
    } catch (Exception e) {
        e.printStackTrace();
        return Response.ok(e.getStackTrace()).build();
    }
}

public static void javaxTest(JsonObject obj) {
    try (ByteArrayOutputStream oos = new ByteArrayOutputStream();
        JsonWriter writer = Json.createWriter(oos)) {
        writer.writeObject(obj);
        byte b[] = oos.toByteArray();
        try (ByteArrayInputStream bais = new ByteArrayInputStream(b)) {
            JsonReader reader = Json.createReader(bais);
            JsonObject jsonObject = reader.readObject();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

@Test
public void testTitleResponse() throws FileNotFoundException, IOException {
    InputStream is = new FileInputStream(new File(getClass().getResource("/solr/solrTitleResponse.json").getFile()));
    JsonReader reader = null;
    try {
        reader = Json.createReader(is);
        JsonObject obj = reader.readObject();
        JsonObject response = obj.getJsonObject("response");
        JsonArray result = response.getJsonArray("docs");
        int i = -1;
        for (JsonObject single : result.getValuesAs(JsonObject.class)) {
            i++;
            String title1 = single.getJsonArray("title").getString(0);
            String title2 = single.getJsonArray("title").getString(1);
            String doi = single.getJsonArray("doi").getString(0);
            switch(i) {
                case 0:
                    Assert.assertEquals("Studiensituation und studentische Orientierungen 2006/07 (Studierenden-Survey)", title1);
                    break;
                case 2:
                    Assert.assertEquals("College Situation and Student Orientations 1992/93", title2);
                    break;
                case 6:
                    Assert.assertEquals("10.4232/1.4344", doi);
                    break;
            }
        }
        Assert.assertEquals(11, i);
    } finally {
        reader.close();
        is.close();
    }
}

@javax.ws.rs.GET
public JsonObject method() {
    final JsonArray array = Json.createArrayBuilder().add(true).add("duke").build();
    return Json.createObjectBuilder().add("array", array).add("int", 42).add("boolean", true).add("long", 100000000000000L).add("double", 1.2d).add("jsonObject", Json.createObjectBuilder().add("key", "value").add("test", 1).build()).add("jsonArray", Json.createArrayBuilder().add("first").add("second").add(3d).add(Json.createObjectBuilder().add("key", "object").build()).add(Json.createObjectBuilder().add("nested", "object"))).build();
}

/**
   * Reads the {@code config.json} configuration file in the classpath and builds a
   * {@link MongoClientConfiguration} from it.
   * 
   * @return the {@link MongoClientConfiguration}
   * @throws IOException if a problem occurred when reading the config file
   */
@SuppressWarnings("static-method")
@Produces
@Default
public MongoClientConfiguration getMongoClientConfiguration() throws IOException {
    try (final InputStream jsonConfigFile = Thread.currentThread().getContextClassLoader().getResourceAsStream("config.json");
        final JsonReader reader = Json.createReader(jsonConfigFile)) {
        final JsonObject root = (JsonObject) reader.read();
        final String databaseName = ((JsonString) root.get("databaseName")).getString();
        LOGGER.debug("Database name: {}", databaseName);
        final MongoClientConfiguration mongoClientConfiguration = new MongoClientConfiguration(databaseName);
        return mongoClientConfiguration;
    }
}

public JsonObject toJson(Object object) {
    JsonObjectBuilder objectBuilder = Json.createObjectBuilder();
    Method methods[] = object.getClass().getDeclaredMethods();
    try {
        for (int i = 0; i < methods.length; i++) {
            String method = methods[i].getName();
            if (method.startsWith("get")) {
                Object result = methods[i].invoke(object);
                String property = method.replaceFirst("get", "");
                property = Character.toLowerCase(property.charAt(0)) + property.substring(1);
                if (methods[i].getReturnType().equals(List.class)) {
                    List resultList = (List) result;
                    JsonArrayBuilder arrayBuilder = Json.createArrayBuilder();
                    for (Object entry : resultList) {
                        if (entry instanceof String) {
                            arrayBuilder.add((String) entry);
                        } else {
                            JsonObject toJson = toJson(entry);
                            arrayBuilder.add(toJson);
                        }
                    }
                    objectBuilder.add(property, arrayBuilder.build());
                } else // for nicer JSON message
                if (result instanceof Double) {
                    objectBuilder.add(property, (double) result);
                } else if (result instanceof Integer) {
                    objectBuilder.add(property, (int) result);
                } else if (result instanceof Boolean) {
                    objectBuilder.add(property, (boolean) result);
                } else if (result instanceof Long) {
                    objectBuilder.add(property, (long) result);
                } else if (result instanceof Date) {
                    objectBuilder.add(property, ((Date) result).getTime());
                } else {
                    objectBuilder.add(property, "" + result);
                }
            }
        }
        return objectBuilder.build();
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

@Override
public ChatMessage decode(final String textMessage) throws DecodeException {
    ChatMessage chatMessage = new ChatMessage();
    JsonObject obj = Json.createReader(new StringReader(textMessage)).readObject();
    chatMessage.setMessage(obj.getString("message"));
    chatMessage.setSender(obj.getString("sender"));
    chatMessage.setReceived(new Date());
    return chatMessage;
}

@Test
public void testBuilder() {
    JsonBuilderFactory jsonFactory = Json.createBuilderFactory(null);
    JsonObjectBuilder json = NullAwareJsonObjectBuilder.wrap(jsonFactory.createObjectBuilder());
    json.addNull("null");
    json.add("nullValue", JsonValue.NULL);
    json.add("false", JsonValue.FALSE);
    String nullString = null;
    json.add("nullString", nullString);
    json.add("string", "String");
    BigInteger nullBigInt = null;
    json.add("nullBigInt", nullBigInt);
    json.add("big1", BigInteger.ONE);
    BigDecimal nullBigDec = null;
    json.add("nullBigDec", nullBigDec);
    json.add("big0.42", BigDecimal.valueOf(0.42));
    json.add("int", 42);
    json.add("long", 4200L);
    json.add("double", 42d);
    json.add("boolean", true);
    JsonArrayBuilder arrayBuilder = null;
    json.add("nullArray", arrayBuilder);
    arrayBuilder = jsonFactory.createArrayBuilder();
    JsonObjectBuilder jsonA = null;
    json.add("nullBuilder", jsonA);
    jsonA = NullAwareJsonObjectBuilder.wrap(jsonFactory.createObjectBuilder());
    JsonObject zero = null;
    json.add("nullObject", zero);
    zero = jsonA.add("zero", 0).build();
    arrayBuilder.add(zero);
    json.add("zeroArray", arrayBuilder);
    json.add("zeroObject", zero);
    JsonObject obj = json.build();
    assertEquals(JsonValue.NULL, obj.get("null"));
    assertEquals(JsonValue.NULL, obj.get("nullValue"));
    assertEquals(JsonValue.FALSE, obj.get("false"));
    assertEquals(JsonValue.NULL, obj.get("nullString"));
    assertEquals(JsonValue.ValueType.STRING, obj.get("string").getValueType());
    assertEquals("\"String\"", obj.get("string").toString());
    assertEquals(JsonValue.NULL, obj.get("nullBigInt"));
    assertEquals(JsonValue.ValueType.NUMBER, obj.get("big1").getValueType());
    assertEquals("1", obj.get("big1").toString());
    assertEquals(JsonValue.NULL, obj.get("nullBigDec"));
    assertEquals(JsonValue.ValueType.NUMBER, obj.get("big0.42").getValueType());
    assertEquals("0.42", obj.get("big0.42").toString());
    assertEquals(JsonValue.ValueType.NUMBER, obj.get("int").getValueType());
    assertEquals("42", obj.get("int").toString());
    assertEquals(JsonValue.ValueType.NUMBER, obj.get("long").getValueType());
    assertEquals("4200", obj.get("long").toString());
    assertEquals(JsonValue.ValueType.NUMBER, obj.get("double").getValueType());
    assertEquals("42.0", obj.get("double").toString());
    assertEquals(JsonValue.ValueType.TRUE, obj.get("boolean").getValueType());
    assertEquals("true", obj.get("boolean").toString());
    assertEquals(JsonValue.ValueType.ARRAY, obj.get("zeroArray").getValueType());
    assertEquals("[{\"zero\":0}]", obj.get("zeroArray").toString());
    assertEquals(JsonValue.ValueType.OBJECT, obj.get("zeroObject").getValueType());
    assertEquals("{\"zero\":0}", obj.get("zeroObject").toString());
    assertEquals(JsonValue.NULL, obj.get("nullArray"));
    assertEquals(JsonValue.NULL, obj.get("nullObject"));
    assertEquals(JsonValue.NULL, obj.get("nullBuilder"));
}

protected void callTerminalMethod(final String methodName, final Object... args) {
    final JsonObjectBuilder builder = Json.createObjectBuilder();
    builder.add(METHOD_PROPERTY_NAME, methodName);
    if (args.length > 0) {
        final JsonArrayBuilder arrayBuilder = Json.createArrayBuilder();
        for (final Object object : args) {
            if (object != null) {
                if (object instanceof JsonValue) {
                    arrayBuilder.add((JsonValue) object);
                } else if (object instanceof Number) {
                    final Number number = (Number) object;
                    if (object instanceof Byte || object instanceof Short || object instanceof Integer)
                        arrayBuilder.add(number.intValue());
                    else if (object instanceof Long)
                        arrayBuilder.add(number.longValue());
                    else if (object instanceof Float || object instanceof Double)
                        arrayBuilder.add(number.doubleValue());
                    else if (object instanceof BigInteger)
                        arrayBuilder.add((BigInteger) object);
                    else if (object instanceof BigDecimal)
                        arrayBuilder.add((BigDecimal) object);
                    else
                        arrayBuilder.add(number.doubleValue());
                } else if (object instanceof Boolean) {
                    arrayBuilder.add((Boolean) object);
                } else if (object instanceof JsonArrayBuilder) {
                    arrayBuilder.add(((JsonArrayBuilder) object).build());
                } else if (object instanceof JsonObjectBuilder) {
                    arrayBuilder.add(((JsonObjectBuilder) object).build());
                } else if (object instanceof Collection) {
                    throw new IllegalArgumentException("Collections are not supported for PAddOn, you need to convert it to JsonArray on primitive array");
                } else {
                    arrayBuilder.add(object.toString());
                }
            } else {
                arrayBuilder.addNull();
            }
        }
        builder.add(ARGUMENTS_PROPERTY_NAME, arrayBuilder);
    }
    saveUpdate( writer -> writer.write(ServerToClientModel.NATIVE, builder.build()));
}

@PUT
@Path("{listid}")
@Consumes(MediaType.APPLICATION_JSON)
public void updateList(@PathParam("listid") long id, InputStream in) {
    List list = em.find(List.class, id);
    if (list == null) {
        throw new NotFoundException();
    }
    // Only admins can update other user's lists.
    if (!list.getOwner().getUsername().equals(context.getUserPrincipal().getName()) && !context.isUserInRole(Role.ADMINISTRATOR.name())) {
        throw new ForbiddenException();
    }
    em.detach(list);
    try {
        JsonObject update = Json.createReader(in).readObject();
        if (update.containsKey("title")) {
            list.setTitle(update.getString("title"));
        }
        if (update.containsKey("owner")) {
            User newOwner = em.find(User.class, update.getString("owner"));
            if (newOwner == null) {
                throw new NotFoundException();
            }
            // Only admins can change the owner of a list.
            if (!newOwner.equals(list.getOwner()) && !context.isUserInRole(Role.ADMINISTRATOR.name())) {
                throw new ForbiddenException();
            } else {
                list.setOwner(newOwner);
            }
        }
    } catch (JsonExceptionClassCastException |  ex) {
        throw new BadRequestException("JSON");
    }
    Set<ConstraintViolation<List>> violations = validator.validate(list);
    if (!violations.isEmpty()) {
        throw new BadRequestException(mergeMessages(violations));
    }
    em.merge(list);
}

protected JsonReader findReader(MediaType mediaType, InputStream is) {
    ContextResolver<JsonReaderFactory> resolver = providers.getContextResolver(JsonReaderFactory.class, mediaType);
    JsonReaderFactory factory = null;
    if (resolver != null) {
        factory = resolver.getContext(JsonReaderFactory.class);
    }
    if (factory == null) {
        factory = Json.createReaderFactory(null);
    }
    Charset charset = getCharset(mediaType);
    return charset == null ? factory.createReader(is) : factory.createReader(is, charset);
}

@Test
public void testPost() {
    Assume.assumeTrue(databaseConfigured);
    String url = contextRoot + testDatabase;
    System.out.println("Testing " + url);
    JsonObject data = Json.createObjectBuilder().add("weather", "sunny").build();
    String dataString = data.toString();
    Entity<String> ent = Entity.entity(dataString, MediaType.APPLICATION_JSON);
    Response response = sendRequest(url, RequestType.POST, ent);
    String responseString = response.readEntity(String.class);
    int responseCode = response.getStatus();
    response.close();
    System.out.println("Returned " + responseString);
    assertTrue("Incorrect response code: " + responseCode + " Response string is " + responseString, responseCode == 200);
}

@GET
@Produces(MediaType.APPLICATION_JSON)
public Response touch() {
    return Response.ok().entity(new StreamingOutput() {

        @Override
        public void write(final OutputStream os) throws IOException, WebApplicationException {
            try (final JsonGenerator jg = Json.createGenerator(os)) {
                // in real life use the factory
                jg.writeStartArray();
                // simple for the assert
                jg.writeStartObject().write("id", 1).writeEnd();
                jg.writeEnd().close();
            }
        }
    }).type(MediaType.APPLICATION_JSON).build();
}

public static String dicomJsonContent(File dicomFile) {
    String dicomJsonString = "";
    try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DicomInputStream dis = new DicomInputStream(dicomFile)) {
        IncludeBulkData includeBulkData = IncludeBulkData.URI;
        dis.setIncludeBulkData(includeBulkData);
        JsonGenerator jsonGen = Json.createGenerator(baos);
        JSONWriter jsonWriter = new JSONWriter(jsonGen);
        dis.setDicomInputHandler(jsonWriter);
        dis.readDataset(-1, -1);
        jsonGen.flush();
        dicomJsonString = new String(baos.toByteArray(), "UTF-8");
    } catch (Exception e) {
        System.out.println("error processing dicom: " + e.getMessage());
    }
    return dicomJsonString;
}

@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    JsonReader reader = Json.createReader(request.getInputStream());
    try {
        JsonObject object = reader.readObject();
        dispatch(object);
    } catch (JsonParsingException t) {
        log("JSON parsing error", t);
    }
    // TODO: Use HttpServletResponse.SC_OK instead.
    response.setStatus(HttpServletResponse.SC_NO_CONTENT);
    // TODO: Return a result page.
    response.getWriter().close();
}

@Test
public void testJson() throws Exception {
    if (!TestUtil.configuredToRun(RUN_CLUSTER_TEST)) {
        throw new SkipException(String.format("%s property not set", RUN_CLUSTER_TEST));
    }
    for (Properties testProps : testPropList) {
        Collector collector = new Collector(testProps);
        final String host = testProps.getProperty(Collector.DB_HOST_PROP);
        final int port = Integer.parseInt(testProps.getProperty(Collector.DB_PORT_PROP));
        String json = collector.makeMetrics(collector.getMongoData(host, port)).toString();
        try {
            JsonParser p = Json.createParser(new StringReader(json));
            while (p.hasNext()) {
                p.next();
            }
            p.close();
        } catch (Exception ex) {
            fail("JSON parse exception", ex);
        }
    }
}

public static JsonObject invokeMBeanOperation(String name, Object[] params, String[] signature) throws Exception {
    try (JMXConnector connector = getConnector(JMX_CONNECTION_URL)) {
        MBeanServerConnection connection = connector.getMBeanServerConnection();
        ObjectInstance mBeanInstance = getProbeMBeanInstance(connection);
        Object o = connection.invoke(mBeanInstance.getObjectName(), name, params, signature);
        CharArrayReader arrayReader = new CharArrayReader(o.toString().toCharArray());
        JsonReader reader = Json.createReader(arrayReader);
        return reader.readObject();
    }
}

public static String metricsToString(Long timestamp, Map<String, Long> counters, Map<String, Double> gauges) {
    JsonObjectBuilder builder = Json.createObjectBuilder();
    if (!counters.isEmpty()) {
        builder.add("counters", metricsJson(timestamp, counters, HawkularJson::longDataPoint));
    }
    if (!gauges.isEmpty()) {
        builder.add("gauges", metricsJson(timestamp, gauges, HawkularJson::doubleDataPoint));
    }
    return builder.build().toString();
}

@Test
public void invokeEndpointChangeProjectTaskStatus() throws Exception {
    Project proj1 = createProjectAndTasks(3);
    service.saveProject(proj1);
    assertFalse(proj1.getTasks().get(0).isCompleted());
    StringWriter swriter = new StringWriter();
    JsonGenerator generator = Json.createGenerator(swriter);
    generator.writeStartObject().write("projectId", proj1.getId()).write("taskId", proj1.getTasks().get(0).getId()).write("completed", true).writeEnd().close();
    System.out.printf("****  SENDING JSON OVER TO WEBSOCKET ****\n" + ">>>>  swriter=%s\n", swriter.toString());
    System.out.printf("****  START  ****\n");
    URI uri = URI.create("ws://localhost:8181/xentracker/update-task-status");
    System.out.printf("uri=%s\n", uri);
    WebSocketClientTesterEndpoint client = new WebSocketClientTesterEndpoint(uri.toString(), swriter.toString());
    client.makeConnection();
    System.out.printf("****  WAIT   ****\n");
    String text = client.getReceivedMessage(3000);
    //        assertEquals("ECHO: "+message,actual);
    System.out.printf(">>>> text=%s\n", text);
    assertNotNull(text);
    List<Project> projects = service.findProjectById(proj1.getId());
    assertTrue(projects.get(0).getTasks().get(0).isCompleted());
    assertEquals("OK", text);
    System.out.printf("****  DONE   ****\n");
}

@Override
public MyObject readFrom(Class<MyObject> type, Type type1, Annotation[] antns, MediaType mt, MultivaluedMap<String, String> mm, InputStream in) throws IOException, WebApplicationException {
    MyObject mo = new MyObject();
    JsonParser parser = Json.createParser(in);
    while (parser.hasNext()) {
        switch(parser.next()) {
            case KEY_NAME:
                String key = parser.getString();
                parser.next();
                switch(key) {
                    case "name":
                        mo.setName(parser.getString());
                        break;
                    case "age":
                        mo.setAge(parser.getInt());
                        break;
                    default:
                        break;
                }
                break;
            default:
                break;
        }
    }
    return mo;
}

/**
	 * Answer a JSON representation of the domain model
	 * @return
	 */
public String getDomainModel() {
    DomainModel model = ((IIntDomainAccess) this.domainAccess).getInternalDomainAccess().getDomainModel();
    StringWriter sw = new StringWriter();
    JsonGenerator generator;
    if (this.prettyFormat != Format.NONE) {
        JsonGeneratorFactory gf = JSONWriter.getPrettyGeneratorFactory();
        generator = gf.createGenerator(sw);
    } else
        generator = Json.createGenerator(sw);
    generator.writeStartObject();
    generator.write("domainName", model.getDomainName());
    writeModel(model, generator);
    generator.writeEnd();
    generator.flush();
    return sw.toString();
}

@GET
@Path("/all")
@Produces({ MediaType.APPLICATION_JSON })
public JsonArray getAll() {
    JsonArrayBuilder jsonArrayBuilder = Json.createArrayBuilder();
    JsonObject jsonStudentObject;
    JsonObject jsonClassRoomObject;
    Student student;
    ClassRoom classRoom;
    for (int i = 1; i <= 100; i++) {
        student = new Student();
        classRoom = new ClassRoom(i, "classRoom" + i);
        student.setSid(i);
        student.setName("student" + i);
        student.setDate(Calendar.getInstance().getTime());
        student.setClassRoom(classRoom);
        jsonClassRoomObject = Json.createObjectBuilder().add("cid", student.getClassRoom().getCid()).add("cname", student.getClassRoom().getName()).build();
        jsonStudentObject = Json.createObjectBuilder().add("sid", student.getSid()).add("sname", student.getName()).add("date", new SimpleDateFormat().format(student.getDate())).add("classroom", jsonClassRoomObject).build();
        jsonArrayBuilder.add(jsonStudentObject);
    }
    return jsonArrayBuilder.build();
}

/**
     * Method generates json from the current filter's model state.
     *
     * @return encoded json which describes current filter's state
     */
public JsonObject encodeJson() {
    JsonObjectBuilder jsonBuilder = Json.createObjectBuilder();
    for (Entry<String, Value<?>> entry : params.entrySet()) {
        Object value = entry.getValue().getValue();
        if (value instanceof String) {
            jsonBuilder.add(entry.getKey(), Json.createObjectBuilder().add("value", (String) value).build());
        }
        if (value instanceof Boolean) {
            jsonBuilder.add(entry.getKey(), Json.createObjectBuilder().add("value", (Boolean) value).build());
        }
        if (value instanceof Number) {
            if (value instanceof Double) {
                jsonBuilder.add(entry.getKey(), Json.createObjectBuilder().add("value", (Double) value).build());
            } else if (value instanceof Integer) {
                jsonBuilder.add(entry.getKey(), Json.createObjectBuilder().add("value", (Integer) value).build());
            }
        }
        if (value instanceof Color) {
            jsonBuilder.add(entry.getKey(), Json.createObjectBuilder().add("value", Json.createObjectBuilder().add("red", ((Color) value).getRed()).add("green", ((Color) value).getGreen()).add("blue", ((Color) value).getBlue()).build()).build());
        }
    }
    return jsonBuilder.build();
}

private void addMeta(JsonObjectBuilder objb, String method, String uri, String... properties) {
    JsonObjectBuilder objBuilder = Json.createObjectBuilder();
    String propStr = this.propertiesBuilder(properties);
    if (propStr != null) {
        objBuilder.add("properties", propStr);
    }
    if (method != null && !method.isEmpty()) {
        objBuilder.add("method", method);
    }
    if (uri != null && !uri.isEmpty()) {
        objBuilder.add("uri", uri);
    }
    JsonObject objMeta = objBuilder.build();
    if (!objMeta.isEmpty()) {
        objb.add("_meta", objMeta);
    }
    this.bulkArray.add(objb.build());
}

@Test
public void testBuildMetricsObject() {
    final Map<String, ?> config = Collections.emptyMap();
    final JsonBuilderFactory factory = Json.createBuilderFactory(config);
    final String instanceId = "1234-5678-1234-5678";
    final String applicationId = "NIFI";
    final String hostname = "localhost";
    final long timestamp = System.currentTimeMillis();
    final Map<String, String> metrics = new HashMap<>();
    metrics.put("a", "1");
    metrics.put("b", "2");
    final MetricsBuilder metricsBuilder = new MetricsBuilder(factory);
    final JsonObject metricsObject = metricsBuilder.applicationId(applicationId).instanceId(instanceId).hostname(hostname).timestamp(timestamp).addAllMetrics(metrics).build();
    final JsonArray metricsArray = metricsObject.getJsonArray("metrics");
    Assert.assertNotNull(metricsArray);
    Assert.assertEquals(2, metricsArray.size());
    JsonObject firstMetric = metricsArray.getJsonObject(0);
    if (!"a".equals(firstMetric.getString(MetricFields.METRIC_NAME))) {
        firstMetric = metricsArray.getJsonObject(1);
    }
    Assert.assertEquals("a", firstMetric.getString(MetricFields.METRIC_NAME));
    Assert.assertEquals(applicationId, firstMetric.getString(MetricFields.APP_ID));
    Assert.assertEquals(instanceId, firstMetric.getString(MetricFields.INSTANCE_ID));
    Assert.assertEquals(hostname, firstMetric.getString(MetricFields.HOSTNAME));
    Assert.assertEquals(String.valueOf(timestamp), firstMetric.getString(MetricFields.TIMESTAMP));
    final JsonObject firstMetricValues = firstMetric.getJsonObject("metrics");
    Assert.assertEquals("1", firstMetricValues.getString("" + timestamp));
}

public static void createProfile(File mcDir, String version, String name, File instanceDir) throws FileNotFoundException, UnsupportedEncodingException {
    File json = new File(mcDir, "launcher_profiles.json");
    if (json.exists()) {
        JsonReader reader = Json.createReader(new FileReader(json));
        JsonObject file = reader.readObject();
        reader.close();
        JsonObject profiles = file.getJsonObject("profiles");
        if (!profiles.containsKey(name)) {
            JsonObject newProfile = Json.createObjectBuilder().add("name", name).add("gameDir", instanceDir.toString()).add("lastVersionId", version).add("launcherVisibilityOnGameClose", "keep the launcher open").build();
            JsonObjectBuilder objectBuilder = Json.createObjectBuilder().add("profiles", newProfile);
            for (java.util.Map.Entry<String, JsonValue> entry : profiles.entrySet()) objectBuilder.add(entry.getKey(), entry.getValue());
            objectBuilder.add("selectedProfile", name);
            if (file.getJsonString("clientToken") != null) {
                objectBuilder.add("clientToken", file.getJsonString("clientToken"));
            }
            if (!file.getJsonObject("authenticationDatabase").isEmpty()) {
                objectBuilder.add("authenticationDatabase", file.getJsonObject("authenticationDatabase"));
            }
            if (file.getJsonString("selectedUser") != null) {
                objectBuilder.add("selectedUser", file.getJsonString("selectedUser"));
            }
            JsonObject newProfiles = objectBuilder.build();
            try {
                JsonWriter writer = null;
                writer = Json.createWriter(new FileWriter(json));
                writer.writeObject(newProfiles);
                System.out.println(newProfiles.toString());
                System.out.println();
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    } else {
        PrintWriter writer = new PrintWriter(json, "UTF-8");
        writer.println("{");
        writer.println("  \"profiles\": {");
        writer.println("      \"" + name + "\": {");
        writer.println("      \"name\": \"" + name + "\",");
        writer.println("      \"gameDir\": \"/Users/mark/Documents/GitHub/OpenLauncher-StandAlone/OpenLauncher/instances/" + name + "\",");
        writer.println("      \"lastVersionId\": \"" + version + "\",");
        writer.println("      \"javaArgs\": \"-Xmx1G -XX:+UseConcMarkSweepGC -XX:+CMSIncrementalMode -XX:-UseAdaptiveSizePolicy -Xmn128M -XX:MaxPermSize=256M\",");
        writer.println("      \"resolution\": {");
        writer.println("        \"width\": 854,");
        writer.println("        \"height\": 480");
        writer.println("      },");
        writer.println("      \"useHopperCrashService\": false");
        writer.println("    }");
        writer.println("  },");
        writer.println("  \"selectedProfile\": \"" + name + "\"");
        writer.println("}");
        writer.close();
        System.out.println("Created a new profile!");
    }
}

public String serializeStatistics(Statistics statistics) {
    JsonObjectBuilder stats = Json.createObjectBuilder();
    stats.add("pipelineName", statistics.getPipelineName());
    final String handlerName = statistics.getRejectedExecutionHandlerName();
    if (handlerName != null) {
        stats.add("rejectedExecutionHandlerName", handlerName);
    }
    stats.add("activeThreadCount", statistics.getActiveThreadCount());
    stats.add("completedTaskCount", statistics.getCompletedTaskCount());
    stats.add("corePoolSize", statistics.getCorePoolSize());
    stats.add("currentThreadPoolSize", statistics.getCurrentThreadPoolSize());
    stats.add("largestThreadPoolSize", statistics.getLargestThreadPoolSize());
    stats.add("maximumPoolSize", statistics.getMaximumPoolSize());
    stats.add("rejectedTasks", statistics.getRejectedTasks());
    stats.add("remainingQueueCapacity", statistics.getRemainingQueueCapacity());
    stats.add("minQueueCapacity", statistics.getMinQueueCapacity());
    stats.add("totalNumberOfTasks", statistics.getTotalNumberOfTasks());
    StringWriter writer = new StringWriter();
    try (JsonWriter outputWriter = Json.createWriter(writer)) {
        outputWriter.writeObject(stats.build());
    }
    return writer.toString();
}

private String assembleFields() {
    JsonObjectBuilder model = Json.createObjectBuilder().add("source_node", getSourceNode());
    Iterator<Integer> it = target_nodes.iterator();
    JsonArrayBuilder targets = Json.createArrayBuilder();
    while (it.hasNext()) {
        targets.add(it.next());
    }
    // requirement for ordered list
    targets.addNull();
    model.add("target_nodes", targets);
    Iterator<Double> dt = weight.iterator();
    JsonArrayBuilder w = Json.createArrayBuilder();
    while (dt.hasNext()) {
        w.add(dt.next());
    }
    w.addNull();
    model.add("weight", w);
    return model.build().toString();
}

@Override
public void run(Race.Registration registration) throws Exception {
    // 1. build an object with nested structure
    JsonObject jsonObject = Json.createObjectBuilder().add(// simple pairs
    "firstName", "John").add("lastName", "Smith").add("age", 25).add(// nested object
    "address", Json.createObjectBuilder().add("streetAddress", "21 2nd Street").add("city", "New York").add("state", "NY").add("postalCode", "10021")).add(// nested object array
    "phoneNumber", Json.createArrayBuilder().add(Json.createObjectBuilder().add("type", "home").add("number", "212 555-1234")).add(Json.createObjectBuilder().add("type", "fax").add("number", "646 555-4567"))).build();
    // 2. write the object to a string
    StringWriter stringWriter = new StringWriter();
    try (JsonWriter writer = Json.createWriter(stringWriter)) {
        writer.write(jsonObject);
    }
    String toString = stringWriter.toString();
    // 3. read object from the string
    JsonObject fromString = null;
    try (JsonReader jsonReader = Json.createReader(new StringReader(toString))) {
        fromString = jsonReader.readObject();
    }
    // 4. sanity check :)
    if (!jsonObject.equals(fromString)) {
        throw new IllegalStateException("json object read from string does not equal the one built");
    }
}

/**
     * Format body with proper indents.
     * @param body Response body
     * @return New properly formatted body
     * @throws IOException If fails
     */
private static byte[] transform(final InputStream body) throws IOException {
    final ByteArrayOutputStream res = new ByteArrayOutputStream();
    final JsonReader rdr = Json.createReader(body);
    try {
        final JsonObject obj = rdr.readObject();
        final JsonWriter wrt = Json.createWriterFactory(Collections.singletonMap(JsonGenerator.PRETTY_PRINTING, true)).createWriter(res);
        try {
            wrt.writeObject(obj);
        } finally {
            wrt.close();
        }
    } catch (final JsonException ex) {
        throw new IOException(ex);
    } finally {
        rdr.close();
    }
    return res.toByteArray();
}

@Override
protected Object decode(Channel channel, SocketAddress remoteAddress, Object msg) throws Exception {
    HttpRequest request = (HttpRequest) msg;
    JsonObject root = Json.createReader(new StringReader(request.getContent().toString(StandardCharsets.US_ASCII))).readObject();
    DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
    DeviceSession deviceSession = getDeviceSession(channel, remoteAddress, root.getString("IMEI"));
    if (deviceSession == null) {
        sendResponse(channel, HttpResponseStatus.BAD_REQUEST);
        return null;
    }
    List<Position> positions = new LinkedList<>();
    JsonArray records = root.getJsonArray("Records");
    for (int i = 0; i < records.size(); i++) {
        Position position = new Position();
        position.setProtocol(getProtocolName());
        position.setDeviceId(deviceSession.getDeviceId());
        JsonObject record = records.getJsonObject(i);
        position.set(Position.KEY_INDEX, record.getInt("SeqNo"));
        position.set(Position.KEY_EVENT, record.getInt("Reason"));
        position.setDeviceTime(dateFormat.parse(record.getString("DateUTC")));
        JsonArray fields = record.getJsonArray("Fields");
        for (int j = 0; j < fields.size(); j++) {
            JsonObject field = fields.getJsonObject(j);
            switch(field.getInt("FType")) {
                case 0:
                    position.setFixTime(dateFormat.parse(field.getString("GpsUTC")));
                    position.setLatitude(field.getJsonNumber("Lat").doubleValue());
                    position.setLongitude(field.getJsonNumber("Long").doubleValue());
                    position.setAltitude(field.getInt("Alt"));
                    position.setSpeed(UnitsConverter.knotsFromCps(field.getInt("Spd")));
                    position.setCourse(field.getInt("Head"));
                    position.setAccuracy(field.getInt("PosAcc"));
                    position.setValid(field.getInt("GpsStat") > 0);
                    break;
                case 2:
                    int input = field.getInt("DIn");
                    int output = field.getInt("DOut");
                    position.set(Position.KEY_IGNITION, BitUtil.check(input, 0));
                    position.set(Position.KEY_INPUT, input);
                    position.set(Position.KEY_OUTPUT, output);
                    position.set(Position.KEY_STATUS, field.getInt("DevStat"));
                    break;
                case 6:
                    JsonObject adc = field.getJsonObject("AnalogueData");
                    if (adc.containsKey("1")) {
                        position.set(Position.KEY_BATTERY, adc.getInt("1") * 0.001);
                    }
                    if (adc.containsKey("2")) {
                        position.set(Position.KEY_POWER, adc.getInt("2") * 0.01);
                    }
                    if (adc.containsKey("3")) {
                        position.set(Position.KEY_DEVICE_TEMP, adc.getInt("3") * 0.01);
                    }
                    if (adc.containsKey("4")) {
                        position.set(Position.KEY_RSSI, adc.getInt("4"));
                    }
                    if (adc.containsKey("5")) {
                        position.set("solarPower", adc.getInt("5") * 0.001);
                    }
                    break;
                default:
                    break;
            }
        }
        positions.add(position);
    }
    sendResponse(channel, HttpResponseStatus.OK);
    return positions;
}

private synchronized boolean readConfig() {
    File cfgFile = new File(this.myperfSnmpConfigPath);
    if (!cfgFile.exists()) {
        logger.info("There is no customized snmp configuration file");
        return true;
    }
    FileInputStream in = null;
    try {
        in = new FileInputStream(cfgFile);
        JsonReader jr = javax.json.Json.createReader(in);
        JsonObject jsonObject = jr.readObject();
        jr.close();
        this.setSiteSetting(readFromJson(jsonObject.getJsonObject("site")));
        JsonArray groups = jsonObject.getJsonArray("group");
        if (groups != null) {
            int len = groups.size();
            for (int i = 0; i < len; i++) {
                JsonObject grp = groups.getJsonObject(i);
                SNMPSetting grpSetting = readFromJson(grp);
                String grpName = grp.getString("dbgroup", null);
                if (grpName != null && grpSetting != null)
                    this.groupSettings.put(grpName, grpSetting);
            }
        }
        JsonArray hosts = jsonObject.getJsonArray("host");
        if (hosts != null) {
            int len = hosts.size();
            for (int i = 0; i < len; i++) {
                JsonObject host = hosts.getJsonObject(i);
                SNMPSetting hostSetting = readFromJson(host);
                String hostName = host.getString("dbhost", null);
                if (hostName != null && hostSetting != null)
                    this.hostSettings.put(hostName, hostSetting);
            }
        }
        return true;
    } catch (Exception ex) {
        logger.log(Level.SEVERE, "Failed to read SNMP configuration file " + cfgFile.getAbsolutePath(), ex);
    } finally {
        if (in != null) {
            try {
                in.close();
            } catch (Exception fex) {
            }
            ;
        }
    }
    return false;
}

@Override
public void load(ActionEvent... actionEvent) {
    fadeOut(infoLabel, "Loading...");
    loadPathDefaults();
    Reader fileReader = IOHelper.fileReader(getConfigPath());
    JsonReader jsonReader = Json.createReader(fileReader);
    JsonObject jsonObject = jsonReader.readObject();
    String stylesheetDefault = jsonObject.getString("stylesheetDefault", null);
    String stylesheetOverrides = jsonObject.getString("stylesheetOverrides", null);
    String mathjax = jsonObject.getString("mathjax", null);
    String kindlegen = jsonObject.getString("kindlegen", null);
    IOHelper.close(jsonReader, fileReader);
    threadService.runActionLater(() -> {
        if (Objects.nonNull(stylesheetDefault)) {
            this.setStylesheetDefault(stylesheetDefault);
        }
        if (Objects.nonNull(stylesheetOverrides)) {
            this.setStylesheetOverrides(stylesheetOverrides);
        }
        if (Objects.nonNull(mathjax)) {
            this.setMathjax(mathjax);
        }
        if (Objects.nonNull(kindlegen)) {
            this.setKindlegen(kindlegen);
        }
        fadeOut(infoLabel, "Loaded...");
    });
}

@Test
public void testParsing() throws IOException, URISyntaxException {
    byte[] result = Files.readAllBytes(Paths.get(TestPhmmerJob.class.getResource(RESULT_PATH).toURI()));
    PhmmerClient client = mock(PhmmerClient.class);
    JsonReader reader = Json.createReader(new ByteArrayInputStream(result));
    when(client.getResults(null, null)).thenReturn(reader.readObject());
    PhmmerJob job = new PhmmerJob(client, null, null);
    PhmmerResults results = job.runJob();
    assertEquals(116, results.getNumChains());
    String[] pdbIds = new String[] { "1cms", "3cms", "4aa9", "5pep", "1psn", "1flh", "1f34", "3pep", "2psg", "1tzs", "1am5", "1avf", "1qdm", "1smr", "3vcm", "1bil", "1bbs", "3d91", "2i4q", "1g0v", "2x0b", "2fs4", "1dp5", "1fq4", "1lya", "4obz", "1b5f", "1uh7", "2apr", "3qrv", "1me6", "2r9b", "1lf3", "1pfz", "3f9q", "1lee", "2bju", "3o9l", "2anl", "1qs8", "1miq", "1ls5", "3liz", "1yg9", "3fns", "3qvc", "1mpp", "2asi", "3fv3", "1lya", "4obz", "2h6s", "3o9l", "1zap", "3emy", "1eag", "4b1c", "1j71", "1apt", "1ibq", "2ewy", "3zkm", "3zkg", "4b70", "4b0q", "4b1d", "4ewo", "2fdp", "1sgz", "4fs4", "3u6a", "1fkn", "4dpf", "3kmx", "2qk5", "2of0", "3r1g", "1ym2", "3udh", "2zjn", "3ixk", "2hm1", "3dm6", "1ym4", "4l7g", "3hvg", "1w50", "2zhr", "4fsl", "2wjo", "3l58", "2zdz", "3vv6", "3bra", "3tpr", "2zjk", "4x7i", "2va5", "2hiz", "3lpi", "2q11", "2q15", "2zji", "2vie", "1tqf", "3qi1", "2qzl", "3exo", "3tpj", "2zjh", "2qzx", "2zjj", "1e5o", "1izd", "1wkr", "1b5f" };
    Set<String> pdbIdSet = new HashSet<>(Arrays.asList(pdbIds));
    assertEquals(pdbIdSet, results.getPdbIds());
    // values checked from http://www.ebi.ac.uk/Tools/hmmer/results/7B8EF2BA-5C4B-11E5-BB6E-2FF0D26C98AD/score
    Alignment a = results.getAlignments().get("3zkm").get("A");
    assertEquals("BETA-SECRETASE 2", a.getDescription());
    assertEquals("Homo sapiens", a.getSpecies());
    assertEquals(78.2, a.getScore(), 0.1);
    assertEquals(16, a.getQuerySequenceStart());
    assertEquals(227, a.getQuerySequenceEnd());
    assertEquals(9, a.getTargetEnvelopeStart());
    assertEquals(259, a.getTargetEnvelopeEnd());
    assertEquals(18, a.getTargetSequenceStart());
    assertEquals(240, a.getTargetSequenceEnd());
    assertEquals(0.75, a.getBias(), 0.01);
    assertEquals(0.78, a.getAccuracy(), 0.01);
    assertEquals(31.6, a.getIdentityPercent(), 0.1);
    assertEquals(67, a.getIdentityCount());
    assertEquals(57.1, a.getSimilarityPercent(), 0.1);
    assertEquals(121, a.getSimilarityCount());
    assertEquals(74.0, a.getBitScore(), 0.1);
    assertEquals(7.9e-21, a.getEValue(), 1e-22);
    assertEquals(1.5e-19, a.getEValueInd(), 1e-20);
    assertEquals(6.6e-23, a.getEValueCond(), 1e-24);
    assertEquals("yfgkiylgtppqeftvlfdtgssdfwvpsiycksnacknhqrfdprksstfqnlgkplsihygtgsmqgilgydtvtvsn" + "ivdiqqtvglstqepgdvft..yaefdgilgmaypslaseys.ip.vfdnmmnrhlvaqdlfsvymdrng........qe" + "smltlgaidpsyytgslhwvpvtvqqywqftvdsvtisgvvv..ace..ggcqaildtgtsklvgpss", a.getQuerySequence());
    assertEquals("y+ ++ +gtppq++ +l dtgss+f v               fd ++sst+++ g  +++ y  gs  g++g d vt+  " + "  +    v+++t   ++ f     +++gilg+ay +la   s +   fd+++ +     ++fs+ m   g          " + "  l lg i+ps y g + + p+  + y+q+ +  + i g  +   c   ++ +ai+d+gt+ l  p  ", a.getMatch());
    assertEquals("YYLEMLIGTPPQKLQILVDTGSSNFAVAGTPH----SYIDTYFDTERSSTYRSKGFDVTVKYTQGSWTGFVGEDLVTIPK" + "GFNTSFLVNIATIFESENFFlpGIKWNGILGLAYATLAKPSSsLEtFFDSLVTQAN-IPNVFSMQMCGAGlpvagsgtNG" + "GSLVLGGIEPSLYKGDIWYTPIKEEWYYQIEILKLEIGGQSLnlDCReyNADKAIVDSGTTLLRLPQK", a.getTargetSequence());
    assertEquals("888999*******************9976432....233467**************************************" + "**********9976665554114699***********9865425515677776655.46789888865441111111134" + "5899*********************************99764115643356789******98877765", a.getPosteriorProbability());
}

@Test
public void testPostComplexJsonObject() {
    final Response r = createWebClient("/bookstore/books").header("Content-Type", MediaType.APPLICATION_JSON).post(Json.createObjectBuilder().add("id", 1).add("name", "Book 1").add("chapters", Json.createArrayBuilder().add(Json.createObjectBuilder().add("id", 1).add("title", "Chapter 1")).add(Json.createObjectBuilder().add("id", 2).add("title", "Chapter 2"))).build());
    assertEquals(Status.CREATED.getStatusCode(), r.getStatus());
}

//http://data.bioontology.org/ontologies/EFO
@Transactional
public String getDiseaseDescription(String term) {
    String definition = "";
    // Reader reader = new StringReader(get(REST_URL + "/search?q=" + term+"&ontology={EFO,MeSH,OMIM}&exact_match=true"));
    Reader reader = new StringReader(get(REST_URL + "/search?q=" + term));
    JsonReader jsonReader = Json.createReader(reader);
    JsonObject jo = jsonReader.readObject();
    JsonArray jsonArray = jo.getJsonArray("collection");
    for (JsonObject obj : jsonArray.getValuesAs(JsonObject.class)) {
        for (Map.Entry<String, JsonValue> entry : obj.entrySet()) {
            if (entry.getKey().equalsIgnoreCase(DEFINITION)) {
                definition = entry.getValue().toString().replace("\"", "").replaceAll("\\[", "").replaceAll("\\]", "");
            }
        }
    }
    return definition;
}

private JsonGenerator newJsonGenerator(Options options) throws IOException {
    JsonGeneratorFactory jgf = Json.createGeneratorFactory(options.isCompactFormat() ? null : singletonMap(JsonGenerator.PRETTY_PRINTING, true));
    OutputStream output = options.getOutput() != null ? new BufferedOutputStream(new FileOutputStream(options.getOutput(), false)) : System.out;
    return jgf.createGenerator(output);
}

public static void main(String[] args) throws IOException, InterruptedException, FuseException {
    File configdir = new java.io.File(new java.io.File(System.getProperty("user.home")), ".gyingpan");
    configdir.mkdirs();
    File configfile = new java.io.File(configdir, "config.json");
    if (!configfile.exists()) {
        System.out.println("create config file");
        return;
    }
    logstream = new PrintStream(new BufferedOutputStream(new FileOutputStream(new java.io.File(configdir, "status.log"))));
    // lock
    final File lockfile = new File(configdir, "lock");
    final RandomAccessFile randomAccessLockFile = new RandomAccessFile(lockfile, "rw");
    fileLock = randomAccessLockFile.getChannel().tryLock();
    if (fileLock != null) {
        Runtime.getRuntime().addShutdownHook(new Thread() {

            public void run() {
                try {
                    fileLock.release();
                    randomAccessLockFile.close();
                    lockfile.delete();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    } else {
        JOptionPane.showMessageDialog(null, "Already running");
        return;
    }
    if (SystemTray.isSupported()) {
        Dimension dim = SystemTray.getSystemTray().getTrayIconSize();
        BufferedImage image = new BufferedImage(dim.width, dim.height, BufferedImage.TYPE_INT_ARGB);
        int step = 256 / dim.width;
        if (step < 1)
            step = 1;
        System.out.println("step " + step + " width " + dim.width);
        for (int x = 0; x < dim.width; x++) {
            int val = x * step;
            if (val > 255)
                val = 255;
            for (int y = 0; y < dim.height; y++) {
                image.setRGB(x, y, new Color(val, val, val).getRGB());
            }
        }
        final PopupMenu popup = new PopupMenu();
        final TrayIcon trayIcon = new TrayIcon(image);
        final SystemTray tray = SystemTray.getSystemTray();
        MenuItem exitItem = new MenuItem("Exit");
        statusLabel = new MenuItem("ready");
        popup.add(statusLabel);
        popup.add(exitItem);
        trayIcon.setPopupMenu(popup);
        exitItem.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                System.exit(0);
            }
        });
        try {
            tray.add(trayIcon);
        } catch (AWTException e) {
            System.out.println("TrayIcon could not be added.");
        }
    }
    JsonObject config = Json.createReader(new FileInputStream(configfile)).readObject();
    JsonArray accounts = config.getJsonArray("accounts");
    for (JsonObject account : accounts.getValuesAs(JsonObject.class)) {
        GDrive g = new GDrive(account.getString("name"));
        new FuseFS(g).mount(new File(account.getString("path")), false);
        System.out.println("after mount " + account.getString("name"));
    }
}

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    try {
        String fileName = req.getParameter("file");
        if (StringUtils.isEmpty(fileName)) {
            fileName = SWAGGER_FILE_NAME;
        }
        // Parse the api-docs.json file to get a JsonReader object
        JsonReader jsonReader = Json.createReader(new InputStreamReader(getServletContext().getResourceAsStream("/" + fileName)));
        JsonObject jsonSwaggerObject = jsonReader.readObject();
        jsonReader.close();
        // Build a JsonReader object with the basePath and the data from api-docs.json in order to write it to the response
        JsonObjectBuilder builder = Json.createObjectBuilder();
        for (Entry<String, JsonValue> entry : jsonSwaggerObject.entrySet()) {
            builder.add(entry.getKey(), entry.getValue());
        }
        builder.add("basePath", req.getContextPath() + "/" + irisUrlMapping);
        builder.add("host", req.getServerName() + ":" + req.getServerPort());
        JsonObject securityDefinitions = Json.createObjectBuilder().add("api_key", Json.createObjectBuilder().add("type", "apiKey").add("name", (null != apiKeyTokenName && !StringUtils.isEmpty(apiKeyTokenName)) ? apiKeyTokenName : "api_key").add("in", "header")).build();
        builder.add("securityDefinitions", securityDefinitions);
        JsonObject jsonFinalSwaggerObject = builder.build();
        JsonWriter jsonWriter = Json.createWriter(resp.getOutputStream());
        jsonWriter.writeObject(jsonFinalSwaggerObject);
        jsonWriter.close();
    } catch (IOException e) {
        throw new ServletException(e);
    }
}

@Override
public MyObject readFrom(Class<MyObject> type, Type type1, Annotation[] antns, MediaType mt, MultivaluedMap<String, String> mm, InputStream in) throws IOException, WebApplicationException {
    MyObject mo = new MyObject();
    JsonParser parser = Json.createParser(in);
    while (parser.hasNext()) {
        switch(parser.next()) {
            case KEY_NAME:
                String key = parser.getString();
                parser.next();
                switch(key) {
                    case "name":
                        mo.setName(parser.getString());
                        break;
                    case "age":
                        mo.setAge(parser.getInt());
                        break;
                    default:
                        break;
                }
                break;
            default:
                break;
        }
    }
    return mo;
}

public JsonObject getById(Integer labId) {
    try {
        //            return Json.createReader(new StringReader(workspace.getJson())).readObject();
        throw new UnsupportedOperationException();
    } catch (NoResultException ex) {
        return Json.createObjectBuilder().add("output", "no workspace available").build();
    }
}

@Test
public void testJsonObject() throws Exception {
    final ResourceConfig resourceConfig = new ResourceConfig(Resource.class);
    final HttpServer server = GrizzlyHttpServerFactory.createHttpServer(baseUri, resourceConfig);
    final JsonObject jsonObject = Json.createObjectBuilder().add("foo", "bar").build();
    final Client client = ClientBuilder.newClient();
    final JsonObject entity = client.target(baseUri).request(MediaType.APPLICATION_JSON_TYPE).post(Entity.json(jsonObject), JsonObject.class);
    System.out.println("RESULT = " + entity);
    assertEquals(jsonObject, entity);
    server.shutdownNow();
}

/**
     * Checks that popular tags are known (i.e included in internal presets, or deprecated, or explicitely ignored)
     * @throws SAXException if any XML parsing error occurs
     * @throws IOException if any I/O error occurs
     * @throws ParseException if any MapCSS parsing error occurs
     */
@Test
public void testCheckPopularTags() throws SAXException, IOException, ParseException {
    TaggingPresets.readFromPreferences();
    new TagChecker().initialize();
    MapCSSTagChecker mapCssTagChecker = new MapCSSTagChecker();
    mapCssTagChecker.addMapCSS("resource://data/validator/deprecated.mapcss");
    List<String> errors = new ArrayList<>();
    try (InputStream in = HttpClient.create(new URL("https://taginfo.openstreetmap.org/api/4/tags/popular")).connect().getContent();
        JsonReader reader = Json.createReader(in)) {
        for (JsonValue item : reader.readObject().getJsonArray("data")) {
            JsonObject obj = (JsonObject) item;
            // Only consider tags with wiki pages
            if (obj.getInt("in_wiki") == 1) {
                String key = obj.getString("key");
                String value = obj.getString("value");
                System.out.print("Checking " + key + "=" + value + " ... ");
                boolean ok = true;
                // Check if tag is in internal presets
                if (!TagChecker.isTagInPresets(key, value)) {
                    // If not, check if we have either a deprecated mapcss test for it
                    Node n = new Node();
                    Way w = new Way();
                    Relation r = new Relation();
                    n.put(key, value);
                    w.put(key, value);
                    r.put(key, value);
                    if (mapCssTagChecker.getErrorsForPrimitive(n, false).isEmpty() && mapCssTagChecker.getErrorsForPrimitive(w, false).isEmpty() && mapCssTagChecker.getErrorsForPrimitive(r, false).isEmpty()) {
                        // Or a legacy tagchecker ignore rule
                        if (!TagChecker.isTagIgnored(key, value)) {
                            ok = !errors.add(key + "=" + value + " - " + obj.getInt("count_all"));
                        }
                    }
                }
                System.out.println(ok ? "OK" : "KO");
            }
        }
    }
    for (String error : errors) {
        System.err.println(error);
    }
    assertTrue(errors.toString(), errors.isEmpty());
}

@Parameters(name = "{index}: ({0})={1}")
public static Iterable<Object[]> data() throws Exception {
    rfc6901Example = JsonPointerTest.readRfc6901Example();
    return Arrays.asList(new Object[][] { { Json.createPointer(""), rfc6901Example, null }, { Json.createPointer("/foo"), rfc6901Example.getJsonArray("foo"), null }, { Json.createPointer("/foo/0"), rfc6901Example.getJsonArray("foo").get(0), null }, { Json.createPointer("/foo/5"), null, JsonException.class }, { Json.createPointer("/p/1"), null, JsonException.class }, { Json.createPointer("/"), rfc6901Example.getJsonNumber(""), null }, { Json.createPointer("/a~1b"), rfc6901Example.getJsonNumber("a/b"), null }, { Json.createPointer("/m~0n"), rfc6901Example.getJsonNumber("m~n"), null }, { Json.createPointer("/c%d"), rfc6901Example.getJsonNumber("c%d"), null }, { Json.createPointer("/e^f"), rfc6901Example.getJsonNumber("e^f"), null }, { Json.createPointer("/g|h"), rfc6901Example.getJsonNumber("g|h"), null }, { Json.createPointer("/i\\j"), rfc6901Example.getJsonNumber("i\\j"), null }, { Json.createPointer("/k\"l"), rfc6901Example.getJsonNumber("k\"l"), null }, { Json.createPointer("/ "), rfc6901Example.getJsonNumber(" "), null }, { Json.createPointer("/notexists"), null, JsonException.class }, { Json.createPointer("/s/t"), null, JsonException.class }, { Json.createPointer("/o"), JsonObject.NULL, null } });
}

public JsonObject toJSON() {
    JsonBuilderFactory f = Json.createBuilderFactory(null);
    JsonObjectBuilder json = f.createObjectBuilder();
    if (name != null)
        json.add("name", name);
    if (type != null)
        json.add("script_type", type);
    if (loadScript != null)
        json.add("load_script", loadScript);
    if (created != null)
        json.add("created", DateUtils.toIso8601(created));
    if (updated != null)
        json.add("updated", DateUtils.toIso8601(updated));
    if (dataStores != null && !dataStores.isEmpty()) {
        JsonArrayBuilder dataStoresJson = f.createArrayBuilder();
        for (int d : dataStores) {
            dataStoresJson.add(d);
        }
        json.add("data_stores", dataStoresJson);
    }
    return json.build();
}

/**
     * <p>
     * 未定義�データを�定���
     * �定出���場��型�UndefeatedData��
     * </p>
     * 
     * @param plaindata
     * @return
     */
public final Data toDefinedData() {
    if (this.response.length != 0) {
        DataType type = DataType.TYPEMAP.get(this.url);
        if (type != null) {
            try {
                // リクエスト�フィールドを復����
                Map<String, String> field = null;
                if (this.request != null) {
                    field = getQueryMap(URLDecoder.decode(new String(this.request).trim(), "UTF-8"));
                }
                // レス�ンス�JSONを復����
                InputStream stream = new ByteArrayInputStream(this.response);
                if ((this.response[0] == (byte) 0x1f) && (this.response[1] == (byte) 0x8b)) {
                    // レス�ンス�先頭2�イト�0x1f, 0x8b��れ�gzip圧縮�れ��る
                    stream = new GZIPInputStream(stream);
                }
                // レス�ンスボディ�JSON�svdata=�ら始�る��除去���
                int read;
                while (((read = stream.read()) != -1) && (read != '=')) {
                }
                JsonReader jsonreader = Json.createReader(stream);
                JsonObject json = jsonreader.readObject();
                return new ActionData(type, this.date, json, field);
            } catch (Exception e) {
                return this;
            }
        }
    }
    return this;
}

public List<NameValuePair> parse(byte[] data) {
    List<NameValuePair> formElements = new ArrayList<NameValuePair>();
    JsonReader reader = Json.createReader(new StringReader(new String(data)));
    JsonObject object = reader.readObject();
    for (String key : object.keySet()) {
        //JsonValue value = object.get(key);
        if (object.get(key).getValueType() == ValueType.ARRAY) {
            JsonArray values = object.getJsonArray(key);
            for (int i = 0; i < values.size(); i++) {
                formElements.add(new BasicNameValuePair(key, values.getString(i)));
            }
        //					value
        } else {
            formElements.add(new BasicNameValuePair(key, object.getString(key)));
        }
    }
    return formElements;
//			return URLEncodedUtils.parse(new String(data), Charset.forName("UTF-8"));
}

public JsonObject processInput(String input) {
    ByteArrayInputStream byteInStream = new ByteArrayInputStream(input.getBytes());
    JsonReader jsonReader = Json.createReader(byteInStream);
    JsonObject ob = jsonReader.readObject();
    PieLogger.info(this.getClass(), String.format("ConnectionText: %s", ob.toString()));
    return ob;
}

private boolean isJsonResult(String response) {
    logger.info(response);
    JsonReader jsonReader = Json.createReader(new StringReader(response));
    JsonObject json = jsonReader.readObject();
    JsonArray table = json.getJsonObject("query").getJsonObject("results").getJsonArray("table");
    JsonObject firstResult = table.getJsonObject(0);
    return firstResult.getString("security").equals("APP") && firstResult.getString("content").equals("appdb.application");
}

@SuppressWarnings("unchecked")
public static JsonObject toJson(Map<String, Object> map) {
    JsonObjectBuilder builder = Json.createObjectBuilder();
    for (Map.Entry<String, Object> entry : map.entrySet()) {
        if (entry.getValue() instanceof Map) {
            builder.add(entry.getKey(), toJson((Map<String, Object>) entry.getValue()));
        } else if (entry.getValue() instanceof List) {
            JsonArrayBuilder array = Json.createArrayBuilder();
            for (String value : (List<String>) entry.getValue()) {
                array.add(value);
            }
            builder.add(entry.getKey(), array.build());
        } else {
            builder.add(entry.getKey(), (String) entry.getValue());
        }
    }
    return builder.build();
}

@Test
public void testObjectValue() throws IOException {
    StringWriter writer = new StringWriter();
    JsonProcessingStreamTarget target = new JsonProcessingStreamTarget(Json.createGenerator(writer));
    target.startObject();
    target.name("alice");
    target.value("bob");
    target.endObject();
    target.close();
    Assert.assertEquals("{\"alice\":\"bob\"}", writer.toString());
}

/**
   * Handles the HTTP <code>GET</code> method.
   *
   * @param request servlet request
   * @param response servlet response
   * @throws ServletException if a servlet-specific error occurs
   * @throws IOException if an I/O error occurs
   */
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    /*
     Firstly, set the Content-type header to the right value
     */
    response.setContentType("application/json;charset=UTF-8");
    /*
     Secondly, build a JSON object with a "fluent" API
     */
    JsonObjectBuilder builder = Json.createObjectBuilder().add("people", Json.createArrayBuilder());
    JsonArrayBuilder arrayBuilder = Json.createArrayBuilder();
    int numberOfPeople = 2 + (int) (Math.random() * 5);
    for (int i = 0; i < numberOfPeople; i++) {
        arrayBuilder.add(Json.createObjectBuilder().add("firstName", Chance.randomFirstName()).add("lastName", Chance.randomLastName()).add("id", (int) (Math.random() * 10000)));
    }
    JsonObject model = builder.add("people", arrayBuilder).build();
    /*
     Thirdly, serialize the JSON object to a string value
     */
    StringWriter stWriter = new StringWriter();
    JsonWriter jsonWriter = Json.createWriter(stWriter);
    jsonWriter.writeObject(model);
    jsonWriter.close();
    String jsonPayload = stWriter.toString();
    /*
     Finally, send the serialized JSON payload to the client
     */
    try (PrintWriter out = response.getWriter()) {
        out.println(jsonPayload);
    }
}

private byte[] createErrorMessage() {
    JsonObjectBuilder objectBuilder = Json.createObjectBuilder();
    objectBuilder.add("status", "invalid_token");
    Object asDiscoveryUrl = serverConfig.get(CONFIG_OPENID_CONFIGURATION_URL);
    if (asDiscoveryUrl != null) {
        objectBuilder.add(CONFIG_OPENID_CONFIGURATION_URL, asDiscoveryUrl.toString());
    }
    return ByteIterator.ofBytes(objectBuilder.build().toString().getBytes()).base64Encode().asUtf8().drain();
}

@Test
public void testJsonServlet() throws Exception {
    final String result = HttpRequest.get(url + "json", 10, TimeUnit.SECONDS);
    final JsonParser parser = Json.createParser(new StringReader(result));
    String key = null;
    String value = null;
    while (parser.hasNext()) {
        final Event event = parser.next();
        switch(event) {
            case KEY_NAME:
                key = parser.getString();
                break;
            case VALUE_STRING:
                value = parser.getString();
                break;
        }
    }
    parser.close();
    Assert.assertEquals("Key should be \"name\"", "name", key);
    Assert.assertEquals("Value should be \"value\"", "value", value);
}

private byte[] createErrorMessage() {
    JsonObjectBuilder objectBuilder = Json.createObjectBuilder();
    objectBuilder.add("status", "invalid_token");
    Object asDiscoveryUrl = serverConfig.get(CONFIG_OPENID_CONFIGURATION_URL);
    if (asDiscoveryUrl != null) {
        objectBuilder.add(CONFIG_OPENID_CONFIGURATION_URL, asDiscoveryUrl.toString());
    }
    return ByteIterator.ofBytes(objectBuilder.build().toString().getBytes()).base64Encode().asUtf8().drain();
}

@Override
public void open(Serializable checkpoint) throws Exception {
    getLogger(this.getClass().getName()).log(Level.INFO, "Processing file " + getContext().getFileToProcess().getFileName() + " for Realm " + getContext().getRealm().getRealmDetail());
    // todo - Configure folderType
    in = openInputStream(getContext().getFileToProcess(FolderType.FI_TMP));
    setParser(Json.createParser(in));
    AuctionFile fileToProcess = getContext().getFileToProcess();
    fileToProcess.setFileStatus(FileStatus.PROCESSING);
    woWBusiness.updateAuctionFile(fileToProcess);
}

//TODO: get contest for sharing?
//-- @ResourceMapping("getProposalVersionFirstIndex")
@GetMapping("/api/phases/{phaseId}/proposals/{proposalId}/versionsFirstIndex")
public void getProposalVersionFirstIndex(HttpServletRequest request, HttpServletResponse response, @PathVariable("phaseId") long contestPhaseId, @PathVariable("proposalId") long proposalId) throws IOException {
    Proposal2Phase p2p = null;
    if (contestPhaseId > 0) {
        p2p = ProposalPhaseClientUtil.getProposal2PhaseByProposalIdContestPhaseId(proposalId, contestPhaseId);
    }
    int index = 0;
    Date oldDate = new Date();
    for (ProposalVersion proposalVersion : ProposalClientUtil.getAllProposalVersions(proposalId)) {
        if (p2p == null || p2p.getVersionTo() == -1 || (proposalVersion.getVersion() >= p2p.getVersionFrom() && (proposalVersion.getVersion() < p2p.getVersionTo()))) {
            break;
        }
        if (Math.abs(oldDate.getTime() - proposalVersion.getCreateDate().getTime()) > MILLISECONDS_TO_GROUP_VERSIONS) {
            index++;
            oldDate = proposalVersion.getCreateDate();
        }
    }
    final JsonObject json = Json.createObjectBuilder().add("index", index).build();
    response.getOutputStream().write(json.toString().getBytes());
}

@OnError
public void onError(Session session, Throwable error) {
    try {
        if (error.getCause() instanceof ConstraintViolationException) {
            // Just report the first validation problem.
            JsonObject jsonObject = Json.createObjectBuilder().add("error", ((ConstraintViolationException) error.getCause()).getConstraintViolations().iterator().next().getMessage()).build();
            session.getBasicRemote().sendText(jsonObject.toString());
        } else {
            logger.log(Level.SEVERE, null, error);
        }
    } catch (IOException ex) {
        logger.log(Level.SEVERE, null, ex);
    }
}

/**
	 * {@inheritDoc}
	 * 
	 */
@Override
public void init(Properties properties) {
    // process/convert any specific properties here 
    Map<String, Object> params = new HashMap<>();
    for (Map.Entry prop : properties.entrySet()) {
        //String name = (String) prop.getKey();
        params.put((String) prop.getKey(), prop.getValue());
    }
    factory = Json.createParserFactory(params);
}

/* (non-Javadoc)
	 * @see com.cloutree.modelevaluator.PredictiveModelResult#toJSON()
	 */
@Deprecated
@Override
public String toJSON() {
    JsonObjectBuilder builder = Json.createObjectBuilder();
    JsonArrayBuilder outputBuilder = Json.createArrayBuilder();
    // Output Values
    Set<String> outputKeys = this.outputValues.keySet();
    for (String outputKey : outputKeys) {
        Object val = this.outputValues.get(outputKey);
        if (val != null) {
            outputBuilder.add(Json.createObjectBuilder().add(outputKey, val.toString()));
        }
    }
    builder.add("outputValues", outputBuilder);
    JsonArrayBuilder predictedBuilder = Json.createArrayBuilder();
    Set<String> predictedKeys = this.predictedValues.keySet();
    for (String predictedKey : predictedKeys) {
        Object val = this.predictedValues.get(predictedKey);
        if (val != null) {
            predictedBuilder.add(Json.createObjectBuilder().add(predictedKey, val.toString()));
        }
    }
    builder.add("predictedValues", predictedBuilder);
    JsonArrayBuilder errorBuilder = Json.createArrayBuilder();
    for (String error : this.errors) {
        errorBuilder.add(error);
    }
    builder.add("errors", errorBuilder);
    JsonObject jsonObject = builder.build();
    return jsonObject.toString();
}

/**
     * Builds the Where statement.
     *
     * @return the Where statement
     */
private String buildTheWhereStatement() {
    String where = "WHERE ";
    InputStream input = null;
    try {
        input = new FileInputStream(DatacafeConstants.RELATIONS_DATA_FILE);
    } catch (FileNotFoundException ex) {
        try {
            input = new FileInputStream(DatacafeConstants.RELATIONS_DATA_FILE_ALT);
        } catch (Exception e) {
            logger.error("Error in loading the relations file.. ", ex);
        }
    }
    JsonReader reader = Json.createReader(input);
    JsonObject jsonObject = reader.readObject();
    reader.close();
    Set<String> primaryCollections = jsonObject.keySet();
    for (String rawCollection : primaryCollections) {
        String rawDataSource = QueryWrapper.getDestinationInDataLakeFromDrill(rawCollection);
        // shorter form as the map name.
        String collection = readValuesFromMap(datalakeID + DatacafeConstants.COLLECTION_INDICES_MAP_SUFFIX, rawDataSource);
        addValueToMap(datalakeID + DatacafeConstants.CHOSEN_COLLECTIONS_MAP_SUFFIX, rawDataSource, collection);
        JsonObject secondaryCollectionObject = jsonObject.getJsonObject(rawCollection);
        Set<String> secondaryCollections = secondaryCollectionObject.keySet();
        for (String secondaryRawCollection : secondaryCollections) {
            String rawSecondaryDataSource = QueryWrapper.getDestinationInDataLakeFromDrill(secondaryRawCollection);
            String secondaryCollection = readValuesFromMap(datalakeID + DatacafeConstants.COLLECTION_INDICES_MAP_SUFFIX, rawSecondaryDataSource);
            addValueToMap(datalakeID + DatacafeConstants.CHOSEN_COLLECTIONS_MAP_SUFFIX, rawSecondaryDataSource, secondaryCollection);
            String attribute = secondaryCollectionObject.getString(secondaryRawCollection);
            HzServer.addValueToMultiMap(datalakeID + DatacafeConstants.LINKS_TO_MAP_SUFFIX + collection, secondaryCollection, attribute);
            if (firstInTheWhere) {
                firstInTheWhere = false;
            } else {
                where += " AND ";
            }
            where += collection + "." + attribute + " = " + secondaryCollection + "." + attribute;
        }
    }
    HzServer.addValueToMap(datalakeID + DatacafeConstants.META_INDICES_SINGLE_MAP_SUFFIX, DatacafeConstants.SQL_WHERE_ENTRY_KEY, where);
    return where;
}

private Availability readJSON(InputStream in) {
    try {
        JSONReader reader = null;
        try {
            reader = new JSONReader(Json.createParser(new InputStreamReader(in, "UTF-8")));
        } catch (UnsupportedEncodingException e) {
            LOG.error("Unsupported encoding exception" + " while parsing json stream", e);
        }
        final ArrayList<Attributes> attrs = new ArrayList<Attributes>();
        reader.readDatasets(new Callback() {

            @Override
            public void onDataset(Attributes fmi, Attributes dataset) {
                attrs.add(dataset);
            }
        });
        if (attrs.get(0).getString(Tag.InstanceAvailability) != null)
            return Availability.valueOf(attrs.get(0).getString(Tag.InstanceAvailability));
    } finally {
        SafeClose.close(in);
    }
    return Availability.UNAVAILABLE;
}

/**
     * Loads the data from the JSON download versions file.
     * 
     * @throws IOException
     *             Parsing the event store version file failed.
     */
public final void parse() throws IOException {
    final Reader reader = new FileReader(jsonDownloadsFile);
    try {
        final JsonReader jsonReader = Json.createReader(reader);
        final JsonArray osArray = jsonReader.readArray();
        for (int i = 0; i < osArray.size(); i++) {
            final JsonObject osObj = (JsonObject) osArray.get(i);
            final String os = osObj.getString("os");
            final String currentVersion = osObj.getString("currentVersion");
            final JsonArray downloadsArray = osObj.getJsonArray("downloads");
            final List<DownloadVersion> versions = new ArrayList<>();
            for (int j = 0; j < downloadsArray.size(); j++) {
                final JsonObject downloadObj = (JsonObject) downloadsArray.get(j);
                final String version = downloadObj.getString("version");
                final String url = downloadObj.getString("url");
                versions.add(new DownloadVersion(version, url));
            }
            Collections.sort(versions);
            osList.add(new DownloadOS(os, currentVersion, versions));
        }
        Collections.sort(osList);
    } finally {
        reader.close();
    }
    for (final DownloadOS os : osList) {
        LOG.info("Latest '" + os + "': " + os.getLatestVersion() + " (Versions: " + os.getVersions().size() + ")");
    }
}

public Account doLogin(String invitation) throws IOException, LoginException {
    RespondentAccount account = new RespondentAccount();
    String query = String.format("invitation=%s", URLEncoder.encode(invitation, "UTF-8"));
    URL url = new URL(endpoint + "/auth?" + query);
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    try (InputStream is = connection.getInputStream();
        JsonReader rdr = Json.createReader(is)) {
        JsonObject obj = rdr.readObject();
        String givenNames = obj.getString("givenNames");
        String surname = obj.getString("surname");
        String email = obj.getString("email");
        String apiKey = obj.getString("apiKey");
        String secret = obj.getString("secret");
        String preferredLanguage = obj.getString("preferredLanguage");
        account.setGivenNames(givenNames);
        account.setSurname(surname);
        account.setEmail(email);
        account.setApiKey(apiKey);
        account.setSecret(secret);
        account.setPreferredLanguage(preferredLanguage);
        JsonArray roles = obj.getJsonArray("roles");
        for (JsonObject role : roles.getValuesAs(JsonObject.class)) {
            String roleName = role.getString("name");
            account.assingRole(roleName);
        }
        JsonArray grantedquestionnaireIds = obj.getJsonArray("grantedquestionnaireIds");
        for (JsonNumber grantedquestionnaireId : grantedquestionnaireIds.getValuesAs(JsonNumber.class)) {
            Integer questionnaireId = grantedquestionnaireId.intValue();
            account.grantquestionnaireId(questionnaireId);
        }
    } catch (ConnectException e) {
        logger.error(e.getMessage(), e);
        throw new FailedLoginException(String.format("Server {} is temporarily unavailable", endpoint));
    } catch (// 404 error
    FileNotFoundException // 404 error
    e) {
        logger.error(e.getMessage(), e);
        throw new FailedLoginException(String.format("Configuration error. Resource {} not found", url));
    } catch (IOException e) {
        String message = getErrorMessage(e, connection);
        logger.error(e.getMessage(), e);
        throw new AccountException(message);
    }
    return account;
}

@OnError
public void onError(Session session, Throwable error) {
    try {
        if (error.getCause() instanceof ConstraintViolationException) {
            // Just report the first validation problem.
            JsonObject jsonObject = Json.createObjectBuilder().add("error", ((ConstraintViolationException) error.getCause()).getConstraintViolations().iterator().next().getMessage()).build();
            session.getBasicRemote().sendText(jsonObject.toString());
        } else {
            logger.log(Level.SEVERE, null, error);
        }
    } catch (IOException ex) {
        logger.log(Level.SEVERE, null, ex);
    }
}

@Override
public Movie readFrom(Class<Movie> type, Type type1, Annotation[] antns, MediaType mt, MultivaluedMap<String, String> mm, InputStream in) throws IOException, WebApplicationException {
    Movie movie = new Movie();
    JsonParser parser = Json.createParser(in);
    while (parser.hasNext()) {
        switch(parser.next()) {
            case KEY_NAME:
                String key = parser.getString();
                parser.next();
                switch(key) {
                    case "id":
                        movie.setId(parser.getInt());
                        break;
                    case "name":
                        movie.setName(parser.getString());
                        break;
                    case "actors":
                        movie.setActors(parser.getString());
                        break;
                    default:
                        break;
                }
                break;
            default:
                break;
        }
    }
    return movie;
}

/**
     * @param args
     */
public static void main(String[] args) {
    boolean init = MasterData.INIT_COMPLETE;
    File dir = new File(args[0]);
    File[] files = dir.listFiles();
    String[] fileNameList = new String[files.length];
    for (int i = 0; i < files.length; ++i) {
        fileNameList[i] = files[i].getAbsolutePath();
    }
    Arrays.sort(fileNameList);
    int resultCount = 0;
    int[] rankCount = new int[10];
    try {
        FileOutputStream output = new FileOutputStream("dump-data.dat");
        Schema<BattleExDto> schema = RuntimeSchema.getSchema(BattleExDto.class);
        LinkedBuffer buffer = LinkedBuffer.allocate(128 * 1024);
        BattleExDto battle = null;
        for (int i = 0; i < fileNameList.length; ++i) {
            String fileName = fileNameList[i];
            boolean ignore = false;
            boolean isBattleResult = false;
            BattlePhaseKind kind = BattlePhaseKind.BATTLE;
            if (fileName.endsWith("COMBINED_BATTLE_MIDNIGHT.json")) {
                kind = BattlePhaseKind.COMBINED_MIDNIGHT;
            } else if (fileName.endsWith("COMBINED_BATTLE_SP_MIDNIGHT.json")) {
                kind = BattlePhaseKind.COMBINED_SP_MIDNIGHT;
            } else if (fileName.endsWith("COMBINED_BATTLE.json")) {
                kind = BattlePhaseKind.COMBINED_BATTLE;
            } else if (fileName.endsWith("COMBINED_AIR_BATTLE.json")) {
                kind = BattlePhaseKind.COMBINED_AIR;
            } else if (fileName.endsWith("PRACTICE_BATTLE_MIDNIGHT.json")) {
                kind = BattlePhaseKind.MIDNIGHT;
            } else if (fileName.endsWith("PRACTICE_BATTLE.json")) {
                kind = BattlePhaseKind.BATTLE;
            } else if (fileName.endsWith("BATTLE_NIGHT_TO_DAY.json")) {
                kind = BattlePhaseKind.NIGHT_TO_DAY;
            } else if (fileName.endsWith("BATTLE_SP_MIDNIGHT.json")) {
                kind = BattlePhaseKind.SP_MIDNIGHT;
            } else if (fileName.endsWith("BATTLE_MIDNIGHT.json")) {
                kind = BattlePhaseKind.MIDNIGHT;
            } else if (fileName.endsWith("BATTLE.json")) {
                kind = BattlePhaseKind.BATTLE;
            } else if (fileName.endsWith("BATTLE_RESULT.json")) {
                isBattleResult = true;
            } else if (fileName.endsWith("COMBINED_BATTLE_RESULT.json")) {
                isBattleResult = true;
            } else if (fileName.endsWith("PRACTICE_BATTLE_RESULT.json")) {
                isBattleResult = true;
            } else {
                ignore = true;
            }
            if (ignore == false) {
                String jsonString = FileUtils.readFileToString(new File(fileName), Charset.forName("MS932"));
                JsonReader jsonreader = Json.createReader(new StringReader(jsonString));
                JsonObject json = jsonreader.readObject();
                JsonObject data = json.getJsonObject("api_data");
                if (data == null)
                    continue;
                if (isBattleResult == false) {
                    if (battle == null) {
                        battle = new BattleExDto(new Date());
                    }
                    battle.addPhase(data, kind);
                } else if (battle != null) {
                    battle.setResult(data, null);
                    // ランク�����る��ェック
                    ResultRank estimatedRank = battle.getLastPhase().getEstimatedRank();
                    if (!battle.getRank().equals(estimatedRank.rank())) {
                        System.out.println("戦闘�果判定ミス: 正解ランク:" + battle.getRank() + " " + battle.getLastPhase().getRankCalcInfo(battle));
                    }
                    ProtostuffIOUtil.writeDelimitedTo(output, battle, schema, buffer);
                    buffer.clear();
                    battle = null;
                    ++resultCount;
                }
                jsonreader.close();
            }
        }
        output.close();
        System.out.println(resultCount + "件�戦闘�果を処�");
        System.out.println(Arrays.toString(rankCount));
    } catch (IOException e) {
        System.out.println("�ん�エラー���");
        e.printStackTrace();
    }
}

@Test
public void testJSONParse() {
    RequestEvent re = new RequestEvent(EventType.TRACE_START, "Start");
    trace.addEvent(re);
    for (int i = 0; i < 10000; i++) {
        re = new RequestEvent("Event" + i);
        trace.addEvent(re);
    }
    re = new RequestEvent(EventType.TRACE_END, "TraceEnd");
    trace.addEvent(re);
    String jsonString = trace.toString();
    JsonReader jsonReader = Json.createReader(new StringReader(jsonString));
    jsonReader.readObject();
}

/**
     * Gets the JSON object of {@link org.picketlink.json.jose.JWK}.
     *
     * @return the json object
     */
public JsonObject getJsonObject() {
    JsonArrayBuilder arrayBuilder = Json.createArrayBuilder();
    Iterator<JWK> iterator = this.keys.values().iterator();
    while (iterator.hasNext()) {
        arrayBuilder.add(iterator.next().getJsonObject());
    }
    return Json.createObjectBuilder().add(JsonConstants.COMMON.HEADER_JSON_WEB_KEY, arrayBuilder.build()).build();
}

@Override
public NamedToroIndex from(String databaseObject) {
    JsonReader reader = Json.createReader(new StringReader(databaseObject));
    JsonObject object = reader.readObject();
    IndexedAttributes.Builder builder = new IndexedAttributes.Builder();
    JsonArray attsArray = object.getJsonArray(ATTS_KEY);
    Set<Integer> descendingAttPos;
    if (object.containsKey(DESCENDING)) {
        JsonArray descArray = object.getJsonArray(DESCENDING);
        descendingAttPos = Sets.newHashSetWithExpectedSize(descArray.size());
        for (int i = 0; i < descArray.size(); i++) {
            descendingAttPos.add(descArray.getInt(i));
        }
    } else {
        descendingAttPos = Collections.emptySet();
    }
    for (int i = 0; i < attsArray.size(); i++) {
        String att = attsArray.getString(i);
        AttributeReference attRef = parseAttRef(att);
        if (descendingAttPos.contains(i)) {
            builder.addAttribute(attRef, IndexType.desc);
        } else {
            builder.addAttribute(attRef, IndexType.asc);
        }
    }
    return new DefaultNamedToroIndex(object.getString(NAME_KEY), builder.build(), databaseName, collectionName, object.getBoolean(UNIQUE_KEY, false));
}

@Override
public void run() {
    try {
        Thread.sleep(100);
    } catch (InterruptedException ignored) {
    }
    final JsonObjectBuilder mapRepresentation = Json.createObjectBuilder();
    for (Map.Entry<String, String> entry : SharedCollection.map.entrySet()) {
        mapRepresentation.add(entry.getKey(), entry.getValue());
    }
    final JsonObjectBuilder event = Json.createObjectBuilder();
    event.add("event", "init");
    event.add("map", mapRepresentation.build());
    try {
        eventOutput.write(new OutboundEvent.Builder().name("update").data(String.class, event.build().toString()).build());
    } catch (IOException e) {
    }
    broadcaster.add(eventOutput);
}

@Override
public void onStatus(Status status) {
    task.setSourceOutage(false);
    String json = TwitterObjectFactory.getRawJSON(status);
    JsonObject originalDoc = Json.createReader(new StringReader(json)).readObject();
    for (Predicate<JsonObject> filter : filters) {
        if (!filter.test(originalDoc)) {
            //logger.info(originalDoc.get("text").toString() + ": failed on filter = " + filter.getFilterName());
            return;
        }
    }
    JsonObjectBuilder builder = Json.createObjectBuilder();
    for (Entry<String, JsonValue> entry : originalDoc.entrySet()) builder.add(entry.getKey(), entry.getValue());
    builder.add("aidr", aidr);
    JsonObject doc = builder.build();
    for (Publisher p : publishers) p.publish(channelName, doc);
}

/**
   * Parses the message and publishes the formatted string to a Cloud Pub/Sub topic.
   */
public void handleMessage(String message) {
    System.out.println(">> message???");
    JsonObject jsonObject = Json.createReader(new StringReader(message)).readObject();
    String minorEdit = jsonObject.get("is_minor").toString();
    String pageTitle = jsonObject.getString("page_title");
    String pageUrl = jsonObject.getString("url");
    String isBot = jsonObject.get("is_bot").toString();
    String isNew = jsonObject.get("is_new").toString();
    String user = jsonObject.getString("user");
    String isAnon = jsonObject.get("is_anon").toString();
    String changeSize = jsonObject.get("change_size").toString();
    String country;
    JsonObject geoIp = jsonObject.getJsonObject("geo_ip");
    if (geoIp == null) {
        country = new String("unknown country");
    } else {
        country = geoIp.getString("country_name");
    }
    String separator = new String("###");
    String finalOutput = minorEdit + separator + pageTitle + separator + pageUrl + separator + isBot + separator + isNew + separator + user + separator + country + separator + isAnon + separator + changeSize;
    if (finalOutput.isEmpty()) {
        return;
    }
    logger.info("Received ...." + finalOutput);
    // Publish message to Pubsub.
    PubsubMessage pubsubMessage = new PubsubMessage();
    try {
        pubsubMessage.encodeData(finalOutput.getBytes("UTF-8"));
    } catch (java.io.UnsupportedEncodingException e) {
        ;
    }
    /*
    messages.add(pubsubMessage);

    if (messages.size() > batchSize) {
      PublishBatchRequest publishBatchRequest = new PublishBatchRequest()
        .setTopic(outputTopic)
        .setMessages(messages);
        pubsub.topics().publishBatch(publishBatchRequest).execute();
        messages.clear();
    }
    */
    /**/
    final PublishRequest publishRequest = new PublishRequest();
    publishRequest.setTopic(outputTopic).setMessage(pubsubMessage);
    for (int i = 0; i < 20; ++i) {
        // publish on a new thread.
        Thread thread = new Thread(new Runnable() {

            public void run() {
                try {
                    pubsub.topics().publish(publishRequest).execute();
                } catch (java.io.IOException e) {
                    ;
                }
            }
        });
        thread.start();
    }
/**/
}

@Override
public void process(int id, Document document) {
    JsonArrayBuilder clusters = Json.createArrayBuilder();
    for (CorefCluster gold : document.goldCorefClusters.values()) {
        JsonArrayBuilder c = Json.createArrayBuilder();
        for (Mention m : gold.corefMentions) {
            c.add(m.mentionID);
        }
        clusters.add(c.build());
    }
    goldClusterWriter.println(Json.createObjectBuilder().add(String.valueOf(id), clusters.build()).build());
    Map<Pair<Integer, Integer>, Boolean> mentionPairs = CorefUtils.getLabeledMentionPairs(document);
    List<Mention> mentionsList = CorefUtils.getSortedMentions(document);
    Map<Integer, List<Mention>> mentionsByHeadIndex = new HashMap<>();
    for (int i = 0; i < mentionsList.size(); i++) {
        Mention m = mentionsList.get(i);
        List<Mention> withIndex = mentionsByHeadIndex.get(m.headIndex);
        if (withIndex == null) {
            withIndex = new ArrayList<>();
            mentionsByHeadIndex.put(m.headIndex, withIndex);
        }
        withIndex.add(m);
    }
    JsonObjectBuilder docFeatures = Json.createObjectBuilder();
    docFeatures.add("doc_id", id);
    docFeatures.add("type", document.docType == DocType.ARTICLE ? 1 : 0);
    docFeatures.add("source", document.docInfo.get("DOC_ID").split("/")[0]);
    JsonArrayBuilder sentences = Json.createArrayBuilder();
    for (CoreMap sentence : document.annotation.get(SentencesAnnotation.class)) {
        sentences.add(getSentenceArray(sentence.get(CoreAnnotations.TokensAnnotation.class)));
    }
    JsonObjectBuilder mentions = Json.createObjectBuilder();
    for (Mention m : document.predictedMentionsByID.values()) {
        Iterator<SemanticGraphEdge> iterator = m.enhancedDependency.incomingEdgeIterator(m.headIndexedWord);
        SemanticGraphEdge relation = iterator.hasNext() ? iterator.next() : null;
        String depRelation = relation == null ? "no-parent" : relation.getRelation().toString();
        String depParent = relation == null ? "<missing>" : relation.getSource().word();
        mentions.add(String.valueOf(m.mentionNum), Json.createObjectBuilder().add("doc_id", id).add("mention_id", m.mentionID).add("mention_num", m.mentionNum).add("sent_num", m.sentNum).add("start_index", m.startIndex).add("end_index", m.endIndex).add("head_index", m.headIndex).add("mention_type", m.mentionType.toString()).add("dep_relation", depRelation).add("dep_parent", depParent).add("sentence", getSentenceArray(m.sentenceWords)).add("contained-in-other-mention", mentionsByHeadIndex.get(m.headIndex).stream().anyMatch( m2 -> m != m2 && m.insideIn(m2)) ? 1 : 0).build());
    }
    JsonArrayBuilder featureNames = Json.createArrayBuilder().add("same-speaker").add("antecedent-is-mention-speaker").add("mention-is-antecedent-speaker").add("relaxed-head-match").add("exact-string-match").add("relaxed-string-match");
    JsonObjectBuilder features = Json.createObjectBuilder();
    JsonObjectBuilder labels = Json.createObjectBuilder();
    for (Map.Entry<Pair<Integer, Integer>, Boolean> e : mentionPairs.entrySet()) {
        Mention m1 = document.predictedMentionsByID.get(e.getKey().first);
        Mention m2 = document.predictedMentionsByID.get(e.getKey().second);
        String key = m1.mentionNum + " " + m2.mentionNum;
        JsonArrayBuilder builder = Json.createArrayBuilder();
        for (int val : CategoricalFeatureExtractor.pairwiseFeatures(document, m1, m2, dictionaries, conll)) {
            builder.add(val);
        }
        features.add(key, builder.build());
        labels.add(key, e.getValue() ? 1 : 0);
    }
    JsonObject docData = Json.createObjectBuilder().add("sentences", sentences.build()).add("mentions", mentions.build()).add("labels", labels.build()).add("pair_feature_names", featureNames.build()).add("pair_features", features.build()).add("document_features", docFeatures.build()).build();
    dataWriter.println(docData);
}

@Test
public void testJSONReading() {
    Attributes dataset = new Attributes();
    JSONReader reader = new JSONReader(Json.createParser(new ByteArrayInputStream(RESULT.getBytes(StandardCharsets.UTF_8))));
    reader.readDataset(dataset);
    Attributes referenceDataset = createTestDataset();
    // currently empty strings become null after reading them from JSON, so we have to adapt the reference a little:
    referenceDataset.setString(Tag.ImageType, VR.CS, "DERIVED", null, null, "PRIMARY");
    assertEquals(referenceDataset, dataset);
}

@Override
protected void analyzeDependency(Dependency dependency, Engine engine) throws AnalysisException {
    final File file = dependency.getActualFile();
    try (JsonReader jsonReader = Json.createReader(FileUtils.openInputStream(file))) {
        final JsonObject json = jsonReader.readObject();
        final EvidenceCollection productEvidence = dependency.getProductEvidence();
        final EvidenceCollection vendorEvidence = dependency.getVendorEvidence();
        if (json.containsKey("name")) {
            final Object value = json.get("name");
            if (value instanceof JsonString) {
                final String valueString = ((JsonString) value).getString();
                productEvidence.addEvidence(PACKAGE_JSON, "name", valueString, Confidence.HIGHEST);
                vendorEvidence.addEvidence(PACKAGE_JSON, "name_project", String.format("%s_project", valueString), Confidence.LOW);
            } else {
                LOGGER.warn("JSON value not string as expected: {}", value);
            }
        }
        addToEvidence(json, productEvidence, "description");
        addToEvidence(json, vendorEvidence, "author");
        addToEvidence(json, dependency.getVersionEvidence(), "version");
        dependency.setDisplayFileName(String.format("%s/%s", file.getParentFile().getName(), file.getName()));
    } catch (JsonException e) {
        LOGGER.warn("Failed to parse package.json file.", e);
    } catch (IOException e) {
        throw new AnalysisException("Problem occurred while reading dependency file.", e);
    }
}

/**
     * Load REST commands by calling describe command
     * @param restClient
     * @return JsonObject that contains all the descriptions of all REST commands
     */
private JsonObject loadRESTCommandsFromServer(RESTClient restClient) {
    RESTResponse response = null;
    try {
        response = restClient.sendRequest(HttpMethod.GET, _DESCRIBE_URI, ContentType.APPLICATION_JSON, null);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    if (!response.getCode().isError()) {
        JsonReader jsonReader = Json.createReader(new StringReader(response.getBody()));
        JsonObject result = jsonReader.readObject().getJsonObject("commands");
        jsonReader.close();
        return result;
    } else {
        throw new RuntimeException("Describe command error: " + response.getBody());
    }
}

static BCTx fromStream(InputStream is) {
    JsonObject obj = null;
    try (JsonReader rdr = Json.createReader(is)) {
        BCTx tx = new BCTx();
        obj = rdr.readObject();
        tx.txid = obj.getString("txid");
        tx.inputs = obj.getJsonArray("vin").stream().map( jv -> BCCoin.cacheFromInput((JsonObject) jv, tx.txid)).collect(Collectors.toList());
        tx.outputs = obj.getJsonArray("vout").stream().map( jv -> BCCoin.cacheFromOutput((JsonObject) jv, tx.txid)).collect(Collectors.toList());
        tx.blockhash = obj.getString("blockhash");
        tx.confirmations = obj.getInt("confirmations");
        JsonNumber num = obj.getJsonNumber("time");
        tx.timeMs = num == null ? 0 : (num.longValue() * 1000L);
        num = obj.getJsonNumber("valueOut");
        tx.outputValue = (num == null) ? 0.0 : num.doubleValue();
        num = obj.getJsonNumber("valueIn");
        tx.inputValue = (num == null) ? 0.0 : num.doubleValue();
        num = obj.getJsonNumber("fees");
        tx.fees = (num == null) ? 0.0 : num.doubleValue();
        txcache.put(tx.txid, tx);
        return tx;
    } catch (Exception e) {
        e.printStackTrace();
        System.out.println(obj);
        return null;
    }
}

@Override
@SuppressFBWarnings(value = { "REC_CATCH_EXCEPTION" }, justification = "Intentionally catching any possible exception as there may be unknown format issues in a file and we don't want to error partially through parsing")
protected CloseableIterator<GeoWaveData<SimpleFeature>> toGeoWaveDataInternal(final WholeFile hfile, final Collection<ByteArrayId> primaryIndexIds, final String globalVisibility) {
    final List<GeoWaveData<SimpleFeature>> featureData = new ArrayList<GeoWaveData<SimpleFeature>>();
    final InputStream in = new ByteArrayInputStream(hfile.getOriginalFile().array());
    try {
        final GZIPInputStream zip = new GZIPInputStream(in);
        final InputStreamReader isr = new InputStreamReader(zip, StringUtils.UTF8_CHAR_SET);
        final BufferedReader br = new BufferedReader(isr);
        final GeometryFactory geometryFactory = new GeometryFactory();
        String line;
        int lineNumber = 0;
        String userid = "";
        String userName = "";
        String tweetText = "";
        String inReplyUser = "";
        String inReplyStatus = "";
        int retweetCount = 0;
        String lang = "";
        Date dtg = null;
        String dtgString = "";
        String tweetId = "";
        double lat = 0;
        double lon = 0;
        StringReader sr = new StringReader("");
        JsonReader jsonReader = null;
        try {
            while ((line = br.readLine()) != null) {
                userid = "";
                userName = "";
                tweetText = "";
                inReplyUser = "";
                inReplyStatus = "";
                retweetCount = 0;
                lang = "";
                dtg = null;
                dtgString = "";
                tweetId = "";
                lat = 0;
                lon = 0;
                lineNumber++;
                try {
                    sr = new StringReader(line);
                    jsonReader = Json.createReader(sr);
                    JsonObject tweet = jsonReader.readObject();
                    try {
                        lon = tweet.getJsonObject("coordinates").getJsonArray("coordinates").getJsonNumber(0).doubleValue();
                        lat = tweet.getJsonObject("coordinates").getJsonArray("coordinates").getJsonNumber(1).doubleValue();
                        LOGGER.debug("line " + lineNumber + " at POINT(" + lon + " " + lat + ")");
                    } catch (final Exception e) {
                        LOGGER.debug("Error reading twitter coordinate on line " + lineNumber + " of " + hfile.getOriginalFilePath() + "\n" + line, e);
                        continue;
                    }
                    final Coordinate coord = new Coordinate(lon, lat);
                    try {
                        dtgString = tweet.getString("created_at");
                        dtg = TwitterUtils.parseDate(dtgString);
                    } catch (final Exception e) {
                        LOGGER.warn("Error reading tweet date on line " + lineNumber + " of " + hfile.getOriginalFilePath(), e);
                        continue;
                    }
                    JsonObject user = tweet.getJsonObject("user");
                    tweetId = tweet.getString("id_str");
                    userid = user.getString("id_str");
                    userName = user.getString("name");
                    tweetText = tweet.getString("text");
                    // nullable
                    if (!tweet.isNull("in_reply_to_user_id_str"))
                        inReplyUser = tweet.getString("in_reply_to_user_id_str");
                    if (!tweet.isNull("in_reply_to_status_id_str"))
                        inReplyStatus = tweet.getString("in_reply_to_status_id_str");
                    retweetCount = tweet.getInt("retweet_count");
                    if (!tweet.isNull("lang"))
                        lang = tweet.getString("lang");
                    twitterSftBuilder.set(TwitterUtils.TWITTER_USERID_ATTRIBUTE, userid);
                    twitterSftBuilder.set(TwitterUtils.TWITTER_USERNAME_ATTRIBUTE, userName);
                    twitterSftBuilder.set(TwitterUtils.TWITTER_TEXT_ATTRIBUTE, tweetText);
                    twitterSftBuilder.set(TwitterUtils.TWITTER_INREPLYTOUSER_ATTRIBUTE, inReplyUser);
                    twitterSftBuilder.set(TwitterUtils.TWITTER_INREPLYTOSTATUS_ATTRIBUTE, inReplyStatus);
                    twitterSftBuilder.set(TwitterUtils.TWITTER_RETWEETCOUNT_ATTRIBUTE, retweetCount);
                    twitterSftBuilder.set(TwitterUtils.TWITTER_LANG_ATTRIBUTE, lang);
                    twitterSftBuilder.set(TwitterUtils.TWITTER_DTG_ATTRIBUTE, dtg);
                    twitterSftBuilder.set(TwitterUtils.TWITTER_GEOMETRY_ATTRIBUTE, geometryFactory.createPoint(coord));
                    SimpleFeature tweetSft = twitterSftBuilder.buildFeature(tweetId);
                    // LOGGER.warn(tweetSft.toString());
                    featureData.add(new GeoWaveData<SimpleFeature>(sftNameKey, primaryIndexIds, tweetSft));
                } catch (final Exception e) {
                    LOGGER.error("Error parsing line: " + line, e);
                    continue;
                } finally {
                    if (sr != null)
                        sr.close();
                    if (jsonReader != null)
                        jsonReader.close();
                }
            }
        } catch (final IOException e) {
            LOGGER.warn("Error reading line from Twitter file: " + hfile.getOriginalFilePath(), e);
        } finally {
            IOUtils.closeQuietly(br);
            IOUtils.closeQuietly(isr);
            IOUtils.closeQuietly(in);
        }
    } catch (final IOException e) {
        LOGGER.error("Failed to read gz entry: " + hfile.getOriginalFilePath(), e);
    }
    return new CloseableIterator.Wrapper<GeoWaveData<SimpleFeature>>(featureData.iterator());
}