Java Code Examples for java.util.LinkedHashSet#removeAll()

/**
 * The function removes similar chemicals from the substrates and products (conenzymes) and remove duplicates
 * within each category.
 * @param reaction The reaction being updated.
 */
private void findAndIsolateCoenzymesFromReaction(Reaction reaction) {
  // Build ordered sets of the substrates/products.
  LinkedHashSet<Long> substrates = new LinkedHashSet<>(Arrays.asList(reaction.getSubstrates()));
  LinkedHashSet<Long> products = new LinkedHashSet<>(Arrays.asList(reaction.getProducts()));

  // Compute the intersection between the sets.
  Set<Long> intersection = new HashSet<>(substrates);
  intersection.retainAll(products);

  // A - int(A, B) = A / B
  substrates.removeAll(intersection);
  products.removeAll(intersection);

  // Update the reaction with the new (ordered) substrates/products + coenzymes.
  reaction.setSubstrates(substrates.toArray(new Long[substrates.size()]));
  reaction.setProducts(products.toArray(new Long[products.size()]));

  // Keep any existing coenzymes, but don't use them when computing the difference--they might be there for a reason.
  intersection.addAll(Arrays.asList(reaction.getCoenzymes()));
  reaction.setCoenzymes(intersection.toArray(new Long[intersection.size()]));
}
 

private MergedRef getMergedRef(String refType, String refName,
		Set<SubtreeConfig> configsWithRef) {
	LinkedHashSet<SubtreeConfig> configsWithoutRef = new LinkedHashSet<>(
			subtreeConfigs);
	configsWithoutRef.removeAll(configsWithRef);

	return new MergedRef(refType, refName, configsWithRef, configsWithoutRef);
}
 

@Override
public boolean unregister(DiscreteResourceId parent, Set<ContinuousResource> resources) {
    // short-circuit: receiving empty resource is regarded as success
    if (resources.isEmpty()) {
        return true;
    }

    // even if one of the resources is allocated to a consumer,
    // all unregistrations are regarded as failure
    boolean allocated = resources.stream().anyMatch(x -> isAllocated(x.id()));
    if (allocated) {
        log.warn("Failed to unregister {}: allocation exists", parent);
        return false;
    }

    Set<ContinuousResource> oldValues = childMap.putIfAbsent(parent, new LinkedHashSet<>());
    if (oldValues == null) {
        log.trace("No-Op removing values. key {} did not exist", parent);
        return true;
    }

    if (resources.stream().allMatch(x -> !oldValues.contains(x))) {
        // don't write map because none of the values are stored
        log.trace("No-Op removing values. key {} did not contain {}", parent, resources);
        return true;
    }

    LinkedHashSet<ContinuousResource> newValues = new LinkedHashSet<>(oldValues);
    newValues.removeAll(resources);
    return childMap.replace(parent, oldValues, newValues);
}
 

/**
 * Returns all the IPs associated with the provided interface, if any, in
 * textual form.
 * 
 * @param strInterface
 *            The name of the network interface or sub-interface to query
 *            (eg eth0 or eth0:0) or the string "default"
 * @param returnSubinterfaces
 *            Whether to return IPs associated with subinterfaces of
 *            the given interface
 * @return A string vector of all the IPs associated with the provided
 *         interface. The local host IP is returned if the interface
 *         name "default" is specified or there is an I/O error looking
 *         for the given interface.
 * @throws UnknownHostException
 *             If the given interface is invalid
 * 
 */
public static String[] getIPs(String strInterface,
    boolean returnSubinterfaces) throws UnknownHostException {
  if ("default".equals(strInterface)) {
    return new String[] { cachedHostAddress };
  }
  NetworkInterface netIf;
  try {
    netIf = NetworkInterface.getByName(strInterface);
    if (netIf == null) {
      netIf = getSubinterface(strInterface);
    }
  } catch (SocketException e) {
    LOG.warn("I/O error finding interface " + strInterface +
        ": " + e.getMessage());
    return new String[] { cachedHostAddress };
  }
  if (netIf == null) {
    throw new UnknownHostException("No such interface " + strInterface);
  }

  // NB: Using a LinkedHashSet to preserve the order for callers
  // that depend on a particular element being 1st in the array.
  // For example, getDefaultIP always returns the first element.
  LinkedHashSet<InetAddress> allAddrs = new LinkedHashSet<InetAddress>();
  allAddrs.addAll(Collections.list(netIf.getInetAddresses()));
  if (!returnSubinterfaces) {
    allAddrs.removeAll(getSubinterfaceInetAddrs(netIf));
  }

  String ips[] = new String[allAddrs.size()];
  int i = 0;
  for (InetAddress addr : allAddrs) {
    ips[i++] = addr.getHostAddress();
  }
  return ips;
}
 

/**
 * Returns all the IPs associated with the provided interface, if any, in
 * textual form.
 * 
 * @param strInterface
 *            The name of the network interface or sub-interface to query
 *            (eg eth0 or eth0:0) or the string "default"
 * @param returnSubinterfaces
 *            Whether to return IPs associated with subinterfaces of
 *            the given interface
 * @return A string vector of all the IPs associated with the provided
 *         interface. The local host IP is returned if the interface
 *         name "default" is specified or there is an I/O error looking
 *         for the given interface.
 * @throws UnknownHostException
 *             If the given interface is invalid
 * 
 */
public static String[] getIPs(String strInterface,
    boolean returnSubinterfaces) throws UnknownHostException {
  if ("default".equals(strInterface)) {
    return new String[] { cachedHostAddress };
  }
  NetworkInterface netIf;
  try {
    netIf = NetworkInterface.getByName(strInterface);
    if (netIf == null) {
      netIf = getSubinterface(strInterface);
    }
  } catch (SocketException e) {
    LOG.warn("I/O error finding interface " + strInterface +
        ": " + e.getMessage());
    return new String[] { cachedHostAddress };
  }
  if (netIf == null) {
    throw new UnknownHostException("No such interface " + strInterface);
  }

  // NB: Using a LinkedHashSet to preserve the order for callers
  // that depend on a particular element being 1st in the array.
  // For example, getDefaultIP always returns the first element.
  LinkedHashSet<InetAddress> allAddrs = new LinkedHashSet<InetAddress>();
  allAddrs.addAll(Collections.list(netIf.getInetAddresses()));
  if (!returnSubinterfaces) {
    allAddrs.removeAll(getSubinterfaceInetAddrs(netIf));
  }

  String ips[] = new String[allAddrs.size()];
  int i = 0;
  for (InetAddress addr : allAddrs) {
    ips[i++] = addr.getHostAddress();
  }
  return ips;
}
 

@Override
protected Set<CssData> getCss() {
    LinkedHashSet<CssData> set = new LinkedHashSet<>(
            fallbackScanner.getCss());
    set.removeAll(frontDeps.getCss());
    return set;
}
 

/**
 * Calculates the event addresses that appear exclusively in the first trace.
 *
 * @param trace1 The first input trace.
 * @param trace2 The second input trace.
 *
 * @return The addresses of those events that appear exlusively in the first input trace.
 */
private static Set<BreakpointAddress> getDifferenceAddresses(
    final TraceList trace1, final TraceList trace2) {
  final List<TraceList> traces = Lists.newArrayList(trace1, trace2);

  final List<Collection<BreakpointAddress>> traceAddresses = getTraceAddresses(traces);

  final LinkedHashSet<BreakpointAddress> addresses =
      new LinkedHashSet<BreakpointAddress>(traceAddresses.get(0));
  addresses.removeAll(traceAddresses.get(1));

  return addresses;
}
 

@Override
protected List<String> getModules() {
    LinkedHashSet<String> set = new LinkedHashSet<>(
            fallbackScanner.getModules());
    set.removeAll(frontDeps.getModules());
    return new ArrayList<String>(set);
}
 

@Override
protected Set<String> getScripts() {
    LinkedHashSet<String> set = new LinkedHashSet<>(
            fallbackScanner.getScripts());
    set.removeAll(frontDeps.getScripts());
    return set;
}
 

private static <E> Set<E> minus(Collection<E> c, Collection<E> c2) {
  final LinkedHashSet<E> c3 = new LinkedHashSet<>(c);
  c3.removeAll(c2);
  return c3;
}
 

private static <E> Set<E> minus(Collection<E> c, Collection<E> c2) {
  final LinkedHashSet<E> c3 = new LinkedHashSet<>(c);
  c3.removeAll(c2);
  return c3;
}
 

/**
 * Computes the transition traces, if necessary.
 *
 * Transition traces are the following:
 *
 *  predicted => active cells
 *  predicted => inactive cells
 *  predicted => active columns
 *  predicted => inactive columns
 *  unpredicted => active columns
 */
@SuppressWarnings("unchecked")
default void mmComputeTransitionTraces() {
    if(!transitionTracesStale()) {
        return;
    }
    
    Map<String, Set<Integer>> predActCells = null;
    if((predActCells = (Map<String, Set<Integer>>)getDataMap()
        .get("predictedActiveCellsForSequence")) == null) {
        
        getDataMap().put("predictedActiveCellsForSequence", predActCells = new HashMap<String, Set<Integer>>());
    }
    
    getTraceMap().put("predictedActiveCells", new IndicesTrace(this, "predicted => active cells (correct)"));
    getTraceMap().put("predictedInactiveCells", new IndicesTrace(this, "predicted => inactive cells (extra)"));
    getTraceMap().put("predictedActiveColumns", new IndicesTrace(this, "predicted => active columns (correct)"));
    getTraceMap().put("predictedInactiveColumns", new IndicesTrace(this, "predicted => inactive columns (extra)"));
    getTraceMap().put("unpredictedActiveColumns", new IndicesTrace(this, "unpredicted => active columns (bursting)"));
    
    IndicesTrace predictedCellsTrace = (IndicesTrace)getTraceMap().get("predictedCells");
    
    int i = 0;LinkedHashSet<Integer> predictedActiveColumns = null;
    for(Set<Integer> activeColumns : mmGetTraceActiveColumns().items) {
        LinkedHashSet<Integer> predictedActiveCells = new LinkedHashSet<>();
        LinkedHashSet<Integer> predictedInactiveCells = new LinkedHashSet<>();
        predictedActiveColumns = new LinkedHashSet<>();
        LinkedHashSet<Integer> predictedInactiveColumns = new LinkedHashSet<>();
        
        for(Integer predictedCell : predictedCellsTrace.items.get(i)) {
            Integer predictedColumn = getConnections().getCell(predictedCell).getColumn().getIndex();
            
            if(activeColumns.contains(predictedColumn)) {
                predictedActiveCells.add(predictedCell);
                predictedActiveColumns.add(predictedColumn);
                
                String sequenceLabel = (String)mmGetTraceSequenceLabels().items.get(i);
                if(sequenceLabel != null && !sequenceLabel.isEmpty()) {
                    Set<Integer> sequencePredictedCells = null;
                    if((sequencePredictedCells = (Set<Integer>)predActCells.get(sequenceLabel)) == null) {
                        
                        ((Map<String, Set<Integer>>)predActCells).put(
                            sequenceLabel, sequencePredictedCells = new LinkedHashSet<Integer>());
                    }
                    
                    sequencePredictedCells.add(predictedCell);
                }
            }else{
                predictedInactiveCells.add(predictedCell);
                predictedInactiveColumns.add(predictedColumn);
            }
        }
        
        LinkedHashSet<Integer> unpredictedActiveColumns = new LinkedHashSet<>(activeColumns);
        unpredictedActiveColumns.removeAll(predictedActiveColumns);
        
        ((IndicesTrace)getTraceMap().get("predictedActiveCells")).items.add(predictedActiveCells);
        ((IndicesTrace)getTraceMap().get("predictedInactiveCells")).items.add(predictedInactiveCells);
        ((IndicesTrace)getTraceMap().get("predictedActiveColumns")).items.add(predictedActiveColumns);
        ((IndicesTrace)getTraceMap().get("predictedInactiveColumns")).items.add(predictedInactiveColumns);
        ((IndicesTrace)getTraceMap().get("unpredictedActiveColumns")).items.add(unpredictedActiveColumns);
        
        i++;
    }
    
    setTransitionTracesStale(false);
}
 

private static <E> Set<E> minus(Collection<E> c, Collection<E> c2) {
  final LinkedHashSet<E> c3 = new LinkedHashSet<>(c);
  c3.removeAll(c2);
  return c3;
}
 

@Override
public Expression rewriteLambdaExpression(LambdaExpression node, Context context, ExpressionTreeRewriter<Context> treeRewriter)
{
    // Use linked hash set to guarantee deterministic iteration order
    LinkedHashSet<Symbol> referencedSymbols = new LinkedHashSet<>();
    Expression rewrittenBody = treeRewriter.rewrite(node.getBody(), context.withReferencedSymbols(referencedSymbols));

    List<Symbol> lambdaArguments = node.getArguments().stream()
            .map(LambdaArgumentDeclaration::getName)
            .map(Identifier::getValue)
            .map(Symbol::new)
            .collect(toImmutableList());

    // referenced symbols - lambda arguments = capture symbols
    // referencedSymbols no longer contains what its name suggests after this line
    referencedSymbols.removeAll(lambdaArguments);
    Set<Symbol> captureSymbols = referencedSymbols;

    // x -> f(x, captureSymbol)    will be rewritten into
    // "$internal$bind"(captureSymbol, (extraSymbol, x) -> f(x, extraSymbol))

    ImmutableMap.Builder<Symbol, Symbol> captureSymbolToExtraSymbol = ImmutableMap.builder();
    ImmutableList.Builder<LambdaArgumentDeclaration> newLambdaArguments = ImmutableList.builder();
    for (Symbol captureSymbol : captureSymbols) {
        Symbol extraSymbol = symbolAllocator.newSymbol(captureSymbol.getName(), symbolTypes.get(captureSymbol));
        captureSymbolToExtraSymbol.put(captureSymbol, extraSymbol);
        newLambdaArguments.add(new LambdaArgumentDeclaration(new Identifier(extraSymbol.getName())));
    }
    newLambdaArguments.addAll(node.getArguments());

    ImmutableMap<Symbol, Symbol> symbolsMap = captureSymbolToExtraSymbol.build();
    Function<Symbol, Expression> symbolMapping = symbol -> symbolsMap.getOrDefault(symbol, symbol).toSymbolReference();
    Expression rewrittenExpression = new LambdaExpression(newLambdaArguments.build(), inlineSymbols(symbolMapping, rewrittenBody));

    if (captureSymbols.size() != 0) {
        List<Expression> capturedValues = captureSymbols.stream()
                .map(symbol -> new SymbolReference(symbol.getName()))
                .collect(toImmutableList());
        rewrittenExpression = new BindExpression(capturedValues, rewrittenExpression);
    }

    context.getReferencedSymbols().addAll(captureSymbols);
    return rewrittenExpression;
}
 

static void moveToEnd(final LinkedHashSet<Cipher> ciphers, final Collection<Cipher> toBeMovedCiphers) {
    List<Cipher> movedCiphers = new ArrayList<>(toBeMovedCiphers);
    movedCiphers.retainAll(ciphers);
    ciphers.removeAll(movedCiphers);
    ciphers.addAll(movedCiphers);
}
 

/**
 * A {@link Set} of all the items that became deselected.
 *
 * <em>Note:</em> this excludes all items that might have been previously
 * deselected.
 *
 * @return a set of the items that became deselected
 */
public Set<E> getRemoved() {
    LinkedHashSet<E> copy = new LinkedHashSet<>(getOldSelection());
    copy.removeAll(getSelected());
    return copy;
}
 

/**
 * A {@link Set} of all the items that became selected.
 *
 * <em>Note:</em> this excludes all items that might have been previously
 * selected.
 *
 * @return a set of the items that became selected
 */
public Set<E> getAdded() {
    LinkedHashSet<E> copy = new LinkedHashSet<>(getSelected());
    copy.removeAll(getOldSelection());
    return copy;
}