Java Code Examples for java.util.LinkedHashSet

public QuerySpec withQueryFilters(QueryFilter... queryFilters) {
    if (queryFilters == null) {
        this.queryFilters = null;
    } else {
        Set<String> names = new LinkedHashSet<String>();
        for (QueryFilter e : queryFilters) {
            names.add(e.getAttribute());
        }
        if (names.size() != queryFilters.length) {
            throw new IllegalArgumentException(
                    "attribute names must not duplicate in the list of query filters");
        }
        this.queryFilters = Arrays.asList(queryFilters);
    }
    return this;
}
 

protected T withCollectionParam(final String name, final Object value) {
    // Sanity test, if we got passed null, we should remove the collection
    if (value == null) {
        // This should remove it.
        return setParam(name, null);
    }

    // Sanity test, if we got passed a collection, we should handle it gracefully.
    if (value instanceof Collection) {
        return withCollectionParams(name, (Collection) value);
    }

    Collection<Object> existingValues = getParam(name);
    if (existingValues == null) {
        // Using linked hash set to preserve ordering.
        existingValues = new LinkedHashSet<>();
    }

    existingValues.add(value);

    return setParam(name, existingValues);
}
 

/**
 * Calculates the top event of the {@link BDD} based on a functionTransformer that delivers for each variable
 * {@code T} a double value.
 * 
 * @param <T>
 *            the type of variable
 * @param bdd
 *            the bdd
 * @param transformer
 *            the transformer that returns a double value for each variable
 * @return the top event of the bdd
 */
public static <T> double calculateTop(BDD<T> bdd, Transformer<T, Double> transformer) {
	if (bdd.isOne()) {
		return 1.0;
	}
	if (bdd.isZero()) {
		return 0.0;
	}

	Set<BDD<T>> upSort = new LinkedHashSet<>();
	traverseBDD(bdd, upSort);
	double top = evaluate(bdd, transformer, upSort);
	for (BDD<T> ups : upSort) {
		ups.free();
	}
	return top;
}
 

@Override
public Set<NitriteId> apply(final NitriteMap<NitriteId, Document> documentMap) {
    Set<NitriteId> result = new LinkedHashSet<>();
    ExecutorService executorService = nitriteService.getNitriteContext().getWorkerPool();

    try {
        List<Callable<Set<NitriteId>>> tasks = createTasks(filters, documentMap);

        List<Future<Set<NitriteId>>> futures = executorService.invokeAll(tasks);
        for (Future<Set<NitriteId>> future : futures) {
            Set<NitriteId> nitriteIds = future.get();
            if (nitriteIds != null) {
                result.addAll(nitriteIds);
            }
        }
    } catch (FilterException fe) {
        throw fe;
    } catch (Throwable t) {
        throw new FilterException(INVALID_OR_FILTER, t);
    }

    return result;
}
 

private static List<Vector3> doFindVector3s(final Scene scene) {
	final Set<Vector3> vector3s = new LinkedHashSet<>();
	
	for(final Shape shape : scene.getShapes()) {
		if(shape instanceof Plane) {
			final Plane plane = Plane.class.cast(shape);
			
			final Vector3 surfaceNormal = plane.getSurfaceNormal();
			
			vector3s.add(surfaceNormal);
		} else if(shape instanceof Triangle) {
			final Triangle triangle = Triangle.class.cast(shape);
			
			final Vector3 a = triangle.getA().getNormal();
			final Vector3 b = triangle.getB().getNormal();
			final Vector3 c = triangle.getC().getNormal();
			
			vector3s.add(a);
			vector3s.add(b);
			vector3s.add(c);
		}
	}
	
	return new ArrayList<>(vector3s);
}
 

@Test
public void zrangeByLex() {
  jedis.zadd("foo", 1, "aa");
  jedis.zadd("foo", 1, "c");
  jedis.zadd("foo", 1, "bb");
  jedis.zadd("foo", 1, "d");

  Set<String> expected = new LinkedHashSet<String>();
  expected.add("bb");
  expected.add("c");

  // exclusive aa ~ inclusive c
  assertEquals(expected, jedis.zrangeByLex("foo", "(aa", "[c"));

  expected.clear();
  expected.add("bb");
  expected.add("c");

  // with LIMIT
  assertEquals(expected, jedis.zrangeByLex("foo", "-", "+", 1, 2));
}
 

/**
 * Get child users of this group
 * @param paging Paging object with max number to return, and items to skip
 * @param sortBy What to sort on (authorityName, shortName or displayName)
 */
public ScriptUser[] getChildUsers(ScriptPagingDetails paging, String sortBy)
{
    if (childUsers == null)
    {
        Set<String> children = getChildNamesOfType(AuthorityType.USER);
        Set<ScriptUser> users = new LinkedHashSet<ScriptUser>();
        for (String authority : children)
        {
            ScriptUser user = new ScriptUser(authority, null, serviceRegistry, this.scope);
            users.add(user);
        }
        childUsers = users.toArray(new ScriptUser[users.size()]);
    }
    return makePagedAuthority(paging, sortBy, childUsers);
}
 

/**
 * Returns the AlloyType corresponding to the given sig; create an AlloyType
 * for it if none existed before.
 */
private void sigMETA(SubsetSig s) throws Err {
	AlloyAtom atom;
	AlloyType type = sig2type.get(s);
	if (type != null)
		return;
	type = makeType(s.label, s.isOne != null, s.isAbstract != null, false, s.isPrivate != null, s.isMeta != null,
			s.isEnum != null);
	atom = new AlloyAtom(type, Integer.MAX_VALUE, s.label);
	atom2sets.put(atom, new LinkedHashSet<AlloySet>());
	sig2atom.put(s, atom);
	sig2type.put(s, type);
	ts.put(type, AlloyType.SET);
	for (Sig p : ((SubsetSig) s).parents) {
		if (p instanceof SubsetSig)
			sigMETA((SubsetSig) p);
		else
			sigMETA((PrimSig) p);
		ins.add(new AlloyTuple(atom, sig2atom.get(p)));
	}
}
 

private ClassPath getToolingImpl() {
    if (!gradleHomeDir.exists()) {
        throw new IllegalArgumentException(String.format("The specified %s does not exist.", locationDisplayName));
    }
    if (!gradleHomeDir.isDirectory()) {
        throw new IllegalArgumentException(String.format("The specified %s is not a directory.", locationDisplayName));
    }
    File libDir = new File(gradleHomeDir, "lib");
    if (!libDir.isDirectory()) {
        throw new IllegalArgumentException(String.format("The specified %s does not appear to contain a Gradle distribution.", locationDisplayName));
    }
    LinkedHashSet<File> files = new LinkedHashSet<File>();
    for (File file : libDir.listFiles()) {
        if (hasExtension(file, ".jar")) {
            files.add(file);
        }
    }
    return new DefaultClassPath(files);
}
 

/** Returns every top-level user type that is itself visible or has a visible subtype.
 * @param vizState
 */
static Set<AlloyType> partiallyVisibleUserTopLevelTypes(final VizState vizState) {
   final AlloyModel model = vizState.getOriginalModel();
   final Set<AlloyType> visibleUserTypes = visibleUserTypes(vizState);
   //final Set<AlloyType> topLevelTypes = topLevelTypes(vizState);

   final Set<AlloyType> result = new LinkedHashSet<AlloyType>();

   for (final AlloyType t : visibleUserTypes) {
      if (visibleUserTypes.contains(t)) {
         result.add(model.getTopmostSuperType(t));
      }
   }

   return Collections.unmodifiableSet(result);
}
 

/**
 * Stores the Array in static for username + connectionId
 * 
 * @param array
 *            the Array to store
 */
public void put(Array array) {

	debug("Creating an array for user: " + connectionKey);
	if (array == null) {
		throw new IllegalArgumentException("array is null!");
	}

	Set<Array> arraySet = arrayMap.get(connectionKey);
	if (arraySet == null) {
		arraySet = new LinkedHashSet<Array>();
	}

	arraySet.add(array);
	arrayMap.put(connectionKey, arraySet);

}
 

/**
 * Makes a deep copy (for security)
 */
public Base deepClone() {
	Base newBase = new Base(getPosition().deepCopy(), teamName, team.deepCopy(), isHomeBase);
	
	newBase.energy = energy;
	newBase.setAlive(isAlive);
	newBase.id = id;
	newBase.maxEnergy = maxEnergy;
	newBase.currentPowerups = new LinkedHashSet<SpaceSettlersPowerupEnum>(currentPowerups);
	newBase.weaponCapacity = weaponCapacity;
	newBase.healingIncrement = healingIncrement;
	newBase.resources = new ResourcePile();
	newBase.resources.add(resources);
	newBase.numFlags = numFlags;
	return newBase;
}
 

/**
 * Return an unordered set all the foreign key ancestor tables for the given table
 * @param catalog_tbl
 */
public Collection<Table> getAncestors(Table catalog_tbl) {
    Database catalog_db = (Database) catalog_tbl.getParent();
    Set<Table> ret = new LinkedHashSet<Table>();
    String key = CatalogKey.createKey(catalog_tbl);
    for (String ancestor_key : this.table_ancestors.get(key)) {
        // If this table is missing from the catalog, then we want to stop
        // the ancestor list
        Table ancestor_tbl = CatalogKey.getFromKey(catalog_db, ancestor_key, Table.class);
        if (ancestor_tbl == null)
            break;
        // Otherwise, add it to our list
        ret.add(ancestor_tbl);
    } // FOR
    return (ret);
}
 

public Set<String> getAndRemZRange(String key, long score) {
  Jedis jedis = null;
  try {
    jedis = pool.getResource();
    Transaction trans = jedis.multi();
    trans.zrangeByScore(key.getBytes(), MIN_INF, SafeEncoder.encode(String.valueOf(score)));
    trans.zremrangeByScore(key.getBytes(), MIN_INF, SafeEncoder.encode(String.valueOf(score)));
    List<Object> response = trans.exec();
    Set<byte[]> data = (Set<byte[]>) response.get(0);
    Set<String> members = new LinkedHashSet<>(data.size());
    for (byte[] d : data) {
      members.add(new String(d));
    }
    pool.returnResource(jedis);
    return members;
  } catch (Exception e) {
    LOGGER.warn("Failed to get zrem keys from cache {0}:{1}", key, score, e);
    pool.returnBrokenResource(jedis);
    throw e;
  }
}
 

private synchronized Collection<AntLogger> getInterestedLoggersByTask(String task) {
    Collection<AntLogger> c = interestedLoggersByTask.get(task);
    if (c == null) {
        c = new LinkedHashSet<AntLogger>(interestedLoggers.size());
        interestedLoggersByTask.put(task, c);
        for (AntLogger l : interestedLoggers) {
            String[] tasks = l.interestedInTasks(thisSession);
            if (tasks == AntLogger.ALL_TASKS ||
                    (task != null && Arrays.asList(tasks).contains(task)) ||
                    (task == null && tasks == AntLogger.NO_TASKS)) {
                c.add(l);
            }
        }
        LOG.log(Level.FINEST, "getInterestedLoggersByTask: task={0} loggers={1}", new Object[] {task, c});
    }
    return c;
}
 

@SuppressWarnings("unchecked")
public Set<String> build(Object data) {
  if (null == data) {
    return null;
  }
  List<byte[]> l = (List<byte[]>) data;
  final Set<String> result = new LinkedHashSet<String>(l.size());
  for (final byte[] barray : l) {
    if (barray == null) {
      result.add(null);
    } else {
      result.add(SafeEncoder.encode(barray));
    }
  }
  return result;
}
 

public void unregisterThrower(Class<?> interfaceClass, IEventThrower<?> thrower, boolean keepSubscribers){
	synchronized (EVENT_THROWERS) {
		if(EVENT_THROWERS.containsKey(interfaceClass)){
			LinkedHashSet<IEventThrower<?>> list = EVENT_THROWERS.get(interfaceClass);
			if(keepSubscribers){
				Queue<Object> toKeep = new ArrayDeque<>();
				Iterator<?> subscribers = thrower.getSubscribers();
				while(subscribers.hasNext()){
					Object listener = subscribers.next();
					toKeep.add(listener);
				}
				if(!QUEUED_LISTENERS.containsKey(interfaceClass)){
					QUEUED_LISTENERS.put(interfaceClass, toKeep);
				}
			}else{
				thrower.clearSubscribers();
			}
			list.remove(thrower);
			if(list.isEmpty()){
				EVENT_THROWERS.remove(interfaceClass);	
			}
		}
	}
}
 

private void loadAll() {
    mFiles = new LinkedHashSet<String>();
    mDirs = new LinkedHashMap<String, AbstractDirectory>();
    
    File[] files = getDir().listFiles();
    for (int i = 0; i < files.length; i++) {
        File file = files[i];
        if (file.isFile()) {
            mFiles.add(file.getName());
        } else {
            // IMPOSSIBLE_EXCEPTION
            try {
                mDirs.put(file.getName(), new FileDirectory(file));
            } catch (DirectoryException e) {}
        }
    }
}
 

/**
 * Stores the Savepoint in static for username + connectionId
 * 
 * @param savepoint
 *            the Savepoint to store
 */
public void put(Savepoint savepoint) {

	debug("Creating a Savepoint for user: " + connectionKey);
	if (savepoint == null) {
		throw new IllegalArgumentException("savepoint is null!");
	}

	Set<Savepoint> savepointSet = savepointMap.get(connectionKey);
	if (savepointSet == null) {
		savepointSet = new LinkedHashSet<Savepoint>();
	}

	savepointSet.add(savepoint);
	savepointMap.put(connectionKey, savepointSet);
}
 

/**
 * Returns the total number of annotations.
 */
int countAnnotations() {
	Set<Annotation> set = new LinkedHashSet<Annotation>();
	for (Layer layer : layers.values())
		set.addAll(layer);
	return set.size();
}
 

List getAopTypesValue(ConditionContext context){
    String aopTypesKey = DruidStatProperties.DRUID_STAT_PREFIX+".aop-types";
    Set<String> keySet = new LinkedHashSet<String>();
    for (int i = 0; i <3 ; i++) {
        String field = context.getEnvironment().getProperty(aopTypesKey+"["+i+"]", String.class);
        if (!StringUtils.isEmpty(field))
            keySet.add(field.toLowerCase());
    }
    if (keySet.size() > 0 ){
        return new ArrayList<String>(keySet);
    }else {
        return new ArrayList<String>();
    }

}
 

/**
 * Prunes the forest by making sure that every node is either
 * a root, or a child of exactly one parent.
 */
public void prune() {
    Collection<LayoutNode> remaining = one();
    // Add real roots one by one
    List<LayoutNode> roots = new ArrayList<>();
    while (!remaining.isEmpty()) {
        Iterator<LayoutNode> remainingIter = remaining.iterator();
        LayoutNode root = remainingIter.next();
        roots.add(root);
        remainingIter.remove();
        // compute reachable children and take them from remaining candidate roots
        // also adjust the branch sets of the reachable leaves
        Set<LayoutNode> children = new LinkedHashSet<>();
        children.add(root);
        while (!children.isEmpty()) {
            Iterator<LayoutNode> childIter = children.iterator();
            LayoutNode child = childIter.next();
            childIter.remove();
            // look up the next generation
            Set<LayoutNode> branches = getBranches(child);
            // restrict to remaining layoutables
            branches.retainAll(remaining);
            children.addAll(branches);
            // remove the new branches from the remaining candidate roots
            remaining.removeAll(branches);
        }
    }
    setOne(roots);
}
 

/**
 * 将字符串词性转为Enum词性
 * @param name 词性名称
 * @param customNatureCollector 一个收集集合
 * @return 转换结果
 */
public static Nature convertStringToNature(String name, LinkedHashSet<Nature> customNatureCollector)
{
    try
    {
        return Nature.valueOf(name);
    }
    catch (Exception e)
    {
        Nature nature = CustomNatureUtility.addNature(name);
        if (customNatureCollector != null) customNatureCollector.add(nature);
        return nature;
    }
}
 

/**
 * Geef de waarde van betrokkenheid set.
 * @param soortBetrokkenheid soort betrokkenheid
 * @return betrokkenheid set
 */
public Set<Betrokkenheid> getBetrokkenheidSet(final SoortBetrokkenheid soortBetrokkenheid) {
    final Set<Betrokkenheid> result = new LinkedHashSet<>();
    for (final Betrokkenheid betrokkenheid : betrokkenheidSet) {
        if (soortBetrokkenheid.equals(betrokkenheid.getSoortBetrokkenheid())) {
            result.add(betrokkenheid);
        }
    }
    return result;
}
 

/**
 * 去重提取
 * 
 * @param memberList
 * @return
 */
private Set<String> formatEmailDuplicateRemoval(List<Map<String, String>> memberList) {

    Set<String> emails = new LinkedHashSet<String>();
    for (Map<String, String> map : memberList) {
        String emailList = map.get("emailList");
        String[] splits = emailList.split(",");
        for (int i = 0; i < splits.length; i++) {
            emails.add(splits[i]);
        }
    }

    return emails;
}
 

SymmInfo(int size) {
	this.parts = new LinkedHashSet<IntSet>();
	for (int i = 0, max = size; i < max; i++) {
		parts.add(Ints.singleton(i));
	}
	this.time = "t\\o";
	this.symms = "t\\o";
}
 

public CommandRegistry(ConsoleLogger logger, Command[] commands) {
    this.logger = logger;
    this.commands = new LinkedHashSet<>(asList(commands));
    this.commands.add(new ShowCommand(logger));
    this.commands.add(new ExitCommand(logger));
    this.commands.add(new ResetProgressionCommand(logger));
    this.commands.add(this);
}
 

private static Set<String> getModifiers(int flags, int[] modifierFlags, Kind t) {
    Set<String> s = new LinkedHashSet<>();
    for (int m: modifierFlags) {
        if ((flags & m) != 0)
            s.add(flagToModifier(m, t));
    }
    return s;
}
 

private static List<Surface> doFindSurfaces(final Scene scene) {
	final Set<Surface> surfaces = new LinkedHashSet<>();
	
	for(final Shape shape : scene.getShapes()) {
		final Surface surface = shape.getSurface();
		
		surfaces.add(surface);
	}
	
	return new ArrayList<>(surfaces);
}
 

/**
 * Obtain a resource object for the given name and type through autowiring
 * based on the given factory.
 * @param factory the factory to autowire against
 * @param element the descriptor for the annotated field/method
 * @param requestingBeanName the name of the requesting bean
 * @return the resource object (never {@code null})
 * @throws BeansException if we failed to obtain the target resource
 */
protected Object autowireResource(BeanFactory factory, LookupElement element, String requestingBeanName)
		throws BeansException {

	Object resource;
	Set<String> autowiredBeanNames;
	String name = element.name;

	if (this.fallbackToDefaultTypeMatch && element.isDefaultName &&
			factory instanceof AutowireCapableBeanFactory && !factory.containsBean(name)) {
		autowiredBeanNames = new LinkedHashSet<String>();
		resource = ((AutowireCapableBeanFactory) factory).resolveDependency(
				element.getDependencyDescriptor(), requestingBeanName, autowiredBeanNames, null);
	}
	else {
		resource = factory.getBean(name, element.lookupType);
		autowiredBeanNames = Collections.singleton(name);
	}

	if (factory instanceof ConfigurableBeanFactory) {
		ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) factory;
		for (String autowiredBeanName : autowiredBeanNames) {
			if (beanFactory.containsBean(autowiredBeanName)) {
				beanFactory.registerDependentBean(autowiredBeanName, requestingBeanName);
			}
		}
	}

	return resource;
}
 

private void setTagApps(List<AppAndTag> list, AppTopic topic) {
    Set<TagApps> tagApps = new LinkedHashSet<TagApps>();
    for (AppAndTag appAndTag : list) {
        if (topic.getId() == appAndTag.getTag().getId()) {
            tagApps.add(new TagApps(appAndTag.getId(), appAndTag.getRank(), "", appAndTag.getApp()));
        }
    }
    topic.setTagApps(tagApps);
}
 

/** Returns all of the top-level types in the original model.
 * @param vizState
 */
static Set<AlloyType> topLevelTypes(final VizState vizState) {
   final Set<AlloyType> result = new LinkedHashSet<AlloyType>();
   final AlloyModel model = vizState.getOriginalModel();
   for (final AlloyType t : model.getTypes()) {
      if (vizState.isTopLevel(t)) {
         result.add(t);
      }
   }
   return Collections.unmodifiableSet(result);
}
 

@Test
public void zrangeWithScores() {
  jedis.zadd("foo", 1d, "a");
  jedis.zadd("foo", 10d, "b");
  jedis.zadd("foo", 0.1d, "c");
  jedis.zadd("foo", 2d, "a");

  Set<Tuple> expected = new LinkedHashSet<Tuple>();
  expected.add(new Tuple("c", 0.1d));
  expected.add(new Tuple("a", 2d));

  Set<Tuple> range = jedis.zrangeWithScores("foo", 0, 1);
  assertEquals(expected, range);

  expected.add(new Tuple("b", 10d));
  range = jedis.zrangeWithScores("foo", 0, 100);
  assertEquals(expected, range);

  // Binary
  jedis.zadd(bfoo, 1d, ba);
  jedis.zadd(bfoo, 10d, bb);
  jedis.zadd(bfoo, 0.1d, bc);
  jedis.zadd(bfoo, 2d, ba);

  Set<Tuple> bexpected = new LinkedHashSet<Tuple>();
  bexpected.add(new Tuple(bc, 0.1d));
  bexpected.add(new Tuple(ba, 2d));

  Set<Tuple> brange = jedis.zrangeWithScores(bfoo, 0, 1);
  assertEquals(bexpected, brange);

  bexpected.add(new Tuple(bb, 10d));
  brange = jedis.zrangeWithScores(bfoo, 0, 100);
  assertEquals(bexpected, brange);

}
 

public SearchLayer addIgnored(String first, String... rest) {
  if (this.ignored == null) {
    this.ignored = new LinkedHashSet<>();
  }
  this.ignored.addAll(Lists.asList(first, rest));
  return this;
}
 

Set<File> getAllFiles () {
    if (allFiles == null) {
        allFiles = new LinkedHashSet<File> ();
        addFiles (loadPresistentState ());
    }
    return allFiles;
}
 

private LinkedHashSet<String> getPersistedCache() {
  String serialized = prefs.getString(EMOJI_LRU_PREFERENCE, "[]");
  try {
    CollectionType collectionType = TypeFactory.defaultInstance()
                                               .constructCollectionType(LinkedHashSet.class, String.class);
    return JsonUtils.getMapper().readValue(serialized, collectionType);
  } catch (IOException e) {
    Log.w(TAG, e);
    return new LinkedHashSet<>();
  }
}
 

private static Collection<String> createRequestSubprotocols(
        Collection<String> subprotocols)
{
    LinkedHashSet<String> sp = new LinkedHashSet<>(subprotocols.size(), 1);
    for (String s : subprotocols) {
        if (s.trim().isEmpty() || !isValidName(s)) {
            throw illegal("Bad subprotocol syntax: " + s);
        }
        if (!sp.add(s)) {
            throw illegal("Duplicating subprotocol: " + s);
        }
    }
    return Collections.unmodifiableCollection(sp);
}
 

private String[] toReversePrimitiveArray(@NonNull LinkedHashSet<String> emojiSet) {
  String[] emojis = new String[emojiSet.size()];
  int i = emojiSet.size() - 1;
  for (String emoji : emojiSet) {
    emojis[i--] = emoji;
  }
  return emojis;
}
 

@Test
public void zremrangeByScore() {
  jedis.zadd("foo", 1d, "a");
  jedis.zadd("foo", 10d, "b");
  jedis.zadd("foo", 0.1d, "c");
  jedis.zadd("foo", 2d, "a");

  long result = jedis.zremrangeByScore("foo", 0, 2);

  assertEquals(2, result);

  Set<String> expected = new LinkedHashSet<String>();
  expected.add("b");

  assertEquals(expected, jedis.zrange("foo", 0, 100));

  // Binary
  jedis.zadd(bfoo, 1d, ba);
  jedis.zadd(bfoo, 10d, bb);
  jedis.zadd(bfoo, 0.1d, bc);
  jedis.zadd(bfoo, 2d, ba);

  long bresult = jedis.zremrangeByScore(bfoo, 0, 2);

  assertEquals(2, bresult);

  Set<byte[]> bexpected = new LinkedHashSet<byte[]>();
  bexpected.add(bb);

  assertByteArraySetEquals(bexpected, jedis.zrange(bfoo, 0, 100));
}
 

/**
 * Retrieves all dependencies with given kind(s).
 */
protected Set<Node> getDependencies(DependencyKind... depKinds) {
    Set<Node> buf = new LinkedHashSet<Node>();
    for (DependencyKind dk : depKinds) {
        Set<Node> depsByKind = deps.get(dk);
        if (depsByKind != null) {
            buf.addAll(depsByKind);
        }
    }
    return buf;
}
 

/**
 * Create an instance of PolicyInformation
 *
 * @param policyIdentifier the policyIdentifier as a
 *          CertificatePolicyId
 * @param policyQualifiers a Set of PolicyQualifierInfo objects.
 *          Must not be NULL. Specify an empty Set for no qualifiers.
 * @exception IOException on decoding errors.
 */
public PolicyInformation(CertificatePolicyId policyIdentifier,
        Set<PolicyQualifierInfo> policyQualifiers) throws IOException {
    if (policyQualifiers == null) {
        throw new NullPointerException("policyQualifiers is null");
    }
    this.policyQualifiers =
        new LinkedHashSet<PolicyQualifierInfo>(policyQualifiers);
    this.policyIdentifier = policyIdentifier;
}
 

@Override
@SuppressWarnings("unchecked")
public Set<NitriteId> apply(NitriteMap<NitriteId, Document> documentMap) {
    if (elementFilter instanceof ElemMatchObjectFilter) {
        throw new FilterException(NESTED_OBJ_ELEM_MATCH_NOT_SUPPORTED);
    }

    if (elementFilter instanceof TextObjectFilter) {
        throw new FilterException(FULL_TEXT_OBJ_ELEM_MATCH_NOT_SUPPORTED);
    }

    elementFilter.setNitriteService(nitriteService);
    elementFilter.setNitriteMapper(nitriteMapper);

    Set<NitriteId> nitriteIdSet = new LinkedHashSet<>();
    for (Map.Entry<NitriteId, Document> entry: documentMap.entrySet()) {
        Document document = entry.getValue();
        Object fieldValue = getFieldValue(document, field);

        if (fieldValue == null) {
            continue;
        }

        if (fieldValue instanceof Iterable) {
            if (matches((Iterable) fieldValue, elementFilter)) {
                nitriteIdSet.add(entry.getKey());
            }
        } else {
            throw new FilterException(OBJ_ELEM_MATCH_SUPPORTED_ON_ARRAY_ONLY);
        }
    }
    return nitriteIdSet;
}
 

/**
 * Returns {@code @Import} class, considering all meta-annotations.
 */
private Set<SourceClass> getImports(SourceClass sourceClass) throws IOException {
	Set<SourceClass> imports = new LinkedHashSet<SourceClass>();
	Set<SourceClass> visited = new LinkedHashSet<SourceClass>();
	collectImports(sourceClass, imports, visited);
	return imports;
}
 

/**
 * Returns a new instance with a union of the HTTP request types
 * from "this" and the "other" instance.
 */
@Override
public WxMessageTypeCondition combine(AbstractWxEnumCondition other) {
    Set<WxMessage.Type> set = new LinkedHashSet(this.enums);
    set.addAll(other.enums);
    return new WxMessageTypeCondition(set);
}
 

@Test
void testCheckerHasMeasuresShortCut() {
	Set<Detail> errors = new LinkedHashSet<>();
	Detail err = new Detail();
	err.setMessage("test");
	errors.add(err);
	Node root = new Node();
	Checker.check(root, errors)
			.hasMeasures(ERROR_MESSAGE, "MeasureId");

	assertWithMessage("Checker should return one validation error")
			.that(errors)
			.comparingElementsUsing(DetailsErrorEquals.INSTANCE)
			.containsExactly(new FormattedErrorCode(null, "test"));
}
 

public Collection<TestSelection> getTests() {
    ClassDependenciesGraph classDependenciesGraph = configureTestClassDetector();

    // TODO this operations should be done in extension to avoid scanning for all modules.
    // TODO In case of Arquillian core is an improvement of 500 ms per module
    // Scan disk finding all tests of current project

    final long beforeDetection = System.currentTimeMillis();

    final Set<File> allTestsOfCurrentProject = this.testClassDetector.detect();
    classDependenciesGraph.buildTestDependencyGraph(allTestsOfCurrentProject);

    final Collection<Change> files = changeStorage.read(projectDir)
        .orElseGet(() -> {
            logger.warn("No cached changes detected... using direct resolution");
            return changeResolver.diff(projectDir, configuration, getName());
        });

    logger.debug("Time To Build Affected Dependencies Graph %d ms", (System.currentTimeMillis() - beforeDetection));

    final long beforeFind = System.currentTimeMillis();

    final Set<TestSelection> affected = classDependenciesGraph.findTestsDependingOn(files)
        .stream()
        .map(s -> new TestSelection(s, "affected"))
        .collect(Collectors.toCollection(LinkedHashSet::new));

    logger.debug("Time To Find Affected Tests %d ms", (System.currentTimeMillis() - beforeFind));

    return affected;
}
 

/**
 * Find in the given resource the native languages corresponding to the element at the root of the resource
 * (built as a set in order to have no duplicate)
 * @param res
 * @return a list of all the native languages of the root elements of the resource  
 */
public static List<String> getNativeLanguagesUsedByResource(Resource res){
	LinkedHashSet<String> usedLanguages = new LinkedHashSet<String>();
	for(EObject eobj : res.getContents()){
		usedLanguages.addAll(getLanguageNamesForURI(eobj.eClass().eResource().getURI().toString()));
	}
	List<String> languagesNames = new ArrayList<String>();
	languagesNames.addAll(usedLanguages);
	return languagesNames;
}
 

private String[] toReversePrimitiveArray(LinkedHashSet<String> emojiSet) {
	String[] emojis = new String[emojiSet.size()];
	int i = emojiSet.size() - 1;
	for (String emoji : emojiSet) {
		emojis[i--] = emoji;
	}
	return emojis;
}
 

/**
 * 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);
    }
}
 

ConsistentContinuousResourceSubStore(StorageService service) {
    this.consumers = service.<ContinuousResourceId, ContinuousResourceAllocation>consistentMapBuilder()
            .withName(MapNames.CONTINUOUS_CONSUMER_MAP)
            .withSerializer(SERIALIZER)
            .build();
    this.childMap = service.<DiscreteResourceId, Set<ContinuousResource>>consistentMapBuilder()
            .withName(MapNames.CONTINUOUS_CHILD_MAP)
            .withSerializer(SERIALIZER)
            .build();

    childMap.put(Resource.ROOT.id(), new LinkedHashSet<>());
}
 

@PostMapping
public String post(@RequestParam(required = false) String tags, @RequestParam(required = false) String latlng,
		@RequestParam(required = false) String replyEmailsOn, @RequestParam(required = false) String commentEmailsOn,
		@RequestParam(required = false) String oldpassword, @RequestParam(required = false) String newpassword,
		HttpServletRequest req) {
	if (utils.isAuthenticated(req)) {
		Profile authUser = utils.getAuthUser(req);
		if (!StringUtils.isBlank(tags)) {
			Set<String> ts = new LinkedHashSet<String>();
			for (String tag : tags.split(",")) {
				if (!StringUtils.isBlank(tag) && ts.size() <= MAX_FAV_TAGS) {
					ts.add(tag);
				}
			}
			authUser.setFavtags(new LinkedList<String>(ts));
		}
		if (!StringUtils.isBlank(latlng)) {
			authUser.setLatlng(latlng);
		}
		authUser.setReplyEmailsEnabled(Boolean.valueOf(replyEmailsOn));
		authUser.setCommentEmailsEnabled(Boolean.valueOf(commentEmailsOn));
		authUser.update();

		if (resetPasswordAndUpdate(authUser.getUser(), oldpassword, newpassword)) {
			return "redirect:" + SETTINGSLINK + "?passChanged=true";
		}
	}
	return "redirect:" + SETTINGSLINK;
}
 

@Test
public void zrevrange() {
  jedis.zadd("foo", 1d, "a");
  jedis.zadd("foo", 10d, "b");
  jedis.zadd("foo", 0.1d, "c");
  jedis.zadd("foo", 2d, "a");

  Set<String> expected = new LinkedHashSet<String>();
  expected.add("b");
  expected.add("a");

  Set<String> range = jedis.zrevrange("foo", 0, 1);
  assertEquals(expected, range);

  expected.add("c");
  range = jedis.zrevrange("foo", 0, 100);
  assertEquals(expected, range);

  // Binary
  jedis.zadd(bfoo, 1d, ba);
  jedis.zadd(bfoo, 10d, bb);
  jedis.zadd(bfoo, 0.1d, bc);
  jedis.zadd(bfoo, 2d, ba);

  Set<byte[]> bexpected = new LinkedHashSet<byte[]>();
  bexpected.add(bb);
  bexpected.add(ba);

  Set<byte[]> brange = jedis.zrevrange(bfoo, 0, 1);
  assertByteArraySetEquals(bexpected, brange);

  bexpected.add(bc);
  brange = jedis.zrevrange(bfoo, 0, 100);
  assertByteArraySetEquals(bexpected, brange);

}
 

protected static Set<String> deletePrimary(Collection<String> nodeRefs, IndexReader reader, boolean delete)
        throws LuceneIndexException
{

    Set<String> refs = new LinkedHashSet<String>();

    for (String nodeRef : nodeRefs)
    {

        try
        {
            TermDocs td = reader.termDocs(new Term("PRIMARYPARENT", nodeRef));
            while (td.next())
            {
                int doc = td.doc();
                Document document = reader.document(doc);
                String[] ids = document.getValues("ID");
                refs.add(ids[ids.length - 1]);
                if (delete)
                {
                    reader.deleteDocument(doc);
                }
            }
            td.close();
        }
        catch (IOException e)
        {
            throw new LuceneIndexException("Failed to delete node by primary parent for " + nodeRef, e);
        }
    }

    return refs;

}
 

/**
 * Returns the set of actions occurring on control edges,
 * either on this level or recursively within function calls.
 */
public Set<Action> getActions() {
    Set<Action> result = new LinkedHashSet<>();
    Set<Function> seen = new HashSet<>();
    Queue<Template> todo = new LinkedList<>();
    todo.add(this);
    while (!todo.isEmpty()) {
        Template t = todo.poll();
        for (Location loc : t.getLocations()) {
            if (!loc.isTrial()) {
                continue;
            }
            for (SwitchStack swit : loc.getAttempt()) {
                Callable unit = swit.getBottomCall()
                    .getUnit();
                if (unit instanceof Action) {
                    result.add((Action) unit);
                } else {
                    Function function = (Function) unit;
                    Template fresh = ((Function) unit).getTemplate();
                    if (seen.add(function) && fresh != null) {
                        todo.add(fresh);
                    }
                }
            }
        }
    }
    return result;
}
 

@Override
public Set<RenderableDependency> getChildren() {
    Set<RenderableDependency> out = new LinkedHashSet<RenderableDependency>();
    for (DependencyResult d : module.getDependencies()) {
        if (d instanceof UnresolvedDependencyResult) {
            out.add(new RenderableUnresolvedDependencyResult((UnresolvedDependencyResult) d));
        } else {
            out.add(new RenderableDependencyResult((ResolvedDependencyResult) d));
        }
    }
    return out;
}
 

private Set<String> nonlinkedImports() {
  Set<String> lines = new LinkedHashSet<>();
  for (String a : imports.all) {
    if (a.startsWith("static ") || a.endsWith(".*")) {
      lines.add(a);
    }
  }
  return lines;
}
 

private Set<String> walkChapters(Set<String> chapterNames, Set<String> visitedChapters, SoloRoleplayData solo) {
	Set<String> result = new LinkedHashSet<String>();
	for (String chapterName:chapterNames) {
		Chapter chapter = solo.getChapter(chapterName);
		List<String> chapterRefs = chapter.collectAllChapterReferences();
		for (String chapterRef:chapterRefs) {
			if (result.contains(chapterRef) || visitedChapters.contains(chapterRef)) {
				continue;
			}
			result.add(chapterRef);
		}
	}
	return result;
}
 

/**
 * Returns a set of the unique names of all query parameters. Iterating
 * over the set will return the names in order of their first occurrence.
 *
 * @return a set of decoded names
 * @throws UnsupportedOperationException if this isn't a hierarchical URI
 */
public Set<String> getQueryParameterNames() {
    if (isOpaque()) {
        throw new UnsupportedOperationException(NOT_HIERARCHICAL);
    }

    String query = getEncodedQuery();
    if (query == null) {
        return Collections.emptySet();
    }

    Set<String> names = new LinkedHashSet<String>();
    int start = 0;
    do {
        int next = query.indexOf('&', start);
        int end = (next == -1) ? query.length() : next;

        int separator = query.indexOf('=', start);
        if (separator > end || separator == -1) {
            separator = end;
        }

        String name = query.substring(start, separator);
        names.add(decode(name));

        // Move start to end of name.
        start = end + 1;
    } while (start < query.length());

    return Collections.unmodifiableSet(names);
}
 

@Test public void queryParametersWithEmptyValues() throws Exception {
  HttpUrl url = HttpUrl.parse("http://host/?foo=&bar=&baz=");
  assertEquals(3, url.querySize());
  assertEquals(new LinkedHashSet<>(Arrays.asList("foo", "bar", "baz")),
      url.queryParameterNames());
  assertEquals("", url.queryParameterValue(0));
  assertEquals("", url.queryParameterValue(1));
  assertEquals("", url.queryParameterValue(2));
  assertEquals(singletonList(""), url.queryParameterValues("foo"));
  assertEquals(singletonList(""), url.queryParameterValues("bar"));
  assertEquals(singletonList(""), url.queryParameterValues("baz"));
}
 

@Override
public void accept(String s) {
    if (!s.equals(src)) { // quick check first
        src = s;
        try {
            Set<String> nextSrcs = new LinkedHashSet<>();
            boolean failed = false;
            while (true) {
                CompletionInfo an = analysis.analyzeCompletion(s);
                if (!an.completeness().isComplete()) {
                    break;
                }
                String tsrc = trimNewlines(an.source());
                if (!failed && !currSrcs.contains(tsrc)) {
                    failed = processCompleteSource(tsrc);
                }
                nextSrcs.add(tsrc);
                if (an.remaining().isEmpty()) {
                    break;
                }
                s = an.remaining();
            }
            currSrcs = nextSrcs;
        } catch (IllegalStateException ex) {
            hardmsg("jshell.msg.resetting");
            resetState();
            currSrcs = new LinkedHashSet<>(); // re-process everything
        }
    }
}