Returns a {@link TreeModelFilter} that is accepting all nodes.

@return The new {@link TreeModelFilter}
333134
public static TreeModelFilter acceptingAll()
    {
        return new TreeModelFilter()
        {
            @Override
            public boolean acceptNode(TreeModel treeModel, TreeNode node)
            {
                return true;
            }
            
            @Override
            public String toString()
            {
                return "TreeModelFilter[acceptingAll]";
            }
        };
    }
344991
private Map<String, TreeItemIdNode> createCustomIdNodeMapping() {
		TreeItemIdNode custom = getCustomTree();
		if (custom == null) {
			return Collections.EMPTY_MAP;
		}

		Map<String, TreeItemIdNode> map = new HashMap<>();
		processCustomIdNodeMapping(map, custom);
		return Collections.unmodifiableMap(map);
	}
582344
public MethodFilter build() {
        if(filters.isEmpty()) {
            throw new IllegalStateException("No filter specified.");
        }
        if(filters.size() == 1) {
            return filters.get(0);
        }
        MethodFilter[] methodFilters = new MethodFilter[filters.size()];
        filters.toArray(methodFilters);
        return new MethodFilterList(methodFilters);
    }
586934
public TreeReaderFactory treeReaderFactory() {
    return new TreeReaderFactory() {
      public TreeReader newTreeReader(Reader in) {
        return new PennTreeReader(in, new LabeledScoredTreeFactory(), new NPTmpRetainingTreeNormalizer(englishTrain.splitTMP, englishTrain.splitSGapped == 5, englishTrain.leaveItAll, englishTrain.splitNPADV >= 1, headFinder()));
      }
    };
  }
315709
public List<FacesConfigFlowDefinitionFlowCallOutboundParameterType<FacesConfigFlowDefinitionFlowCallType<T>>> getAllOutboundParameter()
   {
      List<FacesConfigFlowDefinitionFlowCallOutboundParameterType<FacesConfigFlowDefinitionFlowCallType<T>>> list = new ArrayList<FacesConfigFlowDefinitionFlowCallOutboundParameterType<FacesConfigFlowDefinitionFlowCallType<T>>>();
      List<Node> nodeList = childNode.get("outbound-parameter");
      for(Node node: nodeList)
      {
         FacesConfigFlowDefinitionFlowCallOutboundParameterType<FacesConfigFlowDefinitionFlowCallType<T>>  type = new FacesConfigFlowDefinitionFlowCallOutboundParameterTypeImpl<FacesConfigFlowDefinitionFlowCallType<T>>(this, "outbound-parameter", childNode, node);
         list.add(type);
      }
      return list;
   }
106987
public void setFilter(TreeModelFilter filter)
    {
        this.filter = filter;
        if (this.filter == null)
        {
            this.filter = TreeModelFilters.acceptingAll();
        }
        if (root != null)
        {
            root.notifyFilterChanged();
        }
        fireTreeStructureChanged(this, new TreeNode[] { root }, null, null);
    }
13340
private Node getParentNode(Node node) {

		if (node == null || node == root)
			return null;

		Node newNode = node.getParentNode();
		if (newNode == null)
			return null;

		int accept = acceptNode(newNode);

		if (accept == NodeFilter.FILTER_ACCEPT)
			return newNode;
		else
			// if (accept == NodeFilter.SKIP_NODE)
			// and REJECT too.
			return getParentNode(newNode);

	}
344858
public FilterMappingType<WebAppType<T>> getOrCreateFilterMapping()
   {
      List<Node> nodeList = childNode.get("filter-mapping");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new FilterMappingTypeImpl<WebAppType<T>>(this, "filter-mapping", childNode, nodeList.get(0));
      }
      return createFilterMapping();
   }
113973
public static <T extends Tree> Matcher<T> inLoop() {
    return new Matcher<T>() {
      @Override
      public boolean matches(Tree tree, VisitorState state) {
        TreePath path = state.getPath().getParentPath();
        Tree node = path.getLeaf();
        while (path != null) {
          switch (node.getKind()) {
            case METHOD:
            case CLASS:
              return false;
            case WHILE_LOOP:
            case FOR_LOOP:
            case ENHANCED_FOR_LOOP:
            case DO_WHILE_LOOP:
              return true;
            default:
              path = path.getParentPath();
              node = path.getLeaf();
              break;
          }
        }
        return false;
      }
    };
  }
971665
public static List<Object> getAllNodes(TreeModel treeModel)
    {
        List<Object> result = new ArrayList<Object>();
        getAllDescendants(treeModel, treeModel.getRoot(), result);
        result.add(0, treeModel.getRoot());
        return result;
    }
924158
public JTree resetTree(TreeTableModel treeTableModel) {
        tree = new TreeTableCellRenderer(treeTableModel);

        // Install a tableModel representing the visible rows in the tree.
        super.setModel(new TreeTableModelAdapter(treeTableModel, tree));

        // Force the JTable and JTree to share their row selection models.
        ListToTreeSelectionModelWrapper selectionWrapper = new
            ListToTreeSelectionModelWrapper();
        tree.setSelectionModel(selectionWrapper);
        setSelectionModel(selectionWrapper.getListSelectionModel());

        // Make the tree and table row heights the same.
        if (tree.getRowHeight() < 1) {
            // Metal looks better like this.
            setRowHeight(18);
        }

        // Install the tree editor renderer and editor.
        setDefaultRenderer(TreeTableModel.class, tree);
        setDefaultEditor(TreeTableModel.class, new TreeTableCellEditor());
        setShowGrid(true);
        setIntercellSpacing(new Dimension(1,1));
        tree.setRootVisible(false);
        tree.setShowsRootHandles(true);
        DefaultTreeCellRenderer r = (DefaultTreeCellRenderer)tree.getCellRenderer();
        r.setOpenIcon(null);
        r.setClosedIcon(null);
        r.setLeafIcon(null);
        return tree;
    }
290529
@XmlElementDecl(namespace = "", name = "filter")
    public JAXBElement<Filter> createFilter(Filter value) {
        return new JAXBElement<Filter>(_Filter_QNAME, Filter.class, null, value);
    }
201327
@Override
	public Set<T> getAllChildNodes() {

		Set<T> allChildNodes = new HashSet();

		List<T> childNodes = treeGetChildren();

		for (final T child : childNodes) {

			allChildNodes.add(child);

			if (child instanceof LinkedTreeNode) {

				final LinkedTreeNode treeNode = (LinkedTreeNode)child;
				allChildNodes.addAll(treeNode.getAllChildNodes());
			}
		}

		return allChildNodes;
	}
230868
Stream<TreeNode> getFiltered(Stream<TreeNode> delegateNodes)
    {
        return delegateNodes
            .filter(delegateNode -> filter.acceptNode(this, delegateNode))
            .map(delegateNode -> delegateToThis.get(delegateNode))
            .filter(filteredNode -> filteredNode != null);
    }
1357126
public static Object getParent(TreeModel treeModel, Object node)
    {
        return getParent(treeModel, node, treeModel.getRoot());
    }
1317667
public final TreeModelFilter<SQLPPTriplesMap> type() throws RecognitionException {
        TreeModelFilter<SQLPPTriplesMap> value = null;


        try {
            // C:\\Project\\Obdalib\\obdalib-parent\\obdalib-core\\src\\main\\java\\it\\unibz\\inf\\obda\\gui\\swing\\utils\\MappingFilter.g:69:3: ( ID | TEXT | TARGET | SOURCE | FUNCT | PRED )
            int alt4=6;
            switch ( input.LA(1) ) {
            case ID:
                {
                alt4=1;
                }
                break;
            case TEXT:
                {
                alt4=2;
                }
                break;
            case TARGET:
                {
                alt4=3;
                }
                break;
            case SOURCE:
                {
                alt4=4;
                }
                break;
            case FUNCT:
                {
                alt4=5;
                }
                break;
            case PRED:
                {
                alt4=6;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 4, 0, input);

                throw nvae;

            }

            switch (alt4) {
                case 1 :
                    // C:\\Project\\Obdalib\\obdalib-parent\\obdalib-core\\src\\main\\java\\it\\unibz\\inf\\obda\\gui\\swing\\utils\\MappingFilter.g:69:5: ID
                    {
                    match(input,ID,FOLLOW_ID_in_type120); 

                     value = new MappingIDTreeModelFilter();

                    }
                    break;
                case 2 :
                    // C:\\Project\\Obdalib\\obdalib-parent\\obdalib-core\\src\\main\\java\\it\\unibz\\inf\\obda\\gui\\swing\\utils\\MappingFilter.g:70:5: TEXT
                    {
                    match(input,TEXT,FOLLOW_TEXT_in_type133); 

                     value = new MappingStringTreeModelFilter(); 

                    }
                    break;
                case 3 :
                    // C:\\Project\\Obdalib\\obdalib-parent\\obdalib-core\\src\\main\\java\\it\\unibz\\inf\\obda\\gui\\swing\\utils\\MappingFilter.g:71:5: TARGET
                    {
                    match(input,TARGET,FOLLOW_TARGET_in_type144); 

                     value = new MappingHeadVariableTreeModelFilter();

                    }
                    break;
                case 4 :
                    // C:\\Project\\Obdalib\\obdalib-parent\\obdalib-core\\src\\main\\java\\it\\unibz\\inf\\obda\\gui\\swing\\utils\\MappingFilter.g:72:5: SOURCE
                    {
                    match(input,SOURCE,FOLLOW_SOURCE_in_type153); 

                     value = new MappingSQLStringTreeModelFilter();

                    }
                    break;
                case 5 :
                    // C:\\Project\\Obdalib\\obdalib-parent\\obdalib-core\\src\\main\\java\\it\\unibz\\inf\\obda\\gui\\swing\\utils\\MappingFilter.g:73:5: FUNCT
                    {
                    match(input,FUNCT,FOLLOW_FUNCT_in_type162); 

                     value = new MappingFunctorTreeModelFilter();

                    }
                    break;
                case 6 :
                    // C:\\Project\\Obdalib\\obdalib-parent\\obdalib-core\\src\\main\\java\\it\\unibz\\inf\\obda\\gui\\swing\\utils\\MappingFilter.g:74:5: PRED
                    {
                    match(input,PRED,FOLLOW_PRED_in_type172); 

                     value = new MappingPredicateTreeModelFilter();

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return value;
    }
443810
public List<FacesConfigFlowDefinitionInboundParameterType<FacesConfigFlowDefinitionType<T>>> getAllInboundParameter()
   {
      List<FacesConfigFlowDefinitionInboundParameterType<FacesConfigFlowDefinitionType<T>>> list = new ArrayList<FacesConfigFlowDefinitionInboundParameterType<FacesConfigFlowDefinitionType<T>>>();
      List<Node> nodeList = childNode.get("inbound-parameter");
      for(Node node: nodeList)
      {
         FacesConfigFlowDefinitionInboundParameterType<FacesConfigFlowDefinitionType<T>>  type = new FacesConfigFlowDefinitionInboundParameterTypeImpl<FacesConfigFlowDefinitionType<T>>(this, "inbound-parameter", childNode, node);
         list.add(type);
      }
      return list;
   }