Type Parameters:: T - Type of container: either an object or an array

All Superinterfaces:: JsElem, Serializable

All Known Subinterfaces:: JsArray, JsObj

public interface Json<T extends Json<T>>
extends JsElem, Serializable

 Represents a json of type T, where T is the type of the container, either a JsObj or a JsArray.

 A json of any type can be modeled as a set of pairs JsPair=(JsPath, JsElem), where:

 - a JsElem is a JsBool or JsStr or JsNumber or JsNull, or another Json like JsObj or JsArray,
 what makes the data structure recursive.

 - a JsPath represents the location of the element in the json.

 For example, the json
 {
 "a":1, "x":{ "c": true, "d":null, e: [false, 1, "hi"] }
 }

 can be seen as the following set:

 Set[(a,1), (x.c,true), (x.d,null), (x.e.0,false), (x.e.1,1), (x.e.2,"hi"), (_,NOTHING)]

 where _, which means any other JsPath, and the special element JsNothing.NOTHING, makes the
 function get(JsPath) total (defined for every possible path). Moreover, inserting JsNothing
 in a json doesn't change the json, which is very convenient when passing functions as parameters to
 put data in:

 //all the logic goes into the supplier
Supplier<JsElem> supplier = ()-> (doesnt-put-anything-condition) ? JsNothing.NOTHING : JsInt.of(2);
json.putIfAbsent(path,supplier)

 Another way to see a json is like a stream of pairs, which opens the door to doing all the operations
 that were introduced in Java 8 (map, filter, reduce, etc). For this purpose the methods stream_()
 or stream() are provided. To put the stream back into an immutable json the collectors JsObj.collector()
 and JsArray.collector() can be used, whereas the collectors JsObj._collector_() and JsArray._collector_()
 would put the stream back into a mutable json.

 All the methods that accept a JsPath are overloaded and accept also a path-like string instead.

 There are two types of conventions on method names:

 -Static factory methods that are prefixed and suffixed with underscore return mutable instances.
 -Methods that are suffixed with underscore traverse the whole json recursively.

 All the methods throw a NullPointerException when any of the params passed in is null. The exception
 UserError is thrown when the user calls a method inappropriately:
 for example calling the method asJsStr in a JsNull instance or calling the
 method head in an empty array, etc. Normally, when that happens, a previous check is missing.

Author:: Rafael Merino Garcia
See Also:: to work with jsons that are objects, to work with jsons that are arrays

Field Summary

Fields
Modifier and Type Field Description

static long serialVersionUID

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method	Description
`static Try`	`_parse_(String str)`	Tries to parse the string into a mutable json.
`static Try`	`_parse_(String str, ParseBuilder builder)`	Tries to parse the string into a mutable json, performing the specified transformations while the parsing.
`default T`	`add(JsPath path, boolean elem)`	Inserts the given boolean at the given path in this json, replacing any existing element at that path.
`default T`	`add(JsPath path, double elem)`	Inserts the given double at the given path in this json, replacing any existing element at that path.
`default T`	`add(JsPath path, int elem)`	Inserts the given integer at the given path in this json, replacing any existing element at that path.
`default T`	`add(JsPath path, long elem)`	Inserts the given long at the given path in this json, replacing any existing element at that path.
`default T`	`add(JsPath path, String elem)`	Inserts the given string at the given path in this json, replacing any existing element at that path.
`T`	`add(JsPath path, Function<? super JsElem,? extends JsElem> fn)`	Inserts the element returned by the function at the given path in this json, replacing any existing element at that path.
`default T`	`add(JsPath path, JsElem elem)`	Inserts the given element at the given path in this json, replacing any existing element at that path.
`default T`	`append(JsPath path, boolean elem, boolean... others)`	Appends one or more booleans, starting from the first, to the array located at the given path in this json.
`default T`	`append(JsPath path, double elem, double... others)`	Appends one or more doubles, starting from the first, to the array located at the given path in this json.
`default T`	`append(JsPath path, int elem, int... others)`	Appends one or more integers, starting from the first, to the array located at the given path in this json.
`default T`	`append(JsPath path, long elem, long... others)`	Appends one or more longs, starting from the first, to the array located at the given path in this json.
`default T`	`append(JsPath path, String elem, String... others)`	Appends one or more strings, starting from the first, to the array located at the given path in this json.
`T`	`append(JsPath path, JsElem elem)`	Appends one element to the array located at the given path in this json.
`default T`	`append(JsPath path, JsElem elem, JsElem... others)`	Appends one or more elements, starting from the first, to the array located at the given path in this json.
`T`	`appendAll(JsPath path, JsArray elems)`	Appends all the elements of the array, starting from the head, to the array located at the given path in this json.
`default T`	`appendAllIfPresent(JsPath path, Supplier<JsArray> supplier)`	Appends all the elements of the array computed by the supplier, starting from the head, to an array located at the given path in this json, returning the same this instance if the array is not present, in which case, the supplier is not invoked.
`default T`	`appendIfPresent(JsPath path, boolean number, boolean... others)`	Appends one or more booleans to the array located at the given path in this json, returning the same this instance if the array is not present.
`default T`	`appendIfPresent(JsPath path, double number, double... others)`	Appends one or more doubles to the array located at the given path in this json, returning the same this instance if the array is not present.
`default T`	`appendIfPresent(JsPath path, int number, int... others)`	Appends one or more integers to the array located at the given path in this json, returning the same this instance if the array is not present.
`default T`	`appendIfPresent(JsPath path, long number, long... others)`	Appends one or more longs to the array located at the given path in this json, returning the same this instance if the array is not present.
`default T`	`appendIfPresent(JsPath path, String str, String... others)`	Appends one or more strings to the array located at the given path in this json, returning the same this instance if the array is not present.
`default T`	`appendIfPresent(JsPath path, Supplier<? extends JsElem> supplier)`	Appends the element given by the supplier, to the array located at the given path in this json, returning the same this instance if the array is not present.
`boolean`	`containsElem(JsElem element)`	Returns true if this json contains the given element in the first level.
`default boolean`	`containsElem_(JsElem element)`	Returns true if this json or any of its elements, contains the given element.
`default boolean`	`containsPath(JsPath path)`	Returns true if an element exists in this json at the given path.
`default boolean`	`equals(JsElem elem, JsArray.TYPE ARRAY_AS)`
`T`	`filterElems(Predicate<? super JsPair> filter)`	Filters the pairs of elements in the first level of this json, removing those that don't ifPredicateElse the predicate.
`T`	`filterElems_(Predicate<? super JsPair> filter)`	Filters all the pairs of elements of this json, removing those that don't ifPredicateElse the predicate.
`T`	`filterKeys(Predicate<? super JsPair> filter)`	Filters the keys in the first level parse this json, removing those that don't ifPredicateElse the predicate.
`T`	`filterKeys_(Predicate<? super JsPair> filter)`	Filters all the keys parse this json, removing those that don't ifPredicateElse the predicate.
`T`	`filterObjs(BiPredicate<? super JsPath,? super JsObj> filter)`	Filters the pair of jsons in the first level parse this json, removing those that don't ifPredicateElse the predicate.
`T`	`filterObjs_(BiPredicate<? super JsPath,? super JsObj> filter)`	Filters all the pair of jsons parse this json, removing those that don't ifPredicateElse the predicate.
`default JsElem`	`get(JsPath path)`	Returns the element located at the given path or `JsNothing` if it doesn't exist.
`JsElem`	`get(Position position)`	Returns the element located at the key or index specified by the given position or `JsNothing` if it doesn't exist.
`default Optional<JsArray>`	`getArray(JsPath path)`	Returns the array located at the given path or `Optional.empty()` if it doesn't exist or it's not an array.
`default Optional<BigDecimal>`	`getBigDecimal(JsPath path)`	Returns the big decimal located at the given path as a big decimal or `Optional.empty()` if it doesn't exist or it's not a decimal number.
`default Optional<BigInteger>`	`getBigInt(JsPath path)`	Returns the big integer located at the given path as a big integer or `Optional.empty()` if it doesn't exist or it's not an integral number.
`default Optional<Boolean>`	`getBool(JsPath path)`	Returns the boolean located at the given path or `Optional.empty()` if it doesn't exist.
`default OptionalDouble`	`getDouble(JsPath path)`	Returns the decimal number located at the given path as a double or `OptionalDouble.empty()` if it doesn't exist or it's not a decimal number.
`default OptionalInt`	`getInt(JsPath path)`	Returns the integral number located at the given path as an integer or `OptionalInt.empty()` if it doesn't exist or it's not an integral number or it's an integral number but doesn't fit in an integer.
`default OptionalLong`	`getLong(JsPath path)`	Returns the integral number located at the given path as a long or `OptionalLong.empty()` if it doesn't exist or it's not an integral number or it's an integral number but doesn't fit in a long.
`default Optional<JsObj>`	`getObj(JsPath path)`	Returns the object located at the given path or `Optional.empty()` if it doesn't exist or it's not an object.
`default Optional<String>`	`getStr(JsPath path)`	Returns the string located at the given path or `Optional.empty()` if it doesn't exist or it's not an string.
`default <A> A`	`ifEmptyElse(Supplier<A> emptySupplier, Supplier<A> nonemptySupplier)`	Declarative way parse implementing if(this.isEmpty()) return emptySupplier.get() else return nonEmptySupplier.get()
`default boolean`	`isBigDec()`
`default boolean`	`isBigInt()`
`default boolean`	`isBool()`
`default boolean`	`isDouble()`
`boolean`	`isEmpty()`	return true if there's no element in this json
`default boolean`	`isFalse()`
`boolean`	`isImmutable()`
`default boolean`	`isInt()`
`default boolean`	`isLong()`
`boolean`	`isMutable()`
`default boolean`	`isNotEmpty()`	return true if this json it not empty
`default boolean`	`isNothing()`
`default boolean`	`isNull()`
`default boolean`	`isNumber()`
`default boolean`	`isStr()`
`default boolean`	`isTrue()`
`default T`	`map(UnaryOperator<T> fn)`
`T`	`mapElems(Function<? super JsPair,? extends JsElem> fn)`	Maps the values in the first level parse this json.
`T`	`mapElems(Function<? super JsPair,? extends JsElem> fn, Predicate<? super JsPair> predicate)`	Maps the values in the first level parse this json that satisfies a given predicate.
`T`	`mapElems_(Function<? super JsPair,? extends JsElem> fn)`	Maps all the values parse this json.
`T`	`mapElems_(Function<? super JsPair,? extends JsElem> fn, Predicate<? super JsPair> predicate)`	Maps all the values parse this json that satisfies a given predicate.
`T`	`mapKeys(Function<? super JsPair,String> fn)`	Maps the keys in the first level parse this json.
`T`	`mapKeys(Function<? super JsPair,String> fn, Predicate<? super JsPair> predicate)`	Maps the keys in the first level parse this json that satisfies a given predicate.
`T`	`mapKeys_(Function<? super JsPair,String> fn)`	Maps all the keys parse this json.
`T`	`mapKeys_(Function<? super JsPair,String> fn, Predicate<? super JsPair> predicate)`	Maps all the keys parse this json that satisfies a given predicate.
`T`	`mapObjs(BiFunction<? super JsPath,? super JsObj,JsObj> fn)`	Maps the jsons in the first level parse this json.
`T`	`mapObjs(BiFunction<? super JsPath,? super JsObj,JsObj> fn, BiPredicate<? super JsPath,? super JsObj> predicate)`	Maps the jsons in the first level parse this json that satisfies a given predicate.
`T`	`mapObjs_(BiFunction<? super JsPath,? super JsObj,JsObj> fn)`	Maps all the jsons parse this json.
`T`	`mapObjs_(BiFunction<? super JsPath,? super JsObj,JsObj> fn, BiPredicate<? super JsPath,? super JsObj> predicate)`	Maps all the jsons parse this json that satisfies a given predicate.
`default T`	`merge(JsPath path, JsElem value, BiFunction<? super JsElem,? super JsElem,? extends JsElem> fn)`	If the given path is not already associated with a value or is associated with null, associates it with the given value.
`static Try`	`parse(String str)`	Tries to parse the string into an immutable json.
`static Try`	`parse(String str, ParseBuilder builder)`	Tries to parse the string into an immutable json, performing the specified transformations while the parsing.
`TryPatch<T>`	`patch(JsArray ops)`	Implementation of the Json Patch specification.
`default T`	`prepend(JsPath path, boolean elem, boolean... others)`	prepends one or more booleans, starting from the first, to the array located at the path in this json.
`default T`	`prepend(JsPath path, double elem, double... others)`	prepends one or more doubles, starting from the first, to the array located at the path in this json.
`default T`	`prepend(JsPath path, int elem, int... others)`	prepends one or more integers, starting from the first, to the array located at the path in this json.
`default T`	`prepend(JsPath path, long elem, long... others)`	prepends one or more longs, starting from the first, to the array located at the path in this json.
`default T`	`prepend(JsPath path, String elem, String... others)`	Prepends one or more strings, starting from the first, to the array located at the path in this json.
`T`	`prepend(JsPath path, JsElem elem)`	prepends one element to the array located at the path in this json.
`default T`	`prepend(JsPath path, JsElem elem, JsElem... others)`	prepends one or more elements, starting from the first, to the array located at the path in this json.
`T`	`prependAll(JsPath path, JsArray elems)`	prepends all the elements of the array, starting from the head, to the array located at the path in this json.
`default T`	`prependAllIfPresent(JsPath path, Supplier<JsArray> supplier)`	Prepends all the elements of the array computed by the supplier, starting from the head, to the array located at the path in this json, returning the same this instance if the array is not present, in which case, the supplier is not invoked.
`default T`	`prependIfPresent(JsPath path, boolean bool, boolean... others)`	Prepends one or more booleans to the array located at the given path in this json in the following order [number, others, existing elements], returning the same this instance if the array is not present.
`default T`	`prependIfPresent(JsPath path, double number, double... others)`	Prepends one or more doubles to the array located at the given path in this json in the following order [number, others, existing elements], returning the same this instance if the array is not present.
`default T`	`prependIfPresent(JsPath path, int number, int... others)`	Prepends one or more integers to the array located at the given path in this json in the following order [number, others, existing elements], returning the same this instance if the array is not present.
`default T`	`prependIfPresent(JsPath path, long number, long... others)`	Prepends one or more longs to the array located at the given path in this json in the following order [number, others, existing elements], returning the same this instance if the array is not present.
`default T`	`prependIfPresent(JsPath path, String str, String... others)`	Prepends one or more strings to the array located at the given path in this json in the following order [number, others, existing elements], returning the same this instance if the array is not present.
`default T`	`prependIfPresent(JsPath path, Supplier<JsElem> supplier)`	Prepends one element given by a supplier, to the array located at the given path in this json, returning the same this instance if the array is not present.
`default T`	`put(JsPath path, boolean bool)`	Inserts the boolean at the given path in this json, replacing any existing element in the path and filling with `JsNull` empty positions in arrays when necessary.
`default T`	`put(JsPath path, int n)`	Inserts the integer number at the path in this json, replacing any existing element and filling with `JsNull` empty indexes in arrays when necessary.
`default T`	`put(JsPath path, long n)`	Inserts the long number at the path in this json, replacing any existing element and filling with `JsNull` empty indexes in arrays when necessary.
`default T`	`put(JsPath path, String str)`	Inserts the string at the given path in this json, replacing any existing element in the path and filling with `JsNull` empty positions in arrays when necessary.
`default T`	`put(JsPath path, BigDecimal bigdecimal)`	Inserts the big decimal number at the given path in this json, replacing any existing element in the path and filling with `JsNull` empty positions in arrays when necessary.
`default T`	`put(JsPath path, BigInteger bigint)`	Inserts the big integer number at the given path in this json, replacing any existing element in teh path and filling with `JsNull` empty positions in arrays when necessary.
`T`	`put(JsPath path, Function<? super JsElem,? extends JsElem> fn)`	Inserts the element returned by the function at the given path in this json, replacing any existing element and filling with `JsNull` empty indexes in arrays when necessary.
`default T`	`put(JsPath path, JsElem element)`	Inserts the element at the path in this json, replacing any existing element and filling with `JsNull` empty indexes in arrays when necessary.
`default T`	`putIf(Predicate<? super JsElem> predicate, JsPath path, Function<? super JsElem,? extends JsElem> fn)`	Inserts at the given path in this json, if the existing element satisfies the predicate, a new element returned by the function.
`default T`	`putIfAbsent(JsPath path, double number)`	Inserts at the given path in this json, if no element is present, the specified double, replacing any existing element in the path and filling with `JsNull` empty positions in arrays when necessary.
`default T`	`putIfAbsent(JsPath path, int number)`	Inserts at the given path in this json, if no element is present, the specified integer, replacing any existing element in the path and filling with `JsNull` empty positions in arrays when necessary.
`default T`	`putIfAbsent(JsPath path, long number)`	Inserts at the given path in this json, if no element is present, the specified long, replacing any existing element in the path and filling with `JsNull` empty positions in arrays when necessary.
`default T`	`putIfAbsent(JsPath path, Supplier<? extends JsElem> supplier)`	Inserts at the given path in this json, if no element is present, the element returned by the supplier, replacing any existing element in the path and filling with `JsNull` empty positions in arrays when necessary.
`default T`	`putIfPresent(JsPath path, double number)`	Inserts at the given path in this json, if some element is present, the specified double.
`default T`	`putIfPresent(JsPath path, int number)`	Inserts at the given path in this json, if some element is present, the specified integer.
`default T`	`putIfPresent(JsPath path, long number)`	Inserts at the given path in this json, if some element is present, the specified long.
`default T`	`putIfPresent(JsPath path, Function<? super JsElem,? extends JsElem> fn)`	Inserts at the given path in this json, if some element is present, the element returned by the function.
`<R> Optional<R>`	`reduce(BinaryOperator<R> op, Function<? super JsPair,R> map, Predicate<? super JsPair> predicate)`	Performs a reduction on the values that satisfy the predicate in the first level of this json.
`<R> Optional<R>`	`reduce_(BinaryOperator<R> op, Function<? super JsPair,R> map, Predicate<? super JsPair> predicate)`	Performs a reduction on the values of this json that satisfy the predicate.
`T`	`remove(JsPath path)`	Removes the element in this json located at the given path, if it exists, returning the same this instance otherwise
`int`	`size()`	Returns the number of elements in the first level of this json
`default OptionalInt`	`size(JsPath path)`	Returns the size of the json located at the given path in this json or OptionalInt.empty() if it doesn't exist or it's not a Json
`default int`	`size_()`	Returns the number of all the elements in this json
`default OptionalInt`	`size_(JsPath path)`	Returns the size of the json located at the given path in this json or OptionalInt.empty() if it doesn't exist or it's not a Json
`Stream<JsPair>`	`stream()`	Returns a stream over the pairs of elements in the first level of this json object.
`Stream<JsPair>`	`stream_()`	Returns a stream over all the pairs of elements in this json object.
`default long`	`times(JsElem e)`
`default long`	`times_(JsElem e)`
`T`	`toImmutable()`	Converts this json into immutable if it's mutable, returning this same instance otherwise.
`T`	`toMutable()`	Converts this json into mutable if it's immutable, returning this same instance otherwise.

Methods inherited from interface jsonvalues.JsElem
asJsArray, asJsBigDec, asJsBigInt, asJsBool, asJsDouble, asJsInt, asJsLong, asJsObj, asJson, asJsStr, isArray, isArray, isBigDec, isBigInt, isDecimal, isDouble, isInstant, isInstant, isInt, isIntegral, isJson, isJson, isLocalDate, isLocalDate, isLocalDateTime, isLocalDateTime, isLong, isNotJson, isNotNothing, isNotNull, isNotNumber, isObj, isObj, isSameType, isStr

- Field Detail
  - serialVersionUID
```
static final long serialVersionUID
```
    See Also:
    
    Constant Field Values
- Method Detail
  - _parse_
```
static Try _parse_(String str)
```
    Tries to parse the string into a mutable json.
    
    Parameters:
    
    str - the string to be parsed
    
    Returns:
    
    a Try computation
  - _parse_
```
static Try _parse_(String str,
                   ParseBuilder builder)
```
    Tries to parse the string into a mutable json, performing the specified transformations while the parsing. It's faster to do certain operations right while the parsing instead of doing the parsing and applying them later.
    
    Parameters:
    
    str - the string that will be parsed.
    
    builder - a builder with the transformations that, if specified, will be applied during the parsing
    
    Returns:
    
    a Try computation
  - appendAll
```
T appendAll(JsPath path,
            JsArray elems)
```
    Appends all the elements of the array, starting from the head, to the array located at the given path in this json. If the array doesn't exist, a new one is created, replacing any existing element in the path and filling empty indexes in arrays with JsNull when necessary. The same this instance is returned when it's an array and the head of the path is a key or when it's an object and the head of the path is an index.
    
    Parameters:
    
    path - the given JsPath pointing to the array in which all the elements will be appended
    
    elems - the JsArray of elements to be appended
    
    Returns:
    
    same this instance or a new json of the same type T
  - append
```
default T append(JsPath path,
                 JsElem elem,
                 JsElem... others)
```
    Appends one or more elements, starting from the first, to the array located at the given path in this json. If the array doesn't exist, a new one is created, replacing any existing element in the path and filling empty indexes in arrays with JsNull when necessary. The same this instance is returned when it's an array and the head of the path is a key or when it's an object and the head of the path is an index.
    
    Parameters:
    
    path - the given JsPath pointing to the array in which all the elements will be appended
    
    elem - the first JsElem to be appended to the existing or created array
    
    others - more optional JsElem to be appended
    
    Returns:
    
    same this instance or a new json of the same type T
  - append
```
T append(JsPath path,
         JsElem elem)
```
    Appends one element to the array located at the given path in this json. If the array doesn't exist, a new one is created, replacing any existing element in the path and filling empty indexes in arrays with JsNull when necessary. The same this instance is returned when it's an array and the head of the path is a key or when it's an object and the head of the path is an index.
    
    Parameters:
    
    path - the path pointing to the array in which the element will be appended
    
    elem - the JsElem to be appended to the existing or created array
    
    Returns:
    
    same this instance or a new json of the same type T
  - appendIfPresent
```
default T appendIfPresent(JsPath path,
                          Supplier<? extends JsElem> supplier)
```
    Appends the element given by the supplier, to the array located at the given path in this json, returning the same this instance if the array is not present. The supplier is not applied if there's no array at the specified path.
    
    Parameters:
    
    path - the JsPath pointing to the existing array in which the element will be appended
    
    supplier - the given supplier
    
    Returns:
    
    same this instance or a new json of the same type T
  - appendAllIfPresent
```
default T appendAllIfPresent(JsPath path,
                             Supplier<JsArray> supplier)
```
    Appends all the elements of the array computed by the supplier, starting from the head, to an array located at the given path in this json, returning the same this instance if the array is not present, in which case, the supplier is not invoked.
    
    Parameters:
    
    path - the given JsPath object pointing to the existing array in which all the elements will be appended
    
    supplier - the supplier of the array of elements that will be appended
    
    Returns:
    
    same this instance or a new json of the same type T
  - prependAll
```
T prependAll(JsPath path,
             JsArray elems)
```
    prepends all the elements of the array, starting from the head, to the array located at the path in this json. If the array at the path doesn't exist, a new one is created, replacing any existing element in the path and filling empty indexes in arrays with JsNull when necessary. The same this instance is returned when it's an array and the head of the path is a key or when it's an object and the head of the path is an index.
    
    Parameters:
    
    path - the JsPath pointing to the array in which all the elements will be prepended
    
    elems - the JsArray of elements to be prepended to the existing or created array
    
    Returns:
    
    same this instance or a new json of the same type T
  - prepend
```
default T prepend(JsPath path,
                  JsElem elem,
                  JsElem... others)
```
    prepends one or more elements, starting from the first, to the array located at the path in this json. If the array at the path doesn't exist, a new one is created, replacing any existing element in the path and filling empty indexes in arrays with JsNull when necessary. The same this instance is returned when it's an array and the head of the path is a key or when it's an object and the head of the path is an index.
    
    Parameters:
    
    path - the JsPath pointing to the array in which all the elements will be prepended
    
    elem - the first JsElem to be prepended to the existing or created array
    
    others - more optional JsElem to be prepended
    
    Returns:
    
    same this instance or a new json of the same type T
  - prepend
```
T prepend(JsPath path,
          JsElem elem)
```
    prepends one element to the array located at the path in this json. If the array at the path doesn't exist, a new one is created, replacing any existing element in the path and filling empty indexes in arrays with JsNull when necessary. The same this instance is returned when it's an array and the head of the path is a key or when it's an object and the head of the path is an index.
    
    Parameters:
    
    path - the JsPath pointing to the array in which the element will be prepended
    
    elem - the JsElem to be prepended to the existing or created array
    
    Returns:
    
    same this instance or a new json of the same type T
  - prependAllIfPresent
```
default T prependAllIfPresent(JsPath path,
                              Supplier<JsArray> supplier)
```
    Prepends all the elements of the array computed by the supplier, starting from the head, to the array located at the path in this json, returning the same this instance if the array is not present, in which case, the supplier is not invoked.
    
    Parameters:
    
    path - the JsPath object pointing to the existing array in which all the elements will be prepended
    
    supplier - the supplier of the array of elements that will be prepended
    
    Returns:
    
    same this instance or a new json of the same type T
  - prependIfPresent
```
default T prependIfPresent(JsPath path,
                           Supplier<JsElem> supplier)
```
    Prepends one element given by a supplier, to the array located at the given path in this json, returning the same this instance if the array is not present. The supplier is not applied if there's no array at the specified path.
    
    Parameters:
    
    path - the JsPath pointing to the existing array in which all the elements will be appended
    
    supplier - the given supplier
    
    Returns:
    
    same this instance or a new json of the same type T
  - prependIfPresent
```
default T prependIfPresent(JsPath path,
                           int number,
                           int... others)
```
    Prepends one or more integers to the array located at the given path in this json in the following order [number, others, existing elements], returning the same this instance if the array is not present.
    
    Parameters:
    
    path - the path pointing to the existing array in which the integers will be prepended
    
    number - the integer to be prepended
    
    others - more optional integers to be prepended
    
    Returns:
    
    same this instance or a new json of the same type T
  - prependIfPresent
```
default T prependIfPresent(JsPath path,
                           long number,
                           long... others)
```
    Prepends one or more longs to the array located at the given path in this json in the following order [number, others, existing elements], returning the same this instance if the array is not present.
    
    Parameters:
    
    path - the path pointing to the existing array in which the longs will be prepended
    
    number - the long to be prepended
    
    others - more optional longs to be prepended
    
    Returns:
    
    same this instance or a new json of the same type T
  - prependIfPresent
```
default T prependIfPresent(JsPath path,
                           double number,
                           double... others)
```
    Prepends one or more doubles to the array located at the given path in this json in the following order [number, others, existing elements], returning the same this instance if the array is not present.
    
    Parameters:
    
    path - the path pointing to the existing array in which the doubles will be prepended
    
    number - the double to be prepended
    
    others - more optional doubles to be prepended
    
    Returns:
    
    same this instance or a new json of the same type T
  - prependIfPresent
```
default T prependIfPresent(JsPath path,
                           String str,
                           String... others)
```
    Prepends one or more strings to the array located at the given path in this json in the following order [number, others, existing elements], returning the same this instance if the array is not present.
    
    Parameters:
    
    path - the path pointing to the existing array in which the strings will be prepended
    
    str - the string to be prepended
    
    others - more optional strings to be prepended
    
    Returns:
    
    same this instance or a new json of the same type T
  - prependIfPresent
```
default T prependIfPresent(JsPath path,
                           boolean bool,
                           boolean... others)
```
    Prepends one or more booleans to the array located at the given path in this json in the following order [number, others, existing elements], returning the same this instance if the array is not present.
    
    Parameters:
    
    path - the path pointing to the existing array in which the booleans will be prepended
    
    bool - the boolean to be prepended
    
    others - more optional booleans to be prepended
    
    Returns:
    
    same this instance or a new json of the same type T
  - filterElems
```
T filterElems(Predicate<? super JsPair> filter)
```
    Filters the pairs of elements in the first level of this json, removing those that don't ifPredicateElse the predicate.
    
    Parameters:
    
    filter - the predicate which takes as the input every JsPair in the first level parse this json
    
    Returns:
    
    same this instance if all the pairs satisfy the predicate or a new filtered json of the same type T
    
    See Also:
    
    how to filter the pair of elements of the whole json and not only the first level
  - filterElems_
```
T filterElems_(Predicate<? super JsPair> filter)
```
    Filters all the pairs of elements of this json, removing those that don't ifPredicateElse the predicate.
    
    Parameters:
    
    filter - the predicate which takes as the input every JsPair of this json
    
    Returns:
    
    same this instance if all the pairs satisfy the predicate or a new filtered json of the same type T
    
    See Also:
    
    how to filter the pairs of values parse only the first level
  - filterObjs
```
T filterObjs(BiPredicate<? super JsPath,? super JsObj> filter)
```
    Filters the pair of jsons in the first level parse this json, removing those that don't ifPredicateElse the predicate.
    
    Parameters:
    
    filter - the predicate which takes as the input every JsPair in the first level parse this json
    
    Returns:
    
    same this instance if all the pairs satisfy the predicate or a new filtered json of the same type T
    
    See Also:
    
    how to filter the pair of jsons of the whole json and not only the first level
  - filterObjs_
```
T filterObjs_(BiPredicate<? super JsPath,? super JsObj> filter)
```
    Filters all the pair of jsons parse this json, removing those that don't ifPredicateElse the predicate.
    
    Parameters:
    
    filter - the predicate which takes as the input every JsPair of this json
    
    Returns:
    
    same this instance if all the pairs satisfy the predicate or a new filtered json of the same type T
    
    See Also:
    
    how to filter the pair of jsons parse only the first level
  - filterKeys
```
T filterKeys(Predicate<? super JsPair> filter)
```
    Filters the keys in the first level parse this json, removing those that don't ifPredicateElse the predicate.
    
    Parameters:
    
    filter - the predicate which takes as the input every JsPair in the first level parse this json
    
    Returns:
    
    same this instance if all the keys satisfy the predicate or a new filtered json of the same type T
    
    See Also:
    
    how to filter the keys of the whole json and not only the first level
  - filterKeys_
```
T filterKeys_(Predicate<? super JsPair> filter)
```
    Filters all the keys parse this json, removing those that don't ifPredicateElse the predicate.
    
    Parameters:
    
    filter - the predicate which takes as the input every JsPair of this json
    
    Returns:
    
    same this instance if all the keys satisfy the predicate or a new filtered json of the same type T
    
    See Also:
    
    how to filter the keys of only the first level
  - get
```
JsElem get(Position position)
```
    Returns the element located at the key or index specified by the given position or JsNothing if it doesn't exist.
    
    Parameters:
    
    position - key or index of the element
    
    Returns:
    
    the JsElem located at the given Position or JsNothing if it doesn't exist
  - get
```
default JsElem get(JsPath path)
```
    Returns the element located at the given path or JsNothing if it doesn't exist.
    
    Parameters:
    
    path - the JsPath object of the element that will be returned
    
    Returns:
    
    the JsElem located at the given JsPath or JsNothing if it doesn't exist
  - getArray
```
default Optional<JsArray> getArray(JsPath path)
```
    Returns the array located at the given path or Optional.empty() if it doesn't exist or it's not an array.
    
    Parameters:
    
    path - the JsPath object of the JsArray that will be returned
    
    Returns:
    
    the JsArray located at the given JsPath wrapped in an Optional
  - getBigDecimal
```
default Optional<BigDecimal> getBigDecimal(JsPath path)
```
    Returns the big decimal located at the given path as a big decimal or Optional.empty() if it doesn't exist or it's not a decimal number.
    
    Parameters:
    
    path - the JsPath object of the BigDecimal that will be returned
    
    Returns:
    
    the BigDecimal located at the given JsPath wrapped in an Optional
  - getBigInt
```
default Optional<BigInteger> getBigInt(JsPath path)
```
    Returns the big integer located at the given path as a big integer or Optional.empty() if it doesn't exist or it's not an integral number.
    
    Parameters:
    
    path - the JsPath object of the BigInteger that will be returned
    
    Returns:
    
    the BigInteger located at the given JsPath wrapped in an Optional
  - getBool
```
default Optional<Boolean> getBool(JsPath path)
```
    Returns the boolean located at the given path or Optional.empty() if it doesn't exist.
    
    Parameters:
    
    path - the JsPath object of the Boolean that will be returned
    
    Returns:
    
    the Boolean located at the given JsPath wrapped in an Optional
  - getDouble
```
default OptionalDouble getDouble(JsPath path)
```
    Returns the decimal number located at the given path as a double or OptionalDouble.empty() if it doesn't exist or it's not a decimal number. If the number is a BigDecimal, the conversion is identical to the specified in BigDecimal.doubleValue() and in some cases it can lose information about the precision of the BigDecimal
    
    Parameters:
    
    path - the JsPath object of the double that will be returned
    
    Returns:
    
    the decimal number located at the given JsPath wrapped in an OptionalDouble
  - getInt
```
default OptionalInt getInt(JsPath path)
```
    Returns the integral number located at the given path as an integer or OptionalInt.empty() if it doesn't exist or it's not an integral number or it's an integral number but doesn't fit in an integer.
    
    Parameters:
    
    path - the JsPath object of the integral number that will be returned
    
    Returns:
    
    the integral number located at the given JsPath wrapped in an OptionalInt
  - getLong
```
default OptionalLong getLong(JsPath path)
```
    Returns the integral number located at the given path as a long or OptionalLong.empty() if it doesn't exist or it's not an integral number or it's an integral number but doesn't fit in a long.
    
    Parameters:
    
    path - the JsPath object of the integral number that will be returned
    
    Returns:
    
    the integral number located at the given JsPath wrapped in an OptionalLong
  - getObj
```
default Optional<JsObj> getObj(JsPath path)
```
    Returns the object located at the given path or Optional.empty() if it doesn't exist or it's not an object.
    
    Parameters:
    
    path - the JsPath object of the JsObj that will be returned
    
    Returns:
    
    the JsObj located at the given JsPath wrapped in an Optional
  - getStr
```
default Optional<String> getStr(JsPath path)
```
    Returns the string located at the given path or Optional.empty() if it doesn't exist or it's not an string.
    
    Parameters:
    
    path - the JsPath object of the JsStr that will be returned
    
    Returns:
    
    the JsStr located at the given path wrapped in an Optional
  - ifEmptyElse
```
default <A> A ifEmptyElse(Supplier<A> emptySupplier,
                          Supplier<A> nonemptySupplier)
```
    Declarative way parse implementing if(this.isEmpty()) return emptySupplier.get() else return nonEmptySupplier.get()
    
    Type Parameters:
    
    A - the type of the result
    
    Parameters:
    
    emptySupplier - Supplier that will produce the result if this json is empty
    
    nonemptySupplier - Supplier that will produce the result if this json is not empty
    
    Returns:
    
    an object parse type A
  - times
```
default long times(JsElem e)
```
  - times_
```
default long times_(JsElem e)
```
  - equals
```
default boolean equals(JsElem elem,
                       JsArray.TYPE ARRAY_AS)
```
  - isEmpty
```
boolean isEmpty()
```
    return true if there's no element in this json
    
    Returns:
    
    true if empty, false otherwise
  - isNotEmpty
```
default boolean isNotEmpty()
```
    return true if this json it not empty
    
    Returns:
    
    false if empty, true otherwise
  - mapElems
```
T mapElems(Function<? super JsPair,? extends JsElem> fn)
```
    Maps the values in the first level parse this json.
    
    Parameters:
    
    fn - the mapping function
    
    Returns:
    
    a new mapped json of the same type T
    
    See Also:
    
    to map jsons, to map keys parse json objects, to map all the values and not only the first level
  - mapElems
```
T mapElems(Function<? super JsPair,? extends JsElem> fn,
           Predicate<? super JsPair> predicate)
```
    Maps the values in the first level parse this json that satisfies a given predicate.
    
    Parameters:
    
    fn - the mapping function
    
    predicate - the given predicate that determines what JsValues will be mapped
    
    Returns:
    
    same this instance or a new mapped json of the same type T
    
    See Also:
    
    to map jsons, to map keys parse json objects, to map all the values and not only the first level
  - mapElems_
```
T mapElems_(Function<? super JsPair,? extends JsElem> fn)
```
    Maps all the values parse this json.
    
    Parameters:
    
    fn - the mapping function
    
    Returns:
    
    a new mapped json of the same type T
    
    See Also:
    
    to map jsons, to map keys parse json objects, to map only the first level
  - mapElems_
```
T mapElems_(Function<? super JsPair,? extends JsElem> fn,
            Predicate<? super JsPair> predicate)
```
    Maps all the values parse this json that satisfies a given predicate.
    
    Parameters:
    
    fn - the mapping function
    
    predicate - the given predicate that determines what JsValues will be mapped
    
    Returns:
    
    same this instance or a new mapped json of the same type TT
    
    See Also:
    
    to map jsons, to map keys parse json objects, to map only the first level
  - mapObjs
```
T mapObjs(BiFunction<? super JsPath,? super JsObj,JsObj> fn,
          BiPredicate<? super JsPath,? super JsObj> predicate)
```
    Maps the jsons in the first level parse this json that satisfies a given predicate.
    
    Parameters:
    
    fn - the mapping function
    
    predicate - the given predicate that determines what Jsons will be mapped
    
    Returns:
    
    same this instance or a new mapped json of the same type T
    
    See Also:
    
    to map values, to map keys parse json objects, to map all the jsons and not only the first level
  - mapObjs
```
T mapObjs(BiFunction<? super JsPath,? super JsObj,JsObj> fn)
```
    Maps the jsons in the first level parse this json.
    
    Parameters:
    
    fn - the mapping function
    
    Returns:
    
    a new mapped json of the same type T
    
    See Also:
    
    to map values, to map keys parse json objects, to map all the jsons and not only the first level
  - mapObjs_
```
T mapObjs_(BiFunction<? super JsPath,? super JsObj,JsObj> fn,
           BiPredicate<? super JsPath,? super JsObj> predicate)
```
    Maps all the jsons parse this json that satisfies a given predicate.
    
    Parameters:
    
    fn - the mapping function
    
    predicate - the given predicate that determines what Jsons will be mapped
    
    Returns:
    
    same this instance or a new mapped json of the same type T
    
    See Also:
    
    to map values, to map keys parse json objects, to map only the first level
  - mapObjs_
```
T mapObjs_(BiFunction<? super JsPath,? super JsObj,JsObj> fn)
```
    Maps all the jsons parse this json.
    
    Parameters:
    
    fn - the mapping function
    
    Returns:
    
    a new mapped json of the same type T
    
    See Also:
    
    to map values, to map keys parse json objects, to map only the first level
  - mapKeys
```
T mapKeys(Function<? super JsPair,String> fn)
```
    Maps the keys in the first level parse this json.
    
    Parameters:
    
    fn - the mapping function
    
    Returns:
    
    a new mapped json of the same type T
    
    See Also:
    
    to map values, to map jsons, to map all the keys and not only the first level
  - mapKeys
```
T mapKeys(Function<? super JsPair,String> fn,
          Predicate<? super JsPair> predicate)
```
    Maps the keys in the first level parse this json that satisfies a given predicate.
    
    Parameters:
    
    fn - the mapping function
    
    predicate - the given predicate that determines what keys will be mapped
    
    Returns:
    
    same this instance or a new mapped json of the same type T
    
    See Also:
    
    to map jsons, to map values, to map all the keys and not only the first level
  - mapKeys_
```
T mapKeys_(Function<? super JsPair,String> fn)
```
    Maps all the keys parse this json.
    
    Parameters:
    
    fn - the mapping function
    
    Returns:
    
    a new mapped json of the same type T
    
    See Also:
    
    to map values, to map jsons, to map only the first level
  - mapKeys_
```
T mapKeys_(Function<? super JsPair,String> fn,
           Predicate<? super JsPair> predicate)
```
    Maps all the keys parse this json that satisfies a given predicate.
    
    Parameters:
    
    fn - the mapping function
    
    predicate - the given predicate that determines what keys will be mapped
    
    Returns:
    
    same this instance or a new mapped json of the same type T
    
    See Also:
    
    to map values, to map jsons, to map only the first level
  - merge
```
default T merge(JsPath path,
                JsElem value,
                BiFunction<? super JsElem,? super JsElem,? extends JsElem> fn)
```
    If the given path is not already associated with a value or is associated with null, associates it with the given value. Otherwise, replaces the associated value with the results of the given remapping function. This method may be of use when combining multiple mapped values for a key.For example, to either create or append a String msg to a value mapping: map.merge(key, msg, String::concat)
    
    Parameters:
    
    path - the given JsPath object which the resulting value is to be associated
    
    value - the given value to be merged with the existing value associated with the path or, if no existing value or a null value is associated with the path, to be associated with the path
    
    fn - the given function to recompute a value if present
    
    Returns:
    
    a new json of the same type T
  - parse
```
static Try parse(String str)
```
    Tries to parse the string into an immutable json.
    
    Parameters:
    
    str - the string that will be parsed
    
    Returns:
    
    a Try computation
  - parse
```
static Try parse(String str,
                 ParseBuilder builder)
```
    Tries to parse the string into an immutable json, performing the specified transformations while the parsing.
    
    Parameters:
    
    str - the string that will be parsed
    
    builder - a builder with the transformations that will be applied during the parsing
    
    Returns:
    
    a Try computation
  - put
```
T put(JsPath path,
      Function<? super JsElem,? extends JsElem> fn)
```
    Inserts the element returned by the function at the given path in this json, replacing any existing element and filling with JsNull empty indexes in arrays when necessary. The same instance is returned when the path is empty, or the head of the path is a key and this is an array or the head of the path is an index and this is an object. In both cases the function is not invoked. The same instance is returned as well when the element returned by the function is JsNothing
    
    Parameters:
    
    path - the JsPath object where the JsElem will be inserted at
    
    fn - the function that takes as an input the JsElem at the path and produces the JsElem to be inserted at the path
    
    Returns:
    
    the same instance or a new json of the same type T
  - add
```
T add(JsPath path,
      Function<? super JsElem,? extends JsElem> fn)
```
    Inserts the element returned by the function at the given path in this json, replacing any existing element at that path. If the element can no be added, a UserError exception is thrown and the function is not invoked. The following scenarios produce an error: .the input path is empty. .there's no parent where to insert the element in, because it doesn't exist or it's no a Json or it's not a Json of the expected type.
    Parameters:
    
    path - the given path
    
    fn - the function that returns the element to be inserted from the the existing element
    
    Returns:
    
    a new json of the same type T
  - add
```
default T add(JsPath path,
              JsElem elem)
```
    Inserts the given element at the given path in this json, replacing any existing element at that path. If the element can no be added, a UserError exception is thrown. The following scenarios produce an error: .the input path is empty. .there's no parent where to insert the element in, because it doesn't exist or it's no a Json or it's not a Json of the expected type.
    Parameters:
    
    path - the given path
    
    elem - the element to be inserted
    
    Returns:
    
    a new json of the same type T
  - add
```
default T add(JsPath path,
              int elem)
```
    Inserts the given integer at the given path in this json, replacing any existing element at that path. If the element can no be added, a UserError exception is thrown. The following scenarios produce an error: .the input path is empty. .there's no parent where to insert the element in, because it doesn't exist or it's no a Json or it's not a Json of the expected type.
    Parameters:
    
    path - the given path
    
    elem - the integer to be inserted
    
    Returns:
    
    a new json of the same type T
  - add
```
default T add(JsPath path,
              double elem)
```
    Inserts the given double at the given path in this json, replacing any existing element at that path. If the element can no be added, a UserError exception is thrown. The following scenarios produce an error: .the input path is empty. .there's no parent where to insert the element in, because it doesn't exist or it's no a Json or it's not a Json of the expected type.
    Parameters:
    
    path - the given path
    
    elem - the double to be inserted
    
    Returns:
    
    a new json of the same type T
  - add
```
default T add(JsPath path,
              long elem)
```
    Inserts the given long at the given path in this json, replacing any existing element at that path. If the element can no be added, a UserError exception is thrown. The following scenarios produce an error: .the input path is empty. .there's no parent where to insert the element in, because it doesn't exist or it's no a Json or it's not a Json of the expected type.
    Parameters:
    
    path - the given path
    
    elem - the long to be inserted
    
    Returns:
    
    a new json of the same type T
  - add
```
default T add(JsPath path,
              String elem)
```
    Inserts the given string at the given path in this json, replacing any existing element at that path. If the element can no be added, a UserError exception is thrown. The following scenarios produce an error: .the input path is empty. .there's no parent where to insert the element in, because it doesn't exist or it's no a Json or it's not a Json of the expected type.
    Parameters:
    
    path - the given path
    
    elem - the string to be inserted
    
    Returns:
    
    a new json of the same type T
  - add
```
default T add(JsPath path,
              boolean elem)
```
    Inserts the given boolean at the given path in this json, replacing any existing element at that path. If the element can no be added, a UserError exception is thrown. The following scenarios produce an error: .the input path is empty. .there's no parent where to insert the element in, because it doesn't exist or it's no a Json or it's not a Json of the expected type.
    Parameters:
    
    path - the given path
    
    elem - the boolean to be inserted
    
    Returns:
    
    a new json of the same type T
  - put
```
default T put(JsPath path,
              JsElem element)
```
    Inserts the element at the path in this json, replacing any existing element and filling with JsNull empty indexes in arrays when necessary.
    The same instance is returned when the head of the path is a key and this is an array or the head of the path is an index and this is an object or the element is JsNothing
    
    Parameters:
    
    path - the JsPath object where the element will be inserted at
    
    element - the JsElem that will be inserted
    
    Returns:
    
    the same instance or a new json of the same type T
  - put
```
default T put(JsPath path,
              int n)
```
    Inserts the integer number at the path in this json, replacing any existing element and filling with JsNull empty indexes in arrays when necessary. The same instance is returned when the head of the path is a key and this is an array or the head of the path is an index and this is an object or the element is JsNothing
    
    Parameters:
    
    path - the path where the integer number will be inserted at
    
    n - the integer that will be inserted
    
    Returns:
    
    the same instance or a new json of the same type T
  - put
```
default T put(JsPath path,
              long n)
```
    Inserts the long number at the path in this json, replacing any existing element and filling with JsNull empty indexes in arrays when necessary. The same instance is returned when the head of the path is a key and this is an array or the head of the path is an index and this is an object or the element is JsNothing
    
    Parameters:
    
    path - the path where the long number will be inserted at
    
    n - the long number that will be inserted
    
    Returns:
    
    the same instance or a new json of the same type T
  - put
```
default T put(JsPath path,
              String str)
```
    Inserts the string at the given path in this json, replacing any existing element in the path and filling with JsNull empty positions in arrays when necessary.
    
    Parameters:
    
    path - the path where the string will be inserted at
    
    str - the string that will be inserted
    
    Returns:
    
    the same instance or a new json of the same type T
  - put
```
default T put(JsPath path,
              BigInteger bigint)
```
    Inserts the big integer number at the given path in this json, replacing any existing element in teh path and filling with JsNull empty positions in arrays when necessary.
    
    Parameters:
    
    path - the given path where the big integer number will be inserted at
    
    bigint - the big integer number that will be inserted
    
    Returns:
    
    the same instance or a new json of the same type T
  - put
```
default T put(JsPath path,
              BigDecimal bigdecimal)
```
    Inserts the big decimal number at the given path in this json, replacing any existing element in the path and filling with JsNull empty positions in arrays when necessary.
    
    Parameters:
    
    path - the given path where the big decimal number will be inserted at
    
    bigdecimal - the big decimal number that will be inserted
    
    Returns:
    
    the same instance or a new json of the same type T
  - put
```
default T put(JsPath path,
              boolean bool)
```
    Inserts the boolean at the given path in this json, replacing any existing element in the path and filling with JsNull empty positions in arrays when necessary.
    
    Parameters:
    
    path - the given path where the boolean will be inserted at
    
    bool - the boolean that will be inserted
    
    Returns:
    
    the same instance or a new json of the same type T
  - putIf
```
default T putIf(Predicate<? super JsElem> predicate,
                JsPath path,
                Function<? super JsElem,? extends JsElem> fn)
```
    Inserts at the given path in this json, if the existing element satisfies the predicate, a new element returned by the function. If the predicate evaluates to false, the function is not computed. If the function returns JsNothing, the same this instance is returned.
    
    Parameters:
    
    predicate - the predicate on which the existing element is tested on
    
    path - the JsPath object
    
    fn - the function witch computes the new element if the existing one satisfies the given predicate
    
    Returns:
    
    the same instance or a new json of the same type T
  - putIfAbsent
```
default T putIfAbsent(JsPath path,
                      Supplier<? extends JsElem> supplier)
```
    Inserts at the given path in this json, if no element is present, the element returned by the supplier, replacing any existing element in the path and filling with JsNull empty positions in arrays when necessary. The supplier is not invoked if the element is present.
    
    Parameters:
    
    path - the given JsPath object
    
    supplier - the supplier which computes the new JsElem if absent
    
    Returns:
    
    the same instance or a new json of the same type T
  - putIfAbsent
```
default T putIfAbsent(JsPath path,
                      int number)
```
    Inserts at the given path in this json, if no element is present, the specified integer, replacing any existing element in the path and filling with JsNull empty positions in arrays when necessary.
    
    Parameters:
    
    path - the given JsPath object
    
    number - the specified integer
    
    Returns:
    
    the same instance or a new json of the same type T
  - putIfAbsent
```
default T putIfAbsent(JsPath path,
                      long number)
```
    Inserts at the given path in this json, if no element is present, the specified long, replacing any existing element in the path and filling with JsNull empty positions in arrays when necessary.
    
    Parameters:
    
    path - the given JsPath object
    
    number - the specified long
    
    Returns:
    
    the same instance or a new json of the same type T
  - putIfAbsent
```
default T putIfAbsent(JsPath path,
                      double number)
```
    Inserts at the given path in this json, if no element is present, the specified double, replacing any existing element in the path and filling with JsNull empty positions in arrays when necessary.
    
    Parameters:
    
    path - the given JsPath object
    
    number - the specified double
    
    Returns:
    
    the same instance or a new json of the same type T
  - putIfPresent
```
default T putIfPresent(JsPath path,
                       int number)
```
    Inserts at the given path in this json, if some element is present, the specified integer.
    
    Parameters:
    
    path - the given path
    
    number - the specified integer
    
    Returns:
    
    the same instance or a new json of the same type T
  - putIfPresent
```
default T putIfPresent(JsPath path,
                       long number)
```
    Inserts at the given path in this json, if some element is present, the specified long.
    
    Parameters:
    
    path - the given path
    
    number - the specified long
    
    Returns:
    
    the same instance or a new json of the same type T
  - putIfPresent
```
default T putIfPresent(JsPath path,
                       double number)
```
    Inserts at the given path in this json, if some element is present, the specified double.
    
    Parameters:
    
    path - the given path
    
    number - the specified double
    
    Returns:
    
    the same instance or a new json of the same type T
  - appendIfPresent
```
default T appendIfPresent(JsPath path,
                          int number,
                          int... others)
```
    Appends one or more integers to the array located at the given path in this json, returning the same this instance if the array is not present.
    
    Parameters:
    
    path - the path pointing to the existing array in which the integers will be appended
    
    number - the integer to be appended
    
    others - more optional integers to be appended
    
    Returns:
    
    same this instance or a new json of the same type T
  - appendIfPresent
```
default T appendIfPresent(JsPath path,
                          long number,
                          long... others)
```
    Appends one or more longs to the array located at the given path in this json, returning the same this instance if the array is not present.
    
    Parameters:
    
    path - the path pointing to the existing array in which the longs will be appended
    
    number - the long to be appended
    
    others - more optional longs to be appended
    
    Returns:
    
    same this instance or a new json of the same type T
  - appendIfPresent
```
default T appendIfPresent(JsPath path,
                          String str,
                          String... others)
```
    Appends one or more strings to the array located at the given path in this json, returning the same this instance if the array is not present.
    
    Parameters:
    
    path - the path pointing to the existing array in which the strings will be appended
    
    str - the string to be appended
    
    others - more optional strings to be appended
    
    Returns:
    
    same this instance or a new json of the same type T
  - appendIfPresent
```
default T appendIfPresent(JsPath path,
                          boolean number,
                          boolean... others)
```
    Appends one or more booleans to the array located at the given path in this json, returning the same this instance if the array is not present.
    
    Parameters:
    
    path - the path pointing to the existing array in which the booleans will be appended
    
    number - the boolean to be appended
    
    others - more optional booleans to be appended
    
    Returns:
    
    same this instance or a new json of the same type T
  - appendIfPresent
```
default T appendIfPresent(JsPath path,
                          double number,
                          double... others)
```
    Appends one or more doubles to the array located at the given path in this json, returning the same this instance if the array is not present.
    
    Parameters:
    
    path - the path pointing to the existing array in which the doubles will be appended
    
    number - the double to be appended
    
    others - more optional doubles to be appended
    
    Returns:
    
    same this instance or a new json of the same type T
  - append
```
default T append(JsPath path,
                 String elem,
                 String... others)
```
    Appends one or more strings, starting from the first, to the array located at the given path in this json. If the array doesn't exist, a new one is created, replacing any existing element in the path and filling empty indexes in arrays with JsNull when necessary. The same this instance is returned when it's an array and the head of the path is a key or when it's an object and the head of the path is an index.
    
    Parameters:
    
    path - the given path pointing to the array in which all the strings will be appended
    
    elem - the first string to be appended to the existing or created array
    
    others - more optional strings to be appended
    
    Returns:
    
    same this instance or a new json of the same type T
  - append
```
default T append(JsPath path,
                 int elem,
                 int... others)
```
    Appends one or more integers, starting from the first, to the array located at the given path in this json. If the array doesn't exist, a new one is created, replacing any existing element in the path and filling empty indexes in arrays with JsNull when necessary. The same this instance is returned when it's an array and the head of the path is a key or when it's an object and the head of the path is an index.
    
    Parameters:
    
    path - the given path pointing to the array in which all the integers will be appended
    
    elem - the first integer to be appended to the existing or created array
    
    others - more optional integers to be appended
    
    Returns:
    
    same this instance or a new json of the same type T
  - append
```
default T append(JsPath path,
                 long elem,
                 long... others)
```
    Appends one or more longs, starting from the first, to the array located at the given path in this json. If the array doesn't exist, a new one is created, replacing any existing element in the path and filling empty indexes in arrays with JsNull when necessary. The same this instance is returned when it's an array and the head of the path is a key or when it's an object and the head of the path is an index.
    
    Parameters:
    
    path - the given path pointing to the array in which all the longs will be appended
    
    elem - the first long to be appended to the existing or created array
    
    others - more optional longs to be appended
    
    Returns:
    
    same this instance or a new json of the same type T
  - append
```
default T append(JsPath path,
                 boolean elem,
                 boolean... others)
```
    Appends one or more booleans, starting from the first, to the array located at the given path in this json. If the array doesn't exist, a new one is created, replacing any existing element in the path and filling empty indexes in arrays with JsNull when necessary. The same this instance is returned when it's an array and the head of the path is a key or when it's an object and the head of the path is an index.
    
    Parameters:
    
    path - the given path pointing to the array in which all the booleans will be appended
    
    elem - the first boolean to be appended to the existing or created array
    
    others - more optional booleans to be appended
    
    Returns:
    
    same this instance or a new json of the same type T
  - append
```
default T append(JsPath path,
                 double elem,
                 double... others)
```
    Appends one or more doubles, starting from the first, to the array located at the given path in this json. If the array doesn't exist, a new one is created, replacing any existing element in the path and filling empty indexes in arrays with JsNull when necessary. The same this instance is returned when it's an array and the head of the path is a key or when it's an object and the head of the path is an index.
    
    Parameters:
    
    path - the given path pointing to the array in which all the doubles will be appended
    
    elem - the first double to be appended to the existing or created array
    
    others - more optional doubles to be appended
    
    Returns:
    
    same this instance or a new json of the same type T
  - prepend
```
default T prepend(JsPath path,
                  String elem,
                  String... others)
```
    Prepends one or more strings, starting from the first, to the array located at the path in this json. If the array at the path doesn't exist, a new one is created, replacing any existing element and filling empty indexes in arrays with JsNull when necessary. The same this instance is returned when it's an array and the head of the path is a key or when it's an object and the head of the path is an index.
    
    Parameters:
    
    path - the path-like string pointing to the array in which all the string will be prepended
    
    elem - the first string to be prepended to the existing or created array
    
    others - more optional strings to be prepended
    
    Returns:
    
    same this instance or a new json of the same type T
  - prepend
```
default T prepend(JsPath path,
                  int elem,
                  int... others)
```
    prepends one or more integers, starting from the first, to the array located at the path in this json. If the array at the path doesn't exist, a new one is created, replacing any existing element in the path and filling empty indexes in arrays with JsNull when necessary. The same this instance is returned when it's an array and the head of the path is a key or when it's an object and the head of the path is an index.
    
    Parameters:
    
    path - the JsPath pointing to the array in which all the integers will be prepended
    
    elem - the first integer to be prepended to the existing or created array
    
    others - more optional integers to be prepended
    
    Returns:
    
    same this instance or a new json of the same type T
  - prepend
```
default T prepend(JsPath path,
                  long elem,
                  long... others)
```
    prepends one or more longs, starting from the first, to the array located at the path in this json. If the array at the path doesn't exist, a new one is created, replacing any existing element in the path and filling empty indexes in arrays with JsNull when necessary. The same this instance is returned when it's an array and the head of the path is a key or when it's an object and the head of the path is an index.
    
    Parameters:
    
    path - the JsPath pointing to the array in which all the longs will be prepended
    
    elem - the first long to be prepended to the existing or created array
    
    others - more optional longs to be prepended
    
    Returns:
    
    same this instance or a new json of the same type T
  - prepend
```
default T prepend(JsPath path,
                  boolean elem,
                  boolean... others)
```
    prepends one or more booleans, starting from the first, to the array located at the path in this json. If the array at the path doesn't exist, a new one is created, replacing any existing element in the path and filling empty indexes in arrays with JsNull when necessary. The same this instance is returned when it's an array and the head of the path is a key or when it's an object and the head of the path is an index.
    
    Parameters:
    
    path - the JsPath pointing to the array in which all the booleans will be prepended
    
    elem - the first boolean to be prepended to the existing or created array
    
    others - more optional booleans to be prepended
    
    Returns:
    
    same this instance or a new json of the same type T
  - prepend
```
default T prepend(JsPath path,
                  double elem,
                  double... others)
```
    prepends one or more doubles, starting from the first, to the array located at the path in this json. If the array at the path doesn't exist, a new one is created, replacing any existing element in the path and filling empty indexes in arrays with JsNull when necessary. The same this instance is returned when it's an array and the head of the path is a key or when it's an object and the head of the path is an index.
    
    Parameters:
    
    path - the JsPath pointing to the array in which all the doubles will be prepended
    
    elem - the first double to be prepended to the existing or created array
    
    others - more optional doubles to be prepended
    
    Returns:
    
    same this instance or a new json of the same type T
  - putIfPresent
```
default T putIfPresent(JsPath path,
                       Function<? super JsElem,? extends JsElem> fn)
```
    Inserts at the given path in this json, if some element is present, the element returned by the function.
    
    Parameters:
    
    path - the given JsPath object
    
    fn - the function which computes the new JsElem from the existing one
    
    Returns:
    
    the same instance or a new json of the same type T
  - reduce
```
<R> Optional<R> reduce(BinaryOperator<R> op,
                       Function<? super JsPair,R> map,
                       Predicate<? super JsPair> predicate)
```
    Performs a reduction on the values that satisfy the predicate in the first level of this json. The reduction is performed mapping each value with the mapping function and then applying the operator
    
    Type Parameters:
    
    R - the type of the operands of the operator
    
    Parameters:
    
    op - the operator upon two objects of type R
    
    map - the mapping function which produces an object of type R from a JsValue
    
    predicate - the predicate that determines what JsValue will be mapped and reduced
    
    Returns:
    
    an Optional describing the of of the reduction
    
    See Also:
    
    to apply the reduction in all the Json and not only in the first level
  - reduce_
```
<R> Optional<R> reduce_(BinaryOperator<R> op,
                        Function<? super JsPair,R> map,
                        Predicate<? super JsPair> predicate)
```
    Performs a reduction on the values of this json that satisfy the predicate. The reduction is performed mapping each value with the mapping function and then applying the operator
    
    Type Parameters:
    
    R - the type of the operands of the operator
    
    Parameters:
    
    op - the operator upon two objects of type R
    
    map - the mapping function which produces an object of type R from a JsValue
    
    predicate - the predicate that determines what JsValue will be mapped and reduced
    
    Returns:
    
    an Optional describing the result of the reduction
    
    See Also:
    
    to apply the reduction only in the first level
  - remove
```
T remove(JsPath path)
```
    Removes the element in this json located at the given path, if it exists, returning the same this instance otherwise
    
    Parameters:
    
    path - the given JsPath object
    
    Returns:
    
    a json of the same type T
  - size
```
int size()
```
    Returns the number of elements in the first level of this json
    
    Returns:
    
    the number of elements in the first level of this json
  - size_
```
default int size_()
```
    Returns the number of all the elements in this json
    
    Returns:
    
    the number of all the elements in this json
  - size
```
default OptionalInt size(JsPath path)
```
    Returns the size of the json located at the given path in this json or OptionalInt.empty() if it doesn't exist or it's not a Json
    
    Parameters:
    
    path - the given JsPath object
    
    Returns:
    
    an OptionalInt
  - size_
```
default OptionalInt size_(JsPath path)
```
    Returns the size of the json located at the given path in this json or OptionalInt.empty() if it doesn't exist or it's not a Json
    
    Parameters:
    
    path - the given JsPath object
    
    Returns:
    
    an OptionalInt
  - stream_
```
Stream<JsPair> stream_()
```
    Returns a stream over all the pairs of elements in this json object.
    
    Returns:
    
    a Stream over all the JsPairs in this json
  - stream
```
Stream<JsPair> stream()
```
    Returns a stream over the pairs of elements in the first level of this json object.
    
    Returns:
    
    a Stream over all the JsPairs in the first level of this json
  - toImmutable
```
T toImmutable()
```
    Converts this json into immutable if it's mutable, returning this same instance otherwise.
    
    Returns:
    
    an immutable Json
  - toMutable
```
T toMutable()
```
    Converts this json into mutable if it's immutable, returning this same instance otherwise.
    
    Returns:
    
    an mutable Json
  - containsPath
```
default boolean containsPath(JsPath path)
```
    Returns true if an element exists in this json at the given path.
    
    Parameters:
    
    path - the JsPath
    
    Returns:
    
    true if a JsElem exists at the JsPath
  - containsElem
```
boolean containsElem(JsElem element)
```
    Returns true if this json contains the given element in the first level.
    
    Parameters:
    
    element - the give element JsElem whose presence in this JsArray is to be tested
    
    Returns:
    
    true if this JsArray contains the JsElem
  - containsElem_
```
default boolean containsElem_(JsElem element)
```
    Returns true if this json or any of its elements, contains the given element.
    
    Parameters:
    
    element - the give JsElem whose presence in this JsArray is to be tested
    
    Returns:
    
    true if this JsArray contains the JsElem
  - map
```
default T map(UnaryOperator<T> fn)
```
  - isMutable
```
boolean isMutable()
```
    Returns:
    
    true if the implementation is mutable
  - isImmutable
```
boolean isImmutable()
```
    Returns:
    
    true if the implementation is immutable
  - isNothing
```
default boolean isNothing()
```
    Specified by:
    
    isNothing in interface JsElem
    
    Returns:
    
    true if this element is JsNothing
  - isNull
```
default boolean isNull()
```
    Specified by:
    
    isNull in interface JsElem
    
    Returns:
    
    true if this element is null
  - isNumber
```
default boolean isNumber()
```
    Specified by:
    
    isNumber in interface JsElem
    
    Returns:
    
    true if this element is a number
  - isBool
```
default boolean isBool()
```
    Specified by:
    
    isBool in interface JsElem
    
    Returns:
    
    true if this JsElem is a JsBool
  - isStr
```
default boolean isStr()
```
    Specified by:
    
    isStr in interface JsElem
    
    Returns:
    
    true if this JsElem is a JsStr
  - isTrue
```
default boolean isTrue()
```
    Specified by:
    
    isTrue in interface JsElem
    
    Returns:
    
    true if this JsElem is a JsBool and it's true
  - isFalse
```
default boolean isFalse()
```
    Specified by:
    
    isFalse in interface JsElem
    
    Returns:
    
    true if this JsElem is a JsBool and it's false
  - isInt
```
default boolean isInt()
```
    Specified by:
    
    isInt in interface JsElem
    
    Returns:
    
    true if this JsElem is a JsInt
  - isDouble
```
default boolean isDouble()
```
    Specified by:
    
    isDouble in interface JsElem
    
    Returns:
    
    true if this JsElem is a JsDouble
  - isBigDec
```
default boolean isBigDec()
```
    Specified by:
    
    isBigDec in interface JsElem
    
    Returns:
    
    true if this JsElem is a JsBigDec
  - isLong
```
default boolean isLong()
```
    Specified by:
    
    isLong in interface JsElem
    
    Returns:
    
    true if this JsElem is a JsLong
  - isBigInt
```
default boolean isBigInt()
```
    Specified by:
    
    isBigInt in interface JsElem
    
    Returns:
    
    true if this JsElem is a JsBigInt
  - patch
```
TryPatch<T> patch(JsArray ops)
```
    Implementation of the Json Patch specification. Go to https://tools.ietf.org/html/rfc6902 for further details.
    
    Parameters:
    
    ops - operations to be applied to the json
    
    Returns:
    
    a TryPatch computation

Interface Json<T extends Json<T>>

Field Summary

Method Summary

Methods inherited from interface jsonvalues.JsElem

Field Detail

serialVersionUID

Method Detail

_parse_

_parse_

appendAll

append

append

appendIfPresent

appendAllIfPresent

prependAll

prepend

prepend

prependAllIfPresent

prependIfPresent

prependIfPresent

prependIfPresent

prependIfPresent

prependIfPresent

prependIfPresent

filterElems

filterElems_

filterObjs

filterObjs_

filterKeys

filterKeys_

get

get

getArray

getBigDecimal

getBigInt

getBool

getDouble

getInt

getLong

getObj

getStr

ifEmptyElse

times

times_

equals

isEmpty

isNotEmpty

mapElems

mapElems

mapElems_

mapElems_

mapObjs

mapObjs

mapObjs_

mapObjs_

mapKeys

mapKeys

mapKeys_

mapKeys_

merge

parse

parse

put

add

add

add

add

add

add

add

put

put

put

put

put

put

put

putIf

putIfAbsent

putIfAbsent