src/main/java/org/apache/johnzon/core/JsonPointerImpl.java - sling-org-apache-sling-commons-johnzon - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements. See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership. The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License. You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied. See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 package org.apache.johnzon.core;

 import javax.json.Json;
 import javax.json.JsonArray;
 import javax.json.JsonArrayBuilder;
 import javax.json.JsonException;
 import javax.json.JsonObject;
 import javax.json.JsonObjectBuilder;
 import javax.json.JsonPointer;
 import javax.json.JsonStructure;
 import javax.json.JsonValue;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;


 public class JsonPointerImpl implements JsonPointer {

     private final String jsonPointer;
     private final List<String> referenceTokens = new ArrayList<>();
     private final String lastReferenceToken;

     /**
      * Constructs and initializes a JsonPointer.
      *
      * @param jsonPointer the JSON Pointer string
      * @throws NullPointerException if {@code jsonPointer} is {@code null}
      * @throws JsonException        if {@code jsonPointer} is not a valid JSON Pointer
      */
     public JsonPointerImpl(String jsonPointer) {
         if (jsonPointer == null) {
             throw new NullPointerException("jsonPointer must not be null");
         }
         if (!jsonPointer.equals("") && !jsonPointer.startsWith("/")) {
             throw new JsonException("A non-empty JsonPointer string must begin with a '/'");
         }

         this.jsonPointer = jsonPointer;
         String[] encodedReferenceTokens = jsonPointer.split("/", -1);

         for (String encodedReferenceToken : encodedReferenceTokens) {
             referenceTokens.add(JsonPointerUtil.decode(encodedReferenceToken));
         }
         lastReferenceToken = referenceTokens.get(referenceTokens.size() - 1);
     }

     /**
      * Compares this {@code JsonPointer} with another object.
      *
      * @param obj the object to compare this {@code JsonPointer} against
      * @return true if the given object is a {@code JsonPointer} with the same
      * reference tokens as this one, false otherwise.
      */
     @Override
     public boolean equals(Object obj) {
         if (this == obj) {
             return true;
         }
         if (obj == null || getClass() != obj.getClass()) {
             return false;
         }

         JsonPointerImpl that = (JsonPointerImpl) obj;
         return jsonPointer.equals(that.jsonPointer);
     }

     /**
      * Returns the hash code value for this {@code JsonPointer} object.
      * The hash code of this object is defined by the hash codes of it's reference tokens.
      *
      * @return the hash code value for this {@code JsonPointer} object
      */
     @Override
     public int hashCode() {
         return jsonPointer.hashCode();
     }

     /**
      * Returns the value at the referenced location in the specified {@code target}
      *
      * @param target the target referenced by this {@code JsonPointer}
      * @return the referenced value in the target.
      * @throws NullPointerException if {@code target} is null
      * @throws JsonException        if the referenced value does not exist
      */
     public JsonValue getValue(JsonStructure target) {
         if (target == null) {
             throw new NullPointerException("target must not be null");
         }
         if (isEmptyJsonPointer()) {
             return target;
         }

         JsonValue jsonValue = target;
         for (int i = 1; i < referenceTokens.size(); i++) {
             jsonValue = getValue(jsonValue, referenceTokens.get(i), i, referenceTokens.size() - 1);
         }
         return jsonValue;
     }

     @Override
     public boolean containsValue(JsonStructure target) {
         try {
             getValue(target);
             return true;
         } catch (JsonException je) {
             return false;
         }
     }

     /**
      * Adds or replaces a value at the referenced location in the specified
      * {@code target} with the specified {@code value}.
      * <ol>
      * <li>If the reference is the target (empty JSON Pointer string),
      * the specified {@code value}, which must be the same type as
      * specified {@code target}, is returned.</li>
      * <li>If the reference is an array element, the specified {@code value} is inserted
      * into the array, at the referenced index. The value currently at that location, and
      * any subsequent values, are shifted to the right (adds one to the indices).
      * Index starts with 0. If the reference is specified with a "-", or if the
      * index is equal to the size of the array, the value is appended to the array.</li>
      * <li>If the reference is a name/value pair of a {@code JsonObject}, and the
      * referenced value exists, the value is replaced by the specified {@code value}.
      * If the value does not exist, a new name/value pair is added to the object.</li>
      * </ol>
      *
      * @param target the target referenced by this {@code JsonPointer}
      * @param value  the value to be added
      * @return the transformed {@code target} after the value is added.
      * @throws NullPointerException if {@code target} is {@code null}
      * @throws JsonException        if the reference is an array element and
      *                              the index is out of range ({@code index < 0 || index > array size}),
      *                              or if the pointer contains references to non-existing objects or arrays.
      */
     public JsonStructure add(JsonStructure target, JsonValue value) {
         validateAdd(target);
         if (isEmptyJsonPointer()) {
             if (value.getClass() != target.getClass()) {
                 throw new JsonException("The value must have the same type as the target");
             }
             return (JsonStructure) value;
         }

         return addInternal(target, value);
     }

     /**
      * Adds or replaces a value at the referenced location in the specified
      * {@code target} with the specified {@code value}.
      *
      * @param target the target referenced by this {@code JsonPointer}
      * @param value  the value to be added
      * @return the transformed {@code target} after the value is added.
      * @throws NullPointerException if {@code target} is {@code null}
      * @throws JsonException        if the reference is an array element and
      *                              the index is out of range ({@code index < 0 || index > array size}),
      *                              or if the pointer contains references to non-existing objects or arrays.
      * @see #add(JsonStructure, JsonValue)
      */
     public JsonObject add(JsonObject target, JsonValue value) {
         validateAdd(target);

         return addInternal(target, value);
     }

     /**
      * Adds or replaces a value at the referenced location in the specified
      * {@code target} with the specified {@code value}.
      *
      * @param target the target referenced by this {@code JsonPointer}
      * @param value  the value to be added
      * @return the transformed {@code target} after the value is added.
      * @throws NullPointerException if {@code target} is {@code null}
      * @throws JsonException        if the reference is an array element and
      *                              the index is out of range ({@code index < 0 || index > array size}),
      *                              or if the pointer contains references to non-existing objects or arrays.
      * @see #add(JsonStructure, JsonValue)
      */
     public JsonArray add(JsonArray target, JsonValue value) {
         validateAdd(target);

         return addInternal(target, value);
     }

     /**
      * Replaces the value at the referenced location in the specified
      * {@code target} with the specified {@code value}.
      *
      * @param target the target referenced by this {@code JsonPointer}
      * @param value  the value to be stored at the referenced location
      * @return the transformed {@code target} after the value is replaced.
      * @throws NullPointerException if {@code target} is {@code null}
      * @throws JsonException        if the referenced value does not exist,
      *                              or if the reference is the target.
      */
     public JsonStructure replace(JsonStructure target, JsonValue value) {
         if (target instanceof JsonObject) {
             return replace((JsonObject) target, value);
         } else {
             return replace((JsonArray) target, value);
         }
     }

     /**
      * Replaces the value at the referenced location in the specified
      *
      * @param target the target referenced by this {@code JsonPointer}
      * @param value  the value to be stored at the referenced location
      * @return the transformed {@code target} after the value is replaced.
      * @throws NullPointerException if {@code target} is {@code null}
      * @throws JsonException        if the referenced value does not exist,
      *                              or if the reference is the target.
      * @see #replace(JsonStructure, JsonValue)
      */
     public JsonObject replace(JsonObject target, JsonValue value) {
         return add(remove(target), value);
     }

     /**
      * Replaces the value at the referenced location in the specified
      *
      * @param target the target referenced by this {@code JsonPointer}
      * @param value  the value to be stored at the referenced location
      * @return the transformed {@code target} after the value is replaced.
      * @throws NullPointerException if {@code target} is {@code null}
      * @throws JsonException        if the referenced value does not exist,
      *                              or if the reference is the target.
      * @see #replace(JsonStructure, JsonValue)
      */
     public JsonArray replace(JsonArray target, JsonValue value) {
         return add(remove(target), value);
     }

     /**
      * Removes the value at the reference location in the specified {@code target}
      *
      * @param target the target referenced by this {@code JsonPointer}
      * @return the transformed {@code target} after the value is removed.
      * @throws NullPointerException if {@code target} is {@code null}
      * @throws JsonException        if the referenced value does not exist,
      *                              or if the reference is the target.
      */
     public JsonStructure remove(JsonStructure target) {
         if (target instanceof JsonObject) {
             return remove((JsonObject) target);
         } else {
             return remove((JsonArray) target);
         }
     }

     /**
      * Removes the value at the reference location in the specified {@code target}
      *
      * @param target the target referenced by this {@code JsonPointer}
      * @return the transformed {@code target} after the value is removed.
      * @throws NullPointerException if {@code target} is {@code null}
      * @throws JsonException        if the referenced value does not exist,
      *                              or if the reference is the target.
      * @see #remove(JsonStructure)
      */
     public JsonObject remove(JsonObject target) {
         validateRemove(target);

         return (JsonObject) remove(target, 1, referenceTokens.size() - 1);
     }

     /**
      * Removes the value at the reference location in the specified {@code target}
      *
      * @param target the target referenced by this {@code JsonPointer}
      * @return the transformed {@code target} after the value is removed.
      * @throws NullPointerException if {@code target} is {@code null}
      * @throws JsonException        if the referenced value does not exist,
      *                              or if the reference is the target.
      * @see #remove(JsonStructure)
      */
     public JsonArray remove(JsonArray target) {
         validateRemove(target);

         return (JsonArray) remove(target, 1, referenceTokens.size() - 1);
     }

     String getJsonPointer() {
         return jsonPointer;
     }

     private void validateAdd(JsonValue target) {
         validateJsonPointer(target, referenceTokens.size() - 1);
     }

     private void validateRemove(JsonValue target) {
         validateJsonPointer(target, referenceTokens.size());
         if (isEmptyJsonPointer()) {
             throw new JsonException("The reference must not be the target");
         }
     }

     private boolean isEmptyJsonPointer() {
         return jsonPointer.equals("");
     }

     private JsonValue getValue(JsonValue jsonValue, String referenceToken, int currentPosition, int referencePosition) {
         if (jsonValue instanceof JsonObject) {
             JsonObject jsonObject = (JsonObject) jsonValue;
             jsonValue = jsonObject.get(referenceToken);

             if (jsonValue != null) {
                 return jsonValue;
             }
             throw new JsonException("'" + jsonObject + "' contains no value for name '" + referenceToken + "'");
         } else if (jsonValue instanceof JsonArray) {
             validateArrayIndex(referenceToken);

             try {
                 JsonArray jsonArray = (JsonArray) jsonValue;
                 int arrayIndex = Integer.parseInt(referenceToken);
                 validateArraySize(jsonArray, arrayIndex, jsonArray.size());
                 return jsonArray.get(arrayIndex);
             } catch (NumberFormatException e) {
                 throw new JsonException("'" + referenceToken + "' is no valid array index", e);
             }
         } else {
             if (currentPosition != referencePosition) {
                 return jsonValue;
             }
             throw new JsonException("'" + jsonValue + "' contains no element for '" + referenceToken + "'");
         }
     }

     private <T extends JsonStructure> T addInternal(T jsonValue, JsonValue newValue) {
         List<String> currentPath = new ArrayList<>();
         currentPath.add("");

         return (T) addInternal(jsonValue, newValue, currentPath);
     }

     private JsonValue addInternal(JsonValue jsonValue, JsonValue newValue, List<String> currentPath) {
         if (jsonValue instanceof JsonObject) {
             JsonObject jsonObject = (JsonObject) jsonValue;
             JsonObjectBuilder objectBuilder = Json.createObjectBuilder();

             if (jsonObject.isEmpty()) {
                 objectBuilder.add(lastReferenceToken, newValue);
             } else {
                 for (Map.Entry<String, JsonValue> entry : jsonObject.entrySet()) {

                     currentPath.add(entry.getKey());
                     objectBuilder.add(entry.getKey(), addInternal(entry.getValue(), newValue, currentPath));
                     currentPath.remove(entry.getKey());

                     if (currentPath.size() == referenceTokens.size() - 1 &&
                         currentPath.get(currentPath.size() - 1).equals(referenceTokens.get(referenceTokens.size() - 2))) {
                         objectBuilder.add(lastReferenceToken, newValue);
                     }
                 }
             }
             return objectBuilder.build();
         } else if (jsonValue instanceof JsonArray) {
             JsonArray jsonArray = (JsonArray) jsonValue;
             JsonArrayBuilder arrayBuilder = Json.createArrayBuilder();

             int arrayIndex = -1;
             if (currentPath.size() == referenceTokens.size() - 1 &&
                 currentPath.get(currentPath.size() - 1).equals(referenceTokens.get(referenceTokens.size() - 2))) {

                 arrayIndex = getArrayIndex(lastReferenceToken, jsonArray, true);
             }

             int jsonArraySize = jsonArray.size();
             for (int i = 0; i <= jsonArraySize; i++) {
                 if (i == arrayIndex) {
                     arrayBuilder.add(newValue);
                 }
                 if (i == jsonArraySize) {
                     break;
                 }

                 String path = String.valueOf(i);
                 currentPath.add(path);
                 arrayBuilder.add(addInternal(jsonArray.get(i), newValue, currentPath));
                 currentPath.remove(path);
             }
             return arrayBuilder.build();
         }
         return jsonValue;
     }

     private JsonValue remove(JsonValue jsonValue, int currentPosition, int referencePosition) {
         if (jsonValue instanceof JsonObject) {
             JsonObject jsonObject = (JsonObject) jsonValue;
             JsonObjectBuilder objectBuilder = Json.createObjectBuilder();

             for (Map.Entry<String, JsonValue> entry : jsonObject.entrySet()) {
                 if (currentPosition == referencePosition
                         && lastReferenceToken.equals(entry.getKey())) {
                     continue;
                 }
                 objectBuilder.add(entry.getKey(), remove(entry.getValue(), currentPosition + 1, referencePosition));
             }
             return objectBuilder.build();
         } else if (jsonValue instanceof JsonArray) {
             JsonArray jsonArray = (JsonArray) jsonValue;
             JsonArrayBuilder arrayBuilder = Json.createArrayBuilder();

             int arrayIndex = -1;
             if (currentPosition == referencePosition) {
                 arrayIndex = getArrayIndex(lastReferenceToken, jsonArray, false);
             }

             int jsonArraySize = jsonArray.size();
             for (int i = 0; i < jsonArraySize; i++) {
                 if (i == arrayIndex) {
                     continue;
                 }
                 arrayBuilder.add(remove(jsonArray.get(i), currentPosition + 1, referencePosition));
             }
             return arrayBuilder.build();
         }
         return jsonValue;
     }

     private int getArrayIndex(String referenceToken, JsonArray jsonArray, boolean addOperation) {
         if (addOperation && referenceToken.equals("-")) {
             return jsonArray.size();
         }

         validateArrayIndex(referenceToken);

         try {
             int arrayIndex = Integer.parseInt(referenceToken);
             int arraySize = addOperation ? jsonArray.size() + 1 : jsonArray.size();
             validateArraySize(jsonArray, arrayIndex, arraySize);
             return arrayIndex;
         } catch (NumberFormatException e) {
             throw new JsonException("'" + referenceToken + "' is no valid array index", e);
         }
     }

     private void validateJsonPointer(JsonValue target, int size) throws NullPointerException, JsonException {
         if (target == null) {
             throw new NullPointerException("target must not be null");
         }

         JsonValue jsonValue = target;
         for (int i = 1; i < size; i++) {
             jsonValue = getValue(jsonValue, referenceTokens.get(i), i, referenceTokens.size() - 1);
         }
     }

     private void validateArrayIndex(String referenceToken) throws JsonException {
         if (referenceToken.startsWith("+") || referenceToken.startsWith("-")) {
             throw new JsonException("An array index must not start with '" + referenceToken.charAt(0) + "'");
         }
         if (referenceToken.startsWith("0") && referenceToken.length() > 1) {
             throw new JsonException("An array index must not start with a leading '0'");
         }
     }

     private void validateArraySize(JsonArray jsonArray, int arrayIndex, int arraySize) throws JsonException {
         if (arrayIndex >= arraySize) {
             throw new JsonException("'" + jsonArray + "' contains no element for index " + arrayIndex);
         }
     }

 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/
	package org.apache.johnzon.core;

	import javax.json.Json;
	import javax.json.JsonArray;
	import javax.json.JsonArrayBuilder;
	import javax.json.JsonException;
	import javax.json.JsonObject;
	import javax.json.JsonObjectBuilder;
	import javax.json.JsonPointer;
	import javax.json.JsonStructure;
	import javax.json.JsonValue;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.Map;


	public class JsonPointerImpl implements JsonPointer {

	private final String jsonPointer;
	private final List<String> referenceTokens = new ArrayList<>();
	private final String lastReferenceToken;

	/**
	* Constructs and initializes a JsonPointer.
	*
	* @param jsonPointer the JSON Pointer string
	* @throws NullPointerException if {@code jsonPointer} is {@code null}
	* @throws JsonException if {@code jsonPointer} is not a valid JSON Pointer
	*/
	public JsonPointerImpl(String jsonPointer) {
	if (jsonPointer == null) {
	throw new NullPointerException("jsonPointer must not be null");
	}
	if (!jsonPointer.equals("") && !jsonPointer.startsWith("/")) {
	throw new JsonException("A non-empty JsonPointer string must begin with a '/'");
	}

	this.jsonPointer = jsonPointer;
	String[] encodedReferenceTokens = jsonPointer.split("/", -1);

	for (String encodedReferenceToken : encodedReferenceTokens) {
	referenceTokens.add(JsonPointerUtil.decode(encodedReferenceToken));
	}
	lastReferenceToken = referenceTokens.get(referenceTokens.size() - 1);
	}

	/**
	* Compares this {@code JsonPointer} with another object.
	*
	* @param obj the object to compare this {@code JsonPointer} against
	* @return true if the given object is a {@code JsonPointer} with the same
	* reference tokens as this one, false otherwise.
	*/
	@Override
	public boolean equals(Object obj) {
	if (this == obj) {
	return true;
	}
	if (obj == null \|\| getClass() != obj.getClass()) {
	return false;
	}

	JsonPointerImpl that = (JsonPointerImpl) obj;
	return jsonPointer.equals(that.jsonPointer);
	}

	/**
	* Returns the hash code value for this {@code JsonPointer} object.
	* The hash code of this object is defined by the hash codes of it's reference tokens.
	*
	* @return the hash code value for this {@code JsonPointer} object
	*/
	@Override
	public int hashCode() {
	return jsonPointer.hashCode();
	}

	/**
	* Returns the value at the referenced location in the specified {@code target}
	*
	* @param target the target referenced by this {@code JsonPointer}
	* @return the referenced value in the target.
	* @throws NullPointerException if {@code target} is null
	* @throws JsonException if the referenced value does not exist
	*/
	public JsonValue getValue(JsonStructure target) {
	if (target == null) {
	throw new NullPointerException("target must not be null");
	}
	if (isEmptyJsonPointer()) {
	return target;
	}

	JsonValue jsonValue = target;
	for (int i = 1; i < referenceTokens.size(); i++) {
	jsonValue = getValue(jsonValue, referenceTokens.get(i), i, referenceTokens.size() - 1);
	}
	return jsonValue;
	}

	@Override
	public boolean containsValue(JsonStructure target) {
	try {
	getValue(target);
	return true;
	} catch (JsonException je) {
	return false;
	}
	}

	/**
	* Adds or replaces a value at the referenced location in the specified
	* {@code target} with the specified {@code value}.
	* <ol>
	* <li>If the reference is the target (empty JSON Pointer string),
	* the specified {@code value}, which must be the same type as
	* specified {@code target}, is returned.</li>
	* <li>If the reference is an array element, the specified {@code value} is inserted
	* into the array, at the referenced index. The value currently at that location, and
	* any subsequent values, are shifted to the right (adds one to the indices).
	* Index starts with 0. If the reference is specified with a "-", or if the
	* index is equal to the size of the array, the value is appended to the array.</li>
	* <li>If the reference is a name/value pair of a {@code JsonObject}, and the
	* referenced value exists, the value is replaced by the specified {@code value}.
	* If the value does not exist, a new name/value pair is added to the object.</li>
	* </ol>
	*
	* @param target the target referenced by this {@code JsonPointer}
	* @param value the value to be added
	* @return the transformed {@code target} after the value is added.
	* @throws NullPointerException if {@code target} is {@code null}
	* @throws JsonException if the reference is an array element and
	* the index is out of range ({@code index < 0 \|\| index > array size}),
	* or if the pointer contains references to non-existing objects or arrays.
	*/
	public JsonStructure add(JsonStructure target, JsonValue value) {
	validateAdd(target);
	if (isEmptyJsonPointer()) {
	if (value.getClass() != target.getClass()) {
	throw new JsonException("The value must have the same type as the target");
	}
	return (JsonStructure) value;
	}

	return addInternal(target, value);
	}

	/**
	* Adds or replaces a value at the referenced location in the specified
	* {@code target} with the specified {@code value}.
	*
	* @param target the target referenced by this {@code JsonPointer}
	* @param value the value to be added
	* @return the transformed {@code target} after the value is added.
	* @throws NullPointerException if {@code target} is {@code null}
	* @throws JsonException if the reference is an array element and
	* the index is out of range ({@code index < 0 \|\| index > array size}),
	* or if the pointer contains references to non-existing objects or arrays.
	* @see #add(JsonStructure, JsonValue)
	*/
	public JsonObject add(JsonObject target, JsonValue value) {
	validateAdd(target);

	return addInternal(target, value);
	}

	/**
	* Adds or replaces a value at the referenced location in the specified
	* {@code target} with the specified {@code value}.
	*
	* @param target the target referenced by this {@code JsonPointer}
	* @param value the value to be added
	* @return the transformed {@code target} after the value is added.
	* @throws NullPointerException if {@code target} is {@code null}
	* @throws JsonException if the reference is an array element and
	* the index is out of range ({@code index < 0 \|\| index > array size}),
	* or if the pointer contains references to non-existing objects or arrays.
	* @see #add(JsonStructure, JsonValue)
	*/
	public JsonArray add(JsonArray target, JsonValue value) {
	validateAdd(target);

	return addInternal(target, value);
	}

	/**
	* Replaces the value at the referenced location in the specified
	* {@code target} with the specified {@code value}.
	*
	* @param target the target referenced by this {@code JsonPointer}
	* @param value the value to be stored at the referenced location
	* @return the transformed {@code target} after the value is replaced.
	* @throws NullPointerException if {@code target} is {@code null}
	* @throws JsonException if the referenced value does not exist,
	* or if the reference is the target.
	*/
	public JsonStructure replace(JsonStructure target, JsonValue value) {
	if (target instanceof JsonObject) {
	return replace((JsonObject) target, value);
	} else {
	return replace((JsonArray) target, value);
	}
	}

	/**
	* Replaces the value at the referenced location in the specified
	*
	* @param target the target referenced by this {@code JsonPointer}
	* @param value the value to be stored at the referenced location
	* @return the transformed {@code target} after the value is replaced.
	* @throws NullPointerException if {@code target} is {@code null}
	* @throws JsonException if the referenced value does not exist,
	* or if the reference is the target.
	* @see #replace(JsonStructure, JsonValue)
	*/
	public JsonObject replace(JsonObject target, JsonValue value) {
	return add(remove(target), value);
	}

	/**
	* Replaces the value at the referenced location in the specified
	*
	* @param target the target referenced by this {@code JsonPointer}
	* @param value the value to be stored at the referenced location
	* @return the transformed {@code target} after the value is replaced.
	* @throws NullPointerException if {@code target} is {@code null}
	* @throws JsonException if the referenced value does not exist,
	* or if the reference is the target.
	* @see #replace(JsonStructure, JsonValue)
	*/
	public JsonArray replace(JsonArray target, JsonValue value) {
	return add(remove(target), value);
	}

	/**
	* Removes the value at the reference location in the specified {@code target}
	*
	* @param target the target referenced by this {@code JsonPointer}
	* @return the transformed {@code target} after the value is removed.
	* @throws NullPointerException if {@code target} is {@code null}
	* @throws JsonException if the referenced value does not exist,
	* or if the reference is the target.
	*/
	public JsonStructure remove(JsonStructure target) {
	if (target instanceof JsonObject) {
	return remove((JsonObject) target);
	} else {
	return remove((JsonArray) target);
	}
	}

	/**
	* Removes the value at the reference location in the specified {@code target}
	*
	* @param target the target referenced by this {@code JsonPointer}
	* @return the transformed {@code target} after the value is removed.
	* @throws NullPointerException if {@code target} is {@code null}
	* @throws JsonException if the referenced value does not exist,
	* or if the reference is the target.
	* @see #remove(JsonStructure)
	*/
	public JsonObject remove(JsonObject target) {
	validateRemove(target);

	return (JsonObject) remove(target, 1, referenceTokens.size() - 1);
	}

	/**
	* Removes the value at the reference location in the specified {@code target}
	*
	* @param target the target referenced by this {@code JsonPointer}
	* @return the transformed {@code target} after the value is removed.
	* @throws NullPointerException if {@code target} is {@code null}
	* @throws JsonException if the referenced value does not exist,
	* or if the reference is the target.
	* @see #remove(JsonStructure)
	*/
	public JsonArray remove(JsonArray target) {
	validateRemove(target);

	return (JsonArray) remove(target, 1, referenceTokens.size() - 1);
	}

	String getJsonPointer() {
	return jsonPointer;
	}

	private void validateAdd(JsonValue target) {
	validateJsonPointer(target, referenceTokens.size() - 1);
	}

	private void validateRemove(JsonValue target) {
	validateJsonPointer(target, referenceTokens.size());
	if (isEmptyJsonPointer()) {
	throw new JsonException("The reference must not be the target");
	}
	}

	private boolean isEmptyJsonPointer() {
	return jsonPointer.equals("");
	}

	private JsonValue getValue(JsonValue jsonValue, String referenceToken, int currentPosition, int referencePosition) {
	if (jsonValue instanceof JsonObject) {
	JsonObject jsonObject = (JsonObject) jsonValue;
	jsonValue = jsonObject.get(referenceToken);

	if (jsonValue != null) {
	return jsonValue;
	}
	throw new JsonException("'" + jsonObject + "' contains no value for name '" + referenceToken + "'");
	} else if (jsonValue instanceof JsonArray) {
	validateArrayIndex(referenceToken);

	try {
	JsonArray jsonArray = (JsonArray) jsonValue;
	int arrayIndex = Integer.parseInt(referenceToken);
	validateArraySize(jsonArray, arrayIndex, jsonArray.size());
	return jsonArray.get(arrayIndex);
	} catch (NumberFormatException e) {
	throw new JsonException("'" + referenceToken + "' is no valid array index", e);
	}
	} else {
	if (currentPosition != referencePosition) {
	return jsonValue;
	}
	throw new JsonException("'" + jsonValue + "' contains no element for '" + referenceToken + "'");
	}
	}

	private <T extends JsonStructure> T addInternal(T jsonValue, JsonValue newValue) {
	List<String> currentPath = new ArrayList<>();
	currentPath.add("");

	return (T) addInternal(jsonValue, newValue, currentPath);
	}

	private JsonValue addInternal(JsonValue jsonValue, JsonValue newValue, List<String> currentPath) {
	if (jsonValue instanceof JsonObject) {
	JsonObject jsonObject = (JsonObject) jsonValue;
	JsonObjectBuilder objectBuilder = Json.createObjectBuilder();

	if (jsonObject.isEmpty()) {
	objectBuilder.add(lastReferenceToken, newValue);
	} else {
	for (Map.Entry<String, JsonValue> entry : jsonObject.entrySet()) {

	currentPath.add(entry.getKey());
	objectBuilder.add(entry.getKey(), addInternal(entry.getValue(), newValue, currentPath));
	currentPath.remove(entry.getKey());

	if (currentPath.size() == referenceTokens.size() - 1 &&
	currentPath.get(currentPath.size() - 1).equals(referenceTokens.get(referenceTokens.size() - 2))) {
	objectBuilder.add(lastReferenceToken, newValue);
	}
	}
	}
	return objectBuilder.build();
	} else if (jsonValue instanceof JsonArray) {
	JsonArray jsonArray = (JsonArray) jsonValue;
	JsonArrayBuilder arrayBuilder = Json.createArrayBuilder();

	int arrayIndex = -1;
	if (currentPath.size() == referenceTokens.size() - 1 &&
	currentPath.get(currentPath.size() - 1).equals(referenceTokens.get(referenceTokens.size() - 2))) {

	arrayIndex = getArrayIndex(lastReferenceToken, jsonArray, true);
	}

	int jsonArraySize = jsonArray.size();
	for (int i = 0; i <= jsonArraySize; i++) {
	if (i == arrayIndex) {
	arrayBuilder.add(newValue);
	}
	if (i == jsonArraySize) {
	break;
	}

	String path = String.valueOf(i);
	currentPath.add(path);
	arrayBuilder.add(addInternal(jsonArray.get(i), newValue, currentPath));
	currentPath.remove(path);
	}
	return arrayBuilder.build();
	}
	return jsonValue;
	}

	private JsonValue remove(JsonValue jsonValue, int currentPosition, int referencePosition) {
	if (jsonValue instanceof JsonObject) {
	JsonObject jsonObject = (JsonObject) jsonValue;
	JsonObjectBuilder objectBuilder = Json.createObjectBuilder();

	for (Map.Entry<String, JsonValue> entry : jsonObject.entrySet()) {
	if (currentPosition == referencePosition
	&& lastReferenceToken.equals(entry.getKey())) {
	continue;
	}
	objectBuilder.add(entry.getKey(), remove(entry.getValue(), currentPosition + 1, referencePosition));
	}
	return objectBuilder.build();
	} else if (jsonValue instanceof JsonArray) {
	JsonArray jsonArray = (JsonArray) jsonValue;
	JsonArrayBuilder arrayBuilder = Json.createArrayBuilder();

	int arrayIndex = -1;
	if (currentPosition == referencePosition) {
	arrayIndex = getArrayIndex(lastReferenceToken, jsonArray, false);
	}

	int jsonArraySize = jsonArray.size();
	for (int i = 0; i < jsonArraySize; i++) {
	if (i == arrayIndex) {
	continue;
	}
	arrayBuilder.add(remove(jsonArray.get(i), currentPosition + 1, referencePosition));
	}
	return arrayBuilder.build();
	}
	return jsonValue;
	}

	private int getArrayIndex(String referenceToken, JsonArray jsonArray, boolean addOperation) {
	if (addOperation && referenceToken.equals("-")) {
	return jsonArray.size();
	}

	validateArrayIndex(referenceToken);

	try {
	int arrayIndex = Integer.parseInt(referenceToken);
	int arraySize = addOperation ? jsonArray.size() + 1 : jsonArray.size();
	validateArraySize(jsonArray, arrayIndex, arraySize);
	return arrayIndex;
	} catch (NumberFormatException e) {
	throw new JsonException("'" + referenceToken + "' is no valid array index", e);
	}
	}

	private void validateJsonPointer(JsonValue target, int size) throws NullPointerException, JsonException {
	if (target == null) {
	throw new NullPointerException("target must not be null");
	}

	JsonValue jsonValue = target;
	for (int i = 1; i < size; i++) {
	jsonValue = getValue(jsonValue, referenceTokens.get(i), i, referenceTokens.size() - 1);
	}
	}

	private void validateArrayIndex(String referenceToken) throws JsonException {
	if (referenceToken.startsWith("+") \|\| referenceToken.startsWith("-")) {
	throw new JsonException("An array index must not start with '" + referenceToken.charAt(0) + "'");
	}
	if (referenceToken.startsWith("0") && referenceToken.length() > 1) {
	throw new JsonException("An array index must not start with a leading '0'");
	}
	}

	private void validateArraySize(JsonArray jsonArray, int arrayIndex, int arraySize) throws JsonException {
	if (arrayIndex >= arraySize) {
	throw new JsonException("'" + jsonArray + "' contains no element for index " + arrayIndex);
	}
	}

	}