/**
* ** Returns true if the specified key name is equal to the current key name. ** @param otherKey
* The key name to test for equality ** @return True if equals, false otherwise
*/
public boolean equals(Object otherKey) {
if (otherKey instanceof RTKey) {
RTKey otherRTKey = (RTKey) otherKey;
return this.getName().equals(otherRTKey.getName());
} else {
return false;
}
}
/**
* ** Sets the default property value of the property associated with the ** specified key
* ** @param key The key of the property to set ** @param val The value to set the property to
*/
public static void setDefaultProperty(String key, Object val) {
Entry rtKey = RTKey.getRuntimeEntry(key);
if (rtKey != null) {
rtKey.setDefault(val);
} else {
RTKey.addRuntimeEntry(new Entry(key, val));
}
}
/**
* ** Compares two RTKeys lexicographically. ** @param otherKey The key name to compare ** @return
* 0 if the keys are equal, less-than 0 if this key is lexicographically ** less than the argument
* key, and greater-than 0 if this key is ** lexicographically greater-than the key argument.
*/
public int compareTo(RTKey otherKey) {
if (otherKey == null) {
return 1;
} else {
return this.getName().compareTo(otherKey.getName());
}
}
/** ** Adds an entry ({@link Entry}) to <code>RTKey</code> */
public static void addRuntimeEntry(Entry dftEntry) {
if (dftEntry != null) {
String rtKey = dftEntry.getKey();
if (rtKey != null) {
RTKey.getRuntimeEntryMap().put(rtKey, dftEntry);
defaultProperties = null;
}
}
}
public static void addRuntimeEntries(Entry dftEntry[]) {
if (dftEntry != null) {
Map<String, Entry> gblmap = RTKey.getRuntimeEntryMap();
for (int i = 0; i < dftEntry.length; i++) {
String rtKey = dftEntry[i].getKey();
if (rtKey != null) {
gblmap.put(rtKey, dftEntry[i]);
}
}
defaultProperties = null;
}
}
/**
* ** Gets all the ddefault properties in <code>RTKey</code> represented ** as an {@link
* RTProperties} instance ** @return The <code>RTProperties</code> instance
*/
public static RTProperties getDefaultProperties() {
if (defaultProperties == null) {
RTProperties rtp = new RTProperties();
for (Iterator<Entry> v = RTKey.getRuntimeEntryMap().values().iterator(); v.hasNext(); ) {
Entry rtk = v.next();
if (!rtk.isHelp()) {
String key = rtk.getKey();
Object val = rtk.getDefault();
rtp.setProperty(key, val);
}
}
defaultProperties = rtp;
}
return defaultProperties;
}
/**
* ** Prints all the default values from <code>RTKey</code> and {@link RTConfig} ** to the
* specified <code>PrintStream</code>. Used for debugging/testing ** @param out The <code>
* PrintStream</code>
*/
public static void printDefaults(PrintStream out) {
/* print standard runtime entries */
Set<String> keyList = new OrderedSet<String>();
String keyGrp = null;
for (Iterator<Entry> v = RTKey.getRuntimeEntryMap().values().iterator(); v.hasNext(); ) {
Entry rtk = v.next();
if (rtk.isHelp()) {
out.println("");
out.println("# ===== " + rtk.getHelp());
} else {
Object dft = rtk.getDefault();
out.println("# --- " + rtk.getHelp());
out.println("# " + rtk.toString(dft));
String key = rtk.getKey();
keyList.add(key);
if (!key.equals(CONFIG_FILE) && RTConfig.hasProperty(key)) {
String val = RTConfig.getString(key, null);
// if ((val != null) && ((dft == null) || !val.equals(dft.toString()))) {
out.println(rtk.toString(val));
// }
}
}
}
/* orphaned entries */
RTProperties cmdLineProps = RTConfig.getConfigFileProperties();
if (cmdLineProps != null) {
boolean orphanHeader = false;
for (Iterator i = cmdLineProps.keyIterator(); i.hasNext(); ) {
Object k = i.next();
if (!k.equals(COMMAND_LINE_CONF) && !keyList.contains(k)) {
if (!orphanHeader) {
out.println("");
out.println("# ===== Other entries");
orphanHeader = true;
}
Object v = cmdLineProps.getProperty(k, null);
out.println(k + "=" + ((v != null) ? v : NULL_VALUE));
}
}
}
/* final blank line */
out.println("");
}
/**
* ** Apply the specified partial key as a suffix to the key name contained in this RTKey
* ** @param rtSfx Property key suffix ** @return The combine property key from this RTKey and the
* specified suffix.
*/
public RTKey rtSuffix(RTKey rtSfx) {
String sfx = (rtSfx != null) ? rtSfx.toString() : "";
return new RTKey(this.suffix(sfx));
}
/**
* ** Returns true if the specified key is null, or contains an empty String ** @param key The
* RTKey to test ** @return True if the specified key is null, or contains an empty String
*/
public static boolean isBlank(RTKey key) {
return (key == null) ? true : key.isBlank();
}
/**
* ** Gets the default property value associated with the specified key. ** Returns <code>dft
* </code> if none was found ** @param key The key of the property to get ** @param dft The value
* to return if no propetry value was found
*/
public static Object getDefaultProperty(String key, Object dft) {
Entry rtKey = RTKey.getRuntimeEntry(key);
return (rtKey != null) ? rtKey.getDefault() : dft;
}
/**
* ** Returns true if the specified default property key is defined ** @param key A property key
* ** @return True if the specified default property key is defined
*/
public static boolean hasDefault(String key) {
return (RTKey.getRuntimeEntry(key) != null);
}
/**
* ** Gets the entry associated with the specified key ** @param key The key of the entry to get
* ** @return The entry
*/
protected static Entry getRuntimeEntry(String key) {
return (key != null) ? RTKey.getRuntimeEntryMap().get(key) : null;
}
/** ** Gets an iterator over all of the entries ** @return The iterator over the entries */
public static Iterator<String> getRuntimeKeyIterator() {
return RTKey.getRuntimeEntryMap().keySet().iterator();
}
