@Override public int getLevelCount() { return jsonPointer.getLevelCount(); }
@Override public int getLevelCount() { return jsonPointer.getLevelCount(); }
private static Set<PointerAndPermission> removeDeeperRevokes(final JsonPointer resource, final Iterable<PointerAndPermission> grantedResources, final Collection<PointerAndPermission> revokedResources) { final Set<PointerAndPermission> cleared = new HashSet<>(); grantedResources.forEach(pp -> { final JsonPointer pointer = pp.pointer; if (revokedResources.stream().noneMatch(rp -> resource.getLevelCount() > pointer.getLevelCount() && rp.permission.equals(pp.permission) && rp.pointer.getLevelCount() >= pointer.getLevelCount() && Objects.equals(getPrefixPointerOrThrow(rp.pointer, pointer.getLevelCount()), pointer) )) { cleared.add(pp); } } ); return cleared; }
/** * If this node is part of a tree, e. g. it has a parent and/or children, this method returns the level where * this node is located within this tree. * * @return the level of this node within its tree. */ public int getLevel() { final JsonPointer absolutePointer = getAbsolutePointer(); return absolutePointer.getLevelCount(); }
private boolean isOnReferencePointer(final JsonPointer evaluationPointer) { boolean result = true; final int referencePointerLevelCount = referencePointer.getLevelCount(); final int evaluationPointerLevelCount = evaluationPointer.getLevelCount(); int currentLevel = 0; while (result && currentLevel < referencePointerLevelCount && currentLevel < evaluationPointerLevelCount) { final JsonKey referencePointerCurrentLevelKey = referencePointer.get(currentLevel).orElse(null); result = evaluationPointer.get(currentLevel) .filter(k -> k.equals(referencePointerCurrentLevelKey)) .isPresent(); currentLevel++; } return result; }
@Override public PointerLocation apply(final JsonPointer evaluationPointer) { checkNotNull(evaluationPointer, "pointer to be evaluated"); PointerLocation result = PointerLocation.DIFFERENT; if (isOnReferencePointer(evaluationPointer)) { final int evaluationPointerLevelCount = evaluationPointer.getLevelCount(); final int referencePointerLevelCount = referencePointer.getLevelCount(); if (evaluationPointerLevelCount < referencePointerLevelCount) { result = PointerLocation.ABOVE; } else if (evaluationPointerLevelCount > referencePointerLevelCount) { result = PointerLocation.BELOW; } else { result = PointerLocation.SAME; } } return result; }
@Override public Optional<JsonField> getField(final CharSequence key) { requireNonNull(key, "The key or pointer of the field to be retrieved must not be null!"); final JsonPointer pointer = JsonFactory.newPointer(key); Optional<JsonField> result = pointer.getRoot() .map(JsonKey::toString) .map(fields::get); if (1 < pointer.getLevelCount()) { result = result.map(JsonField::getValue) .filter(JsonValue::isObject) .map(JsonValue::asObject) .flatMap(jsonObject -> jsonObject.getField(pointer.nextLevel())); // Recursion } return result; }
@Override public Optional<JsonField> getField(final CharSequence key) { requireNonNull(key, "The key or pointer of the field to be retrieved must not be null!"); final JsonPointer pointer = JsonPointer.of(key); Optional<JsonField> result = pointer.getRoot() .map(JsonKey::toString) .map(fieldMap::getOrNull); if (1 < pointer.getLevelCount()) { result = result.map(JsonField::getValue) .filter(JsonValue::isObject) .map(JsonValue::asObject) .flatMap(jsonObject -> jsonObject.getField(pointer.nextLevel())); // Recursion } return result; }
private Optional<JsonValue> getValueForPointer(final JsonPointer pointer) { final Optional<JsonValue> result; final JsonKey rootKey = pointer.getRoot().orElse(ROOT_KEY); final int levelCount = pointer.getLevelCount(); if (0 == levelCount) { result = Optional.of(this); } else if (1 == levelCount) { // same as getting a value for a key result = getValueForKey(rootKey); } else { result = getValueForKey(rootKey) .filter(JsonValue::isObject) .map(JsonValue::asObject) .flatMap(jsonObject -> jsonObject.getValue(pointer.nextLevel())); } return result; }
private Optional<JsonValue> getValueForPointer(final JsonPointer pointer) { final Optional<JsonValue> result; final JsonKey rootKey = pointer.getRoot().orElse(ROOT_KEY); final int levelCount = pointer.getLevelCount(); if (0 == levelCount) { result = Optional.of(this); } else if (1 == levelCount) { // same as getting a value for a key result = getValueForKey(rootKey); } else { result = getValueForKey(rootKey) .filter(JsonValue::isObject) .map(JsonValue::asObject) .flatMap(jsonObject -> jsonObject.getValue(pointer.nextLevel())); } return result; }
@Override public boolean contains(final CharSequence key) { requireNonNull(key, "The key or pointer to check the existence of a value for must not be null!"); final boolean result; final JsonPointer pointer = JsonFactory.newPointer(key); if (1 >= pointer.getLevelCount()) { result = pointer.getRoot().map(this::containsKey).orElse(false); } else { result = pointer.getRoot() .flatMap(this::getValueForKey) .map(jsonValue -> !jsonValue.isObject() || jsonValue.asObject().contains(pointer.nextLevel())) // Recursion .orElse(false); } return result; }
@Override public boolean contains(final CharSequence key) { requireNonNull(key, "The key or pointer to check the existence of a value for must not be null!"); final boolean result; final JsonPointer pointer = JsonPointer.of(key); if (1 >= pointer.getLevelCount()) { result = pointer.getRoot().map(this::containsKey).orElse(false); } else { result = pointer.getRoot() .flatMap(this::getValueForKey) .map(jsonValue -> !jsonValue.isObject() || jsonValue.asObject().contains(pointer.nextLevel())) // Recursion .orElse(false); } return result; }
private static JsonObject setFieldInHierarchy(final JsonObject target, final JsonPointer pointer, final JsonField jsonField) { if (1 >= pointer.getLevelCount()) { return target.set(jsonField); } final JsonKey rootKey = pointer.getRoot().orElse(ROOT_KEY); final JsonObject newTarget = target.getValue(rootKey) .filter(JsonValue::isObject) .filter(jsonValue -> !jsonValue.isNull()) .map(JsonValue::asObject) .orElseGet(ImmutableJsonObject::empty); // let the recursion begin ]:-) return target.setValue(rootKey, setFieldInHierarchy(newTarget, pointer.nextLevel(), jsonField)); }
private static JsonObject setFieldInHierarchy(final JsonObject target, final JsonPointer pointer, final JsonField jsonField) { if (1 >= pointer.getLevelCount()) { return target.set(jsonField); } final JsonKey rootKey = pointer.getRoot().orElse(ROOT_KEY); final JsonObject newTarget = target.getValue(rootKey) .filter(JsonValue::isObject) .filter(jsonValue -> !jsonValue.isNull()) .map(JsonValue::asObject) .orElseGet(ImmutableJsonObject::empty); // let the recursion begin ]:-) return target.setValue(rootKey, setFieldInHierarchy(newTarget, pointer.nextLevel(), jsonField)); }
/** * Returns a new JSON pointer instance. * * @param rootLevel the JSON key which is the root level of the JSON pointer to create. * @param subPointer the JSON keys which form sub levels to the root level as well as to each other. * @return a new JSON pointer consisting of hierarchical JSON keys. * @throws NullPointerException if any argument is {@code null}. */ static ImmutableJsonPointer of(final JsonKey rootLevel, final JsonPointer subPointer) { checkRootLevel(rootLevel); checkSubPointer(subPointer); final ImmutableJsonPointer result; final List<JsonKey> keyHierarchy = new ArrayList<>(1 + subPointer.getLevelCount()); keyHierarchy.add(rootLevel); subPointer.forEach(keyHierarchy::add); result = newInstance(keyHierarchy); return result; }
private JsonObject removeForPointer(final JsonPointer pointer) { final JsonObject result; final JsonKey rootKey = pointer.getRoot().orElse(ROOT_KEY); final Optional<JsonFieldDefinition> rootKeyDefinition = getDefinitionForKey(rootKey); if (pointer.isEmpty()) { result = this; } else if (1 == pointer.getLevelCount()) { result = removeValueForKey(rootKey); } else { final JsonPointer nextPointerLevel = pointer.nextLevel(); final Predicate<JsonObject> containsNextLevelRootKey = jsonObject -> nextPointerLevel.getRoot() .map(jsonObject::contains) .orElse(false); result = getValueForKey(rootKey) .filter(JsonValue::isObject) .map(JsonValue::asObject) .filter(containsNextLevelRootKey) .map(jsonObject -> jsonObject.remove(nextPointerLevel)) // Recursion .map(withoutValue -> JsonField.newInstance(rootKey, withoutValue, rootKeyDefinition.orElse(null))) .map(this::set) .orElse(this); } return result; }
/** * Returns a new JSON pointer instance. * * @param rootLevel the JSON key which is the root level of the JSON pointer to create. * @param subPointer the JSON keys which form sub levels to the root level as well as to each other. * @return a new JSON pointer consisting of hierarchical JSON keys. * @throws NullPointerException if any argument is {@code null}. */ static ImmutableJsonPointer of(final JsonKey rootLevel, final JsonPointer subPointer) { checkRootLevel(rootLevel); checkSubPointer(subPointer); final ImmutableJsonPointer result; final List<JsonKey> keyHierarchy = new ArrayList<>(1 + subPointer.getLevelCount()); keyHierarchy.add(rootLevel); subPointer.forEach(keyHierarchy::add); result = newInstance(keyHierarchy); return result; }
/** * Verifies that the actual JSON pointer has the expected level count. * * @param expectedLevelCount the expected level count. * @return this assert to allow method chaining. */ public JsonPointerAssert hasLevelCount(final int expectedLevelCount) { isNotNull(); final int actualSize = actual.getLevelCount(); Assertions.assertThat(actualSize) .overridingErrorMessage("Expected JSON object to have size <%d> but was <%d>", expectedLevelCount, actualSize) .isEqualTo(expectedLevelCount); return this; }
private static JsonObjectBuilder setFieldInHierarchy(final ImmutableJsonObjectBuilder target, final JsonPointer pointer, final JsonField field) { if (1 >= pointer.getLevelCount()) { return target.set(field); } final JsonKey rootKey = pointer.getRoot().orElse(ROOT_KEY); final ImmutableJsonObjectBuilder newTarget = newInstance(); final JsonField rootJsonField = target.fields.get(rootKey.toString()); if (null != rootJsonField) { final JsonValue rootValue = rootJsonField.getValue(); if (rootValue.isObject() && !rootValue.isNull()) { newTarget.setAll(rootValue.asObject()); } } // let the recursion begin >:-( final JsonObject jsonObject = setFieldInHierarchy(newTarget, pointer.nextLevel(), field).build(); return target.set(rootKey, jsonObject); }
private static JsonObjectBuilder setFieldInHierarchy(final ImmutableJsonObjectBuilder target, final JsonPointer pointer, final JsonField field) { if (1 >= pointer.getLevelCount()) { return target.set(field); } final JsonKey rootKey = pointer.getRoot().orElse(ROOT_KEY); final ImmutableJsonObjectBuilder newTarget = newInstance(); final JsonField rootJsonField = target.fields.get(rootKey.toString()); if (null != rootJsonField) { final JsonValue rootValue = rootJsonField.getValue(); if (rootValue.isObject() && !rootValue.isNull()) { newTarget.setAll(rootValue.asObject()); } } // let the recursion begin >:-( final JsonObject jsonObject = setFieldInHierarchy(newTarget, pointer.nextLevel(), field).build(); return target.set(rootKey, jsonObject); }