PropMap ( Frame4J -- the Java framework de.frame4j... )

java.lang.Object
- java.util.AbstractMap<CharSequence,String>
- - de.frame4j.util.PropMap

All Implemented Interfaces:

Serializable, Cloneable, ConcurrentMap<CharSequence,String>, Map<CharSequence,String>

Direct Known Subclasses:

AppLangMap, Prop
```
@MinDoc(copyright="Copyright 2004 - 2008, 2009, 2016  A. Weinert",
        author="Albrecht Weinert",
        version="V.56",
        lastModified="28.06.2021",
        usage="3 phase: make, populate, use (preferably not further modified)",
        purpose="initial properties for applications and other objects")
public class PropMap
extends AbstractMap<CharSequence,String>
implements ConcurrentMap<CharSequence,String>, Cloneable, Serializable
```
A set of properties.

A PropMap object features a set of String-String key value pairs. So it is a Map. The class is quite similar to java.util.Properties respectively to java.util.Dictionary. Under circumstances, often given and defined below, PropMap is the better choice than any of the standard Maps.

The interface's Map freedoms are limited a bit (beyond <CharSequence, String>):
- Keys and values are character sequences (hence internally Strings).
- Keys are not empty and do not have surrounding white space.
  (Especially they never begin or end with a blank.)
As already contracted by Map, keys are unique. A PropMap object is by this condition a set (Set); see also entrySet() respectively keySet()).

According to the "non empty non white space surrounded" condition, many methods accept CharSequences as parameter for the key, which they strip from surrounding white spaces, should those be there. See TextHelper.trimUq(..). If the key is then still not empty, it is accepted and used as such.

Class and object relations

This class PropMap is the parent of AppLangMap and de.frame4j.util.Prop in the same package. The pedigree Prop -> PropMap -> AbstractMap separates Collection's aspects clearly from many extra services for applications, Servlets and else, especially for de.frame4j.util.App's inheritors.

Figure 1 shows those relations between the mentioned types, namely PropMap, its inner classes PropMapHelper.Entry, PropMap.EntrySet and PropMap.KeySet, as well as Prop and AppLangMap and the Java-Collection-Framework's classes and interfaces.

Figure 1: PropMap and the Collection-Framework — relations.
(Click the picture for full size and sharpness.)

de.frame4j.util.PropMap's and .Prop's application background

Primary intended usage of PropMap (and of its inheritor Prop) is the settings of modes and options as well as the handling and evaluation of start parameters for applications of all kinds as well as for other single objects (Beans).

One logical consequence was the limitation to <non empty String, String> <key, value> pairs, with the additional conditions of
- keys not being surrounded by whitespace and
- allowing empty and null as value.
All (nearly all) those settings of applications, Servlets and so on are given as character sequences (in text form) in the beginning, be it as command line parameters, contents of .properties, .ini or .xml files or as (parameter) attributes in a .html-tag.

As second consequence of the main intended usage is a wide support for "prefixed" and "indexed" properties, by optional special handling for exemplary keys like uhu9 uhu09 uhu[9] de.uhu de_DE.uhu en_GB.uhu[123].

Design aspects, optimisation goals and limits

The main intended usage for mode, controlling, options handling and evaluation of parameters (see Prop.parse(String[], CharSequence)) means for such use cases, that a "Map" of (application) properties
a) more often is of small or medium size of from about 30 "Entrys" up to about 200, more being exceptional
and that
b) a "two phase" pattern of usage (or life cycle) is the rule:
Phase 1: Constructing, building, adding of entries
and afterwards
Phase 2: utilisation with now fixed endowment of keys.
And usually phase 1 is done in exact one thread (initialising the application, Servlet end so on).

To put it short, the designated normal use case pattern is:
Make and modify) the PropMap in one thread completely, and then use (read, copy, clone) it unmodified in one or more other threads.

Applications sticking mostly to this frequent pattern of usage are served by this class and its inheritors quite well and with less consumption of resources than the standard alternatives. So PropMap and its extensions may be a good choice even when the extra features and services are not needed.

The generation of subsets is often needed in above mentioned phase 2 and is normally quite expensive. Here is a cost optimised realisation (by subSet(CharSequence)).

Hint 1: Allowing null as value, goes beyond what Properties is willing to forbear. Here it is used to distinguish an empty from a not yet set value. If that difference is not needed or disturbing it can be masked away by using
getString(key, "") bzw. getString(key, ComVar.EMPTY_STRING),
which will substitute the empty String for null.

Hint 2: The methods equals(Object) and hashCode() of standard containers (including the parent class AbstractMap) are (have to be) quite expensive. They are optimised here finally.

© Copyright 2004 - 2006, 2008, 2009 Albrecht Weinert.
Version:

56 (28.06.2021

Author:

Albrecht Weinert

See Also:

de.frame4j, App, de.frame4j.util, TextHelper, Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

class PropMap.EntrySet
The entries as Set.

class PropMap.KeySet<S>
The keys as Set.
- 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>

Nested Classes
Modifier and Type	Class and Description
`class`	`PropMap.EntrySet` The entries as Set.
`class`	`PropMap.KeySet<S>` The keys as Set.

Field Summary

Fields
Modifier and Type	Field and Description
`protected PropMapHelper.Entry[]`	`entries` The entries.
`static int`	`FILE_LIST_LEN` Maximum length of loaded .properties files or resources list.
`protected int`	`hashMissMax` Maximum of "hash miss side steps".
`protected int`	`hashMissSum` Summed up "hash miss side steps".
`protected AbstractSet<Map.Entry<CharSequence,String>>`	`internalEntrySet` Entry set view (singleton).
`protected PropMap.KeySet<CharSequence>`	`internalKeySet` KeySet view (singleton).
`static String`	`keyStringMld` Message on key to be non empty a character sequence, for exceptions.
`protected String`	`language` The (preferred) language of this PropMap.
`protected String`	`region` The (preferred) region of this PropMap.
`protected int`	`reHashes` Summed up re-hashes (since new or empty).
`protected ReentrantReadWriteLock.ReadLock`	`rLock` The lock for reads.
`static String`	`valStringMld` Message on value to be a character sequence, for exceptions.
`static int`	`VL_CL` Cache size for valueLang() look up.
`protected ReentrantReadWriteLock.WriteLock`	`wLock` The lock for writes.

Constructor Summary

Constructors
Constructor and Description

PropMap()
Make an empty set of properties.

PropMap(int startCap)
Make an empty set of properties, choosing the starting capacity.

Constructors
Constructor and Description
`PropMap()` Make an empty set of properties.
`PropMap(int startCap)` Make an empty set of properties, choosing the starting capacity.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`add(CharSequence key, CharSequence value)` Adding a new property.
`Properties`	`asProperties(CharSequence filter)` The content as Properties.
`void`	`clear()` Clear / forget all.
`void`	`clear(int startCap)` Clear / forget all and choose starting capacity.
`Object`	`clone()` A copy of this PropMap.
`boolean`	`containsKey(Object key)` Is there a certain key.
`boolean`	`containsValue(Object value)` Is there a value.
`void`	`deepIt()` "Deepening" a preceding clone().
`PropMapHelper.Entry`	`entry(CharSequence key)` Get the entry for a key.
`Set<Map.Entry<CharSequence,String>>`	`entrySet()` The entries as Set.
`boolean`	`equals(Object o)` Equality with other object.
`String`	`get(Object key)` Get the value for a key.
`boolean`	`getBoolean(CharSequence name)` Get a property as boolean.
`boolean`	`getBoolean(CharSequence name, boolean defV)` Get a property as boolean with default.
`boolean`	`getBoolean(CharSequence name, int num, boolean defV)` Get a "numbered / indexed" property as boolean with default.
`int`	`getInt(CharSequence name, int defV)` Get a property as int.
`int`	`getInt(String name, int num, int defV)` Get a "numbered / indexed" property as int with default.
`String`	`getLanguage()` The (preferred) language of this PropMap.
`long`	`getLong(CharSequence name, long defV)` Get a property as long.
`String`	`getProperty(CharSequence key, int num, String defV)` Get a "numbered / indexed" property as String.
`String`	`getProperty(CharSequence key, String defaultValue)` Get a value for a key with default.
`String`	`getProperty(CharSequence key, String pref1, String pref2, String defV)` Get a property wit a (may be) prefixed key.
`String`	`getProperty(String name)` Get a property as String.
`String`	`getRegion()` The (preferred) region of this PropMap.
`String`	`getString(CharSequence name)` Get a property as non empty String.
`String`	`getString(CharSequence key, String defV)` Get a property if non empty String.
`int`	`hashCode()` The whole maps hash code.
`StringBuilder`	`hashQuality(StringBuilder bastel)` The hash quality as two line String.
`int`	`indexOfKey(CharSequence key)` Find the index for a key.
`boolean`	`isEmpty()` Is it empty.
`Set<CharSequence>`	`keySet()` The keys as Set.
`void`	`load(InputStream input, CharSequence encoding)` Load key value pairs from an input stream.
`boolean`	`load1(CharSequence fileName, CharSequence encoding)` Load properties from (just) one text file.
`boolean`	`load1(Class<?> cl, CharSequence fileName, CharSequence encoding)` Load properties from a text file, class related.
`String`	`put(CharSequence key, String value)` Enter a key value pair.
`PropMapHelper.Entry`	`put(PropMapHelper.Entry newEntry)` Enter a key value pair as Entry.
`void`	`putAll(Map<? extends CharSequence,? extends String> map)` Take all entries from another `Map`.
`String`	`putIfAbsent(CharSequence key, String value)` Putting a new property.
`protected String`	`putImpl(String key, CharSequence value)` Enter a key/value pair.
`protected void`	`putNewImpl(String key, String value)` Enter a key/value pair, guaranteed to be new.
`protected void`	`putNewImut(String key, String value)` Enter a new immutable key/value pair.
`void`	`rehash()` Re-hash.
`protected void`	`rehash(PropMapHelper.Entry newEnt, int ensCap)` Re-hash.
`protected boolean`	`remove(int i)` Remove an Entry by (internal) index.
`String`	`remove(Object key)` Remove an entry.
`boolean`	`remove(Object key, Object value)` Remove an entry.
`String`	`replace(CharSequence key, String value)` Replace an entry's value.
`boolean`	`replace(CharSequence key, String oldValue, String newValue)` Replace an entry's value.
`void`	`setLanguage(CharSequence language)` Set the (preferred) language of this PropMap.
`boolean`	`setNewProperty(CharSequence keyValue)` Set a new property.
`boolean`	`setNewProperty(CharSequence key, String value)` Set a new property.
`boolean`	`setProperty(CharSequence keyValue)` Set a property.
`boolean`	`setProperty(CharSequence keyValue, boolean onlyNew)` Set property or make a new one.
`Object`	`setProperty(CharSequence key, CharSequence value)` Enter a key/value pair.
`void`	`setRegion(CharSequence region)` Set the (preferred) region of this PropMap.
`int`	`size()` Number of entries.
`String[]`	`sortedKeys()` Fetch a sorted array of all keys.
`StringBuilder`	`sortedList(StringBuilder bastel)` Sorted multi line entries list.
`void`	`store(OutputStream output, CharSequence startComment, CharSequence encoding)` Storing all key value pairs to an output stream.
`PropMap`	`subSet(CharSequence prefix)` Make a subset of this key/value pairs by key prefix.
`protected PropMapHelper.Entry`	`substLang(String key, String lang, String regio, String def)` Get a substitute entry for a key — nationalised.
`String`	`toString()` State as multi line String.
`String`	`value(CharSequence key)` Get the value for a key.
`String`	`valueLang(CharSequence key, String defV)` Get value for a key — nationalised.

Methods inherited from class java.util.AbstractMap
values

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

Methods inherited from interface java.util.concurrent.ConcurrentMap
compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, replaceAll

Methods inherited from interface java.util.Map
values

- Field Detail
  - rLock
```
protected final ReentrantReadWriteLock.ReadLock rLock
```
    The lock for reads.
    
    This is only to guard multi thread reads against critical writes guarded by wLock.
    lock() and unlock() must be used as guaranteed pair.
  - wLock
```
protected final ReentrantReadWriteLock.WriteLock wLock
```
    The lock for writes.
    
    This is to guard those writes / modifications that must not interfere with multi thread critical reads (to be guarded by rLock).
    lock() and unlock() must be used as guaranteed pair.
  - entries
```
protected volatile PropMapHelper.Entry[] entries
```
    The entries.
  - hashMissMax
```
protected volatile int hashMissMax
```
    Maximum of "hash miss side steps".
    
    This number is the maximum of additional search steps for an entry. If non existing entry is looked for exactly hashMissMax + 1 search steps are necessary for this discovery.
    
    In a empty or weakly populated PropMap this value will normally be 0. Experiments show (see hashQuality(StringBuilder)) that values > 5 are quite improbable.
    
    Implementation hint: As this Map is not intended for use cases with a highly dynamic content, the value will not be decremented should this be possible after a remove(). So after a lot of removes an explicit rehash(null, 0) might be appropriate.
    
    See Also:
    
    hashQuality(StringBuilder), hashMissSum
  - hashMissSum
```
protected int hashMissSum
```
    Summed up "hash miss side steps".
    
    hashMissSum / size is a measurement number for the actual quality of the internal hashing. It's the average of search steps to find an existing entry.
    
    Hint: This variable is pure measurement; its value has no influence on the working of any method.
    
    See Also:
    
    hashMissMax, hashQuality(StringBuilder), reHashes
  - reHashes
```
protected int reHashes
```
    Summed up re-hashes (since new or empty).
    
    This counts the occurrence of necessary or explicit rehash()s. This is pure measurement.
    
    See Also:
    
    hashQuality(StringBuilder), hashMissMax
  - VL_CL
```
public static final int VL_CL
```
    Cache size for valueLang() look up.
    
    Value: 11
    
    See Also:
    
    valueLang(CharSequence, String), Prop.valueLang(CharSequence), valueLang(CharSequence, String), Constant Field Values
  - language
```
protected String language
```
    The (preferred) language of this PropMap.
    
    See Also:
    
    getLanguage()
  - region
```
protected String region
```
    The (preferred) region of this PropMap.
    
    See Also:
    
    getRegion()
  - FILE_LIST_LEN
```
public static final int FILE_LIST_LEN
```
    Maximum length of loaded .properties files or resources list.
    
    Value: 25
    
    See Also:
    
    Constant Field Values
  - internalKeySet
```
protected transient volatile PropMap.KeySet<CharSequence> internalKeySet
```
    KeySet view (singleton).
    
    Implementation hint: set on construction and clone; would be final if not for clone().
  - internalEntrySet
```
protected transient volatile AbstractSet<Map.Entry<CharSequence,String>> internalEntrySet
```
    Entry set view (singleton).
  - valStringMld
```
public static final String valStringMld
```
    Message on value to be a character sequence, for exceptions.
    
    Value: "de.frame4j.util.ProMap.Entry values must be CharSequences (or null)."
    
    See Also:
    
    Constant Field Values
  - keyStringMld
```
public static final String keyStringMld
```
    Message on key to be non empty a character sequence, for exceptions.
    
    Value: "de.frame4j.util.ProMap.Entry keys must be non empty (trimmed) Strings."
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - PropMap
```
public PropMap()
```
    Make an empty set of properties.
    
    Is like PropMap(71).
  - PropMap
```
public PropMap(int startCap)
```
    Make an empty set of properties, choosing the starting capacity.
- Method Detail
  - size
```
public final int size()
```
    Number of entries.
    
    Specified by:
    
    size in interface Map<CharSequence,String>
    
    Overrides:
    
    size in class AbstractMap<CharSequence,String>
  - equals
```
public final boolean equals(Object o)
```
    Equality with other object.
    
    This method returns true, if the other object o is of type PropMap, has the same size and for all o's entries one own can be found that is equal.
    
    Hint: This comparison uses no synchronisation. If one of the PropMaps change in the proceeding this method's result might reflect the new or the previous state.
    
    Specified by:
    
    equals in interface Map<CharSequence,String>
    
    Overrides:
    
    equals in class AbstractMap<CharSequence,String>
  - hashCode
```
public final int hashCode()
```
    The whole maps hash code.
    
    Specified by:
    
    hashCode in interface Map<CharSequence,String>
    
    Overrides:
    
    hashCode in class AbstractMap<CharSequence,String>
  - clone
```
public Object clone()
```
    A copy of this PropMap.
    
    A shallow copy of this PropMap is made and returned. Original and copy share the PropMapHelper.Entrys existing or contained at the time of the call. Changing the value of a (mutable) entry effects both; adding and removing effects only one. The first call to deepIt() clones all shared mutable PropMapHelper.Entrys, hence making the copy independent.
    
    The operation is (internally) synchronised and (compared to Hashtable) low-cost.
    
    Overrides:
    
    clone in class AbstractMap<CharSequence,String>
    
    See Also:
    
    deepIt()
  - deepIt
```
public final void deepIt()
```
    "Deepening" a preceding clone().
    
    This method, when called the first time for a cloned PropMap replaces every mutable PropMapHelper.Entry by its copy (using entry.clone()). This makes the shallow clone() deep.
    If called a second time, this method does nothing.
    
    See Also:
    
    clone()
  - isEmpty
```
public final boolean isEmpty()
```
    Is it empty.
    
    Specified by:
    
    isEmpty in interface Map<CharSequence,String>
    
    Overrides:
    
    isEmpty in class AbstractMap<CharSequence,String>
    
    See Also:
    
    Map.isEmpty()
  - clear
```
public final void clear()
```
    Clear / forget all.
    
    Makes this an empty PropMap (with a starting capacity of 71 entries).
    
    Specified by:
    
    clear in interface Map<CharSequence,String>
    
    Overrides:
    
    clear in class AbstractMap<CharSequence,String>
    
    See Also:
    
    clear(int)
  - clear
```
public void clear(int startCap)
```
    Clear / forget all and choose starting capacity.
    
    Makes this an empty PropMap with a specified minimal (stating) capacity.
    
    Implementation hint: inheriting classes wanting to prohibit such total clearing have to override only this method, where all direct or indirect total clearances go through.
  - remove
```
protected boolean remove(int i)
```
    Remove an Entry by (internal) index.
    
    Internal helper method.
    
    Implementation hint: This implementation removes the indexed entry from this PropMap. All other removal methods use this method. It's the one to be modified / overridden if inheritors want to avert the removal of certain entries.
    
    Returns:
    
    true if an existing entry was removed.
  - indexOfKey
```
public final int indexOfKey(CharSequence key)
```
    Find the index for a key.
    
    Internal helper with little use outside this class or its inheritors.
    Hint: This method uses no synchronisation at all. If used outside (other method's) sync. blocks it may lie in case of concurrent modifications.
    
    Returns:
    
    -1, if no such key.
  - containsKey
```
public final boolean containsKey(Object key)
```
    Is there a certain key.
    
    Keys have to be non empty character sequences, even after "trimming".
    
    Specified by:
    
    containsKey in interface Map<CharSequence,String>
    
    Overrides:
    
    containsKey in class AbstractMap<CharSequence,String>
    
    See Also:
    
    Map.containsKey(java.lang.Object)
  - get
```
public String get(Object key)
```
    Get the value for a key.
    
    If an entry fitting the key (that has to be a legal character sequence) exist its value is returned; otherwise null.
    
    Hint: null may also be the value of an entry found. If this ambiguity is not acceptable, use containsKey(Object).
    
    Specified by:
    
    get in interface Map<CharSequence,String>
    
    Overrides:
    
    get in class AbstractMap<CharSequence,String>
    
    Returns:
    
    String oder null
    
    See Also:
    
    Map.get(java.lang.Object), containsKey(Object)
  - value
```
public final String value(CharSequence key)
```
    Get the value for a key.
    
    This method is just like get(Object), but with a method signature better fitting this class' contract.
    
    See Also:
    
    Map.get(java.lang.Object)
  - getProperty
```
public final String getProperty(String name)
```
    Get a property as String.
    
    This methods delegates to value(CharSequence). Its only purpose is the compatibility to the late Properties (facilitating the change of pedigree in some cases).
  - getString
```
public final String getString(CharSequence name)
```
    Get a property as non empty String.
    
    This method returns a non empty String only if this PropMap contains a property / entry with key name, the value of it being a non empty String even after stripping surrounding white spaces (from the value).
    
    This (may be stripped) value is returned, or null otherwise.
    
    The call is equivalent to getString(name, null).
    
    Parameters:
    
    name - the key of the searched for property / entry
    
    Returns:
    
    a non empty String or null
    
    See Also:
    
    getString(CharSequence, String), getInt(CharSequence, int), getBoolean(CharSequence)
  - getString
```
public String getString(CharSequence key,
                        String defV)
```
    Get a property if non empty String.
    
    If this PropMap does not contain a property fitting key (the parameter will be stripped from surrounding white space before) the substitute defV will be returned.
    
    If the property exists, its value will (also) be stripped from surrounding white space. If (still) not null nor empty it is returned. Otherwise the substitute defV will be returned.
    
    In other words: Instead of the value got by key from this PropMap TextHelper.trimUq(value, defV) is returned.
    
    Parameters:
    
    key - the name of the searched for property / entry
    
    defV - the substitute for unavailable null or (stripped) empty value
    
    Returns:
    
    the (stripped) value or defV
    
    See Also:
    
    getString(CharSequence), getInt(CharSequence, int), getBoolean(CharSequence), TextHelper.trimUq(CharSequence, String)
  - entry
```
public PropMapHelper.Entry entry(CharSequence key)
```
    Get the entry for a key.
    
    key must be a non empty character sequence, even after stripping surrounding white space.
    
    Implementation hint: get(Object), value(CharSequence) and all other entry / value getters *) delegate to this method. Hence it's the only one to be overridden in inheriting classes, if the determination of the value is less straightforward (e.g. by having to consult substitute Maps or the like).
    
    Hint *): containsValue(Object), containsKey(Object) and PropMap.EntrySet.contains(Object) are exceptions; the work alone.
    
    See Also:
    
    Map.get(java.lang.Object), get(Object)
  - containsValue
```
public boolean containsValue(Object value)
```
    Is there a value.
    
    Values are character sequences; null is allowed.
    
    Specified by:
    
    containsValue in interface Map<CharSequence,String>
    
    Overrides:
    
    containsValue in class AbstractMap<CharSequence,String>
    
    See Also:
    
    Map.containsValue(java.lang.Object)
  - getBoolean
```
public final boolean getBoolean(CharSequence name)
```
    Get a property as boolean.
    
    Returns true, if and only if a property / entry by key name exists in this PropMap, having a value of "true", "wahr", "ja", "yes", "an" or "on".
    The comparison is not case sensitive.
    
    To be exact: The value has to be interpreted by the (rules of the) method TextHelper.asBoolean(CharSequence) as true.
    
    Parameters:
    
    name - the key of the searched for property / entry
    
    Returns:
    
    the boolean interpretation of its value
    
    See Also:
    
    getInt(), getBoolean(CharSequence, boolean)
  - getBoolean
```
public final boolean getBoolean(CharSequence name,
                                boolean defV)
```
    Get a property as boolean with default.
    
    If there's no property named name here defV is returned.
    
    Otherwise it is tried to interpret the value by asBoolean(value, defV) as a logical value. If that is feasible by that method's rules that value is returned and defV otherwise.
    
    Parameters:
    
    name - the properties name
    
    defV - default / substitute value
    
    Returns:
    
    the property's boolean value if so interpretable, or defV
    
    See Also:
  - getInt
```
public final int getInt(CharSequence name,
                        int defV)
```
    Get a property as int.
    
    If there's no property named name here defV is returned.
    
    Otherwise it is tried to interpret the value by asInt(value, defV) as a whole number. If that is feasible by that method's rules that value is returned and defV otherwise.
    
    Parameters:
    
    name - the properties name
    
    defV - default / substitute value
    
    Returns:
    
    the property's integer value if so interpretable, or defV
    
    See Also:
    
    getBoolean(CharSequence), getLong(CharSequence, long), TextHelper.asInt(CharSequence, int)
  - getLong
```
public long getLong(CharSequence name,
                    long defV)
```
    Get a property as long.
    
    If there's no property named name here defV is returned.
    
    Otherwise it is tried to interpret the value as a (long) whole number. If that is feasible the that long value is returned and defV otherwise.
    
    Parameters:
    
    name - the properties name
    
    defV - default / substitute value
    
    Returns:
    
    the property's long value if so interpretable, or defV
    
    See Also:
    
    getBoolean(CharSequence), getInt(CharSequence, int)
  - remove
```
public String remove(Object key)
```
    Remove an entry.
    
    If there's no property / entry named key here null will be returned.
    Otherwise the entry will be removed and its value returned.
    
    In the case of the enty's removal is denied (could be done by an overridden method remove(int) only) null is returned also.
    
    Specified by:
    
    remove in interface Map<CharSequence,String>
    
    Overrides:
    
    remove in class AbstractMap<CharSequence,String>
    
    Parameters:
    
    key - the key to the entry to be removed
    
    Returns:
    
    the removed entry's value or null
  - put
```
public String put(CharSequence key,
                  String value)
           throws UnsupportedOperationException
```
    Enter a key value pair.
    
    The key supplied has to be a non empty character sequence even after being stripped from surrounding white space by TextHelperTextHelper.trimUq(CharSequence, String). Otherwise an IllegalArgumentException is thrown.
    
    If there's already an PropMapHelper.Entry for key, its value will be changed, otherwise a new pair (key, value) will be made and entered to this Map.
    
    Specified by:
    
    put in interface Map<CharSequence,String>
    
    Overrides:
    
    put in class AbstractMap<CharSequence,String>
    
    Parameters:
    
    key - the new entry's key
    
    value - the new value; may be null
    
    Returns:
    
    if there was an entry for key before its value or null otherwise
    
    Throws:
    
    UnsupportedOperationException - if the call hits an existing entry with another value marked as immutable
    
    IllegalArgumentException - if the key supplied violates PropMap's rules
    
    See Also:
    
    put(de.frame4j.util.PropMapHelper.Entry)
  - putImpl
```
protected final String putImpl(String key,
                               CharSequence value)
                        throws UnsupportedOperationException
```
    Enter a key/value pair.
    
    This method is like put(CharSequence, String) but without checks; it's a internal helper for correct parameters.
    
    Parameters:
    
    key - the new entry's key
    
    value - the new value; may be null
    
    Returns:
    
    if there was an entry for key before its value or null otherwise
    
    Throws:
    
    UnsupportedOperationException - if the call hits an existing entry with another value marked as immutable
    
    See Also:
    
    put(de.frame4j.util.PropMapHelper.Entry), put(CharSequence, String)
  - putNewImpl
```
protected final void putNewImpl(String key,
                                String value)
                         throws UnsupportedOperationException
```
    Enter a key/value pair, guaranteed to be new.
    
    Like put(CharSequence, String) but without any checks and for a really new entry only.
    
    Internal helper.
    
    Parameters:
    
    key - the new entry's key
    
    value - the new value; may be null
    
    Throws:
    
    UnsupportedOperationException - if the call hits an existing entry with another value marked as immutable
    
    See Also:
    
    put(de.frame4j.util.PropMapHelper.Entry)
  - putNewImut
```
protected final void putNewImut(String key,
                                String value)
                         throws UnsupportedOperationException
```
    Enter a new immutable key/value pair.
    
    Like put(CharSequence, String) but without any checks; internal helper.
    
    Parameters:
    
    key - the new entry's key
    
    value - the new value; may be null
    
    Throws:
    
    UnsupportedOperationException - if the call hits an existing entry with another value marked as immutable
    
    See Also:
    
    put(de.frame4j.util.PropMapHelper.Entry), put(CharSequence, String)
  - setProperty
```
public final Object setProperty(CharSequence key,
                                CharSequence value)
```
    Enter a key/value pair.
    
    This method just delegates to put(CharSequence, String), better called directly if value's type is String.
    
    See Also:
    
    put(CharSequence, String), put(de.frame4j.util.PropMapHelper.Entry)
  - getProperty
```
public final String getProperty(CharSequence key,
                                String defaultValue)
```
    Get a value for a key with default.
    
    Keys must be non empty character sequences even after stripping surrounding white space.
    
    If there's no entry for key defaultValue is returned.
    
    Otherwise the entry's value is returned even if it is null. (Thas is the difference to getString(CharSequence, String).
    
    See Also:
    
    Map.get(java.lang.Object), get(Object), value(CharSequence)
  - getProperty
```
public String getProperty(CharSequence key,
                          int num,
                          String defV)
```
    Get a "numbered / indexed" property as String.
    
    If key is null or empty or if num is < 0, null is returned.
    Otherwise the following applies:
    
    If there's a property key + num (in any of the forms mentioned below) its value is returned even if empty.
    
    If num in the range 0 to 9 and if key + num above fails the same is tried with one leading zero ("name7" e.g. and also "name07").
    
    If that fails index brackets ([]) around the number are tried also (would be "name[7]" in above example).
    
    If that fails and if num == 0 the "pure" property key is searched for.
    
    If all fails defV is returned.
    
    Parameters:
    
    key - the property's (pure) name
    
    num - the property's index / number (>=0)
    
    defV - the default / substitute value for nothing or only null values found
  - getProperty
```
public String getProperty(CharSequence key,
                          String pref1,
                          String pref2,
                          String defV)
```
    Get a property wit a (may be) prefixed key.
    
    If key is null or empty null is returned.
    Otherwise the following applies:
    
    If pref1 is not null and there is a property named pref1.key its value is returned (also if it is empty).
    
    Otherwise the same is repeated withpref2.
    
    If that failed the "pure" non prefixed property key is searched for.
    
    If none is found defV is returned.
    
    Parameters:
    
    key - the property's (pure) name
    
    pref1 - the first prefix to try
    
    pref2 - the second prefix to try
    
    defV - the default / substitute value for nothing or only null values found
  - getBoolean
```
public boolean getBoolean(CharSequence name,
                          int num,
                          boolean defV)
```
    Get a "numbered / indexed" property as boolean with default.
    
    This method gets a property value by getProperty(name, num, null). If that returns null, defV is returned.
    
    Otherwise the returned value is interpreted by asBoolean(value, defV) as logical value that will be returned.
    
    Parameters:
    
    name - the property's (pure) name
    
    num - the property's index / number (>=0)
    
    defV - the default / substitute value for nothing or only null values found
    
    See Also:
  - getInt
```
public int getInt(String name,
                  int num,
                  int defV)
```
    Get a "numbered / indexed" property as int with default.
    
    This method gets a property value by getProperty(name, num, null). If that returns null, defV is returned.
    
    Otherwise the returned value is interpreted by asInt(value, defV) as numerical value that will be returned.
    
    Parameters:
    
    name - the property's (pure) name
    
    num - the property's index / number (>=0)
    
    defV - the default / substitute value for nothing or only null values found
    
    See Also:
    
    getBoolean(), getLong(), TextHelper.asInt(CharSequence, int)
  - valueLang
```
public final String valueLang(CharSequence key,
                              String defV)
```
    Get value for a key — nationalised.
    
    For a null or empty key (after removal of surrounding white space) the substitute value defV is returned.
    
    Otherwise language (getLanguage()) and region (getRegion()) codes are used in combination with key to search for properties in the following order:
    1. language_region.key
    2. language.key
    3. key
    4. en.key
    5. en_GB.key
    6. de.key
    The steps 3..6 are done by substLang(key, lang, regio, defV), so this behaviour or strategy could be changed in classes extending PropMap.
    If all endeavour fails defV is returned.
    The returned value is cached for the (non empty key); so subsequent requests for the same (VL_CL) keys are returned very fast.
  - substLang
```
protected PropMapHelper.Entry substLang(String key,
                                        String lang,
                                        String regio,
                                        String def)
```
    Get a substitute entry for a key — nationalised.
    
    For the (already worked on) case of not having found an entry for
    1. language_region.key
    2. language.key
    this method tries to find a substitute entry in the following order:
    1. key
    2. en.key (only if lang is not en)
    3. en_GB.key (only if lang is not en and if regio is not GB)
    4. de.key (only if lang is not de
    If none is found, null is returned.
    This method is used in the (final) method valueLang(CharSequence, String) and may be overridden in extending classes to implement further endeavours or other strategies to get nationalised property values.
    Parameters:
    
    key - non empty
    
    lang - two letter lower case language code
    
    regio - two letter upper case region or country code or ComVar.EMPTY_STRING if no region to be used
    
    def - the default value; ignored in this implementation (the parameter being only there for potential use in inheritors)
  - getLanguage
```
public final String getLanguage()
```
    The (preferred) language of this PropMap.
    
    If a language was set, it will be returned.
    Otherwise the default (or runtime) language will be set before.
    
    Returns:
    
    a two letter (lower case) language code, never null
    
    See Also:
    
    setLanguage(CharSequence)
  - setLanguage
```
public void setLanguage(CharSequence language)
```
    Set the (preferred) language of this PropMap.
    
    If the parameter language is null the (preferred) language will remain unchanged, if it was already set. Otherwise the values will be chosen from a property "language", if present, or by the (default) rules of TextHelper.checkLanguage(CharSequence, CharSequence).
    
    The parameter will be checked / corrected according to the rules of TextHelper.checkLanguage() with an already set language as default.
    The (preferred) language of this PropMap will the be set accordingly.
    
    Should this PropMap contain a property key="language", its value will a) be used as default for parameter null and b) be set accordingly.
    
    Five letter parameters on the form "en_GB" are accepted, too. in this case the last two characters are passed to setRegion(CharSequence) and the first two taken as effective argument to this method.
    
    Parameters:
    
    language - new preferred language
    
    See Also:
    
    getLanguage()
  - getRegion
```
public final String getRegion()
```
    The (preferred) region of this PropMap.
    
    If a region was set, it will be returned.
    Otherwise the default (or runtime) language will be set before.
    
    Returns:
    
    a two letter (lower case) region code, never null
    
    See Also:
    
    setRegion(CharSequence)
  - setRegion
```
public void setRegion(CharSequence region)
```
    Set the (preferred) region of this PropMap.
    
    If the parameter region is null the (preferred) region will remain unchanged, if it was already set. Otherwise the values will be chosen from a property "region", if present, or by the (default) rules of TextHelper.checkRegion(CharSequence, CharSequence).
    
    The parameter will be checked / corrected according to the rules of TextHelper.checkRegion() with an already set region as default.
    The (preferred) region of this PropMap will the be set accordingly.
    
    Should this PropMap contain a property key="region", its value will a) be used as a default for parameter null and b) be set accordingly.
    
    Parameters:
    
    region - new preferred region, null will be replaced
    
    See Also:
    
    getRegion()
  - rehash
```
protected void rehash(PropMapHelper.Entry newEnt,
                      int ensCap)
```
    Re-hash.
    
    This method enlarges the capacity and enters newEnt at the "hash right" spot.
    
    Parameters:
    
    newEnt - null or until now not yet entered.
    Violating this rule produces any chaos.
    
    ensCap - ordered minimal new capacity, if larger than before
  - rehash
```
public void rehash()
```
    Re-hash.
    
    This method enlarges the capacity and re-organises the internal hashing. The call is equivalent to
    rehash(null, 0).
  - put
```
public PropMapHelper.Entry put(PropMapHelper.Entry newEntry)
                        throws UnsupportedOperationException
```
    Enter a key value pair as Entry.
    
    If an entry with the same key as newEntry is not yet in this map newEntry will be put in and null will be returned. Null will also be returned if newEntry is null.
    
    If an entry with the same key exists already it is replaced only if it is either not immutable or the values are the same.
    
    Trying to change / replace an immutable entry will be punished by an UnsupportedOperationException.
    
    Implementation hint: All other entry methods of this class rely on / delegate to this one if changes to the set are due. Extending classes must only override this method (and keep the implementation by super(..)) if extra work on changes has to be done.
    
    Parameters:
    
    newEntry - an Entry object (according to the contract) or null
    
    Returns:
    
    the former entry if one was replaced or null
    
    Throws:
    
    UnsupportedOperationException - if an immutable entry would have to be replaced / modified
    
    See Also:
    
    put(CharSequence, String)
  - add
```
public boolean add(CharSequence key,
                   CharSequence value)
```
    Adding a new property.
    
    The parameter key is stripped from surrounding white space. If (then) empty nothing happens and and false is returned.
    
    If an entry fitting key is already in this Map it is not touched and false is returned. Otherwise a new entry key/value is made and entered. true is returned in that case.
    
    Non regarding the return and parameter types this method is exactly like putIfAbsent(CharSequence, String).
    
    See Also:
    
    put(CharSequence, String), putIfAbsent(CharSequence, String)
  - putIfAbsent
```
public String putIfAbsent(CharSequence key,
                          String value)
```
    Putting a new property.
    
    This method makes a new entry, i.e. a key value pair according to the parameters (after trimming key from surrounding white space) if no entry fitting the key is yet there.
    
    If key is empty or there is already an entry fitting key nothing happens and null or the existing value is returned.
    
    Otherwise a new mutable entry (trimmed) key / value is added to this PropMap and null is returned.
    
    Specified by:
    
    putIfAbsent in interface ConcurrentMap<CharSequence,String>
    
    Specified by:
    
    putIfAbsent in interface Map<CharSequence,String>
    
    Returns:
    
    the value associated with the specified key if the entry is already contained, or null if a new entry was made. (null can also be returned, if an already existing entry does have that value.)
    
    See Also:
    
    put(CharSequence, String), add(CharSequence, CharSequence)
  - remove
```
public boolean remove(Object key,
                      Object value)
```
    Remove an entry.
    
    The entry for key is removed if
    - is exists in this map and
    - has value as value.
    This method removes immutable entries (in the the sense that immutable does not mean non removable.)
    Specified by:
    
    remove in interface ConcurrentMap<CharSequence,String>
    
    Specified by:
    
    remove in interface Map<CharSequence,String>
    
    Returns:
    
    true if the an entry for key was found in and removed from this map
  - replace
```
public String replace(CharSequence key,
                      String value)
```
    Replace an entry's value.
    
    This method replaces the value of an entry for key only if that entry is already in this map and it is not immutable.
    
    Specified by:
    
    replace in interface ConcurrentMap<CharSequence,String>
    
    Specified by:
    
    replace in interface Map<CharSequence,String>
  - replace
```
public boolean replace(CharSequence key,
                       String oldValue,
                       String newValue)
```
    Replace an entry's value.
    
    This method replaces the value of an entry for key only if that entry is already in this map and it is not immutable and if its former value id oldValue.
    
    Specified by:
    
    replace in interface ConcurrentMap<CharSequence,String>
    
    Specified by:
    
    replace in interface Map<CharSequence,String>
  - setProperty
```
public boolean setProperty(CharSequence keyValue)
```
    Set a property.
    
    The call is equivalent to setProperty(keyValue, false).
    
    See Also:
    
    getBooelan(), getInt(), setNewProperty(CharSequence)
  - setNewProperty
```
public boolean setNewProperty(CharSequence keyValue)
```
    Set a new property.
    
    The call is equivalent to setProperty(keyValue, true).
    
    See Also:
    
    setProperty(CharSequence), setNewProperty(CharSequence, String), setProperty(CharSequence, boolean)
  - setProperty
```
public final boolean setProperty(CharSequence keyValue,
                                 boolean onlyNew)
```
    Set property or make a new one.
    
    The character sequence keyValue will be stripped from surrounding white space and then separated at the first occurrence of
    - Equal sign (=),
    - Colon (:) oder
    - Space ( ) or a control character (<\\u0020),
    where : or = may be surrounded by spaces. This separation gives a key / value pair. " uhu = otto 3 ", for example, means key "uhu" and value "otto 3".
    
    A missing or empty key will have no effect at all and return false.
    
    A missing value will be (String)null (not the empty String).
    
    If onlyNew is true and an entry fitting key already exists nothing happens and false is returned.
    
    Otherwise an entry fitting key will be made or modified. True is returned if the entry is new or had the value null until now.
    See Also:
    
    setProperty(CharSequence), setNewProperty(CharSequence, String)
  - setNewProperty
```
public boolean setNewProperty(CharSequence key,
                              String value)
```
    Set a new property.
    
    This method makes a new entry, i.e. a key value pair according to the parameters (after trimming key from surrounding white space).
    
    If key is empty or there is already an entry fitting key nothing happens and false is returned.
    
    Otherwise a new mutable entry (trimmed) key / value is added to this PropMap and true is returned.
    
    See Also:
    
    setProperty(), setNewProperty(CharSequence)
  - putAll
```
public void putAll(Map<? extends CharSequence,? extends String> map)
```
    Take all entries from another Map.
    
    The obvious effect of this method is that described for AbstractMap with extra exploiting the cases where map is of type PropMap or where map's EntrySet contains PropMapHelper.Entrys.
    
    If map map is not a PropMap only those entries will be transfered that fulfil this classes contract for values and keys. key/value pairs of type CharSequence/Number, CharSequence/Character or CharSequence/Boolean will be transformed accordingly.
    
    Specified by:
    
    putAll in interface Map<CharSequence,String>
    
    Overrides:
    
    putAll in class AbstractMap<CharSequence,String>
    
    Parameters:
    
    map - entries to be taken to this map
    
    Throws:
    
    UnsupportedOperationException - if an existing immutable entry would have to be changed
  - hashQuality
```
public final StringBuilder hashQuality(StringBuilder bastel)
```
    The hash quality as two line String.
    
    Appended to the supplied StringBuilder are two comment lines (beginning with # ) describing the actual hash quality of this PropMap object. For testing and debugging purposes.
    
    Parameters:
    
    bastel - StringBuilder to append to. If non existing, it will be made with a starting capacity of 133
    
    Returns:
    
    bastel
    
    See Also:
    
    toString()
  - sortedList
```
public StringBuilder sortedList(StringBuilder bastel)
```
    Sorted multi line entries list.
    
    Appended to the supplied StringBuilder will be a multi-line list sorted by keys (with at least one line per entry) of all entries (PropMapHelper.Entry).
    
    Parameters:
    
    bastel - StringBuilder to append to. If non existing, it will be made with a starting capacity of size() * 43 + 122
    
    Returns:
    
    bastel
    
    See Also:
    
    toString(), hashQuality(StringBuilder)
  - toString
```
public final String toString()
```
    State as multi line String.
    
    A multi-line list sorted by keys (with at least one line per entry) of all entries (PropMapHelper.Entry) will be returned.
    
    The returned list will be prepended by two comment lines describing the actual hash quality of this PropMap and by two empty lines.
    
    The outputs syntax is a property list readable / parsable by this classes respectively Java API's rules.
    
    Overrides:
    
    toString in class AbstractMap<CharSequence,String>
    
    See Also:
    
    PropMapHelper.Entry.toString(), hashQuality(StringBuilder), sortedList(StringBuilder), load(InputStream, CharSequence)
  - load
```
public void load(InputStream input,
                 CharSequence encoding)
          throws IOException
```
    Load key value pairs from an input stream.
    
    Calls load(input, encoding, this).
    
    Parameters:
    
    input - the stream to read the properties from
    
    encoding - the stream's encoding (character set)
    
    Throws:
    
    IOException - stream or file problems
    
    See Also:
    
    PropMapHelper.load(InputStream, CharSequence, Map), PropMapHelper.store(Map, OutputStream, CharSequence, CharSequence), Properties.load(InputStream), Properties.store(java.io.OutputStream, java.lang.String), store(OutputStream, CharSequence, CharSequence)
  - load1
```
public boolean load1(CharSequence fileName,
                     CharSequence encoding)
              throws IllegalArgumentException,
                     ClassCastException
```
    Load properties from (just) one text file.
    
    Into this PropMap object all properties (key/value pairs) parsable from the text file FileName will be entered or modified accordingly. See PropMapHelper.load(InputStream, CharSequence, Map) for syntax and all details.
    
    If the file opening, reading or closing fails (by any exceptions) false is returned. Nevertheless some entries may have been changed or added to this Map.
    
    Exceptions thrown by PropMap operations will be forwarded. That will end the process.
    
    In case of success true is returned and fileName will be recorded as one of the files / resources loaded.
    
    Parameters:
    
    fileName - the name of the text file to be parsed and loaded. If null false will be returned.
    
    encoding - the file's or stream's encoding (character set)
    
    Returns:
    
    true on success
    
    Throws:
    
    IllegalArgumentException - if put(String, String) will be so rejected
    
    UnsupportedOperationException - if put(String, String) will be so rejected
    
    ClassCastException - if a key violates PropMap' contract
    
    See Also:
    
    load(InputStream, CharSequence), PropMapHelper.load(InputStream, CharSequence, Map)
  - load1
```
public boolean load1(Class<?> cl,
                     CharSequence fileName,
                     CharSequence encoding)
              throws ClassCastException,
                     UnsupportedOperationException
```
    Load properties from a text file, class related.
    
    Into this PropMap object all properties (key/value pairs) parsable from the text file FileName will be entered or modified accordingly. See PropMapHelper.load(InputStream, CharSequence, Map) for syntax and all details.
    
    The file will be related, if feasible, to the class loader determined by the parameter cl. Used accordingly, this can have the effect of getting the denoted text file as resource from the application's or Frame4's (the framework's) .jar file. This is the best way of deploying properties, (beans) settings and else as resources. If the .jar file is signed, the protection against manipulation applies to the properties as well as to the classes / code.
    
    If the file opening, reading or closing fails (by any exceptions) false is returned. Nevertheless some entries may have been changed or added to this Map.
    
    Exceptions thrown by PropMap operations will be forwarded. That will end the process.
    
    In case of success true is returned and fileName will be recorded as one of the files / resources loaded.
    
    Parameters:
    
    cl - the base class to relate resources to. If null false is returned
    
    fileName - the name of the text file to be parsed and loaded. If null false will be returned.
    
    encoding - the file's or stream's encoding (character set)
    
    Returns:
    
    true on success
    
    Throws:
    
    IllegalArgumentException - if put(String, String) will be so rejected
    
    UnsupportedOperationException - if put(String, String) will be so rejected
    
    ClassCastException - if a key violates PropMap' contract
    
    ClassCastException - a key violates PropMap' contract
    
    See Also:
    
    load(InputStream, CharSequence), PropMapHelper.load(InputStream, CharSequence, Map), load1(CharSequence, CharSequence)
  - store
```
public void store(OutputStream output,
                  CharSequence startComment,
                  CharSequence encoding)
           throws IOException
```
    Storing all key value pairs to an output stream.
    
    Calls store(this, output, startComment, encoding).
    
    Parameters:
    
    output - the stream to write the properties to
    
    startComment - a describing comment to put at the begin
    
    encoding - the streams encoding (character set)
    
    Throws:
    
    IOException - when output problems
    
    NullPointerException - when output or map are null
    
    See Also:
    
    PropMapHelper.load(InputStream, CharSequence, Map), PropMapHelper.store(Map, OutputStream, CharSequence, CharSequence), Properties.load(java.io.InputStream), Properties.store(java.io.OutputStream, java.lang.String), load(InputStream, CharSequence)
  - subSet
```
public PropMap subSet(CharSequence prefix)
```
    Make a subset of this key/value pairs by key prefix.
    
    If prefix is null or empty this PropMap object itself is returned (this).
    
    Otherwise a new PropMap object will be made and filled only with those entries, which's keys are longer than prefix and start with it. Each new entry's key will be shortened by the given prefix.
    
    If this PropMap is of the type Prop, a Prop object will be returned.
    
    Example: If this Map contains a property with the key "serialA-baudRate" and the value "38600", subSet("serialA-") will contain a property "baudRate" with the (same) value "38600".
    
    Parameters:
    
    prefix - the prefix for the properties to take in
    
    Returns:
    
    the filtered new map (it may be empty)
  - asProperties
```
public final Properties asProperties(CharSequence filter)
```
    The content as Properties.
    
    Some methods (of legacy classes) do insist on getting a Properties or a Dictionary object, while really wanting any Map. This happens mainly in older APIs, like in javax.mail but also in OSGI implementations.
    
    For those cases only, this method delivers the whole content of this PropMap as a new Properties object.
    
    Returned is a new @link java.util.Properties} object containing all key/value pairs of this object except for those, whose value is null. A PropMap allows for null values while a Properties container does not.
    
    Parameters:
    
    filter - if (trimmed) not empty or null, it is used as a key filter letting only those keys pass that start with filter (e.g. mail.)
    
    Returns:
    
    a new Properties object containing the key/value pairs of this object; never null, but may be empty
  - keySet
```
public final Set<CharSequence> keySet()
```
    The keys as Set.
    
    This method always returns the same (singleton) PropMap.KeySet object.
    
    Specified by:
    
    keySet in interface Map<CharSequence,String>
    
    Overrides:
    
    keySet in class AbstractMap<CharSequence,String>
  - sortedKeys
```
public String[] sortedKeys()
```
    Fetch a sorted array of all keys.
    
    Returns:
    
    the sorted list of all keys as array (never null, but may be empty)
    
    See Also:
    
    keySet()
  - entrySet
```
public final Set<Map.Entry<CharSequence,String>> entrySet()
```
    The entries as Set.
    
    This method always returns the same (singleton) PropMap.EntrySet object for this PropMap.
    
    The method Set.toArray() returns (every time) a new filled PropMapHelper.Entry array.
    
    Specified by:
    
    entrySet in interface Map<CharSequence,String>
    
    Specified by:
    
    entrySet in class AbstractMap<CharSequence,String>

Class PropMap

Nested Class Summary

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

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

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.util.AbstractMap

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.concurrent.ConcurrentMap

Methods inherited from interface java.util.Map

Field Detail

rLock

wLock

entries

hashMissMax

hashMissSum

reHashes

VL_CL

language

region

FILE_LIST_LEN

internalKeySet

internalEntrySet

valStringMld

keyStringMld

Constructor Detail

PropMap

PropMap

Method Detail

size

equals

hashCode

clone

deepIt

isEmpty

clear

clear

remove

indexOfKey

containsKey

get

value

getProperty

getString

getString

entry

containsValue

getBoolean

getBoolean

getInt

getLong

remove

put

putImpl

putNewImpl

putNewImut

setProperty

getProperty

getProperty

getProperty

getBoolean

getInt

valueLang

substLang

getLanguage

setLanguage

getRegion

setRegion

rehash

rehash

put

add

putIfAbsent

remove

replace

replace

setProperty

setNewProperty

setProperty