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

public RichIterable<FileObject> getSourceDirs() {
    if (this.sourceDirs == null) {
        // only keep the distinct list of files here
        LinkedHashSet<FileObject> fileObjects = new LinkedHashSet<FileObject>();
        if (coreSourcePath != null) {
            fileObjects.add(coreSourcePath);
        }
        if (additionalSourceDirs != null) {
            fileObjects.addAll(additionalSourceDirs.flatCollect(new Function<String, Iterable<FileObject>>() {
                @Override
                public Iterable<FileObject> valueOf(String path) {
                    MutableList<FileObject> resolvedFileObjects = Lists.mutable.empty();
                    for (FileResolverStrategy fileResolverStrategy : fileResolverStrategies) {
                        resolvedFileObjects.addAllIterable(fileResolverStrategy.resolveFileObjects(path));
                    }
                    if (resolvedFileObjects.isEmpty()) {
                        throw new IllegalArgumentException("Unable to find the given path [" + path + "] via any of the fileResolverStrategies:" + fileResolverStrategies.makeString(", "));
                    }
                    return resolvedFileObjects;
                }
            }).toList());
        }
        this.sourceDirs = Lists.mutable.withAll(fileObjects);
    }
    return this.sourceDirs;
}
 

/**
 * returns all unread messages of a specific type, after an iterator on the stream
 *
 * @param iterator the iterator pointing to an offset in the coordinator stream. All unread messages after this iterator are returned
 * @param type     the type of the messages to be returned
 * @return a set of unread messages of a given type, after a given iterator
 */
public Set<CoordinatorStreamMessage> getUnreadMessages(SystemStreamPartitionIterator iterator, String type) {
  LinkedHashSet<CoordinatorStreamMessage> messages = new LinkedHashSet<CoordinatorStreamMessage>();
  while (iterator.hasNext()) {
    IncomingMessageEnvelope envelope = iterator.next();
    Object[] keyArray = keySerde.fromBytes((byte[]) envelope.getKey()).toArray();
    Map<String, Object> valueMap = null;
    if (envelope.getMessage() != null) {
      valueMap = messageSerde.fromBytes((byte[]) envelope.getMessage());
    }
    CoordinatorStreamMessage coordinatorStreamMessage = new CoordinatorStreamMessage(keyArray, valueMap);
    if (type == null || type.equals(coordinatorStreamMessage.getType())) {
      messages.add(coordinatorStreamMessage);
    }
  }
  return messages;
}
 

private Formula transformOr(final Or or) {
  Formula aig = or.transformationCacheEntry(AIG);
  if (aig == null) {
    final LinkedHashSet<Formula> nops = new LinkedHashSet<>(or.numberOfOperands());
    for (final Formula op : or)
      nops.add(f.not(apply(op, cache)));
    aig = f.not(f.and(nops));
    if (cache) {
      or.setTransformationCacheEntry(AIG, aig);
      aig.setPredicateCacheEntry(PredicateCacheEntry.IS_AIG, true);
    }
  }
  return aig;
}
 

/**
 * Returns all namespaces that have values in this map.
 *
 * @return the namespaces stored in this map.
 */
public String[] getNameSpaces() {
  if ( content == null ) {
    return AttributeMap.EMPTY_NAMESPACES;
  }

  LinkedHashSet<String> entries = new LinkedHashSet<String>();
  for ( final Map.Entry<DualKey, T> entry : content.entrySet() ) {
    entries.add( entry.getKey().namespace );
  }

  return entries.toArray( new String[entries.size()] );
}
 

/**
 * <pre>
 * SELECT SUM(?y) as ?x
 * GROUP BY ?z
 * HAVING ?x > 10
 * </pre>
 */
@SuppressWarnings({ "rawtypes", "unchecked" })
public void test_simpleHavingClause() {
    
    final IVariable<IV> y = Var.var("y");
    final IVariable<IV> x = Var.var("x");
    final IVariable<IV> z = Var.var("z");

    final IValueExpression<IV> xExpr = new /* Conditional */Bind(x, new SUM(
            false/* distinct */, (IValueExpression<IV>) y));

    final IValueExpression<IV>[] select = new IValueExpression[] { xExpr };

    final IValueExpression<IV>[] groupBy = new IValueExpression[] { z };

    final IConstraint[] having = new IConstraint[] {//
    new SPARQLConstraint<XSDBooleanIV>(new CompareBOp(x,
            new Constant<XSDNumericIV>(new XSDNumericIV(10)), CompareOp.LT
            ))//
        };

    final LinkedHashSet<IVariable<?>> groupByVars = new LinkedHashSet<IVariable<?>>();
    groupByVars.add(z);

    final LinkedHashSet<IVariable<?>> selectVars = new LinkedHashSet<IVariable<?>>();
    selectVars.add(x);

    final LinkedHashSet<IVariable<?>> columnVars = new LinkedHashSet<IVariable<?>>();
    columnVars.add(y);

    final MockGroupByState expected = new MockGroupByState(groupBy,
            groupByVars, select, selectVars, having, columnVars,
            false/* anyDistinct */, false/* selectDependency */,
            false/* nestedAggregates */, true/* simpleHaving */);

    final IGroupByState actual = new GroupByState(select, groupBy, having);

    assertSameState(expected, actual);

}
 

/**
 * for attribute valueIntegerSet parsing
 */
protected LinkedHashSet<Integer> parseValueIntegerSet(String input) {
  if (input==null) {
    return null;
  }
  KriptonJsonContext context=KriptonBinder.jsonBind();
  try (JacksonWrapperParser wrapper=context.createParser(input)) {
    JsonParser jacksonParser=wrapper.jacksonParser;
    // START_OBJECT
    jacksonParser.nextToken();
    // value of "element"
    jacksonParser.nextValue();
    LinkedHashSet<Integer> result=null;
    if (jacksonParser.currentToken()==JsonToken.START_ARRAY) {
      LinkedHashSet<Integer> collection=new LinkedHashSet<>();
      Integer item=null;
      while (jacksonParser.nextToken() != JsonToken.END_ARRAY) {
        if (jacksonParser.currentToken()==JsonToken.VALUE_NULL) {
          item=null;
        } else {
          item=jacksonParser.getIntValue();
        }
        collection.add(item);
      }
      result=collection;
    }
    return result;
  } catch(Exception e) {
    e.printStackTrace();
    throw(new KriptonRuntimeException(e.getMessage()));
  }
}
 

/**
 * Returns all of the superclasses and superinterfaces for a given generator
 * including the generator itself. The returned set maintains an internal
 * breadth-first ordering of the generator, followed by its interfaces (and their
 * super-interfaces), then the supertype and its interfaces, and so on.
 *
 * @param types      types
 * @param typeMirror of the class to check
 * @return Set of implemented super types
 */
public Set<TypeMirror> getFlattenedSupertypeHierarchy(Types types,
                                                      TypeMirror typeMirror) {
  List<TypeMirror> toAdd = new ArrayList<>();
  LinkedHashSet<TypeMirror> result = new LinkedHashSet<>();
  toAdd.add(typeMirror);
  for (int i = 0; i < toAdd.size(); i++) {
    TypeMirror type = toAdd.get(i);
    if (result.add(type)) {
      toAdd.addAll(types.directSupertypes(type));
    }
  }
  return result;
}
 

public HashSet getAnnotationTypes() {
    LinkedHashSet<String> types = new LinkedHashSet<String>();
    if(firstPersonCheckBox.isSelected())    types.add("FirstPerson");
    if(lookupCheckBox.isSelected())         types.add("Lookup");
    if(personCheckBox.isSelected())         types.add("Person");
    if(sentenceCheckBox.isSelected())       types.add("Sentence");
    if(spaceTokenCheckBox.isSelected())     types.add("SpaceToken");
    if(splitCheckBox.isSelected())          types.add("Split");
    if(tokenCheckBox.isSelected())          types.add("Token");
    if(unknownCheckBox.isSelected())        types.add("Unknown");

    if(dateCheckBox.isSelected())           types.add("Date");
    if(jobTitleCheckBox.isSelected())       types.add("JobTitle");
    if(locationCheckBox.isSelected())       types.add("Location");
    if(organizationCheckBox.isSelected())   types.add("Organization");
    if(tempCheckBox.isSelected())           types.add("Temp");

    if(identifierCheckBox.isSelected())     types.add("Identifier");
    if(moneyCheckBox.isSelected())          types.add("Money");
    if(percentCheckBox.isSelected())        types.add("Percent");
    if(titleCheckBox.isSelected())          types.add("Title");

    String other = otherTextField.getText();
    String[] others = other.split(",");
    if(others.length > 0) {
        for(int i=0; i<others.length; i++) {
            String o = others[i];
            if(o != null && o.trim().length() > 0) {
                types.add(o);
            }
        }
    }
    return types;
}
 

/**
 * Compute a fixed point for the given graph, entering from the given nodes.
 * @param graph The graph to traverse.
 * @param entrySet The nodes to begin traversing from.
 */
public void computeFixedPoint(DiGraph<N, E> graph, Set<N> entrySet) {
  int cycleCount = 0;
  long nodeCount = graph.getNodes().size();

  // Choose a bail-out heuristically in case the computation
  // doesn't converge.
  long maxIterations = Math.max(nodeCount * nodeCount * nodeCount, 100);

  // Use a LinkedHashSet, so that the traversal is deterministic.
  LinkedHashSet<DiGraphNode<N, E>> workSet =
      Sets.newLinkedHashSet();
  for (N n : entrySet) {
    workSet.add(graph.getDirectedGraphNode(n));
  }
  for (; !workSet.isEmpty() && cycleCount < maxIterations; cycleCount++) {
    // For every out edge in the workSet, traverse that edge. If that
    // edge updates the state of the graph, then add the destination
    // node to the resultSet, so that we can update all of its out edges
    // on the next iteration.
    DiGraphNode<N, E> source = workSet.iterator().next();
    N sourceValue = source.getValue();

    workSet.remove(source);

    List<DiGraphEdge<N, E>> outEdges = source.getOutEdges();
    for (DiGraphEdge<N, E> edge : outEdges) {
      N destNode = edge.getDestination().getValue();
      if (callback.traverseEdge(sourceValue, edge.getValue(), destNode)) {
        workSet.add(edge.getDestination());
      }
    }
  }

  Preconditions.checkState(cycleCount != maxIterations,
      NON_HALTING_ERROR_MSG);
}
 

/**
 * Returns a {@link Set} of indexes mapped to patterns
 * which contain the specified bit.
 * 
 * @param bit
 * @return
 */
public LinkedHashSet<Integer> numbersForBit(int bit) {
    LinkedHashSet<Integer> retVal = new LinkedHashSet<Integer>();
    for(Integer i : patterns.keySet()) {
        if(patterns.get(i).contains(bit)) {
            retVal.add(i);
        }
    }
    
    return retVal;
}
 

@SafeVarargs
private final LinkedHashSet<StrategyIdentifier> mockGetPossibleStrategies(
        LinkedHashSet<MethodSkeleton<MethodGenerationData>> skeletons, StrategyIdentifier... identifiers) {
    LinkedHashSet<StrategyIdentifier> possibleStrategies = new LinkedHashSet<StrategyIdentifier>();
    for (StrategyIdentifier strategyIdentifier : identifiers) {
        possibleStrategies.add(strategyIdentifier);
    }
    when(methodContentManager.getStrategiesIntersection(skeletons)).thenReturn(possibleStrategies);
    return possibleStrategies;
}
 

public static LinkedHashSet<String> splitTags(String tags) {
    LinkedHashSet<String> set = Sets.newLinkedHashSet();
    for(String s: tags.split(SPLITTER)) {
       set.add(s.replaceAll(" ", ""));
    }
    return set;
}
 

/**
 * Stores the listed object under the specified hash key in map. Unlike a
 * standard map, the listed object will not replace any object already at
 * the appropriate Map location, but rather will be appended to a List
 * stored in that location.
 */
private <H, L> void store(H hashed, L listed, Map<H, LinkedHashSet<L>> map) {
    LinkedHashSet<L> list = map.get(hashed);
    if (list == null) {
        list = new LinkedHashSet<>(1);
        map.put(hashed, list);
    }
    if (!list.contains(listed)) {
        list.add(listed);
    }
}
 

@Test(expected = ServletException.class)
public void registerClassesWithSameRoute_class_unrelatedClass_throws()
        throws ServletException {
    LinkedHashSet<Class<?>> classes = new LinkedHashSet<>();
    classes.add(BaseRouteTarget.class);
    classes.add(OtherRouteTarget.class);
    routeRegistryInitializer.process(classes, servletContext);
}
 

/**
 * Returns the query schema as defined in XML format on the given stream.
 * 
 * @param stream
 *          The source of the XML query schema description.
 * @return The query schema.
 * @throws IOException
 *           A problem occurred reading from the given stream.
 * @throws PIRException
 *           The schema description is invalid.
 */
public QuerySchema loadSchema(InputStream stream) throws IOException, PIRException
{
  // Read in and parse the XML file.
  Document doc = parseXMLDocument(stream);

  // Used to build the final schema.
  QuerySchemaBuilder schemaBuilder = new QuerySchemaBuilder();

  // Extract the schemaName.
  String schemaName = extractValue(doc, "schemaName");
  schemaBuilder.setName(schemaName);
  logger.info("schemaName = " + schemaName);

  // Extract the dataSchemaName.
  String dataSchemaName = extractValue(doc, "dataSchemaName");
  schemaBuilder.setDataSchemaName(dataSchemaName);
  logger.info("dataSchemaName = " + dataSchemaName);

  // Extract the selectorName.
  String selectorName = extractValue(doc, "selectorName");
  schemaBuilder.setSelectorName(selectorName);
  logger.info("selectorName = " + selectorName);

  // Extract the query elements.
  NodeList elementsList = doc.getElementsByTagName("elements");
  if (elementsList.getLength() != 1)
  {
    throw new PIRException("elementsList.getLength() = " + elementsList.getLength() + " -- should be 1");
  }
  Element elements = (Element) elementsList.item(0);

  LinkedHashSet<String> elementNames = new LinkedHashSet<>();
  NodeList nList = elements.getElementsByTagName("name");
  for (int i = 0; i < nList.getLength(); i++)
  {
    Node nNode = nList.item(i);
    if (nNode.getNodeType() == Node.ELEMENT_NODE)
    {
      elementNames.add(nNode.getFirstChild().getNodeValue().trim());
    }
  }
  schemaBuilder.setQueryElementNames(elementNames);

  // Extract the filter, if it exists
  if (doc.getElementsByTagName("filter").item(0) != null)
  {
    schemaBuilder.setFilterTypeName(doc.getElementsByTagName("filter").item(0).getTextContent().trim());
  }

  // Create a filter over the query elements.
  schemaBuilder.setFilteredElementNames(extractFilteredElementNames(doc));

  // Extract the additional fields, if they exists
  Map<String,String> additionalFields = new HashMap<>();
  if (doc.getElementsByTagName("additional").item(0) != null)
  {
    NodeList fieldList = doc.getElementsByTagName("field");
    int numFields = fieldList.getLength();
    if (numFields == 0)
    {
      throw new PIRException("numFields = " + numFields + " -- should be at least one");
    }
    for (int i = 0; i < numFields; ++i)
    {
      Element fields = (Element) fieldList.item(i);
      NodeList kv = fields.getChildNodes();
      additionalFields.put(getNodeValue("key", kv), getNodeValue("value", kv));
    }
  }
  schemaBuilder.setAdditionalFields(additionalFields);

  // Create and return the query schema object.
  return schemaBuilder.build();
}
 

VcfPositionZipper(ReferenceRanges<String> rr, Set<String> forceMerge, File... vcfFiles) throws IOException {
  mFiles = vcfFiles;
  mReaders = new VcfReader[mFiles.length];
  mHeaders = new VcfHeader[mFiles.length];
  mIndexes = new TabixIndexReader[mFiles.length];
  VcfHeader current = null;
  int numSamples = 0;
  boolean warnNumSamples = true;
  for (int i = 0; i < mFiles.length; ++i) {
    final File vcfFile = mFiles[i];
    final VcfHeader header = VcfUtils.getHeader(vcfFile);
    mHeaders[i] = header;
    if (current != null) {
      current = VcfHeaderMerge.mergeHeaders(current, header, forceMerge);
      if (current.getNumberOfSamples() != numSamples && warnNumSamples) {
        Diagnostic.warning("When merging multiple samples the QUAL, FILTER, and INFO fields are taken from the first record at each position.");
        warnNumSamples = false;
      }
    } else {
      current = header;
      numSamples = current.getNumberOfSamples();
    }
    final File index = TabixIndexer.indexFileName(vcfFile);
    if (!TabixIndexer.isBlockCompressed(vcfFile)) {
      throw new NoTalkbackSlimException(vcfFile + " is not in bgzip format");
    } else if (!index.exists()) {
      throw new NoTalkbackSlimException("Index not found for file: " + index.getPath() + " expected index called: " + index.getPath());
    }
    mIndexes[i] = new TabixIndexReader(TabixIndexer.indexFileName(vcfFile));
  }
  mMergedHeader = current;

  if (rr == null) {
    final LinkedHashSet<String> chroms = new LinkedHashSet<>();
    if (!mMergedHeader.getContigLines().isEmpty()) {
      for (final ContigField cf : mMergedHeader.getContigLines()) {
        chroms.add(cf.getId());
      }
    }
    for (int i = 0; i < vcfFiles.length; ++i) {
      chroms.addAll(Arrays.asList(mIndexes[i].sequenceNames()));
    }
    final ReferenceRanges<String> rrr = SamRangeUtils.createExplicitReferenceRange(chroms);
    mRegions = chroms.stream().map(rrr::forSequence).collect(Collectors.toList());
  } else {
    mRegions = rr.sequenceNames().stream().map(rr::forSequence).collect(Collectors.toList());
  }
  populateNext();
}
 

/**
 * Find the best combination given the order (second way, koller's)
 */
@Override
public ParentSet[] search() {

    vars = smp.sample();

    done = new boolean[n_var];

    sk = 0;

    forbidden = new boolean[n_var];

    LinkedHashSet todo = new LinkedHashSet();

    for (int v = 0; v < n_var; v++) {
        todo.add(v);
    }

    // index of the best parent set for that variable so far (at start, it is 0 for every variable)
    int[] best_ps = new int[n_var];

    // weight for the importance sampling
    double[] ws = new double[n_var];

    // indexes
    int[] ix = new int[n_var];

    int last_chosen = -1;

    ParentSet best;

    for (int i = 0; i < n_var; i++) {

        double tot = 0;
        int j = 0;

        // For each variable that has not been chosen yet (n_var - i), build the weight array
        for (int v = 0; v < n_var; v++) {
            if (done[v]) {
                continue;
            }

            // Update the list of best parent sets; for each variable
            best = m_scores[v][best_ps[v]];
            // check if the last chosen blocks the current best, and find the new best
            if (last_chosen != -1 && find(last_chosen, best.parents)) {
                best_ps[v] = new_best(v, forbidden, best_ps[v]);
                best = m_scores[v][best_ps[v]];
            }

            // best_ps[v] has the best
            ws[j] = 1 / (-best.sk);
            tot += ws[j];
            ix[j] = v;
            j++;
        }

        // j now has the number of variables to check

        double r = solver.randDouble() - Math.pow(2, -10);
        int sel = -1;

        for (int v = 0; v < j && sel == -1; v++) {
            // Normalize weights
            double s = ws[v] /= tot;

            if (r < s) {
                sel = v;
            }
            r -= s;
        }

        // "sel" is the selected index
        int var = ix[sel];

        forbidden[var] = true;
        last_chosen = var;
        done[var] = true;
        str[var] = m_scores[var][best_ps[var]];
        sk += str[var].sk;

        // pf("%d %s \n", var, str[var]);
    }

    return str;
}
 

private static Map<String, ConfigModel> configs() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
    ConfigDef def = brokerConfigs();
    Map<String, String> dynamicUpdates = brokerDynamicUpdates();
    Method getConfigValueMethod = def.getClass().getDeclaredMethod("getConfigValue", ConfigDef.ConfigKey.class, String.class);
    getConfigValueMethod.setAccessible(true);

    Method sortedConfigs = ConfigDef.class.getDeclaredMethod("sortedConfigs");
    sortedConfigs.setAccessible(true);

    List<ConfigDef.ConfigKey> keys = (List) sortedConfigs.invoke(def);
    Map<String, ConfigModel> result = new TreeMap<>();
    for (ConfigDef.ConfigKey key : keys) {
        String configName = String.valueOf(getConfigValueMethod.invoke(def, key, "Name"));
        Type type = parseType(String.valueOf(getConfigValueMethod.invoke(def, key, "Type")));
        Scope scope = parseScope(dynamicUpdates.getOrDefault(key.name, "read-only"));
        ConfigModel descriptor = new ConfigModel();
        descriptor.setType(type);
        descriptor.setScope(scope);

        if (key.validator instanceof ConfigDef.Range) {
            descriptor = range(key, descriptor);
        } else if (key.validator instanceof ConfigDef.ValidString) {
            descriptor.setValues(enumer(key.validator));
        } else if (key.validator instanceof ConfigDef.ValidList) {
            descriptor.setItems(validList(key));
        } else if (key.validator instanceof ApiVersionValidator$) {
            Iterator<ApiVersion> iterator = ApiVersion$.MODULE$.allVersions().iterator();
            LinkedHashSet<String> versions = new LinkedHashSet<>();
            while (iterator.hasNext()) {
                ApiVersion next = iterator.next();
                ApiVersion$.MODULE$.apply(next.shortVersion());
                versions.add(Pattern.quote(next.shortVersion()) + "(\\.[0-9]+)*");
                ApiVersion$.MODULE$.apply(next.version());
                versions.add(Pattern.quote(next.version()));
            }
            descriptor.setPattern(String.join("|", versions));
        } else if (key.validator != null) {
            throw new IllegalStateException(key.validator.getClass().toString());
        }
        result.put(configName, descriptor);
    }
    return result;
}
 

/**
 * Semantically equivalent to 'flavorToNative.get(flav)'. This method
 * handles the case where 'flav' is not found in 'flavorToNative' depending
 * on the value of passes 'synthesize' parameter. If 'synthesize' is
 * SYNTHESIZE_IF_NOT_FOUND a native is synthesized, stored, and returned by
 * encoding the DataFlavor's MIME type. Otherwise an empty List is returned
 * and 'flavorToNative' remains unaffected.
 */
private LinkedHashSet<String> flavorToNativeLookup(final DataFlavor flav,
                                                   final boolean synthesize) {

    LinkedHashSet<String> natives = getFlavorToNative().get(flav);

    if (flav != null && !disabledMappingGenerationKeys.contains(flav)) {
        DataTransferer transferer = DataTransferer.getInstance();
        if (transferer != null) {
            LinkedHashSet<String> platformNatives =
                transferer.getPlatformMappingsForFlavor(flav);
            if (!platformNatives.isEmpty()) {
                if (natives != null) {
                    // Prepend the platform-specific mappings to ensure
                    // that the natives added with
                    // addUnencodedNativeForFlavor() are at the end of
                    // list.
                    platformNatives.addAll(natives);
                }
                natives = platformNatives;
            }
        }
    }

    if (natives == null) {
        if (synthesize) {
            String encoded = encodeDataFlavor(flav);
            natives = new LinkedHashSet<>(1);
            getFlavorToNative().put(flav, natives);
            natives.add(encoded);

            LinkedHashSet<DataFlavor> flavors = getNativeToFlavor().get(encoded);
            if (flavors == null) {
                flavors = new LinkedHashSet<>(1);
                getNativeToFlavor().put(encoded, flavors);
            }
            flavors.add(flav);

            nativesForFlavorCache.remove(flav);
            flavorsForNativeCache.remove(encoded);
        } else {
            natives = new LinkedHashSet<>(0);
        }
    }

    return new LinkedHashSet<>(natives);
}
 

/**
 * Adds a mapping from the specified <code>DataFlavor</code> (and all
 * <code>DataFlavor</code>s equal to the specified <code>DataFlavor</code>)
 * to the specified <code>String</code> native.
 * Unlike <code>getNativesForFlavor</code>, the mapping will only be
 * established in one direction, and the native will not be encoded. To
 * establish a two-way mapping, call
 * <code>addFlavorForUnencodedNative</code> as well. The new mapping will
 * be of lower priority than any existing mapping.
 * This method has no effect if a mapping from the specified or equal
 * <code>DataFlavor</code> to the specified <code>String</code> native
 * already exists.
 *
 * @param flav the <code>DataFlavor</code> key for the mapping
 * @param nat the <code>String</code> native value for the mapping
 * @throws NullPointerException if flav or nat is <code>null</code>
 *
 * @see #addFlavorForUnencodedNative
 * @since 1.4
 */
public synchronized void addUnencodedNativeForFlavor(DataFlavor flav,
                                                     String nat) {
    Objects.requireNonNull(nat, "Null native not permitted");
    Objects.requireNonNull(flav, "Null flavor not permitted");

    LinkedHashSet<String> natives = getFlavorToNative().get(flav);
    if (natives == null) {
        natives = new LinkedHashSet<>(1);
        getFlavorToNative().put(flav, natives);
    }
    natives.add(nat);
    nativesForFlavorCache.remove(flav);
}