org.apache.groovy.json.internal

## Class LazyValueMap

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

- All Implemented Interfaces:
    Map<String,Object>, ValueMap<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.

- - ### Nested Class Summary

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

      `AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V>`

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

      `Map.Entry<K,V>`

  - ### Constructor Summary

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

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and 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 class java.lang.Object

      `finalize, getClass, notify, notifyAll, wait, wait, wait`

    - ### 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`

- - ### 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>`