Removes all the filter join leaf nodes that were converted. Returns true if at least one node
has been removed.
423029
private boolean removeConvertedNodes(AbstractNode node) {
    boolean nodeRemoved = false;
    Iterator<AbstractNode> it = node.getChildren().iterator();
    while (it.hasNext()) {
      FilterJoinNode child = (FilterJoinNode) it.next();
      if (child.getState().equals(FilterJoinNode.State.CONVERTED)) {
        it.remove();
        nodeRemoved |= true;
      }
      else {
        nodeRemoved |= this.removeConvertedNodes(child) ? true : false;
      }
    }
    return nodeRemoved;
  }
781354
public boolean isBloomFilteringSupported() {
        if (clientVersion >= params.getProtocolVersionNum(NetworkParameters.ProtocolVersion.BLOOM_FILTER)
                && clientVersion < params.getProtocolVersionNum(NetworkParameters.ProtocolVersion.BLOOM_FILTER_BIP111))
            return true;
        if ((localServices & NODE_BLOOM) == NODE_BLOOM)
            return true;
        return false;
    }
479380
private void clearParentFilter (SiteNode parent) {
		if (parent != null) {
			parent.setFiltered(false);
			clearParentFilter(parent.getParent());
		}
	}
897966
def remove_filter(self, filter_attr):
        
        filter_attr = self._get_mapping(filter_attr)
        new_filters = []
        remove_chain = False

        for flt in self._filters:
            if isinstance(flt, tuple):
                if flt[0] == filter_attr:
                    remove_chain = True
                else:
                    new_filters.append(flt)
            else:
                # this is a ChainOperator
                if remove_chain is False:
                    new_filters.append(flt)
                else:
                    remove_chain = False

        self._filters = new_filters
537682
function() {
            if (!this.removed) {
                this.removed = true;

                if (_CSGDEBUG) {
                    if (this.isRootNode()) throw new Error("Assertion failed"); // can't remove root node
                    if (this.children.length) throw new Error("Assertion failed"); // we shouldn't remove nodes with children
                }

                // remove ourselves from the parent's children list:
                var parentschildren = this.parent.children;
                var i = parentschildren.indexOf(this);
                if (i < 0) throw new Error("Assertion failed");
                parentschildren.splice(i, 1);

                // invalidate the parent's polygon, and of all parents above it:
                this.parent.recursivelyInvalidatePolygon();
            }
        }
1001294
public boolean removeAfter(Node node) {

        if (node == null || node.next == null) {
            return false;
        }

        if (node.next == last) {
            last = node;
        }

        node.next = node.next.next;

        return true;
    }
875720
function () {
					oNodeForContext.nodeState.removed = false;
					var iNodeStateFound = that._aRemoved.indexOf(oNodeForContext);
					if (iNodeStateFound != -1) {
						that._aRemoved.splice(iNodeStateFound, 1);
					}
					// clear cache to make sure findNode etc. don't deliver wrong nodes (index is shifted due to adding)
					this._aNodeCache = [];
					that._cleanTreeStateMaps();
					that._fireChange({reason: ChangeReason.Add});
				}
245705
def remove_all(self):
        ''''''
        if self._children:
            for child in self._children:
                if isinstance(child, String):
                    child._parent = None
            self._children = []
211770
public OperationFuture<List<Server>> removeSecondaryNetwork(ServerFilter filter, Network network) {
        return removeSecondaryNetwork(Arrays.asList(getRefsFromFilter(filter)), network);
    }
156932
def filter(self, query: str) -> Optional['CompatNodeIterator']:
        
        if not self._last_node:
            return None

        return filter(self._last_node, query)
1122402
private final V remove_semi_leaf(BinTreeNode<K,V> node, BinTreeNode<K,V> prev,
				     int son, BinTreeNode<K,V> m) {
	if(prev == null) {
	    root = m;
	}
	else {
	    if(son == 0)
		prev.left = m;
	    else
		prev.right = m;
	}

	return node.value;
    }
48656
def clear_all(node=nil)
      if node.nil?
        node = @root_node
        delete_node_storage node
      end

      return if node == BLANK_NODE

      node_type = get_node_type node
      delete_node_storage node

      if NODE_KV_TYPE.include?(node_type)
        value_is_node = node_type == :extension
        clear_all decode_to_node(node[1]) if value_is_node
      elsif node_type == :branch
        16.times do |i|
          clear_all decode_to_node(node[i])
        end
      end
    end
210182
public boolean deleteDataNode(DataNode node) {
    try {
      rwLock.writeLock().lock();
      if (!dataNodeMap.containsKey(node.getId())) {
        return false;
      }
      //Delete node from dataNodeMap
      dataNodeMap.remove(node.getId());

      //Delete all the edges adjacent to the node. First, delete edges from flowEdgeMap and next, remove the edges
      // from nodesToEdges
      for (FlowEdge edge : nodesToEdges.get(node)) {
        flowEdgeMap.remove(edge.getId());
      }
      nodesToEdges.remove(node);
      return true;

    } finally {
      rwLock.writeLock().unlock();
    }
  }
813453
def remove(self, *args):
        '''
        
        '''
        return Plan(reduce(lambda m,k: m.remove(k), args, self.nodes))
359161
def remove_pattern(self, pattern):
        

        for index, node in enumerate(self.root_node.children):
            if node.name != pattern:
                continue

            LOGGER.debug("> Removing '{0}' at '{1}' index.".format(pattern, index))

            self.beginRemoveRows(self.get_node_index(self.root_node), index, index)
            pattern_node = self.root_node.child(index)
            self.root_node.remove_child(index)
            self.endRemoveRows()
            self.pattern_removed.emit(pattern_node)
            return True
1173231
def remove_certain_leaves(tr, to_remove=lambda node: False):
    

    tips = [tip for tip in tr if to_remove(tip)]
    for node in tips:
        if node.is_root():
            return None
        parent = node.up
        parent.remove_child(node)
        # If the parent node has only one child now, merge them.
        if len(parent.children) == 1:
            brother = parent.children[0]
            brother.dist += parent.dist
            if parent.is_root():
                brother.up = None
                tr = brother
            else:
                grandparent = parent.up
                grandparent.remove_child(parent)
                grandparent.add_child(brother)
    return tr
907983
def clear_filters
      self.current_filter = {exclude: {actions: [], verbs: [], names: [], controllers: []},
                              include: {actions: [], verbs: [], names: [], controllers: []}}
      return nil
    end