import gnu.trove.set.hash.TLinkedHashSet; //导入依赖的package包/类
/**
 * For a given set of completions for a search word puts them in histogram rank order.
 * Also ensures that if the searched for word was a known word that it will be included in the results.
 * 
 * @param currentWordCompletions The set of full word completions from the tries
 * @param word The word being searched for
 * @param limit Max number of results to return
 * @return A histogram ordered
 */
private Set<String> getSingleWordCompletions(Set<String> currentWordCompletions, String word, int limit) {
	Set<String> orderedWordCompletions = new TLinkedHashSet<String>(UnigramHistogram.getOrderedResults(unigramHistogram, currentWordCompletions, limit));
	
	// makes sense that if there is an exact match, it should show up in the results
	// logic here is that after the histogram ordering, if currentWordCompletions does
	// contain the word then it fell out in the histogram ordering so add it back at the end.
	boolean wordExactMatch = UnigramHistogram.contains(unigramHistogram, word);
	if (wordExactMatch && !orderedWordCompletions.contains(word)) {
		String[] words = orderedWordCompletions.toArray(new String[0]);
		orderedWordCompletions.remove(words[words.length - 1]);
		orderedWordCompletions.add(word);
	}

	return orderedWordCompletions;
}
 

import gnu.trove.set.hash.TLinkedHashSet; //导入依赖的package包/类
/**
 * Internal method to get the unordered completions for a single word.
 *  
 * @param word Word to get the completions for
 * @param fuzzyMatch provides character back-off and re-searching if no completions are found 
 * @param limit Max number of results to return
 * @return Not-null set of the suggested completions
 */
private Set<String> getCompletionsSingleWordUnordered(String word, boolean fuzzyMatch, int limit) {
	Set<String> completions = new TLinkedHashSet<String>();

	if (word != null && word.length() > 0) {
		for (CostString wordPlusPrefix : prefixTrie.getCompletions(new CostString(word), limit * 2, true)) {
			for (CostString completedWord : suffixTrie.getCompletions(wordPlusPrefix, limit * 2, true)) {
				completions.add(completedWord.str);
			}
		}

		if (fuzzyMatch && completions.isEmpty()) {
			completions.addAll(getCompletionsSingleWordUnordered(word.substring(0, word.length() - 1), fuzzyMatch, limit));
		}
	}

	return completions;
}
 

import gnu.trove.set.hash.TLinkedHashSet; //导入依赖的package包/类
@Override
public Set<IAgent> getNeighborsIn(final IScope scope, final int placeIndex, final int radius) {
	int[] n = neighborsIndexes[placeIndex];
	if (n == null) {
		n = new int[0];
		neighborsIndexes[placeIndex] = n;
	}
	final int size = n.length;
	if (radius > size) {
		computeNeighborsFrom(placeIndex, size + 1, radius);
	}
	final int[] nn = neighbors[placeIndex];
	final int nnSize = neighborsIndexes[placeIndex][radius - 1];
	final Set<IAgent> result = new TLinkedHashSet<>();
	for (int i = 0; i < nnSize; i++) {
		result.add(matrix.matrix[nn[i]].getAgent());
	}
	scope.getRandom().shuffle2(result);
	return result;
}
 

import gnu.trove.set.hash.TLinkedHashSet; //导入依赖的package包/类
public static IType<?> findCommonType(final IExpression[] elements, final int kind) {
	final IType<?> result = Types.NO_TYPE;
	if (elements.length == 0) { return result; }
	final Set<IType<?>> types = new TLinkedHashSet<>();
	for (final IExpression e : elements) {
		// TODO Indicates a previous error in compiling expressions. Maybe
		// we should cut this
		// part
		if (e == null) {
			continue;
		}
		final IType<?> eType = e.getType();
		types.add(kind == TYPE ? eType : kind == CONTENT ? eType.getContentType() : eType.getKeyType());
	}
	final IType<?>[] array = types.toArray(new IType[types.size()]);
	return findCommonType(array);
}
 

import gnu.trove.set.hash.TLinkedHashSet; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public List<String> getQueryableProperties() {
  if (queryableProperties == null) {
    synchronized (queryablePropertiesLock) {
      if (queryableProperties == null) {
        Set<String> queryablePropertiesSet = new TLinkedHashSet<>(1);
        List<IComponentDescriptor<?>> ancestorDescs = getAncestorDescriptors();
        if (ancestorDescs != null) {
          for (IComponentDescriptor<?> ancestorDescriptor : ancestorDescs) {
            queryablePropertiesSet.addAll(ancestorDescriptor.getQueryableProperties());
          }
        }
        for (String renderedProperty : getRenderedProperties()) {
          IPropertyDescriptor declaredPropertyDescriptor = getDeclaredPropertyDescriptor(renderedProperty);
          if (declaredPropertyDescriptor != null && declaredPropertyDescriptor.isQueryable()) {
            queryablePropertiesSet.add(renderedProperty);
          }
        }
        queryableProperties = new ArrayList<>(queryablePropertiesSet);
      }
    }
  }
  return explodeComponentReferences(this, queryableProperties);
}
 

import gnu.trove.set.hash.TLinkedHashSet; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public Collection<String> getServiceContractClassNames() {
  Set<String> serviceContractClassNames = new TLinkedHashSet<>(1);
  if (serviceContracts != null) {
    for (Class<?> serviceContract : serviceContracts) {
      serviceContractClassNames.add(serviceContract.getName());
    }
  } else {
    if (serviceDelegateClassNames != null) {
      serviceContractClassNames.addAll(serviceDelegateClassNames.keySet());
    }
    if (serviceDelegateBeanNames != null) {
      serviceContractClassNames.addAll(serviceDelegateBeanNames.keySet());
    }
  }
  return serviceContractClassNames;
}
 

import gnu.trove.set.hash.TLinkedHashSet; //导入依赖的package包/类
private Set<IAgent> computeNeighborsFrom(final IScope scope, final int placeIndex, final int begin, final int end) {
	final Set<IAgent> result = new TLinkedHashSet<>();
	for (int i = begin; i <= end; i++) {
		for (final Integer index : matrix.usesVN ? get4NeighborsAtRadius(placeIndex, i)
				: get8NeighborsAtRadius(placeIndex, i)) {
			result.add(matrix.matrix[index].getAgent());
		}
	}
	// Addresses Issue 1071 by explicitly shuffling the result
	scope.getRandom().shuffle2(result);
	return result;
}
 

import gnu.trove.set.hash.TLinkedHashSet; //导入依赖的package包/类
@Override
public Collection<IAgent> allAgents() {
	final Collection<IAgent> result = new TLinkedHashSet();
	for (int x = 0; x < detail; x++)
		for (int y = 0; y < detail; y++) {
			cells[x][y].findIntersects(bounds, result);
		}
	return result;
}
 

import gnu.trove.set.hash.TLinkedHashSet; //导入依赖的package包/类
@Override
public IAgent[] getAgentsStack() {
	final Set<IAgent> agents = new TLinkedHashSet<>();
	AgentExecutionContext current = agentContext;
	if (current == null) { return new IAgent[0]; }
	final int i = 0;
	while (current != null) {
		agents.add(current.getAgent());
		current = current.getOuterContext();
	}
	return agents.stream().toArray(IAgent[]::new);
}
 

import gnu.trove.set.hash.TLinkedHashSet; //导入依赖的package包/类
private void assertReturnedValueIsOk(final StatementDescription cd) {
	final IType at = cd.getType();
	if (at == Types.NO_TYPE) { return; }
	final Set<StatementDescription> returns = new TLinkedHashSet<>();
	cd.collectAllStatements(RETURN, returns);

	// Primitives dont need to be ckecked
	// if ( cd.getKeyword().equals(PRIMITIVE) ) { return; }
	if (returns.isEmpty()) {
		cd.error("Action " + cd.getName() + " must return a result of type " + at, IGamlIssue.MISSING_RETURN);
		return;
	}
	for (final StatementDescription ret : returns) {
		final IExpression ie = ret.getFacetExpr(VALUE);
		if (ie == null) {
			continue;
		}
		if (ie.equals(IExpressionFactory.NIL_EXPR)) {
			if (at.getDefault() != null) {
				ret.error("'nil' is not an acceptable return value. A valid " + at + " is expected instead.",
						IGamlIssue.WRONG_TYPE, VALUE);
			} else {
				continue;
			}
		} else {
			final IType<?> rt = ie.getType();
			if (!rt.isTranslatableInto(at)) {
				ret.error("Action " + cd.getName() + " must return a result of type " + at + " (and not " + rt
						+ ")", IGamlIssue.SHOULD_CAST, VALUE, at.toString());
			}
		}
	}
	// FIXME This assertion is still simple (i.e. the tree is not
	// verified to ensure that every
	// branch returns something)
}
 

import gnu.trove.set.hash.TLinkedHashSet; //导入依赖的package包/类
public Set<String> getExperimentTitles() {
	final Set<String> strings = new TLinkedHashSet();
	if (experiments != null) {
		experiments.forEachEntry((a, b) -> {
			if (b.getOriginName().equals(getName()))
				strings.add(b.getExperimentTitleFacet());
			return true;
		});
	}
	return strings;
}
 

import gnu.trove.set.hash.TLinkedHashSet; //导入依赖的package包/类
public Collection<String> getAttributeNames() {
	final Collection<String> accumulator =
			parent != null && parent != this ? parent.getAttributeNames() : new TLinkedHashSet<String>();
	if (attributes != null) {
		attributes.forEachKey(s -> {
			if (accumulator.contains(s))
				accumulator.remove(s);
			accumulator.add(s);
			return true;
		});
	}
	return accumulator;
}
 

import gnu.trove.set.hash.TLinkedHashSet; //导入依赖的package包/类
/**
 * Adds a new {@code IModelChangeListener}.
 *
 * @param listener
 *          The added listener.
 * @see IModelProvider#addModelChangeListener(IModelChangeListener)
 */
public synchronized void addModelChangeListener(IModelChangeListener listener) {
  if (listener != null) {
    if (listeners == null) {
      listeners = new TLinkedHashSet<>();
    }
    if (!listeners.contains(listener)) {
      listeners.add(listener);
    }
  }
}
 

import gnu.trove.set.hash.TLinkedHashSet; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public List<String> getRenderedProperties() {
  if (renderedProperties == null) {
    synchronized (renderedPropertiesLock) {
      if (renderedProperties == null) {
        Set<String> renderedPropertiesSet = new TLinkedHashSet<>(1);
        List<IComponentDescriptor<?>> ancestorDescs = getAncestorDescriptors();
        if (ancestorDescs != null) {
          for (IComponentDescriptor<?> ancestorDescriptor : ancestorDescs) {
            renderedPropertiesSet.addAll(ancestorDescriptor.getRenderedProperties());
          }
        }
        Collection<IPropertyDescriptor> declaredPropertyDescriptors = getDeclaredPropertyDescriptors();
        if (declaredPropertyDescriptors != null) {
          for (IPropertyDescriptor propertyDescriptor : declaredPropertyDescriptors) {
            if (!(propertyDescriptor instanceof ICollectionPropertyDescriptor<?>)
                && !(propertyDescriptor instanceof ITextPropertyDescriptor)
                && !(propertyDescriptor instanceof IObjectPropertyDescriptor)) {
              String propertyName = propertyDescriptor.getName();
              if (!propertyName.endsWith(RAW_SUFFIX) && !propertyName.endsWith(NLS_SUFFIX)) {
                renderedPropertiesSet.add(propertyName);
              }
            }
          }
        }
        renderedProperties = new ArrayList<>(renderedPropertiesSet);
      }
    }
  }
  return explodeComponentReferences(this, renderedProperties);
}
 

import gnu.trove.set.hash.TLinkedHashSet; //导入依赖的package包/类
/**
 * Registers a listener to be excluded (generally temporarily) from the
 * notification process without being removed from the actual listeners
 * collection.
 *
 * @param listener
 *          the excluded listener.
 */
public void addInhibitedListener(ISelectionChangeListener listener) {
  if (inhibitedListeners == null && listener != null) {
    inhibitedListeners = new TLinkedHashSet<>(1);
  }
  if (inhibitedListeners != null) {
    inhibitedListeners.add(listener);
  }
}
 

import gnu.trove.set.hash.TLinkedHashSet; //导入依赖的package包/类
/**
 * Adds a new listener to this source.
 *
 * @param listener
 *          The added listener.
 */
public synchronized void addItemSelectionListener(
    IItemSelectionListener listener) {
  if (listener != null) {
    if (listeners == null) {
      listeners = new TLinkedHashSet<>(1);
    }
    if (!listeners.contains(listener)) {
      listeners.add(listener);
    }
  }
}
 

import gnu.trove.set.hash.TLinkedHashSet; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public synchronized void addValueChangeListener(IValueChangeListener listener) {
  if (listener != null) {
    if (listeners == null) {
      listeners = new TLinkedHashSet<>(1);
    }
    if (!listeners.contains(listener)) {
      listeners.add(listener);
    }
  }
}
 

import gnu.trove.set.hash.TLinkedHashSet; //导入依赖的package包/类
/**
 * Gets the listeners.
 *
 * @return the listeners.
 */
@Override
public Set<IValueChangeListener> getValueChangeListeners() {
  if (listeners != null) {
    return new TLinkedHashSet<>(listeners);
  }
  return Collections.emptySet();
}
 

import gnu.trove.set.hash.TLinkedHashSet; //导入依赖的package包/类
@Override
public Collection<IAgent> allAgents() {
	final Collection<IAgent> result = new TLinkedHashSet();
	root.findIntersects(root.bounds, result);
	return result;
}
 

import gnu.trove.set.hash.TLinkedHashSet; //导入依赖的package包/类
@Override
protected void initCollect() {
	if (collect == null) {
		collect = new TLinkedHashSet<>();
	}
}