public abstract class MapParser<T> extends Parser implements Map<T,T>
MapParser
object represents a parser for name
value pairs. Any parser extending this will typically be parsing
name=value tokens or the like, and inserting these pairs into
the internal map. This type of parser is useful as it exposes all
pairs extracted using the java.util.Map
interface
and as such can be used with the Java collections framework. The
internal map used by this is a Hashtable
, however
subclasses are free to assign a different type to the map used.Modifier and Type | Field and Description |
---|---|
protected Map<T,List<T>> |
all
Represents all values inserted to the map as a list of values.
|
protected Map<T,T> |
map
Represents the last value inserted into this map instance.
|
Modifier | Constructor and Description |
---|---|
protected |
MapParser()
Constructor for the
MapParser object. |
Modifier and Type | Method and Description |
---|---|
void |
clear()
The
clear method is used to wipe out all the
currently existing tokens from the collection. |
boolean |
containsKey(Object name)
This is used to determine whether a token representing the
name of a pair has been inserted into the internal map.
|
boolean |
containsValue(Object value)
This method is used to determine whether any pair that has
been inserted into the internal map had the presented value.
|
Set<Map.Entry<T,T>> |
entrySet()
This method is used to acquire the name and value pairs that
have currently been collected by this parser.
|
T |
get(Object name)
The
get method is used to acquire the value for
a named pair. |
List<T> |
getAll(Object key)
This method is used to acquire a
List for all of
the values that have been put in to the map. |
boolean |
isEmpty()
This method is used to determine whether the parser has any
tokens available.
|
Set<T> |
keySet()
This is used to acquire the names for all the tokens that
have currently been collected by this parser.
|
T |
put(T name,
T value)
The
put method is used to insert the name and
value provided into the collection of tokens. |
void |
putAll(Map<? extends T,? extends T> data)
This method is used to insert a collection of tokens into
the parsers map.
|
T |
remove(Object name)
The
remove method is used to remove the named
token pair from the collection of tokens. |
int |
size()
This obviously enough provides the number of tokens that
have been inserted into the internal map.
|
Collection<T> |
values()
This method is used to acquire the value for all tokens that
have currently been collected by this parser.
|
digit, ensureCapacity, init, parse, parse, skip, space, toLower
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
compute, computeIfAbsent, computeIfPresent, equals, forEach, getOrDefault, hashCode, merge, putIfAbsent, remove, replace, replace, replaceAll
protected MapParser()
MapParser
object. This is
used to create a new parser that makes use of a thread safe
map implementation. The HashMap
is used so
that the resulting parser can be accessed in a concurrent
environment with the fear of data corruption.public boolean containsKey(Object name)
containsKey
in interface Map<T,T>
name
- this is the name of a pair within the mappublic boolean containsValue(Object value)
containsValue
in interface Map<T,T>
value
- this is the value that is to be searched forpublic Set<Map.Entry<T,T>> entrySet()
public T get(Object name)
get
method is used to acquire the value for
a named pair. So if a pair of name=value has been parsed and
inserted into the collection of tokens this will return the
value given the name. The value returned will be a string.public List<T> getAll(Object key)
List
for all of
the values that have been put in to the map. The list allows
all values associated with the specified key. This enables a
parser to collect a number of associated tokens.key
- this is the key used to search for the valuepublic boolean isEmpty()
size
is zero then the
parser is empty and this returns true. The is acts as a
proxy the the isEmpty
of the internal map.public Set<T> keySet()
public T put(T name, T value)
put
method is used to insert the name and
value provided into the collection of tokens. Although it is
up to the parser to decide what values will be inserted it
is generally the case that the inserted tokens will be text.public void putAll(Map<? extends T,? extends T> data)
public T remove(Object name)
remove
method is used to remove the named
token pair from the collection of tokens. This acts like a
take, in that it will get the token value and remove if
from the collection of tokens the parser has stored.public int size()
size
.public Collection<T> values()
Copyright © 2023. All rights reserved.