private void updateText() {
StringBuilder sb = new StringBuilder();
if (myShowSettingsBeforeRunCheckBox.isSelected()) {
sb.append(ExecutionBundle.message("configuration.edit.before.run")).append(", ");
}
List<BeforeRunTask> tasks = myModel.getItems();
if (!tasks.isEmpty()) {
LinkedHashMap<BeforeRunTaskProvider, Integer> counter =
new LinkedHashMap<BeforeRunTaskProvider, Integer>();
for (BeforeRunTask task : tasks) {
BeforeRunTaskProvider<BeforeRunTask> provider =
BeforeRunTaskProvider.getProvider(
myRunConfiguration.getProject(), task.getProviderId());
if (provider != null) {
Integer count = counter.get(provider);
if (count == null) {
count = task.getItemsCount();
} else {
count += task.getItemsCount();
}
counter.put(provider, count);
}
}
for (Iterator<Map.Entry<BeforeRunTaskProvider, Integer>> iterator =
counter.entrySet().iterator();
iterator.hasNext(); ) {
Map.Entry<BeforeRunTaskProvider, Integer> entry = iterator.next();
BeforeRunTaskProvider provider = entry.getKey();
String name = provider.getName();
if (name.startsWith("Run ")) {
name = name.substring(4);
}
sb.append(name);
if (entry.getValue() > 1) {
sb.append(" (").append(entry.getValue().intValue()).append(")");
}
if (iterator.hasNext()) sb.append(", ");
}
}
if (sb.length() > 0) {
sb.insert(0, ": ");
}
sb.insert(0, ExecutionBundle.message("before.launch.panel.title"));
myListener.titleChanged(sb.toString());
}
private String buildLabelText(
@NotNull final String text,
@NotNull final Map<TextRange, ParameterInfoUIContextEx.Flag> flagsMap) {
final StringBuilder labelText = new StringBuilder(text);
final String disabledTag = FLAG_TO_TAG.get(ParameterInfoUIContextEx.Flag.DISABLE);
final Map<Integer, Integer> faultMap = new HashMap<>();
if (isDisabledBeforeHighlight) {
final String tag = getTag(disabledTag);
labelText.insert(0, tag);
faultMap.put(0, tag.length());
}
for (Map.Entry<TextRange, ParameterInfoUIContextEx.Flag> entry : flagsMap.entrySet()) {
final TextRange highlightRange = entry.getKey();
final ParameterInfoUIContextEx.Flag flag = entry.getValue();
final String tagValue = FLAG_TO_TAG.get(flag);
final String tag = getTag(tagValue);
int startOffset = highlightRange.getStartOffset();
int endOffset = highlightRange.getEndOffset() + tag.length();
for (Map.Entry<Integer, Integer> entry1 : faultMap.entrySet()) {
if (entry1.getKey() < highlightRange.getStartOffset()) {
startOffset += entry1.getValue();
}
if (entry1.getKey() < highlightRange.getEndOffset()) {
endOffset += entry1.getValue();
}
}
if (flag == ParameterInfoUIContextEx.Flag.HIGHLIGHT && isDisabledBeforeHighlight) {
final String disableCloseTag = getClosingTag(disabledTag);
labelText.insert(startOffset, disableCloseTag);
faultMap.put(highlightRange.getStartOffset(), disableCloseTag.length());
}
labelText.insert(startOffset, tag);
faultMap.put(highlightRange.getStartOffset(), tag.length());
final String endTag = getClosingTag(tagValue);
labelText.insert(endOffset, endTag);
faultMap.put(highlightRange.getEndOffset(), endTag.length());
}
return XmlStringUtil.wrapInHtml(labelText);
}
public void removeEntryPoint(RefElement anEntryPoint) {
if (anEntryPoint instanceof RefClass) {
RefClass refClass = (RefClass) anEntryPoint;
if (!refClass.isInterface()) {
anEntryPoint = refClass.getDefaultConstructor();
}
}
if (anEntryPoint == null) return;
myTemporaryEntryPoints.remove(anEntryPoint);
Set<Map.Entry<String, SmartRefElementPointer>> set = myPersistentEntryPoints.entrySet();
String key = null;
for (Map.Entry<String, SmartRefElementPointer> entry : set) {
SmartRefElementPointer value = entry.getValue();
if (value.getRefElement() == anEntryPoint) {
key = entry.getKey();
break;
}
}
if (key != null) {
myPersistentEntryPoints.remove(key);
((RefElementImpl) anEntryPoint).setEntry(false);
}
if (anEntryPoint.isPermanentEntry() && anEntryPoint.isValid()) {
final Project project = anEntryPoint.getElement().getProject();
final EntryPointsManagerImpl entryPointsManager = getInstance(project);
if (this != entryPointsManager) {
entryPointsManager.removeEntryPoint(anEntryPoint);
}
}
}
/**
* Prepare branch descriptors for existing configuration
*
* @param target the target
* @param roots the vcs root
* @return the list of branch descriptors
* @throws VcsException in case of error
*/
private List<BranchDescriptor> prepareBranchDescriptors(
BranchConfiguration target, List<VirtualFile> roots) throws VcsException {
Map<String, String> map =
target == null ? Collections.<String, String>emptyMap() : target.getReferences();
List<BranchDescriptor> rc = new ArrayList<BranchDescriptor>();
for (VirtualFile root : roots) {
BranchDescriptor d = new BranchDescriptor();
d.root = root;
d.storedReference = map.remove(root.getPath());
if (d.storedReference != null) {
d.storedRoot = d.root.getPath();
}
d.currentReference = myConfig.describeRoot(root);
if (d.storedReference != null && !myModify) {
d.referenceToCheckout = d.storedReference;
} else {
d.referenceToCheckout = d.currentReference;
}
Branch.listAsStrings(myProject, root, false, true, d.existingBranches, null);
Branch.listAsStrings(myProject, root, true, true, d.referencesToSelect, null);
d.updateStatus();
rc.add(d);
}
for (Map.Entry<String, String> m : map.entrySet()) {
String root = m.getKey();
String ref = m.getValue();
BranchDescriptor d = new BranchDescriptor();
d.storedReference = ref;
d.storedRoot = root;
d.referenceToCheckout = ref;
d.updateStatus();
rc.add(d);
}
return rc;
}
private void copyCustomSettingsFrom(@NotNull CodeStyleSettings from) {
synchronized (myCustomSettings) {
myCustomSettings.clear();
for (final CustomCodeStyleSettings settings : from.getCustomSettingsValues()) {
addCustomSettings((CustomCodeStyleSettings) settings.clone());
}
FIELD_TYPE_TO_NAME.copyFrom(from.FIELD_TYPE_TO_NAME);
STATIC_FIELD_TYPE_TO_NAME.copyFrom(from.STATIC_FIELD_TYPE_TO_NAME);
PARAMETER_TYPE_TO_NAME.copyFrom(from.PARAMETER_TYPE_TO_NAME);
LOCAL_VARIABLE_TYPE_TO_NAME.copyFrom(from.LOCAL_VARIABLE_TYPE_TO_NAME);
PACKAGES_TO_USE_IMPORT_ON_DEMAND.copyFrom(from.PACKAGES_TO_USE_IMPORT_ON_DEMAND);
IMPORT_LAYOUT_TABLE.copyFrom(from.IMPORT_LAYOUT_TABLE);
OTHER_INDENT_OPTIONS.copyFrom(from.OTHER_INDENT_OPTIONS);
myAdditionalIndentOptions.clear();
for (Map.Entry<FileType, IndentOptions> optionEntry :
from.myAdditionalIndentOptions.entrySet()) {
IndentOptions options = optionEntry.getValue();
myAdditionalIndentOptions.put(optionEntry.getKey(), (IndentOptions) options.clone());
}
myCommonSettingsManager = from.myCommonSettingsManager.clone(this);
}
}
private GroovyTreeNode(GroovyTreeNode parent, GroovyNode node) {
this.parent = parent;
this.node = node;
for (Map.Entry<String, String> entry : node.attributes().entrySet()) {
children.add(new GroovyTreeNode(this, entry.getKey(), entry.getValue()));
}
if (node.getNodeValue() instanceof List) {
string = node.getNodeName();
toolTip = String.format("Size: %d", ((List) node.getNodeValue()).size());
} else {
String truncated = node.text();
if (truncated.contains("\n") || truncated.length() >= MAX_LENGTH) {
int index = truncated.indexOf('\n');
if (index > 0) truncated = truncated.substring(0, index);
if (truncated.length() >= MAX_LENGTH) truncated = truncated.substring(0, MAX_LENGTH);
string = String.format("<html><b>%s</b> = %s ...</html>", node.getNodeName(), truncated);
toolTip = tameTooltipText(node.text());
} else {
string = String.format("<html><b>%s</b> = %s</html>", node.getNodeName(), truncated);
toolTip = truncated;
}
}
if (this.node.getNodeValue() instanceof List) {
for (Object sub : ((List) this.node.getNodeValue())) {
GroovyNode subnode = (GroovyNode) sub;
children.add(new GroovyTreeNode(this, subnode));
}
Collections.sort(children);
}
}
public static BiMap<Combo, Integer> getComboTuneMap() {
int mod = getAsciiTuneMods();
BiMap<Combo, Integer> map = HashBiMap.create();
for (Map.Entry<Integer, Integer> entry : getAsciTuneMap().entrySet()) {
map.put(new Combo(mod, entry.getKey()), entry.getValue());
}
return map;
}
@NotNull
public static List<SymfonyInstallerVersion> getVersions(@NotNull String jsonContent) {
JsonObject jsonObject = new JsonParser().parse(jsonContent).getAsJsonObject();
List<SymfonyInstallerVersion> symfonyInstallerVersions = new ArrayList<>();
// prevent adding duplicate version on alias names
Set<String> aliasBranches = new HashSet<>();
// get alias version, in most common order
for (String s : new String[] {"latest", "lts"}) {
JsonElement asJsonObject = jsonObject.get(s);
if (asJsonObject == null) {
continue;
}
String asString = asJsonObject.getAsString();
aliasBranches.add(asString);
symfonyInstallerVersions.add(
new SymfonyInstallerVersion(s, String.format("%s (%s)", asString, s)));
}
List<SymfonyInstallerVersion> branches = new ArrayList<>();
Set<Map.Entry<String, JsonElement>> entries = jsonObject.entrySet();
for (Map.Entry<String, JsonElement> entry : entries) {
if (!entry.getKey().matches("^\\d+\\.\\d+$")) {
continue;
}
// "2.8.0-dev", "2.8.0-DEV" is not supported
String asString = entry.getValue().getAsString();
if (asString.matches(".*[a-zA-Z].*") || aliasBranches.contains(asString)) {
continue;
}
branches.add(
new SymfonyInstallerVersion(
asString, String.format("%s (%s)", entry.getKey(), asString)));
}
branches.sort(Comparator.comparing(SymfonyInstallerVersion::getVersion));
Collections.reverse(branches);
symfonyInstallerVersions.addAll(branches);
// we need reverse order for sorting them on version string
List<SymfonyInstallerVersion> installableVersions = new ArrayList<>();
for (JsonElement installable : jsonObject.getAsJsonArray("installable")) {
installableVersions.add(new SymfonyInstallerVersion(installable.getAsString()));
}
Collections.reverse(installableVersions);
symfonyInstallerVersions.addAll(installableVersions);
return symfonyInstallerVersions;
}
private void rodytiAutoRinkinius() {
zonaNeregAuto.setText("");
for (Automobilis a : rg.neregAuto) zonaNeregAuto.append(a.toString() + "\n");
zonaRegAuto.setText("");
for (Map.Entry<String, Automobilis> me : rg.regAuto.entrySet())
zonaRegAuto.append(String.format("%8s=%s\n", me.getKey(), me.getValue()));
tfNeregKiekis.setText(Integer.toString(rg.neregAuto.size()));
tfRegKiekis.setText(Integer.toString(rg.regAuto.size()));
}
public void printIdentified() {
System.out.println("Identified elements follow");
XMLOutputter outputter = new XMLOutputter();
for (Map.Entry<String, XMLModelIdentifiable> stringXMLModelIdentifiableEntry :
identifiedElements.entrySet()) {
System.out.println("Original name: " + stringXMLModelIdentifiableEntry.getKey());
stringXMLModelIdentifiableEntry.getValue().print(outputter, System.out);
}
}
@Override
@Nullable
public ToolWindow getToolWindowByDescriptor(@NotNull final RunContentDescriptor descriptor) {
for (Map.Entry<String, ContentManager> entry : myToolwindowIdToContentManagerMap.entrySet()) {
if (getRunContentByDescriptor(entry.getValue(), descriptor) != null) {
return ToolWindowManager.getInstance(myProject).getToolWindow(entry.getKey());
}
}
return null;
}
@NotNull
private static <K, V> Map<V, K> invertMap(@NotNull Map<K, V> map) {
final Map<V, K> inverted = new HashMap<V, K>();
for (Map.Entry<K, V> entry : map.entrySet()) {
final V value = entry.getValue();
if (!inverted.containsKey(value)) {
inverted.put(value, entry.getKey());
}
}
return inverted;
}
@NotNull
public List<String> getDirNames() {
final List<String> selectedDirs = new ArrayList<String>();
for (Map.Entry<String, JCheckBox> entry : myCheckBoxes.entrySet()) {
if (entry.getValue().isSelected()) {
selectedDirs.add(entry.getKey());
}
}
return selectedDirs;
}
private PropertiesFile getSelectedPropertiesFile() {
if (mySelectedEditor == null) return null;
PropertiesFile selectedFile = null;
for (Map.Entry<PropertiesFile, Editor> entry : myEditors.entrySet()) {
Editor editor = entry.getValue();
if (editor == mySelectedEditor) {
selectedFile = entry.getKey();
break;
}
}
return selectedFile;
}
@NotNull
private Set<Usage> getReadOnlyUsages() {
final Set<Usage> result = new THashSet<Usage>();
final Set<Map.Entry<Usage, UsageNode>> usages = myUsageNodes.entrySet();
for (Map.Entry<Usage, UsageNode> entry : usages) {
Usage usage = entry.getKey();
UsageNode node = entry.getValue();
if (node != null && node != NULL_NODE && !node.isExcluded() && usage.isReadOnly()) {
result.add(usage);
}
}
return result;
}
@Nullable
public InnerSearchableConfigurable findSubConfigurable(@NotNull final Class pageClass) {
if (mySubPanelFactories == null) {
buildConfigurables();
}
for (Map.Entry<ColorAndFontPanelFactory, InnerSearchableConfigurable> entry :
mySubPanelFactories.entrySet()) {
if (pageClass.isInstance(entry.getValue().createPanel().getSettingsPage())) {
return entry.getValue();
}
}
return null;
}
@Override
public void dispose() {
if (mySelectedEditor != null) {
for (final Map.Entry<PropertiesFile, Editor> entry : myEditors.entrySet()) {
if (mySelectedEditor.equals(entry.getValue())) {
writeEditorPropertyValue(mySelectedEditor, entry.getKey(), null);
}
}
}
VirtualFileManager.getInstance().removeVirtualFileListener(myVfsListener);
myDisposed = true;
Disposer.dispose(myStructureViewComponent);
releaseAllEditors();
}
private static Map<String, MultiValueOption<?>> getMultiValueOptions(
String prefix, Options options) {
Map<String, MultiValueOption<?>> result = new HashMap<String, MultiValueOption<?>>();
for (Option option : options.getOptions()) {
if (option instanceof MultiValueOption) {
result.put(
prefix + option.getName().replace(MultiValueOption.SUFFIX, ""),
(MultiValueOption) option);
}
}
for (Map.Entry<String, Options> entry : options.getChildOptions().entrySet()) {
result.putAll(getMultiValueOptions(prefix + entry.getKey() + ".", entry.getValue()));
}
return result;
}
private static void applySystemFonts(UIDefaults defaults) {
try {
String fqn = UIUtil.getSystemLookAndFeelClassName();
Object systemLookAndFeel = Class.forName(fqn).newInstance();
final Method superMethod = BasicLookAndFeel.class.getDeclaredMethod("getDefaults");
superMethod.setAccessible(true);
final UIDefaults systemDefaults = (UIDefaults) superMethod.invoke(systemLookAndFeel);
for (Map.Entry<Object, Object> entry : systemDefaults.entrySet()) {
if (entry.getValue() instanceof Font) {
defaults.put(entry.getKey(), entry.getValue());
}
}
} catch (Exception e) {
log(e);
}
}
WordListModel(ASDGrammar grammar) {
Set entrySet = grammar.lexicon().entrySet();
ArrayList words = new ArrayList(entrySet.size());
for (Iterator it = entrySet.iterator(); it.hasNext(); ) {
Map.Entry e = (Map.Entry) it.next();
String word = (String) e.getKey();
words.add(word);
}
Object[] wordArray = words.toArray();
if (words.size() > 1)
// Arrays.sort(wordArray);
Arrays.sort(wordArray, new WordComparator());
for (int j = 0; j < wordArray.length; j++) {
this.addElement((String) wordArray[j]);
}
}
@Override
@NotNull
public Set<Usage> getExcludedUsages() {
Set<Usage> result = new THashSet<Usage>();
for (Map.Entry<Usage, UsageNode> entry : myUsageNodes.entrySet()) {
UsageNode node = entry.getValue();
Usage usage = entry.getKey();
if (node == NULL_NODE || node == null) {
continue;
}
if (node.isExcluded()) {
result.add(usage);
}
}
return result;
}
private void PrettyPrint(File file, TreeMap<String, Long> sortedMap) {
// Long size = 0L;
// ArrayList<Long> values = new ArrayList<Long>(sortedMap.values());
Long total = 0L;
for (Long value : sortedMap.values()) {
total = total + value; // Can also be done by total += value;
}
log.append(file.getName() + ": " + readableFileSize(total) + "\n\n");
for (Map.Entry<String, Long> entry : sortedMap.entrySet()) {
log.append("[ " + readableFileSize(entry.getValue()) + " ]");
log.append(" --> " + entry.getKey() + "\n");
}
// log.append(sortedMap + "\n");
}
/** Draw the entire panel from the state */
@SuppressWarnings("rawtypes")
public void drawState() {
// clear();
Map.Entry entry;
Point pt;
Color col;
synchronized (state) {
for (Iterator it = state.entrySet().iterator(); it.hasNext(); ) {
entry = (Map.Entry) it.next();
pt = (Point) entry.getKey();
col = (Color) entry.getValue();
gr.setColor(col);
gr.fillOval(pt.x, pt.y, 10, 10);
}
}
repaint();
}
/**
* \ Draw saved State (color dots on panel) on WhiteBoard
*
* @param outstream
* @throws IOException
*/
public void writeState(OutputStream outstream) throws IOException {
if (state == null) return;
synchronized (state) {
DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(outstream));
// DataOutputStream dos=new DataOutputStream(outstream);
dos.writeInt(state.size());
for (Map.Entry<Point, Color> entry : state.entrySet()) {
Point point = entry.getKey();
Color col = entry.getValue();
dos.writeInt(point.x);
dos.writeInt(point.x);
dos.writeInt(col.getRGB());
}
dos.flush();
System.out.println("wrote " + state.size() + " elements");
}
}
/**
* Makes a POST request and returns the server response.
*
* @param urlString the URL to post to
* @param nameValuePairs a map of name/value pairs to supply in the request.
* @return the server reply (either from the input stream or the error stream)
*/
public static String doPost(String urlString, Map<String, String> nameValuePairs)
throws IOException {
URL url = new URL(urlString);
URLConnection connection = url.openConnection();
connection.setDoOutput(true);
PrintWriter out = new PrintWriter(connection.getOutputStream());
boolean first = true;
for (Map.Entry<String, String> pair : nameValuePairs.entrySet()) {
if (first) first = false;
else out.print('&');
String name = pair.getKey();
String value = pair.getValue();
out.print(name);
out.print('=');
out.print(URLEncoder.encode(value, "UTF-8"));
}
out.close();
Scanner in;
StringBuilder response = new StringBuilder();
try {
in = new Scanner(connection.getInputStream());
} catch (IOException e) {
if (!(connection instanceof HttpURLConnection)) throw e;
InputStream err = ((HttpURLConnection) connection).getErrorStream();
if (err == null) throw e;
in = new Scanner(err);
}
while (in.hasNextLine()) {
response.append(in.nextLine());
response.append("\n");
}
in.close();
return response.toString();
}
private static void patchHiDPI(UIDefaults defaults) {
if (!JBUI.isHiDPI()) return;
List<String> myIntKeys = Arrays.asList("Tree.leftChildIndent", "Tree.rightChildIndent");
List<String> patched = new ArrayList<String>();
for (Map.Entry<Object, Object> entry : defaults.entrySet()) {
Object value = entry.getValue();
String key = entry.getKey().toString();
if (value instanceof DimensionUIResource) {
entry.setValue(JBUI.size((DimensionUIResource) value).asUIResource());
} else if (value instanceof InsetsUIResource) {
entry.setValue(JBUI.insets(((InsetsUIResource) value)).asUIResource());
} else if (value instanceof Integer) {
if (key.endsWith(".maxGutterIconWidth") || myIntKeys.contains(key)) {
if (!"true".equals(defaults.get(key + ".hidpi.patched"))) {
entry.setValue(Integer.valueOf(JBUI.scale((Integer) value)));
patched.add(key);
}
}
}
}
for (String key : patched) {
defaults.put(key + ".hidpi.patched", "true");
}
}
void populateTable(HashMap data) {
String key, strval = "<null>";
Object val;
int num_rows = 0;
Map.Entry entry;
if (data == null) return;
num_rows = data.size();
clearTable();
if (num_rows > 0) {
for (Iterator it = data.entrySet().iterator(); it.hasNext(); ) {
entry = (Map.Entry) it.next();
key = (String) entry.getKey();
val = entry.getValue();
if (val != null) strval = val.toString();
table_model.addRow(new Object[] {key, strval});
}
table_model.fireTableRowsInserted(0, num_rows - 1);
validate();
}
}
private static JFreeChart[] createPresenceCharts(
Stats.RecordStats recordStats, String which, String name) {
if (recordStats == null) return null;
int bars = recordStats.frequencies.size();
JFreeChart[] charts;
if (bars > MAX_BAR_CHART_SIZE) {
charts = new JFreeChart[bars / MAX_BAR_CHART_SIZE + 1];
} else {
charts = new JFreeChart[1];
}
Iterator<Map.Entry<Path, Stats.Histogram>> entryWalk =
recordStats.frequencies.entrySet().iterator();
int chartSize = bars / charts.length;
for (int walk = 0; walk < charts.length; walk++) {
DefaultCategoryDataset data = new DefaultCategoryDataset();
if (walk == charts.length - 1) chartSize = MAX_BAR_CHART_SIZE;
for (int count = 0; count < chartSize; count++) {
if (!entryWalk.hasNext()) continue;
Map.Entry<Path, Stats.Histogram> histogramEntry = entryWalk.next();
data.addValue(
histogramEntry.getValue().absent, "Absent", histogramEntry.getKey().getTail());
data.addValue(
histogramEntry.getValue().present, "Present", histogramEntry.getKey().getTail());
}
charts[walk] =
finishBarChart(
ChartFactory.createBarChart(
String.format("Fields presence in %s of %s", which, name),
"Field",
"Record count",
data,
PlotOrientation.VERTICAL,
true,
true,
false));
}
return charts;
}
private ActionCallback processAjusted(
final Map<Object, Condition> adjusted, final Set<Object> originallySelected) {
final ActionCallback result = new ActionCallback();
final Set<Object> allSelected = myUi.getSelectedElements();
Set<Object> toSelect = new HashSet<Object>();
for (Map.Entry<Object, Condition> entry : adjusted.entrySet()) {
if (entry.getValue().value(entry.getKey())) continue;
for (final Object eachSelected : allSelected) {
if (isParentOrSame(entry.getKey(), eachSelected)) continue;
toSelect.add(entry.getKey());
}
if (allSelected.isEmpty()) {
toSelect.add(entry.getKey());
}
}
final Object[] newSelection = ArrayUtil.toObjectArray(toSelect);
if (newSelection.length > 0) {
myUi._select(
newSelection,
new Runnable() {
@Override
public void run() {
final Set<Object> hangByParent = new HashSet<Object>();
processUnsuccessfulSelections(
newSelection,
new Function<Object, Object>() {
@Override
public Object fun(final Object o) {
if (myUi.isInStructure(o) && !adjusted.get(o).value(o)) {
hangByParent.add(o);
} else {
addAdjustedSelection(o, adjusted.get(o), null);
}
return null;
}
},
originallySelected);
processHangByParent(hangByParent).notify(result);
}
},
false,
true,
true);
} else {
result.setDone();
}
return result;
}
public void prefixIdentifiedNames(String prefix, Map<String, String> special, boolean keepID) {
if (special == null) {
special = new HashMap<String, String>();
}
for (Map.Entry<String, XMLModelIdentifiable> stringXMLModelIdentifiableEntry :
identifiedElements.entrySet()) {
String newName;
if (special.containsKey(stringXMLModelIdentifiableEntry.getKey())) { // assign a special name
newName = special.get(stringXMLModelIdentifiableEntry.getKey());
if (keepID) {
stringXMLModelIdentifiableEntry.getValue().restoreDefinition();
} else {
stringXMLModelIdentifiableEntry.getValue().removeDefinition();
}
} else {
newName = prefix + stringXMLModelIdentifiableEntry.getKey();
}
stringXMLModelIdentifiableEntry.getValue().rename(newName);
}
}