Traverses the concepts' descendants, setting isOpen = false as it goes.
506262
function closeDescendants(concept) {
  concept.isOpen = false;
  concept.items.forEach(child => {
    if (child.items) {
      closeDescendants(child);
    }
  });
}
595263
private void revisitGateways(Definitions def) {
        List<RootElement> rootElements = def.getRootElements();
        for (RootElement root : rootElements) {
            if (root instanceof Process) {
                setGatewayInfo((Process) root);
            }
        }
    }
517832
private void checkAtLeast(int i) throws ContradictionException {
		ISet pot = target.getPotSet(g, i);
		ISet ker = target.getMandSet(g, i);
		int potSize = pot.size();
		if (potSize < degrees[i]) {
			g.removeNode(i, this);
		} else if (potSize == degrees[i] && g.getMandatoryNodes().contains(i) && ker.size() < potSize) {
			for (int s : pot) {
				target.enforce(g, i, s, this);
			}
		}
	}
1364805
@Override
    protected void propagateAcrossPhiNode(TypeQualifierValueSet fact, ValueNumber sourceVN, ValueNumber targetVN) {
        // Backwards analysis - propagate value from target to source
        fact.propagateAcrossPhiNode(targetVN, sourceVN);
    }
438310
def visit_set(self, node, parent):
        """"""
        newnode = nodes.Set(node.lineno, node.col_offset, parent)
        newnode.postinit([self.visit(child, newnode) for child in node.elts])
        return newnode
950457
def visit_if(self, node, parent):
        """"""
        newnode = nodes.If(node.lineno, node.col_offset, parent)
        newnode.postinit(
            self.visit(node.test, newnode),
            [self.visit(child, newnode) for child in node.body],
            [self.visit(child, newnode) for child in node.orelse],
        )
        return newnode
1060939
public void setOpen(boolean isOpen) {

        m_opener.setStyleOpen(isOpen);
        m_children.setVisible(isOpen);
        m_isOpen = isOpen;
    }
183250
private static boolean peek(ListIterator<Segment> segments, SegmentKind... kinds) {
    int start = segments.nextIndex();
    boolean success = false;
    for (SegmentKind kind : kinds) {
      if (!segments.hasNext() || segments.next().kind() != kind) {
        success = false;
        break;
      }
    }
    if (success) {
      return true;
    }
    restore(segments, start);
    return false;
  }
388939
public boolean goForward() {
	if (currentNode.hasChildren()) {
	    currentNode = currentNode.getChildren().get(0);
	    return true;
	} else if (currentNode.getParent() == null) {
	    return false;
	}
	while (true) {
	    N parent = currentNode.getParent();
	    if ((parent == null) || (currentNode == tree)) {
		return false;
	    }
	    int index = parent.getChildren().indexOf(currentNode);
	    if (parent.getChildren().size() > index + 1) {
		currentNode = parent.getChildren().get(index + 1);
		return true;
	    } else {
		currentNode = parent;
	    }
	}
    }
1208314
function isOrContains(container, node)
			{
			    while (node != null)
			    {
			        if (node === container)
			        {
			            return true;
			        }
			        
			        node = node.parentNode;
			    }
			    
			    return false;
			}
529798
def descendant_or_self( path_stack, nodeset )
      rs = []
      #puts "#"*80
      #puts "PATH_STACK = #{path_stack.inspect}"
      #puts "NODESET = #{nodeset.collect{|n|n.inspect}.inspect}"
      d_o_s( path_stack, nodeset, rs )
      #puts "RS = #{rs.collect{|n|n.inspect}.inspect}"
      document_order(rs.flatten.compact)
      #rs.flatten.compact
    end
406527
private Entry setParent(Entry entry, Entry parent) {
        unlinkFromNeighbors(entry);
        entry.oParent = parent;
        parent.oFirstChild = mergeLists(entry, parent.oFirstChild);
        parent.degree++;
        entry.isMarked = false;

        return parent;
    }
676514
private void traverseClassMembers(Node n) {
    for (Node child = n.getFirstChild(); child != null;) {
      Node next = child.getNext(); // see traverseChildren
      if (child.isComputedProp()) {
        curNode = n;
        if (callback.shouldTraverse(this, child, n)) {
          traverseBranch(child.getLastChild(), child);
          curNode = n;
          callback.visit(this, child, n);
        }
      } else {
        traverseBranch(child, n);
      }
      child = next;
    }
  }
801537
@Override
	public void propagate(int evt) throws ContradictionException {
		g.enforceNode(root, this);
		// explore the graph from the root
		explore();
		// remove unreachable nodes
		for (int o = visited.nextClearBit(0); o < n; o = visited.nextClearBit(o + 1)) {
			g.removeNode(o, this);
		}
		super.propagate(evt);
	}
1215190
@Override
	public void propagate(int evtmask) throws ContradictionException {
		int min = 0;
		int max = 0;
		ISet nodes = g.getPotentialNodes();
		for (int i : nodes) {
			if (g.getMandSuccOrNeighOf(i).contains(i)) {
				min++;
				max++;
			} else if (g.getPotSuccOrNeighOf(i).contains(i)) {
				max++;
			}
		}
		k.updateLowerBound(min, this);
		k.updateUpperBound(max, this);
		if (min == max) {
			setPassive();
		} else if (k.isInstantiated()) {
			if (k.getValue() == max) {
				for (int i : nodes) {
					if (g.getPotSuccOrNeighOf(i).contains(i)) {
						g.enforceArc(i, i, this);
					}
				}
				setPassive();
			} else if (k.getValue() == min) {
				for (int i : nodes) {
					if (!g.getMandSuccOrNeighOf(i).contains(i)) {
						g.removeArc(i, i, this);
					}
				}
				setPassive();
			}
		}
	}
663681
def iter_descendants(self, strategy="levelorder", is_leaf_fn=None):
        
        for n in self.traverse(strategy=strategy, is_leaf_fn=is_leaf_fn):
            if n is not self:
                yield n
591134
public function setEof()
    {
        $this->parentBoundaryFound = true;
        if ($this->parent !== null) {
            $this->parent->parentBoundaryFound = true;
        }
    }