    001    /*
    002     * Copyright (c) 2007-2014 Concurrent, Inc. All Rights Reserved.
    003     *
    004     * Project and contact information: http://www.cascading.org/
    005     *
    006     * This file is part of the Cascading project.
    007     *
    008     * Licensed under the Apache License, Version 2.0 (the "License");
    009     * you may not use this file except in compliance with the License.
    010     * You may obtain a copy of the License at
    011     *
    012     *     http://www.apache.org/licenses/LICENSE-2.0
    013     *
    014     * Unless required by applicable law or agreed to in writing, software
    015     * distributed under the License is distributed on an "AS IS" BASIS,
    016     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    017     * See the License for the specific language governing permissions and
    018     * limitations under the License.
    019     */
    020
    021    package cascading.operation.regex;
    022
    023    import java.beans.ConstructorProperties;
    024    import java.util.regex.Pattern;
    025
    026    import cascading.management.annotation.Property;
    027    import cascading.management.annotation.PropertyDescription;
    028    import cascading.management.annotation.Visibility;
    029    import cascading.operation.BaseOperation;
    030    import cascading.tuple.Fields;
    031
    032    /** Class RegexOperation is the base class for all regex Operations. */
    033    public class RegexOperation<C> extends BaseOperation<C>
    034      {
    035      /** Field patternString */
    036      protected String patternString = ".*";
    037
    038      /** Constructor RegexOperation creates a new RegexOperation instance. */
    039      public RegexOperation()
    040        {
    041        }
    042
    043      /**
    044       * Constructor RegexOperation creates a new RegexOperation instance.
    045       *
    046       * @param numArgs of type int
    047       */
    048      @ConstructorProperties({"numArgs"})
    049      public RegexOperation( int numArgs )
    050        {
    051        super( numArgs );
    052        }
    053
    054      /**
    055       * Constructor RegexOperation creates a new RegexOperation instance.
    056       *
    057       * @param fieldDeclaration of type Fields
    058       */
    059      @ConstructorProperties({"fieldDeclaration"})
    060      public RegexOperation( Fields fieldDeclaration )
    061        {
    062        super( fieldDeclaration );
    063        }
    064
    065      /**
    066       * Constructor RegexOperation creates a new RegexOperation instance.
    067       *
    068       * @param numArgs       of type int
    069       * @param patternString of type String
    070       */
    071      @ConstructorProperties({"numArgs", "patternString"})
    072      public RegexOperation( int numArgs, String patternString )
    073        {
    074        super( numArgs );
    075        this.patternString = patternString;
    076        }
    077
    078      /**
    079       * Constructor RegexOperation creates a new RegexOperation instance.
    080       *
    081       * @param patternString of type String
    082       */
    083      @ConstructorProperties({"patternString"})
    084      public RegexOperation( String patternString )
    085        {
    086        this.patternString = patternString;
    087        }
    088
    089      /**
    090       * Constructor RegexOperation creates a new RegexOperation instance.
    091       *
    092       * @param numArgs          of type int
    093       * @param fieldDeclaration of type Fields
    094       */
    095      @ConstructorProperties({"numArgs", "fieldDeclaration"})
    096      public RegexOperation( int numArgs, Fields fieldDeclaration )
    097        {
    098        super( numArgs, fieldDeclaration );
    099        }
    100
    101      /**
    102       * Constructor RegexOperation creates a new RegexOperation instance.
    103       *
    104       * @param numArgs          of type int
    105       * @param fieldDeclaration of type Fields
    106       * @param patternString    of type String
    107       */
    108      @ConstructorProperties({"numArgs", "fieldDeclaration", "patternString"})
    109      public RegexOperation( int numArgs, Fields fieldDeclaration, String patternString )
    110        {
    111        super( numArgs, fieldDeclaration );
    112        this.patternString = patternString;
    113        }
    114
    115      /**
    116       * Method getPatternString returns the patternString of this RegexOperation object.
    117       *
    118       * @return the patternString (type String) of this RegexOperation object.
    119       */
    120      @Property(name = "patternString", visibility = Visibility.PRIVATE)
    121      @PropertyDescription("The regular expression pattern string.")
    122      public final String getPatternString()
    123        {
    124        return patternString;
    125        }
    126
    127      /**
    128       * Method getPattern returns the pattern of this RegexOperation object.
    129       *
    130       * @return the pattern (type Pattern) of this RegexOperation object.
    131       */
    132      protected Pattern getPattern()
    133        {
    134        return Pattern.compile( getPatternString() );
    135        }
    136
    137      @Override
    138      public boolean equals( Object object )
    139        {
    140        if( this == object )
    141          return true;
    142        if( !( object instanceof RegexOperation ) )
    143          return false;
    144        if( !super.equals( object ) )
    145          return false;
    146
    147        RegexOperation that = (RegexOperation) object;
    148
    149        if( patternString != null ? !patternString.equals( that.patternString ) : that.patternString != null )
    150          return false;
    151
    152        return true;
    153        }
    154
    155      @Override
    156      public int hashCode()
    157        {
    158        int result = super.hashCode();
    159        result = 31 * result + ( patternString != null ? patternString.hashCode() : 0 );
    160        return result;
    161        }
    162      }