Complete for Java types.

@param context the completion context.
@param filter the filter for the types.
@param acceptor the proposal acceptor.
324018
protected void completeJavaTypes(ContentAssistContext context,
			ITypesProposalProvider.Filter filter, ICompletionProposalAcceptor acceptor) {
		completeJavaTypes(context,
				TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__TYPE,
				true,
				getQualifiedNameValueConverter(),
				filter,
				acceptor);
	}
219275
@Override
    public boolean accepts(Item item, List<Item> acceptedItems, List<Item> rejectedItems,
                           boolean runningBeforeProcessing) {
        boolean accepted = true;

        if (CollectionUtils.isNotEmpty(filters)) {
            for (Iterator<ItemFilter> filterIter = filters.iterator(); accepted && filterIter.hasNext();) {
                ItemFilter filter = filterIter.next();
                if (runningBeforeProcessing && filter.runBeforeProcessing()) {
                    accepted = filter.accepts(item, acceptedItems, rejectedItems, runningBeforeProcessing);
                } else if (!runningBeforeProcessing && filter.runAfterProcessing()) {
                    accepted = filter.accepts(item, acceptedItems, rejectedItems, runningBeforeProcessing);
                }
            }
        }

        return accepted;
    }
817005
@Fix(IssueCodes.OVERRIDDEN_FINAL)
	public void fixOverriddenFinal(Issue issue, IssueResolutionAcceptor acceptor) {
		final MultiModification modifications = new MultiModification(
				this, issue, acceptor,
				Messages.SARLQuickfixProvider_0,
				Messages.SARLQuickfixProvider_1);
		modifications.bind(XtendTypeDeclaration.class, SuperTypeRemoveModification.class);
		modifications.bind(XtendMember.class, MemberRemoveModification.class);
	}
250415
public void complete() throws CompletionFailure {
        if (completer != Completer.NULL_COMPLETER) {
            Completer c = completer;
            completer = Completer.NULL_COMPLETER;
            c.complete(this);
        }
    }
521344
public static void accept(SARLQuickfixProvider provider, Issue issue, IssueResolutionAcceptor acceptor) {
		final CapacityReferenceRemoveModification modification = new CapacityReferenceRemoveModification();
		modification.setIssue(issue);
		modification.setTools(provider);
		acceptor.accept(issue,
				Messages.SARLQuickfixProvider_0,
				Messages.SARLQuickfixProvider_5,
				JavaPluginImages.IMG_CORRECTION_REMOVE,
				modification,
				IProposalRelevance.REMOVE_ARGUMENTS);
	}
1248978
private void add(ClassFilter filter) {
        switch(operator) {
        case NOT:
            filters.add(new NegationClassFilter(filter));
            operator = Operator.NONE;
            break;
        case OR:
            filters.set(filters.size() - 1, 
                        new OrClassFilter(filters.get(filters.size() - 1), filter));
            operator = Operator.NONE;
            break;
        default:
            filters.add(filter);
            break;
        }
    }
1096067
public VaadinForHeroku withFilterDefinition(final FilterDefinitionBuilder... filterDefs){
        checkVarArgsArguments(filterDefs);
        this.filterDefinitions.addAll(Arrays.asList(filterDefs));
        return self();
    }
212262
public void before(String path, String acceptType, Filter filter) {
        addFilter(HttpMethod.before, FilterImpl.create(path, acceptType, filter));
    }
384431
@Override
	protected void processFeatureNames(QualifiedName name, NameAcceptor acceptor) {
		QualifiedName methodName = operatorMapping == null? null : operatorMapping.getMethodName(name);
		if (methodName != null) {
			acceptor.accept(methodName.toString(), 2);
			QualifiedName simpleOperator = operatorMapping.getSimpleOperator(name);
			if (simpleOperator != null) {
				QualifiedName simpleMethodName = operatorMapping.getMethodName(simpleOperator);
				if (simpleMethodName != null) {
					acceptor.accept(simpleMethodName.toString(), 3);
				}
			}
		} else {
			acceptor.accept(name.toString(), 1);
			processAsPropertyNames(name, acceptor);
		}
	}
354269
public void addFilter(Filter filter) {
		List<Filter> filters = filterFactory.getAllFilter();
		
		int index = searchFilterIndex(filters, filter.getId(), 0, filters.size());
		
		if (index == -1) {
			// not found - put at the end
			filters.add(filter);
		} else {
			filters.add(index, filter);
		}
	}
126464
@Override
    protected <R, C> R accept(AstVisitor<R, C> visitor, C context)
    {
        return visitor.visitExpression(this, context);
    }
466384
public List<CompletionItem> resolve(String filter, int startOffset, int caretOffset) {
    final Set<ElementHandle<TypeElement>> result = classpath.getClassIndex().getDeclaredTypes("",
            ClassIndex.NameKind.PREFIX, EnumSet.of(ClassIndex.SearchScope.SOURCE));
    List<CompletionItem> ret = new ArrayList<>();

    for (ElementHandle<TypeElement> te : result) {
      if (te.getKind().isClass()) {
        String binaryName = te.getBinaryName();
        if (!StringUtils.equals(binaryName, "") && StringUtils.startsWith(binaryName, filter)) {
          ret.add(new BasicCompletionItem(te.getBinaryName(), false, startOffset, caretOffset));
        }
      }
    }
    return ret;
  }
1273147
@Override
    public boolean accept(final DependencyNode node, List<DependencyNode> parents) {
        Dependency dependency = node.getDependency();

        if (dependency == null) {
            return false;
        }

        List<MavenDependency> ancestors = new ArrayList<MavenDependency>();
        for (DependencyNode parent : parents) {
            Dependency parentDependency = parent.getDependency();
            if (parentDependency != null) {
                ancestors.add(MavenConverter.fromDependency(parentDependency));
            }
        }

        if (log.isLoggable(Level.FINER)) {
            log.log(Level.FINER, "Filtering {0} using {1} filters", new Object[] { dependency, filters.length });
        }

        for (final MavenResolutionFilter filter : filters) {
            if (!filter.accepts(MavenConverter.fromDependency(dependency), dependenciesForResolution, ancestors)) {
                if (log.isLoggable(Level.FINER)) {
                    log.log(Level.FINER, "Dependency {0} rejected by {1}", new Object[] { dependency, filter });
                }
                return false;
            }
        }

        // All filters passed
        if (log.isLoggable(Level.FINER)) {
            log.log(Level.FINER, "Dependency {0} was accepted.", dependency);
        }
        return true;
    }
341747
public static void accept(SARLQuickfixProvider provider, Issue issue, IssueResolutionAcceptor acceptor) {
		for (final String newName : issue.getData()) {
			final String msg = MessageFormat.format(
					Messages.SARLQuickfixProvider_11,
					newName);
			final MemberRenameModification modification = new MemberRenameModification(newName);
			modification.setIssue(issue);
			modification.setTools(provider);
			acceptor.accept(issue,
					msg,
					MessageFormat.format(Messages.SARLQuickfixProvider_12, newName),
					JavaPluginImages.IMG_CORRECTION_RENAME,
					modification,
					IProposalRelevance.RENAME_REFACTORING);
		}
	}
915640
function( filter, context ) {
			context = this.getFilterContext( context );

			// Apply the root filter.
			filter.onRoot( context, this );

			this.filterChildren( filter, false, context );
		}
848239
private void commitContexts(boolean accept, boolean all) {
        Stack<IManagedContext<?>> stack = commitStack;
        commitStack = new Stack<>();
        // First, commit or cancel all pending context changes.
        for (IManagedContext<?> managedContext : stack) {
            if (managedContext.isPending()) {
                managedContext.commit(accept);
            }
        }
        // Then notify subscribers of the changes.
        while (!stack.isEmpty()) {
            stack.pop().notifySubscribers(accept, all);
        }
    }
837295
private void processFilterAction() {
		if (!(chkFilter.isSelected())) {
			applyFilters(new ArrayList<>());
		}
		if (chkFilter.isSelected()) {
			if (txtFilter.getText().isEmpty()) {
				chkFilter.setSelected(false);
				applyFilters(new ArrayList<>());
				return;
			}
			try {
				List<TreeModelFilter<SQLPPTriplesMap>> filters = parseSearchString(txtFilter.getText());
				if (filters == null) {
					throw new Exception("Impossible to parse search string");
				}
				applyFilters(filters);
			} catch (Exception e) {
				LoggerFactory.getLogger(this.getClass()).debug(e.getMessage(), e);
				JOptionPane.showMessageDialog(this, e.getMessage());
			}
		}
	}