1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18
19 package org.apache.commons.net.ftp.parser;
20
21 import java.util.regex.MatchResult;
22 import java.util.regex.Matcher;
23 import java.util.regex.Pattern;
24 import java.util.regex.PatternSyntaxException;
25
26 import org.apache.commons.net.ftp.FTPFileEntryParserImpl;
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
38 FTPFileEntryParserImpl {
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 Matcher _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 super();
72 setRegex(regex);
73 }
74
75 /**
76 * Convenience method delegates to the internal MatchResult's matches()
77 * method.
78 *
79 * @param s the String to be matched
80 * @return true if s matches this object's regular expression.
81 */
82
83 public boolean matches(String s) {
84 this.result = null;
85 _matcher_ = pattern.matcher(s);
86 if (_matcher_.matches()) {
87 this.result = _matcher_.toMatchResult();
88 }
89 return null != this.result;
90 }
91
92 /**
93 * Convenience method
94 *
95 * @return the number of groups() in the internal MatchResult.
96 */
97
98 public int getGroupCnt() {
99 if (this.result == null) {
100 return 0;
101 }
102 return this.result.groupCount();
103 }
104
105 /**
106 * Convenience method delegates to the internal MatchResult's group()
107 * method.
108 *
109 * @param matchnum match group number to be retrieved
110 *
111 * @return the content of the <code>matchnum'th<code> group of the internal
112 * match or null if this method is called without a match having
113 * been made.
114 */
115 public String group(int matchnum) {
116 if (this.result == null) {
117 return null;
118 }
119 return this.result.group(matchnum);
120 }
121
122 /**
123 * For debugging purposes - returns a string shows each match group by
124 * number.
125 *
126 * @return a string shows each match group by number.
127 */
128
129 public String getGroupsAsString() {
130 StringBuffer b = new StringBuffer();
131 for (int i = 1; i <= this.result.groupCount(); i++) {
132 b.append(i).append(") ").append(this.result.group(i)).append(
133 System.getProperty("line.separator"));
134 }
135 return b.toString();
136 }
137
138 /**
139 * Alter the current regular expression being utilised for entry parsing
140 * and create a new {@link Pattern} instance.
141 * @param regex The new regular expression
142 * @return
143 * @since 2.0
144 */
145 public boolean setRegex(String regex) {
146 try {
147 pattern = Pattern.compile(regex);
148 } catch (PatternSyntaxException pse) {
149 throw new IllegalArgumentException("Unparseable regex supplied: "
150 + regex);
151 }
152 return (pattern != null);
153 }
154
155 }