/** * Method to find the Euler Tour based on the Hierholzer's algorithm. * * @param g : Input graph for which the tour is to be found. * @return : Returns a list of edges that comprises of the Euler Tour. */ public static List<Edge> findEulerTour(Graph<Vertex> g) { Vertex start = g.verts.get(1); Stack<Edge> forward = new Stack<Edge>(); Stack<Edge> backtrack = new Stack<Edge>(); Edge e = getUnvisitedEdge(start); while (e != null) { e.visited = true; forward.push(e); e = getUnvisitedEdge(e.To); } while (!(forward.isEmpty())) { e = forward.pop(); backtrack.push(e); e = getUnvisitedEdge(e.From); while (e != null) { e.visited = true; forward.push(e); e = getUnvisitedEdge(e.To); } } List<Edge> path = new LinkedList<Edge>(); while (!backtrack.isEmpty()) { Edge edge = backtrack.pop(); path.add(edge); } return path; }
/** * This is for debug only: print out training matrices in a CSV type format so that the matrices * can be examined in a spreadsheet program for debugging purposes. */ private void WriteCSVfile( List<String> rowNames, List<String> colNames, float[][] buf, String fileName) { p("tagList.size()=" + tagList.size()); try { FileWriter fw = new FileWriter(fileName + ".txt"); PrintWriter bw = new PrintWriter(new BufferedWriter(fw)); // write the first title row: StringBuffer sb = new StringBuffer(500); for (int i = 0, size = colNames.size(); i < size; i++) { sb.append("," + colNames.get(i)); } bw.println(sb.toString()); // loop on remaining rows: for (int i = 0, size = buf.length; i < size; i++) { sb.delete(0, sb.length()); sb.append(rowNames.get(i)); for (int j = 0, size2 = buf[i].length; j < size2; j++) { sb.append("," + buf[i][j]); } bw.println(sb.toString()); } bw.close(); } catch (IOException ioe) { ioe.printStackTrace(); } }
@NotNull public static char[] adaptiveLoadText(@NotNull Reader reader) throws IOException { char[] chars = new char[4096]; List<char[]> buffers = null; int count = 0; int total = 0; while (true) { int n = reader.read(chars, count, chars.length - count); if (n <= 0) break; count += n; if (total > 1024 * 1024 * 10) throw new FileTooBigException("File too big " + reader); total += n; if (count == chars.length) { if (buffers == null) { buffers = new ArrayList<char[]>(); } buffers.add(chars); int newLength = Math.min(1024 * 1024, chars.length * 2); chars = new char[newLength]; count = 0; } } char[] result = new char[total]; if (buffers != null) { for (char[] buffer : buffers) { System.arraycopy(buffer, 0, result, result.length - total, buffer.length); total -= buffer.length; } } System.arraycopy(chars, 0, result, result.length - total, total); return result; }
/** Return the list of ProgramElementDoc objects as Array. */ public static ProgramElementDoc[] toProgramElementDocArray(List list) { ProgramElementDoc[] pgmarr = new ProgramElementDoc[list.size()]; for (int i = 0; i < list.size(); i++) { pgmarr[i] = (ProgramElementDoc) (list.get(i)); } return pgmarr; }
public static IdeaPluginDescriptorImpl[] loadDescriptors(@Nullable StartupProgress progress) { if (ClassUtilCore.isLoadingOfExternalPluginsDisabled()) { return IdeaPluginDescriptorImpl.EMPTY_ARRAY; } final List<IdeaPluginDescriptorImpl> result = new ArrayList<IdeaPluginDescriptorImpl>(); int pluginsCount = countPlugins(PathManager.getPluginsPath()) + countPlugins(PathManager.getPreinstalledPluginsPath()); loadDescriptors(PathManager.getPluginsPath(), result, progress, pluginsCount); Application application = ApplicationManager.getApplication(); boolean fromSources = false; if (application == null || !application.isUnitTestMode()) { int size = result.size(); loadDescriptors(PathManager.getPreinstalledPluginsPath(), result, progress, pluginsCount); fromSources = size == result.size(); } loadDescriptorsFromProperty(result); loadDescriptorsFromClassPath(result, fromSources ? progress : null); IdeaPluginDescriptorImpl[] pluginDescriptors = result.toArray(new IdeaPluginDescriptorImpl[result.size()]); try { Arrays.sort(pluginDescriptors, new PluginDescriptorComparator(pluginDescriptors)); } catch (Exception e) { prepareLoadingPluginsErrorMessage( IdeBundle.message("error.plugins.were.not.loaded", e.getMessage())); getLogger().info(e); return findCorePlugin(pluginDescriptors); } return pluginDescriptors; }
/** * Given a string, return an array of tokens. The separator can be escaped with the '\' character. * The '\' character may also be escaped by the '\' character. * * @param s the string to tokenize. * @param separator the separator char. * @param maxTokens the maxmimum number of tokens returned. If the max is reached, the remaining * part of s is appended to the end of the last token. * @return an array of tokens. */ public static String[] tokenize(String s, char separator, int maxTokens) { List tokens = new ArrayList(); StringBuilder token = new StringBuilder(); boolean prevIsEscapeChar = false; for (int i = 0; i < s.length(); i += Character.charCount(i)) { int currentChar = s.codePointAt(i); if (prevIsEscapeChar) { // Case 1: escaped character token.appendCodePoint(currentChar); prevIsEscapeChar = false; } else if (currentChar == separator && tokens.size() < maxTokens - 1) { // Case 2: separator tokens.add(token.toString()); token = new StringBuilder(); } else if (currentChar == '\\') { // Case 3: escape character prevIsEscapeChar = true; } else { // Case 4: regular character token.appendCodePoint(currentChar); } } if (token.length() > 0) { tokens.add(token.toString()); } return (String[]) tokens.toArray(new String[] {}); }
/** * @return hash code of the instance * @author Klaus Meffert * @since 2.3 */ public int hashCode() { if (m_data.size() == 0) { return -29; } else { return m_data.hashCode(); } }
private Tree getTreeFromXML(Node root) { final Element eRoot = (Element) root; if (isWordNode(eRoot)) { return buildWordNode(eRoot); } else if (isEllipticNode(eRoot)) { return buildEllipticNode(eRoot); } else { List<Tree> kids = new ArrayList<>(); for (Node childNode = eRoot.getFirstChild(); childNode != null; childNode = childNode.getNextSibling()) { if (childNode.getNodeType() != Node.ELEMENT_NODE) continue; Tree t = getTreeFromXML(childNode); if (t == null) { System.err.printf( "%s: Discarding empty tree (root: %s)%n", this.getClass().getName(), childNode.getNodeName()); } else { kids.add(t); } } return (kids.size() == 0) ? null : buildConstituentNode(eRoot, kids); } }
@NotNull public static IpnbFile parseIpnbFile( @NotNull final CharSequence fileText, @NotNull final VirtualFile virtualFile) throws IOException { final String path = virtualFile.getPath(); IpnbFileRaw rawFile = gson.fromJson(fileText.toString(), IpnbFileRaw.class); if (rawFile == null) { int nbformat = isIpythonNewFormat(virtualFile) ? 4 : 3; return new IpnbFile(Collections.emptyMap(), nbformat, Lists.newArrayList(), path); } List<IpnbCell> cells = new ArrayList<IpnbCell>(); final IpnbWorksheet[] worksheets = rawFile.worksheets; if (worksheets == null) { for (IpnbCellRaw rawCell : rawFile.cells) { cells.add(rawCell.createCell()); } } else { for (IpnbWorksheet worksheet : worksheets) { final List<IpnbCellRaw> rawCells = worksheet.cells; for (IpnbCellRaw rawCell : rawCells) { cells.add(rawCell.createCell()); } } } return new IpnbFile(rawFile.metadata, rawFile.nbformat, cells, path); }
public TreeNode[] findNodeInContext(String startCtxPath, @Nullable final String name) { final List<TreeNode> out = new ArrayList<TreeNode>(); root.iterateThruContext( startCtxPath, new TreeNodeRoot.TreeNodeHandler2() { public boolean handleNode(int ctxPathCounter, TreeNode node) { if (name == null || node.getName().equalsIgnoreCase(name)) { out.add(node); } return true; } }); return out.toArray(new TreeNode[out.size()]); /* String[] path = startCtxPath.split("/"); int startWith = ("/" + path[1]).startsWith(ContextPath.FILE_CTX_PRX) ? 2 : 1; TreeNode cycled = root; for (int i = startWith; i < path.length; i++) { String encodedName = "/" + path[i]; cycled = cycled.findChildByEncodedName(encodedName); if (cycled == null) { return new TreeNode[0]; } } return cycled.findChildrenBySuffix(name); */ }
public List<TreeNode> getChildren() { List<TreeNode> lst = new ArrayList<TreeNode>(); for (List<TreeNodeImpl> lst1 : childs.values()) { lst.addAll(lst1); } return lst; }
@NotNull public ContextItem[] findCtxItems(String startCtxPath, String name) { String[] path = startCtxPath.split("/"); int startWith = ("/" + path[1]).startsWith(ContextPath.FILE_CTX_PRX) ? 2 : 1; TreeNode cycled = root; for (int i = startWith; i < path.length; i++) { String encodedName = "/" + path[i]; cycled = cycled.findChildByEncodedName(encodedName); if (cycled == null) { return new ContextItem[0]; } } List<ContextItem> out = new ArrayList<ContextItem>(); TreeNode[] children = name == null ? cycled.getChildren().toArray(new TreeNode[0]) : cycled.findChildrenBySuffix(name); for (TreeNode n : children) { // todo -- revise to replace using value directly with a TreeNode instance out.add(new ContextItemImpl(n.getPath(), n.getValue())); } return out.toArray(new ContextItem[out.size()]); }
public static void loadDescriptors( String pluginsPath, List<IdeaPluginDescriptorImpl> result, @Nullable StartupProgress progress, int pluginsCount) { final File pluginsHome = new File(pluginsPath); final File[] files = pluginsHome.listFiles(); if (files != null) { int i = result.size(); for (File file : files) { final IdeaPluginDescriptorImpl descriptor = loadDescriptor(file, PLUGIN_XML); if (descriptor == null) continue; if (progress != null) { progress.showProgress( descriptor.getName(), PLUGINS_PROGRESS_MAX_VALUE * ((float) ++i / pluginsCount)); } int oldIndex = result.indexOf(descriptor); if (oldIndex >= 0) { final IdeaPluginDescriptorImpl oldDescriptor = result.get(oldIndex); if (StringUtil.compareVersionNumbers(oldDescriptor.getVersion(), descriptor.getVersion()) < 0) { result.set(oldIndex, descriptor); } } else { result.add(descriptor); } } } }
private static boolean checkDependants( final IdeaPluginDescriptor pluginDescriptor, final Function<PluginId, IdeaPluginDescriptor> pluginId2Descriptor, final Condition<PluginId> check, final Set<PluginId> processed) { processed.add(pluginDescriptor.getPluginId()); final PluginId[] dependentPluginIds = pluginDescriptor.getDependentPluginIds(); final Set<PluginId> optionalDependencies = new HashSet<PluginId>(Arrays.asList(pluginDescriptor.getOptionalDependentPluginIds())); for (final PluginId dependentPluginId : dependentPluginIds) { if (processed.contains(dependentPluginId)) continue; // TODO[yole] should this condition be a parameter? if (isModuleDependency(dependentPluginId) && (ourAvailableModules.isEmpty() || ourAvailableModules.contains(dependentPluginId.getIdString()))) { continue; } if (!optionalDependencies.contains(dependentPluginId)) { if (!check.value(dependentPluginId)) { return false; } final IdeaPluginDescriptor dependantPluginDescriptor = pluginId2Descriptor.fun(dependentPluginId); if (dependantPluginDescriptor != null && !checkDependants(dependantPluginDescriptor, pluginId2Descriptor, check, processed)) { return false; } } } return true; }
// --------------------------------------------------------------------------- private void printDependencies(String target, PrintWriter pw, int spacing) throws TablesawException { Rule tr = findTargetRule(target); String[] pre; for (int I = 0; I < spacing; I++) pw.print("\t"); List<String> targetList = new ArrayList<String>(); if (tr != null) { for (String name : tr.getDependNames()) { targetList.add(name); } for (Rule r : tr.getDependRules()) { if ((r.getName() != null) && (!r.getName().startsWith(NAMED_RULE_PREFIX))) { targetList.add(r.getName()); } else { for (String t : r.getTargets()) { targetList.add(t); } } } } if (!m_printedDependencies.add(target) && (targetList.size() != 0)) { pw.println(target + "*"); return; } pw.println(target); for (String t : targetList) printDependencies(t, pw, spacing + 1); }
public static List asList(ProgramElementDoc[] members) { List list = new ArrayList(); for (int i = 0; i < members.length; i++) { list.add(members[i]); } return list; }
private List<Integer> primitiveArrayToObjectList(int[] ctxTypes) { List<Integer> out = new ArrayList<Integer>(ctxTypes != null ? ctxTypes.length : 0); for (int i = 0; i < out.size(); i++) { out.add(ctxTypes[i]); } return out; }
/** * This function obtains a list with the subexpressions of a given expressions * * @param expr The original expresion * @return the list with all the subexpressions */ public static List<Expr> getListExpr(Expr expr) throws IllegalArgumentException { List<Expr> list = new ArrayList<Expr>(); if (expr instanceof NumExpr) { list.add(expr); } else if (expr instanceof RefExpr) { RefExpr refExpr = (RefExpr) expr; String strRefExpr = refExpr.getZName().getWord(); // The \emptyset expression will be ignored if (!strRefExpr.equals(UtilSymbols.emptySetSymbol())) list.add(expr); } else if (expr instanceof SetExpr) { list = ((SetExpr) expr).getZExprList(); } else if (expr instanceof TupleExpr) { list = ((TupleExpr) expr).getZExprList(); } else if (expr instanceof ApplExpr) { if (((ApplExpr) expr).getMixfix()) { // es una secuencia ZExprListImpl applList = (ZExprListImpl) ((SetExpr) (((ApplExpr) expr).getRightExpr())).getZExprList(); for (int i = 0; i < applList.size(); i++) { Expr elem = (((TupleExpr) (applList.get(i))).getZExprList()).get(1); list.add(elem); } } else { // es un valor negativo list.add(expr); } } else { throw new IllegalArgumentException(); } return list; }
public IpnbCell createCell() { final IpnbCell cell; if (cell_type.equals("markdown")) { cell = new IpnbMarkdownCell(source, metadata); } else if (cell_type.equals("code")) { final List<IpnbOutputCell> outputCells = new ArrayList<IpnbOutputCell>(); for (CellOutputRaw outputRaw : outputs) { outputCells.add(outputRaw.createOutput()); } final Integer prompt = prompt_number != null ? prompt_number : execution_count; cell = new IpnbCodeCell( language == null ? "python" : language, input == null ? source : input, prompt, outputCells, metadata); } else if (cell_type.equals("raw")) { cell = new IpnbRawCell(source); } else if (cell_type.equals("heading")) { cell = new IpnbHeadingCell(source, level, metadata); } else { cell = null; } return cell; }
List<ANTLRMessage> getMessagesOfType(List<ANTLRMessage> msgs, Class c) { List<ANTLRMessage> filtered = new ArrayList<ANTLRMessage>(); for (ANTLRMessage m : msgs) { if (m.getClass() == c) filtered.add(m); } return filtered; }
public ListIterator<ICFLibAnyObj> enumerateDetails(MssCFGenContext genContext) { final String S_ProcName = "CFAsteriskMssCFIterateHostNodeConfFile.enumerateDetails() "; if (genContext == null) { throw CFLib.getDefaultExceptionFactory() .newNullArgumentException(getClass(), S_ProcName, 1, "genContext"); } ICFLibAnyObj genDef = genContext.getGenDef(); if (genDef == null) { throw CFLib.getDefaultExceptionFactory() .newNullArgumentException(getClass(), S_ProcName, 1, "genContext.getGenDef()"); } List<ICFLibAnyObj> list = new LinkedList<ICFLibAnyObj>(); if (genDef instanceof ICFAsteriskHostNodeObj) { Iterator<ICFAsteriskConfigurationFileObj> elements = ((ICFAsteriskHostNodeObj) genDef).getOptionalComponentsConfFile().iterator(); while (elements.hasNext()) { list.add(elements.next()); } } else { throw CFLib.getDefaultExceptionFactory() .newUnsupportedClassException( getClass(), S_ProcName, "genContext.getGenDef()", genDef, "ICFAsteriskHostNodeObj"); } return (list.listIterator()); }
/* hack TODO do not know how to get int status back from Windows * Stick in code that handles particular commands that we can figure out * the status. */ private int determineStatus(List<String> args) { if (args == null) throw new NullPointerException(); if (args.size() < 2) return 0; String instanceName = args.get(args.size() - 1); if (isCommand(args, "_delete-instance-filesystem")) { try { String dir = Paths.getInstanceDirPath(node, instanceName); WindowsRemoteFile instanceDir = new WindowsRemoteFile(dcomInfo.getCredentials(), dir); return instanceDir.exists() ? 1 : 0; } catch (WindowsException ex) { return 0; } } else if (isCommand(args, "_create-instance-filesystem")) { try { String dir = Paths.getDasPropsPath(node); WindowsRemoteFile dasProps = new WindowsRemoteFile(dcomInfo.getCredentials(), dir); if (dasProps.exists()) return 0; // uh-oh. Wipe out the instance directory that was created dir = Paths.getInstanceDirPath(node, instanceName); WindowsRemoteFile instanceDir = new WindowsRemoteFile(dcomInfo.getCredentials(), dir); instanceDir.delete(); return 1; } catch (WindowsException ex) { return 1; } } return 0; }
/** @see java.lang.ClassLoader#findResources(java.lang.String) */ @Override public Enumeration<URL> findResources(String resourceName) throws IOException { String webInfResourceName = "WEB-INF/classes/" + resourceName; List<URL> urlList = new ArrayList<URL>(); int jarFileListSize = jarFileList.size(); for (int i = 0; i < jarFileListSize; i++) { JarFile jarFile = jarFileList.get(i); JarEntry jarEntry = jarFile.getJarEntry(resourceName); // to better support war format, look for the resourceName in the WEB-INF/classes directory if (loadWebInf && jarEntry == null) jarEntry = jarFile.getJarEntry(webInfResourceName); if (jarEntry != null) { try { String jarFileName = jarFile.getName(); if (jarFileName.contains("\\")) jarFileName = jarFileName.replace('\\', '/'); urlList.add(new URL("jar:file:" + jarFileName + "!/" + jarEntry)); } catch (MalformedURLException e) { System.out.println( "Error making URL for [" + resourceName + "] in jar [" + jarFile + "] in war file [" + outerFile + "]: " + e.toString()); } } } // add all resources found in parent loader too Enumeration<URL> superResources = super.findResources(resourceName); while (superResources.hasMoreElements()) urlList.add(superResources.nextElement()); return Collections.enumeration(urlList); }
/* * return 0 is success, otherwise failure */ public final int runAdminCommandOnRemoteNode( Node thisNode, StringBuilder output, List<String> args, List<String> stdinLines) throws SSHCommandExecutionException, IllegalArgumentException, UnsupportedOperationException { String humanreadable = null; try { this.node = thisNode; dcomInfo = new DcomInfo(node); List<String> fullcommand = new ArrayList<String>(); WindowsRemoteAsadmin asadmin = dcomInfo.getAsadmin(); if (stdinLines != null && !stdinLines.isEmpty()) setupAuthTokenFile(fullcommand, stdinLines); fullcommand.addAll(args); humanreadable = dcomInfo.getNadminPath() + " " + commandListToString(fullcommand); // This is where the rubber meets the road... String out = asadmin.run(fullcommand); output.append(out); logger.info(Strings.get("remote.command.summary", humanreadable, out)); return determineStatus(args); } catch (WindowsException ex) { throw new SSHCommandExecutionException( Strings.get("remote.command.error", ex.getMessage(), humanreadable), ex); } finally { teardownAuthTokenFile(); } }
public void addTypeArgument(Access node) { List<Access> list = (parent == null || state == null) ? getTypeArgumentListNoTransform() : getTypeArgumentList(); list.addChild(node); }
private long[] getTotals(int day, long start_offset) { if (start_offset == 0) { return (getTotals(day)); } else { List<Long> records = getContents().get(day + "." + start_offset); if (records != null) { long[] result = new long[STAT_ENTRY_COUNT]; if (records.size() == STAT_ENTRY_COUNT) { for (int i = 0; i < STAT_ENTRY_COUNT; i++) { result[i] = (Long) records.get(i); } } return (result); } return (null); } }
/** * This is for book production only: print out training matrices in a Latex type format so that * the matrices can be inserted into my manuscript: * * <p>\begin{table}[htdp] \caption{Runtimes by Method} \centering * * <p>\begin{tabular}{|l|l|l|} \hline \textbf{Class.method name}&\textbf{Percent of total * runtime}&\textbf{Percent in this method}\\ \hline Chess.main&97.7&0.0\\ * GameSearch.playGame&96.5&0.0\\ * * <p>Chess.calcPieceMoves&1.7&0.8\\ \hline \end{tabular} * * <p>\label{tab:runtimes_by_method} \end{table} */ private void WriteLatexFile( List<String> rowNames, List<String> colNames, float[][] buf, String fileName) { p("tagList.size()=" + tagList.size()); int SKIP = 6; try { FileWriter fw = new FileWriter(fileName + ".latex"); PrintWriter bw = new PrintWriter(new BufferedWriter(fw)); int size = colNames.size() - SKIP; bw.print("\\begin{table*}[htdp]\n\\caption{ADD CAPTION}\\centering\\begin{tabular}{|"); for (int i = 0; i < size + 1; i++) bw.print("l|"); bw.println("}\n\\hline"); bw.print(" &"); for (int i = 0; i < size; i++) { bw.print("\\emph{" + colNames.get(i) + "}"); if (i < (size - 1)) bw.print("&"); } bw.println("\\\\\n\\hline"); // bw.printf(format, args) // loop on remaining rows: for (int i = 0, size3 = buf.length - SKIP; i < size3; i++) { bw.print(rowNames.get(i) + "&"); for (int j = 0, size2 = buf[i].length - SKIP; j < size2; j++) { bw.printf("%.2f", buf[i][j]); if (j < (size2 - 1)) bw.print("&"); } bw.println("\\\\"); } bw.println("\\hline\n\\end{tabular}\n\\label{tab:CHANGE_THIS_LABEL}\n\\end{table*}"); bw.close(); } catch (IOException ioe) { ioe.printStackTrace(); } }
private CipherTest(PeerFactory peerFactory) throws IOException { THREADS = Integer.parseInt(System.getProperty("numThreads", "4")); factory = (SSLSocketFactory) SSLSocketFactory.getDefault(); SSLSocket socket = (SSLSocket) factory.createSocket(); String[] cipherSuites = socket.getSupportedCipherSuites(); String[] protocols = socket.getSupportedProtocols(); // String[] clientAuths = {null, "RSA", "DSA"}; String[] clientAuths = {null}; tests = new ArrayList<TestParameters>(cipherSuites.length * protocols.length * clientAuths.length); for (int i = 0; i < cipherSuites.length; i++) { String cipherSuite = cipherSuites[i]; for (int j = 0; j < protocols.length; j++) { String protocol = protocols[j]; if (!peerFactory.isSupported(cipherSuite, protocol)) { continue; } for (int k = 0; k < clientAuths.length; k++) { String clientAuth = clientAuths[k]; if ((clientAuth != null) && (cipherSuite.indexOf("DH_anon") != -1)) { // no client with anonymous ciphersuites continue; } tests.add(new TestParameters(cipherSuite, protocol, clientAuth)); } } } testIterator = tests.iterator(); }
@NotNull public static byte[] adaptiveLoadBytes(@NotNull InputStream stream) throws IOException { byte[] bytes = new byte[4096]; List<byte[]> buffers = null; int count = 0; int total = 0; while (true) { int n = stream.read(bytes, count, bytes.length - count); if (n <= 0) break; count += n; if (total > 1024 * 1024 * 10) throw new FileTooBigException("File too big " + stream); total += n; if (count == bytes.length) { if (buffers == null) { buffers = new ArrayList<byte[]>(); } buffers.add(bytes); int newLength = Math.min(1024 * 1024, bytes.length * 2); bytes = new byte[newLength]; count = 0; } } byte[] result = new byte[total]; if (buffers != null) { for (byte[] buffer : buffers) { System.arraycopy(buffer, 0, result, result.length - total, buffer.length); total -= buffer.length; } } System.arraycopy(bytes, 0, result, result.length - total, total); return result; }
/** * Constructor for Graph * * @param size : int - number of vertices */ Graph(int size) { numNodes = size; verts = new ArrayList<>(size + 1); verts.add(0, null); // create an array of Vertex objects for (int i = 1; i <= size; i++) verts.add(i, new Vertex(i)); }