/**
  * 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();
   }
 }
 private void traverseToLeaves(
     final PackageDependenciesNode treeNode,
     final StringBuffer denyRules,
     final StringBuffer allowRules) {
   final Enumeration enumeration = treeNode.breadthFirstEnumeration();
   while (enumeration.hasMoreElements()) {
     PsiElement childPsiElement =
         ((PackageDependenciesNode) enumeration.nextElement()).getPsiElement();
     if (myIllegalDependencies.containsKey(childPsiElement)) {
       final Map<DependencyRule, Set<PsiFile>> illegalDeps =
           myIllegalDependencies.get(childPsiElement);
       for (final DependencyRule rule : illegalDeps.keySet()) {
         if (rule.isDenyRule()) {
           if (denyRules.indexOf(rule.getDisplayText()) == -1) {
             denyRules.append(rule.getDisplayText());
             denyRules.append("\n");
           }
         } else {
           if (allowRules.indexOf(rule.getDisplayText()) == -1) {
             allowRules.append(rule.getDisplayText());
             allowRules.append("\n");
           }
         }
       }
     }
   }
 }
  /**
   * create a 1-d String array from a network, for easy transmission to R. triples (source,
   * edgeType, target) are filled in to an array of length 3 * # of interactions
   *
   * @param network a gaggle network
   * @return the edge attributes of the network as a string array
   */
  protected String[] networkEdgeAttributesToStringArray(Network network) {
    Interaction[] interactions = network.getInteractions();
    String source, target, type;
    String[] attributeNames = network.getEdgeAttributeNames();
    ArrayList<String> list = new ArrayList<String>();

    for (Interaction interaction : interactions) {
      source = interaction.getSource();
      type = interaction.getType();
      target = interaction.getTarget();
      String edgeName = source + " (" + type + ") " + target;
      String terseEdgeName = source + "::" + target + "::" + type;
      for (String name : attributeNames) {
        HashMap hash = network.getEdgeAttributes(name);
        if (hash.containsKey(edgeName)) {
          Object value = hash.get(edgeName);
          StringBuffer sb = new StringBuffer();
          sb.append(terseEdgeName);
          sb.append("::");
          sb.append(name);
          sb.append("::");
          sb.append(value.toString());
          list.add(sb.toString());
        } else {
          System.out.println("no " + name + " attribute for " + edgeName);
        }
      } // for a
    } // for r

    return list.toArray(new String[0]);
  } // networkEdgeAttributesToStringArray
Example #4
0
  /**
   * Returns a String representation of the <code>&lt;saml:Attribute&gt;</code> element.
   *
   * @param includeNS Determines whether or not the namespace qualifier is prepended to the Element
   *     when converted
   * @param declareNS Determines whether or not the namespace is declared within the Element.
   * @return A string containing the valid XML for this element
   */
  public String toString(boolean includeNS, boolean declareNS) {
    StringBuffer result = new StringBuffer(1000);
    String prefix = "";
    String uri = "";
    if (includeNS) {
      prefix = SAMLConstants.ASSERTION_PREFIX;
    }
    if (declareNS) {
      uri = SAMLConstants.assertionDeclareStr;
    }
    result
        .append("<")
        .append(prefix)
        .append("Attribute")
        .append(uri)
        .append(" AttributeName=\"")
        .append(_attributeName)
        .append("\" AttributeNamespace=\"")
        .append(_attributeNameSpace)
        .append("\">\n");

    Iterator iter = _attributeValue.iterator();
    while (iter.hasNext()) {
      result.append(XMLUtils.printAttributeValue((Element) iter.next(), prefix)).append("\n");
    }
    result.append("</").append(prefix).append("Attribute>\n");
    return result.toString();
  }
  /**
   * convert email address mapping<br>
   * <code>user-</code> will be replace by the email address of the user as stored in the user
   * repository <code>group-</code> will
   */
  public String convertEmailList(String mailTo) {
    StringBuffer ret = new StringBuffer();
    String[] list = mailTo.split(";");
    if (list == null) {
      return "";
    }
    for (int i = 0; i < list.length; i++) { // for each item
      String userName = list[i];
      if (i != 0) {
        ret.append("\n");
      }
      if (userName.startsWith(MailConstants.PREFIX_USER)) {
        userName = StringUtils.removeStart(userName, MailConstants.PREFIX_USER);
        if (log.isDebugEnabled()) {
          log.debug("username =" + userName);
        }
        ret.append(getUserMail(userName));
      } else if (userName.startsWith(MailConstants.PREFIX_GROUP)) {

      } else if (userName.startsWith(MailConstants.PREFIX_ROLE)) {

      } else {
        // none of the above, just add the mail to the list
        ret.append(userName);
      }
    }
    return ret.toString();
  }
 private String addNewInteraction(String fingerprint, BiologicalInteraction interaction)
     throws SQLException {
   String sql =
       String.format(
           "INSERT IGNORE INTO interaction (fingerprint) VALUES (%s)",
           SqlUtil.toSqlVarchar(fingerprint));
   if (1 != DBUtil.update(sql)) {
     System.out.println("SQL update failed? " + sql);
   }
   String interaction_id = DBUtil.querySingle("SELECT LAST_INSERT_ID()");
   Iterator<BiologicalEntity> iter = interaction.getEntityIterator();
   StringBuffer sb =
       new StringBuffer(
           "INSERT IGNORE INTO interaction_pool (interaction_id, gene_id, entity_src_table, role) VALUES ");
   while (iter.hasNext()) {
     BiologicalEntity entity = iter.next();
     sb.append("(")
         .append(interaction_id)
         .append(", ")
         .append(SqlUtil.toSqlVarchar(entity.getId()))
         .append(", '")
         .append(srcTableLookup.get(entity.getId_src()))
         .append("', '")
         .append(entity.getRole())
         .append("')");
     if (iter.hasNext()) sb.append(", ");
   }
   if (DBUtil.update(sb.toString()) != interaction.getEnvolvedEntityCount()) {
     System.out.println("SQL update failed? " + sb);
   }
   return interaction_id;
 }
Example #7
0
  static String compress(String str) {
    int size;
    int strLength = str.length();
    size = compressCount(str, strLength);
    if (size > strLength) {
      return str;
    }

    StringBuffer sb = new StringBuffer();
    char newChar = str.charAt(0);
    int count = 1;
    for (int i = 1; i < strLength; i++) {
      if (str.charAt(i) == newChar) {
        count++;
      } else {
        sb.append(newChar);
        sb.append(count);
        newChar = str.charAt(i);
        count = 1;
      }
    }
    sb.append(newChar);
    sb.append(count);
    return sb.toString();
  }
Example #8
0
 public String toString() {
   StringBuffer sb = new StringBuffer();
   sb.append("Phase: " + getPhaseAlias() + " SubPhase: " + getSubPhaseAlias());
   sb.append(
       "Leader: "
           + getLeader().getAlias()
           + " sel: "
           + getLeader().getButton().getSelection()
           + " enabled: "
           + getLeader().getButton().isEnabled()
           + "\n");
   if (getControls() != null) {
     Iterator it = getControls().iterator();
     while (it.hasNext()) {
       ISootOptionWidget next = (ISootOptionWidget) it.next();
       sb.append("control: " + next.getId() + "\n");
       if (next instanceof BooleanOptionWidget) {
         sb.append(
             "control is boolean and enable state: "
                 + ((BooleanOptionWidget) next).getButton().isEnabled()
                 + "\n");
       }
     }
   }
   return sb.toString();
 }
    private Pair<MutableTextRange, StringBuffer> getFragmentByRange(int start, final int length) {
      final StringBuffer fragmentBuffer = new StringBuffer();
      int end = start + length;

      // restoring buffer and remove all subfragments from the list
      int documentOffset = 0;
      int effectiveOffset = 0;

      Iterator<Pair<MutableTextRange, StringBuffer>> iterator = myAffectedFragments.iterator();
      while (iterator.hasNext() && effectiveOffset <= end) {
        final Pair<MutableTextRange, StringBuffer> pair = iterator.next();
        final MutableTextRange range = pair.getFirst();
        final StringBuffer buffer = pair.getSecond();
        int effectiveFragmentEnd = range.getStartOffset() + buffer.length();

        if (range.getStartOffset() <= start && effectiveFragmentEnd >= end) return pair;

        if (effectiveFragmentEnd >= start) {
          final int effectiveStart = Math.max(effectiveOffset, start);
          if (range.getStartOffset() > start) {
            fragmentBuffer.append(
                myDocument.getCharsSequence(),
                effectiveStart - effectiveOffset + documentOffset,
                Math.min(range.getStartOffset(), end) - effectiveOffset + documentOffset);
          }
          if (end >= range.getStartOffset()) {
            fragmentBuffer.append(buffer);
            end =
                end > effectiveFragmentEnd
                    ? end - (buffer.length() - range.getLength())
                    : range.getEndOffset();
            effectiveFragmentEnd = range.getEndOffset();
            start = Math.min(start, range.getStartOffset());
            iterator.remove();
          }
        }

        documentOffset += range.getEndOffset() - effectiveOffset;
        effectiveOffset = effectiveFragmentEnd;
      }

      if (effectiveOffset < end) {
        final int effectiveStart = Math.max(effectiveOffset, start);
        fragmentBuffer.append(
            myDocument.getCharsSequence(),
            effectiveStart - effectiveOffset + documentOffset,
            end - effectiveOffset + documentOffset);
      }

      MutableTextRange newRange = new MutableTextRange(start, end);
      final Pair<MutableTextRange, StringBuffer> pair =
          new Pair<MutableTextRange, StringBuffer>(newRange, fragmentBuffer);
      for (Pair<MutableTextRange, StringBuffer> affectedFragment : myAffectedFragments) {
        MutableTextRange range = affectedFragment.getFirst();
        assert end <= range.getStartOffset() || range.getEndOffset() <= start
            : "Range :" + range + "; Added: " + newRange;
      }
      myAffectedFragments.add(pair);
      return pair;
    }
Example #10
0
 public String toString() {
   StringBuffer sb = new StringBuffer(url.length() + 17);
   sb.append("[MyMockCachedUrl: ");
   sb.append(url);
   sb.append("]");
   return sb.toString();
 }
Example #11
0
 /** Sets LOV. */
 public void setListOfValues(List listOfValues) {
   if (listOfValues.size() > 0) {
     StringBuffer buf = new StringBuffer();
     buf.append("        java.util.ArrayList lov = new ArrayList();\n");
     Iterator iter = listOfValues.iterator();
     while (iter.hasNext()) {
       ListOfValuesXMLEntity e = (ListOfValuesXMLEntity) iter.next();
       String value = e.getValue();
       if (!e.getValue().startsWith("new")) {
         if (type == T_TEXT) value = "\"" + e.getValue() + "\"";
         else if (type == T_NUMERIC) {
           if (jrfColumnClassName.equals("java.lang.Long"))
             value = "new Long(" + e.getValue() + ")";
           else if (jrfColumnClassName.equals("java.lang.Short"))
             value = "new Short(" + e.getValue() + ")";
           else if (jrfColumnClassName.equals("java.lang.Integer"))
             value = "new Integer(" + e.getValue() + ")";
           else if (jrfColumnClassName.equals("java.lang.Double"))
             value = "new Double(" + e.getValue() + ")";
           else if (jrfColumnClassName.equals("java.lang.Float"))
             value = "new Float(" + e.getValue() + ")";
           else
             throw new IllegalArgumentException(
                 this
                     + ": Unsupported list of value number type (long,short,double,float and integer supported)");
         } else
           throw new IllegalArgumentException(
               this + ": Unsupported list of value literal; use 'new X..");
       }
       buf.append("        lov.add(" + value + ");\n");
     }
     super.transientKeys.put("listOfValues", "lov");
     super.transientKeys.put("listOfValuesAdd", buf.toString());
   }
 }
Example #12
0
    public void run() {
      int i;
      String cmdToLookFor = getServerProperty("pidHint");
      if (cmdToLookFor == null) {
        StringBuffer buf = new StringBuffer();
        for (i = 0; i < mExecArgs.length; i++) {
          if (i > 0) {
            buf.append(" ");
          }
          buf.append(mExecArgs[i]);
        }
        cmdToLookFor = buf.toString();
      }

      mLogger.finer("Looking for pid for command: " + cmdToLookFor);

      i = 0;
      do {
        try {
          Thread.sleep(1000);
        } catch (InterruptedException ie) {
        }
        mPid = UnixStdlib.getProcessID(cmdToLookFor);
      } while (mPid == 0 && ++i < 300); // up to 5 minutes

      if (mPid == 0) {
        mLogger.warning("Giving up on trying to identify pid");
      } else {
        mLogger.finer("Serverpid server=" + mName + " pid=" + mPid);
      }
    }
Example #13
0
  protected void prepare() throws Exception {
    try {

      List execCommand = buildExecCommand();

      if (execCommand == null) {
        mLogger.severe("No command property was specified; disabling server");
        synchronized (this) {
          changeState(STATE_DISABLED);
        }
        return;
      } else {
        mExecArgs = (String[]) execCommand.toArray(new String[0]);
        StringBuffer printableCmd = new StringBuffer(4096);
        int index = 0;
        for (; index < mExecArgs.length - 1; index++) {
          printableCmd.append(mExecArgs[index]).append(" ");
        }
        printableCmd.append(mExecArgs[index]);
        mPrintableCommand = printableCmd.toString();

        if (useOptimizeIt()) {
          System.err.println(mPrintableCommand);
        }
      }
    } catch (Exception ex) {
      mLogger.severe("Failed In preparing execargs");
      throw ex;
    }
  }
Example #14
0
  public Properties internalToProperties() {
    Properties props = new Properties();

    StringBuffer st = new StringBuffer();
    st.append(" ");
    for (int i = 0; i < visibleViewIds.size(); i++) {
      st.append(" " + Constants.cpNames[((Integer) visibleViewIds.elementAt(i)).intValue()]);
    }
    // System.out.println(" visibleViewIds: " + st.toString());

    props.setProperty("ndedit.visibleViewIds", st.toString());

    props.setProperty("ndedit.cutPanelSizeW", (new Integer(cutPanelSize.width).toString()));
    props.setProperty("ndedit.cutPanelSizeH", (new Integer(cutPanelSize.height).toString()));
    props.setProperty("ndedit.cutPanelWMin", (new Integer(cutPanelMinSize.width).toString()));
    props.setProperty("ndedit.cutPanelHMin", (new Integer(cutPanelMinSize.height).toString()));
    props.setProperty("ndedit.cutPanelWMax", (new Integer(cutPanelMaxSize.width).toString()));
    props.setProperty("ndedit.cutPanelHMax", (new Integer(cutPanelMaxSize.height).toString()));
    props.setProperty("ndedit.lonReference", (new Double(lonReference).toString()));
    props.setProperty("ndedit.geoDisplayFormat", (new Integer(geoDisplayFormat).toString()));
    props.setProperty("ndedit.timeDisplayFormat", (new Integer(timeDisplayFormat).toString()));
    props.setProperty("ndedit.timeAxisMode", (new Integer(timeAxisMode).toString()));
    props.setProperty("ndedit.timeAxisReference", (new Double(timeAxisReference).toString()));
    String dpa = new Boolean(displayPanelAxes).toString();
    props.setProperty("ndedit.displayPanelAxes", dpa);
    dpa = new Boolean(independentHandles).toString();
    props.setProperty("ndedit.independentHandles", dpa);
    return props;
  }
Example #15
0
  /**
   * Get a string from the underlying resource bundle and format it with the given set of arguments.
   *
   * @param key
   * @param args
   */
  public String getString(String key, Object[] args) {
    String iString;
    String value = getString(key);

    // this check for the runtime exception is some pre 1.1.6
    // VM's don't do an automatic toString() on the passed in
    // objects and barf out

    try {
      // ensure the arguments are not null so pre 1.2 VM's don't barf
      if (args == null) {
        args = new Object[1];
      }

      Object[] nonNullArgs = args;
      for (int i = 0; i < args.length; i++) {
        if (args[i] == null) {
          if (nonNullArgs == args) {
            nonNullArgs = args.clone();
          }
          nonNullArgs[i] = "null";
        }
      }
      if (value == null) value = key;
      iString = MessageFormat.format(value, nonNullArgs);
    } catch (IllegalArgumentException iae) {
      StringBuffer buf = new StringBuffer();
      buf.append(value);
      for (int i = 0; i < args.length; i++) {
        buf.append(" arg[").append(i).append("]=").append(args[i]);
      }
      iString = buf.toString();
    }
    return iString;
  }
Example #16
0
 // Serialize the bean using the specified namespace prefix & uri
 public String serialize(Object bean) throws IntrospectionException, IllegalAccessException {
   // Use the class name as the name of the root element
   String className = bean.getClass().getName();
   String rootElementName = null;
   if (bean.getClass().isAnnotationPresent(ObjectXmlAlias.class)) {
     AnnotatedElement annotatedElement = bean.getClass();
     ObjectXmlAlias aliasAnnotation = annotatedElement.getAnnotation(ObjectXmlAlias.class);
     rootElementName = aliasAnnotation.value();
   }
   // Use the package name as the namespace URI
   Package pkg = bean.getClass().getPackage();
   nsURI = pkg.getName();
   // Remove a trailing semi-colon (;) if present (i.e. if the bean is an array)
   className = StringUtils.deleteTrailingChar(className, ';');
   StringBuffer sb = new StringBuffer(className);
   String objectName = sb.delete(0, sb.lastIndexOf(".") + 1).toString();
   domDocument = createDomDocument(objectName);
   document = domDocument.getDocument();
   Element root = document.getDocumentElement();
   // Parse the bean elements
   getBeanElements(root, rootElementName, className, bean);
   StringBuffer xml = new StringBuffer();
   if (prettyPrint)
     xml.append(domDocument.serialize(lineSeperator, indentChars, includeXmlProlog));
   else xml.append(domDocument.serialize(includeXmlProlog));
   if (!includeTypeInfo) {
     int index = xml.indexOf(root.getNodeName());
     xml.delete(index - 1, index + root.getNodeName().length() + 2);
     xml.delete(xml.length() - root.getNodeName().length() - 4, xml.length());
   }
   return xml.toString();
 }
  /** ** Reads/returns the specified CompileTime template file */
  private static String readTemplate(File tf, String pkgName) {

    /* read template data */
    byte templData[] = FileTools.readFile(tf);
    if (templData == null) {
      Print.errPrintln("\nUnable to read Input/Template file: " + tf);
      return null;
    } else if (templData.length == 0) {
      Print.errPrintln("\nInput/Template file is empty: " + tf);
      return null;
    }

    /* return template String */
    String templateText = StringTools.toStringValue(templData);
    if (!StringTools.isBlank(pkgName) && !StringTools.isBlank(templateText)) {
      String lines[] = StringTools.split(templateText, '\n', false);
      for (int i = 0; i < lines.length; i++) {
        if (lines[i].trim().startsWith(JAVA_PACKAGE_)) {
          lines[i] = CompiletimeVars.packageLine(pkgName);
          return StringTools.join(lines, '\n') + "\n";
        }
      }
      StringBuffer sb = new StringBuffer();
      sb.append(CompiletimeVars.packageLine(pkgName)).append("\n");
      sb.append(templateText);
      return sb.toString();
    } else {
      return templateText;
    }
  }
Example #18
0
  /**
   * Computes previous revision or <code>null</code> for initial.
   *
   * @param revision num.dot revision or <code>null</code>
   */
  public static String previousRevision(String revision) {
    if (revision == null) return null;
    String[] nums = revision.split("\\."); // NOI18N
    assert (nums.length % 2) == 0
        : "File revisions must consist from even tokens: " + revision; // NOI18N

    // eliminate branches
    int lastIndex = nums.length - 1;
    boolean cutoff = false;
    while (lastIndex > 1 && "1".equals(nums[lastIndex])) { // NOI18N
      lastIndex -= 2;
      cutoff = true;
    }
    if (lastIndex <= 0) {
      return null;
    } else if (lastIndex == 1 && "1".equals(nums[lastIndex])) { // NOI18N
      return null;
    } else {
      int rev = Integer.parseInt(nums[lastIndex]);
      if (!cutoff) rev--;
      StringBuffer sb = new StringBuffer(nums[0]);
      for (int i = 1; i < lastIndex; i++) {
        sb.append('.').append(nums[i]); // NOI18N
      }
      sb.append('.').append(rev); // NOI18N
      return sb.toString();
    }
  }
Example #19
0
 /**
  * ************************************************************************ Lineas de Remesa
  *
  * @param whereClause where clause or null (starting with AND)
  * @return lines
  */
 public MRemesaLine[] getLines(String whereClause, String orderClause) {
   ArrayList list = new ArrayList();
   StringBuffer sql = new StringBuffer("SELECT * FROM C_RemesaLine WHERE C_Remesa_ID=? ");
   if (whereClause != null) sql.append(whereClause);
   if (orderClause != null) sql.append(" ").append(orderClause);
   PreparedStatement pstmt = null;
   try {
     pstmt = DB.prepareStatement(sql.toString(), get_TrxName());
     pstmt.setInt(1, getC_Remesa_ID());
     ResultSet rs = pstmt.executeQuery();
     while (rs.next()) list.add(new MRemesaLine(getCtx(), rs));
     rs.close();
     pstmt.close();
     pstmt = null;
   } catch (Exception e) {
     log.saveError("getLines - " + sql, e);
   } finally {
     try {
       if (pstmt != null) pstmt.close();
     } catch (Exception e) {
     }
     pstmt = null;
   }
   //
   MRemesaLine[] lines = new MRemesaLine[list.size()];
   list.toArray(lines);
   return lines;
 } //	getLines
Example #20
0
 public String pairClusters2string(
     ArrayList<Record> pair1, ArrayList<Record> pair2, boolean left) {
   StringBuffer bf = new StringBuffer();
   for (int i = 0; i < pair1.size(); i++) {
     for (int j = 0; j < pair2.size(); j++) {
       if (pair1.get(i).isInsertionPair(pair2.get(j), left)) {
         bf.append(pair1.get(i) + "\n" + pair2.get(j) + "\n\n");
         pair1.remove(i);
         pair2.remove(j);
         i--;
         j--;
         break;
       }
     }
   }
   if ((pair1.size() + pair2.size()) > 0) {
     bf.append("***** UNPAIRED *****\n");
     for (int i = 0; i < pair1.size(); i++) {
       bf.append(pair1.get(i) + "\n");
     }
     for (int j = 0; j < pair2.size(); j++) {
       bf.append(pair2.get(j) + "\n");
     }
     bf.append("**** END OF UNPAIRED ****\n");
   }
   // bf.append("\n");
   return bf.toString();
 }
Example #21
0
 // ----------------------------------------------------------------------
 // for "SrvTypeRqst"
 // get the list of service types for specified scope & naming authority
 // ----------------------------------------------------------------------
 public synchronized String getServiceTypeList(String na, String scope) {
   Vector typelist = new Vector(5);
   Iterator values = table.values().iterator();
   while (values.hasNext()) {
     Entry e = (Entry) values.next();
     if (!e.getDeleted()
         && // nor deleted
         scope.equalsIgnoreCase(e.getScope())
         && // match scope
         (na.equals("*")
             || // NA wildcard
             na.equalsIgnoreCase(e.getNA()))
         && // match NA
         !typelist.contains(e.getType())) {
       typelist.addElement(e.getType());
     }
   }
   StringBuffer tl = new StringBuffer();
   for (int i = 0; i < typelist.size(); i++) {
     String s = (String) typelist.elementAt(i);
     if (tl.length() > 0) tl.append(",");
     tl.append(s);
   }
   return tl.toString();
 }
Example #22
0
 /** @return nick(id) */
 public String getNickAndId() {
   StringBuffer sb = new StringBuffer(getNick());
   sb.append('(');
   sb.append(Long.toString(getId()));
   sb.append(')');
   return sb.toString();
 }
 private String quoteTimeStampChars(String input) {
   // put single quotes around text that isn't a supported dateformat char
   StringBuffer result = new StringBuffer();
   // ok to default to false because we also check for index zero below
   boolean lastCharIsDateFormat = false;
   for (int i = 0; i < input.length(); i++) {
     String thisVal = input.substring(i, i + 1);
     boolean thisCharIsDateFormat = VALID_DATEFORMAT_CHARS.contains(thisVal);
     // we have encountered a non-dateformat char
     if (!thisCharIsDateFormat && (i == 0 || lastCharIsDateFormat)) {
       result.append("'");
     }
     // we have encountered a dateformat char after previously encountering a non-dateformat char
     if (thisCharIsDateFormat && i > 0 && !lastCharIsDateFormat) {
       result.append("'");
     }
     lastCharIsDateFormat = thisCharIsDateFormat;
     result.append(thisVal);
   }
   // append an end single-quote if we ended with non-dateformat char
   if (!lastCharIsDateFormat) {
     result.append("'");
   }
   return result.toString();
 }
Example #24
0
 /**
  * Starts a new column, possibly closing the current column if needed
  *
  * @param ret the output buffer to put LaTeX into
  * @param p the properties from the <code>&lt;td&gt;</code> tag
  */
 public void startCol(StringBuffer ret, Properties p) {
   endCol(ret);
   int span = hasNumProp("colspan", p);
   if (colcnt > 0) {
     ret.append(" & ");
   }
   String align = hasProp("align", p);
   if (align != null && span < 0) span = 1;
   if (span > 0) {
     ret.append("\\multicolumn{" + span + "}{");
     if (border && colcnt == 0) ret.append("|");
     String cc =
         ""
             + (char) ('a' + (colcnt / (26 * 26)))
             + (char) ((colcnt / 26) + 'a')
             + (char) ((colcnt % 26) + 'a');
     if (align != null) {
       String h = align.substring(0, 1);
       if ("rR".indexOf(h) >= 0) ret.append("r");
       else if ("lL".indexOf(h) >= 0) ret.append("p{\\tbl" + tc + "c" + cc + "w}");
       else if ("cC".indexOf(h) >= 0) ret.append("p{\\tbl" + tc + "c" + cc + "w}");
     } else ret.append("p{\\tbl" + tc + "c" + cc + "w}");
     if (border) ret.append("|");
     ret.append("}");
   }
   String wid = p.getProperty("texwidth");
   ret.append("{");
   if (wid != null) {
     ret.append("\\parbox{" + wid + "}{\\vskip 1ex ");
     parboxed = true;
   }
   colcnt++;
   colopen = true;
 }
Example #25
0
  public static String reportKillData() {
    HashMap hm = getKillHashMap();

    ArrayList al = new ArrayList(hm.keySet());

    Collections.sort(al);

    StringBuffer sb = new StringBuffer();

    sb.append("You have killed the following creatures:\n");
    sb.append("\n");

    boolean uniques = true;

    for (Iterator it = al.iterator(); it.hasNext(); ) {
      String name = (String) it.next();

      // display line after uniques
      if (uniques && (!Character.isUpperCase(name.charAt(0)))) {
        uniques = false;
        sb.append("\n");
      }

      Integer count = (Integer) (hm.get(name));
      String g = Text.centrePad(name, count.toString(), 60);
      sb.append(g + "\n");
    }

    return sb.toString();
  }
Example #26
0
  private static String[] getSuggestionsByValue(final String stringValue) {
    List<String> result = new ArrayList<String>();
    StringBuffer currentWord = new StringBuffer();

    boolean prevIsUpperCase = false;

    for (int i = 0; i < stringValue.length(); i++) {
      final char c = stringValue.charAt(i);
      if (Character.isUpperCase(c)) {
        if (currentWord.length() > 0 && !prevIsUpperCase) {
          result.add(currentWord.toString());
          currentWord = new StringBuffer();
        }
        currentWord.append(c);
      } else if (Character.isLowerCase(c)) {
        currentWord.append(Character.toUpperCase(c));
      } else if (Character.isJavaIdentifierPart(c) && c != '_') {
        if (Character.isJavaIdentifierStart(c) || currentWord.length() > 0 || !result.isEmpty()) {
          currentWord.append(c);
        }
      } else {
        if (currentWord.length() > 0) {
          result.add(currentWord.toString());
          currentWord = new StringBuffer();
        }
      }

      prevIsUpperCase = Character.isUpperCase(c);
    }

    if (currentWord.length() > 0) {
      result.add(currentWord.toString());
    }
    return ArrayUtil.toStringArray(result);
  }
Example #27
0
 /**
  * ** Reads a line from the specified socket's input stream ** @param socket The socket to read a
  * line from ** @param maxLen The maximum length of of the line to read ** @param sb The string
  * buffer to use ** @throws IOException if an error occurs or the server has stopped
  */
 protected static String socketReadLine(Socket socket, int maxLen, StringBuffer sb)
     throws IOException {
   if (socket != null) {
     int dataLen = 0;
     StringBuffer data = (sb != null) ? sb : new StringBuffer();
     InputStream input = socket.getInputStream();
     while ((maxLen < 0) || (maxLen > dataLen)) {
       int ch = input.read();
       // Print.logInfo("ReadLine char: " + ch);
       if (ch < 0) {
         // this means that the server has stopped
         throw new IOException("End of input");
       } else if (ch == LineTerminatorChar) {
         // include line terminator in String
         data.append((char) ch);
         dataLen++;
         break;
       } else {
         // append character
         data.append((char) ch);
         dataLen++;
       }
     }
     return data.toString();
   } else {
     return null;
   }
 }
  /*
   * Filters strings from a line of text and formats them properly.
   */
  private String stringFilter(String line) {
    if (line == null || line.equals("")) {
      return "";
    }
    StringBuffer buf = new StringBuffer();
    if (!line.contains("\"")) {
      return keywordFilter(line);
    }
    int start = 0;
    int startStringIndex = -1;
    int endStringIndex;
    int tempIndex;
    // Keep moving through String characters until we want to stop...
    while ((tempIndex = line.indexOf("\"")) > -1) {
      // We found the beginning of a string
      if (startStringIndex == -1) {
        startStringIndex = 0;
        buf.append(stringFilter(line.substring(start, tempIndex)));
        buf.append(stringStart).append("\"");
        line = line.substring(tempIndex + 1);
      }
      // Must be at the end
      else {
        startStringIndex = -1;
        endStringIndex = tempIndex;
        buf.append(line.substring(0, endStringIndex + 1));
        buf.append(stringEnd);
        line = line.substring(endStringIndex + 1);
      }
    }

    buf.append(keywordFilter(line));

    return buf.toString();
  }
 /*
  * Filters keywords from a line of text and formats them properly.
  */
 private String keywordFilter(String line) {
   if (line == null || line.equals("")) {
     return "";
   }
   StringBuffer buf = new StringBuffer();
   Map<String, String> usedReservedWords =
       new HashMap<String, String>(); // >= Java2 only (not thread-safe)
   // Hashtable usedReservedWords = new Hashtable(); // < Java2 (thread-safe)
   int i = 0;
   char ch;
   StringBuffer temp = new StringBuffer();
   while (i < line.length()) {
     temp.setLength(0);
     ch = line.charAt(i);
     // 65-90, uppercase letters
     // 97-122, lowercase letters
     while (i < line.length() && ((ch >= 65 && ch <= 90) || (ch >= 97 && ch <= 122))) {
       temp.append(ch);
       i++;
       if (i < line.length()) {
         ch = line.charAt(i);
       }
     }
     String tempString = temp.toString();
     if (RESERVED_WORDS.containsKey(tempString) && !usedReservedWords.containsKey(tempString)) {
       usedReservedWords.put(tempString, tempString);
       line = replace(line, tempString, (reservedWordStart + tempString + reservedWordEnd));
       i += (reservedWordStart.length() + reservedWordEnd.length());
     } else {
       i++;
     }
   }
   buf.append(line);
   return buf.toString();
 }
 public String toString() {
   StringBuffer s = new StringBuffer();
   s.append("ed:");
   for (int i = 0; i < count; i++) s.append(" " + args[i]);
   if (size != null) s.append(" (" + size + ")");
   return s.toString();
 }