harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mloe...@apache.org
Subject svn commit: r397177 - in /incubator/harmony/enhanced/classlib/trunk/modules/regex/src/main/java/java/util/regex: Matcher.java Pattern.java
Date Wed, 26 Apr 2006 11:22:23 GMT
Author: mloenko
Date: Wed Apr 26 04:22:19 2006
New Revision: 397177

URL: http://svn.apache.org/viewcvs?rev=397177&view=rev
Log:
applied patch from HARMONY-375:
Regex javadoc should be copied from the old regex in archive

Modified:
    incubator/harmony/enhanced/classlib/trunk/modules/regex/src/main/java/java/util/regex/Matcher.java
    incubator/harmony/enhanced/classlib/trunk/modules/regex/src/main/java/java/util/regex/Pattern.java

Modified: incubator/harmony/enhanced/classlib/trunk/modules/regex/src/main/java/java/util/regex/Matcher.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/regex/src/main/java/java/util/regex/Matcher.java?rev=397177&r1=397176&r2=397177&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/regex/src/main/java/java/util/regex/Matcher.java
(original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/regex/src/main/java/java/util/regex/Matcher.java
Wed Apr 26 04:22:19 2006
@@ -217,16 +217,25 @@
         return this;
     }
 
-    /**
-     * @com.intel.drl.spec_ref
-     */
+	/**
+	 * TODO: appendTail(StringBuffer) javadoc
+	 * 
+	 * @param sb
+	 * @return
+	 */
     public StringBuffer appendTail(StringBuffer sb) {
         return sb.append(string.subSequence(appendPos, string.length()));
     }
 
-    /**
-     * @com.intel.drl.spec_ref
-     */
+	/**
+	 * This is very similar to replaceAll except only the first occurrence of a
+	 * sequence matching the pattern is replaced.
+	 * 
+	 * @param replacement
+	 *            A string to replace occurrences of character sequences
+	 *            matching the pattern.
+	 * @return A new string with replacements inserted
+	 */
     public String replaceFirst(String replacement) {
         reset();
         if (find()) {
@@ -239,9 +248,16 @@
 
     }
 
-    /**
-     * @com.intel.drl.spec_ref
-     */
+	/**
+	 * Replace all occurrences of character sequences which match the pattern
+	 * with the given replacement string. The replacement string may refer to
+	 * capturing groups using the syntax "$<group number>".
+	 * 
+	 * @param replacement
+	 *            A string to replace occurrences of character sequences
+	 *            matching the pattern.
+	 * @return A new string with replacements inserted
+	 */
     public String replaceAll(String replacement) {
         StringBuffer sb = new StringBuffer();
         reset();
@@ -252,9 +268,11 @@
         return appendTail(sb).toString();
     }
 
-    /**
-     * @com.intel.drl.spec_ref
-     */
+	/**
+	 * Return a reference to the pattern used by this Matcher.
+	 * 
+	 * @return A reference to the pattern used by this Matcher.
+	 */
     public Pattern pattern() {
         return pat;
     }
@@ -299,9 +317,14 @@
         return start.find(startIndex, string, matchResult);
     }
 
-    /**
-     * @com.intel.drl.spec_ref
-     */
+	/**
+	 * The find() method matches the pattern against the character sequence
+	 * beginning at the character after the last match or at the beginning of
+	 * the sequence if called immediately after reset(). The method returns true
+	 * if and only if a match is found.
+	 * 
+	 * @return A boolean indicating if the pattern was matched.
+	 */
     public boolean find() {
         int length = string.length();
         if (!hasTransparentBounds())
@@ -334,9 +357,14 @@
         return matchResult.end(groupIndex);
     }
 
-    /**
-     * @com.intel.drl.spec_ref
-     */
+	/**
+	 * This method is identical in function to the Pattern.matches() method. It
+	 * returns true if and only if the regular expression pattern matches the
+	 * entire input character sequence.
+	 * 
+	 * @return A boolean indicating if the pattern matches the entire input
+	 *         character sequence.
+	 */
     public boolean matches() {
         return lookingAt(leftBound, Matcher.MODE_MATCH);
     }
@@ -387,9 +415,15 @@
         return false;
     }
 
-    /**
-     * @com.intel.drl.spec_ref
-     */
+	/**
+	 * This method attempts to match the pattern against the character sequence
+	 * starting at the beginning. If the pattern matches even a prefix of the
+	 * input character sequence, lookingAt() will return true. Otherwise it will
+	 * return false.
+	 * 
+	 * @return A boolean indicating if the pattern matches a prefix of the input
+	 *         character sequence.
+	 */
     public boolean lookingAt() {
         return lookingAt(leftBound, Matcher.MODE_FIND);
     }
@@ -408,9 +442,11 @@
         return start(0);
     }
 
-    /**
-     * @com.intel.drl.spec_ref
-     */
+	/**
+	 * Return the number of capturing groups in the pattern.
+	 * 
+	 * @return The number of capturing groups in the pattern.
+	 */
     public int groupCount() {
         return matchResult.groupCount();
     }

Modified: incubator/harmony/enhanced/classlib/trunk/modules/regex/src/main/java/java/util/regex/Pattern.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/regex/src/main/java/java/util/regex/Pattern.java?rev=397177&r1=397176&r2=397177&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/regex/src/main/java/java/util/regex/Pattern.java
(original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/regex/src/main/java/java/util/regex/Pattern.java
Wed Apr 26 04:22:19 2006
@@ -24,11 +24,14 @@
 
 import java.util.ArrayList;
 
+
 /**
- * @com.intel.drl.spec_ref
+ * Pattern implements a compiler for regular expressions as defined by the J2SE
+ * specification. The regular expression syntax is largely similar to the syntax
+ * defined by Perl 5 but has both omissions and extensions. A formal and
+ * complete definition of the regular expression syntax is not provided by the
+ * J2SE speTBD (TODO)
  * 
- * @author Nikolay A. Kuznetsov
- * @version $Revision: 1.36.2.2 $
  */
 public final class Pattern implements Serializable {
     
@@ -110,16 +113,29 @@
 
     transient AbstractSet start = null;
 
-    /**
-     * @com.intel.drl.spec_ref
-     */
+	/**
+	 * Create a matcher for this pattern and a given input character sequence
+	 * 
+	 * @param cs
+	 *            The input character sequence
+	 * @return A new matcher
+	 */
     public Matcher matcher(CharSequence cs) {
         return new Matcher(this, cs);
     }
 
-    /**
-     * @com.intel.drl.spec_ref
-     */
+	/**
+	 * Split an input string using the pattern as a token separator.
+	 * 
+	 * @param input
+	 *            Input sequence to tokenize
+	 * @param limit
+	 *            If positive, the maximum number of tokens to return. If
+	 *            negative, an indefinite number of tokens are returned. If
+	 *            zero, an indefinite number of tokens are returned but trailing
+	 *            empty tokens are excluded.
+	 * @return A sequence of tokens split out of the input string.
+	 */
     public String[] split(CharSequence input, int limit) {
         ArrayList res = new ArrayList();
         Matcher mat = matcher(input);
@@ -157,30 +173,87 @@
         return split(input, 0);
     }
 
-    /**
-     * @com.intel.drl.spec_ref
-     */
+	/**
+	 * Returns the pattern string passed to the compile method
+	 * 
+	 * @return A string representation of the pattern
+	 */
     public String pattern() {
         return lexemes.toString();
     }
 
-    /**
-     * @com.intel.drl.spec_ref
-     */
+	/**
+	 * Return a textual representation of the pattern.
+	 * 
+	 * @return The regular expression string
+	 */
     public String toString() {
         return this.pattern();
     }
 
-    /**
-     * @com.intel.drl.spec_ref
-     */
+	/**
+	 * Return the mask of flags used to compile the pattern
+	 * 
+	 * @return A mask of flags used to compile the pattern.
+	 */
     public int flags() {
         return this.flags;
     }
 
-    /**
-     * @com.intel.drl.spec_ref
-     */
+	/**
+	 * Return a compiled pattern corresponding to the input regular expression
+	 * string.
+	 * 
+	 * The input <code>flags</code> is a mask of the following flags:
+	 * <dl>
+	 * <dt><code>UNIX_LINES</code> (0x0001)
+	 * <dd>Enables UNIX lines mode where only \n is recognized as a line
+	 * terminator. The default setting of this flag is <em>off</em> indicating
+	 * that all of the following character sequences are recognized as line
+	 * terminators: \n, \r, \r\n, NEL (\u0085), \u2028 and \u2029.
+	 * <dt><code>CASE_INSENSITIVE</code> (0x0002)
+	 * <dd>Directs matching to be done in a way that ignores differences in
+	 * case. If input character sequences are encoded in character sets other
+	 * than ASCII, then the UNICODE_CASE must also be set to enable Unicode case
+	 * detection.
+	 * <dt><code>UNICODE_CASE</code> (0x0040)
+	 * <dd>Enables Unicode case folding if used in conjuntion with the
+	 * <code>CASE_INSENSITIVE</code> flag. If <code>CASE_INSENSITIVE</code>
+	 * is not set, then this flag has no effect.
+	 * <dt><code>COMMENTS</code> (0x0004)
+	 * <dd>Directs the pattern compiler to ignore whitespace and comments in
+	 * the pattern. Whitespace consists of sequences including only these
+	 * characters: SP (\u0020), HT (\t or \u0009), LF (\n or ), VT (\u000b), FF
+	 * (\f or \u000c), and CR (\r or ). A comment is any sequence of characters
+	 * beginning with the "#" (\u0023) character and ending in a LF character.
+	 * <dt><code>MULTILINE</code> (0x0008)
+	 * <dd>Turns on multiple line mode for matching of character sequences. By
+	 * default, this mode is off so that the character "^" (\u005e) matches the
+	 * beginning of the entire input sequence and the character "$" (\u0024)
+	 * matches the end of the input character sequence. In multiple line mode,
+	 * the character "^" matches any character in the input sequence which
+	 * immediately follows a line terminator and the character "$" matches any
+	 * character in the input sequence which immediately precedes a line
+	 * terminator.
+	 * <dt><code>DOTALL</code> (0x0020)
+	 * <dd>Enables the DOT (".") character in regular expressions to match line
+	 * terminators. By default, line terminators are not matched by DOT.
+	 * <dt><code>CANON_EQ</code> (0x0080)
+	 * <dd>Enables matching of character sequences which are cacnonically
+	 * equivalent according to the Unicode standard. Canonical equivalence is
+	 * described here: http://www.unicode.org/reports/tr15/. By default,
+	 * canonical equivalence is not detected while matching.
+	 * </dl>
+	 * 
+	 * @param regex
+	 *            A regular expression string.
+	 * @param flags
+	 *            A set of flags to control the compilation of the pattern.
+	 * @return A compiled pattern
+	 * @throws PatternSyntaxException
+	 *             If the input regular expression does not match the required
+	 *             grammar.
+	 */
     public static Pattern compile(String regex, int flags)
             throws PatternSyntaxException {
         AbstractSet.counter = 1;



Mime
View raw message