github-repos/config
1
0
Fork 0
mirror of https://github.com/lightbend/config.git synced 2025-03-23 07:40:25 +08:00
Code Issues Packages Projects Releases Wiki Activity

make ResolveSource.replacements use the value, not MemoKey, as key

Browse Source 
The MemoKey stuff here was leftover from some earlier version of
the code, and was no longer used (the restrictToChild was always
null in the MemoKey).
This commit is contained in:
Havoc Pennington 2012-03-30 21:40:18 -04:00
parent 0f712f423b
commit 27d92bec46
3 changed files with 13 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
config/src/main/java/com/typesafe/config/impl/MemoKey.java
View File

@ -10,10 +10,6 @@ final class MemoKey {
final private AbstractConfigValue value;
final private Path restrictToChildOrNull;
AbstractConfigValue value() {
return value;
}
@Override
public final int hashCode() {
int h = System.identityHashCode(value);

4
config/src/main/java/com/typesafe/config/impl/ResolveContext.java
View File

@ -161,9 +161,7 @@ final class ResolveContext {
if (cached != null) {
return cached;
} else {
MemoKey key = restrictedKey != null ? restrictedKey : fullKey;
AbstractConfigValue resolved = source.resolveCheckingReplacement(this, key);
AbstractConfigValue resolved = source.resolveCheckingReplacement(this, original);
if (resolved == null || resolved.resolveStatus() == ResolveStatus.RESOLVED) {
// if the resolved object is fully resolved by resolving

28
config/src/main/java/com/typesafe/config/impl/ResolveSource.java
View File

@ -1,6 +1,6 @@
package com.typesafe.config.impl;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.LinkedList;
import java.util.Map;
@ -18,11 +18,11 @@ final class ResolveSource {
// traversed node and therefore avoid circular dependencies.
// We implement it with this somewhat hacky "patch a replacement"
// mechanism instead of actually transforming the tree.
final private Map<MemoKey, LinkedList<ResolveReplacer>> replacements;
final private Map<AbstractConfigValue, LinkedList<ResolveReplacer>> replacements;
ResolveSource(AbstractConfigObject root) {
this.root = root;
this.replacements = new HashMap<MemoKey, LinkedList<ResolveReplacer>>();
this.replacements = new IdentityHashMap<AbstractConfigValue, LinkedList<ResolveReplacer>>();
}
static private AbstractConfigValue findInObject(final AbstractConfigObject obj,
@ -73,28 +73,26 @@ final class ResolveSource {
}
void replace(AbstractConfigValue value, ResolveReplacer replacer) {
MemoKey key = new MemoKey(value, null /* restrictToChild */);
LinkedList<ResolveReplacer> stack = replacements.get(key);
LinkedList<ResolveReplacer> stack = replacements.get(value);
if (stack == null) {
stack = new LinkedList<ResolveReplacer>();
replacements.put(key, stack);
replacements.put(value, stack);
}
stack.addFirst(replacer);
}
void unreplace(AbstractConfigValue value) {
MemoKey key = new MemoKey(value, null /* restrictToChild */);
LinkedList<ResolveReplacer> stack = replacements.get(key);
LinkedList<ResolveReplacer> stack = replacements.get(value);
if (stack == null)
throw new ConfigException.BugOrBroken("unreplace() without replace(): " + value);
stack.removeFirst();
}
private AbstractConfigValue replacement(MemoKey key) throws Undefined {
LinkedList<ResolveReplacer> stack = replacements.get(new MemoKey(key.value(), null));
private AbstractConfigValue replacement(AbstractConfigValue value) throws Undefined {
LinkedList<ResolveReplacer> stack = replacements.get(value);
if (stack == null || stack.isEmpty())
return key.value();
return value;
else
return stack.peek().replace();
}
@ -103,14 +101,12 @@ final class ResolveSource {
* Conceptually, this is key.value().resolveSubstitutions() but using the
* replacement for key.value() if any.
*/
AbstractConfigValue resolveCheckingReplacement(ResolveContext context, MemoKey key)
throws NotPossibleToResolve {
AbstractConfigValue original = key.value();
AbstractConfigValue resolveCheckingReplacement(ResolveContext context,
AbstractConfigValue original) throws NotPossibleToResolve {
AbstractConfigValue replacement;
boolean forceUndefined = false;
try {
replacement = replacement(key);
replacement = replacement(original);
} catch (Undefined e) {
replacement = original;
forceUndefined = true;