getChildNodeNames() {
+ return read().getChildNodeNames();
+ }
+
+ public boolean hasChildNode(String name) {
+ return read().hasChildNode(name);
+ }
+
+ public void setChildNode(String name, NodeState nodeState) {
+ write().setChildNode(name, nodeState);
+ }
+
+ public void remove() {
+ head.write();
+ parent.head.write().removeChildNode(name);
+ }
+
+ public long getPropertyCount() {
+ return read().getPropertyCount();
+ }
+
+ public Iterable getProperties() {
+ return read().getProperties();
+ }
+
+ public boolean hasProperty(String name) {
+ return read().hasProperty(name);
+ }
+
+ public PropertyState getProperty(String name) {
+ return read().getProperty(name);
+ }
+
+ public void setProperty(PropertyState propertyState) {
+ write().setProperty(propertyState);
+ }
+
+ public boolean removeProperty(String name) {
+ return write().removeProperty(name);
+ }
+ }
+
+ private class ConnectedHead extends Head {
+ @Override
+ protected MutableNodeState read() {
+ if (revision != rootBuilder.baseRevision) {
+ // the root builder's base state has been reset: re-get
+ // state from parent.
+ MutableNodeState parentState = (MutableNodeState) parent.head.read();
+ state = parentState.getMutableChildNode(name);
+ revision = rootBuilder.baseRevision;
+ }
+ return (MutableNodeState) state;
+ }
+
+ @Override
+ protected MutableNodeState write() {
+ // incrementing the root revision triggers unconnected
+ // child state to re-get their state on next access
+ rootBuilder.head.revision++;
+ return read();
+ }
+ }
+
+ private class UnconnectedHead extends Head {
+ @Override
+ protected NodeState read() {
+ if (revision != rootBuilder.head.revision) {
+ // root revision changed: recursively re-get state from parent
+ NodeState parentState = parent.head.read();
+ state = parentState.getChildNode(name);
+ revision = rootBuilder.head.revision;
+ }
+ return state;
+ }
+
+ @Override
+ protected MutableNodeState write() {
+ // switch to connected state recursively up to the parent
+ parent.head.write();
+ return (head = new ConnectedHead()).write();
+ }
+ }
+
+ private class RootHead extends Head {
+ public RootHead() {
+ // ensure updating of child builders on first access
+ reset();
+ }
+
+ @Override
+ protected MutableNodeState read() {
+ return (MutableNodeState) state;
+ }
+
+ @Override
+ protected MutableNodeState write() {
+ return (MutableNodeState) state;
+ }
+
+ @Override
+ public final void reset() {
+ state = new MutableNodeState(base);
+ revision++;
+ }
}
}
Index: oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/memory/MutableNodeState.java
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
--- oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/memory/MutableNodeState.java (revision 81d2780d5da04237b88ac95aa6f5bd2359e8cc39)
+++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/memory/MutableNodeState.java (revision )
@@ -83,23 +83,6 @@
}
/**
- * Get and optionally connect a potentially non existing child
- * node of a given {@code name}. Connected child nodes are kept
- * in the list of modified child nodes of this node.
- */
- MutableNodeState getChildNode(String name, boolean connect) {
- assert base != null;
- MutableNodeState child = nodes.get(name);
- if (child == null) {
- child = new MutableNodeState(base.getChildNode(name));
- if (connect) {
- nodes.put(name, child);
- }
- }
- return child;
- }
-
- /**
* Equivalent to
*
* MutableNodeState child = getChildNode(name, true);
@@ -269,9 +252,31 @@
}
}
+ /**
+ * Returns a mutable child node with the given name. If the named
+ * child node has already been modified, i.e. there's an entry for
+ * it in the {@link #nodes} map, then that child instance is returned
+ * directly. Otherwise a new mutable child instance is created based
+ * on the (possibly non-existent) respective child node of the base
+ * state, added to the {@link #nodes} map and returned.
+ */
+ MutableNodeState getMutableChildNode(String name) {
+ assert base != null;
+ MutableNodeState child = nodes.get(name);
+ if (child == null) {
+ child = new MutableNodeState(base.getChildNode(name));
+ nodes.put(name, child);
+ }
+ return child;
+ }
+
@Override
- public MutableNodeState getChildNode(String name) {
- throw new UnsupportedOperationException();
+ public NodeState getChildNode(String name) {
+ NodeState child = nodes.get(name);
+ if (child == null) {
+ child = base.getChildNode(name);
+ }
+ return child;
}
@Override @Nonnull