system/src/sc/parser/NestedParselet.java
protected void invalidateChildElement(ParentParseNode pnode, Parselet childParselet, Object semanticValue, Object element, int parseNodeIx, ChangeType changeType) {
      ISemanticNode sv = (ISemanticNode) element;
      Object childParseNode = sv.getParseNode();

      if (childParseNode != null) {
         // This node could have been moved from one place to another.  In that case, we can't use the old node as the parselet is wrong and that will
         // mess up the regeneration.
         if (childParseNode instanceof IParseNode) {
            if (!childParselet.producesParselet(((IParseNode) childParseNode).getParselet()))
               //if (((IParseNode) childParseNode).getParselet() != childParselet)
               childParseNode = null;
         }
      }
      if (childParseNode == null) {
         childParseNode = childParselet.newGeneratedParseNode(sv);
         sv.setParseNodeValid(false);
      }
      updateElement(pnode, childParseNode, element, parseNodeIx, changeType);
   }
/*
   protected void invalidateChildElements(ParentParseNode pnode, Parselet childParselet, List parentValue, List elements, int parseNodeIx, ChangeType changeType) {
      for (int i = 0; i < elements.size(); i++) {
         // And since we are regenerating the entire element, we'll invalidate the entire sequence
         // TODO: change this so it actually invalidates the child, inserting it into the parent's parsenode if necessary.
         ISemanticNode sv = (ISemanticNode) elements.get(i);
         sv.invalidateParseNode();
         Object childParseNode = sv.getParseNode();
         if (childParseNode != null) {
            // This node could have been moved from one place to another.  In that case, we can't use the old node as the parselet is wrong and that will
            // mess up the regeneration.
            if (childParseNode instanceof IParseNode) {
               if (((IParseNode) childParseNode).getParselet() != this)
                  childParseNode = null;
            }
         }
         if (childParseNode == null) {
            childParseNode = childParselet.newGeneratedParseNode(parentValue);
         }
         updateElement(pnode, childParseNode, sv, parseNodeIx, changeType);
      }
   }
   */
protected void invalidateChildElements(ParentParseNode pnode, Parselet childParselet, List parentValue, List elements, int parseNodeIx, ChangeType changeType) {
for (int i = 0; i < elements.size(); i++) {
And since we are regenerating the entire element, we'll invalidate the entire sequence
TODO: change this so it actually invalidates the child, inserting it into the parent's parsenode if necessary.
ISemanticNode sv = (ISemanticNode) elements.get(i);
sv.invalidateParseNode();
Object childParseNode = sv.getParseNode();
if (childParseNode != null) {
This node could have been moved from one place to another.  In that case, we can't use the old node as the parselet is wrong and that will
mess up the regeneration.
protected void invalidateChildElements ( ParentParseNode pnode Parselet childParselet List parentValue List elements int parseNodeIx ChangeType changeType ) { for ( int i = 0 ; i < elements . size () ; i ++ ) { And since we are regenerating the entire element we ' ll invalidate the entire sequence TODO : change this so it actually invalidates the child inserting it into the parent ' s parsenode if necessary . ISemanticNode sv = ( ISemanticNode ) elements . get ( i ) ; sv . invalidateParseNode () ; Object childParseNode = sv . getParseNode () ; if ( childParseNode ! = null ) { This node could have been moved from one place to another . In that case we can ' t use the old node as the parselet is wrong and that will mess up the regeneration .
protected void invalidateChildElement(ParentParseNode pnode, Parselet childParselet, Object semanticValue, Object element, int parseNodeIx, ChangeType changeType) {
      ISemanticNode sv = (ISemanticNode) element;
      Object childParseNode = sv.getParseNode();
      if (childParseNode != null) {
         if (childParseNode instanceof IParseNode) {
            if (!childParselet.producesParselet(((IParseNode) childParseNode).getParselet()))
               childParseNode = null;
         }
      }
      if (childParseNode == null) {
         childParseNode = childParselet.newGeneratedParseNode(sv);
         sv.setParseNodeValid(false);
      }
      updateElement(pnode, childParseNode, element, parseNodeIx, changeType);
   }
protected void invalidateChildElement ( ParentParseNode pnode , Parselet childParselet , Object semanticValue , Object element , int parseNodeIx , ChangeType changeType ) { ISemanticNode sv = ( ISemanticNode ) element ; Object childParseNode = sv . getParseNode ( ) ; if ( childParseNode != null ) { if ( childParseNode instanceof IParseNode ) { if ( ! childParselet . producesParselet ( ( ( IParseNode ) childParseNode ) . getParselet ( ) ) ) childParseNode = null ; } } if ( childParseNode == null ) { childParseNode = childParselet . newGeneratedParseNode ( sv ) ; sv . setParseNodeValid ( false ) ; } updateElement ( pnode , childParseNode , element , parseNodeIx , changeType ) ; }
protected void invalidateChildElements(ParentParseNode pnode, Parselet childParselet, List parentValue, List elements, int parseNodeIx, ChangeType changeType) {
for (int i = 0; i < elements.size(); i++) {
 And since we are regenerating the entire element, we'll invalidate the entire sequence
 TODO: change this so it actually invalidates the child, inserting it into the parent's parsenode if necessary.
protected void invalidateChildElements ( ParentParseNode pnode Parselet childParselet List parentValue List elements int parseNodeIx ChangeType changeType ) { for ( int i = 0 ; i < elements . size () ; i ++ ) { And since we are regenerating the entire element we ' ll invalidate the entire sequence TODO : change this so it actually invalidates the child inserting it into the parent ' s parsenode if necessary .
// This node could have been moved from one place to another.  In that case, we can't use the old node as the parselet is wrong and that will // mess up the regeneration. //if (((IParseNode) childParseNode).getParselet() != childParselet)