<p>
List of ParameterMapEntry objects.
</p>

@param mapEntries
List of ParameterMapEntry objects.
542767
public void setMapEntries(java.util.Collection<ParameterMapEntry> mapEntries) {
        if (mapEntries == null) {
            this.mapEntries = null;
            return;
        }

        this.mapEntries = new java.util.ArrayList<ParameterMapEntry>(mapEntries);
    }
662902
private static <A, B> Map<A, B> listToMap(List<Map.Entry<A, B>> list) {
    Map<A, B> result = new LinkedHashMap<A, B>();
    for (Iterator<Map.Entry<A, B>> it = list.iterator(); it.hasNext();) {
      Map.Entry<A, B> entry = (Map.Entry<A, B>) it.next();
      result.put(entry.getKey(), entry.getValue());
    }
    return result;
  }
796119
public void setEntries(List<E> entries) {
        if (entries == null) {
            this.entries = new ArrayList<>();
        } else {
            this.entries = entries;
        }
    }
408531
@SafeVarargs
    private static Map<Pattern, Pass> asMap(
        final Map.Entry<Pattern, Pass>... entries) {
        final Map<Pattern, Pass> map = new HashMap<>(entries.length);
        for (final Map.Entry<Pattern, Pass> ent : entries) {
            map.put(ent.getKey(), ent.getValue());
        }
        return map;
    }
317143
@SuppressWarnings("unchecked")
    @Resource(name = "searchTabs")
    // Map of tab-key to string or collection<string> of search result types
    public void setSearchTabs(Map<String, Object> searchTabMappings) {
        final Map<String, Set<String>> resultTypeMappingsBuilder = new LinkedHashMap<>();
        final List<String> tabKeysBuilder = new ArrayList<>(searchTabMappings.size());

        for (final Map.Entry<String, Object> tabMapping : searchTabMappings.entrySet()) {
            final String tabKey = tabMapping.getKey();
            tabKeysBuilder.add(tabKey);

            final Object resultTypes = tabMapping.getValue();
            if (resultTypes instanceof Collection) {
                for (final String resultType : (Collection<String>) resultTypes) {
                    addTabKey(resultTypeMappingsBuilder, tabKey, resultType);
                }
            } else {
                final String resultType = (String) resultTypes;
                addTabKey(resultTypeMappingsBuilder, tabKey, resultType);
            }
        }

        this.resultTypeMappings = resultTypeMappingsBuilder;
        this.tabKeys = tabKeysBuilder;
    }
488673
public void setPathMappings(List<String> pathMappings) {

		this.pathMappings.clear();
		if (pathMappings != null) {
			for (String mapping : pathMappings) {
				this.pathMappings.add(new PathMapping(bundle, mapping));
			}
		}

	}
434813
public void setKeys(java.util.Collection<DimensionKeyDescription> keys) {
        if (keys == null) {
            this.keys = null;
            return;
        }

        this.keys = new java.util.ArrayList<DimensionKeyDescription>(keys);
    }
255835
public static <K, V> LinkedHashMap<K, V> sortToMap(Collection<Map.Entry<K, V>> entryCollection, Comparator<Map.Entry<K, V>> comparator) {
		List<Map.Entry<K, V>> list = new LinkedList<>(entryCollection);
		Collections.sort(list, comparator);

		LinkedHashMap<K, V> result = new LinkedHashMap<>();
		for (Map.Entry<K, V> entry : list) {
			result.put(entry.getKey(), entry.getValue());
		}
		return result;
	}
600042
@Override
  public Set<java.util.Map.Entry<String, String>> entrySet() {
    return bindings.entrySet();
  }
877583
protected void registerBindingConfigurationEntries(Iterable<BindingConfigurationEntry> bindings) {

        for (BindingConfigurationEntry nextBinding : bindings) {
        	try {
        		registerBindingConfigurationEntry(nextBinding);
        	} catch (IllegalStateException e) {
        		// Ignore this - it can happen when introspecting class mappings
        	}
        }
    }
691316
public static List<TagEntryAO> tagsMapToTagEntries(Map<String, String> tagsMap) {

    	if (tagsMap==null)
    		return Collections.EMPTY_LIST;

        List<TagEntryAO> tagEntries = new ArrayList<>(tagsMap.size());

        for (Map.Entry<String,String> entry : tagsMap.entrySet())
            tagEntries.add(
                    new TagEntryAO(entry.getKey(), entry.getValue())
            );

        return tagEntries;

    }
17245
private static Map<?, ?> mapOfEntries( Entry<?, ?>... entries ) {
        Map<Object, Object> looseTypedMap = new LinkedHashMap<>( entries.length );
        for (Entry<?, ?> entry : entries)
            looseTypedMap.put(entry.getKey(), entry.getValue());
        return looseTypedMap;
    }
1054919
public void setSecurityProfileTargetMappings(java.util.Collection<SecurityProfileTargetMapping> securityProfileTargetMappings) {
        if (securityProfileTargetMappings == null) {
            this.securityProfileTargetMappings = null;
            return;
        }

        this.securityProfileTargetMappings = new java.util.ArrayList<SecurityProfileTargetMapping>(securityProfileTargetMappings);
    }
1134254
public <T> void setEntries(Collection<I_CmsSimpleContextMenuEntry<T>> entries, T data) {

        removeAllItems();
        Locale locale = UI.getCurrent().getLocale();
        for (final I_CmsSimpleContextMenuEntry<T> entry : entries) {
            CmsMenuItemVisibilityMode visibility = entry.getVisibility(data);
            if (!visibility.isInVisible()) {
                ContextMenuItem item = addItem(entry.getTitle(locale));
                if (visibility.isInActive()) {
                    item.setEnabled(false);
                    if (visibility.getMessageKey() != null) {
                        item.setDescription(CmsVaadinUtils.getMessageText(visibility.getMessageKey()));
                    }
                } else {
                    item.setData(data);
                    item.addItemClickListener(new ContextMenuItemClickListener() {

                        @SuppressWarnings("unchecked")
                        public void contextMenuItemClicked(ContextMenuItemClickEvent event) {

                            entry.executeAction((T)((ContextMenuItem)event.getSource()).getData());
                        }
                    });
                }
                if (entry instanceof I_CmsSimpleContextMenuEntry.I_HasCssStyles) {
                    item.addStyleName(((I_CmsSimpleContextMenuEntry.I_HasCssStyles)entry).getStyles());
                }
            }
        }
    }
187598
public void setMappings(List<String> mappings) {
        if (mappings.size() > 0) {
            @SuppressWarnings("unchecked") Pair<String, String>[] renames = (Pair<String, String>[])Array.newInstance(Pair.class, mappings.size());
            for (int i = 0; i < _renames.length; ++i) {
                String[] names = mappings.get(i).split("[ ,]+");
                renames[i] = new Pair<String, String>(names[0], names[1]);
            }
            _renames = renames;
        }
    }
888351
public void setEntries(List<FatDirectoryEntry> newEntries) {
        if (newEntries.size() > capacity)
            throw new IllegalArgumentException("too many entries");
        
        this.entries.clear();
        this.entries.addAll(newEntries);
    }
1334250
public void setTargetMaps(java.util.Collection<java.util.Map<String, java.util.List<String>>> targetMaps) {
        if (targetMaps == null) {
            this.targetMaps = null;
            return;
        }

        this.targetMaps = new com.amazonaws.internal.SdkInternalList<java.util.Map<String, java.util.List<String>>>(targetMaps);
    }