protected Map<String, String> getAttributes() {
    if (attributes != null) {
      return attributes;
    }

    attributes = new HashMap<String, String>();

    matcher = ADDITIONAL_ATTRIBUTES_PATTERN.matcher(firstLine);
    if (matcher.find()) {
      String s;
      Matcher attributeMatcher;

      s = matcher.group(2);
      attributeMatcher = ADDITIONAL_ATTRIBUTE_PATTERN.matcher(s);
      while (attributeMatcher.find()) {
        String key;
        String value;

        key = attributeMatcher.group(1);
        value = attributeMatcher.group(2);
        attributes.put(key.toLowerCase(Locale.ENGLISH), value);
      }
    }
    return attributes;
  }
Example #2
0
 /**
  * Import an XQuery library module from the given document. The namespace and preferred prefix of
  * the module are extracted from the module itself. The MIME type of the document is set to
  * "application/xquery" as a side-effect.
  *
  * @param module the non-XML document that holds the library module's source
  * @return this service, to chain calls
  * @throws DatabaseException if the module is an XML document, or the module declaration cannot be
  *     found at the top of the document
  */
 public QueryService importModule(Document module) {
   if (module instanceof XMLDocument)
     throw new DatabaseException("module cannot be an XML document: " + module);
   Matcher matcher = MODULE_DECLARATION_DQUOTE.matcher(module.contentsAsString());
   if (!matcher.find()) {
     matcher = MODULE_DECLARATION_SQUOTE.matcher(module.contentsAsString());
     if (!matcher.find())
       throw new DatabaseException("couldn't find a module declaration at the top of " + module);
   }
   module.metadata().setMimeType("application/xquery");
   String moduleNamespace = matcher.group(1);
   // TODO: should do URILiteral processing here to replace entity and character references and
   // normalize
   // whitespace, but since it seems that eXist doesn't do it either (bug?) there's no reason to
   // rush.
   Document prevModule = moduleMap.get(moduleNamespace);
   if (prevModule != null && !prevModule.equals(module))
     throw new DatabaseException(
         "module "
             + moduleNamespace
             + " already bound to "
             + prevModule
             + ", can't rebind to "
             + module);
   moduleMap.put(moduleNamespace, module);
   return this;
 }
 public boolean checkCondition(String format, ScoreBoardEvent event) {
   boolean triggerCondition = true;
   Matcher m = conditionPattern.matcher(format);
   if (!m.find()) throw new IllegalArgumentException("No conditions in format : " + format);
   do {
     String specifier = m.group(1);
     String comparator = m.group(2);
     String targetValue = m.group(3);
     if (null == comparator || null == targetValue) continue;
     String value = scoreBoardValues.get(specifier).getValue();
     if (triggerCondition) {
       triggerCondition = false;
       // If current trigger event value == previous value after processing
       // (e.g. conversion to min:sec) then ignore, to prevent multiple consecutive
       // identical triggers
       if (value.equals(
           scoreBoardValues.get(specifier).getPreviousValue(event.getPreviousValue())))
         return false;
     }
     try {
       if (!checkConditionValue(value, comparator, targetValue)) return false;
     } catch (IllegalArgumentException iaE) {
       return false;
     }
   } while (m.find());
   return true;
 }
 public String parse(String format) {
   StringBuffer buffer = new StringBuffer();
   Matcher m = formatPattern.matcher(format);
   while (m.find()) m.appendReplacement(buffer, getFormatSpecifierValue(m.group()));
   m.appendTail(buffer);
   return buffer.toString();
 }
Example #5
0
  /**
   * Leave only the value for RCS keywords.
   *
   * <p>For example, <code>$Revision: 1.1 $</code> becomes <code>1.0</code>.
   */
  public String replaceRcsKeywords(String text) {
    if (matcher == null) {
      matcher =
          Pattern.compile(
                  "\\$(Author|Date|Header|Id|Locker|Log|Name|RCSFile|Revision|Source|State): (.+?) \\$")
              .matcher(text);
    } else {
      matcher.reset(text);
    }

    StringBuffer buffer = new StringBuffer();
    while (matcher.find()) {
      String string = matcher.group(2);

      // For the Date: keyword, have a shot at reformatting string
      if ("Date".equals(matcher.group(1))) {
        try {
          DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
          Date date = dateFormat.parse(string);
          string = date.toString();
        } catch (ParseException e) {
        } // if we can't parse, return unchanged
      }

      matcher.appendReplacement(buffer, string);
    }
    matcher.appendTail(buffer);
    return buffer.toString();
  }
Example #6
0
  /**
   * Get dependencies of a source file.
   *
   * @param path The canonical path of source file.
   * @return Path of dependencies.
   */
  private ArrayList<String> getDependencies(String path) {
    if (!dependenceMap.containsKey(path)) {
      ArrayList<String> dependencies = new ArrayList<String>();
      Matcher m = PATTERN_REQUIRE.matcher(read(path, charset));

      while (m.find()) {
        // Decide which root path to use.
        // Path wrapped in <> is related to root path.
        // Path wrapped in "" is related to parent folder of the source file.
        String root = null;

        if (m.group(1).equals("<")) {
          root = this.root;
        } else {
          root = new File(path).getParent();
        }

        // Get path of required file.
        String required = m.group(2);

        File f = new File(root, required);

        if (f.exists()) {
          dependencies.add(canonize(f));
        } else {
          App.exit("Cannot find required file " + required + " in " + path);
        }
      }

      dependenceMap.put(path, dependencies);
    }

    return dependenceMap.get(path);
  }
Example #7
0
  private InstanceList readFile() throws IOException {

    String NL = System.getProperty("line.separator");
    Scanner scanner = new Scanner(new FileInputStream(fileName), encoding);

    ArrayList<Pipe> pipeList = new ArrayList<Pipe>();
    pipeList.add(new CharSequence2TokenSequence(Pattern.compile("\\p{L}\\p{L}+")));
    pipeList.add(new TokenSequence2FeatureSequence());

    InstanceList testing = new InstanceList(new SerialPipes(pipeList));

    try {
      while (scanner.hasNextLine()) {

        String text = scanner.nextLine();
        text = text.replaceAll("\\x0d", "");

        Pattern patten = Pattern.compile("^(.*?),(.*?),(.*)$");
        Matcher matcher = patten.matcher(text);

        if (matcher.find()) {
          docIds.add(matcher.group(1));
          testing.addThruPipe(new Instance(matcher.group(3), null, "test instance", null));
        }
      }
    } finally {
      scanner.close();
    }

    return testing;
  }
 /**
  * Takes a line and looks for an archive request tag. If one is found, the information from the
  * tag is returned as an <CODE>ArchiveRequest</CODE>. If a tag is found, the data in the tag is
  * stored in the <CODE>HashMap</CODE> provided.
  *
  * @param currentLine The line in which to look for the archive tag.
  * @param group The <CODE>ArchiveGroup</CODE> to which to add the <CODE>ArchiveRequest</CODE>. Can
  *     be <CODE>null</CODE>.
  * @param template The <CODE>Template</CODE> to which the <CODE>ArchiveRequest</CODE> belongs.
  * @return The archive request tag data as an instance of <CODE>ArchiveRequest</CODE>, <CODE>null
  *     </CODE> if the line passed in does not contain an arFile tag.
  */
 private ArchiveRequest parseArchiveRequestTag(
     String currentLine, ArchiveGroup group, Template template) {
   ArchiveRequest archiveTag;
   Matcher currentMatcher = archiveRequestPattern.matcher(currentLine);
   if (currentMatcher.find()) {
     String fileName = currentMatcher.group(1);
     archiveTag = template.getArchiveRequest(fileName);
     if (archiveTag == null) {
       archiveTag = new ArchiveRequest(fileName);
       template.addArchiveRequest(archiveTag);
     }
     if (group != null) {
       // Creating a new request object because the requests
       // in the groups flagged as not in database will mean the
       // group - request association is not in database. Requests
       // in the archiveRequests map flagged as not in database
       // means the request record is not there.
       String requestFileName = archiveTag.getFileName();
       String requestFileLocation = archiveTag.getFileLocation();
       ArchiveRequest groupRequest = new ArchiveRequest(requestFileLocation, requestFileName);
       group.addArchiveRequest(groupRequest);
     }
   } else archiveTag = null;
   return archiveTag;
 }
Example #9
0
 @Override
 public void processingInstruction(String target, String data) throws SAXException {
   _logger.fine("Processing Instruction " + target);
   _logger.fine("Processing Instruction data: " + data);
   if (target.equals("assemble")) {
     if (!_stack.isEmpty()) {
       ElementInfo element = _stack.get(_stack.size() - 1);
       Matcher matcher = PROCESSING_INSTRUCTION.matcher(data);
       while (matcher.find()) {
         if (matcher.groupCount() == 2) {
           String name = matcher.group(1);
           if (name.charAt(0) == '@') {
             element.inst.put(name, matcher.group(2));
           } else {
             element.args.add(guessUntypedValue(name, matcher.group(2)));
           }
           _logger.fine(
               "Processing Instruction for "
                   + element.data.getClass()
                   + "\n\ttarget = "
                   + target
                   + "\n\t"
                   + name
                   + "="
                   + matcher.group(2));
         }
       }
     }
   }
 }
Example #10
0
 protected RichText.Part text(PState s, String text, Map<? extends Attribute, ?> attrs)
     throws IOException {
   RichText.Part ret = null;
   int p = 0;
   while (true) {
     Matcher m = urlpat.matcher(text);
     if (!m.find(p)) break;
     URL url;
     try {
       String su = text.substring(m.start(), m.end());
       if (su.indexOf(':') < 0) su = "http://" + su;
       url = new URL(su);
     } catch (java.net.MalformedURLException e) {
       p = m.end();
       continue;
     }
     RichText.Part lead = new RichText.TextPart(text.substring(0, m.start()), attrs);
     if (ret == null) ret = lead;
     else ret.append(lead);
     Map<Attribute, Object> na = new HashMap<Attribute, Object>(attrs);
     na.putAll(urlstyle);
     na.put(ChatAttribute.HYPERLINK, new FuckMeGentlyWithAChainsaw(url));
     ret.append(new RichText.TextPart(text.substring(m.start(), m.end()), na));
     p = m.end();
   }
   if (ret == null) ret = new RichText.TextPart(text, attrs);
   else ret.append(new RichText.TextPart(text.substring(p), attrs));
   return (ret);
 }
 public synchronized String format(String message) {
   Matcher matcher = variablePattern.matcher(message);
   while (matcher.find()) {
     String variable = matcher.group();
     variable = variable.substring(1);
     if (variable.startsWith("{") && variable.endsWith("}"))
       variable = variable.substring(1, variable.length() - 1);
     String value = variables.get(variable);
     if (value == null) value = "";
     message =
         message.replaceFirst(Pattern.quote(matcher.group()), Matcher.quoteReplacement(value));
   }
   matcher = colorPattern.matcher(message);
   while (matcher.find())
     message =
         message.substring(0, matcher.start()) + "\247" + message.substring(matcher.end() - 1);
   return message;
 }
  private List<String> convertFollowupPatientIds(List<String> patientIds) {
    List<String> convertedPatientIds = new ArrayList<String>();

    for (String patientId : patientIds) {
      Matcher patientIdMatcher = FOLLOW_UP_PATIENT_ID_REGEX.matcher(patientId);
      convertedPatientIds.add(patientIdMatcher.find() ? patientIdMatcher.group(1) : patientId);
    }

    return convertedPatientIds;
  }
Example #13
0
  public URLFinder(String text) {
    Matcher matcher = dfPattern.matcher(text);
    urls = new ArrayList<String>();
    locations = new ArrayList<Integer[]>();

    while (matcher.find()) {
      urls.add(matcher.group(1));
      locations.add(new Integer[] {matcher.start(1), matcher.end(1)});
    }
  }
 public BasicSpellChecker(String file) throws IOException {
   BufferedReader in = new BufferedReader(new FileReader(file));
   Pattern p = Pattern.compile("\\w+");
   for (String temp = ""; temp != null; temp = in.readLine()) {
     Matcher m = p.matcher(temp.toLowerCase());
     while (m.find())
       nWords.put((temp = m.group()), nWords.containsKey(temp) ? nWords.get(temp) + 1 : 1);
   }
   in.close();
 }
  public String getResult() {
    if (result != null) {
      return result;
    }

    matcher = RESULT_PATTERN.matcher(firstLine);
    if (matcher.find()) {
      result = matcher.group(1);
    }
    return result;
  }
  public int getStatus() {
    if (status != null) {
      return status;
    }

    matcher = STATUS_PATTERN.matcher(firstLine);
    if (matcher.find()) {
      status = Integer.parseInt(matcher.group(1));
    }
    return status;
  }
  /**
   * Removes all sections (both header and content) with the given sectionName
   *
   * @param sectionName the name of the section (case insensitive) to remove.
   * @param markup the markup to be stripped
   * @return the stripped markup
   */
  public static String stripSection(String markup, String sectionName) {

    Pattern p =
        Pattern.compile(
            "(={2,})\\s*" + sectionName + "\\s*\\1.*?([^=]\\1[^=])",
            Pattern.CASE_INSENSITIVE + Pattern.DOTALL);
    Matcher m = p.matcher(markup);

    StringBuffer sb = new StringBuffer();
    int lastIndex = 0;

    while (m.find()) {
      sb.append(markup.substring(lastIndex, m.start()));
      sb.append(m.group(2));
      lastIndex = m.end();
    }

    sb.append(markup.substring(lastIndex));
    markup = sb.toString();

    // if this was the last section in the doc, then it won't be discarded because we can't tell
    // where it ends.
    // best we can do is delete the title and the paragraph below it.

    p =
        Pattern.compile(
            "(={2,})\\s*" + sectionName + "\\s*\\1\\W*.*?\n\n",
            Pattern.CASE_INSENSITIVE + Pattern.DOTALL);
    m = p.matcher(markup);

    sb = new StringBuffer();
    lastIndex = 0;

    while (m.find()) {
      sb.append(markup.substring(lastIndex, m.start()));
      lastIndex = m.end() - 2;
    }

    sb.append(markup.substring(lastIndex));
    return sb.toString();
  }
 /*
  * This is comlicated. MOST AUs have articles that live below and issue level TOC
  * that is,
  * <blah>/<journal_id>/vol#/iss#/ is a toc with no relevant metadata
  * <blah>/<journal_id>/vol#/iss#/xxx is an article with metadata
  * (eg Economist Voice V1)
  * BUT
  * in some AUs there are issues with only 1 article, in which case
  * <blah>/<journal_id>/vol#/iss#/ is an abstract with metadata
  * (eg Rhodes Cook V4)
  * and a few AUs with a mixture
  * (eg Forum for Health Economics V5)
  * So to identify ALL articles, we'll also have to capture issue level items and then look
  * at the html and if it has article metadata in it, count it as an article.
  *
  */
 @Override
 protected ArticleFiles createArticleFiles(CachedUrl cu) {
   String url = cu.getUrl();
   Matcher mat = pattern.matcher(url);
   if (mat.find()) {
     // we matched, but could this pattern potentially be a toc?
     Matcher tocmat = TOC_pattern.matcher(url);
     // if we could be a TOC then we must have metadata to be considered an article
     if (tocmat.find()) {
       if (hasArticleMetadata(cu)) {
         return processUrl(cu, mat);
       }
     } else {
       // we're not a potential TOC, so treat this as an article without checking
       return processUrl(cu, mat);
     }
     return null; // this was a TOC, not an article
   }
   log.warning("Mismatch between article iterator factory and article iterator: " + url);
   return null;
 }
 private static List<String> loadAccounts(String fileName) {
   List<String> accounts = new ArrayList<String>();
   try {
     Pattern pattern = Pattern.compile("[\\w]{1,16}");
     BufferedReader reader = new BufferedReader(new FileReader(new File(fileName)));
     String line;
     while ((line = reader.readLine()) != null) {
       Matcher matcher = pattern.matcher(line);
       if (!matcher.find()) continue;
       String username = matcher.group();
       if (!matcher.find()) continue;
       String password = matcher.group();
       accounts.add(username + ":" + password);
     }
     reader.close();
   } catch (Exception exception) {
     throw new RuntimeException(exception);
   }
   System.out.println("Loaded " + accounts.size() + " accounts.");
   return accounts;
 }
  /**
   * Strips all non-article links from the given markup; anything like [[this]] is removed unless it
   * goes to a wikipedia article, redirect, or disambiguation page.
   *
   * @param markup the text to be stripped
   * @return the stripped text
   */
  public static String stripIsolatedLinks(String markup) {

    Vector<Integer> linkStack = new Vector<Integer>();

    Pattern p = Pattern.compile("(\\[\\[|\\]\\])");
    Matcher m = p.matcher(markup);

    StringBuffer sb = new StringBuffer();
    int lastIndex = 0;

    while (m.find()) {
      String tag = markup.substring(m.start(), m.end());

      if (tag.equals("[[")) linkStack.add(m.start());
      else {
        if (!linkStack.isEmpty()) {
          int linkStart = linkStack.lastElement();
          linkStack.remove(linkStack.size() - 1);

          if (linkStack.isEmpty()) {
            sb.append(markup.substring(lastIndex, linkStart));

            // we have the whole link, with other links nested inside if it's an image
            String linkMarkup = markup.substring(linkStart + 2, m.start());

            // System.out.println(" - " + linkStart + ", " + m.end() + ", " + markup.length()) ;

            if (markup.substring(Math.max(0, linkStart - 10), linkStart).matches("(?s).*(\\W*)\n")
                && (m.end() >= markup.length() - 1
                    || markup
                        .substring(m.end(), Math.min(markup.length() - 1, m.end() + 10))
                        .matches("(?s)(\\W*)(\n.*|$)"))) {
              // discarding link
            } else {
              sb.append("[[");
              sb.append(linkMarkup);
              sb.append("]]");
            }

            lastIndex = m.end();
          }
        }
      }
    }

    if (!linkStack.isEmpty())
      System.err.println(
          "MarkupStripper | Warning: links were not well formed, so we cannot guarantee that they were stripped out correctly. ");

    sb.append(markup.substring(lastIndex));
    return sb.toString();
  }
Example #21
0
  void findRemoveDirectives(boolean clean) {
    // if ( clean ) editor.startCompoundEdit();

    Sketch sketch = editor.getSketch();
    for (int i = 0; i < sketch.getCodeCount(); i++) {
      SketchCode code = sketch.getCode(i);
      String program = code.getProgram();
      StringBuffer buffer = new StringBuffer();

      Matcher m = pjsPattern.matcher(program);
      while (m.find()) {
        String mm = m.group();

        // TODO this urgently needs tests ..

        /* remove framing */
        mm = mm.replaceAll("^\\/\\*\\s*@pjs", "").replaceAll("\\s*\\*\\/\\s*$", "");
        /* fix multiline nice formatting */
        mm = mm.replaceAll("[\\s]*([^;\\s\\n\\r]+)[\\s]*,[\\s]*[\\n\\r]+", "$1,");
        /* fix multiline version without semicolons */
        mm = mm.replaceAll("[\\s]*([^;\\s\\n\\r]+)[\\s]*[\\n\\r]+", "$1;");
        mm = mm.replaceAll("\n", " ").replaceAll("\r", " ");

        // System.out.println(mm);

        if (clean) {
          m.appendReplacement(buffer, "");
        } else {
          String[] directives = mm.split(";");
          for (String d : directives) {
            // System.out.println(d);
            parseDirective(d);
          }
        }
      }

      if (clean) {
        m.appendTail(buffer);

        // TODO: not working!
        code.setProgram(buffer.toString());
        code.setModified(true);
      }
    }

    if (clean) {
      // editor.stopCompoundEdit();
      editor.setText(sketch.getCurrentCode().getProgram());
      sketch.setModified(false);
      sketch.setModified(true);
    }
  }
 /**
  * Takes a line and looks for an archive group tag. If one is found, the information from the tag
  * is returned as an <CODE>ArchiveGroup</CODE>. If a tag is found, the data in the tag is stored
  * in the <CODE>HashMap</CODE> provided.
  *
  * @param currentLine The line in which to look for the archive tag.
  * @param template The <CODE>Template</CODE> to which the <CODE>ArchiveGroup</CODE> belongs.
  * @return The archive request tag data as an instance of <CODE>ArchiveGroup</CODE>, <CODE>null
  *     </CODE> if the line passed in does not contain an arFile tag.
  */
 private ArchiveGroup parseArchiveGroupTag(String currentLine, Template template) {
   ArchiveGroup archiveTag;
   Matcher currentMatcher = archiveRequestPattern.matcher(currentLine);
   if (currentMatcher.find()) {
     String fileName = currentMatcher.group(1);
     archiveTag = template.getArchiveGroup(fileName);
     if (archiveTag == null) {
       File groupFile = new File(fileName);
       archiveTag = new ArchiveGroup(groupFile.getParent(), groupFile.getName());
       template.addArchiveGroup(archiveTag);
     }
   } else archiveTag = null;
   return archiveTag;
 }
  private static List<String> findQuotedArguments(String command) {
    List<String> arguments = new ArrayList<>();

    Pattern pattern = Pattern.compile("\".*?\"");
    Matcher matcher = pattern.matcher(command);

    while (matcher.find()) {
      String argument = command.substring(matcher.start(), matcher.end());
      argument = unquote(argument);
      argument = argument.trim();
      arguments.add(argument);
    }
    return arguments;
  }
Example #24
0
 private String presub(String query, Object[] params) {
   if (params == null) return query;
   StringBuffer buf = new StringBuffer();
   Matcher matcher = PRE_SUB_PATTERN.matcher(query);
   while (matcher.find()) {
     matcher.appendReplacement(
         buf,
         ((String) params[Integer.parseInt(matcher.group(1)) - 1])
             .replace("\\", "\\\\")
             .replace("$", "\\$"));
   }
   matcher.appendTail(buf);
   return buf.toString();
 }
Example #25
0
  public void run() {
    // each file is processed into a local hash table and then merged with the global results
    // this will cause much less contention on the global table, but still avoids a sequential
    // update
    Hashtable<String, Integer> local_results =
        new Hashtable<String, Integer>(WordCountJ.HASH_SIZE, WordCountJ.LF);
    // grab a file to work on
    String cf;
    while ((cf = files.poll()) != null) {
      try {
        BufferedReader input = new BufferedReader(new FileReader(cf));
        String text;
        // well go line-by-line... maybe this is not the fastest
        while ((text = input.readLine()) != null) {
          // parse words
          Matcher matcher = pattern.matcher(text);
          while (matcher.find()) {
            String word = matcher.group(1);
            if (local_results.containsKey(word)) {
              local_results.put(word, 1 + local_results.get(word));
            } else {
              local_results.put(word, 1);
            }
          }
        }
        input.close();
      } catch (Exception e) {
        System.out.println(" caught a " + e.getClass() + "\n with message: " + e.getMessage());
        return;
      }
      // merge local hashmap with shared one,could have a
      // seperate thread do this but that might be cheating

      Iterator<Map.Entry<String, Integer>> updates = local_results.entrySet().iterator();
      while (updates.hasNext()) {
        Map.Entry<String, Integer> kv = updates.next();
        String k = kv.getKey();
        Integer v = kv.getValue();
        synchronized (results) {
          if (results.containsKey(k)) {
            results.put(k, v + results.get(k));
          } else {
            results.put(k, v);
          }
        }
      }
      local_results.clear();
    }
  }
  /** Set this news object using the news specified by newsFile */
  public void setNews(String newsFile) throws IOException {
    Pattern pDocId = Pattern.compile("<DOC-ID>(.*)</DOC-ID>");
    Pattern pTitle = Pattern.compile("<TITLE>(.*)</TITLE>");
    Pattern pTimestamp = Pattern.compile("<TIMESTAMP>(.*)</TIMESTAMP>");
    Pattern pContent = Pattern.compile("<CONTENT>(.*)</CONTENT>");
    Matcher m = null;

    BufferedReader br = new BufferedReader(new FileReader(newsFile));

    String line = "";
    String news = "";
    while ((line = br.readLine()) != null) {
      news += line;
    }

    // get news metadata and content
    m = pDocId.matcher(news);
    if (m.find()) {
      this.docId = m.group(1);
    }

    m = pTitle.matcher(news);
    if (m.find()) {
      this.title = m.group(1);
    }

    m = pTimestamp.matcher(news);
    if (m.find()) {
      this.timestamp = m.group(1);
    }

    m = pContent.matcher(news);
    if (m.find()) {
      this.content = m.group(1);
    }
  }
  /**
   * Removes all section headers.
   *
   * @param markup the text to be stripped
   * @return the stripped markup
   */
  public static String stripHeadings(String markup) {
    Pattern p = Pattern.compile("(={2,})([^=]+)(\\1)");
    Matcher m = p.matcher(markup);

    StringBuffer sb = new StringBuffer();
    int lastIndex = 0;

    while (m.find()) {
      sb.append(markup.substring(lastIndex, m.start()));
      lastIndex = m.end();
    }

    sb.append(markup.substring(lastIndex));
    return sb.toString();
  }
  public String getExtra() {
    if (getStatus() != SC_SUCCESS) {
      return null;
    }

    if (extraCreated) {
      return extra;
    }

    matcher = PARENTHESIS_PATTERN.matcher(firstLine);
    if (matcher.find()) {
      extra = matcher.group(1);
    }
    extraCreated = true;
    return extra;
  }
Example #29
0
 private void processResponse(InputStream response) throws IOException {
   Pattern p = Pattern.compile("<cdbId>\\s*(\\d+)");
   BufferedReader in = new BufferedReader(new InputStreamReader(response));
   String line = in.readLine();
   while (line != null) {
     System.out.println(line);
     Matcher m = p.matcher(line);
     if (m.find()) {
       String idText = m.group(1);
       if (idText != null) {
         cdbId = Integer.parseInt(idText);
       }
     }
     line = in.readLine();
   }
 }
 /**
  * Replaces instances of Java reserved words that could not appear in a valid Java condition or
  * Java variable name that are being used as variable names in string.
  *
  * @param string the string in which the Java reserved words should be replaced.
  * @return string with the Java reserved words replaced with a substitute names.
  */
 private static String replaceReservedWords(String string) {
   // cheap hack so that pattern never need to look for a key word at
   // the beginning or end of string.  That way one may simplify the pattern
   // to looking for a reserved word that is not prefixed or suffix with a
   // letter or number.
   string = "(" + string + ")";
   for (int i = 0; i < reservedWords.length; i++) {
     String reservedWord = reservedWords[i];
     Pattern p = Pattern.compile("([\\W])(" + reservedWord + ")([\\W])");
     Matcher m = p.matcher(string);
     while (m.find()) {
       string = m.replaceFirst(m.group(1) + "daikon" + reservedWord + m.group(3));
       m = p.matcher(string);
     }
   }
   return string.substring(1, string.length() - 1);
 }