/** * Reports that the given node has just been cloned. * * @param node the node that was cloned * @param clone the clone of <code>node</code> * @since 3.0 */ void postCloneNodeEvent(ASTNode node, ASTNode clone) { synchronized (this.internalASTLock) { // guard against concurrent access by a reader doing lazy init if (this.disableEvents > 0) { // doing lazy init OR already processing an event // System.out.println("[BOUNCE CLONE]"); return; } else { disableEvents(); } } try { this.eventHandler.postCloneNodeEvent(node, clone); // N.B. even if event handler blows up, the AST is not // corrupted since node has already been changed } finally { reenableEvents(); } }
/** * Reports that the given node jsut lost a child. * * @param node the node that was modified * @param child the child node that was removed * @param property the child or child list property descriptor * @since 3.0 */ void postRemoveChildEvent(ASTNode node, ASTNode child, StructuralPropertyDescriptor property) { // IMPORTANT: this method is called by readers during lazy init synchronized (this.internalASTLock) { // guard against concurrent access by a reader doing lazy init if (this.disableEvents > 0) { // doing lazy init OR already processing an event // System.out.println("[BOUNCE DEL]"); return; } else { disableEvents(); } } try { this.eventHandler.postRemoveChildEvent(node, child, property); // N.B. even if event handler blows up, the AST is not // corrupted since node has not been changed yet } finally { reenableEvents(); } }
/** * Reports that the given node has just had a child replaced. * * @param node the node modified * @param child the child removed * @param newChild the replacement child * @param property the child or child list property descriptor * @since 3.0 */ void postReplaceChildEvent(ASTNode node, ASTNode child, ASTNode newChild, StructuralPropertyDescriptor property) { // IMPORTANT: this method is called by readers during lazy init synchronized (this.internalASTLock) { // guard against concurrent access by a reader doing lazy init if (this.disableEvents > 0) { // doing lazy init OR already processing an event // System.out.println("[BOUNCE REP]"); return; } else { disableEvents(); } } try { this.eventHandler.postReplaceChildEvent(node, child, newChild, property); // N.B. even if event handler blows up, the AST is not // corrupted since node has not been changed yet } finally { reenableEvents(); } }
/** * Reports that the given node is about to be cloned. * * @param node the node to be cloned * @since 3.0 */ void preCloneNodeEvent(ASTNode node) { synchronized (this.internalASTLock) { // guard against concurrent access by a reader doing lazy init if (this.disableEvents > 0) { // doing lazy init OR already processing an event // System.out.println("[BOUNCE CLONE]"); return; } else { disableEvents(); } } try { this.eventHandler.preCloneNodeEvent(node); // N.B. even if event handler blows up, the AST is not // corrupted since node has already been changed } finally { reenableEvents(); } }
/** * Reports that the given node is about to change the value of a * non-child property. * * @param node the node to be modified * @param property the property descriptor * @since 3.0 */ void preValueChangeEvent(ASTNode node, SimplePropertyDescriptor property) { // IMPORTANT: this method is called by readers during lazy init synchronized (this.internalASTLock) { // guard against concurrent access by a reader doing lazy init if (this.disableEvents > 0) { // doing lazy init OR already processing an event // System.out.println("[BOUNCE CHANGE]"); return; } else { disableEvents(); } } try { this.eventHandler.preValueChangeEvent(node, property); // N.B. even if event handler blows up, the AST is not // corrupted since node has already been changed } finally { reenableEvents(); } }
/** * Reports that the given node has just changed the value of a * non-child property. * * @param node the node that was modified * @param property the property descriptor * @since 3.0 */ void postValueChangeEvent(ASTNode node, SimplePropertyDescriptor property) { // IMPORTANT: this method is called by readers during lazy init synchronized (this.internalASTLock) { // guard against concurrent access by a reader doing lazy init if (this.disableEvents > 0) { // doing lazy init OR already processing an event // System.out.println("[BOUNCE CHANGE]"); return; } else { disableEvents(); } } try { this.eventHandler.postValueChangeEvent(node, property); // N.B. even if event handler blows up, the AST is not // corrupted since node has already been changed } finally { reenableEvents(); } }
/** * Reports that the given node is about to gain a child. * * @param node the node that to be modified * @param child the node that to be added as a child * @param property the child or child list property descriptor * @since 3.0 */ void preAddChildEvent(ASTNode node, ASTNode child, StructuralPropertyDescriptor property) { // IMPORTANT: this method is called by readers during lazy init synchronized (this.internalASTLock) { // guard against concurrent access by a reader doing lazy init if (this.disableEvents > 0) { // doing lazy init OR already processing an event // System.out.println("[BOUNCE ADD]"); return; } else { disableEvents(); } } try { this.eventHandler.preAddChildEvent(node, child, property); // N.B. even if event handler blows up, the AST is not // corrupted since node has already been changed } finally { reenableEvents(); } }
/** * Reports that the given node is about to lose a child. * * @param node the node about to be modified * @param child the node about to be removed * @param property the child or child list property descriptor * @since 3.0 */ void preRemoveChildEvent(ASTNode node, ASTNode child, StructuralPropertyDescriptor property) { // IMPORTANT: this method is called by readers during lazy init synchronized (this.internalASTLock) { // guard against concurrent access by a reader doing lazy init if (this.disableEvents > 0) { // doing lazy init OR already processing an event // System.out.println("[BOUNCE DEL]"); return; } else { disableEvents(); } } try { this.eventHandler.preRemoveChildEvent(node, child, property); // N.B. even if event handler blows up, the AST is not // corrupted since node has not been changed yet } finally { reenableEvents(); } }
/** * Reports that the given node has just gained a child. * * @param node the node that was modified * @param child the node that was added as a child * @param property the child or child list property descriptor * @since 3.0 */ void postAddChildEvent(ASTNode node, ASTNode child, StructuralPropertyDescriptor property) { // IMPORTANT: this method is called by readers during lazy init synchronized (this.internalASTLock) { // guard against concurrent access by a reader doing lazy init if (this.disableEvents > 0) { // doing lazy init OR already processing an event // System.out.println("[BOUNCE ADD]"); return; } else { disableEvents(); } } try { this.eventHandler.postAddChildEvent(node, child, property); // N.B. even if event handler blows up, the AST is not // corrupted since node has already been changed } finally { reenableEvents(); } }
/** * Reports that the given node is about have a child replaced. * * @param node the node about to be modified * @param child the child node about to be removed * @param newChild the replacement child * @param property the child or child list property descriptor * @since 3.0 */ void preReplaceChildEvent(ASTNode node, ASTNode child, ASTNode newChild, StructuralPropertyDescriptor property) { // IMPORTANT: this method is called by readers during lazy init synchronized (this.internalASTLock) { // guard against concurrent access by a reader doing lazy init if (this.disableEvents > 0) { // doing lazy init OR already processing an event // System.out.println("[BOUNCE REP]"); return; } else { disableEvents(); } } try { this.eventHandler.preReplaceChildEvent(node, child, newChild, property); // N.B. even if event handler blows up, the AST is not // corrupted since node has not been changed yet } finally { reenableEvents(); } }
/** * Reports that the given node is about to be cloned. * * @param node the node to be cloned * @since 3.0 */ void preCloneNodeEvent(ASTNode node) { synchronized (this.internalASTLock) { // guard against concurrent access by a reader doing lazy init if (this.disableEvents > 0) { // doing lazy init OR already processing an event // System.out.println("[BOUNCE CLONE]"); return; } else { disableEvents(); } } try { this.eventHandler.preCloneNodeEvent(node); // N.B. even if event handler blows up, the AST is not // corrupted since node has already been changed } finally { reenableEvents(); } }
/** * Reports that the given node is about to change the value of a * non-child property. * * @param node the node to be modified * @param property the property descriptor * @since 3.0 */ void preValueChangeEvent(ASTNode node, SimplePropertyDescriptor property) { // IMPORTANT: this method is called by readers during lazy init synchronized (this.internalASTLock) { // guard against concurrent access by a reader doing lazy init if (this.disableEvents > 0) { // doing lazy init OR already processing an event // System.out.println("[BOUNCE CHANGE]"); return; } else { disableEvents(); } } try { this.eventHandler.preValueChangeEvent(node, property); // N.B. even if event handler blows up, the AST is not // corrupted since node has already been changed } finally { reenableEvents(); } }
/** * Reports that the given node has just changed the value of a * non-child property. * * @param node the node that was modified * @param property the property descriptor * @since 3.0 */ void postValueChangeEvent(ASTNode node, SimplePropertyDescriptor property) { // IMPORTANT: this method is called by readers during lazy init synchronized (this.internalASTLock) { // guard against concurrent access by a reader doing lazy init if (this.disableEvents > 0) { // doing lazy init OR already processing an event // System.out.println("[BOUNCE CHANGE]"); return; } else { disableEvents(); } } try { this.eventHandler.postValueChangeEvent(node, property); // N.B. even if event handler blows up, the AST is not // corrupted since node has already been changed } finally { reenableEvents(); } }
/** * Reports that the given node is about to gain a child. * * @param node the node that to be modified * @param child the node that to be added as a child * @param property the child or child list property descriptor * @since 3.0 */ void preAddChildEvent(ASTNode node, ASTNode child, StructuralPropertyDescriptor property) { // IMPORTANT: this method is called by readers during lazy init synchronized (this.internalASTLock) { // guard against concurrent access by a reader doing lazy init if (this.disableEvents > 0) { // doing lazy init OR already processing an event // System.out.println("[BOUNCE ADD]"); return; } else { disableEvents(); } } try { this.eventHandler.preAddChildEvent(node, child, property); // N.B. even if event handler blows up, the AST is not // corrupted since node has already been changed } finally { reenableEvents(); } }
/** * Reports that the given node is about to lose a child. * * @param node the node about to be modified * @param child the node about to be removed * @param property the child or child list property descriptor * @since 3.0 */ void preRemoveChildEvent(ASTNode node, ASTNode child, StructuralPropertyDescriptor property) { // IMPORTANT: this method is called by readers during lazy init synchronized (this.internalASTLock) { // guard against concurrent access by a reader doing lazy init if (this.disableEvents > 0) { // doing lazy init OR already processing an event // System.out.println("[BOUNCE DEL]"); return; } else { disableEvents(); } } try { this.eventHandler.preRemoveChildEvent(node, child, property); // N.B. even if event handler blows up, the AST is not // corrupted since node has not been changed yet } finally { reenableEvents(); } }
/** * Reports that the given node has just gained a child. * * @param node the node that was modified * @param child the node that was added as a child * @param property the child or child list property descriptor * @since 3.0 */ void postAddChildEvent(ASTNode node, ASTNode child, StructuralPropertyDescriptor property) { // IMPORTANT: this method is called by readers during lazy init synchronized (this.internalASTLock) { // guard against concurrent access by a reader doing lazy init if (this.disableEvents > 0) { // doing lazy init OR already processing an event // System.out.println("[BOUNCE ADD]"); return; } else { disableEvents(); } } try { this.eventHandler.postAddChildEvent(node, child, property); // N.B. even if event handler blows up, the AST is not // corrupted since node has already been changed } finally { reenableEvents(); } }
/** * Reports that the given node is about have a child replaced. * * @param node the node about to be modified * @param child the child node about to be removed * @param newChild the replacement child * @param property the child or child list property descriptor * @since 3.0 */ void preReplaceChildEvent(ASTNode node, ASTNode child, ASTNode newChild, StructuralPropertyDescriptor property) { // IMPORTANT: this method is called by readers during lazy init synchronized (this.internalASTLock) { // guard against concurrent access by a reader doing lazy init if (this.disableEvents > 0) { // doing lazy init OR already processing an event // System.out.println("[BOUNCE REP]"); return; } else { disableEvents(); } } try { this.eventHandler.preReplaceChildEvent(node, child, newChild, property); // N.B. even if event handler blows up, the AST is not // corrupted since node has not been changed yet } finally { reenableEvents(); } }
/** * Reports that the given node is about to be cloned. * * @param node the node to be cloned * @since 3.0 */ void preCloneNodeEvent(ASTNode node) { synchronized (this.internalASTLock) { // guard against concurrent access by a reader doing lazy init if (this.disableEvents > 0) { // doing lazy init OR already processing an event // System.out.println("[BOUNCE CLONE]"); return; } else { disableEvents(); } } try { this.eventHandler.preCloneNodeEvent(node); // N.B. even if event handler blows up, the AST is not // corrupted since node has already been changed } finally { reenableEvents(); } }
/** * Reports that the given node is about to change the value of a * non-child property. * * @param node the node to be modified * @param property the property descriptor * @since 3.0 */ void preValueChangeEvent(ASTNode node, SimplePropertyDescriptor property) { // IMPORTANT: this method is called by readers during lazy init synchronized (this.internalASTLock) { // guard against concurrent access by a reader doing lazy init if (this.disableEvents > 0) { // doing lazy init OR already processing an event // System.out.println("[BOUNCE CHANGE]"); return; } else { disableEvents(); } } try { this.eventHandler.preValueChangeEvent(node, property); // N.B. even if event handler blows up, the AST is not // corrupted since node has already been changed } finally { reenableEvents(); } }
/** * Reports that the given node has just changed the value of a * non-child property. * * @param node the node that was modified * @param property the property descriptor * @since 3.0 */ void postValueChangeEvent(ASTNode node, SimplePropertyDescriptor property) { // IMPORTANT: this method is called by readers during lazy init synchronized (this.internalASTLock) { // guard against concurrent access by a reader doing lazy init if (this.disableEvents > 0) { // doing lazy init OR already processing an event // System.out.println("[BOUNCE CHANGE]"); return; } else { disableEvents(); } } try { this.eventHandler.postValueChangeEvent(node, property); // N.B. even if event handler blows up, the AST is not // corrupted since node has already been changed } finally { reenableEvents(); } }