Package Summary Overview Summary

### class:SimpleBindings [NONE]
- All Implemented Interfaces: Map<String,Object>, Bindings
      public class SimpleBindings
      extends Object
      implements Bindings
A simple implementation of Bindings backed by a `HashMap` or some other specified `Map`. Since: 1.6

### constructor:SimpleBindings(java.util.Map) [NONE]
- #### SimpleBindings
      public SimpleBindings(Map<String,Object> m)
Constructor uses an existing `Map` to store the values. Parameters: `m` - The `Map` backing this `SimpleBindings`. Throws: `NullPointerException` - if m is null

### constructor:SimpleBindings() [NONE]
- #### SimpleBindings
      public SimpleBindings()
Default constructor uses a `HashMap`.

### method:put(java.lang.String, java.lang.Object) [NONE]
- #### put
      public Object put(String name,
                        Object value)
Sets the specified key/value in the underlying `map` field. Specified by: `put` in interface `Map<String,Object>` Specified by: `put` in interface `Bindings` Parameters: `name` - Name of value `value` - Value to set. Returns: Previous value for the specified key. Returns null if key was previously unset. Throws: `NullPointerException` - if the name is null. `IllegalArgumentException` - if the name is empty.

### method:putAll(java.util.Map) [NONE]
- #### putAll
      public void putAll(Map<? extends String,? extends Object> toMerge)
`putAll` is implemented using `Map.putAll`. Specified by: `putAll` in interface `Map<String,Object>` Specified by: `putAll` in interface `Bindings` Parameters: `toMerge` - The `Map` of values to add. Throws: `NullPointerException` - if toMerge map is null or if some key in the map is null. `IllegalArgumentException` - if some key in the map is an empty String.

### method:clear() [NONE]
- #### clear
      public void clear()
Removes all of the mappings from this map (optional operation). The map will be empty after this call returns. Specified by: `clear` in interface `Map<String,Object>`

### method:containsKey(java.lang.Object) [NONE]
- #### containsKey
      public boolean containsKey(Object key)
Returns `true` if this map contains a mapping for the specified key. More formally, returns `true` if and only if this map contains a mapping for a key `k` such that `(key==null ? k==null : key.equals(k))` . (There can be at most one such mapping.) Specified by: `containsKey` in interface `Map<String,Object>` Specified by: `containsKey` in interface `Bindings` Parameters: `key` - key whose presence in this map is to be tested. Returns: `true` if this map contains a mapping for the specified key. Throws: `NullPointerException` - if key is null `ClassCastException` - if key is not String `IllegalArgumentException` - if key is empty String

### method:containsValue(java.lang.Object) [NONE]
- #### containsValue
      public boolean containsValue(Object value)
Returns `true` if this map maps one or more keys to the specified value. More formally, returns `true` if and only if this map contains at least one mapping to a value `v` such that `(value==null ? v==null : value.equals(v))` . This operation will probably require time linear in the map size for most implementations of the `Map` interface. Specified by: `containsValue` in interface `Map<String,Object>` Parameters: `value` - value whose presence in this map is to be tested Returns: `true` if this map maps one or more keys to the specified value

### method:entrySet() [NONE]
- #### entrySet
      public Set<Map.Entry<String,Object>> entrySet()
Returns a `Set` view of the mappings contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own `remove` operation, or through the `setValue` operation on a map entry returned by the iterator) the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Set.remove`, `removeAll`, `retainAll` and `clear` operations. It does not support the `add` or `addAll` operations. Specified by: `entrySet` in interface `Map<String,Object>` Returns: a set view of the mappings contained in this map

### method:get(java.lang.Object) [NONE]
- #### get
      public Object get(Object key)
Returns the value to which this map maps the specified key. Returns `null` if the map contains no mapping for this key. A return value of `null` does not necessarily indicate that the map contains no mapping for the key; it's also possible that the map explicitly maps the key to `null`. The `containsKey` operation may be used to distinguish these two cases. More formally, if this map contains a mapping from a key `k` to a value `v` such that `(key==null ? k==null : key.equals(k))` , then this method returns `v`; otherwise it returns `null`. (There can be at most one such mapping.) Specified by: `get` in interface `Map<String,Object>` Specified by: `get` in interface `Bindings` Parameters: `key` - key whose associated value is to be returned. Returns: the value to which this map maps the specified key, or `null` if the map contains no mapping for this key. Throws: `NullPointerException` - if key is null `ClassCastException` - if key is not String `IllegalArgumentException` - if key is empty String

### method:isEmpty() [NONE]
- #### isEmpty
      public boolean isEmpty()
Returns `true` if this map contains no key-value mappings. Specified by: `isEmpty` in interface `Map<String,Object>` Returns: `true` if this map contains no key-value mappings

### method:keySet() [NONE]
- #### keySet
      public Set<String> keySet()
Returns a `Set` view of the keys contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own `remove` operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Set.remove`, `removeAll`, `retainAll`, and `clear` operations. It does not support the `add` or `addAll` operations. Specified by: `keySet` in interface `Map<String,Object>` Returns: a set view of the keys contained in this map

### method:remove(java.lang.Object) [NONE]
- #### remove
      public Object remove(Object key)
Removes the mapping for this key from this map if it is present (optional operation). More formally, if this map contains a mapping from key `k` to value `v` such that `(key==null ? k==null : key.equals(k))` , that mapping is removed. (The map can contain at most one such mapping.) Returns the value to which the map previously associated the key, or `null` if the map contained no mapping for this key. (A `null` return can also indicate that the map previously associated `null` with the specified key if the implementation supports `null` values.) The map will not contain a mapping for the specified key once the call returns. Specified by: `remove` in interface `Map<String,Object>` Specified by: `remove` in interface `Bindings` Parameters: `key` - key whose mapping is to be removed from the map. Returns: previous value associated with specified key, or `null` if there was no mapping for key. Throws: `NullPointerException` - if key is null `ClassCastException` - if key is not String `IllegalArgumentException` - if key is empty String

### method:size() [NONE]
- #### size
      public int size()
Returns the number of key-value mappings in this map. If the map contains more than `Integer.MAX_VALUE` elements, returns `Integer.MAX_VALUE`. Specified by: `size` in interface `Map<String,Object>` Returns: the number of key-value mappings in this map

### method:values() [NONE]
- #### values
      public Collection<Object> values()
Returns a `Collection` view of the values contained in this map. The collection is backed by the map, so changes to the map are reflected in the collection, and vice-versa. If the map is modified while an iteration over the collection is in progress (except through the iterator's own `remove` operation), the results of the iteration are undefined. The collection supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Collection.remove`, `removeAll`, `retainAll` and `clear` operations. It does not support the `add` or `addAll` operations. Specified by: `values` in interface `Map<String,Object>` Returns: a collection view of the values contained in this map