PropertiesImpl (Bracket Properties 1.3.6 API)

java.lang.Object
- asia.redact.bracket.properties.PropertiesBaseImpl
- - asia.redact.bracket.properties.AbstractMapDerivedPropertiesBase
  - - asia.redact.bracket.properties.PropertiesImpl

All Implemented Interfaces:

Properties, Serializable

Direct Known Subclasses:

SortedPropertiesImpl
```
public class PropertiesImpl
extends AbstractMapDerivedPropertiesBase
implements Properties
```
A better Properties class. This implementation class is thread-safe.

Author:

Dave

See Also:

Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from interface asia.redact.bracket.properties.Properties
  Properties.Factory, Properties.Mode

Field Summary

Fields
Modifier and Type Field and Description

private static long serialVersionUID
- Fields inherited from class asia.redact.bracket.properties.AbstractMapDerivedPropertiesBase
  map
- Fields inherited from class asia.redact.bracket.properties.PropertiesBaseImpl
  antStyleVarPattern, dotIdentifierPattern, dotIntegerPattern, dotKeyValuePattern, lock, REF_TOKEN

Fields
Modifier and Type	Field and Description
`private static long`	`serialVersionUID`

Constructor Summary

Constructors
Constructor and Description
`PropertiesImpl()`
`PropertiesImpl(InputStream in)`
`PropertiesImpl(InputStream in, Charset charset)`
`PropertiesImpl(Map map)`
`PropertiesImpl(Properties legacy)` Load from a legacy instance.
`PropertiesImpl(Reader in)`
`PropertiesImpl(URL url)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Object`	`beanValue(Class<?> clazz, String keyBase)` Serialize an arbitrary object
`BigDecimal`	`bigDecimalValue(String key)` Serialized bigDecimal support
`BigInteger`	`bigValue(String key)` serialized BigInteger support
`BitSet`	`bitsetValue(String key)` Return the value as a BitSet.
`boolean`	`booleanValue(String key)` Works for "true/false", "enabled/disabled", "yes/no"
`Properties`	`convertToLegacyProperties()` Get java.util.Properties from ours
`Date`	`dateValue(String key)` The value is assumed to be a long integer
`Date`	`dateValue(String key, String format)` I should really deprecate this - you should really use long values as dates in a serialization.
`void`	`delete(String key)`
`void`	`deobfuscate(String key)` Obverse of the above
`char[]`	`deobfuscateToChar(String key)`
`boolean`	`equals(Object obj)`
`float`	`floatValue(String key)`
`String`	`get(String key)` Get the value of the property; concatenate multiple lines.
`List<String>`	`getComments(String key)` Get the list of comments, return an empty list if none
`Map<String,String>`	`getFlattenedMap()` Just return Strings as the values
`Properties`	`getGroup(GroupParams params)`
`List<String>`	`getKeyGroup(String keyBase)`
`String`	`getKeyRef(String key)`
`List<String>`	`getList(String keyBase)` This method relies on the convention of using numbers at the end of a property key to represent a list member.
`List<String>`	`getListKeys(String keyBase)` Return keys which match the pattern keyBase.0, keyBase.1, keyBase.2, etc.
`List<String>`	`getMapKeys(String keyBase)` Specialty method used with a map that has been serialized in the form keyBase dot integer dot k\|v For example, 0.0.k=a key 0.0.v=a value
`List<String>`	`getMatchingKeys(String partial)` Return the keys which match the partial key submitted
`Map<String,ValueModel>`	`getPropertyMap()` Can be used to get direct access to the Entry data structures
`char`	`getSeparator(String key)` The char found in the parse, normally '='
`Node`	`getTree()` Use "\\." as the separator
`Node`	`getTree(GroupParams params)` Get the properties as a tree of nodes with a selector a.b.c=something a.b.c.d=something else a.b.c.e.f=item a.b.c.e=item2
`int`	`hashCode()`
`boolean`	`hasKeyLike(String partial)` Like containsKey but matching on the partial
`boolean`	`hasValue(String key)` Returns true if the key exists and has a non-empty value
`protected void`	`initMap()`
`int`	`intValue(String key)` Coerce the value to an integer.
`List<String>`	`listValue(String key)` Given a value of the form item1 item2 item3, return a List of those values
`List<String>`	`listValue(String key, String delimiter)` Like the above but with a specified delimiter such as item1-item2-item3 where the delimiter is -
`long`	`longValue(String key)` Coerce to a long value.
`Properties`	`merge(Properties props)` This is a combine function, existing keys which do not collide with the incoming are kept, keys that collide are overwritten with the new values
`Properties`	`merge(Properties props, boolean mergeComments)` Overwrite existing keys with the new ones, keep those existing ones that don't collide This operation is non-destructive on the input
`Properties`	`merge(Properties props, boolean mergeComments, boolean deobfuscate)`
`void`	`mergeIntoSystemProperties()` Caution
`void`	`obfuscate(String key)` Obfuscate the value so it is more difficult to read.
`void`	`put(Entry entry)`
`void`	`put(String key, BigDecimal bd)`
`void`	`put(String key, BigInteger bi)`
`void`	`put(String key, boolean val)`
`void`	`put(String key, char val)`
`void`	`put(String key, char separator, Comment comment, String... values)`
`void`	`put(String key, char separator, String... values)`
`void`	`put(String key, Comment comment, String... values)`
`void`	`put(String key, double val)`
`void`	`put(String key, float val)`
`void`	`put(String key, int val)`
`void`	`put(String key, List<String> values)` companion of the above.
`void`	`put(String key, long val)`
`void`	`put(String key, String... values)` Yes, multi-valued (multi-lined) properties are in the spec.
`void`	`putKeyRef(String newRefKey, String existingKey)`
`void`	`putList(List<String> list, char sep, Comment comment, String rootKey)`
`void`	`putList(List<String> list, Comment comment, String rootKey)`
`void`	`putList(List<String> list, String rootKey)` create property keys and values based on a root key and a list in the form: rootKey.0= list.get(0); rootKey.1= list.get(1); and so on.
`void`	`putList(String key, char ch, List<String> list)`
`String`	`resolve(String key)` System properties and environment variable resolution.
`Properties`	`slice(String root)` Return a Properties object with only the set of keys which match the root.

Methods inherited from class asia.redact.bracket.properties.AbstractMapDerivedPropertiesBase
atIndex, clear, containsKey, containsValue, isEmpty, keySet, remove, size, toString, values

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

Methods inherited from interface asia.redact.bracket.properties.Properties
clear, containsKey, size

- Field Detail
  - serialVersionUID
```
private static final long serialVersionUID
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - PropertiesImpl
```
public PropertiesImpl()
```
  - PropertiesImpl
```
public PropertiesImpl(Properties legacy)
```
```
 Load from a legacy instance.
 Some slight information loss here is unavoidable. For example if a colon is used as the separator in the original,
 that information will be lost. If you need a more exact translation you can do that
 with the lexer and parser classes by reading in the data directly from the properties file instead
 of reading in with java.util.Properties and then converting.
 
 
```
  - PropertiesImpl
```
public PropertiesImpl(Map map)
```
  - PropertiesImpl
```
public PropertiesImpl(URL url)
```
  - PropertiesImpl
```
public PropertiesImpl(InputStream in)
```
  - PropertiesImpl
```
public PropertiesImpl(InputStream in,
                      Charset charset)
```
  - PropertiesImpl
```
public PropertiesImpl(Reader in)
```
- Method Detail
  - initMap
```
protected void initMap()
```
  - get
```
public String get(String key)
```
    Get the value of the property; concatenate multiple lines.
    
    Specified by:
    
    get in interface Properties
    
    Parameters:
    
    key -
    
    Returns:
    
    Throws:
    
    RuntimeException - if key is not present.
  - getKeyRef
```
public String getKeyRef(String key)
```
  - putKeyRef
```
public void putKeyRef(String newRefKey,
                      String existingKey)
```
  - put
```
public void put(Entry entry)
```
    Specified by:
    
    put in interface Properties
  - put
```
public void put(String key,
                String... values)
```
    Yes, multi-valued (multi-lined) properties are in the spec. If the key already exists, all the values are removed and replaced
    
    Specified by:
    
    put in interface Properties
    
    Parameters:
    
    key -
    
    values -
  - put
```
public void put(String key,
                List<String> values)
```
    Description copied from interface: Properties
    
    companion of the above. Given a list flatten it to a set of items as a value
    
    Specified by:
    
    put in interface Properties
  - put
```
public void put(String key,
                Comment comment,
                String... values)
```
    Specified by:
    
    put in interface Properties
  - put
```
public void put(String key,
                char separator,
                String... values)
```
  - put
```
public void put(String key,
                char separator,
                Comment comment,
                String... values)
```
    Specified by:
    
    put in interface Properties
  - put
```
public void put(String key,
                int val)
```
    Specified by:
    
    put in interface Properties
  - put
```
public void put(String key,
                BigInteger bi)
```
    Specified by:
    
    put in interface Properties
  - put
```
public void put(String key,
                BigDecimal bd)
```
    Specified by:
    
    put in interface Properties
  - put
```
public void put(String key,
                float val)
```
    Specified by:
    
    put in interface Properties
  - put
```
public void put(String key,
                long val)
```
    Specified by:
    
    put in interface Properties
  - put
```
public void put(String key,
                double val)
```
    Specified by:
    
    put in interface Properties
  - put
```
public void put(String key,
                boolean val)
```
    Specified by:
    
    put in interface Properties
  - put
```
public void put(String key,
                char val)
```
    Specified by:
    
    put in interface Properties
  - getPropertyMap
```
public Map<String,ValueModel> getPropertyMap()
```
    Description copied from interface: Properties
    
    Can be used to get direct access to the Entry data structures
    
    Specified by:
    
    getPropertyMap in interface Properties
    
    Returns:
  - getFlattenedMap
```
public Map<String,String> getFlattenedMap()
```
    Description copied from interface: Properties
    
    Just return Strings as the values
    
    Specified by:
    
    getFlattenedMap in interface Properties
    
    Returns:
  - getComments
```
public List<String> getComments(String key)
```
    Description copied from interface: Properties
    
    Get the list of comments, return an empty list if none
    
    Specified by:
    
    getComments in interface Properties
    
    Returns:
  - getSeparator
```
public char getSeparator(String key)
```
    Description copied from interface: Properties
    
    The char found in the parse, normally '='
    
    Specified by:
    
    getSeparator in interface Properties
    
    Returns:
  - getKeyGroup
```
public List<String> getKeyGroup(String keyBase)
```
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class AbstractMapDerivedPropertiesBase
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class AbstractMapDerivedPropertiesBase
  - merge
```
public Properties merge(Properties props)
```
    This is a combine function, existing keys which do not collide with the incoming are kept, keys that collide are overwritten with the new values
    
    Specified by:
    
    merge in interface Properties
    
    Parameters:
    
    props -
    
    Returns:
    
    the merged properties
  - merge
```
public Properties merge(Properties props,
                        boolean mergeComments)
```
    Description copied from interface: Properties
    
    Overwrite existing keys with the new ones, keep those existing ones that don't collide This operation is non-destructive on the input
    
    Specified by:
    
    merge in interface Properties
    
    Returns:
    
    the merged properties
  - merge
```
public Properties merge(Properties props,
                        boolean mergeComments,
                        boolean deobfuscate)
```
    Specified by:
    
    merge in interface Properties
  - obfuscate
```
public void obfuscate(String key)
```
    Description copied from interface: Properties
    
    Obfuscate the value so it is more difficult to read. First call "put(key,value)" then "obfuscate(key)"
    
    Specified by:
    
    obfuscate in interface Properties
  - deobfuscate
```
public void deobfuscate(String key)
```
    Description copied from interface: Properties
    
    Obverse of the above
    
    Specified by:
    
    deobfuscate in interface Properties
  - deobfuscateToChar
```
public char[] deobfuscateToChar(String key)
```
    Specified by:
    
    deobfuscateToChar in interface Properties
  - getTree
```
public Node getTree()
```
    Use "\\." as the separator
    
    Specified by:
    
    getTree in interface Properties
    
    Returns:
  - getTree
```
public Node getTree(GroupParams params)
```
    Description copied from interface: Properties
```
 Get the properties as a tree of nodes with a selector
 
 a.b.c=something
 a.b.c.d=something else
 a.b.c.e.f=item
 a.b.c.e=item2
 
```
    Specified by:
    
    getTree in interface Properties
  - getGroup
```
public Properties getGroup(GroupParams params)
```
  - slice
```
public Properties slice(String root)
```
    Description copied from interface: Properties
    
    Return a Properties object with only the set of keys which match the root.
    
    Specified by:
    
    slice in interface Properties
  - getMatchingKeys
```
public List<String> getMatchingKeys(String partial)
```
    Return the keys which match the partial key submitted
    
    Parameters:
    
    partial -
    
    Returns:
  - hasKeyLike
```
public boolean hasKeyLike(String partial)
```
    Description copied from interface: Properties
    
    Like containsKey but matching on the partial
    
    Specified by:
    
    hasKeyLike in interface Properties
    
    Returns:
  - intValue
```
public int intValue(String key)
```
    Description copied from interface: Properties
    
    Coerce the value to an integer. Obviously this works better if the value is actually an integer.
    
    Specified by:
    
    intValue in interface Properties
    
    Returns:
  - booleanValue
```
public boolean booleanValue(String key)
```
    Works for "true/false", "enabled/disabled", "yes/no"
    
    Specified by:
    
    booleanValue in interface Properties
  - longValue
```
public long longValue(String key)
```
    Description copied from interface: Properties
    
    Coerce to a long value. Obviously this works better if the value is actually a long.
    
    Specified by:
    
    longValue in interface Properties
    
    Returns:
  - floatValue
```
public float floatValue(String key)
```
    Specified by:
    
    floatValue in interface Properties
  - dateValue
```
public Date dateValue(String key)
```
    The value is assumed to be a long integer
    
    Specified by:
    
    dateValue in interface Properties
    
    Returns:
  - dateValue
```
public Date dateValue(String key,
                      String format)
               throws ParseException
```
    I should really deprecate this - you should really use long values as dates in a serialization. See above.
    
    Specified by:
    
    dateValue in interface Properties
    
    Returns:
    
    Throws:
    
    ParseException
  - hasValue
```
public boolean hasValue(String key)
```
    Description copied from interface: Properties
    
    Returns true if the key exists and has a non-empty value
    
    Specified by:
    
    hasValue in interface Properties
    
    Returns:
  - mergeIntoSystemProperties
```
public void mergeIntoSystemProperties()
```
    Caution
    
    Specified by:
    
    mergeIntoSystemProperties in interface Properties
  - getMapKeys
```
public List<String> getMapKeys(String keyBase)
```
    Description copied from interface: Properties
    
    Specialty method used with a map that has been serialized in the form keyBase dot integer dot k|v For example, 0.0.k=a key 0.0.v=a value
    
    Specified by:
    
    getMapKeys in interface Properties
  - getListKeys
```
public List<String> getListKeys(String keyBase)
```
    Description copied from interface: Properties
    
    Return keys which match the pattern keyBase.0, keyBase.1, keyBase.2, etc. The list returned is in natural sorted order.
    
    Specified by:
    
    getListKeys in interface Properties
    
    Returns:
  - getList
```
public List<String> getList(String keyBase)
```
    Description copied from interface: Properties
```
 This method relies on the convention of using numbers at
 the end of a property key to represent a list member. The total 
 list is the set of all similar keys with key as the base
 and dot delimited integers at the end. Suppose the following 
 (from, e.g., the Tanukisoft wrapper.conf):
 
 wrapper.java.classpath.1=../lib/wrapper.jar
 wrapper.java.classpath.2=../lib/myapp.jar
 wrapper.java.classpath.3=../lib/mysql.jar
 wrapper.java.classpath.4=../classes
 
 Then calling getList("wrapper.java.classpath") would
 return all the values above, in numeric order, as a List.
 
 If key does not exist but numbered properties exist, the
 key is synthesized. if no numbered properties exist, an
 empty list is returned. If the key does not exist and no numbered
 keys exist, the method returns an empty list
 
 Numbers need not be sequential
  
  
```
    Specified by:
    
    getList in interface Properties
    
    Returns:
  - listValue
```
public List<String> listValue(String key)
```
    Description copied from interface: Properties
    
    Given a value of the form item1 item2 item3, return a List of those values
    
    Specified by:
    
    listValue in interface Properties
    
    Returns:
  - listValue
```
public List<String> listValue(String key,
                              String delimiter)
```
    Description copied from interface: Properties
    
    Like the above but with a specified delimiter such as item1-item2-item3 where the delimiter is -
    
    Specified by:
    
    listValue in interface Properties
    
    Returns:
  - putList
```
public void putList(String key,
                    char ch,
                    List<String> list)
```
  - bitsetValue
```
public BitSet bitsetValue(String key)
```
    Description copied from interface: Properties
    
    Return the value as a BitSet. Obviously works better if the value is zeros and ones
    
    Specified by:
    
    bitsetValue in interface Properties
    
    Returns:
  - bigValue
```
public BigInteger bigValue(String key)
```
    Description copied from interface: Properties
    
    serialized BigInteger support
    
    Specified by:
    
    bigValue in interface Properties
    
    Returns:
  - bigDecimalValue
```
public BigDecimal bigDecimalValue(String key)
```
    Description copied from interface: Properties
    
    Serialized bigDecimal support
    
    Specified by:
    
    bigDecimalValue in interface Properties
    
    Returns:
  - beanValue
```
public Object beanValue(Class<?> clazz,
                        String keyBase)
```
    Description copied from interface: Properties
    
    Serialize an arbitrary object
    
    Specified by:
    
    beanValue in interface Properties
    
    Returns:
  - putList
```
public void putList(List<String> list,
                    String rootKey)
```
    Description copied from interface: Properties
```
 create property keys and values based on a root key and a list in the form:
 
 rootKey.0= list.get(0);
 rootKey.1= list.get(1);
 
 and so on. This method is a complement to using getList(rootKey).
 
 
```
    Specified by:
    
    putList in interface Properties
  - putList
```
public void putList(List<String> list,
                    Comment comment,
                    String rootKey)
```
    Specified by:
    
    putList in interface Properties
  - putList
```
public void putList(List<String> list,
                    char sep,
                    Comment comment,
                    String rootKey)
```
  - convertToLegacyProperties
```
public Properties convertToLegacyProperties()
```
    Description copied from interface: Properties
    
    Get java.util.Properties from ours
    
    Specified by:
    
    convertToLegacyProperties in interface Properties
    
    Returns:
  - resolve
```
public String resolve(String key)
```
    Description copied from interface: Properties
```
 System properties and environment variable resolution. 
 This uses the familiar "ant" style replacement expression ${name} 
 in the property value. 
 
 For example: 
 
 localpath=${PATH}
 user.home=${user.home}
 
 
```
    Specified by:
    
    resolve in interface Properties
    
    Returns:
  - delete
```
public void delete(String key)
```
    Specified by:
    
    delete in interface Properties

Class PropertiesImpl

Nested Class Summary

Nested classes/interfaces inherited from interface asia.redact.bracket.properties.Properties

Field Summary

Fields inherited from class asia.redact.bracket.properties.AbstractMapDerivedPropertiesBase

Fields inherited from class asia.redact.bracket.properties.PropertiesBaseImpl

Constructor Summary

Method Summary

Methods inherited from class asia.redact.bracket.properties.AbstractMapDerivedPropertiesBase

Methods inherited from class java.lang.Object

Methods inherited from interface asia.redact.bracket.properties.Properties

Field Detail

serialVersionUID

Constructor Detail

PropertiesImpl

PropertiesImpl

PropertiesImpl

PropertiesImpl

PropertiesImpl

PropertiesImpl

PropertiesImpl

Method Detail

initMap

get

getKeyRef

putKeyRef

put

put

put

put

put

put

put

put

put

put

put

put

put

put

getPropertyMap

getFlattenedMap

getComments

getSeparator

getKeyGroup

hashCode

equals

merge

merge

merge

obfuscate

deobfuscate

deobfuscateToChar

getTree

getTree

getGroup

slice

getMatchingKeys

hasKeyLike

intValue

booleanValue

longValue

floatValue

dateValue

dateValue

hasValue

mergeIntoSystemProperties

getMapKeys

getListKeys

getList

listValue

listValue

putList

bitsetValue

bigValue

bigDecimalValue

beanValue

putList

putList

putList