Example usage for com.google.gson JsonArray add

List of usage examples for com.google.gson JsonArray add

  1. HOME
  2. Java
  3. com.google.gson
  4. com.google.gson.*
  5. JsonArray
  6. add

Introduction

In this page you can find the example usage for com.google.gson JsonArray add.

Prototype

public void add(JsonElement element)

Source Link

Document

Adds the specified element to self.

Usage

From source file:be.iminds.iot.dianne.builder.DianneDeployer.java

License:Open Source License

@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setContentType("application/json");

    String action = request.getParameter("action");
    if (action.equals("deploy")) {
        String id = request.getParameter("id");
        if (id == null) {
            id = UUID.randomUUID().toString();
        }/*from   www. j av a 2 s  .c  o m*/
        String name = request.getParameter("name");
        if (name == null) {
            name = "unknown";
        }
        String[] tags = null;
        String t = request.getParameter("tags");
        if (t != null && !t.isEmpty()) {
            tags = t.split(",");
        }

        List<ModuleDTO> toDeploy = new ArrayList<ModuleDTO>();
        if (request.getParameter("modules") != null) {
            String modulesJsonString = request.getParameter("modules");
            NeuralNetworkDTO nn = DianneJSONConverter.parseJSON(modulesJsonString);
            toDeploy.addAll(nn.modules.values());
        } else if (request.getParameter("module") != null) {
            String moduleJsonString = request.getParameter("module");
            ModuleDTO module = DianneJSONConverter.parseModuleJSON(moduleJsonString);
            toDeploy.add(module);
        }

        try {
            String target = request.getParameter("target");
            if (target == null) {
                throw new Exception("No DIANNE runtime selected to deploy to");
            }
            UUID runtimeId = UUID.fromString(target);

            UUID nnId = UUID.fromString(id);
            List<ModuleInstanceDTO> moduleInstances = platform.deployModules(nnId, name, toDeploy, runtimeId,
                    tags);

            // return json object with deployment
            JsonObject result = new JsonObject();
            JsonObject deployment = deploymentToJSON(moduleInstances);
            result.add("id", new JsonPrimitive(id));
            result.add("deployment", deployment);
            try {
                response.getWriter().write(result.toString());
                response.getWriter().flush();
            } catch (IOException e) {
            }

        } catch (Exception ex) {
            System.out.println("Failed to deploy modules: " + ex.getMessage());
            JsonObject result = new JsonObject();
            result.add("error", new JsonPrimitive("Failed to deploy modules: " + ex.getMessage()));
            try {
                response.getWriter().write(result.toString());
                response.getWriter().flush();
            } catch (IOException e) {
            }
        }

    } else if (action.equals("undeploy")) {
        String id = request.getParameter("id");
        String moduleId = request.getParameter("moduleId");
        if (id != null) {
            NeuralNetworkInstanceDTO nn = platform.getNeuralNetworkInstance(UUID.fromString(id));
            if (nn != null) {
                ModuleInstanceDTO moduleInstance = nn.modules.get(UUID.fromString(moduleId));
                if (moduleInstance != null)
                    platform.undeployModules(Collections.singletonList(moduleInstance));

                response.getWriter().write(new JsonPrimitive(id).toString());
                response.getWriter().flush();
            }
        }
    } else if (action.equals("targets")) {
        JsonArray targets = new JsonArray();

        Map<UUID, String> runtimes = platform.getRuntimes();
        runtimes.entrySet().stream().forEach(e -> {
            JsonObject o = new JsonObject();
            o.add("id", new JsonPrimitive(e.getKey().toString()));
            o.add("name", new JsonPrimitive(e.getValue()));
            targets.add(o);
        });

        response.getWriter().write(targets.toString());
        response.getWriter().flush();
    } else if ("recover".equals(action)) {
        String id = request.getParameter("id");
        if (id == null) {
            // list all options
            JsonArray nns = new JsonArray();
            platform.getNeuralNetworkInstances().stream().forEach(nni -> {
                JsonObject o = new JsonObject();
                o.add("id", new JsonPrimitive(nni.id.toString()));
                o.add("name", new JsonPrimitive(nni.name));
                if (nni.description != null) {
                    o.add("description", new JsonPrimitive(nni.description));
                }
                nns.add(o);
            });
            response.getWriter().write(nns.toString());
            response.getWriter().flush();

        } else {
            NeuralNetworkInstanceDTO nni = platform.getNeuralNetworkInstance(UUID.fromString(id));
            if (nni == null) {
                System.out.println("Failed to recover " + id + " , instance not found");
                return;
            }

            try {
                response.getWriter().write("{\"nn\":");
                NeuralNetworkDTO nn = repository.loadNeuralNetwork(nni.name);
                String s = DianneJSONConverter.toJsonString(nn);
                response.getWriter().write(s);
                response.getWriter().write(", \"layout\":");
                String layout = repository.loadLayout(nni.name);
                response.getWriter().write(layout);
                response.getWriter().write(", \"deployment\":");
                JsonObject deployment = deploymentToJSON(nni.modules.values());
                response.getWriter().write(deployment.toString());
                response.getWriter().write(", \"id\":");
                response.getWriter().write("\"" + id + "\"");
                response.getWriter().write("}");
                response.getWriter().flush();
            } catch (Exception e) {
                System.out.println("Failed to recover " + nni.name + " " + nni.id);
            }
        }
    }

}

From source file:be.iminds.iot.dianne.builder.DianneInput.java

License:Open Source License

@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setContentType("application/json");

    String action = request.getParameter("action");
    if ("available-inputs".equals(action)) {
        JsonArray availableInputs = new JsonArray();
        synchronized (inputs) {
            for (DianneInputs i : inputs) {
                for (InputDescription input : i.getAvailableInputs()) {
                    JsonObject o = new JsonObject();
                    o.add("name", new JsonPrimitive(input.getName()));
                    o.add("type", new JsonPrimitive(input.getType()));
                    availableInputs.add(o);
                }//  ww  w .j ava 2 s . co m
            }
        }
        response.getWriter().write(availableInputs.toString());
        response.getWriter().flush();
    } else if ("setinput".equals(action)) {
        String nnId = request.getParameter("nnId");
        String inputId = request.getParameter("inputId");
        String input = request.getParameter("input");

        synchronized (inputs) {
            // TODO select the right one instead of forwarding to all?
            for (DianneInputs i : inputs) {
                i.setInput(UUID.fromString(nnId), UUID.fromString(inputId), input);
            }

            ForwardListener inputListener = new ForwardListener() {
                @Override
                public void onForward(UUID moduleId, Tensor output, String... tags) {
                    if (sses.get(input) != null) {
                        JsonObject json = converter.toJson(output);
                        StringBuilder builder = new StringBuilder();
                        builder.append("data: ").append(json.toString()).append("\n\n");
                        String msg = builder.toString();

                        List<AsyncContext> list = sses.get(input);
                        Iterator<AsyncContext> it = list.iterator();
                        while (it.hasNext()) {
                            AsyncContext sse = it.next();
                            try {
                                PrintWriter writer = sse.getResponse().getWriter();
                                writer.write(msg);
                                writer.flush();
                                if (writer.checkError()) {
                                    System.err.println("Writer error: removing async endpoint.");
                                    writer.close();
                                    it.remove();
                                }
                            } catch (Exception e) {
                                try {
                                    sse.getResponse().getWriter().close();
                                } catch (Exception ignore) {
                                }
                                it.remove();
                                e.printStackTrace();
                            }
                        }
                    }
                }

                @Override
                public void onError(UUID moduleId, ModuleException e, String... tags) {
                    e.printStackTrace();
                }
            };
            Dictionary<String, Object> properties = new Hashtable<String, Object>();
            properties.put("targets", new String[] { nnId + ":" + inputId });
            properties.put("aiolos.unique", true);
            ServiceRegistration<ForwardListener> r = context.registerService(ForwardListener.class,
                    inputListener, properties);
            inputListeners.put(UUID.fromString(inputId), r);
        }
    } else if ("unsetinput".equals(action)) {
        String nnId = request.getParameter("nnId");
        String inputId = request.getParameter("inputId");
        String input = request.getParameter("input");

        synchronized (inputs) {
            for (DianneInputs i : inputs) {
                i.unsetInput(UUID.fromString(nnId), UUID.fromString(inputId), input);
            }
        }

        ServiceRegistration<ForwardListener> r = inputListeners.get(UUID.fromString(inputId));
        if (r != null) {
            r.unregister();
        }
    }
}

From source file:be.iminds.iot.dianne.builder.DianneLearner.java

License:Open Source License

@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setContentType("application/json");
    String id = request.getParameter("id");
    if (id == null) {
        System.out.println("No neural network instance specified");
    }/*from w  w w.  j  a v a  2  s  . com*/
    UUID nnId = UUID.fromString(id);
    NeuralNetworkInstanceDTO nni = platform.getNeuralNetworkInstance(nnId);
    if (nni == null) {
        System.out.println("Neural network instance " + id + " not deployed");
        return;
    }

    String action = request.getParameter("action");
    if (action.equals("stop")) {
        learner.stop();
        return;
    }

    String target = request.getParameter("target");
    // this list consists of all ids of modules that are needed for trainer:
    // the input, output, trainable and preprocessor modules
    String configJsonString = request.getParameter("config");

    JsonObject configJson = parser.parse(configJsonString).getAsJsonObject();

    JsonObject learnerConfig = (JsonObject) configJson.get(target);

    for (Entry<String, JsonElement> configs : configJson.entrySet()) {
        JsonObject datasetConfig = (JsonObject) configs.getValue();
        if (datasetConfig.get("category").getAsString().equals("Dataset")
                && datasetConfig.get("input") != null) {
            String dataset = datasetConfig.get("dataset").getAsString();
            if (action.equals("learn")) {
                int start = 0;
                int end = datasetConfig.get("train").getAsInt();

                int batch = learnerConfig.get("batch").getAsInt();
                float learningRate = learnerConfig.get("learningRate").getAsFloat();
                float momentum = learnerConfig.get("momentum").getAsFloat();
                float regularization = learnerConfig.get("regularization").getAsFloat();
                String criterion = learnerConfig.get("loss").getAsString();
                String method = learnerConfig.get("method").getAsString();

                boolean clean = learnerConfig.get("clean").getAsBoolean();

                Map<String, String> config = new HashMap<>();
                config.put("range", "" + start + "," + end);
                config.put("batchSize", "" + batch);
                config.put("learningRate", "" + learningRate);
                config.put("momentum", "" + momentum);
                config.put("regularization", "" + regularization);
                config.put("criterion", criterion);
                config.put("method", method);
                config.put("syncInterval", "" + interval);
                config.put("clean", clean ? "true" : "false");
                config.put("trace", "true");

                try {
                    Dataset d = datasets.getDataset(dataset);
                    if (d != null) {
                        JsonObject labels = new JsonObject();
                        labels.add(target, new JsonPrimitive(Arrays.toString(d.getLabels())));
                        response.getWriter().write(labels.toString());
                        response.getWriter().flush();
                    }

                    learner.learn(dataset, config, nni);

                } catch (Exception e) {
                    e.printStackTrace();
                }

            } else if (action.equals("evaluate")) {
                int start = datasetConfig.get("train").getAsInt();
                int end = start + datasetConfig.get("test").getAsInt();

                Map<String, String> config = new HashMap<>();
                config.put("range", "" + start + "," + end);

                try {
                    Evaluation result = evaluator.eval(dataset, config, nni);

                    JsonObject eval = new JsonObject();

                    eval.add("metric", new JsonPrimitive(result.metric()));
                    eval.add("time", new JsonPrimitive(result.time()));

                    if (result instanceof ErrorEvaluation) {
                        ErrorEvaluation ee = (ErrorEvaluation) result;
                        eval.add("error", new JsonPrimitive(ee.error()));
                    }

                    if (result instanceof ClassificationEvaluation) {
                        ClassificationEvaluation ce = (ClassificationEvaluation) result;
                        eval.add("accuracy", new JsonPrimitive(ce.accuracy() * 100));

                        Tensor confusionMatrix = ce.confusionMatrix();
                        JsonArray data = new JsonArray();
                        for (int i = 0; i < confusionMatrix.size(0); i++) {
                            for (int j = 0; j < confusionMatrix.size(1); j++) {
                                JsonArray element = new JsonArray();
                                element.add(new JsonPrimitive(i));
                                element.add(new JsonPrimitive(j));
                                element.add(new JsonPrimitive(confusionMatrix.get(i, j)));
                                data.add(element);
                            }
                        }
                        eval.add("confusionMatrix", data);
                    }

                    response.getWriter().write(eval.toString());
                    response.getWriter().flush();
                } catch (Exception e) {
                    e.printStackTrace();
                    JsonObject eval = new JsonObject();
                    eval.add("error", new JsonPrimitive(e.getCause().getMessage()));
                    response.getWriter().write(eval.toString());
                    response.getWriter().flush();
                }
            }
            break;
        }
    }
}

From source file:be.iminds.iot.dianne.builder.DianneLoader.java

License:Open Source License

@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setContentType("application/json");

    String action = request.getParameter("action");
    if ("list".equals(action)) {
        JsonArray names = new JsonArray();
        for (String name : repository.availableNeuralNetworks()) {
            names.add(new JsonPrimitive(name));
        }/*  w w  w . j a v a2  s. c om*/
        response.getWriter().write(names.toString());
        response.getWriter().flush();
    } else if ("load".equals(action)) {
        String name = request.getParameter("name");

        response.getWriter().write("{\"nn\":");
        NeuralNetworkDTO nn = repository.loadNeuralNetwork(name);
        String s = DianneJSONConverter.toJsonString(nn);
        response.getWriter().write(s);
        response.getWriter().write(", \"layout\":");
        String layout = repository.loadLayout(name);
        response.getWriter().write(layout);
        response.getWriter().write("}");
        response.getWriter().flush();
    }
}

From source file:be.iminds.iot.dianne.builder.DianneOutput.java

License:Open Source License

@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setContentType("application/json");

    String action = request.getParameter("action");
    if ("available-outputs".equals(action)) {
        JsonArray availableOutputs = new JsonArray();
        synchronized (outputs) {
            for (DianneOutputs o : outputs) {
                for (OutputDescription output : o.getAvailableOutputs()) {
                    JsonObject ob = new JsonObject();
                    ob.add("name", new JsonPrimitive(output.getName()));
                    ob.add("type", new JsonPrimitive(output.getType()));
                    availableOutputs.add(ob);
                }/*from  w w  w.ja v  a 2 s  .  c o m*/
            }
        }
        response.getWriter().write(availableOutputs.toString());
        response.getWriter().flush();
    } else if ("setoutput".equals(action)) {
        String nnId = request.getParameter("nnId");
        String outputId = request.getParameter("outputId");
        String output = request.getParameter("output");
        // TODO only forward to applicable outputmgr?
        synchronized (outputs) {
            for (DianneOutputs o : outputs) {
                o.setOutput(UUID.fromString(nnId), UUID.fromString(outputId), output);
            }
        }
    } else if ("unsetoutput".equals(action)) {
        String nnId = request.getParameter("nnId");
        String outputId = request.getParameter("outputId");
        String output = request.getParameter("output");
        // TODO only forward to applicable outputmgr?
        synchronized (outputs) {
            for (DianneOutputs o : outputs) {
                o.unsetOutput(UUID.fromString(nnId), UUID.fromString(outputId), output);
            }
        }
    }
}

From source file:be.iminds.iot.dianne.builder.DianneRunner.java

License:Open Source License

private String outputSSEMessage(UUID outputId, String[] outputLabels, Tensor output, long time,
        String... tags) {/*from  w w  w . j a  v  a2  s. c  om*/
    JsonObject data = jsonConverter.toJson(output);

    float max = TensorOps.max(output);
    if (outputLabels != null || isProbability(output)) {
        // format output as [['label', val],['label2',val2],...] for in highcharts
        String[] labels;
        float[] values;
        if (output.size() > 10) {
            // if more than 10 outputs, only send top-10 results
            Integer[] indices = new Integer[output.size()];
            for (int i = 0; i < output.size(); i++) {
                indices[i] = i;
            }
            Arrays.sort(indices, new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    float v1 = output.get(o1);
                    float v2 = output.get(o2);
                    // inverse order to have large->small order
                    return v1 > v2 ? -1 : (v1 < v2 ? 1 : 0);
                }
            });
            labels = new String[10];
            values = new float[10];
            for (int i = 0; i < 10; i++) {
                labels[i] = outputLabels != null ? outputLabels[indices[i]] : "" + indices[i];
                values[i] = output.get(indices[i]);
            }
        } else {
            labels = outputLabels;
            if (labels == null) {
                labels = new String[output.size()];
                for (int i = 0; i < labels.length; i++) {
                    labels[i] = "" + i;
                }
            }
            values = output.get();
        }

        JsonArray probabilities = new JsonArray();
        for (int i = 0; i < values.length; i++) {
            // if negative values for classification - assume log probabilities
            // take exp to return probability
            if (max < 0) {
                values[i] = (float) Math.exp(values[i]);
            }
            probabilities.add(new JsonPrimitive(values[i]));
        }
        data.add("probabilities", probabilities);

        JsonArray l = new JsonArray();
        for (int i = 0; i < labels.length; i++) {
            l.add(new JsonPrimitive(labels[i]));
        }
        data.add("labels", l);
    }

    if (time > 0) {
        data.add("time", new JsonPrimitive(time));
    }

    if (tags != null) {
        JsonArray ta = new JsonArray();
        for (String tt : tags) {
            if (tt.equals("ui") || tt.startsWith("_")) // ignore the ui tag
                continue;

            ta.add(new JsonPrimitive(tt));
        }
        data.add("tags", ta);
    }

    data.add("id", new JsonPrimitive(outputId.toString()));

    StringBuilder builder = new StringBuilder();
    builder.append("data: ").append(data.toString()).append("\n\n");
    return builder.toString();
}

From source file:be.iminds.iot.dianne.builder.DianneVAE.java

License:Open Source License

@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setContentType("application/json");
    String d = request.getParameter("dataset");
    if (d == null) {
        System.out.println("No dataset provided");
        return;// www . j a  v a 2s  .  c om
    }
    Dataset dataset = datasets.getDataset(d);
    if (dataset == null) {
        System.out.println("No such dataset found: " + d);
        return;
    }

    String enc = request.getParameter("encoder");
    if (enc == null) {
        System.out.println("No encoder provided");
        return;
    }

    NeuralNetwork encoder = nns.get(enc);
    if (encoder == null) {
        try {
            encoder = dianne.getNeuralNetwork(platform.deployNeuralNetwork(enc, new String[] { "vae" }))
                    .getValue();
            nns.put(enc, encoder);
        } catch (Exception e) {
            e.printStackTrace();
            return;
        }
    }

    NeuralNetwork decoder = null;
    String dec = request.getParameter("decoder");
    if (dec != null) {
        decoder = nns.get(dec);
        if (decoder == null) {
            try {
                decoder = dianne.getNeuralNetwork(platform.deployNeuralNetwork(dec, new String[] { "vae" }))
                        .getValue();
                nns.put(dec, decoder);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    int size = this.size;
    String s = request.getParameter("size");
    if (s != null) {
        size = Integer.parseInt(s);
    }

    JsonArray result = new JsonArray();

    String sample = request.getParameter("sample");
    String l = request.getParameter("latent");
    if (sample == null && l == null) {
        // fetch random samples from dataset
        for (int i = 0; i < size; i++) {
            JsonObject o = new JsonObject();
            int index = random.nextInt(dataset.size());
            Tensor data = dataset.getSample(index).input;
            Tensor latent = encoder.forward(data);

            o.add("index", new JsonPrimitive(index));
            o.add("data", converter.toJson(data));
            o.add("latent", converter.toJson(latent));

            result.add(o);
        }

    } else {
        Tensor latent = null;
        if (sample != null) {
            int index = Integer.parseInt(sample);
            Tensor base = dataset.getSample(index).input;
            latent = encoder.forward(base).clone();
        } else {
            Tensor lmeans = converter.fromString(l);
            latent = new Tensor(lmeans.size() * 2);
            latent.fill(0.0f);
            lmeans.copyInto(latent.narrow(0, lmeans.size()));
        }
        if (decoder != null) {
            // generate samples using the decoder
            Tensor mean = latent.narrow(0, latent.size() / 2);
            Tensor stdev = latent.narrow(latent.size() / 2, latent.size() / 2);
            Tensor rand = new Tensor(latent.size() / 2);
            Tensor rand2 = null;

            for (int i = 0; i < size; i++) {
                rand.randn();
                TensorOps.cmul(rand, rand, stdev);
                TensorOps.add(rand, rand, mean);

                Tensor reconstruction = decoder.forward(rand);
                Tensor rmean = reconstruction.narrow(0, reconstruction.size() / 2);
                Tensor rstdev = reconstruction.narrow(reconstruction.size() / 2, reconstruction.size() / 2);

                if (rand2 == null) {
                    rand2 = new Tensor(rmean.dims());
                }
                rand2.randn();
                TensorOps.cmul(rand2, rand2, rstdev);
                TensorOps.add(rand2, rand2, rmean);

                JsonObject o = new JsonObject();
                o.add("index", new JsonPrimitive(-1));
                o.add("data", converter.toJson(rand2));
                o.add("latent", converter.toJson(latent));
                result.add(o);
            }

        } else {
            // search for samples close to this sample in the dataset
            final Tensor baseline = latent;
            SortedSet<LatentSample> set = new TreeSet<>(new Comparator<LatentSample>() {
                @Override
                public int compare(LatentSample o1, LatentSample o2) {
                    Tensor diff = TensorOps.sub(null, o1.latent.narrow(0, baseline.size() / 2),
                            baseline.narrow(0, baseline.size() / 2));
                    Float d1 = TensorOps.dot(diff, diff);
                    diff = TensorOps.sub(null, o2.latent.narrow(0, baseline.size() / 2),
                            baseline.narrow(0, baseline.size() / 2));
                    Float d2 = TensorOps.dot(diff, diff);
                    return d1.compareTo(d2);
                }
            });

            for (int i = 0; i < tries; i++) {
                LatentSample ls = new LatentSample();
                ls.index = random.nextInt(dataset.size());
                ls.data = dataset.getSample(ls.index).input;
                ls.latent = encoder.forward(ls.data).clone();
                set.add(ls);

                if (set.size() > size) {
                    set.remove(set.last());
                }
            }

            for (LatentSample ls : set) {
                JsonObject o = new JsonObject();
                o.add("index", new JsonPrimitive(ls.index));
                o.add("data", converter.toJson(ls.data));
                o.add("latent", converter.toJson(ls.latent));
                result.add(o);
            }
        }
    }

    response.getWriter().println(result);
    response.getWriter().flush();
}

From source file:be.iminds.iot.dianne.nn.util.DianneJSONConverter.java

License:Open Source License

public static JsonObject toJson(ModuleDTO dto) {
    JsonObject module = new JsonObject();

    module.add("id", new JsonPrimitive(dto.id.toString()));
    module.add("type", new JsonPrimitive(dto.type));

    if (dto.next != null) {
        JsonArray next = new JsonArray();
        for (UUID n : dto.next) {
            next.add(new JsonPrimitive(n.toString()));
        }//from ww  w. j  a v  a  2  s.  c  o  m
        module.add("next", next);
    }

    if (dto.prev != null) {
        JsonArray prev = new JsonArray();
        for (UUID p : dto.prev) {
            prev.add(new JsonPrimitive(p.toString()));
        }
        module.add("prev", prev);
    }

    if (dto.properties != null) {
        for (String k : dto.properties.keySet()) {
            module.add(k, new JsonPrimitive(dto.properties.get(k)));
        }
    }

    return module;
}

From source file:be.iminds.iot.dianne.nn.util.DianneJSONRPCRequestFactory.java

License:Open Source License

public static JsonObject createLearnRequest(int id, NeuralNetworkDTO nn, String dataset,
        Map<String, String> properties) {
    JsonObject request = new JsonObject();
    request.add("jsonrpc", new JsonPrimitive("2.0"));
    request.add("method", new JsonPrimitive("learn"));
    request.add("id", new JsonPrimitive(id));

    JsonArray params = new JsonArray();
    params.add(DianneJSONConverter.toJson(nn));
    params.add(new JsonPrimitive(dataset));
    params.add(createJsonFromMap(properties));
    request.add("params", params);

    return request;
}

From source file:be.iminds.iot.dianne.nn.util.DianneJSONRPCRequestFactory.java

License:Open Source License

public static JsonObject createEvalRequest(int id, String nnName, String dataset,
        Map<String, String> properties) {
    JsonObject request = new JsonObject();
    request.add("jsonrpc", new JsonPrimitive("2.0"));
    request.add("method", new JsonPrimitive("eval"));
    request.add("id", new JsonPrimitive(id));

    JsonArray params = new JsonArray();
    params.add(new JsonPrimitive(nnName));
    params.add(new JsonPrimitive(dataset));
    params.add(createJsonFromMap(properties));
    request.add("params", params);

    return request;

}