    001/*
    002 * Copyright (c) 2007-2016 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
    021package cascading.operation.state;
    022
    023import java.beans.ConstructorProperties;
    024
    025import cascading.flow.FlowProcess;
    026import cascading.operation.BaseOperation;
    027import cascading.operation.Filter;
    028import cascading.operation.FilterCall;
    029
    030/**
    031 * Class Counter is a {@link Filter} that increments a given {@link Enum} counter by 1 or by the given {@code increment} value.
    032 * <p/>
    033 * Internally, the {@link #isRemove(cascading.flow.FlowProcess, cascading.operation.FilterCall)} method calls
    034 * {@link FlowProcess#increment(Enum, long)}.
    035 * <p/>
    036 * No {@link cascading.tuple.Tuple} instances are ever discarded.
    037 *
    038 * @see FlowProcess
    039 * @see Filter
    040 */
    041public class Counter extends BaseOperation implements Filter
    042  {
    043  private final Enum counterEnum;
    044  private final String groupString;
    045  private final String counterString;
    046  private final int increment;
    047
    048  /**
    049   * Constructor Counter creates a new Counter instance.
    050   *
    051   * @param counter of type Enum
    052   */
    053  @ConstructorProperties({"counter"})
    054  public Counter( Enum counter )
    055    {
    056    this( counter, 1 );
    057    }
    058
    059  /**
    060   * Constructor Counter creates a new Counter instance.
    061   *
    062   * @param counter   of type Enum
    063   * @param increment of type int
    064   */
    065  @ConstructorProperties({"counter", "increment"})
    066  public Counter( Enum counter, int increment )
    067    {
    068    this.counterEnum = counter;
    069    this.groupString = null;
    070    this.counterString = null;
    071    this.increment = increment;
    072    }
    073
    074  @ConstructorProperties({"group", "counter"})
    075  public Counter( String group, String counter )
    076    {
    077    this( group, counter, 1 );
    078    }
    079
    080  @ConstructorProperties({"group", "counter", "increment"})
    081  public Counter( String group, String counter, int increment )
    082    {
    083    this.counterEnum = null;
    084    this.groupString = group;
    085    this.counterString = counter;
    086    this.increment = increment;
    087    }
    088
    089  public Enum getCounterEnum()
    090    {
    091    return counterEnum;
    092    }
    093
    094  public String getGroupString()
    095    {
    096    return groupString;
    097    }
    098
    099  public String getCounterString()
    100    {
    101    return counterString;
    102    }
    103
    104  public int getIncrement()
    105    {
    106    return increment;
    107    }
    108
    109  @Override
    110  public boolean isRemove( FlowProcess flowProcess, FilterCall filterCall )
    111    {
    112    if( counterEnum != null )
    113      flowProcess.increment( counterEnum, increment );
    114    else
    115      flowProcess.increment( groupString, counterString, increment );
    116
    117    return false;
    118    }
    119
    120  @Override
    121  public boolean equals( Object object )
    122    {
    123    if( this == object )
    124      return true;
    125    if( !( object instanceof Counter ) )
    126      return false;
    127    if( !super.equals( object ) )
    128      return false;
    129
    130    Counter counter = (Counter) object;
    131
    132    if( increment != counter.increment )
    133      return false;
    134    if( counterEnum != null ? !counterEnum.equals( counter.counterEnum ) : counter.counterEnum != null )
    135      return false;
    136    if( counterString != null ? !counterString.equals( counter.counterString ) : counter.counterString != null )
    137      return false;
    138    if( groupString != null ? !groupString.equals( counter.groupString ) : counter.groupString != null )
    139      return false;
    140
    141    return true;
    142    }
    143
    144  @Override
    145  public int hashCode()
    146    {
    147    int result = super.hashCode();
    148    result = 31 * result + ( counterEnum != null ? counterEnum.hashCode() : 0 );
    149    result = 31 * result + ( groupString != null ? groupString.hashCode() : 0 );
    150    result = 31 * result + ( counterString != null ? counterString.hashCode() : 0 );
    151    result = 31 * result + increment;
    152    return result;
    153    }
    154  }