@Override public BinaryOperator<JsonArray> combiner() { return (l,r) -> {l.addAll(r); return l;}; }
/** * GeoJson specifies the order of coordinates as x,y or in geo terms longitude followed by latitude. * Most data sources stick to latitude, longitude though. This function, swaps the two for any dimension array. * * * @param array 2d array with latitude, longitude pairs * @return swapped array 2d array with longitude, latitude pairs */ public static @Nonnull JsonArray swapLatLon(@Nonnull JsonArray array) { if(array.isNotEmpty() && array.first().isArray()) { for(JsonElement e: array) { swapLatLon(e.asArray()); } } else { if(array.size() < 2) { throw new IllegalArgumentException("need at least two coordinates"); } JsonElement first = array.get(0); JsonElement second = array.get(1); array.set(0, second); array.set(1, first); } return array; }
/** * Variant of add that adds one or more JsonElements. * @param elements elements */ public void add(@Nonnull JsonElement...elements) { for (JsonElement element : elements) { add(element); } }
public void shouldDoDeepClone() { JsonArray a = array(1, 2, 3); JsonArray cloneOfA = a.deepClone(); assertThat(a).isEqualTo(cloneOfA); a.remove(1); assertThat(a).isNotEqualTo(cloneOfA); JsonArray b = array(); b.addAll(cloneOfA); assertThat(b).isEqualTo(b.clone()); assertThat(b).isEqualTo(cloneOfA); }
/** * Takes a two dimensional linestring and creates a three dimensional polygon from it. Also closes the polygon if needed. * @param lineString 2d JsonArray * @return 3d double array with the polygon */ public static @Nonnull JsonArray lineStringToPolygon(@Nonnull JsonArray lineString) { if(!lineString.first().equals(lineString.last())) { JsonElement e = lineString.first().deepClone(); lineString.add(e); } return array(lineString); }
"or a string"); assertTrue(object.getArray("array").isArray(), "works for arrays as well"); assertTrue(object.getObject("a","b").isObject(), assertTrue(object.getString("1","2","3","4","5").equals("xxx"), "yep, we just added a string value 5 levels deep that did not exist so far"); object.getOrCreateArray("5","4","3","2","1").add("xxx"); assertTrue(object.getArray("5","4","3","2","1").contains("xxx"), "naturally it works for arrays too"); assertTrue(array.get(1) == array.get("bar"), "returns the same object"); assertTrue(array.contains(primitive("foo")), "obviously this works"); assertTrue(array.contains("foo"), "but this works as well");
/** * Variant of contains that checks if the array contains something that can be extracted with JsonElement get(final String label). * @param label label * @return true if the array contains the element */ public boolean contains(final String label) { return get(label) != null; }
@Override public Supplier<JsonArray> supplier() { return () -> new JsonArray(); }
public Optional<Boolean> maybeGetBoolean(int index) { return maybeGet(index).map(e -> e.asBoolean()); }
@Test(expectedExceptions=IllegalStateException.class) public void shouldNotAllowMutationsOnElement() { JsonArray list = array(array(1)).immutableClone(); JsonArray l2=list.first().asArray(); l2.add(2); }
public void shouldReplaceElement() { JsonArray array = array("bar","foo"); assertThat(array.replace("bar", "rab"), is(true)); assertThat(array.replace("bar", "rab"), is(false)); assertThat(array.contains("rab"), is(true)); assertThat(array.contains("foo"), is(true)); assertThat(array.contains("bar"), is(false)); }
public void shouldRemovePrimitive() { JsonArray array = array("1","2","3"); array.remove("2"); assertThat("should be removed as primitive", !array.contains(primitive("2"))); assertThat("should be removed as primitive", !array.contains("2")); array.remove(primitive("3")); assertThat("should be removed", !array.contains(primitive("3"))); assertThat("should be removed", !array.contains("3")); }