Example usage for com.google.common.collect Iterables removeAll

List of usage examples for com.google.common.collect Iterables removeAll

Introduction

In this page you can find the example usage for com.google.common.collect Iterables removeAll.

Prototype

public static boolean removeAll(Iterable<?> removeFrom, Collection<?> elementsToRemove) 

Source Link

Document

Removes, from an iterable, every element that belongs to the provided collection.

Usage

From source file:org.apache.brooklyn.location.jclouds.networking.JcloudsLocationSecurityGroupCustomizer.java

/**
 * Applies the given security group permissions to the given node with the given compute service.
 * <p>/*www . j  a v  a 2 s  .  c o  m*/
 * Takes no action if the compute service does not have a security group extension.
 * @param permissions The set of permissions to be applied to the node
 * @param nodeId The id of the node to update
 * @param computeService The compute service to use to apply the changes
 */
@VisibleForTesting
void addPermissionsToLocation(Iterable<IpPermission> permissions, final String nodeId,
        ComputeService computeService) {
    if (!computeService.getSecurityGroupExtension().isPresent()) {
        LOG.warn("Security group extension for {} absent; cannot update node {} with {}",
                new Object[] { computeService, nodeId, permissions });
        return;
    }
    final SecurityGroupExtension securityApi = computeService.getSecurityGroupExtension().get();
    final String locationId = computeService.getContext().unwrap().getId();

    // Expect to have two security groups on the node: one shared between all nodes in the location,
    // that is cached in sharedGroupCache, and one created by Jclouds that is unique to the node.
    // Relies on customize having been called before. This should be safe because the arguments
    // needed to call this method are not available until post-instance creation.
    SecurityGroup machineUniqueSecurityGroup = getSecurityGroup(nodeId, securityApi, locationId);
    MutableList<IpPermission> newPermissions = MutableList.copyOf(permissions);
    Iterables.removeAll(newPermissions, machineUniqueSecurityGroup.getIpPermissions());
    for (IpPermission permission : newPermissions) {
        addPermission(permission, machineUniqueSecurityGroup, securityApi);
    }
}

From source file:org.eclipse.sirius.diagram.sequence.business.internal.util.SubEventsHelper.java

private Iterable<ISequenceEvent> getSequenceEventsToFilter(ISequenceEvent self, ISequenceEvent child,
        final Range range, final Collection<Lifeline> lifelines) {
    Set<ISequenceEvent> result = Sets.newHashSet(self.getSubEvents());
    Predicate<ISequenceEvent> inRangePredicate = new Predicate<ISequenceEvent>() {

        public boolean apply(ISequenceEvent input) {
            Range inputRange = input.getVerticalRange();
            return range.includesAtLeastOneBound(inputRange)
                    || new ISequenceEventQuery(input).isReflectiveMessage()
                            && inputRange.includesAtLeastOneBound(range);
        }//w ww.  j av a2 s  . co  m

    };
    Predicate<ISequenceEvent> inCoverage = new Predicate<ISequenceEvent>() {

        public boolean apply(ISequenceEvent input) {
            Collection<Lifeline> inputCoverage = Lists.newArrayList(getCoverage(input));
            return Iterables.removeAll(inputCoverage, lifelines);
        }

    };

    @SuppressWarnings("unchecked")
    Predicate<ISequenceEvent> predicateFilter = Predicates.and(Predicates.not(Predicates.equalTo(child)),
            inRangePredicate, inCoverage);
    return Iterables.filter(result, predicateFilter);
}

From source file:org.eclipse.sirius.diagram.ui.tools.internal.clipboard.SiriusClipboardGlobalActionHandler.java

private void fillPasteContext(Collection<Object> clipboard, Collection<DSemanticDecorator> dCopies,
        Collection<EObject> dTargetcopies, Collection<EObject> strictSemanticCopies) {
    if (clipboard == null) {
        // No viewpoint data in clipboard.
        return;//from   w  ww. j av  a2 s .  c  o  m
    }

    for (EObject obj : Iterables.filter(clipboard, EObject.class)) {
        if (obj instanceof DSemanticDecorator) {
            DSemanticDecorator semDecCopy = (DSemanticDecorator) obj;
            if (semDecCopy.getTarget() != null && isTargetInClipboard(clipboard, semDecCopy)) {
                dCopies.add(semDecCopy);
                dTargetcopies.add(semDecCopy.getTarget());
            }
        } else {
            strictSemanticCopies.add(obj);
        }
    }
    Iterables.removeAll(strictSemanticCopies, dTargetcopies);
}

From source file:org.eclipse.rcptt.launching.internal.target.TargetPlatformHelper.java

public IStatus applyInjection(InjectionConfiguration configuration, IProgressMonitor monitor) {
    // remove the "host" from bundles, it is handled in a separate, special
    // way//from  w  w  w . jav  a  2 s.c  om
    Iterables.removeAll(extra, Arrays.asList(getInstanceContainer()));

    EList<Entry> entries = configuration.getEntries();
    monitor.beginTask("Apply injection plugins", 20 + entries.size() * 20);
    for (Entry entry : entries) {
        SubProgressMonitor mon = new SubProgressMonitor(monitor, 20);
        if (monitor.isCanceled()) {
            return Status.CANCEL_STATUS;
        }
        IStatus result = new Status(IStatus.ERROR, PLUGIN_ID,
                "Unknown injection type: " + entry.getClass().getName());
        if (entry instanceof UpdateSite) {
            result = processUpdateSite(mon, (UpdateSite) entry);
        } else if (entry instanceof Directory) {
            result = processDirectory((Directory) entry);
        }
        if (result.matches(IStatus.ERROR | IStatus.CANCEL)) {
            return result;
        }
    }
    update();
    IStatus resolveStatus = resolve(monitor);
    if (!resolveStatus.isOK()) {
        return resolveStatus;
    }
    if (getWeavingHook() == null) {
        return status = createError("No org.eclipse.weaving hook plugin");
    }
    try {
        save();
    } catch (CoreException e) {
        return e.getStatus();
    }
    return Status.OK_STATUS;
}

From source file:com.eucalyptus.autoscaling.activities.ActivityManager.java

private ScalingProcessTask<?, ?> perhapsTerminateInstances(final AutoScalingGroupScalingView group,
        final int terminateCount) {
    final List<String> instancesToTerminate = Lists.newArrayList();
    boolean anyRegisteredInstances = false;
    int currentCapacity = 0;
    try {//from  w  w w.  jav a 2  s  . co  m
        final List<AutoScalingInstanceCoreView> currentInstances = autoScalingInstances.listByGroup(group,
                Predicates.alwaysTrue(),
                TypeMappers.lookup(AutoScalingInstance.class, AutoScalingInstanceCoreView.class));
        currentCapacity = currentInstances.size();
        if (currentInstances.size() == terminateCount) {
            Iterables.addAll(instancesToTerminate,
                    Iterables.transform(currentInstances, RestrictedTypes.toDisplayName()));
            anyRegisteredInstances = Iterables.any(currentInstances, ConfigurationState.Registered.forView());
        } else {
            // First terminate instances in zones that are no longer in use
            final Set<String> groupZones = Sets.newLinkedHashSet(group.getAvailabilityZones());
            groupZones.removeAll(
                    zoneMonitor.getUnavailableZones(AutoScalingConfiguration.getZoneFailureThresholdMillis()));
            final Set<String> unwantedZones = Sets
                    .newHashSet(Iterables.transform(currentInstances, availabilityZone()));
            unwantedZones.removeAll(groupZones);

            final Set<String> targetZones;
            final List<AutoScalingInstanceCoreView> remainingInstances = Lists.newArrayList(currentInstances);
            if (!unwantedZones.isEmpty()) {
                int unwantedInstanceCount = CollectionUtils.reduce(currentInstances, 0,
                        CollectionUtils.count(withAvailabilityZone(unwantedZones)));
                if (unwantedInstanceCount < terminateCount) {
                    Iterable<AutoScalingInstanceCoreView> unwantedInstances = Iterables.filter(currentInstances,
                            withAvailabilityZone(unwantedZones));
                    Iterables.addAll(instancesToTerminate,
                            Iterables.transform(unwantedInstances, RestrictedTypes.toDisplayName()));
                    Iterables.removeAll(remainingInstances, Lists.newArrayList(unwantedInstances));
                    anyRegisteredInstances = Iterables.any(unwantedInstances,
                            ConfigurationState.Registered.forView());
                    targetZones = groupZones;
                } else {
                    targetZones = unwantedZones;
                }
            } else {
                targetZones = groupZones;
            }

            final Map<String, Integer> zoneCounts = buildAvailabilityZoneInstanceCounts(currentInstances,
                    targetZones);

            for (int i = instancesToTerminate.size(); i < terminateCount
                    && remainingInstances.size() >= 1; i++) {
                final Map.Entry<String, Integer> entry = selectEntry(zoneCounts, Ordering.natural().reverse());
                final AutoScalingInstanceCoreView instanceForTermination = TerminationPolicyType
                        .selectForTermination(group.getTerminationPolicies(), Lists.newArrayList(
                                Iterables.filter(remainingInstances, withAvailabilityZone(entry.getKey()))));
                remainingInstances.remove(instanceForTermination);
                entry.setValue(entry.getValue() - 1);
                instancesToTerminate.add(instanceForTermination.getInstanceId());
                anyRegisteredInstances |= ConfigurationState.Registered.forView().apply(instanceForTermination);
            }
        }
    } catch (final Exception e) {
        logger.error(e, e);
    }

    final List<ActivityCause> causes = Lists.newArrayList();
    causes.add(new ActivityCause(String.format(
            "an instance was taken out of service in response to a difference between desired and actual capacity, shrinking the capacity from %1$d to %2$d",
            group.getCapacity(), group.getCapacity() - instancesToTerminate.size())));
    for (final String instanceId : instancesToTerminate) {
        causes.add(new ActivityCause(String.format("instance %1$s was selected for termination", instanceId)));
    }

    return removeFromLoadBalancerOrTerminate(group, currentCapacity, anyRegisteredInstances,
            instancesToTerminate, causes, false);
}

From source file:org.eclipse.sirius.diagram.sequence.business.internal.layout.vertical.SequenceVerticalLayout.java

private void lookForUnconnectedLostEnd() {
    Collection<LostMessageEnd> allLostMessageEnds = sequenceDiagram.getAllLostMessageEnds();
    Collection<LostMessageEnd> discoveredLostEnds = Lists.newArrayList();
    for (Message knownMsgs : Iterables.filter(iSequenceEventsToEventEnds.keySet(), Message.class)) {
        ISequenceNode sourceElement = knownMsgs.getSourceElement();
        if (sourceElement instanceof LostMessageEnd) {
            discoveredLostEnds.add((LostMessageEnd) sourceElement);
        }// w w  w  .j a v a2 s.  com

        ISequenceNode targetElement = knownMsgs.getTargetElement();
        if (targetElement instanceof LostMessageEnd) {
            discoveredLostEnds.add((LostMessageEnd) targetElement);
        }
    }

    Iterables.removeAll(allLostMessageEnds, discoveredLostEnds);

    unconnectedLostEnds.addAll(allLostMessageEnds);
}

From source file:org.eclipse.xtext.idea.build.XtextAutoBuilderComponent.java

protected void internalBuild(final ProgressIndicator indicator) {
    this.queue.drainTo(this.unProcessedEvents);
    boolean _isEmpty = this.unProcessedEvents.isEmpty();
    if (_isEmpty) {
        return;/*  w w  w.j  ava  2  s. com*/
    }
    final Application app = ApplicationManager.getApplication();
    final XtextAutoBuilderComponent.MutableCancelIndicator cancelIndicator = new XtextAutoBuilderComponent.MutableCancelIndicator(
            indicator);
    this.cancelIndicators.add(cancelIndicator);
    Project _project = this.getProject();
    final ModuleManager moduleManager = ModuleManager.getInstance(_project);
    final BuildProgressReporter buildProgressReporter = this.buildProgressReporterProvider.get();
    buildProgressReporter.setProject(this.project);
    ArrayList<BuildEvent> _arrayList = new ArrayList<BuildEvent>(this.unProcessedEvents);
    buildProgressReporter.setEvents(_arrayList);
    try {
        final Computable<Graph<Module>> _function = () -> {
            return moduleManager.moduleGraph();
        };
        final Graph<Module> moduleGraph = app.<Graph<Module>>runReadAction(_function);
        final ArrayList<IResourceDescription.Delta> deltas = CollectionLiterals.<IResourceDescription.Delta>newArrayList();
        Collection<Module> _nodes = moduleGraph.getNodes();
        final ArrayList<Module> sortedModules = new ArrayList<Module>(_nodes);
        ModuleCompilerUtil.sortModules(this.project, sortedModules);
        for (final Module module : sortedModules) {
            {
                Source2GeneratedMapping _elvis = null;
                String _name = module.getName();
                Source2GeneratedMapping _get = this.moduleName2GeneratedMapping.get(_name);
                if (_get != null) {
                    _elvis = _get;
                } else {
                    Source2GeneratedMapping _source2GeneratedMapping = new Source2GeneratedMapping();
                    _elvis = _source2GeneratedMapping;
                }
                final Source2GeneratedMapping fileMappings = _elvis;
                ResourceDescriptionsData _elvis_1 = null;
                String _name_1 = module.getName();
                ResourceDescriptionsData _container = this.chunkedResourceDescriptions.getContainer(_name_1);
                if (_container != null) {
                    _elvis_1 = _container;
                } else {
                    List<IResourceDescription> _emptyList = CollectionLiterals
                            .<IResourceDescription>emptyList();
                    ResourceDescriptionsData _resourceDescriptionsData = new ResourceDescriptionsData(
                            _emptyList);
                    _elvis_1 = _resourceDescriptionsData;
                }
                final ResourceDescriptionsData moduleDescriptions = _elvis_1;
                final HashSet<URI> changedUris = CollectionLiterals.<URI>newHashSet();
                final HashSet<URI> deletedUris = CollectionLiterals.<URI>newHashSet();
                ModuleRootManager _instance = ModuleRootManager.getInstance(module);
                final VirtualFile[] contentRoots = _instance.getContentRoots();
                final LinkedHashSet<BuildEvent> events = this.getEventsForModule(this.unProcessedEvents,
                        module);
                if ((((List<VirtualFile>) Conversions.doWrapArray(contentRoots)).isEmpty()
                        || (events.isEmpty() && deltas.isEmpty()))) {
                    String _name_2 = module.getName();
                    String _plus = ("Skipping module \'" + _name_2);
                    String _plus_1 = (_plus + "\'. Nothing to do here.");
                    XtextAutoBuilderComponent.LOG.info(_plus_1);
                } else {
                    this.collectChanges(events, module, changedUris, deletedUris, deltas);
                    final ResourceDescriptionsData newIndex = moduleDescriptions.copy();
                    BuildRequest _buildRequest = new BuildRequest();
                    final Procedure1<BuildRequest> _function_1 = (BuildRequest it) -> {
                        XtextResourceSet _createResourceSet = this.createResourceSet(module, newIndex);
                        it.setResourceSet(_createResourceSet);
                        List<URI> _dirtyFiles = it.getDirtyFiles();
                        Iterables.<URI>addAll(_dirtyFiles, changedUris);
                        List<URI> _deletedFiles = it.getDeletedFiles();
                        Iterables.<URI>addAll(_deletedFiles, deletedUris);
                        List<IResourceDescription.Delta> _externalDeltas = it.getExternalDeltas();
                        Iterables.<IResourceDescription.Delta>addAll(_externalDeltas, deltas);
                        VirtualFile _head = IterableExtensions.<VirtualFile>head(
                                ((Iterable<VirtualFile>) Conversions.doWrapArray(contentRoots)));
                        URI _uRI = VirtualFileURIUtil.getURI(_head);
                        it.setBaseDir(_uRI);
                        Source2GeneratedMapping _copy = fileMappings.copy();
                        IndexState _indexState = new IndexState(newIndex, _copy);
                        it.setState(_indexState);
                        it.setAfterValidate(buildProgressReporter);
                        final Procedure1<URI> _function_2 = (URI it_1) -> {
                            buildProgressReporter.markAsAffected(it_1);
                        };
                        it.setAfterDeleteFile(_function_2);
                        it.setCancelIndicator(cancelIndicator);
                    };
                    final BuildRequest request = ObjectExtensions
                            .<BuildRequest>operator_doubleArrow(_buildRequest, _function_1);
                    IncrementalBuilder _get_1 = this.builderProvider.get();
                    Function1<URI, IResourceServiceProvider> _serviceProviderProvider = this
                            .getServiceProviderProvider(module);
                    final IncrementalBuilder.Result result = _get_1.build(request, _serviceProviderProvider);
                    final Runnable _function_2 = () -> {
                        try {
                            this.ignoreIncomingEvents = true;
                            XtextResourceSet _resourceSet = request.getResourceSet();
                            final IdeaResourceSetProvider.VirtualFileBasedUriHandler handler = IdeaResourceSetProvider.VirtualFileBasedUriHandler
                                    .find(_resourceSet);
                            handler.flushToDisk();
                        } finally {
                            this.ignoreIncomingEvents = false;
                            buildProgressReporter.rehighlight();
                        }
                    };
                    ModalityState _defaultModalityState = app.getDefaultModalityState();
                    app.invokeAndWait(_function_2, _defaultModalityState);
                    String _name_3 = module.getName();
                    IndexState _indexState = result.getIndexState();
                    ResourceDescriptionsData _resourceDescriptions = _indexState.getResourceDescriptions();
                    this.chunkedResourceDescriptions.setContainer(_name_3, _resourceDescriptions);
                    String _name_4 = module.getName();
                    IndexState _indexState_1 = result.getIndexState();
                    Source2GeneratedMapping _fileMappings = _indexState_1.getFileMappings();
                    this.moduleName2GeneratedMapping.put(_name_4, _fileMappings);
                    List<IResourceDescription.Delta> _affectedResources = result.getAffectedResources();
                    deltas.addAll(_affectedResources);
                    Iterables.removeAll(this.unProcessedEvents, events);
                }
            }
        }
        this.unProcessedEvents.clear();
    } catch (final Throwable _t) {
        if (_t instanceof Throwable) {
            final Throwable exc = (Throwable) _t;
            boolean _isOperationCanceledException = this.operationCanceledManager
                    .isOperationCanceledException(exc);
            if (_isOperationCanceledException) {
                boolean _isInfoEnabled = XtextAutoBuilderComponent.LOG.isInfoEnabled();
                if (_isInfoEnabled) {
                    XtextAutoBuilderComponent.LOG.info("Build canceled.");
                }
            } else {
                XtextAutoBuilderComponent.LOG.error("Error during auto build.", exc);
            }
        } else {
            throw Exceptions.sneakyThrow(_t);
        }
    } finally {
        buildProgressReporter.clearProgress();
        this.cancelIndicators.remove(cancelIndicator);
    }
}