com.cedarsoftware.util.io

Class MapResolver

java.lang.Object

com.cedarsoftware.util.io.Resolver

com.cedarsoftware.util.io.MapResolver

All Implemented Interfaces:

ReaderContext

public class MapResolver
extends Resolver

The MapResolver converts the raw Maps created from the JsonParser to higher quality Maps representing the implied object graph. It does this by replacing @ref values with the Map indicated by the @id key with the same value.

This approach 'wires' the original object graph. During the resolution process, if 'peer' classes can be found for given Maps (for example, an @type entry is available which indicates the class that would have been associated to the Map, then the associated class is consulted to help 'improve' the quality of the primitive values within the map fields. For example, if the peer class indicated that a field was of type 'short', and the Map had a long value (JSON only returns long's for integer types), then the long would be converted to a short.

The final Map representation is a very high-quality graph that represents the original JSON graph. It can be passed as input to JsonWriter, and the JsonWriter will write out the equivalent JSON to what was originally read. This technique allows json-io to be used on a machine that does not have any of the Java classes from the original graph, read it in a JSON graph (any JSON graph), return the equivalent maps, allow mutations of those maps, and finally this graph can be written out.

Author:

John DeRegnaucourt ([email protected])
Copyright (c) Cedar Software LLC

Licensed 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

License

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.

Nested Class Summary

Nested classes/interfaces inherited from class com.cedarsoftware.util.io.Resolver

Resolver.Missingfields

Field Summary

Fields inherited from class com.cedarsoftware.util.io.Resolver

missingFields

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	MapResolver(ReadOptions readOptions, ReferenceTracker references, com.cedarsoftware.util.convert.Converter converter)

Method Summary

Modifier and Type	Method and Description
protected Object	readWithFactoryIfExists(Object o, Class compType, Deque<JsonObject> stack)
protected void	traverseArray(Deque<JsonObject> stack, JsonObject jsonObj)
protected void	traverseCollection(Deque<JsonObject> stack, JsonObject jsonObj) Process java.util.Collection and it's derivatives.
void	traverseFields(Deque<JsonObject> stack, JsonObject jsonObj) Walk the JsonObject fields and perform necessary substitutions so that all references matched up.

Methods inherited from class com.cedarsoftware.util.io.Resolver

cleanup, coerceClassIfNeeded, convertJsonValuesToJava, convertMapToKeysItems, createInstance, createInstanceUsingType, extractEnumSet, patchUnresolvedReferences, reentrantConvertJsonValueToJava, rehashMaps, resolveRefs, traverseMap

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface com.cedarsoftware.util.io.ReaderContext

getConverter, getReadOptions, getReferences

Constructor Detail

MapResolver

protected MapResolver(ReadOptions readOptions,
                      ReferenceTracker references,
                      com.cedarsoftware.util.convert.Converter converter)

Method Detail

readWithFactoryIfExists

protected Object readWithFactoryIfExists(Object o,
                                         Class compType,
                                         Deque<JsonObject> stack)

Specified by:

readWithFactoryIfExists in class Resolver

traverseFields

public void traverseFields(Deque<JsonObject> stack,
                           JsonObject jsonObj)

Walk the JsonObject fields and perform necessary substitutions so that all references matched up. This code patches @ref and @id pairings up, in the 'Map of Map' mode. Where the JSON may contain an @id of an object which can have more than one @ref to it, this code will make sure that each

Parameters:

stack - Stack (Deque) used for graph traversal.

jsonObj - a Map-of-Map representation of the current object being examined (containing all fields).

traverseCollection

protected void traverseCollection(Deque<JsonObject> stack,
                                  JsonObject jsonObj)

Process java.util.Collection and it's derivatives. Collections are written specially so that the serialization does not expose the Collection's internal structure, for example a TreeSet. All entries are processed, except unresolved references, which are filled in later. For an indexable collection, the unresolved references are set back into the proper element location. For non-indexable collections (Sets), the unresolved references are added via .add().

Specified by:

traverseCollection in class Resolver

Parameters:

stack - a Stack (Deque) used to support graph traversal.

jsonObj - a Map-of-Map representation of the JSON input stream.

traverseArray

protected void traverseArray(Deque<JsonObject> stack,
                             JsonObject jsonObj)

Specified by:

traverseArray in class Resolver