@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;
}
public static TreePath getPathFromRoot(TreeNode node) {
final ArrayList<TreeNode> path = new ArrayList<TreeNode>();
do {
path.add(node);
node = node.getParent();
} while (node != null);
Collections.reverse(path);
return new TreePath(path.toArray());
}
@Nullable
@SuppressWarnings({"HardCodedStringLiteral"})
private JPanel readExternalPanel(
final Element element, @Nullable JPanel panel, Ref<EditorWindow> currentWindow) {
final Element splitterElement = element.getChild("splitter");
if (splitterElement != null) {
return readSplitter(panel, splitterElement, currentWindow);
}
final Element leaf = element.getChild("leaf");
if (leaf == null) {
return null;
}
EditorWindow window = (panel == null) ? new EditorWindow(this) : findWindowWith(panel);
LOG.assertTrue(window != null);
@SuppressWarnings("unchecked")
final List<Element> children = ContainerUtil.newArrayList(leaf.getChildren("file"));
if (UISettings.getInstance().ACTIVATE_RIGHT_EDITOR_ON_CLOSE) {
Collections.reverse(children);
}
VirtualFile currentFile = null;
for (final Element file : children) {
try {
final HistoryEntry entry =
new HistoryEntry(getManager().getProject(), file.getChild(HistoryEntry.TAG), true);
boolean isCurrent = Boolean.valueOf(file.getAttributeValue("current")).booleanValue();
getManager().openFileImpl3(window, entry.myFile, false, entry, isCurrent);
if (getManager().isFileOpen(entry.myFile)) {
window.setFilePinned(
entry.myFile, Boolean.valueOf(file.getAttributeValue("pinned")).booleanValue());
if (Boolean.valueOf(file.getAttributeValue("current-in-tab")).booleanValue()) {
currentFile = entry.myFile;
}
}
} catch (InvalidDataException e) {
// OK
}
}
if (currentFile != null) {
final EditorComposite editor = window.findFileComposite(currentFile);
if (editor != null) {
window.setSelectedEditor(editor, true);
}
}
return window.myPanel;
}
private static CompositePackagingElement<?> getOrCreateModifiableParent(
CompositePackagingElement<?> parentElement, PackagingElementNode<?> node) {
PackagingElementNode<?> current = node;
List<String> dirNames = new ArrayList<String>();
while (current != null && !(current instanceof ArtifactRootNode)) {
final PackagingElement<?> packagingElement = current.getFirstElement();
if (!(packagingElement instanceof DirectoryPackagingElement)) {
return parentElement;
}
dirNames.add(((DirectoryPackagingElement) packagingElement).getDirectoryName());
current = current.getParentNode();
}
if (current == null) return parentElement;
final PackagingElement<?> rootElement = current.getElementIfSingle();
if (!(rootElement instanceof CompositePackagingElement<?>)) return parentElement;
Collections.reverse(dirNames);
String path = StringUtil.join(dirNames, "/");
return PackagingElementFactory.getInstance()
.getOrCreateDirectory((CompositePackagingElement<?>) rootElement, path);
}
@Nullable
@SuppressWarnings({"HardCodedStringLiteral"})
private JPanel readExternalPanel(
final Element element, @Nullable JPanel panel, Ref<EditorWindow> currentWindow) {
final Element splitterElement = element.getChild("splitter");
if (splitterElement != null) {
return readSplitter(panel, splitterElement, currentWindow);
}
final Element leaf = element.getChild("leaf");
if (leaf == null) {
return null;
}
final EditorWindow window = panel == null ? new EditorWindow(this) : findWindowWith(panel);
LOG.assertTrue(window != null);
@SuppressWarnings("unchecked")
final List<Element> children = ContainerUtil.newArrayList(leaf.getChildren("file"));
if (UISettings.getInstance().ACTIVATE_RIGHT_EDITOR_ON_CLOSE) {
Collections.reverse(children);
}
// trim to EDITOR_TAB_LIMIT, ignoring CLOSE_NON_MODIFIED_FILES_FIRST policy
for (Iterator<Element> iterator = children.iterator();
iterator.hasNext() && UISettings.getInstance().EDITOR_TAB_LIMIT < children.size(); ) {
Element child = iterator.next();
if (!Boolean.valueOf(child.getAttributeValue(PINNED)).booleanValue()) {
iterator.remove();
}
}
VirtualFile currentFile = null;
for (int i = 0; i < children.size(); i++) {
final Element file = children.get(i);
try {
final FileEditorManagerImpl fileEditorManager = getManager();
final HistoryEntry entry =
new HistoryEntry(fileEditorManager.getProject(), file.getChild(HistoryEntry.TAG), true);
final boolean isCurrent = Boolean.valueOf(file.getAttributeValue("current")).booleanValue();
fileEditorManager.openFileImpl4(window, entry.myFile, false, entry, isCurrent, i);
if (fileEditorManager.isFileOpen(entry.myFile)) {
window.setFilePinned(
entry.myFile, Boolean.valueOf(file.getAttributeValue(PINNED)).booleanValue());
if (Boolean.valueOf(file.getAttributeValue("current-in-tab")).booleanValue()) {
currentFile = entry.myFile;
}
}
} catch (InvalidDataException e) {
if (ApplicationManager.getApplication().isUnitTestMode()) {
LOG.error(e);
}
}
}
if (currentFile != null) {
final EditorComposite editor = window.findFileComposite(currentFile);
if (editor != null) {
window.setSelectedEditor(editor, true);
}
}
return window.myPanel;
}
/** Add the UI components for the given file sequence to the panel. */
private void addFileSeqPanel(FileSeq fseq) {
boolean isPresentInWorking = false;
if ((pStatus != null) && pStatus.hasLightDetails()) {
NodeDetailsLight details = pStatus.getLightDetails();
NodeMod mod = details.getWorkingVersion();
if (mod != null) {
if (mod.getPrimarySequence().equals(fseq)) isPresentInWorking = true;
else {
for (FileSeq sfseq : mod.getSecondarySequences()) {
if (sfseq.equals(fseq)) {
isPresentInWorking = true;
break;
}
}
}
}
}
/* collate the row information */
ArrayList<VersionID> vids = new ArrayList<VersionID>();
ArrayList<FileSeq> singles = new ArrayList<FileSeq>();
TreeSet<FileSeq> enabled = new TreeSet<FileSeq>();
TreeMap<FileSeq, FileState> fstates = new TreeMap<FileSeq, FileState>();
TreeMap<FileSeq, NativeFileInfo> finfos = new TreeMap<FileSeq, NativeFileInfo>();
TreeMap<FileSeq, QueueState> qstates = new TreeMap<FileSeq, QueueState>();
TreeMap<FileSeq, Boolean[]> novel = new TreeMap<FileSeq, Boolean[]>();
{
TreeMap<FileSeq, Integer> wsingles = new TreeMap<FileSeq, Integer>();
if ((pStatus != null) && pStatus.hasLightDetails()) {
if (isPresentInWorking) {
if (pStatus.hasHeavyDetails()) {
NodeDetailsHeavy details = pStatus.getHeavyDetails();
FileState[] fs = details.getFileStates(fseq);
QueueState[] qs = details.getQueueStates();
NativeFileInfo[] infos = details.getFileInfos(fseq);
if ((fs != null) && (qs != null) && (infos != null)) {
int wk;
for (wk = 0; wk < fs.length; wk++) {
FileSeq sfseq = new FileSeq(fseq, wk);
wsingles.put(sfseq, wk);
fstates.put(sfseq, fs[wk]);
finfos.put(sfseq, infos[wk]);
qstates.put(sfseq, qs[wk]);
if (fs[wk] != FileState.CheckedIn) enabled.add(sfseq);
}
}
} else {
NodeDetailsLight details = pStatus.getLightDetails();
int wk;
for (wk = 0; wk < fseq.numFrames(); wk++) {
FileSeq sfseq = new FileSeq(fseq, wk);
wsingles.put(sfseq, wk);
if (details.getVersionState() == VersionState.CheckedIn) {
fstates.put(sfseq, FileState.CheckedIn);
qstates.put(sfseq, QueueState.Undefined);
} else {
enabled.add(sfseq);
}
}
}
}
{
vids.addAll(pNovelty.keySet());
Collections.reverse(vids);
int idx = 0;
for (VersionID vid : vids) {
TreeMap<FileSeq, boolean[]> table = pNovelty.get(vid);
for (FileSeq nfseq : table.keySet()) {
if (fseq.similarTo(nfseq)) {
boolean[] flags = table.get(nfseq);
int wk;
for (wk = 0; wk < flags.length; wk++) {
FileSeq sfseq = new FileSeq(nfseq, wk);
if (!wsingles.containsKey(sfseq)) wsingles.put(sfseq, null);
Boolean[] rflags = novel.get(sfseq);
if (rflags == null) {
rflags = new Boolean[pNovelty.size()];
novel.put(sfseq, rflags);
}
rflags[idx] = new Boolean(flags[wk]);
}
break;
}
}
idx++;
}
}
}
TreeMap<Integer, FileSeq> order = new TreeMap<Integer, FileSeq>();
for (FileSeq sfseq : wsingles.keySet()) {
int frame = -1;
if (sfseq.hasFrameNumbers()) frame = sfseq.getFrameRange().getStart();
order.put(frame, sfseq);
}
singles.addAll(order.values());
}
/* add the panel */
{
JFileSeqPanel panel =
new JFileSeqPanel(
this,
pManagerPanel,
pStatus,
pPrivilegeDetails,
fseq,
vids,
pOffline,
singles,
fstates,
finfos,
qstates,
enabled,
novel,
pIsListLayout);
if (pIsListLayout) pFileSeqsBox.add(panel);
else pFileSeqsTab.addTab(fseq.getFilePattern().toString(), sTabIcon, panel);
pFileSeqPanels.put(fseq, panel);
}
}
private RebaseInfo collectRebaseInfo() {
final Set<VirtualFile> roots = new HashSet<VirtualFile>();
final Set<VirtualFile> rootsWithMerges = new HashSet<VirtualFile>();
final Map<VirtualFile, List<String>> reorderedCommits =
new HashMap<VirtualFile, List<String>>();
final Map<VirtualFile, Set<String>> uncheckedCommits = new HashMap<VirtualFile, Set<String>>();
for (int i = 0; i < myTreeRoot.getChildCount(); i++) {
CheckedTreeNode node = (CheckedTreeNode) myTreeRoot.getChildAt(i);
Root r = (Root) node.getUserObject();
Set<String> unchecked = new HashSet<String>();
uncheckedCommits.put(r.root, unchecked);
if (r.commits.size() == 0) {
if (r.remoteCommits > 0) {
roots.add(r.root);
}
continue;
}
boolean seenCheckedNode = false;
boolean reorderNeeded = false;
boolean seenMerges = false;
for (int j = 0; j < node.getChildCount(); j++) {
if (node.getChildAt(j) instanceof CheckedTreeNode) {
CheckedTreeNode commitNode = (CheckedTreeNode) node.getChildAt(j);
Commit commit = (Commit) commitNode.getUserObject();
seenMerges |= commit.isMerge;
if (commitNode.isChecked()) {
seenCheckedNode = true;
} else {
unchecked.add(commit.commitId());
if (seenCheckedNode) {
reorderNeeded = true;
}
}
}
}
if (seenMerges) {
rootsWithMerges.add(r.root);
}
if (r.remoteCommits > 0 || reorderNeeded) {
roots.add(r.root);
}
if (reorderNeeded) {
List<String> reordered = new ArrayList<String>();
for (int j = 0; j < node.getChildCount(); j++) {
if (node.getChildAt(j) instanceof CheckedTreeNode) {
CheckedTreeNode commitNode = (CheckedTreeNode) node.getChildAt(j);
if (!commitNode.isChecked()) {
Commit commit = (Commit) commitNode.getUserObject();
reordered.add(commit.revision.asString());
}
}
}
for (int j = 0; j < node.getChildCount(); j++) {
if (node.getChildAt(j) instanceof CheckedTreeNode) {
CheckedTreeNode commitNode = (CheckedTreeNode) node.getChildAt(j);
if (commitNode.isChecked()) {
Commit commit = (Commit) commitNode.getUserObject();
reordered.add(commit.revision.asString());
}
}
}
Collections.reverse(reordered);
reorderedCommits.put(r.root, reordered);
}
}
final GitVcsSettings.UpdateChangesPolicy p =
UpdatePolicyUtils.getUpdatePolicy(myStashRadioButton, myShelveRadioButton);
assert p == GitVcsSettings.UpdateChangesPolicy.STASH
|| p == GitVcsSettings.UpdateChangesPolicy.SHELVE;
return new RebaseInfo(reorderedCommits, rootsWithMerges, uncheckedCommits, roots, p);
}
// This method will construct the best possible path by using the A* search algorithm
private static List<String> AStarSearch(Polygon[] finalPolygons) {
List<String> completedPath = new ArrayList<String>();
String[] Ender = ePoint.split(",");
// The final goal point
double endx = Double.parseDouble(Ender[0]);
double endy = Double.parseDouble(Ender[1]);
//////////////////////////////////////////////////
// Correct path from the example map:
// (1,3) (2,6) (14,8) (22,19) (28,19) (31,19) (34,19)
//////////////////////////////////////////////////
// set of points to be evaluated, initially only containing start point
List<Points> openset = new ArrayList<Points>();
// set of points already evaluated
List<Points> closedset = new ArrayList<Points>();
// The initial starting point
GStartx = Startx;
GStarty = Starty;
// G-score is the calculated cost from the start to the current point
// Calculating F score, which is the distance between the current starting point and the final
// end point
double F_Cost = distance(Startx, Starty, endx, endy);
// initializing variables for each point
// current x and y location, current "came from" x and y location
int currX, currY, currCamex, currCamey;
// current G-Score and F-Score
double currG, currF;
double tentGscore, tentFscore;
openset.add(new Points((int) Startx, (int) Starty, 0, 0, F_Cost, -1, -1));
boolean dummy = true;
// while the openset is not empty
while (openset.size() != 0) {
// get the next Point to be evaluated in the openset with the lowest f-score
// filling variables with the information from the point being evaluated
currX = openset.get(0).XPoint;
currY = openset.get(0).YPoint;
currF = openset.get(0).costF;
currG = openset.get(0).costG;
currCamex = openset.get(0).camefromx;
currCamey = openset.get(0).camefromy;
Startx = currX;
Starty = currY;
// If the current point equals the goal point, start constructing a path back to the start
if (currX == endx && currY == endy) {
// add the last point to the closed set
closedset.add(new Points(currX, currY, 0, currG, currF, currCamex, currCamey));
for (int r = closedset.size() - 1; r >= 0; r--) {
// Loop from the end to the start of the closed set
// From the end point, look at the point that was "travelled from" and add that point to
// the path
if ((currX == closedset.get(r).XPoint) && (currY == closedset.get(r).YPoint)) {
completedPath.add(" (" + currX + "," + currY + ") ");
currX = closedset.get(r).camefromx;
currY = closedset.get(r).camefromy;
}
}
// Reverse the order from start to finish and print the path
Collections.reverse(completedPath);
System.out.print("Best path: ");
for (String omg : completedPath) {
// Final, constructed path
System.out.print(omg);
}
// End the algorithm
break;
}
// Check which points can be seen and travelled to from the current point
List<Points> Seeable = visible(finalPolygons);
// Before evaluating the current point, remove it from the openset and add it to the closed
// set
openset.remove(0);
closedset.add(new Points(currX, currY, 0, currG, currF, currCamex, currCamey));
// loop through all of the seeable points from the current point
for (Points neighbor : Seeable) {
int wanz = 0;
// Tentative F-Score = current G Score and the distance between current point and the
// neighbor point
tentGscore = currG + neighbor.lineLength;
tentFscore = tentGscore + distance(neighbor.XPoint, neighbor.YPoint, endx, endy);
for (int j = 0; j < closedset.size() - 1; j++) {
// if neighbor point is in closedset and the tentative FScore is >= the neighbor's FScore
if ((neighbor.XPoint == closedset.get(j).XPoint)
&& (neighbor.YPoint == closedset.get(j).YPoint)) {
// give the neighbor the F and G score it already has in the closed set
neighbor.costF = closedset.get(j).costF;
neighbor.costG = closedset.get(j).costG;
}
}
// if the neighbor point is not in the open set, or the tentative FScore of the current
// point is less than the FScore of the neighbor point
if ((!openset.contains(neighbor)) || tentFscore < neighbor.costF) {
// assign the current point as the "travelled from" point for the neighbor point
neighbor.camefromx = currX;
neighbor.camefromy = currY;
// give the F and G scores of the current point to the neighbor point
neighbor.costG = tentGscore;
neighbor.costF = tentFscore;
// Check to see if the current neighbor is in the open set
for (int i = 0; i < openset.size() - 1; i++) {
if ((neighbor.XPoint == openset.get(i).XPoint)
&& (neighbor.YPoint == openset.get(i).YPoint)) {
wanz++;
}
}
// If not, add to the open set
if (wanz == 0) {
openset = addStuff(openset, neighbor);
}
}
}
}
return completedPath;
}