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;
022
023 import java.util.Iterator;
024
025 import cascading.pipe.joiner.JoinerClosure;
026 import cascading.tuple.Fields;
027 import cascading.tuple.TupleEntry;
028 import cascading.tuple.TupleEntryCollector;
029
030 /**
031 * Class OperationCall is the common base class for {@link FunctionCall}, {@link FilterCall},
032 * {@link AggregatorCall}, {@link ValueAssertionCall}, and {@link GroupAssertionCall}.
033 */
034 public class ConcreteCall<C> implements FunctionCall<C>, FilterCall<C>, AggregatorCall<C>, BufferCall<C>, ValueAssertionCall<C>, GroupAssertionCall<C>
035 {
036 /** Field context */
037 private C context;
038 /** Field group */
039 private TupleEntry group;
040 /** Field argumentFields */
041 private Fields argumentFields;
042 /** Field arguments */
043 private TupleEntry arguments;
044 /** Field argumentsIterator */
045 private Iterator<TupleEntry> argumentsIterator;
046 /** Field declaredFields */
047 private Fields declaredFields;
048 /** Field outputCollector */
049 private TupleEntryCollector outputCollector;
050 /** Field retainValues */
051 private boolean retainValues = false;
052 /** Fields joinerClosure * */
053 private JoinerClosure joinerClosure;
054
055 /** Constructor OperationCall creates a new OperationCall instance. */
056 public ConcreteCall()
057 {
058 }
059
060 /**
061 * Constructor ConcreteCall creates a new ConcreteCall instance.
062 *
063 * @param argumentFields of type Fields
064 */
065 public ConcreteCall( Fields argumentFields )
066 {
067 this.argumentFields = argumentFields;
068 }
069
070 /**
071 * Constructor ConcreteCall creates a new ConcreteCall instance.
072 *
073 * @param argumentFields of type Fields
074 * @param declaredFields of type Fields
075 */
076 public ConcreteCall( Fields argumentFields, Fields declaredFields )
077 {
078 this.argumentFields = argumentFields;
079 this.declaredFields = declaredFields;
080 }
081
082 /**
083 * Constructor OperationCall creates a new OperationCall instance.
084 *
085 * @param arguments of type TupleEntry
086 * @param outputCollector of type TupleCollector
087 */
088 public ConcreteCall( TupleEntry arguments, TupleEntryCollector outputCollector )
089 {
090 this.arguments = arguments;
091 this.outputCollector = outputCollector;
092 }
093
094 public ConcreteCall( ConcreteCall<C> concreteCall )
095 {
096 this.arguments = concreteCall.arguments;
097 this.argumentFields = concreteCall.argumentFields;
098 this.argumentsIterator = concreteCall.argumentsIterator;
099 this.context = concreteCall.context;
100 this.declaredFields = concreteCall.declaredFields;
101 this.outputCollector = concreteCall.outputCollector;
102 this.retainValues = concreteCall.retainValues;
103 this.joinerClosure = concreteCall.joinerClosure;
104 }
105
106 /** @see AggregatorCall#getContext() */
107 public C getContext()
108 {
109 return context;
110 }
111
112 public void setContext( C context )
113 {
114 this.context = context;
115 }
116
117 /** @see AggregatorCall#getGroup() */
118 public TupleEntry getGroup()
119 {
120 return group;
121 }
122
123 public void setGroup( TupleEntry group )
124 {
125 this.group = group;
126 }
127
128 public Fields getArgumentFields()
129 {
130 return argumentFields;
131 }
132
133 public void setArgumentFields( Fields argumentFields )
134 {
135 this.argumentFields = argumentFields;
136 }
137
138 /** @see BufferCall#getArgumentsIterator() */
139 public Iterator<TupleEntry> getArgumentsIterator()
140 {
141 return argumentsIterator;
142 }
143
144 public void setArgumentsIterator( Iterator<TupleEntry> argumentsIterator )
145 {
146 this.argumentsIterator = argumentsIterator;
147 }
148
149 /** @see FunctionCall#getArguments() */
150 public TupleEntry getArguments()
151 {
152 return arguments;
153 }
154
155 public void setArguments( TupleEntry arguments )
156 {
157 this.arguments = arguments;
158 }
159
160 public Fields getDeclaredFields()
161 {
162 return declaredFields;
163 }
164
165 /** @see FunctionCall#getOutputCollector() */
166 public TupleEntryCollector getOutputCollector()
167 {
168 return outputCollector;
169 }
170
171 public void setOutputCollector( TupleEntryCollector outputCollector )
172 {
173 this.outputCollector = outputCollector;
174 }
175
176 @Override
177 public void setRetainValues( boolean retainValues )
178 {
179 this.retainValues = retainValues;
180 }
181
182 @Override
183 public boolean isRetainValues()
184 {
185 return retainValues;
186 }
187
188 public void setJoinerClosure( JoinerClosure joinerClosure )
189 {
190 this.joinerClosure = joinerClosure;
191 }
192
193 @Override
194 public JoinerClosure getJoinerClosure()
195 {
196 return joinerClosure;
197 }
198 }