    001    /*
    002     * Licensed to the Apache Software Foundation (ASF) under one or more
    003     * contributor license agreements.  See the NOTICE file distributed with
    004     * this work for additional information regarding copyright ownership.
    005     * The ASF licenses this file to You under the Apache License, Version 2.0
    006     * (the "License"); you may not use this file except in compliance with
    007     * the License.  You may obtain a copy of the License at
    008     *
    009     *      http://www.apache.org/licenses/LICENSE-2.0
    010     *
    011     * Unless required by applicable law or agreed to in writing, software
    012     * distributed under the License is distributed on an "AS IS" BASIS,
    013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014     * See the License for the specific language governing permissions and
    015     * limitations under the License.
    016     */
    017
    018
    019    package org.apache.commons.net.ftp.parser;
    020
    021    import java.util.regex.MatchResult;
    022    import java.util.regex.Matcher;
    023    import java.util.regex.Pattern;
    024    import java.util.regex.PatternSyntaxException;
    025
    026    import org.apache.commons.net.ftp.FTPFileEntryParserImpl;
    027
    028    /**
    029     * This abstract class implements both the older FTPFileListParser and
    030     * newer FTPFileEntryParser interfaces with default functionality.
    031     * All the classes in the parser subpackage inherit from this.
    032     *
    033     * This is the base class for all regular expression based FTPFileEntryParser classes
    034     *
    035     * @author Steve Cohen <scohen@apache.org>
    036     */
    037    public abstract class RegexFTPFileEntryParserImpl extends
    038            FTPFileEntryParserImpl {
    039        /**
    040         * internal pattern the matcher tries to match, representing a file
    041         * entry
    042         */
    043        private Pattern pattern = null;
    044
    045        /**
    046         * internal match result used by the parser
    047         */
    048        private MatchResult result = null;
    049
    050        /**
    051         * Internal PatternMatcher object used by the parser.  It has protected
    052         * scope in case subclasses want to make use of it for their own purposes.
    053         */
    054        protected Matcher _matcher_ = null;
    055
    056        /**
    057         * The constructor for a RegexFTPFileEntryParserImpl object.
    058         *
    059         * @param regex  The regular expression with which this object is
    060         * initialized.
    061         *
    062         * @exception IllegalArgumentException
    063         * Thrown if the regular expression is unparseable.  Should not be seen in
    064         * normal conditions.  It it is seen, this is a sign that a subclass has
    065         * been created with a bad regular expression.   Since the parser must be
    066         * created before use, this means that any bad parser subclasses created
    067         * from this will bomb very quickly,  leading to easy detection.
    068         */
    069
    070        public RegexFTPFileEntryParserImpl(String regex) {
    071            super();
    072            setRegex(regex);
    073        }
    074
    075        /**
    076         * Convenience method delegates to the internal MatchResult's matches()
    077         * method.
    078         *
    079         * @param s the String to be matched
    080         * @return true if s matches this object's regular expression.
    081         */
    082
    083        public boolean matches(String s) {
    084            this.result = null;
    085            _matcher_ = pattern.matcher(s);
    086            if (_matcher_.matches()) {
    087                this.result = _matcher_.toMatchResult();
    088            }
    089            return null != this.result;
    090        }
    091
    092        /**
    093         * Convenience method
    094         *
    095         * @return the number of groups() in the internal MatchResult.
    096         */
    097
    098        public int getGroupCnt() {
    099            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            StringBuilder b = new StringBuilder();
    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  true if the compiled pattern is not null
    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    }