/** * To reduce the search space we will only consider routes that start and end at one city * (whichever is first in the collection). All other possible routes are equivalent to one of * these routes since start city is irrelevant in determining the shortest cycle. * * @param cities The list of destinations, each of which must be visited once. * @param progressListener Call-back for receiving the status of the algorithm as it progresses. * May be null. * @return The shortest route that visits each of the specified cities once. */ public List<String> calculateShortestRoute( Collection<String> cities, ProgressListener progressListener) { Iterator<String> iterator = cities.iterator(); String startCity = iterator.next(); Collection<String> destinations = new ArrayList<String>(cities.size() - 1); while (iterator.hasNext()) { destinations.add(iterator.next()); } FitnessEvaluator<List<String>> evaluator = new RouteEvaluator(distances); PermutationGenerator<String> generator = new PermutationGenerator<String>(destinations); long totalPermutations = generator.getTotalPermutations(); long count = 0; List<String> shortestRoute = null; double shortestDistance = Double.POSITIVE_INFINITY; List<String> currentRoute = new ArrayList<String>(cities.size()); while (generator.hasMore()) { List<String> route = generator.nextPermutationAsList(currentRoute); route.add(0, startCity); double distance = evaluator.getFitness(route, null); if (distance < shortestDistance) { shortestDistance = distance; shortestRoute = new ArrayList<String>(route); } ++count; if (count % 1000 == 0 && progressListener != null) { progressListener.updateProgress(((double) count) / totalPermutations * 100); } } if (progressListener != null) { progressListener.updateProgress(100); // Finished. } return shortestRoute; }
private int calcProgress(int totalChunks, int writtenChunks, int lastProgress) { int curProgress = 100 * writtenChunks / totalChunks; if (lastProgress < curProgress) { lastProgress = curProgress; for (ProgressListener pl : this.listeners) pl.trigger(lastProgress); } return lastProgress; }
private void updateProgress(final String text) { if (lastValue <= 0.0F) { if (!(currentCounter + 1 >= totalCounter)) progressListener.onProgressUpdate(computeMultiProgress(), text); else finish(text); return; } if (!(currentCounter + 1 >= totalCounter)) progressListener.onProgressUpdate(computeProgress(), text); else finish(text); }
public List<MarketSnapshot> load(ProgressListener progressListener) throws JBookTraderException { String line = ""; int lineSeparatorSize = System.getProperty("line.separator").length(); long sizeRead = 0, lineNumber = 0; List<MarketSnapshot> snapshots = new ArrayList<MarketSnapshot>(); try { while ((line = reader.readLine()) != null) { if (lineNumber % 50000 == 0) { progressListener.setProgress(sizeRead, fileSize, "Loading historical data file"); if (progressListener.isCancelled()) { break; } } lineNumber++; sizeRead += line.length() + lineSeparatorSize; boolean isComment = line.startsWith("#"); boolean isProperty = line.contains("="); boolean isBlankLine = (line.trim().length() == 0); boolean isMarketDepthLine = !(isComment || isProperty || isBlankLine); if (isMarketDepthLine) { MarketSnapshot marketSnapshot = toMarketDepth(line); if (filter == null || filter.contains(time)) { snapshots.add(marketSnapshot); } previousTime = time; } else if (isProperty) { if (line.startsWith("timeZone")) { setTimeZone(line); } } } if (sdf == null) { String msg = "Property " + "\"timeZone\"" + " is not defined in the data file." + LINE_SEP; throw new JBookTraderException(msg); } } catch (IOException ioe) { throw new JBookTraderException("Could not read data file"); } catch (Exception e) { String errorMsg = "Problem parsing line #" + lineNumber + ": " + line + LINE_SEP; String description = e.getMessage(); if (description == null) { description = e.toString(); } errorMsg += description; throw new RuntimeException(errorMsg); } return snapshots; }
@Override public void onClick(DialogInterface dialog, int which) { if (which == DialogInterface.BUTTON_POSITIVE) { if (mListener != null) { mListener.onConfirmDialogDismissed(true); } onMenuClicked(mActionId, mListener); } else { if (mListener != null) { mListener.onConfirmDialogDismissed(false); } } }
public void analyzeInnerClasses(ProgressListener pl, double done, double scale) { double subScale = scale / innerComplexity; // If output should be immediate, we delay analyzation to output. // Note that this may break anonymous classes, but the user // has been warned. if ((Options.options & Options.OPTION_IMMEDIATE) != 0) return; // Now analyze the inner classes. for (int j = 0; j < inners.length; j++) { if (pl != null) { double innerCompl = inners[j].getComplexity() * subScale; if (innerCompl > STEP_COMPLEXITY) { double innerscale = subScale * inners[j].methodComplexity; inners[j].analyze(pl, done, innerscale); inners[j].analyzeInnerClasses(null, done + innerscale, innerCompl - innerscale); } else { pl.updateProgress(done, inners[j].name); inners[j].analyze(null, 0.0, 0.0); inners[j].analyzeInnerClasses(null, 0.0, 0.0); } done += innerCompl; } else { inners[j].analyze(null, 0.0, 0.0); inners[j].analyzeInnerClasses(null, 0.0, 0.0); } } // Now analyze the method scoped classes. for (int j = 0; j < methods.length; j++) methods[j].analyzeInnerClasses(); }
@Override public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { super.startElement(uri, localName, qName, attributes); if (localName.equals("repo")) { String pk = attributes.getValue("", "pubkey"); if (pk != null) pubkey = pk; } else if (localName.equals("application") && curapp == null) { curapp = new DB.App(); curapp.detail_Populated = true; Bundle progressData = createProgressData(repo.address); progressCounter++; progressListener.onProgress( new ProgressListener.Event( RepoXMLHandler.PROGRESS_TYPE_PROCESS_XML, progressCounter, totalAppCount, progressData)); } else if (localName.equals("package") && curapp != null && curapk == null) { curapk = new DB.Apk(); curapk.id = curapp.id; curapk.repo = repo.id; hashType = null; } else if (localName.equals("hash") && curapk != null) { hashType = attributes.getValue("", "type"); } curchars.setLength(0); }
public static void copyInputStreamToOutputStream( InputStream from, OutputStream to, int bufferSize, boolean closeInput, boolean closeOutput, ProgressListener progressListener) { try { int totalBytesRead = 0; int bytesRead = 0; int offset = 0; byte[] data = new byte[bufferSize]; while ((bytesRead = from.read(data, offset, bufferSize)) > 0) { totalBytesRead += bytesRead; to.write(data, offset, bytesRead); if (progressListener != null) progressListener.onProgressUpdate(totalBytesRead); // Log.d(TAG, "Copied " + totalBytesRead + " bytes"); } closeStreams(from, to, closeInput, closeOutput); } catch (Exception e) { closeStreams(from, to, closeInput, closeOutput); e.printStackTrace(); throw new RuntimeException(e); } }
protected void _setMessage(String message) { if (currentSubTaskMessage.length() > 0) { message = currentSubTaskMessage + (message.length() > 0 ? ": " + message : ""); // concatentate the parent message and the sub-task messages. Previous behaviour was // just to overwrite the parent sub-task message, but I think this is just wrong. } listener._setMessage(message); }
/** * Sets the size for total increments. * * @param totalCounter */ public void setup(final int totalCounter) { if (!enabled) return; this.totalCounter = totalCounter; progressLength = progressListener.getProgressLength(); currentValue = 0.0F; lastValue = 0.0F; currentCounter = 0.0F; }
private void publishResults( String a, int p1, int p2, int id, long total, long done, boolean b, boolean move) { if (hash.get(id)) { mBuilder.setProgress(100, p1, false); mBuilder.setOngoing(true); int title = R.string.copying; if (move) title = R.string.moving; mBuilder.setContentTitle(utils.getString(c, title)); mBuilder.setContentText( new File(a).getName() + " " + utils.readableFileSize(done) + "/" + utils.readableFileSize(total)); int id1 = Integer.parseInt("456" + id); mNotifyManager.notify(id1, mBuilder.build()); if (p1 == 100 || total == 0) { mBuilder.setContentTitle("Copy completed"); if (move) mBuilder.setContentTitle("Move Completed"); mBuilder.setContentText(""); mBuilder.setProgress(0, 0, false); mBuilder.setOngoing(false); mBuilder.setAutoCancel(true); mNotifyManager.notify(id1, mBuilder.build()); publishCompletedResult(id, id1); } DataPackage intent = new DataPackage(); intent.setName(a); intent.setTotal(total); intent.setDone(done); intent.setId(id); intent.setP1(p1); intent.setP2(p2); intent.setMove(move); intent.setCompleted(b); hash1.put(id, intent); if (progressListener != null) { progressListener.onUpdate(intent); if (b) progressListener.refresh(); } } else publishCompletedResult(id, Integer.parseInt("456" + id)); }
public void dumpJavaFile(TabbedPrintWriter writer, ProgressListener pl) throws IOException { imports.init(clazz.getName()); LocalInfo.init(); initialize(); double done = 0.05; double scale = (0.75) * methodComplexity / (methodComplexity + innerComplexity); analyze(pl, INITIALIZE_COMPLEXITY, scale); done += scale; analyzeInnerClasses(pl, done, 0.8 - done); makeDeclaration(new SimpleSet()); imports.dumpHeader(writer); dumpSource(writer, pl, 0.8, 0.2); if (pl != null) pl.updateProgress(1.0, name); }
public void onMenuClicked(MenuItem menuItem, String confirmMsg, final ProgressListener listener) { final int action = menuItem.getItemId(); if (confirmMsg != null) { if (listener != null) listener.onConfirmDialogShown(); ConfirmDialogListener cdl = new ConfirmDialogListener(action, listener); new AlertDialog.Builder(mActivity.getAndroidContext()) .setMessage(confirmMsg) .setOnCancelListener(cdl) .setPositiveButton(R.string.ok, cdl) .setNegativeButton(R.string.cancel, cdl) .create() .show(); } else { onMenuClicked(action, listener); } }
@Override public void write(byte[] b, int off, int len) throws IOException { int BUFFER_SIZE = 10000; int chunkSize; int currentOffset = 0; while (len > currentOffset) { chunkSize = len - currentOffset; if (chunkSize > BUFFER_SIZE) { chunkSize = BUFFER_SIZE; } out.write(b, currentOffset, chunkSize); currentOffset += chunkSize; transferred += chunkSize; listener.transferred(transferred); } }
protected void _setProgress(double fractionCompleted) { if (fractionCompleted > 1.0000001) { // Allow 1.0000001 to handle rounding errors assert false : "Progress should be <= 1. Passed in " + fractionCompleted; } if (fractionCompleted > 1) fractionCompleted = 1; if (fractionCompleted < currentOperationProgress) { assert false : "Progress shouldn't go backwards. Went from " + currentOperationProgress + " to " + fractionCompleted; } if (fractionCompleted < 0) { assert false : "Progress must be >=0 but got " + fractionCompleted; } currentOperationProgress = fractionCompleted; listener._setProgress(baseTime + fractionCompleted * getTaskFraction(currentOperationNum)); }
public void trimAllThreads(int length, ProgressListener listener) { Cursor cursor = null; int threadCount = 0; int complete = 0; try { cursor = this.getConversationList(); if (cursor != null) threadCount = cursor.getCount(); while (cursor != null && cursor.moveToNext()) { long threadId = cursor.getLong(cursor.getColumnIndexOrThrow(ID)); trimThread(threadId, length); listener.onProgress(++complete, threadCount); } } finally { if (cursor != null) cursor.close(); } }
@Override public void write(int b) throws IOException { out.write(b); transferred++; listener.transferred(transferred); }
/** * Construct the singular value decomposition * * @param Arg Rectangular matrix * @return Structure to access U, S and V. */ public SingularValueDecomposition( double[][] A, ProgressListener progressListener, ThreadMaster threadMaster) { // Derived from LINPACK code. // Initialize. m = A.length; n = A[0].length; int nu = Math.min(m, n); s = new double[Math.min(m + 1, n)]; U = new double[m][nu]; V = new double[n][n]; double[] e = new double[n]; double[] work = new double[m]; boolean wantu = true; boolean wantv = true; // Reduce A to bidiagonal form, storing the diagonal elements // in s and the super-diagonal elements in e. int nct = Math.min(m - 1, n); int nrt = Math.max(0, Math.min(n - 2, m)); if (progressListener != null) progressListener.startProgress("Initializing SVD...", 0, Math.max(nct, nrt)); for (int k = 0; k < Math.max(nct, nrt); k++) { if (progressListener != null) progressListener.updateProgress(k); if (threadMaster != null && threadMaster.threadMustDie()) return; if (k < nct) { // Compute the transformation for the k-th column and // place the k-th diagonal in s[k]. // Compute 2-norm of k-th column without under/overflow. s[k] = 0; for (int i = k; i < m; i++) { s[k] = hypot(s[k], A[i][k]); } if (s[k] != 0.0) { if (A[k][k] < 0.0) { s[k] = -s[k]; } for (int i = k; i < m; i++) { A[i][k] /= s[k]; } A[k][k] += 1.0; } s[k] = -s[k]; } for (int j = k + 1; j < n; j++) { if ((k < nct) & (s[k] != 0.0)) { // Apply the transformation. double t = 0; for (int i = k; i < m; i++) { t += A[i][k] * A[i][j]; } t = -t / A[k][k]; for (int i = k; i < m; i++) { A[i][j] += t * A[i][k]; } } // Place the k-th row of A into e for the // subsequent calculation of the row transformation. e[j] = A[k][j]; } if (wantu & (k < nct)) { // Place the transformation in U for subsequent back // multiplication. for (int i = k; i < m; i++) { U[i][k] = A[i][k]; } } if (k < nrt) { // Compute the k-th row transformation and place the // k-th super-diagonal in e[k]. // Compute 2-norm without under/overflow. e[k] = 0; for (int i = k + 1; i < n; i++) { e[k] = hypot(e[k], e[i]); } if (e[k] != 0.0) { if (e[k + 1] < 0.0) { e[k] = -e[k]; } for (int i = k + 1; i < n; i++) { e[i] /= e[k]; } e[k + 1] += 1.0; } e[k] = -e[k]; if ((k + 1 < m) & (e[k] != 0.0)) { // Apply the transformation. for (int i = k + 1; i < m; i++) { work[i] = 0.0; } for (int j = k + 1; j < n; j++) { for (int i = k + 1; i < m; i++) { work[i] += e[j] * A[i][j]; } } for (int j = k + 1; j < n; j++) { double t = -e[j] / e[k + 1]; for (int i = k + 1; i < m; i++) { A[i][j] += t * work[i]; } } } if (wantv) { // Place the transformation in V for subsequent // back multiplication. for (int i = k + 1; i < n; i++) { V[i][k] = e[i]; } } } } // Set up the final bidiagonal matrix or order p. int p = Math.min(n, m + 1); if (nct < n) { s[nct] = A[nct][nct]; } if (m < p) { s[p - 1] = 0.0; } if (nrt + 1 < p) { e[nrt] = A[nrt][p - 1]; } e[p - 1] = 0.0; // If required, generate U. if (wantu) { if (progressListener != null) progressListener.startProgress("generating eigenvalues...", 0, nct); for (int j = nct; j < nu; j++) { for (int i = 0; i < m; i++) { U[i][j] = 0.0; } U[j][j] = 1.0; } for (int k = nct - 1; k >= 0; k--) { if (progressListener != null) progressListener.updateProgress(nct - k); if (threadMaster != null && threadMaster.threadMustDie()) return; if (s[k] != 0.0) { for (int j = k + 1; j < nu; j++) { double t = 0; for (int i = k; i < m; i++) { t += U[i][k] * U[i][j]; } t = -t / U[k][k]; for (int i = k; i < m; i++) { U[i][j] += t * U[i][k]; } } for (int i = k; i < m; i++) { U[i][k] = -U[i][k]; } U[k][k] = 1.0 + U[k][k]; for (int i = 0; i < k - 1; i++) { U[i][k] = 0.0; } } else { for (int i = 0; i < m; i++) { U[i][k] = 0.0; } U[k][k] = 1.0; } } } // If required, generate V. if (wantv) { if (progressListener != null) progressListener.startProgress("generating eigenvectors...", 0, n); for (int k = n - 1; k >= 0; k--) { if (progressListener != null) progressListener.updateProgress(n - k); if (threadMaster != null && threadMaster.threadMustDie()) return; if ((k < nrt) & (e[k] != 0.0)) { for (int j = k + 1; j < nu; j++) { double t = 0; for (int i = k + 1; i < n; i++) { t += V[i][k] * V[i][j]; } t = -t / V[k + 1][k]; for (int i = k + 1; i < n; i++) { V[i][j] += t * V[i][k]; } } } for (int i = 0; i < n; i++) { V[i][k] = 0.0; } V[k][k] = 1.0; } } // Main iteration loop for the singular values. int pp = p - 1; int iter = 0; double eps = Math.pow(2.0, -52.0); if (progressListener != null) progressListener.startProgress("locating negligible elements...", 0, pp + 1); while (p > 0) { if (progressListener != null) progressListener.updateProgress(pp - p); if (threadMaster != null && threadMaster.threadMustDie()) return; int k, kase; // Here is where a test for too many iterations would go. // This section of the program inspects for // negligible elements in the s and e arrays. On // completion the variables kase and k are set as follows. // kase = 1 if s(p) and e[k-1] are negligible and k<p // kase = 2 if s(k) is negligible and k<p // kase = 3 if e[k-1] is negligible, k<p, and // s(k), ..., s(p) are not negligible (qr step). // kase = 4 if e(p-1) is negligible (convergence). for (k = p - 2; k >= -1; k--) { if (k == -1) { break; } if (Math.abs(e[k]) <= eps * (Math.abs(s[k]) + Math.abs(s[k + 1]))) { e[k] = 0.0; break; } } if (k == p - 2) { kase = 4; } else { int ks; for (ks = p - 1; ks >= k; ks--) { if (ks == k) { break; } double t = (ks != p ? Math.abs(e[ks]) : 0.) + (ks != k + 1 ? Math.abs(e[ks - 1]) : 0.); if (Math.abs(s[ks]) <= eps * t) { s[ks] = 0.0; break; } } if (ks == k) { kase = 3; } else if (ks == p - 1) { kase = 1; } else { kase = 2; k = ks; } } k++; // Perform the task indicated by kase. switch (kase) { // Deflate negligible s(p). case 1: { double f = e[p - 2]; e[p - 2] = 0.0; for (int j = p - 2; j >= k; j--) { double t = hypot(s[j], f); double cs = s[j] / t; double sn = f / t; s[j] = t; if (j != k) { f = -sn * e[j - 1]; e[j - 1] = cs * e[j - 1]; } if (wantv) { for (int i = 0; i < n; i++) { t = cs * V[i][j] + sn * V[i][p - 1]; V[i][p - 1] = -sn * V[i][j] + cs * V[i][p - 1]; V[i][j] = t; } } } } break; // Split at negligible s(k). case 2: { double f = e[k - 1]; e[k - 1] = 0.0; for (int j = k; j < p; j++) { double t = hypot(s[j], f); double cs = s[j] / t; double sn = f / t; s[j] = t; f = -sn * e[j]; e[j] = cs * e[j]; if (wantu) { for (int i = 0; i < m; i++) { t = cs * U[i][j] + sn * U[i][k - 1]; U[i][k - 1] = -sn * U[i][j] + cs * U[i][k - 1]; U[i][j] = t; } } } } break; // Perform one qr step. case 3: { // Calculate the shift. double scale = Math.max( Math.max( Math.max( Math.max(Math.abs(s[p - 1]), Math.abs(s[p - 2])), Math.abs(e[p - 2])), Math.abs(s[k])), Math.abs(e[k])); double sp = s[p - 1] / scale; double spm1 = s[p - 2] / scale; double epm1 = e[p - 2] / scale; double sk = s[k] / scale; double ek = e[k] / scale; double b = ((spm1 + sp) * (spm1 - sp) + epm1 * epm1) / 2.0; double c = (sp * epm1) * (sp * epm1); double shift = 0.0; if ((b != 0.0) | (c != 0.0)) { shift = Math.sqrt(b * b + c); if (b < 0.0) { shift = -shift; } shift = c / (b + shift); } double f = (sk + sp) * (sk - sp) + shift; double g = sk * ek; // Chase zeros. for (int j = k; j < p - 1; j++) { double t = hypot(f, g); double cs = f / t; double sn = g / t; if (j != k) { e[j - 1] = t; } f = cs * s[j] + sn * e[j]; e[j] = cs * e[j] - sn * s[j]; g = sn * s[j + 1]; s[j + 1] = cs * s[j + 1]; if (wantv) { for (int i = 0; i < n; i++) { t = cs * V[i][j] + sn * V[i][j + 1]; V[i][j + 1] = -sn * V[i][j] + cs * V[i][j + 1]; V[i][j] = t; } } t = hypot(f, g); cs = f / t; sn = g / t; s[j] = t; f = cs * e[j] + sn * s[j + 1]; s[j + 1] = -sn * e[j] + cs * s[j + 1]; g = sn * e[j + 1]; e[j + 1] = cs * e[j + 1]; if (wantu && (j < m - 1)) { for (int i = 0; i < m; i++) { t = cs * U[i][j] + sn * U[i][j + 1]; U[i][j + 1] = -sn * U[i][j] + cs * U[i][j + 1]; U[i][j] = t; } } } e[p - 2] = f; iter = iter + 1; } break; // Convergence. case 4: { // Make the singular values positive. if (s[k] <= 0.0) { s[k] = (s[k] < 0.0 ? -s[k] : 0.0); if (wantv) { for (int i = 0; i <= pp; i++) { V[i][k] = -V[i][k]; } } } // Order the singular values. while (k < pp) { if (s[k] >= s[k + 1]) { break; } double t = s[k]; s[k] = s[k + 1]; s[k + 1] = t; if (wantv && (k < n - 1)) { for (int i = 0; i < n; i++) { t = V[i][k + 1]; V[i][k + 1] = V[i][k]; V[i][k] = t; } } if (wantu && (k < m - 1)) { for (int i = 0; i < m; i++) { t = U[i][k + 1]; U[i][k + 1] = U[i][k]; U[i][k] = t; } } k++; } iter = 0; p--; } break; } } }
public synchronized void finish(final String format, final Object... args) { if (!enabled) return; progressListener.onProgressUpdate( progressLength, MessageFormatter.format(format, args).getMessage()); }
@Override protected void onPreExecute() { final ProgressListener pl = listeners.getListener(); pl.showProgress(true); }
@Override public void onCancel(DialogInterface dialog) { if (mListener != null) { mListener.onConfirmDialogDismissed(false); } }
public static void processBasicColumns( MetaDataDialect metaDataDialect, ReverseEngineeringStrategy revengStrategy, String defaultSchema, String defaultCatalog, Table table, ProgressListener progress) { String qualify = TableNameQualifier.qualify(table.getCatalog(), table.getSchema(), table.getName()); Iterator<?> columnIterator = null; try { Map<?, ?> columnRs = null; log.debug("Finding columns for " + qualify); progress.startSubTask("Finding columns for " + qualify); columnIterator = metaDataDialect.getColumns( getCatalogForDBLookup(table.getCatalog(), defaultCatalog), getSchemaForDBLookup(table.getSchema(), defaultSchema), table.getName(), null); // dumpHeader(columnRs); while (columnIterator.hasNext()) { // dumpRow(columnRs); columnRs = (Map<?, ?>) columnIterator.next(); String tableName = (String) columnRs.get("TABLE_NAME"); int sqlType = ((Integer) columnRs.get("DATA_TYPE")).intValue(); // String sqlTypeName = (String) columnRs.get("TYPE_NAME"); String columnName = (String) columnRs.get("COLUMN_NAME"); String comment = (String) columnRs.get("REMARKS"); TableIdentifier ti = RevEngUtils.createTableIdentifier(table, defaultCatalog, defaultSchema); if (revengStrategy.excludeColumn(ti, columnName)) { log.debug("Column " + ti + "." + columnName + " excluded by strategy"); continue; } if (!tableName.equals(table.getName())) { log.debug( "Table name " + tableName + " does not match requested " + table.getName() + ". Ignoring column " + columnName + " since it either is invalid or a duplicate"); continue; } // String columnDefaultValue = columnRs.getString("COLUMN_DEF"); TODO: only read if have a // way to avoid issues with clobs/lobs and similar int dbNullability = ((Integer) columnRs.get("NULLABLE")).intValue(); boolean isNullable = true; switch (dbNullability) { case DatabaseMetaData.columnNullable: case DatabaseMetaData.columnNullableUnknown: isNullable = true; break; case DatabaseMetaData.columnNoNulls: isNullable = false; break; default: isNullable = true; } int size = ((Integer) columnRs.get("COLUMN_SIZE")).intValue(); int decimalDigits = ((Integer) columnRs.get("DECIMAL_DIGITS")).intValue(); Column column = new Column(); column.setName(quote(columnName, metaDataDialect)); Column existing = table.getColumn(column); if (existing != null) { // TODO: should we just pick it up and fill it up with whatever we get from the db instead // ? throw new JDBCBinderException(column + " already exists in " + qualify); } // TODO: column.setSqlType(sqlTypeName); //this does not work 'cos the // precision/scale/length are not retured in TYPE_NAME // column.setSqlType(sqlTypeName); column.setComment(comment); column.setSqlTypeCode(new Integer(sqlType)); if (intBounds(size)) { if (JDBCToHibernateTypeHelper.typeHasLength(sqlType)) { column.setLength(size); } if (JDBCToHibernateTypeHelper.typeHasScaleAndPrecision(sqlType)) { column.setPrecision(size); } } if (intBounds(decimalDigits)) { if (JDBCToHibernateTypeHelper.typeHasScaleAndPrecision(sqlType)) { column.setScale(decimalDigits); } } column.setNullable(isNullable); // columnDefaultValue is useless for Hibernate // isIndexed (available via Indexes) // unique - detected when getting indexes // isPk - detected when finding primary keys table.addColumn(column); } } finally { if (columnIterator != null) { try { metaDataDialect.close(columnIterator); } catch (JDBCException se) { log.warn("Exception while closing iterator for column meta data", se); } } } }
/** Called for notifying the listener. */ private void notifyListener() { if (listener != null) { listener.update(bytesRead, contentLength, items); } }
public void analyze(ProgressListener pl, double done, double scale) { if (GlobalOptions.verboseLevel > 0) GlobalOptions.err.println("Class " + name); double subScale = scale / methodComplexity; if (pl != null) pl.updateProgress(done, name); imports.useClass(clazz); if (clazz.getSuperclass() != null) imports.useClass(clazz.getSuperclass()); ClassInfo[] interfaces = clazz.getInterfaces(); for (int j = 0; j < interfaces.length; j++) imports.useClass(interfaces[j]); if (fields == null) { /* This means that the class could not be loaded. * give up. */ return; } // First analyze constructors and synthetic fields: constrAna = null; if (constructors.length > 0) { for (int j = 0; j < constructors.length; j++) { if (pl != null) { double constrCompl = constructors[j].getComplexity() * subScale; if (constrCompl > STEP_COMPLEXITY) constructors[j].analyze(pl, done, constrCompl); else { pl.updateProgress(done, name); constructors[j].analyze(null, 0.0, 0.0); } done += constrCompl; } else constructors[j].analyze(null, 0.0, 0.0); } constrAna = new TransformConstructors(this, false, constructors); constrAna.removeSynthInitializers(); } if (staticConstructor != null) { if (pl != null) { double constrCompl = staticConstructor.getComplexity() * subScale; if (constrCompl > STEP_COMPLEXITY) staticConstructor.analyze(pl, done, constrCompl); else { pl.updateProgress(done, name); staticConstructor.analyze(null, 0.0, 0.0); } done += constrCompl; } else staticConstructor.analyze(null, 0.0, 0.0); } // If output should be immediate, we delay analyzation to output. // Note that this may break anonymous classes, but the user // has been warned. if ((Options.options & Options.OPTION_IMMEDIATE) != 0) return; // Analyze fields for (int j = 0; j < fields.length; j++) fields[j].analyze(); // Now analyze remaining methods. for (int j = 0; j < methods.length; j++) { if (!methods[j].isConstructor()) if (pl != null) { double methodCompl = methods[j].getComplexity() * subScale; if (methodCompl > STEP_COMPLEXITY) methods[j].analyze(pl, done, methodCompl); else { pl.updateProgress(done, methods[j].getName()); methods[j].analyze(null, 0.0, 0.0); } done += methodCompl; } else methods[j].analyze(null, 0.0, 0.0); } }
@Override protected void onPostExecute(final Void v) { final ProgressListener pl = listeners.getListener(); pl.showProgress(false); }
public boolean isCanceled() { return listener.isCanceled(); }
public void dumpBlock(TabbedPrintWriter writer, ProgressListener pl, double done, double scale) throws IOException { double subScale = scale / getComplexity(); writer.pushScope(this); boolean needFieldNewLine = false; boolean needNewLine = false; Set declared = null; if ((Options.options & Options.OPTION_IMMEDIATE) != 0) declared = new SimpleSet(); for (int i = 0; i < fields.length; i++) { if (blockInitializers[i] != null) { if (needNewLine) writer.println(); writer.openBrace(); writer.tab(); blockInitializers[i].dumpSource(writer); writer.untab(); writer.closeBrace(); needFieldNewLine = needNewLine = true; } if ((Options.options & Options.OPTION_IMMEDIATE) != 0) { // We now do the analyzation we skipped before. fields[i].analyze(); fields[i].makeDeclaration(declared); } if (fields[i].skipWriting()) continue; if (needFieldNewLine) writer.println(); fields[i].dumpSource(writer); needNewLine = true; } if (blockInitializers[fields.length] != null) { if (needNewLine) writer.println(); writer.openBrace(); writer.tab(); blockInitializers[fields.length].dumpSource(writer); writer.untab(); writer.closeBrace(); needNewLine = true; } for (int i = 0; i < inners.length; i++) { if (needNewLine) writer.println(); if ((Options.options & Options.OPTION_IMMEDIATE) != 0) { // We now do the analyzation we skipped before. inners[i].analyze(null, 0.0, 0.0); inners[i].analyzeInnerClasses(null, 0.0, 0.0); inners[i].makeDeclaration(declared); } if (pl != null) { double innerCompl = inners[i].getComplexity() * subScale; if (innerCompl > STEP_COMPLEXITY) inners[i].dumpSource(writer, pl, done, innerCompl); else { pl.updateProgress(done, name); inners[i].dumpSource(writer); } done += innerCompl; } else inners[i].dumpSource(writer); needNewLine = true; } for (int i = 0; i < methods.length; i++) { if ((Options.options & Options.OPTION_IMMEDIATE) != 0) { // We now do the analyzation we skipped before. if (!methods[i].isConstructor()) methods[i].analyze(null, 0.0, 0.0); methods[i].analyzeInnerClasses(); methods[i].makeDeclaration(declared); } if (methods[i].skipWriting()) continue; if (needNewLine) writer.println(); if (pl != null) { double methodCompl = methods[i].getComplexity() * subScale; pl.updateProgress(done, methods[i].getName()); methods[i].dumpSource(writer); done += methodCompl; } else methods[i].dumpSource(writer); needNewLine = true; } writer.popScope(); clazz.dropInfo(clazz.KNOWNATTRIBS | clazz.UNKNOWNATTRIBS); }
protected void _setIndeterminateProgress() { listener._setIndeterminateProgress(); }
public void run() { ProgressListener pl = new ProgressListenerImpl(folder, frame); pl.onMigrationBegin(); ProjectConverter converter = new ProjectConverter(conversionType, pl); converter.convertProject(folder); }
public void setCurrentProgress(int progress) { for (ProgressListener pl : progressListeners) pl.setCurrentProgress(progress); }