View Javadoc

1   /*
2    * Copyright 2004-2005 The Apache Software Foundation
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *     http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  
17  package org.apache.commons.net.ftp.parser;
18  import org.apache.commons.net.ftp.FTPFileEntryParserImpl;
19  import org.apache.oro.text.regex.MalformedPatternException;
20  import org.apache.oro.text.regex.MatchResult;
21  import org.apache.oro.text.regex.Pattern;
22  import org.apache.oro.text.regex.PatternMatcher;
23  import org.apache.oro.text.regex.Perl5Compiler;
24  import org.apache.oro.text.regex.Perl5Matcher;
25  
26  
27  
28  /**
29   * This abstract class implements both the older FTPFileListParser and
30   * newer FTPFileEntryParser interfaces with default functionality.
31   * All the classes in the parser subpackage inherit from this.
32   *
33   * This is the base for all regular based FTPFileEntryParser
34   *
35   * @author Steve Cohen <scohen@apache.org>
36   */
37  public abstract class RegexFTPFileEntryParserImpl extends FTPFileEntryParserImpl
38  {
39      /**
40       * internal pattern the matcher tries to match, representing a file
41       * entry
42       */
43      private Pattern pattern = null;
44  
45      /**
46       * internal match result used by the parser
47       */
48      private MatchResult result = null;
49  
50      /**
51       * Internal PatternMatcher object used by the parser.  It has protected
52       * scope in case subclasses want to make use of it for their own purposes.
53       */
54      protected PatternMatcher _matcher_ = null;
55  
56      /**
57       * The constructor for a RegexFTPFileEntryParserImpl object.
58       *
59       * @param regex  The regular expression with which this object is
60       * initialized.
61       *
62       * @exception IllegalArgumentException
63       * Thrown if the regular expression is unparseable.  Should not be seen in
64       * normal conditions.  It it is seen, this is a sign that a subclass has
65       * been created with a bad regular expression.   Since the parser must be
66       * created before use, this means that any bad parser subclasses created
67       * from this will bomb very quickly,  leading to easy detection.
68       */
69  
70      public RegexFTPFileEntryParserImpl(String regex)
71      {
72          super();
73          try
74          {
75              _matcher_ = new Perl5Matcher();
76              pattern   = new Perl5Compiler().compile(regex);
77          }
78          catch (MalformedPatternException e)
79          {
80              throw new IllegalArgumentException (
81                 "Unparseable regex supplied:  " + regex);
82          }
83      }
84  
85      /**
86       * Convenience method delegates to the internal MatchResult's matches()
87       * method.
88       *
89       * @param s the String to be matched
90       * @return true if s matches this object's regular expression.
91       */
92  
93      public boolean matches(String s)
94      {
95          this.result = null;
96          if (_matcher_.matches(s.trim(), this.pattern))
97          {
98              this.result = _matcher_.getMatch();
99          }
100         return null != this.result;
101     }
102 
103 
104 
105     /**
106      * Convenience method delegates to the internal MatchResult's groups()
107      * method.
108      *
109      * @return the number of groups() in the internal MatchResult.
110      */
111 
112     public int getGroupCnt()
113     {
114         if (this.result == null)
115         {
116             return 0;
117         }
118         return this.result.groups();
119     }
120 
121 
122 
123     /**
124      * Convenience method delegates to the internal MatchResult's group()
125      * method.
126      *
127      * @param matchnum match group number to be retrieved
128      *
129      * @return the content of the <code>matchnum'th<code> group of the internal
130      *         match or null if this method is called without a match having
131      *         been made.
132      */
133     public String group(int matchnum)
134     {
135         if (this.result == null)
136         {
137             return null;
138         }
139         return this.result.group(matchnum);
140     }
141 
142     /**
143      * For debugging purposes - returns a string shows each match group by
144      * number.
145      *
146      * @return a string shows each match group by number.
147      */
148 
149     public String getGroupsAsString()
150     {
151         StringBuffer b = new StringBuffer();
152         for (int i = 1; i <= this.result.groups(); i++)
153         {
154             b.append(i).append(") ").append(this.result.group(i))
155                 .append(System.getProperty("line.separator"));
156         }
157         return b.toString();
158     }
159     
160 }
161 
162