Esempio n. 1
0
  /**
   * Map path segments to tree nodes, each segment to a set of nodes of a same level from the root
   *
   * @param pathSegments
   * @param treeRoot
   * @return
   * @throws PathException
   */
  public static Map<String, List<JsonNode>> mapPath2Tree(
      List<String> pathSegments, JsonNode treeRoot) throws PathException {

    if (treeRoot == null || !treeRoot.has(pathSegments.get(0))) {
      // Failed from root
      return null;
    }
    Map<String, List<JsonNode>> queryMap = new HashMap<String, List<JsonNode>>();
    for (String s : pathSegments) {
      queryMap.put(s, new ArrayList<JsonNode>());
    }

    for (int i = 0; i < pathSegments.size(); i++) {
      String nodeName = pathSegments.get(i);
      List<JsonNode> ret = new ArrayList<JsonNode>();
      if (i == 0) {
        JsonNode childs = treeRoot.get(nodeName);
        if (childs != null) {
          if (childs.isArray()) {
            Iterator<JsonNode> iter = childs.iterator();
            while (iter.hasNext()) {
              ret.add(iter.next());
            }
          } else {
            ret.add(childs);
          }
        }
      } else {
        // parent node
        List<JsonNode> parents = queryMap.get(pathSegments.get(i - 1));
        for (JsonNode parent : parents) {
          JsonNode childs = parent.get(nodeName);
          if (childs != null) {
            if (childs.isArray()) {
              Iterator<JsonNode> iter = childs.iterator();
              while (iter.hasNext()) {
                ret.add(iter.next());
              }
            } else {
              ret.add(childs);
            }
          }
        }
      }
      if (ret.size() > 0) {
        queryMap.get(nodeName).addAll(ret);
      } else if (i < pathSegments.size() - 1) {
        // not found in the middle of the path
        return null;
      }
    }

    return queryMap;
  }
Esempio n. 2
0
 private static void mergeJsonObject(ObjectNode src, ObjectNode other) {
   Iterator<Map.Entry<String, JsonNode>> ite = other.fields();
   while (ite.hasNext()) {
     Map.Entry<String, JsonNode> pair = ite.next();
     JsonNode s = src.get(pair.getKey());
     JsonNode v = pair.getValue();
     if (v.isObject() && s != null && s.isObject()) {
       mergeJsonObject((ObjectNode) s, (ObjectNode) v);
     } else if (v.isArray() && s != null && s.isArray()) {
       mergeJsonArray((ArrayNode) s, (ArrayNode) v);
     } else {
       src.replace(pair.getKey(), v);
     }
   }
 }
  @Test
  public void testCommandGetFilteredCollection() {
    running(
        fakeApplication(),
        () -> {
          try {
            DbHelper.open("1234567890", TEST_USER, TEST_USER);
            ObjectNode cmd = MAPPER.createObjectNode();
            ObjectNode p = MAPPER.createObjectNode();
            ObjectNode q = MAPPER.createObjectNode();
            q.put("where", "idx < ?");
            ArrayNode params = MAPPER.createArrayNode();
            params.add("5");
            q.put("params", params);
            p.put("collection", TEST_COLLECTION);
            p.put("query", q);

            cmd.put(ScriptCommand.RESOURCE, "documents");
            cmd.put(ScriptCommand.NAME, "list");
            cmd.put(ScriptCommand.PARAMS, p);

            JsonNode node = CommandRegistry.execute(cmd, null);
            assertNotNull(node);
            assertTrue(node.isArray());
            assertEquals(5, node.size());
          } catch (Throwable t) {
            fail(ExceptionUtils.getFullStackTrace(t));
          } finally {
            DbHelper.close(DbHelper.getConnection());
          }
        });
  }
  @Override
  public Tuple convert(String source) {
    TupleBuilder builder = TupleBuilder.tuple();
    try {

      JsonNode root = mapper.readTree(source);
      for (Iterator<Entry<String, JsonNode>> it = root.fields(); it.hasNext(); ) {
        Entry<String, JsonNode> entry = it.next();
        String name = entry.getKey();
        JsonNode node = entry.getValue();
        if (node.isObject()) {
          // tuple
          builder.addEntry(name, convert(node.toString()));
        } else if (node.isArray()) {
          builder.addEntry(name, nodeToList(node));
        } else {
          if (name.equals("id")) {
            // TODO how should this be handled?
          } else if (name.equals("timestamp")) {
            // TODO how should this be handled?
          } else {
            builder.addEntry(name, node.asText());
          }
        }
      }
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
    return builder.build();
  }
Esempio n. 5
0
 private static void mergeJsonArray(ArrayNode src, ArrayNode other) {
   for (int i = 0; i < other.size(); i++) {
     JsonNode s = src.get(i);
     JsonNode v = other.get(i);
     if (s == null) {
       src.add(v);
     } else if (v.isObject() && s.isObject()) {
       mergeJsonObject((ObjectNode) s, (ObjectNode) v);
     } else if (v.isArray() && s.isArray()) {
       mergeJsonArray((ArrayNode) s, (ArrayNode) v);
     } else {
       src.remove(i);
       src.insert(i, v);
     }
   }
 }
  @Override
  public Tuple convert(String source) {
    TupleBuilder builder = TupleBuilder.tuple();
    try {

      JsonNode root = mapper.readTree(source);
      for (Iterator<Entry<String, JsonNode>> it = root.fields(); it.hasNext(); ) {
        Entry<String, JsonNode> entry = it.next();
        String name = entry.getKey();
        JsonNode node = entry.getValue();
        if (node.isObject()) {
          // tuple
          builder.addEntry(name, convert(node.toString()));
        } else if (node.isArray()) {
          builder.addEntry(name, nodeToList(node));
        } else if (node.isNull()) {
          builder.addEntry(name, null);
        } else if (node.isBoolean()) {
          builder.addEntry(name, node.booleanValue());
        } else if (node.isNumber()) {
          builder.addEntry(name, node.numberValue());
        } else {
          builder.addEntry(name, mapper.treeToValue(node, Object.class));
        }
      }
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
    return builder.build();
  }
Esempio n. 7
0
 protected Coordinate[] decodeCoordinates(JsonNode node) throws GeoJSONException {
   if (!node.isArray()) {
     throw new GeoJSONException("expected array");
   }
   Coordinate[] coordinates = new Coordinate[node.size()];
   for (int i = 0; i < node.size(); ++i) {
     coordinates[i] = decodeCoordinate(node.get(i));
   }
   return coordinates;
 }
 @Test
 public void unclosedArray_AutoClosesOnClose() throws IOException {
   jsonGenerator.writeStartArray();
   jsonGenerator.writeValue("valOne");
   jsonGenerator.writeValue("valTwo");
   jsonGenerator.writeValue("valThree");
   JsonNode node = toJsonNode();
   assertTrue(node.isArray());
   assertEquals(3, node.size());
 }
Esempio n. 9
0
  @Test
  public void canWriteSimpleResults() throws IOException {
    libratoWriter.beforeBatch(out);
    libratoWriter.write(out, counterResult1);
    libratoWriter.write(out, counterResult2);
    libratoWriter.write(out, gaugeResult1);
    libratoWriter.write(out, gaugeResult2);
    libratoWriter.afterBatch(out);

    JsonNode tree = objectMapper.readTree(out.toByteArray());
    JsonNode counters = tree.findPath("counters");
    assertThat(counters.isArray()).isTrue();
    assertThat(counters.size()).isEqualTo(2);

    JsonNode counter1 = counters.get(0);
    assertThat(counter1.get("name").textValue()).isEqualTo("counter1");
    assertThat(counter1.get("source").textValue()).isEqualTo("myHost.test.net");
    assertThat(counter1.get("measure_time").intValue()).isEqualTo(1);
    assertThat(counter1.get("value").intValue()).isEqualTo(1);

    JsonNode counter2 = counters.get(1);
    assertThat(counter2.get("name").textValue()).isEqualTo("counter2");
    assertThat(counter2.get("source").textValue()).isEqualTo("myHost.test.net");
    assertThat(counter2.get("measure_time").intValue()).isEqualTo(2);
    assertThat(counter2.get("value").longValue()).isEqualTo(2L);

    JsonNode gauges = tree.findPath("gauges");
    assertThat(gauges.isArray()).isTrue();

    JsonNode gauge1 = gauges.get(0);
    assertThat(gauge1.get("name").textValue()).isEqualTo("gauge1");
    assertThat(gauge1.get("source").textValue()).isEqualTo("myHost.test.net");
    assertThat(gauge1.get("measure_time").intValue()).isEqualTo(3);
    assertThat(gauge1.get("value").doubleValue()).isEqualTo(3.3);

    JsonNode gauge2 = gauges.get(1);
    assertThat(gauge2.get("name").textValue()).isEqualTo("gauge2");
    assertThat(gauge2.get("source").textValue()).isEqualTo("myHost.test.net");
    assertThat(gauge2.get("measure_time").intValue()).isEqualTo(4);
    assertThat(gauge2.get("value").floatValue()).isEqualTo(4.4f);
  }
Esempio n. 10
0
  /**
   * Determines whether or not the given {@link JsonNode} matches the given type. This method is
   * limitted to a few java types only and shouldn't be used to determine with great accuracy
   * whether or not the types match.
   *
   * @param node the {@link JsonNode}
   * @param type the {@link Class}
   * @return true if the types match, false otherwise
   */
  protected boolean isMatchingType(JsonNode node, Class<?> type) {

    if (node.isNull()) {
      return true;

    } else if (node.isTextual()) {
      return String.class.isAssignableFrom(type);

    } else if (node.isNumber()) {
      return Number.class.isAssignableFrom(type)
          || short.class.isAssignableFrom(type)
          || int.class.isAssignableFrom(type)
          || long.class.isAssignableFrom(type)
          || float.class.isAssignableFrom(type)
          || double.class.isAssignableFrom(type);

    } else if (node.isArray() && type.isArray()) {
      return (node.size() > 0) ? isMatchingType(node.get(0), type.getComponentType()) : false;

    } else if (node.isArray()) {
      return type.isArray() || Collection.class.isAssignableFrom(type);

    } else if (node.isBinary()) {
      return byte[].class.isAssignableFrom(type)
          || Byte[].class.isAssignableFrom(type)
          || char[].class.isAssignableFrom(type)
          || Character[].class.isAssignableFrom(type);

    } else if (node.isBoolean()) {
      return boolean.class.isAssignableFrom(type) || Boolean.class.isAssignableFrom(type);

    } else if (node.isObject() || node.isPojo()) {
      return !type.isPrimitive()
          && !String.class.isAssignableFrom(type)
          && !Number.class.isAssignableFrom(type)
          && !Boolean.class.isAssignableFrom(type);
    }

    // not sure if it's a matching type
    return false;
  }
Esempio n. 11
0
 @Override
 public Object valueFromJson(JsonNode node) {
   if (node.isArray()) {
     if (node.size() == 2) {
       if (node.get(0).isTextual() && "map".equals(node.get(0).asText())) {
         OvsdbMap<Object, Object> map = new OvsdbMap<Object, Object>();
         for (JsonNode pairNode : node.get(1)) {
           if (pairNode.isArray() && node.size() == 2) {
             Object key = getKeyType().toValue(pairNode.get(0));
             Object value = getBaseType().toValue(pairNode.get(1));
             map.put(key, value);
           }
         }
         return map;
       } else if (node.size() == 0) {
         return null;
       }
     }
   }
   return null;
 }
Esempio n. 12
0
 protected GeometryCollection decodeGeometryCollection(JsonNode node, GeometryFactory fac)
     throws GeoJSONException {
   final JsonNode geometries = node.path(GEOMETRIES);
   if (!geometries.isArray()) {
     throw new GeoJSONException("expected 'geometries' array");
   }
   Geometry[] geoms = new Geometry[geometries.size()];
   for (int i = 0; i < geometries.size(); ++i) {
     geoms[i] = decodeGeometry(geometries.get(i), fac);
   }
   return fac.createGeometryCollection(geoms);
 }
 private AutoPromotionProperty loadAutoPromotionProperty(JsonNode node) {
   // Backward compatibility (before 2.14)
   if (node.isArray()) {
     return new AutoPromotionProperty(readValidationStamps(node), "", "");
   } else {
     JsonNode validationStamps = node.get("validationStamps");
     List<ValidationStamp> validationStampList = readValidationStamps(validationStamps);
     return new AutoPromotionProperty(
         validationStampList,
         JsonUtils.get(node, "include", false, ""),
         JsonUtils.get(node, "exclude", false, ""));
   }
 }
Esempio n. 14
0
 public void testEmbeddedObjectInArray() throws Exception {
   TokenBuffer buf = new TokenBuffer(MAPPER);
   buf.writeStartArray();
   buf.writeObject(MARKER);
   buf.writeEndArray();
   JsonNode node = MAPPER.readTree(buf.asParser());
   buf.close();
   assertTrue(node.isArray());
   assertEquals(1, node.size());
   JsonNode n = node.get(0);
   assertTrue(n.isPojo());
   assertSame(MARKER, ((POJONode) n).getPojo());
 }
 @Test
 public void stringArray() throws IOException {
   jsonGenerator.writeStartArray();
   jsonGenerator.writeValue("valOne");
   jsonGenerator.writeValue("valTwo");
   jsonGenerator.writeValue("valThree");
   jsonGenerator.writeEndArray();
   JsonNode node = toJsonNode();
   assertTrue(node.isArray());
   assertEquals("valOne", node.get(0).textValue());
   assertEquals("valTwo", node.get(1).textValue());
   assertEquals("valThree", node.get(2).textValue());
 }
  @Override
  public void validate(final ValidationReport report, final JsonNode instance) {
    final JsonNode oldParent = report.getSchema();

    report.setSchema(parent);

    for (final KeywordValidator validator : validators)
      validator.validateInstance(report, instance);

    if (!(instance.isContainerNode() || report.isSuccess())) {
      report.setSchema(oldParent);
      return;
    }

    final JsonPointer ptr = report.getPath();

    JsonPointer current;

    if (instance.isArray()) {
      JsonNode subSchema;
      int i = 0;
      for (final JsonNode element : instance) {
        current = ptr.append(i);
        report.setPath(current);
        subSchema = arrayPath(i);
        JsonSchema.fromNode(parent, subSchema).validate(report, element);
        i++;
      }
      report.setSchema(oldParent);
      report.setPath(ptr);
      return;
    }

    // Can only be an object now
    final Map<String, JsonNode> map = CollectionUtils.toMap(instance.fields());

    String key;
    JsonNode value;

    for (final Map.Entry<String, JsonNode> entry : map.entrySet()) {
      key = entry.getKey();
      value = entry.getValue();
      current = ptr.append(key);
      report.setPath(current);
      for (final JsonNode subSchema : objectPath(key))
        JsonSchema.fromNode(parent, subSchema).validate(report, value);
    }

    report.setSchema(oldParent);
    report.setPath(ptr);
  }
 private List<Object> nodeToList(JsonNode node) {
   List<Object> list = new ArrayList<Object>(node.size());
   for (int i = 0; i < node.size(); i++) {
     JsonNode item = node.get(i);
     if (item.isObject()) {
       list.add(convert(item.toString()));
     } else if (item.isArray()) {
       list.add(nodeToList(item));
     } else {
       list.add(item.asText());
     }
   }
   return list;
 }
Esempio n. 18
0
  /** More complicated test */
  public static void test2() {
    ObjectMapper mapper = new ObjectMapper(); // create once, reuse
    try {
      String fullPath = System.getProperty("user.dir") + File.separator + "etc/RES-15-46.json";

      // Target
      JsonNode root = mapper.readTree(new File(fullPath));
      System.out.println("URI: " + root.get("uri"));

      //			JsonNode targets = root.get("targets");
      //			if (targets.isArray()) {
      //				Iterator<JsonNode> iter = targets.elements();
      //				while (iter.hasNext()) {
      //					JsonNode node = iter.next();
      //					System.out.println(node.get("name").asText());
      //				}
      //			}

      // try null
      //			JsonNode cannotBeFound = root.get("aaa");
      //			System.out.println(cannotBeFound);
      //			cannotBeFound = root.path("aaa");
      //			System.out.println(cannotBeFound.isMissingNode());
      //
      //			cannotBeFound = root.with("aaa");
      //			System.out.println(cannotBeFound);

      // Try to query
      JsonNode result = root.path("targets");
      System.out.println(result.isArray());

      //			List<JsonNode> list = root.findValues("system");
      //			for (JsonNode n : list) {
      //				System.out.println(n.get("uri").asText());
      //				((ObjectNode) n).put("uri", "new uri");
      //			}
      //			ObjectWriter w = mapper.writer().with(
      //					SerializationFeature.INDENT_OUTPUT);
      //			w.writeValue(new File(System.getProperty("user.dir")
      //					+ File.separator + "user-modified.json"), root);

    } catch (JsonProcessingException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
 private JsonNode createProduct(JsonNode node, String userName) throws Exception {
   ObjectMapper om = new ObjectMapper();
   ArrayNode anode = om.createArrayNode();
   if (node.isArray()) {
     Iterator<JsonNode> nodeiterator = node.iterator();
     while (nodeiterator.hasNext()) {
       ProductBack cbase = om.convertValue(nodeiterator.next(), ProductBack.class);
       anode.add(createProductToDb(om, cbase, userName));
     }
   } else {
     ProductBack cbase = JSON.parseObject(node.asText(), ProductBack.class);
     anode.add(createProductToDb(om, cbase, userName));
   }
   return anode;
 }
Esempio n. 20
0
  @Test
  public void nonNumericValuesAreSentEmpty() throws IOException {
    libratoWriter.beforeBatch(out);
    libratoWriter.write(out, new QueryResult("nonNumeric", COUNTER, "stringValue", 1000));
    libratoWriter.afterBatch(out);

    JsonNode tree = objectMapper.readTree(out.toByteArray());
    JsonNode counters = tree.findPath("counters");
    assertThat(counters.isArray()).isTrue();
    assertThat(counters.size()).isEqualTo(1);

    JsonNode counter1 = counters.get(0);
    assertThat(counter1.get("name").textValue()).isEqualTo("nonNumeric");
    assertThat(counter1.get("value")).isNull();
  }
Esempio n. 21
0
 protected Polygon decodePolygonCoordinates(JsonNode coordinates, GeometryFactory fac)
     throws GeoJSONException {
   if (!coordinates.isArray()) {
     throw new GeoJSONException("expected array");
   }
   if (coordinates.size() < 1) {
     throw new GeoJSONException("missing polygon shell");
   }
   LinearRing shell = fac.createLinearRing(decodeCoordinates(coordinates.get(0)));
   LinearRing[] holes = new LinearRing[coordinates.size() - 1];
   for (int i = 1; i < coordinates.size(); ++i) {
     holes[i - 1] = fac.createLinearRing(decodeCoordinates(coordinates.get(i)));
   }
   return fac.createPolygon(shell, holes);
 }
Esempio n. 22
0
  @Test
  public void atomicLongAreSentAsNumbers() throws IOException {
    libratoWriter.beforeBatch(out);
    libratoWriter.write(out, new QueryResult("atomicLong", COUNTER, new AtomicLong(2), 1000));
    libratoWriter.afterBatch(out);

    JsonNode tree = objectMapper.readTree(out.toByteArray());
    JsonNode counters = tree.findPath("counters");
    assertThat(counters.isArray()).isTrue();
    assertThat(counters.size()).isEqualTo(1);

    JsonNode counter1 = counters.get(0);
    assertThat(counter1.get("name").textValue()).isEqualTo("atomicLong");
    assertThat(counter1.get("value").longValue()).isEqualTo(2);
  }
Esempio n. 23
0
  /**
   * Handles the given {@link JsonNode} and writes the responses to the given {@link OutputStream}.
   *
   * @param node the {@link JsonNode}
   * @param ops the {@link OutputStream}
   * @throws IOException on error
   */
  protected void handleNode(JsonNode node, OutputStreamWrapper opsw) throws IOException {

    // handle objects
    if (node.isObject()) {
      handleObject(ObjectNode.class.cast(node), opsw);

      // handle arrays
    } else if (node.isArray()) {
      handleArray(ArrayNode.class.cast(node), opsw);

      // bail on bad data
    } else {
      throw new IllegalArgumentException("Invalid JsonNode type: " + node.getClass().getName());
    }
  }
 private List<ValidationStamp> readValidationStamps(JsonNode validationStampIds) {
   List<ValidationStamp> validationStampList;
   if (validationStampIds.isArray()) {
     List<Integer> ids = new ArrayList<>();
     validationStampIds.forEach(id -> ids.add(id.asInt()));
     // Reading the validation stamps and then the names
     validationStampList =
         ids.stream()
             .map(id -> structureService.getValidationStamp(ID.of(id)))
             .collect(Collectors.toList());
   } else {
     throw new AutoPromotionPropertyCannotParseException(
         "Cannot get the list of validation stamps");
   }
   return validationStampList;
 }
  @Override
  public void receiveLoop() {
    log.debug("receiveLoop starts");
    ObjectReader reader = this.mapper.reader();

    while (true) {
      try {
        JsonNode root = reader.readTree(this.istream);
        String type = root.path(TYPE).asText();
        JsonNode data = root.path(DATA);
        log.debug("Processing {} with {}", type, data);
        if (type.equals(GOODBYE)) {
          log.info("Connection closing from server.");
          break;
        } else if (type.equals(HELLO)) {
          this.receiveHello(data);
        } else if (type.equals(LOCALE)) {
          this.receiveHello(data);
        } else if (type.equals(PONG)) {
          // silently ignore
        } else if (!data.isMissingNode() || (root.isArray() && ((ArrayNode) root).size() > 0)) {
          // process replies with a data node or non-empty arrays
          JsonClientReply reply = new JsonClientReply(root);
          Runnable r = new RcvNotifier(reply, mLastSender, this);
          try {
            SwingUtilities.invokeAndWait(r);
          } catch (InterruptedException e) {
            log.error("Exception notifying listeners of reply: {}", e.getMessage(), e);
          } catch (InvocationTargetException e) {
            log.error("Exception notifying listeners of reply: {}", e.getMessage(), e);
          }
        }
      } catch (IOException e) {
        this.rcvException = true;
        reportReceiveLoopException(e);
        break;
      } catch (NoSuchElementException nse) {
        // we get an NSE when we are finished with this client
        // so break out of the loop
        break;
      }
    }
    ConnectionStatus.instance()
        .setConnectionState(this.controller.getCurrentPortName(), ConnectionStatus.CONNECTION_DOWN);
    log.error("Exit from rcv loop");
    this.recovery();
  }
Esempio n. 26
0
  /**
   * Return true if value is not present or if underlying JSON is empty object, array or null.
   * WARNING this method can throw same exceptions as {@link JsonNodeValue#get()} in a case if
   * source is invalid JSON string.
   */
  public boolean isEmpty() {
    if (!isPresent()) {
      return true;
    }

    JsonNode n = get();

    if ((n.isObject() || n.isArray()) && n.size() == 0) {
      return true;
    }

    if (n.isNull()) {
      return true;
    }

    return false;
  }
Esempio n. 27
0
  private static void testJson() {
    String json1 = "[\"hello\"]";
    JsonNode jsonNode = Json.parse(json1);
    Json.stringify(jsonNode);
    System.out.println(jsonNode.toString());
    System.out.println(Json.stringify(jsonNode));
    ObjectNode jsonObject = Json.newObject();
    jsonObject.put("hello", jsonNode);
    jsonObject.put("hello", 56);
    System.out.println(jsonObject.toString());
    List<Object> strings = new ArrayList<Object>();
    strings.add("hello");
    strings.add("world");
    jsonObject.put("test", Json.toJson(strings));
    System.out.println(jsonObject.toString());
    jsonObject.put("test2", Json.toJson("string"));
    jsonObject.put("test2", Json.toJson("sshshhs"));
    List<String> list = new ArrayList<String>();
    list.add("hello me");
    // ObjectNode objectNode = Json.newObject();

    jsonObject.put("me", Json.toJson(list));
    System.out.println(jsonObject.toString());
    System.out.println(jsonObject.size());
    System.out.println(jsonObject.get("test").isArray());
    JsonNode jsonNode1 = jsonObject.get("test");
    Iterator iterator = jsonNode1.iterator();
    while ((iterator.hasNext())) {
      System.out.println(iterator.next());
    }
    Iterator<JsonNode> iterator1 = jsonObject.iterator();
    while (iterator1.hasNext()) {
      System.out.println("----------------------");
      JsonNode jsonNode2 = iterator1.next();
      if (jsonNode2.isArray()) {
        Iterator iterator2 = jsonNode2.iterator();
        while ((iterator2.hasNext())) {
          System.out.println(iterator2.next());
        }
      } else {
        if (jsonNode2.isTextual()) {
          System.out.println("String:" + jsonNode2);
        }
      }
    }
  }
  private BasicDBList processGeneList(String genes) {

    BasicDBList list = new BasicDBList();

    Client wsRestClient = Client.create();
    WebResource webResource =
        wsRestClient.resource("http://ws.bioinfo.cipf.es/cellbase/rest/latest/hsa/feature/gene/");

    ObjectMapper mapper = new ObjectMapper();

    String response =
        webResource.path(genes).path("info").queryParam("of", "json").get(String.class);

    try {
      JsonNode actualObj = mapper.readTree(response);
      Iterator<JsonNode> it = actualObj.iterator();
      Iterator<JsonNode> aux;

      while (it.hasNext()) {
        JsonNode node = it.next();
        if (node.isArray()) {

          aux = node.iterator();
          while (aux.hasNext()) {
            JsonNode auxNode = aux.next();

            DBObject regionClause = new BasicDBObject("chr", auxNode.get("chromosome").asText());
            regionClause.put(
                "pos",
                new BasicDBObject("$gte", auxNode.get("start").asInt())
                    .append("$lte", auxNode.get("end").asInt()));
            list.add(regionClause);
          }
        }
      }

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

    return list;
  }
  private void setupArrayNodes(final JsonNode schema) {
    JsonNode node = schema.path("items");

    /**
     * We don't bother at this point: if items is a schema, then it will be used for each and every
     * element of the instance to validate -- it's just as if additionalItems were never defined.
     * So, as items is defined as a list above, we just leave it empty and assign the contents of
     * the keyword to additionalItems.
     */
    if (node.isObject()) {
      additionalItems = node;
      return;
    }

    if (node.isArray()) for (final JsonNode item : node) items.add(item);

    node = schema.path("additionalItems");

    if (node.isObject()) additionalItems = node;
  }
 private List<Object> nodeToList(JsonNode node) throws JsonProcessingException {
   List<Object> list = new ArrayList<Object>(node.size());
   for (int i = 0; i < node.size(); i++) {
     JsonNode item = node.get(i);
     if (item.isObject()) {
       list.add(convert(item.toString()));
     } else if (item.isArray()) {
       list.add(nodeToList(item));
     } else if (item.isNull()) {
       list.add(null);
     } else if (item.isBoolean()) {
       list.add(item.booleanValue());
     } else if (item.isNumber()) {
       list.add(item.numberValue());
     } else {
       list.add(mapper.treeToValue(item, Object.class));
     }
   }
   return list;
 }