public static String getGoalText(
     final ChallengeGoalData goal, final ChallengeData data, final ChallengeDataModel model) {
   String rawText = goal.getFormattedString();
   if (rawText == null || rawText.length() == 0) {
     return null;
   }
   rawText =
       (String)
           ChallengeFormatter.extractValue(
               rawText, ChallengeFormatter.Type.STRING, model.getParams());
   for (Matcher match = ChallengeGoalView.GOAL_BREED_PATTERN.matcher(rawText);
       match.find();
       match = ChallengeGoalView.GOAL_BREED_PATTERN.matcher(rawText)) {
     final String name =
         WakfuTranslator.getInstance()
             .getString(7, PrimitiveConverter.getInteger(match.group(1)), new Object[0]);
     rawText = match.replaceFirst(name);
   }
   for (Matcher match = ChallengeGoalView.GOAL_RESOURCE_PATTERN.matcher(rawText);
       match.find();
       match = ChallengeGoalView.GOAL_RESOURCE_PATTERN.matcher(rawText)) {
     final String name =
         WakfuTranslator.getInstance()
             .getString(12, PrimitiveConverter.getInteger(match.group(1)), new Object[0]);
     rawText = match.replaceFirst(name);
   }
   for (Matcher match = ChallengeGoalView.GOAL_VAR_PATTERN.matcher(rawText);
       match.find();
       match = ChallengeGoalView.GOAL_VAR_PATTERN.matcher(rawText)) {
     final Long value = data.getVarValue(match.group().substring(1, match.group().length() - 1));
     rawText = match.replaceFirst(value.toString());
   }
   return rawText;
 }
示例#2
0
  /**
   * Creates a new {@code UriPathTemplate} from the given {@code uriPattern}.
   *
   * @param uriPattern The pattern to be used by the template
   */
  public UriPathTemplate(String uriPattern) {
    String s = "^" + uriPattern;

    Matcher m = NAME_SPLAT_PATTERN.matcher(s);
    while (m.find()) {
      for (int i = 1; i <= m.groupCount(); i++) {
        String name = m.group(i);
        pathVariables.add(name);
        s = m.replaceFirst(NAME_SPLAT_REPLACEMENT.replaceAll("%NAME%", name));
        m.reset(s);
      }
    }

    m = NAME_PATTERN.matcher(s);
    while (m.find()) {
      for (int i = 1; i <= m.groupCount(); i++) {
        String name = m.group(i);
        pathVariables.add(name);
        s = m.replaceFirst(NAME_REPLACEMENT.replaceAll("%NAME%", name));
        m.reset(s);
      }
    }

    m = FULL_SPLAT_PATTERN.matcher(s);
    while (m.find()) {
      s = m.replaceAll(FULL_SPLAT_REPLACEMENT);
      m.reset(s);
    }

    this.uriPattern = Pattern.compile(s + "$");
  }
示例#3
0
  /**
   * 以给定日期为基准展开宏
   *
   * @param str 含有待展开宏的字符串
   * @param dateYmd 基准日期,对应{yyyymmdd},{yyyymmdd-n},{yyyymmdd+n}
   * @return 展开后的字符串
   */
  public static String expandMacroDateYmd(String str, Date dateYmd) {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
    Pattern dateYmdPat = Pattern.compile("\\{\\s*yyyymmdd\\s*(([+-])\\s*(\\d+))?\\s*\\}");
    String res = str;
    Matcher matcher = dateYmdPat.matcher(res);
    while (matcher.find()) {
      String expr = matcher.group(1);
      String op = matcher.group(2);
      String ndays = matcher.group(3);

      if (StringUtils.isEmpty(expr)) {
        // 无日期计算部分,直接展开
        res = matcher.replaceFirst(sdf.format(dateYmd));
        matcher = dateYmdPat.matcher(res);
      } else if ("+".equals(op)) {
        // 基准日期+n 天
        int n = Integer.parseInt(ndays);
        res = matcher.replaceFirst(sdf.format(DateUtils.addDays(dateYmd, n)));
        matcher = dateYmdPat.matcher(res);
      } else if ("-".equals(op)) {
        // 基准日期-n 天
        int n = -Integer.parseInt(ndays);
        res = matcher.replaceFirst(sdf.format(DateUtils.addDays(dateYmd, n)));
        matcher = dateYmdPat.matcher(res);
      }
    }
    return res;
  }
示例#4
0
  /**
   * Creates a count projected query from the given original query.
   *
   * @param originalQuery must not be {@literal null}.
   * @param countProjection may be {@literal null}.
   * @return
   * @since 1.6
   */
  public static String createCountQueryFor(String originalQuery, String countProjection) {

    Assert.hasText(originalQuery, "OriginalQuery must not be null or empty!");

    Matcher matcher = COUNT_MATCH.matcher(originalQuery);
    String countQuery = null;

    if (countProjection == null) {

      String variable = matcher.matches() ? matcher.group(VARIABLE_NAME_GROUP_INDEX) : null;
      boolean useVariable =
          variable != null
              && StringUtils.hasText(variable)
              && !variable.startsWith("new")
              && !variable.startsWith("count(")
              && !variable.contains(",");

      String replacement = useVariable ? SIMPLE_COUNT_VALUE : COMPLEX_COUNT_VALUE;
      countQuery = matcher.replaceFirst(String.format(COUNT_REPLACEMENT_TEMPLATE, replacement));
    } else {
      countQuery = matcher.replaceFirst(String.format(COUNT_REPLACEMENT_TEMPLATE, countProjection));
    }

    return countQuery.replaceFirst(ORDER_BY_PART, "");
  }
  protected void runOnce() {
    String line = io.readLine();
    line = line.replace(" ", ""); // Strip spaces

    // Keep replacing the leftmost highest precedence subexpression
    while (true) {
      Matcher m;

      // Brackets
      m = BRACKET.matcher(line);
      if (m.find()) {
        line = m.replaceFirst("$1");
        continue;
      }

      // "Exponentiation"
      m = EXPONENT.matcher(line);
      if (m.find()) {
        int x = Integer.parseInt(m.group(1));
        int y = Integer.parseInt(m.group(2));
        int z = Integer.parseInt(Math.abs(x) + "" + Math.abs(y));
        line = m.replaceFirst(Integer.toString(z));
        continue;
      }

      // Multiplication, division
      m = MULT_DIV.matcher(line);
      if (m.find()) {
        int x = Integer.parseInt(m.group(1));
        int y = Integer.parseInt(m.group(3));
        int z = m.group(2).equals("*") ? x * y : x / y;
        line = m.replaceFirst(Integer.toString(z));
        continue;
      }

      // Addition, subtraction
      m = ADD_SUB.matcher(line);
      if (m.find()) {
        int x = Integer.parseInt(m.group(1));
        int y = Integer.parseInt(m.group(3));
        int z = m.group(2).equals("+") ? x + y : x - y;
        line = m.replaceFirst(Integer.toString(z));
        continue;
      }

      break;
    }

    io.println(line);
  }
示例#6
0
  /**
   * 当前Session中用户所属的组织的名称 组织名称,当前登录用户所属的组织名称,是否带路径 @GROUPNAME(true|false);
   *
   * @param cf
   * @return
   */
  public String eval_GROUPNAME(String cf) {
    String regex = "@GROUPNAME\\(((false)|(true))\\)"; // 匹配@GROUPNAME公式
    Pattern p = Pattern.compile(regex);
    Matcher mt = p.matcher(cf);
    P2GManager p2gManager = (P2GManager) SpringContextUtil.getBean("p2gManager");
    while (mt.find()) {
      String gp = mt.group();
      String fm = gp.substring(gp.indexOf("(") + 1, gp.indexOf(")"));
      Boolean flag = Boolean.parseBoolean(fm);
      String personId = (String) this.sessionAttrs.get(Constants.SESSION_CURRENT_PERSONID);

      ArrayList<Group> entities = (ArrayList<Group>) p2gManager.findGroupsOfThePerson(personId);

      // 获得第一个组织名
      Group entity = entities.get(0);

      String groupName = null;
      if (!flag) {
        groupName = entity.getGroupName();
        // 返回第一个组织名
      } else {
        // 需要获得完整路径
        // 当前组织ID
        groupName = entity.getPathWithText();
      }

      cf = mt.replaceFirst("\"" + groupName + "\"");
      mt = p.matcher(cf);
    }
    return cf;
  }
示例#7
0
 /**
  * CONTEXT公式
  *
  * @param cf
  * @return
  */
 public String eval_CONTEXT(String cf) {
   String regex = "(@CONTEXT\\([a-zA-Z0-9\"-\\/_ 年月日:,]+\\))"; // 匹配@VALUE公式
   Pattern p = Pattern.compile(regex);
   Matcher mt = p.matcher(cf);
   while (mt.find()) {
     String group = mt.group();
     String tmpArray[] = group.split("\"");
     String varName = tmpArray[1].toUpperCase();
     Object value = this.context.getVar(varName);
     if (value == null) {
       value = "";
     } else {
       if (value instanceof Date) {
         String fm = "yyyy-MM-dd";
         if (tmpArray.length > 3) {
           fm = tmpArray[3];
         }
         value = DateUtils.formatDate((Date) value, fm);
       }
     }
     cf = mt.replaceFirst("\"" + value + "\"");
     mt = p.matcher(cf);
   }
   return cf;
 }
示例#8
0
 /**
  * 计算@PARSENUMBER("333.33");公式
  *
  * @param cf
  * @return
  */
 public String eval_PARSENUMBER(String cf) {
   String regex = "(@PARSENUMBER\\([0-9|.|\"]*\\))"; // 匹配@VALUE公式
   Pattern p = Pattern.compile(regex);
   Matcher mt = p.matcher(cf);
   while (mt.find()) {
     String group = mt.group();
     String number = group.substring(group.indexOf("\"") + 1, group.lastIndexOf("\""));
     if (NumberUtils.isNumeric(number)) {
       cf = mt.replaceFirst(number);
     } else {
       cf = mt.replaceFirst("0");
     }
     mt = p.matcher(cf);
   }
   return cf;
 }
 /**
  * Get a target subdirectory under current/ for a given block file that is being restored from
  * trash.
  *
  * <p>The subdirectory structure under trash/ mirrors that under current/ to keep implicit memory
  * of where the files are to be restored.
  *
  * @return the target directory to restore a previously deleted block file.
  */
 @VisibleForTesting
 String getRestoreDirectory(File blockFile) {
   Matcher matcher = BLOCK_POOL_TRASH_PATH_PATTERN.matcher(blockFile.getParent());
   String restoreDirectory = matcher.replaceFirst("$1$2" + STORAGE_DIR_CURRENT + "$4");
   LOG.info("Restoring " + blockFile + " to " + restoreDirectory);
   return restoreDirectory;
 }
示例#10
0
  public Token nextToken() throws InvalidCodeException {
    str = str.trim();

    if (pushBack) {
      pushBack = false;
      return lastToken;
    }

    if (str.equals("")) {
      return lastToken = new Token(Token.TokenType.EMPTY);
    }

    for (TokenData data : tokenDatas) {
      Matcher matcher = data.getPattern().matcher(str);

      if (matcher.find()) {
        String token = matcher.group().trim();
        str = matcher.replaceFirst("");

        if (data.getTokenType() == Token.TokenType.STRING_LITERAL) {
          return lastToken =
              new Token(Token.TokenType.STRING_LITERAL, token.substring(1, token.length() - 1));
        } else {
          return lastToken = new Token(data.getTokenType(), token);
        }
      }
    }

    throw new InvalidCodeException("Unknown token: " + str.substring(0, str.indexOf(" ")));
  }
示例#11
0
 @Override
 public String solverRandom(int type, String value) {
   Matcher matcher = PATTERN.matcher(value);
   matcher.find();
   return matcher.replaceFirst(
       RandomRegistry.getRandomFromSet(Arrays.asList(matcher.group(1).split(", ?"))));
 }
  public static String getGroupPrefixString(String username) {
    Matcher match = groupRegex.matcher(CoreConfig.groupPrefixFormat);

    ArrayList<TreeSet<Group>> list = getGroupsList(match, username);

    String end = "";

    StringBuilder temp = new StringBuilder();
    for (TreeSet<Group> set : list) {
      for (Group g : set) {
        if (g.prefix.trim().isEmpty()) {
          continue;
        }

        if (temp.length() == 0) {
          temp.append(g.prefix);
        } else {
          temp.insert(0, g.prefix + "&r");
        }
      }

      end = match.replaceFirst(temp.toString());
      temp = new StringBuilder();
    }

    return end;
  }
示例#13
0
  /**
   * 条件判断 @IF(表单变量?"":""); aaa && bbb || ccc
   *
   * @param cf
   * @return
   */
  public String eval_IF(String cf) {
    // "123"+@IF((A>100 && B<100)?@UUID():@VALUE());
    String regex = "@IF\\(.*\\)"; // 匹配@IF公式
    Pattern p = Pattern.compile(regex);
    Matcher mt = p.matcher(cf);
    while (mt.find()) {
      String group = mt.group();
      String condition = group.substring(group.indexOf("(") + 1, group.indexOf("?"));
      String v1 = group.substring(group.indexOf("?") + 1, group.indexOf(":"));
      String v2 = group.substring(group.indexOf(":") + 1, group.lastIndexOf(")"));
      Interpreter i = new Interpreter();
      String v = "\"\"";

      try {
        initEvalContext(i);
        Boolean ret = (Boolean) i.eval(condition);
        if (ret == true) {
          v = v1;
        } else {
          v = v2;
        }
        mt = p.matcher(cf);
      } catch (Exception ex) {
        // ex.printStackTrace();
      }
      cf = mt.replaceFirst(v);
    }
    return cf;
  }
示例#14
0
 /**
  * Normalize components of the given file path, removing any environment- or test-run dependent
  * components. For example, substitutes the unique id portion of Impala generated file names with
  * a fixed literal. Subclasses should override to do filesystem specific cleansing.
  */
 protected Path cleanseFilePath(Path path) {
   String fileName = path.getName();
   Pattern pattern = Pattern.compile("\\w{16}-\\w{16}_\\d+_data");
   Matcher matcher = pattern.matcher(fileName);
   fileName = matcher.replaceFirst("<UID>_data");
   return new Path(path.getParent(), fileName);
 }
 /** Capitalize a.m./p.m and remove the all '.' characters. */
 private String formatAmPm(String dateTime) {
   final Pattern AM_PM = Pattern.compile("(a.m.|p.m.)");
   Matcher matcher = AM_PM.matcher(dateTime);
   matcher.find();
   String capitalized = matcher.group(1).toUpperCase();
   return matcher.replaceFirst(capitalized).replaceAll("\\.", "");
 }
示例#16
0
 public Lexer2(String str) {
   tokenInfos = new LinkedList<>();
   tokens = new LinkedList<>();
   add("PARTDESC|PARTNO|PNC|INVOICEDESC|SUNDRYCODE", 10);
   add("\\(", 6);
   add("\\)", 7);
   add("\\=|LIKE", 11);
   add("OR", 1);
   add("AND", 2);
   add("[0-9]+", 12);
   add("'[%][0-9]+[%]'", 12);
   add("\\'(.*?)\\'", 12);
   String s = str.trim();
   tokens.clear();
   while (!s.equals("")) {
     boolean match = false;
     for (TokenInfo info : tokenInfos) {
       Matcher m = info.regex.matcher(s);
       if (m.find()) {
         match = true;
         String tok = m.group().trim();
         s = m.replaceFirst("").trim();
         tokens.add(new Token(info.token, tok));
         break;
       }
     }
     if (!match) {
       System.out.println("Unexpected character in input: " + s);
     }
   }
 }
示例#17
0
  /** Extract a condition from the working string. */
  @Override
  @SuppressWarnings("nls")
  public TalkConsequence extract() {
    if (getNewLine() == null) {
      throw new IllegalStateException("Can't extract if no state set.");
    }

    final Matcher stringMatcher = STRING_FIND.matcher(getNewLine());
    if (stringMatcher.find()) {
      final AdvancedNumber level = AdvNumber.getNumber(stringMatcher.group(1));

      setLine(stringMatcher.replaceFirst(EMPTY_STRING));

      if (level == null) {
        reportError(
            String.format(
                Lang.getMsg(getClass(), "number"), stringMatcher.group(1), stringMatcher.group(0)));
        return extract();
      }

      final ConsequenceTreasure treasureCons = ConsequenceTreasure.getInstance();
      treasureCons.setData(level);
      return treasureCons;
    }

    return null;
  }
示例#18
0
  public void doReplacement() {
    EditWindow currentWindow = editor.getActiveWindow();

    if (currentWindow == null || getFindTextField().getText().length() == 0) {
      // launch error dialog?
      return;
    }
    JEditorPane editorPane = currentWindow.getEditorPane();
    String text = editorPane.getSelectedText();

    if (text == null) {
      // no selection
      return;
    }
    Matcher m = getCurrentPattern().matcher(text);

    if (m.matches()) {
      String replacement = getReplaceTextField().getText();

      if (getRegexButton().isSelected()) {
        replacement = m.replaceFirst(replacement);
      }
      editorPane.replaceSelection(replacement);
    }
  }
示例#19
0
 private static String removeComments(String line) {
   Matcher m = commentPattern.matcher(line);
   line = m.replaceFirst("");
   Matcher m1 = escapedCommentCharacterPattern.matcher(line);
   line = m1.replaceAll(commentIntroducingCharacter);
   return line;
 }
 @Override
 public String suggestSdkName(String currentSdkName, String sdkHome) {
   final String suggestedName;
   if (currentSdkName != null && !currentSdkName.isEmpty()) {
     final Matcher matcher = VERSION_STRING_PATTERN.matcher(currentSdkName);
     final boolean replaceNameWithVersion = matcher.matches();
     if (replaceNameWithVersion) {
       // user did not change name -> set it automatically
       final String versionString = getVersionString(sdkHome);
       suggestedName =
           versionString == null
               ? currentSdkName
               : matcher.replaceFirst("$1" + versionString + "$3");
     } else {
       suggestedName = currentSdkName;
     }
   } else {
     String versionString = getVersionString(sdkHome);
     suggestedName =
         versionString == null
             ? ProjectBundle.message("sdk.java.unknown.name")
             : getVersionNumber(versionString);
   }
   return suggestedName;
 }
  @Override
  public DatePickerPanel waitForElementsToLoad() {
    for (Map.Entry<Month, ExtendedWebElement> entry : this.monthElements.entrySet()) {
      entry
          .getValue()
          .setUnderlyingWebElement(
              this.driver.findElement(
                  By.className(
                      appProps.getELEMENT_CLASS_PREFIX_MONTH() + (entry.getKey().getValue() - 1))));
    }
    List<WebElement> yearButtons =
        this.getDriver().findElementsByClassName(appProps.getELEMENT_CLASS_YEAR_BUTTON());
    for (WebElement yearButton : yearButtons) {
      Matcher yearButtonMatcher =
          YEAR_BUTTON_CLASS_PATTERN.matcher(
              yearButton.getAttribute(appProps.getATTRIBUTE_NAME_CLASS()));
      this.yearElements.put(
          yearButtonMatcher.replaceFirst("$1"), new ExtendedWebElement(this, yearButton));
    }

    this.okButton.setUnderlyingWebElement(
        this.driver.findElement(By.className(appProps.getELEMENT_ID_OK_BUTTON())));
    this.cancelButton.setUnderlyingWebElement(
        this.driver.findElement(By.className(appProps.getELEMENT_ID_CANCEL_BUTTON())));

    return this;
  }
示例#22
0
 static void testReplace() {
   Pattern pattern = Pattern.compile("(d.)");
   Matcher m = pattern.matcher("abcdefgd");
   System.out.println(m.replaceFirst("12$1\3"));
   System.out.println("abcdefgd".replaceFirst("(d.)", "12$1\\3"));
   System.out.println("abcdef\\\\gd ");
 }
示例#23
0
  private static String setBase(String content, String base) {
    // remove base tag if it exists
    Pattern basePattern = Pattern.compile("<base.*?>", Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
    Matcher baseMatcher = basePattern.matcher(content);
    if (baseMatcher.find()) {
      // base is already set
      return content;
    }

    // add new base tag
    Pattern headPattern =
        Pattern.compile("<head>(.*?)</head>", Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
    Matcher headMatcher = headPattern.matcher(content);

    if (headMatcher.find()) {
      StringBuffer newHead = new StringBuffer();
      newHead.append("<head>\n");
      newHead.append("<base href=\"");
      newHead.append(base);
      newHead.append("\" target=\"_blank\"/>\n");
      newHead.append(headMatcher.group(1));
      newHead.append("\n");
      newHead.append("</head>\n");

      content = headMatcher.replaceFirst(newHead.toString());
    }

    return content;
  }
示例#24
0
 public String apply(String word) {
   Matcher matcher = regex.matcher(word);
   boolean find = matcher.find();
   if (!find) {
     return null;
   }
   return matcher.replaceFirst(replacement);
 }
 /**
  * Get a target subdirectory under trash/ for a given block file that is being deleted.
  *
  * <p>The subdirectory structure under trash/ mirrors that under current/ to keep implicit memory
  * of where the files are to be restored (if necessary).
  *
  * @return the trash directory for a given block file that is being deleted.
  */
 public String getTrashDirectory(File blockFile) {
   if (isTrashAllowed(blockFile)) {
     Matcher matcher = BLOCK_POOL_CURRENT_PATH_PATTERN.matcher(blockFile.getParent());
     String trashDirectory = matcher.replaceFirst("$1$2" + TRASH_ROOT_DIR + "$4");
     return trashDirectory;
   }
   return null;
 }
示例#26
0
 /** Inverse of {@link #doMigrate}. */
 private void unmigrateBuildsDir(File builds) throws Exception {
   File mapFile = new File(builds, MAP_FILE);
   if (!mapFile.isFile()) {
     System.err.println(builds + " does not look to have been migrated yet; skipping");
     return;
   }
   for (File build : builds.listFiles()) {
     int number;
     try {
       number = Integer.parseInt(build.getName());
     } catch (NumberFormatException x) {
       continue;
     }
     File buildXml = new File(build, "build.xml");
     if (!buildXml.isFile()) {
       System.err.println(buildXml + " did not exist");
       continue;
     }
     String xml = FileUtils.readFileToString(buildXml, Charsets.UTF_8);
     Matcher m = TIMESTAMP_ELT.matcher(xml);
     if (!m.find()) {
       System.err.println(buildXml + " did not contain <timestamp> as expected");
       continue;
     }
     long timestamp = Long.parseLong(m.group(1));
     String nl = m.group(2);
     xml = m.replaceFirst("  <number>" + number + "</number>" + nl);
     m = ID_ELT.matcher(xml);
     String id;
     if (m.find()) {
       id = m.group(1);
       xml = m.replaceFirst("");
     } else {
       // Post-migration build. We give it a new ID based on its timestamp.
       id = legacyIdFormatter.format(new Date(timestamp));
     }
     FileUtils.write(buildXml, xml, Charsets.UTF_8);
     if (!build.renameTo(new File(builds, id))) {
       System.err.println(build + " could not be renamed");
     }
     Util.createSymlink(builds, id, Integer.toString(number), StreamTaskListener.fromStderr());
   }
   Util.deleteFile(mapFile);
   System.err.println(builds + " has been restored to its original format");
 }
示例#27
0
 private String getWordMatchingPattern() {
   Matcher m = STRIP_PATTERN.matcher(pattern);
   if (!m.matches()) {
     throw new IllegalStateException("internal pattern mismatch:" + pattern);
   }
   String content = m.group(GROUP_CONTENT);
   return pattern.replaceFirst(
       content, m.replaceFirst("(?<" + GROUP_CONTENT + ">" + content + ")"));
 }
示例#28
0
  /**
   * A helper method to strip unwanted whitespace from an input text.
   *
   * <p>This method is expected to be called on a input text consiting of multiple lines.
   *
   * @param text
   * @return not null
   */
  public static final String stripws(String text) {
    Pattern P;
    Matcher m;
    String t;
    int e, n;

    // Compile a regex matching all whitespace starting from the begin of
    // input till the first non-whitespace character. Note, that '\s'
    // matches EOL as well as classical whitespace.

    P = makeregex("^[ \\t\\f]*(?:\\n|\\r\\n)(\\s*)");

    // Create matcher object, then test whether basic regex matches. If not
    // then there is no \eol between begin-of-input and first non-ws char -
    // in which case we do not strip any ws on purpose.
    m = P.matcher(text);
    if (m.find() == false) {
      return text;
    }

    // Calculate the number of ws characters between first non-ws character
    // and \eol before that character. Such a character must exist, other-
    // wise regex 'P' could not have matched.

    e = m.end();
    n = 0;
    while (e > 0) {
      switch (text.charAt(--e)) {
        case '\n':
          break;
        default:
          n = n + 1;
      }
    }

    // Remove initial ws including \eol.
    t = m.replaceFirst("$1");

    if (n > 0) {
      // Compile a pattern on the fly that matches a newline followed by
      // at most n whitespace characters (but newline).
      P = makeregex("(?m)(^|\\A)[ \\t\\f]{1," + n + "}");
      m = P.matcher(t);
      t = m.replaceAll("");
    }

    // Eventually remove trailing whitespace
    // Warning: do not use '$' to denote ONLY the end of input - this can
    // be tricky. Cause '$' also matches the *last* \eol before \eof. Better
    // to use \z cause always means \eof. See also unit cases for further
    // details.
    P = makeregex("\\n[ \\t\\f]*\\z");
    m = P.matcher(t);
    t = m.replaceAll("");
    return t;
  }
示例#29
0
 /**
  * Reverts a string from camel case.
  *
  * @param s The string to be transformed.
  * @param space The new word separator character.
  * @return The new string.
  */
 public static String unCamelCase(String s, char space) {
   final Pattern pattern = Pattern.compile("([a-z0-9])([A-Z])");
   Matcher matcher = pattern.matcher(s);
   String[] pieces = pattern.split(s);
   while (matcher.find()) {
     s = matcher.replaceFirst(matcher.group(1) + space + matcher.group(2).toLowerCase());
     matcher.reset(s);
   }
   return s;
 }
 public String replaceURL(Pattern pattern, String toReplaceString) {
   final Matcher matcher = pattern.matcher(toReplaceString);
   if (matcher.find()) {
     toReplaceString = matcher.replaceFirst(linkStrings.get(uneed2TranslateElementIndex));
     uneed2TranslateElementIndex++;
     return replaceURL(pattern, toReplaceString);
   } else {
     return toReplaceString;
   }
 }