LazyValueMap (Groovy 2.4.15)

java.lang.Object
- java.util.AbstractMap<String,Object>
- - groovy.json.internal.LazyValueMap

All Implemented Interfaces:

ValueMap<String,Object>, Map<String,Object>
```
public class LazyValueMap
extends AbstractMap<String,Object>
implements ValueMap<String,Object>
```
This class is important to the performance of the parser. It stores Value objects in a map where they are evaluated lazily. This is great for JSONPath types of application, and Object Serialization but not for maps that are going to be stored in a cache.
This is because the Value construct is a type of index overlay that merely tracks where the token is located in the buffer, and what if any thing we noted about it (like can be converted to a decimal number, etc.).
To mitigate memory leaks this class along with CharSequenceValue implement two constructs, namely, chop, and lazyChop.
A chop is when we convert backing buffer of a Value object into a smaller buffer. A lazyChop is when we do a chop but only when a get operation is called.
The lazyChop is performed on the tree that is touched by the JSONPath expression or its ilk.
The chop operation can be done during parsing or lazily by storing the values in this construct.

Author:

Rick Hightower (insane chipmonk)

Nested Class Summary
- Nested classes/interfaces inherited from class java.util.AbstractMap
  AbstractMap.SimpleEntry<K extends Object,V extends Object>, AbstractMap.SimpleImmutableEntry<K extends Object,V extends Object>
- Nested classes/interfaces inherited from interface java.util.Map
  Map.Entry<K extends Object,V extends Object>

Constructor Summary

Constructors
Constructor Description

LazyValueMap(boolean lazyChop)

LazyValueMap(boolean lazyChop, int initialSize)

Constructors
Constructor	Description
`LazyValueMap(boolean lazyChop)`
`LazyValueMap(boolean lazyChop, int initialSize)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`add(MapItemValue miv)`	Adds a new MapItemValue to the mapping.
`void`	`chopMap()`	Chop this map.
`Set<Map.Entry<String,Object>>`	`entrySet()`
`Object`	`get(Object key)`	Gets the item by key from the mapping.
`boolean`	`hydrated()`	Has the map been hydrated.
`Map.Entry<String,Value>[]`	`items()`	Give me the items in the map without hydrating the map.
`int`	`len()`	Return size w/o hydrating the map.
`Value`	`put(String key, Object value)`
`int`	`size()`
`String`	`toString()`
`Collection<Object>`	`values()`

Methods inherited from class java.util.AbstractMap
clear, clone, containsKey, containsValue, equals, hashCode, isEmpty, keySet, putAll, remove

Methods inherited from interface java.util.Map
clear, compute, computeIfAbsent, computeIfPresent, containsKey, containsValue, equals, forEach, getOrDefault, hashCode, isEmpty, keySet, merge, putAll, putIfAbsent, remove, remove, replace, replace, replaceAll

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

- Constructor Detail
  - LazyValueMap
```
public LazyValueMap(boolean lazyChop)
```
  - LazyValueMap
```
public LazyValueMap(boolean lazyChop,
                    int initialSize)
```
- Method Detail
  - add
```
public final void add(MapItemValue miv)
```
    Adds a new MapItemValue to the mapping.
    
    Specified by:
    
    add in interface ValueMap<String,Object>
    
    Parameters:
    
    miv - miv we are adding.
  - get
```
public final Object get(Object key)
```
    Gets the item by key from the mapping.
    
    Specified by:
    
    get in interface Map<String,Object>
    
    Overrides:
    
    get in class AbstractMap<String,Object>
    
    Parameters:
    
    key - to lookup
    
    Returns:
    
    the item for the given key
  - chopMap
```
public final void chopMap()
```
    Chop this map.
  - put
```
public Value put(String key,
                 Object value)
```
    Specified by:
    
    put in interface Map<String,Object>
    
    Overrides:
    
    put in class AbstractMap<String,Object>
  - entrySet
```
public Set<Map.Entry<String,Object>> entrySet()
```
    Specified by:
    
    entrySet in interface Map<String,Object>
    
    Specified by:
    
    entrySet in class AbstractMap<String,Object>
  - values
```
public Collection<Object> values()
```
    Specified by:
    
    values in interface Map<String,Object>
    
    Overrides:
    
    values in class AbstractMap<String,Object>
  - size
```
public int size()
```
    Specified by:
    
    size in interface Map<String,Object>
    
    Overrides:
    
    size in class AbstractMap<String,Object>
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class AbstractMap<String,Object>
  - len
```
public int len()
```
    Description copied from interface: ValueMap
    
    Return size w/o hydrating the map.
    
    Specified by:
    
    len in interface ValueMap<String,Object>
  - hydrated
```
public boolean hydrated()
```
    Description copied from interface: ValueMap
    
    Has the map been hydrated.
    
    Specified by:
    
    hydrated in interface ValueMap<String,Object>
  - items
```
public Map.Entry<String,Value>[] items()
```
    Description copied from interface: ValueMap
    
    Give me the items in the map without hydrating the map. Realize that the array is likely larger than the length so array items can be null.
    
    Specified by:
    
    items in interface ValueMap<String,Object>

Class LazyValueMap

Nested Class Summary

Nested classes/interfaces inherited from class java.util.AbstractMap

Nested classes/interfaces inherited from interface java.util.Map

Constructor Summary

Method Summary

Methods inherited from class java.util.AbstractMap

Methods inherited from interface java.util.Map

Methods inherited from class java.lang.Object

Constructor Detail

LazyValueMap

LazyValueMap

Method Detail

add

get

chopMap

put

entrySet

values

size

toString

len

hydrated

items