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 }