JsonPointer (json-schema-validator 0.5.3 API)

java.lang.Object
- org.eel.kitchen.jsonschema.ref.JsonFragment
- - org.eel.kitchen.jsonschema.ref.JsonPointer

All Implemented Interfaces:

Comparable<JsonPointer>
```
public final class JsonPointer
extends JsonFragment
implements Comparable<JsonPointer>
```
Implementation of IETF JSON Pointer draft, version 3
JSON Pointer is an IETF draft defining a way to address paths within JSON documents. Paths apply to container objects, ie arrays or nodes. For objects, path elements are property names. For arrays, they are the index in the array (starting from 0).

The general syntax is #/path/elements/here. A path element is referred to as a "reference token" in the specification.

The difficulty with JSON Pointer is that any JSON String is valid as an object's property name. These are all valid:
- "" -- the empty string;
- "/";
- "0";
- "-1";
- ".", "..", "../..".
The latter example is the reason why a JSON Pointer is always absolute.

All instances of this class are immutable (therefore thread safe).

Field Summary

Fields
Modifier and Type	Field and Description
`private List<String>`	`elements` The list of individual elements in the pointer.
`private static CharMatcher`	`ESCAPE_CHAR`
`private static BiMap<Character,Character>`	`ESCAPE_REPLACEMENT_MAP`
`private static CharMatcher`	`ESCAPED`
`private String`	`fullPointer` The pointer in a raw, but JSON Pointer-escaped, string.
`private static CharMatcher`	`SLASH`
`private static CharMatcher`	`SPECIAL`

Constructor Summary

Constructors
Modifier Constructor and Description

JsonPointer(String input)
Constructor

private JsonPointer(String fullPointer, List<String> elements)

Constructors
Modifier	Constructor and Description
	`JsonPointer(String input)` Constructor
`private`	`JsonPointer(String fullPointer, List<String> elements)`

Method Summary

Methods
Modifier and Type	Method and Description
`JsonPointer`	`append(int index)` Append an array index to this pointer.
`JsonPointer`	`append(String element)` Append a path element to this pointer.
`int`	`compareTo(JsonPointer other)`
`private static void`	`decode(String input, ImmutableList.Builder<String> builder)` Initialize the object
`boolean`	`equals(Object obj)`
`private static String`	`getNextRefToken(String input)` Grab a (cooked) reference token from an input string
`int`	`hashCode()`
`private static JsonSchemaException`	`illegalPointer(String message)`
`private static String`	`refTokenDecode(String cooked)` Turn a cooked reference token into a raw reference token
`private static String`	`refTokenEncode(String raw)` Make a cooked reference token out of a raw element token
`JsonNode`	`resolve(JsonNode node)` Resolve this fragment against a given node
`String`	`toString()`

Methods inherited from class org.eel.kitchen.jsonschema.ref.JsonFragment
fromFragment, isEmpty

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - SLASH
```
private static final CharMatcher SLASH
```
  - ESCAPE_CHAR
```
private static final CharMatcher ESCAPE_CHAR
```
  - ESCAPE_REPLACEMENT_MAP
```
private static final BiMap<Character,Character> ESCAPE_REPLACEMENT_MAP
```
  - ESCAPED
```
private static final CharMatcher ESCAPED
```
  - SPECIAL
```
private static final CharMatcher SPECIAL
```
  - fullPointer
```
private final String fullPointer
```
    The pointer in a raw, but JSON Pointer-escaped, string.
  - elements
```
private final List<String> elements
```
    The list of individual elements in the pointer.
- Constructor Detail
  - JsonPointer
```
public JsonPointer(String input)
            throws JsonSchemaException
```
    Constructor
    
    Parameters:
    input - The input string, guaranteed not to be JSON encoded
    
    Throws:
    
    JsonSchemaException - Illegal JSON Pointer
  - JsonPointer
```
private JsonPointer(String fullPointer,
           List<String> elements)
```
- Method Detail
  - append
```
public JsonPointer append(String element)
```
    Append a path element to this pointer. Returns a new instance.
    
    Parameters:
    element - the element to append
    
    Returns:
    a new instance with the element appended
  - append
```
public JsonPointer append(int index)
```
    Append an array index to this pointer. Returns a new instance.
    Note that the index validity is NOT checked for (ie, you can append -1 if you want to -- don't do that)
    
    Parameters:
    index - the index to add
    
    Returns:
    a new instance with the index appended
  - resolve
```
public JsonNode resolve(JsonNode node)
```
    Description copied from class: JsonFragment
    
    Resolve this fragment against a given node
    
    Specified by:
    
    resolve in class JsonFragment
    
    Parameters:
    node - the node
    
    Returns:
    the result node (MissingNode if the fragment is not found)
  - decode
```
private static void decode(String input,
          ImmutableList.Builder<String> builder)
                    throws JsonSchemaException
```
    Initialize the object
    We read the string sequentially, a slash, then a reference token, then a slash, etc. Bail out if the string is malformed.
    
    Parameters:
    input - Input string, guaranteed not to be JSON/URI encoded
    builder - the list builder
    
    Throws:
    
    JsonSchemaException - the input is not a valid JSON Pointer
  - getNextRefToken
```
private static String getNextRefToken(String input)
                               throws JsonSchemaException
```
    Grab a (cooked) reference token from an input string
    This method is only called from decode(String, ImmutableList.Builder), after a delimiter (/) has been swallowed up. The input string is therefore guaranteed to start with a reference token, which may be empty.
    
    Parameters:
    input - the input string
    
    Returns:
    the cooked reference token
    
    Throws:
    
    JsonSchemaException - the string is malformed
  - refTokenDecode
```
private static String refTokenDecode(String cooked)
```
    Turn a cooked reference token into a raw reference token
    This means we replace all occurrences of ~0 with ~, and all occurrences of ~1 with /.
    
    It is called from decode(java.lang.String, com.google.common.collect.ImmutableList.Builder<java.lang.String>), in order to push a token into elements.
    
    Parameters:
    cooked - the cooked token
    
    Returns:
    the raw token
  - refTokenEncode
```
private static String refTokenEncode(String raw)
```
    Make a cooked reference token out of a raw element token
    Used to build new pointer instances when called from (String) or append(int), in order to build fullPointer.
    
    Parameters:
    raw - the raw token
    
    Returns:
    the cooked token
  - illegalPointer
```
private static JsonSchemaException illegalPointer(String message)
```
  - compareTo
```
public int compareTo(JsonPointer other)
```
    Specified by:
    
    compareTo in interface Comparable<JsonPointer>
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Specified by:
    
    toString in class JsonFragment

Class JsonPointer

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.eel.kitchen.jsonschema.ref.JsonFragment

Methods inherited from class java.lang.Object

Field Detail

SLASH

ESCAPE_CHAR

ESCAPE_REPLACEMENT_MAP

ESCAPED

SPECIAL

fullPointer

elements

Constructor Detail

JsonPointer

JsonPointer

Method Detail

append

append

resolve

decode

getNextRefToken

refTokenDecode

refTokenEncode

illegalPointer

compareTo

equals

hashCode

toString