observing: create interface AstObserver

javaparser-core/src/main/java/com/github/javaparser/HasParentNode.java

@@ -1,14 +1,15 @@
 package com.github.javaparser;
 
+import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.observing.Observable;
+
 import java.util.List;
 import java.util.Optional;
 
-import com.github.javaparser.ast.Node;
-
 /**
  * An object that has a parent node.
  */
-public interface HasParentNode<T> {
+public interface HasParentNode<T> extends Observable {
 
     /**
      * Return the parent node or null, if no parent is set.

javaparser-core/src/main/java/com/github/javaparser/ast/Node.java

@@ -27,8 +27,7 @@
 import com.github.javaparser.ast.comments.BlockComment;
 import com.github.javaparser.ast.comments.Comment;
 import com.github.javaparser.ast.comments.LineComment;
-import com.github.javaparser.ast.observing.NodeObserver;
-import com.github.javaparser.ast.observing.Observable;
+import com.github.javaparser.ast.observing.AstObserver;
 import com.github.javaparser.ast.visitor.CloneVisitor;
 import com.github.javaparser.ast.visitor.EqualsVisitor;
 import com.github.javaparser.ast.visitor.Visitable;
@@ -50,7 +49,7 @@
  * @author Julio Vilmar Gesser
  */
 // Use <Node> to prevent Node from becoming generic.
-public abstract class Node implements Cloneable, HasParentNode<Node>, Visitable, Observable<NodeObserver> {
+public abstract class Node implements Cloneable, HasParentNode<Node>, Visitable {
     /**
      * This can be used to sort nodes on position.
      */
@@ -70,7 +69,7 @@ public abstract class Node implements Cloneable, HasParentNode<Node>, Visitable,
 
     private Comment comment;
 
-    private List<NodeObserver> observers = new ArrayList<>();
+    private List<AstObserver> observers = new ArrayList<>();
 
     public Node(Range range) {
         this.range = range;
@@ -269,6 +268,8 @@ public List<Comment> getAllContainedComments() {
      */
     @Override
     public Node setParentNode(Node parentNode) {
+        observers.forEach(o -> o.parentChange(this, this.parentNode, parentNode));
+
         // remove from old parent, if any
         if (this.parentNode != null) {
             this.parentNode.childrenNodes.remove(this);
@@ -419,12 +420,22 @@ protected <P> void notifyPropertyChange(String propertyName, P oldValue, P newVa
     }
 
     @Override
-    public void unregister(NodeObserver observer) {
+    public void unregister(AstObserver observer) {
         this.observers.remove(observer);
     }
 
     @Override
-    public void register(NodeObserver observer) {
+    public void register(AstObserver observer) {
         this.observers.add(observer);
     }
+
+    public void registerForSubtree(AstObserver observer) {
+        register(observer);
+        this.getChildNodes().forEach(c -> c.registerForSubtree(observer));
+    }
+
+    @Override
+    public boolean isRegistered(AstObserver observer) {
+        return this.observers.contains(observer);
+    }
 }

javaparser-core/src/main/java/com/github/javaparser/ast/NodeList.java

@@ -1,6 +1,5 @@
 package com.github.javaparser.ast;
 
-<<<<<<< e35fb78d58750176ee0175f27ba1b2e9c9da61d6
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -15,12 +14,9 @@
 import java.util.function.UnaryOperator;
 import java.util.stream.Stream;
 
-=======
->>>>>>> observing: create separate observers for node and nodelist
 import com.github.javaparser.HasParentNode;
+import com.github.javaparser.ast.observing.AstObserver;
 import com.github.javaparser.ast.observing.ListChangeType;
-import com.github.javaparser.ast.observing.ListObserver;
-import com.github.javaparser.ast.observing.Observable;
 import com.github.javaparser.ast.visitor.GenericVisitor;
 import com.github.javaparser.ast.visitor.Visitable;
 import com.github.javaparser.ast.visitor.VoidVisitor;
@@ -33,16 +29,12 @@
  *
  * @param <N> the type of nodes contained.
  */
-<<<<<<< e35fb78d58750176ee0175f27ba1b2e9c9da61d6
-public class NodeList<N extends Node> implements List<N>, Iterable<N>, HasParentNode<NodeList<N>>, Visitable {
-=======
-public class NodeList<N extends Node> implements Iterable<N>, HasParentNode<NodeList<N>>, Visitable, Observable<ListObserver> {
->>>>>>> observing: create separate observers for node and nodelist
+public class NodeList<N extends Node> implements List<N>, Iterable<N>, HasParentNode<NodeList<N>>, Visitable, Observable<ListObserver> {
     private List<N> innerList = new ArrayList<>(0);
 
     private Node parentNode;
 
-    private List<ListObserver> observers = new ArrayList<>();
+    private List<AstObserver> observers = new ArrayList<>();
 
     public NodeList() {
         this(null);
@@ -52,13 +44,9 @@ public NodeList(Node parent) {
         setParentNode(parent);
     }
 
-<<<<<<< e35fb78d58750176ee0175f27ba1b2e9c9da61d6
     @Override
     public boolean add(N node) {
-=======
-    public NodeList<N> add(N node) {
         notifyElementAdded(innerList.size(), node);
->>>>>>> observing: create separate observers for node and nodelist
         own(node);
         return innerList.add(node);
     }
@@ -132,19 +120,13 @@ public N set(int index, N element) {
         return innerList.set(index, element);
     }
 
-<<<<<<< e35fb78d58750176ee0175f27ba1b2e9c9da61d6
     @Override
     public N remove(int index) {
+        notifyElementRemoved(index, innerList.get(index));
         N remove = innerList.remove(index);
         if (remove != null)
             remove.setParentNode(null);
         return remove;
-=======
-    public NodeList<N> remove(int index) {
-        notifyElementRemoved(index, innerList.get(index));
-        innerList.remove(index);
-        return this;
->>>>>>> observing: create separate observers for node and nodelist
     }
 
     @Override
@@ -163,13 +145,9 @@ public void addAll(NodeList<N> otherList) {
         }
     }
 
-<<<<<<< e35fb78d58750176ee0175f27ba1b2e9c9da61d6
     @Override
     public void add(int index, N node) {
-=======
-    public NodeList<N> add(int index, N node) {
         notifyElementAdded(index, node);
->>>>>>> observing: create separate observers for node and nodelist
         own(node);
         innerList.add(index, node);
     }
@@ -207,7 +185,6 @@ public <A> void accept(final VoidVisitor<A> v, final A arg) {
         v.visit(this, arg);
     }
 
-<<<<<<< e35fb78d58750176ee0175f27ba1b2e9c9da61d6
     /**
      * @param action
      * @see java.lang.Iterable#forEach(java.util.function.Consumer)
@@ -438,7 +415,7 @@ public List<N> subList(int fromIndex, int toIndex) {
     @Override
     public Spliterator<N> spliterator() {
         return innerList.spliterator();
-=======
+
     private void notifyElementAdded(int index, Node nodeAddedOrRemoved) {
         this.observers.forEach(o -> o.listChange(this, ListChangeType.ADDITION, index, nodeAddedOrRemoved));
     }
@@ -448,14 +425,18 @@ private void notifyElementRemoved(int index, Node nodeAddedOrRemoved) {
     }
 
     @Override
-    public void unregister(ListObserver observer) {
+    public void unregister(AstObserver observer) {
         this.observers.remove(observer);
     }
 
     @Override
-    public void register(ListObserver observer) {
+    public void register(AstObserver observer) {
         this.observers.add(observer);
->>>>>>> observing: create separate observers for node and nodelist
+    }
+
+    @Override
+    public boolean isRegistered(AstObserver observer) {
+        return this.observers.contains(observer);
     }
 
 }

javaparser-core/src/main/java/com/github/javaparser/ast/observing/AstObserver.java

@@ -0,0 +1,10 @@
+package com.github.javaparser.ast.observing;
+
+import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.NodeList;
+
+public interface AstObserver {
+    void propertyChange(Node observedNode, String propertyName, Object oldValue, Object newValue);
+    void parentChange(Node observedNode, Node previousParent, Node newParent);
+    void listChange(NodeList observedNode, ListChangeType type, int index, Node nodeAddedOrRemoved);
+}

javaparser-core/src/main/java/com/github/javaparser/ast/observing/Observable.java

@@ -1,6 +1,7 @@
 package com.github.javaparser.ast.observing;
 
-public interface Observable<O> {
-    void register(O observer);
-    void unregister(O observer);
+public interface Observable {
+    void register(AstObserver observer);
+    void unregister(AstObserver observer);
+    boolean isRegistered(AstObserver observer);
 }

javaparser-core/src/main/java/com/github/javaparser/ast/observing/PropagatingAstObserver.java

@@ -0,0 +1,43 @@
+package com.github.javaparser.ast.observing;
+
+import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.NodeList;
+
+public abstract class PropagatingAstObserver implements AstObserver {
+
+    @Override
+    public void propertyChange(Node observedNode, String propertyName, Object oldValue, Object newValue) {
+        considerRemoving(oldValue);
+        considerAdding(newValue);
+        concretePropertyChange(observedNode, propertyName, oldValue, newValue);
+    }
+
+    @Override
+    public void listChange(NodeList observedNode, ListChangeType type, int index, Node nodeAddedOrRemoved) {
+        if (type == ListChangeType.REMOVAL) {
+            considerRemoving(nodeAddedOrRemoved);
+        } else if (type == ListChangeType.ADDITION) {
+            considerAdding(nodeAddedOrRemoved);
+        }
+        concreteListChange(observedNode, type, index, nodeAddedOrRemoved);
+    }
+
+    protected abstract void concretePropertyChange(Node observedNode, String propertyName, Object oldValue, Object newValue);
+
+    protected abstract void concreteListChange(NodeList observedNode, ListChangeType type, int index, Node nodeAddedOrRemoved);
+
+    private void considerRemoving(Object element) {
+        if (element instanceof Observable) {
+            if (((Observable) element).isRegistered(this)) {
+                ((Observable) element).unregister(this);
+            }
+        }
+    }
+
+    private void considerAdding(Object element) {
+        if (element instanceof Observable) {
+            ((Observable) element).register(this);
+        }
+    }
+
+}