Java Code Examples for java.util.Collection

/** 
 * Sets up this AnimatorSet to play all of the supplied animations at the same time.
 * @param items The animations that will be started simultaneously.
 */
public void playTogether(Collection<Animator> items){
  if (items != null && items.size() > 0) {
    mNeedsSort=true;
    Builder builder=null;
    for (    Animator anim : items) {
      if (builder == null) {
        builder=play(anim);
      }
 else {
        builder.with(anim);
      }
    }
  }
}
 

/** 
 * Sets up this AnimatorSet to play all of the supplied animations at the same time.
 * @param items The animations that will be started simultaneously.
 */
public void playTogether(Collection<Animator> items){
  if (items != null && items.size() > 0) {
    mNeedsSort=true;
    Builder builder=null;
    for (    Animator anim : items) {
      if (builder == null) {
        builder=play(anim);
      }
 else {
        builder.with(anim);
      }
    }
  }
}
 

/** 
 * This specifies how to implement  {@link #getChildren} and is used to deduce an appropriate feature for an{@link org.eclipse.emf.edit.command.AddCommand},  {@link org.eclipse.emf.edit.command.RemoveCommand} or{@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}. <!-- begin-user-doc --> <!-- end-user-doc -->
 * @generated
 */
@Override public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object){
  if (childrenFeatures == null) {
    super.getChildrenFeatures(object);
    childrenFeatures.add(ScalaPackage.Literals.CLASSIFIER__FIELDS);
    childrenFeatures.add(ScalaPackage.Literals.CLASSIFIER__METHODS);
    childrenFeatures.add(ScalaPackage.Literals.CLASS__CONSTRUCTORS);
  }
  return childrenFeatures;
}
 

/** 
 * This specifies how to implement  {@link #getChildren} and is used to deduce an appropriate feature for an{@link org.eclipse.emf.edit.command.AddCommand},  {@link org.eclipse.emf.edit.command.RemoveCommand} or{@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}. <!-- begin-user-doc --> <!-- end-user-doc -->
 * @generated
 */
@Override public Collection<? extends EStructuralFeature> getChildrenFeatures(Object object){
  if (childrenFeatures == null) {
    super.getChildrenFeatures(object);
    childrenFeatures.add(WebappPackage.Literals.APPLICATION__ROUTER);
    childrenFeatures.add(WebappPackage.Literals.APPLICATION__COLLECTIONS);
    childrenFeatures.add(WebappPackage.Literals.APPLICATION__VIEWS);
    childrenFeatures.add(WebappPackage.Literals.APPLICATION__MODELS);
  }
  return childrenFeatures;
}
 

/** 
 * The partitions forming the split.
 * @param divideType Determinant of remainder distribution among partitions
 * @return The partitions with the original money "fairly" distributed.
 */
public Collection<Money> getPartitions(final DivideType divideType){
  return new AbstractCollection<Money>(){
    @Override public Iterator<Money> iterator(){
      return new SplitIterator(divideType);
    }
    @Override public int size(){
      return partitions;
    }
  }
;
}
 

public Collection<LexicalRule> getLexRules(AbstractOption option){
  String catName=option.getCategoryName();
  Collection<LexicalRule> lexRules=new ArrayList<LexicalRule>();
  if (catName.equals("def_noun_sg")) {
    for (    Word w : getWordsByCategory("noun_sg")) {
      Preterminal cat=new Preterminal("def_noun_sg");
      cat.setFeature("noun",w.getWordForm());
      cat.setFeature("text","the " + w.getWordForm());
      lexRules.add(new LexicalRule(cat,"the " + w.getWordForm()));
    }
  }
 else   if (catName.equals("var")) {
    addVariableEntries(lexRules,"var");
  }
 else   if (catName.equals("ref")) {
    addVariableEntries(lexRules,"ref");
  }
 else   if (catName.equals("num")) {
    for (int i=2; i < 100; i++) {
      lexRules.add(new LexicalRule("num",i + ""));
    }
  }
 else   if (catName.equals("adj_prep")) {
    for (    Word w : getWordsByCategory("adj_tr")) {
      Preterminal p=new Preterminal("adj_prep");
      String prep=w.getCategory().getFeature("prep").getString();
      p.setFeature("prep",prep);
      lexRules.add(new LexicalRule(p,prep));
    }
  }
 else {
    for (    Word w : getWordsByCategory(catName)) {
      lexRules.add(w.getLexicalRule());
    }
  }
  return lexRules;
}
 

@Override public Collection<String> getAllTypes(){
  Collection<String> result=new ArrayList<String>();
  List<GoodwillSchema> goodwillSchemata=goodwillAccessor.getSchemata();
  for (  GoodwillSchema goodwillSchema : goodwillSchemata) {
    result.add(goodwillSchema.getName());
  }
  return result;
}
 

/** 
 * Sets up this AnimatorSet to play all of the supplied animations at the same time.
 * @param items The animations that will be started simultaneously.
 */
public void playTogether(Collection<Animator> items){
  if (items != null && items.size() > 0) {
    mNeedsSort=true;
    Builder builder=null;
    for (    Animator anim : items) {
      if (builder == null) {
        builder=play(anim);
      }
 else {
        builder.with(anim);
      }
    }
  }
}
 

public Collection<V> values(){
  return new AbstractCollection<V>(){
    @Override public Iterator<V> iterator(){
      return new ValueIterator();
    }
    @Override public int size(){
      return count;
    }
  }
;
}
 

private void deleteDeployments(Collection<String> deploymentIds){
  RepositoryService repositoryService=activitiRule.getRepositoryService();
  for (  String deploymentId : deploymentIds) {
    repositoryService.deleteDeployment(deploymentId);
  }
}
 

public Collection<?> getItemIds(){
  return new AbstractList<Integer>(){
    public int size(){
      return size();
    }
    public Integer get(    int index){
      return index;
    }
  }
;
}
 

@Override public Set<Entity> getDependencies(){
  HashSet<Entity> deps=new HashSet<Entity>();
  Collection<Category> categories=EntityUtil.flatten(getAlternatives());
  for (  Category category : categories) {
    deps.addAll(category.getDependencies());
  }
  deps.add(getIndication());
  deps.add(getOutcomeMeasure());
  deps.addAll(getIncludedStudies());
  return deps;
}
 

@Override public void execute(final CommandSender sender,final CommandArgs args) throws ActionNotPermitedException, PlayerNotFound {
  final Collection<String> list=Utils.getPlayerList(sender);
  sender.sendMessage(Utils.I18n("onlinePlayers") + " " + ChatColor.WHITE+ list.size());
  final String toDisplay=Joiner.on(", ").join(list);
  if (toDisplay.length() >= ACMinecraftFontWidthCalculator.chatwidth) {
    sender.sendMessage(toDisplay.substring(0,ACMinecraftFontWidthCalculator.chatwidth));
    sender.sendMessage(toDisplay.substring(ACMinecraftFontWidthCalculator.chatwidth,toDisplay.length()));
    return;
  }
  sender.sendMessage(toDisplay);
}
 

private void killAll(Player player){
  Collection<LivingEntity> entities=player.getWorld().getEntitiesByClass(LivingEntity.class);
  int counter=0;
  for (  LivingEntity entity : entities) {
    if (entity instanceof Player)     continue;
    entity.remove();
    ++counter;
  }
  PlayerUtils.sendSuccess(player,pluginName,"Es wurden " + counter + " Monster entfernt.");
}
 

/** 
 * F?hrt alle definierten Filter auf das Ergebnis der Bannersuche aus
 * @param request
 * @param banners
 * @return
 */
public List<AdDefinition> processFilter(AdRequest request,List<AdDefinition> banners,AdDB db){
  if (!request.hasConditions()) {
    return banners;
  }
  Collection<AdDefinition> bcol=new ArrayList<AdDefinition>();
  bcol.addAll(banners);
  for (  Condition condition : db.manager.getConditions()) {
    if (Filter.class.isInstance(condition) && !banners.isEmpty()) {
      bcol=(Collection<AdDefinition>)Collections2.filter(bcol,((Filter)condition).getFilterPredicate(request));
    }
  }
  banners.clear();
  banners.addAll(bcol);
  return banners;
}
 

public static <T>Collection<T> loadAll(MBeanServerConnection mbs,Class<T> beanInterface,ObjectName query){
  Collection<T> beans=new LinkedList<T>();
  try {
    for (    ObjectName name : mbs.queryNames(query,null)) {
      beans.add(factory.makeProxy(mbs,beanInterface,name));
    }
  }
 catch (  IOException e) {
  }
  return beans;
}
 

@Override public final void schedule(Task task,Task parent,Collection<Task> deps){
  if (enableGraphViz) {
    ImplicitTask itask=(ImplicitTask)task;
    digraphviz.addNode(itask.hashCode(),itask.body.toString());
    if (parent != NO_PARENT) {
      digraphviz.addConnection(itask.hashCode(),parent.hashCode(),LineStyle.DASHED,Color.RED,"");
    }
    if (deps != NO_DEPS) {
      for (      Task dep : deps) {
        digraphviz.addConnection(itask.hashCode(),dep.hashCode(),LineStyle.SOLID,Color.BLUE,"");
      }
    }
  }
  graph.addTask((ImplicitTask)task,parent,deps);
}
 

private String nameFor(ParameterizedType type){
  Class<?> raw=(Class<?>)type.getRawType();
  if (Collection.class.isAssignableFrom(raw)) {
    return nameFor(type.getActualTypeArguments()[0]) + "List";
  }
  return nameFor(raw);
}
 

private AuthenticationSelector getAuthSelector(){
  DefaultAuthenticationSelector selector=new DefaultAuthenticationSelector();
  Collection<String> ids=new HashSet<String>();
  for (  Authentication auth : authentications) {
    List<String> servers=auth.getServers();
    if (!servers.isEmpty()) {
      org.eclipse.aether.repository.Authentication a=ConverterUtils.toAuthentication(auth);
      for (      String server : servers) {
        if (ids.add(server)) {
          selector.add(server,a);
        }
      }
    }
  }
  Settings settings=getSettings();
  for (  Server server : settings.getServers()) {
    AuthenticationBuilder auth=new AuthenticationBuilder();
    auth.addUsername(server.getUsername()).addPassword(server.getPassword());
    auth.addPrivateKey(server.getPrivateKey(),server.getPassphrase());
    selector.add(server.getId(),auth.build());
  }
  return new ConservativeAuthenticationSelector(selector);
}
 

public UnsolvableVersionConflictException(Object dependencyConflictId,Collection<String> versions){
  super("Could not resolve version conflict for " + dependencyConflictId + " with requested versions "+ toList(versions));
  this.dependencyConflictId=(dependencyConflictId != null) ? dependencyConflictId : "";
  this.versions=(versions != null) ? versions : Collections.<String>emptyList();
  this.paths=Collections.emptyList();
}