|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectorg.simpleframework.util.parse.Parser
org.simpleframework.util.parse.MapParser<T>
public abstract class MapParser<T>
The 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.
Nested Class Summary |
---|
Nested classes/interfaces inherited from interface java.util.Map |
---|
java.util.Map.Entry<K,V> |
Field Summary | |
---|---|
protected java.util.Map<T,java.util.List<T>> |
all
Represents all values inserted to the map as a list of values. |
protected java.util.Map<T,T> |
map
Represents the last value inserted into this map instance. |
Fields inherited from class org.simpleframework.util.parse.Parser |
---|
buf, count, off |
Constructor Summary | |
---|---|
protected |
MapParser()
Constructor for the MapParser object. |
Method Summary | |
---|---|
void |
clear()
The clear method is used to wipe out all the
currently existing tokens from the collection. |
boolean |
containsKey(java.lang.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(java.lang.Object value)
This method is used to determine whether any pair that has been inserted into the internal map had the presented value. |
java.util.Set<java.util.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(java.lang.Object name)
The get method is used to acquire the value for
a named pair. |
java.util.List<T> |
getAll(java.lang.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. |
java.util.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(java.util.Map<? extends T,? extends T> data)
This method is used to insert a collection of tokens into the parsers map. |
T |
remove(java.lang.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. |
java.util.Collection<T> |
values()
This method is used to acquire the value for all tokens that have currently been collected by this parser. |
Methods inherited from class org.simpleframework.util.parse.Parser |
---|
digit, ensureCapacity, init, parse, parse, skip, space, toLower |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Methods inherited from interface java.util.Map |
---|
equals, hashCode |
Field Detail |
---|
protected java.util.Map<T,java.util.List<T>> all
protected java.util.Map<T,T> map
Constructor Detail |
---|
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.
Method Detail |
---|
public boolean containsKey(java.lang.Object name)
containsKey
in interface java.util.Map<T,T>
name
- this is the name of a pair within the map
public boolean containsValue(java.lang.Object value)
containsValue
in interface java.util.Map<T,T>
value
- this is the value that is to be searched for
public java.util.Set<java.util.Map.Entry<T,T>> entrySet()
entrySet
in interface java.util.Map<T,T>
public T get(java.lang.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.
get
in interface java.util.Map<T,T>
name
- this is a string used to search for the value
public java.util.List<T> getAll(java.lang.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 value
public 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.
isEmpty
in interface java.util.Map<T,T>
public java.util.Set<T> keySet()
keySet
in interface java.util.Map<T,T>
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.
put
in interface java.util.Map<T,T>
name
- this is the name token from a name=value pairvalue
- this is the value token from a name=value pair
public void putAll(java.util.Map<? extends T,? extends T> data)
putAll
in interface java.util.Map<T,T>
data
- this is the collection of tokens to be addedpublic T remove(java.lang.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.
remove
in interface java.util.Map<T,T>
name
- this is a string used to search for the value
public int size()
size
.
size
in interface java.util.Map<T,T>
public java.util.Collection<T> values()
values
in interface java.util.Map<T,T>
public void clear()
clear
method is used to wipe out all the
currently existing tokens from the collection. This is used
to recycle the parser so that it can be used to parse some
other source of tokens without any lingering state.
clear
in interface java.util.Map<T,T>
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |