- @Override\r
- public ParentNode<?> getRootNode() {\r
- // This is a root node!\r
- return this;\r
- }\r
-\r
- // ILookupService implementation\r
-\r
- private final Object lookupLock = new Object();\r
- private final Map<String, INode> toNode = new HashMap<String, INode>();\r
- private final Map<INode, String> toId = new HashMap<INode, String>();\r
-\r
- transient Logger logger = Logger.getLogger(getClass().getName());\r
-\r
- @Override\r
- public INode map(String id, INode node) {\r
- if (id == null)\r
- throw new NullPointerException("null id");\r
- if (node == null)\r
- throw new NullPointerException("null node");\r
-\r
- INode oldNode;\r
- String oldId;\r
- synchronized (lookupLock) {\r
- oldNode = toNode.put(id, node);\r
- oldId = toId.put(node, id);\r
-\r
- // Keep the mapping a consistent bijection:\r
- // If ID => INode mapping is removed, the INode => ID mappings must\r
- // removed also.\r
-\r
- if (oldNode != null && !oldNode.equals(node)) {\r
- String removedId = toId.remove(oldNode);\r
- if (!id.equals(removedId))\r
- toNode.remove(removedId);\r
- }\r
- if (oldId != null && !oldId.equals(id)) {\r
- INode removedNode = toNode.remove(oldId);\r
- if (removedNode != node)\r
- toId.remove(removedNode);\r
- }\r
- }\r
- if (logger.isLoggable(Level.FINER))\r
- logger.fine("map(" + id + ", " + node + ")");\r
- if (oldNode != null || oldId != null) {\r
- if (logger.isLoggable(Level.FINE)) {\r
- logger.info("replaced mappings for ID " + oldId + " and node " + oldNode);\r
- }\r
- }\r
- return oldNode;\r
- }\r
-\r
- @Override\r
- public INode unmap(String id) {\r
- INode node;\r
- String mappedId;\r
- synchronized (lookupLock) {\r
- node = toNode.remove(id);\r
- if (node == null)\r
- return null;\r
- mappedId = toId.remove(node);\r
- }\r
- if (logger.isLoggable(Level.FINER))\r
- logger.fine("unmap(" + id + "): " + node);\r
- if (mappedId != null && !mappedId.equals(id)) {\r
- if (logger.isLoggable(Level.WARNING))\r
- logger.log(Level.WARNING, "mapping was out-of-sync: " + id + " => " + node + " & " + mappedId + " => " + node, new Exception("trace"));\r
- }\r
- return node;\r
- }\r
-\r
- @Override\r
- public String unmap(INode node) {\r
- String id;\r
- INode mappedNode;\r
- synchronized (lookupLock) {\r
- id = toId.remove(node);\r
- if (node == null)\r
- return null;\r
- mappedNode = toNode.remove(id);\r
- }\r
- if (logger.isLoggable(Level.FINER))\r
- logger.fine("unmap(" + node + "): " + id);\r
- if (mappedNode != null && node != mappedNode) {\r
- if (logger.isLoggable(Level.WARNING))\r
- logger.log(Level.WARNING, "mapping was out-of-sync: " + node + " => " + id + " & " + id + " => " + mappedNode, new Exception("trace"));\r
- }\r
- return id;\r
- }\r
-\r
- @Override\r
- public INode lookupNode(String id) {\r
- synchronized (lookupLock) {\r
- return toNode.get(id);\r
- }\r
- }\r
-\r
- @Override\r
- public String lookupId(INode node) {\r
- synchronized (lookupLock) {\r
- return toId.get(node);\r
- }\r
- }\r
-\r
- public boolean isPending() {\r
- return !pending.isEmpty();\r
- }\r
-\r
- synchronized public void increasePending(Object object) {\r
- Integer ref = pending.get(object);\r
- if (ref == null) pending.put(object, 1);\r
- else pending.put(object, ref+1);\r
- }\r
-\r
- synchronized public void setPending(Object object) {\r
- pending.put(object, 1);\r
- }\r
-\r
- synchronized public void clearPending(Object object) {\r
- pending.remove(object);\r
- }\r
-\r
- synchronized public void decreasePending(Object object) {\r
- Integer ref = pending.get(object);\r
- if (ref == null) {\r
- return;\r
- //throw new IllegalStateException("Ref count in unregister was 0 for " + object);\r
- }\r
- if (ref > 1) pending.put(object, ref-1);\r
- else if (ref==1) pending.remove(object);\r
- else {\r
- return;\r
- //throw new IllegalStateException("Ref count in unregister was 0 for " + object);\r
- }\r
- }\r
- \r
- synchronized public void setGlobalProperty(String key, Object value) {\r
- globalProperties.put(key, value);\r
- }\r
- \r
- @SuppressWarnings("unchecked")\r
- synchronized public <T> T getGlobalProperty(String key, T defaultValue) {\r
- T t = (T)globalProperties.get(key);\r
- if(t == null) return defaultValue;\r
- return t;\r
- }\r
-\r
+ @Override
+ public ParentNode<?> getRootNode() {
+ // This is a root node!
+ return this;
+ }
+
+ // ILookupService implementation
+
+ private final Object lookupLock = new Object();
+ private final Map<String, INode> toNode = new HashMap<String, INode>();
+ private final Map<INode, String> toId = new HashMap<INode, String>();
+
+ transient Logger logger = Logger.getLogger(getClass().getName());
+
+ @Override
+ public INode map(String id, INode node) {
+ if (id == null)
+ throw new NullPointerException("null id");
+ if (node == null)
+ throw new NullPointerException("null node");
+
+ INode oldNode;
+ String oldId;
+ synchronized (lookupLock) {
+ oldNode = toNode.put(id, node);
+ oldId = toId.put(node, id);
+
+ // Keep the mapping a consistent bijection:
+ // If ID => INode mapping is removed, the INode => ID mappings must
+ // removed also.
+
+ if (oldNode != null && !oldNode.equals(node)) {
+ String removedId = toId.remove(oldNode);
+ if (!id.equals(removedId))
+ toNode.remove(removedId);
+ }
+ if (oldId != null && !oldId.equals(id)) {
+ INode removedNode = toNode.remove(oldId);
+ if (removedNode != node)
+ toId.remove(removedNode);
+ }
+ }
+ if (logger.isLoggable(Level.FINER))
+ logger.fine("map(" + id + ", " + node + ")");
+ if (oldNode != null || oldId != null) {
+ if (logger.isLoggable(Level.FINE)) {
+ logger.info("replaced mappings for ID " + oldId + " and node " + oldNode);
+ }
+ }
+ return oldNode;
+ }
+
+ @Override
+ public INode unmap(String id) {
+ INode node;
+ String mappedId;
+ synchronized (lookupLock) {
+ node = toNode.remove(id);
+ if (node == null)
+ return null;
+ mappedId = toId.remove(node);
+ }
+ if (logger.isLoggable(Level.FINER))
+ logger.fine("unmap(" + id + "): " + node);
+ if (mappedId != null && !mappedId.equals(id)) {
+ if (logger.isLoggable(Level.WARNING))
+ logger.log(Level.WARNING, "mapping was out-of-sync: " + id + " => " + node + " & " + mappedId + " => " + node, new Exception("trace"));
+ }
+ return node;
+ }
+
+ @Override
+ public String unmap(INode node) {
+ String id;
+ INode mappedNode;
+ synchronized (lookupLock) {
+ id = toId.remove(node);
+ if (node == null)
+ return null;
+ mappedNode = toNode.remove(id);
+ }
+ if (logger.isLoggable(Level.FINER))
+ logger.fine("unmap(" + node + "): " + id);
+ if (mappedNode != null && node != mappedNode) {
+ if (logger.isLoggable(Level.WARNING))
+ logger.log(Level.WARNING, "mapping was out-of-sync: " + node + " => " + id + " & " + id + " => " + mappedNode, new Exception("trace"));
+ }
+ return id;
+ }
+
+ @Override
+ public INode lookupNode(String id) {
+ synchronized (lookupLock) {
+ return toNode.get(id);
+ }
+ }
+
+ @Override
+ public String lookupId(INode node) {
+ synchronized (lookupLock) {
+ return toId.get(node);
+ }
+ }
+
+ public boolean isPending() {
+ return !pending.isEmpty();
+ }
+
+ synchronized public void increasePending(Object object) {
+ Integer ref = pending.get(object);
+ if (ref == null) pending.put(object, 1);
+ else pending.put(object, ref+1);
+ }
+
+ synchronized public void setPending(Object object) {
+ pending.put(object, 1);
+ }
+
+ synchronized public void clearPending(Object object) {
+ pending.remove(object);
+ }
+
+ synchronized public void decreasePending(Object object) {
+ Integer ref = pending.get(object);
+ if (ref == null) {
+ return;
+ //throw new IllegalStateException("Ref count in unregister was 0 for " + object);
+ }
+ if (ref > 1) pending.put(object, ref-1);
+ else if (ref==1) pending.remove(object);
+ else {
+ return;
+ //throw new IllegalStateException("Ref count in unregister was 0 for " + object);
+ }
+ }
+
+ synchronized public void setGlobalProperty(String key, Object value) {
+ globalProperties.put(key, value);
+ }
+
+ @SuppressWarnings("unchecked")
+ synchronized public <T> T getGlobalProperty(String key, T defaultValue) {
+ T t = (T)globalProperties.get(key);
+ if(t == null) return defaultValue;
+ return t;
+ }
+