public static void abcd(String str) { BigInteger sum = BigInteger.ZERO; StringBuffer n = new StringBuffer(""); for (int i = 0; i < str.length(); i++) { BigInteger ab = BigInteger.valueOf(((int) str.charAt(i)) - 96); sum = sum.add(div.pow(str.length() - i - 1).multiply(ab)); } String s = sum.toString(); for (int i = 0; i < s.length(); i++) { if (i % 3 == 0 && i != 0) n.insert(0, ","); n.insert(0, s.charAt(s.length() - i - 1)); } while (str.length() < 22) str = str + " "; System.out.println(str + "" + n); }
public static void num(String str) { BigInteger a = new BigInteger(str); StringBuffer sb = new StringBuffer(""); StringBuffer n = new StringBuffer(""); while (!(a.divide(div).equals(zero))) { sb.insert(0, (char) (a.mod(div).intValue() + 96)); a = a.divide(div); } sb.insert(0, (char) (a.intValue() + 96)); for (int i = 0; i < str.length(); i++) { if (i % 3 == 0 && i != 0) n.insert(0, ","); n.insert(0, str.charAt(str.length() - i - 1)); } while (sb.length() < 22) sb.append(" "); System.out.println(sb + "" + n); }
/** * Modifies the DO within its table. Performs recursive commit/delete on referenced DOs; all * operations occur within a single transaction to allow rollback in the event of error. Only the * creator of the transaction releases it. * * @param dbt The transaction object to use for this operation. * @param delete True if doing a delete, otherwise doing insert/update. * @exception com.lutris.appserver.server.sql.DatabaseManagerException if a Transaction can not be * created. * @exception com.lutris.appserver.server.sql.DBRowUpdateException if a version error occurs. * @exception RefAssertionException thrown by okTo method. * @exception java.sql.SQLException if any SQL errors occur. */ protected void modifyDO(DBTransaction dbt, boolean delete) throws SQLException, DatabaseManagerException, DataObjectException, RefAssertionException, DBRowUpdateException, QueryException { if (delete) okToDelete(); else okToCommit(); boolean ownTransaction = false; try { if (null == dbt) { DatabaseManager dbm = Enhydra.getDatabaseManager(); dbt = dbm.createTransaction(); // create a transaction ownTransaction = true; } if (null == dbt) throw new DatabaseManagerException("DatabaseManager.createTransaction returned null."); if (delete) { // Code to perform cascading deletes is generated here // if cascading deletes are not supported by the database. // The following line keeps the compiler happy // when the CASCADING_DELETES tag is empty. if (false) throw new QueryException("XXX"); } else { // commit referenced DOs. jobmatch.data.ProfileDO Profile_DO = getProfile(); if (null != Profile_DO) { if (Profile_DO.isLoaded()) { okToCommitProfile(Profile_DO); Profile_DO.commit(dbt); } else { // since the referenced DO is not loaded, // it cannot be dirty, so there is no need to commit it. } } else { if (!false) throw new RefAssertionException( "Cannot commit TreeLeafDO ( " + toString() + " ) because Profile is not allowed to be null."); } } if (false) { // This throw is here to keep the compiler happy // in the case of a DO that does not refer to other DOs. // In that case, the above delete/commit code blocks will be empty // and throw nothing. throw new DataObjectException("foo"); } if (delete) { dbt.delete(this); } else { if (isLoaded()) dbt.insert(this); // dbt.insert() handles insertions and updates } if (ownTransaction) { dbt.commit(); // commit the transaction } } catch (SQLException sqle) { StringBuffer message = new StringBuffer("Failed to insert/update DO: "); message.append(sqle.getMessage()); // rollback, if necessary if (ownTransaction) { try { dbt.rollback(); } catch (SQLException sqle2) { message.insert(0, "\n"); message.insert(0, sqle2.getMessage()); message.insert(0, "Rollback failed: "); } } throw new SQLException(message.toString()); } finally { // release the transaction, if any if (ownTransaction) { dbt.release(); } } }