scalding

Type Members

1. sealed abstract class AccessMode extends AnyRef

2. class AdaptiveMapsideCache[K, V] extends MapsideCache[K, V]

3. trait ArgHelper extends AnyRef

4. trait BaseNullSource extends Source

5. case class BooleanArg(key: String, description: String) extends DescribedArg with Product with Serializable

6. class BufferOp[I, T, X] extends BaseOperation[Any] with Buffer[Any] with ScaldingPrepare[Any]

7. abstract class CascadeJob extends Job

8. class CascadeTest extends JobTest

9. trait CascadingLocal extends Mode

10. trait CaseClassPackers extends LowPriorityTuplePackers

11. class CleanupIdentityFunction extends BaseOperation[Any] with Function[Any] with ScaldingPrepare[Any]

12. class CoGroupBuilder extends GroupBuilder

    Builder classes used internally to implement coGroups (joins).

13. class CollectFunction[S, T] extends BaseOperation[Any] with Function[Any] with ScaldingPrepare[Any]

14. trait Config extends Serializable

    This is a wrapper class on top of Map[String, String]

15. trait CounterVerification extends Job

    Allows custom counter verification logic when the job completes.

16. case class Csv(p: String, separator: String = ",", fields: Fields = cascading.tuple.Fields.ALL, skipHeader: Boolean = false, writeHeader: Boolean = false, quote: String = "\"", sinkMode: SinkMode = cascading.tap.SinkMode.REPLACE) extends FixedPathSource with DelimitedScheme with Product with Serializable

    Csv value source separated by commas and quotes wrapping all fields

17. trait DefaultDateRangeJob extends Job

    Sets up an implicit dateRange to use in your sources and an implicit timezone.

18. trait DelimitedScheme extends SchemedSource

    Mix this in for delimited schemes such as TSV or one-separated values By default, TSV is given

19. sealed trait DescribedArg extends AnyRef

20. class DescriptionValidationException extends RuntimeException

21. sealed trait Execution[+T] extends Serializable

    Execution[T] represents and computation that can be run and will produce a value T and keep track of counters incremented inside of TypedPipes using a Stat.

22. trait ExecutionApp extends Serializable

23. trait ExecutionContext extends AnyRef

24. trait ExecutionCounters extends AnyRef

    This represents the counters portion of the JobStats that are returned.

25. abstract class ExecutionJob[+T] extends Job

    This is a simple job that allows you to launch Execution[T] instances using scalding.

26. sealed trait Field[T] extends Serializable

27. trait FieldConversions extends LowPriorityFieldConversions

28. abstract class FileSource extends SchemedSource with LocalSourceOverride with HfsTapProvider

    This is a base class for File-based sources

29. class FilterFunction[T] extends BaseOperation[Any] with Filter[Any] with ScaldingPrepare[Any]

30. abstract class FixedPathSource extends FileSource

31. class FlatMapFunction[S, T] extends BaseOperation[Any] with Function[Any] with ScaldingPrepare[Any]

32. case class FlowState(sourceMap: Map[String, Source] = ..., flowConfigUpdates: Set[(String, String)] = ...) extends Product with Serializable

    Immutable state that we attach to the Flow using the FlowStateMap

33. class FoldAggregator[T, X] extends BaseOperation[X] with Aggregator[X] with ScaldingPrepare[X]

34. abstract class FoldFunctor[X] extends Functor

    This handles the mapReduceMap work on the map-side of the operation.

35. trait FoldOperations[+Self <: FoldOperations[Self]] extends ReduceOperations[Self] with Sortable[Self]

    Implements reductions on top of a simple abstraction for the Fields-API We use the f-bounded polymorphism trick to return the type called Self in each operation.

36. class FutureCache[-K, V] extends AnyRef

    This is a map for values that are produced in futures as is common in Execution

37. trait GeneratedTupleAdders extends AnyRef

38. trait GeneratedTupleConverters extends LowPriorityTupleConverters

39. trait GeneratedTupleSetters extends LowPriorityTupleSetters

40. class GroupBuilder extends FoldOperations[GroupBuilder] with StreamOperations[GroupBuilder]

    This controls the sequence of reductions that happen inside a particular grouping operation.

41. type Grouped[K, +V] = scalding.typed.Grouped[K, V]

42. case class HadoopArgs(toArray: Array[String]) extends Product with Serializable

43. trait HadoopMode extends Mode

44. case class HadoopTest(conf: Configuration, buffers: (Source) ⇒ Option[Buffer[Tuple]]) extends HadoopMode with TestMode with Product with Serializable

45. case class Hdfs(strict: Boolean, conf: Configuration) extends HadoopMode with Product with Serializable

46. class HelpException extends RuntimeException

47. trait HfsConfPropertySetter extends HfsTapProvider

48. trait HfsTapProvider extends AnyRef

49. case class IntField[T](id: Integer)(implicit ord: Ordering[T], mf: Option[Manifest[T]]) extends Field[T] with Product with Serializable

    Annotations

    @DefaultSerializer()

50. class IntegralComparator extends Comparator[AnyRef] with Hasher[AnyRef] with Serializable

51. class InvalidJoinModeException extends Exception

52. class InvalidSourceException extends RuntimeException

    thrown when validateTaps fails

53. class InvalidSourceTap extends SourceTap[JobConf, RecordReader[_, _]]

    InvalidSourceTap used in createTap method when we want to defer the failures to validateTaps method.

54. case class IterableSource[+T](iter: Iterable[T], inFields: Fields = cascading.tuple.Fields.NONE)(implicit set: TupleSetter[T], conv: TupleConverter[T]) extends Source with Mappable[T] with Product with Serializable

    Allows working with an iterable object defined in the job (on the submitter) to be used within a Job as you would a Pipe/RichPipe

55. class Job extends FieldConversions with Serializable

    Job is a convenience class to make using Scalding easier.

56. case class JobStats(toMap: Map[String, Any]) extends Product with Serializable

57. class JobTest extends AnyRef

    This class is used to construct unit tests for scalding jobs.

58. trait JoinAlgorithms extends AnyRef

59. sealed abstract class JoinMode extends AnyRef

60. type KeyedList[K, +V] = scalding.typed.KeyedList[K, V]

61. case class ListArg(key: String, description: String) extends DescribedArg with Product with Serializable

62. case class Local(strictSources: Boolean) extends CascadingLocal with Product with Serializable

63. trait LocalSourceOverride extends SchemedSource

    A trait which provides a method to create a local tap.

64. trait LocalTapSource extends SchemedSource with LocalSourceOverride

    Use this class to add support for Cascading local mode via the Hadoop tap.

65. trait LowPriorityFieldConversions extends AnyRef

66. trait LowPriorityTupleConverters extends Serializable

67. trait LowPriorityTupleGetter extends Serializable

68. trait LowPriorityTuplePackers extends Serializable

69. trait LowPriorityTupleSetters extends Serializable

70. trait LowPriorityTupleUnpackers extends AnyRef

71. class MRMAggregator[T, X, U] extends BaseOperation[Tuple] with Aggregator[Tuple] with ScaldingPrepare[Tuple]

72. class MRMBy[T, X, U] extends AggregateBy

    MapReduceMapBy Class

73. class MRMFunctor[T, X] extends FoldFunctor[X]

    This handles the mapReduceMap work on the map-side of the operation.

74. class MapFunction[S, T] extends BaseOperation[Any] with Function[Any] with ScaldingPrepare[Any]

75. trait Mappable[+T] extends Source with TypedSource[T]

    Usually as soon as we open a source, we read and do some mapping operation on a single column or set of columns.

76. trait Mappable1[A] extends Source with Mappable[(A)]

77. trait Mappable10[A, B, C, D, E, F, G, H, I, J] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J)]

78. trait Mappable11[A, B, C, D, E, F, G, H, I, J, K] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K)]

79. trait Mappable12[A, B, C, D, E, F, G, H, I, J, K, L] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L)]

80. trait Mappable13[A, B, C, D, E, F, G, H, I, J, K, L, M] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L, M)]

81. trait Mappable14[A, B, C, D, E, F, G, H, I, J, K, L, M, N] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]

82. trait Mappable15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]

83. trait Mappable16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]

84. trait Mappable17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]

85. trait Mappable18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]

86. trait Mappable19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

87. trait Mappable2[A, B] extends Source with Mappable[(A, B)]

88. trait Mappable20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]

89. trait Mappable21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]

90. trait Mappable22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]

91. trait Mappable3[A, B, C] extends Source with Mappable[(A, B, C)]

92. trait Mappable4[A, B, C, D] extends Source with Mappable[(A, B, C, D)]

93. trait Mappable5[A, B, C, D, E] extends Source with Mappable[(A, B, C, D, E)]

94. trait Mappable6[A, B, C, D, E, F] extends Source with Mappable[(A, B, C, D, E, F)]

95. trait Mappable7[A, B, C, D, E, F, G] extends Source with Mappable[(A, B, C, D, E, F, G)]

96. trait Mappable8[A, B, C, D, E, F, G, H] extends Source with Mappable[(A, B, C, D, E, F, G, H)]

97. trait Mappable9[A, B, C, D, E, F, G, H, I] extends Source with Mappable[(A, B, C, D, E, F, G, H, I)]

98. sealed trait MapsideCache[K, V] extends AnyRef

99. class MapsideReduce[V] extends BaseOperation[MapsideCache[Tuple, V]] with Function[MapsideCache[Tuple, V]] with ScaldingPrepare[MapsideCache[Tuple, V]]

100. class MemoryTap[In, Out] extends Tap[Properties, In, Out]

101. class MemoryTupleEntryCollector extends TupleEntryCollector

102. trait Mode extends Serializable

103. case class ModeException(message: String) extends RuntimeException with Product with Serializable

104. case class ModeLoadException(message: String, origin: ClassNotFoundException) extends RuntimeException with Product with Serializable

105. abstract class MostRecentGoodSource extends TimePathedSource

106. case class MultipleDelimitedFiles(f: Fields, separator: String, quote: String, skipHeader: Boolean, writeHeader: Boolean, p: String*) extends FixedPathSource with DelimitedScheme with Product with Serializable

     Delimited files source allowing to override separator and quotation characters and header configuration

107. case class MultipleSequenceFiles(p: String*) extends FixedPathSource with SequenceFileScheme with LocalTapSource with Product with Serializable

108. case class MultipleTextLineFiles(p: String*) extends FixedPathSource with TextLineScheme with Product with Serializable

109. case class MultipleTsvFiles(p: Seq[String], fields: Fields = cascading.tuple.Fields.ALL, skipHeader: Boolean = false, writeHeader: Boolean = false) extends FixedPathSource with DelimitedScheme with Product with Serializable

     Allows the use of multiple Tsv input paths.

110. case class MultipleWritableSequenceFiles[K <: Writable, V <: Writable](p: Seq[String], f: Fields)(implicit evidence$7: Manifest[K], evidence$8: Manifest[V]) extends FixedPathSource with WritableSequenceFileScheme with LocalTapSource with TypedSource[(K, V)] with Product with Serializable

     This is only a TypedSource as sinking into multiple directories is not well defined

111. class NamedPoolThreadFactory extends ThreadFactory

112. case class NonHadoopArgs(toArray: Array[String]) extends Product with Serializable

113. class NullTap[Config, Input, Output, SourceContext, SinkContext] extends SinkTap[Config, Output]

     A tap that output nothing.

114. class OffsetTextLine extends FixedPathSource with Mappable[(Long, String)] with TextSourceScheme

     Alternate typed TextLine source that keeps both 'offset and 'line fields.

115. case class OptionalArg(key: String, description: String) extends DescribedArg with Product with Serializable

116. case class OptionalSource[T](src: Mappable[T]) extends Source with Mappable[T] with Product with Serializable

117. class OrderedConstructorConverter[T] extends TupleConverter[T]

118. class OrderedTuplePacker[T] extends TuplePacker[T]

     This just blindly uses the first public constructor with the same arity as the fields size

119. case class Osv(p: String, f: Fields = cascading.tuple.Fields.ALL, sinkMode: SinkMode = cascading.tap.SinkMode.REPLACE) extends FixedPathSource with DelimitedScheme with Product with Serializable

     One separated value (commonly used by Pig)

120. abstract class PartitionSource extends SchemedSource with HfsTapProvider

     This is a base class for partition-based output sources

121. case class PartitionedSequenceFile(basePath: String, partition: Partition, sequenceFields: Fields, sinkMode: SinkMode) extends PartitionSource with SequenceFileScheme with Product with Serializable

     An implementation of SequenceFile output, split over a partition tap.

122. case class PartitionedTsv(basePath: String, partition: Partition, writeHeader: Boolean, tsvFields: Fields, sinkMode: SinkMode) extends PartitionSource with DelimitedScheme with Product with Serializable

     An implementation of TSV output, split over a partition tap.

123. case class PipeDebug(output: Output = ..., prefix: String = null, printFieldsEvery: Option[Int] = scala.None, printTuplesEvery: Int = 1) extends Product with Serializable

     This is a builder for Cascading's Debug object.

124. trait ReduceOperations[+Self <: ReduceOperations[Self]] extends Serializable

     Implements reductions on top of a simple abstraction for the Fields-API This is for associative and commutive operations (particularly Monoids and Semigroups play a big role here)

125. class ReflectionSetter[T] extends TupleSetter[T]

126. class ReflectionTupleConverter[T] extends TupleConverter[T]

127. class ReflectionTuplePacker[T] extends TuplePacker[T]

     Packs a tuple into any object with set methods, e.

128. class ReflectionTupleUnpacker[T] extends TupleUnpacker[T]

129. case class RequiredArg(key: String, description: String) extends DescribedArg with Product with Serializable

130. case class RichFields(toFieldList: List[Field[_]]) extends Fields with Product with Serializable

131. class RichFlowDef extends AnyRef

     This is an enrichment-pattern class for cascading.

132. class RichPathFilter extends AnyRef

133. class RichPipe extends Serializable with JoinAlgorithms

     This is an enrichment-pattern class for cascading.

134. class SampleWithReplacement extends BaseOperation[Poisson] with Function[Poisson] with ScaldingPrepare[Poisson]

135. class ScaldingMultiSourceTap extends MultiSourceTap[Tap[JobConf, RecordReader[_, _], OutputCollector[_, _]], JobConf, RecordReader[_, _]]

136. trait ScaldingPrepare[C] extends Operation[C]

137. class ScanLeftIterator[T, U] extends Iterator[U] with Serializable

     Scala 2.

138. abstract class SchemedSource extends Source

     A base class for sources that take a scheme trait.

139. class ScriptJob extends Job

140. case class SequenceFile(p: String, f: Fields = cascading.tuple.Fields.ALL, sinkMode: SinkMode = cascading.tap.SinkMode.REPLACE) extends FixedPathSource with SequenceFileScheme with LocalTapSource with Product with Serializable

141. trait SequenceFileScheme extends SchemedSource

142. abstract class SideEffectBaseOperation[C] extends BaseOperation[C] with ScaldingPrepare[C]

143. class SideEffectBufferOp[I, T, C, X] extends SideEffectBaseOperation[C] with Buffer[C]

144. class SideEffectFlatMapFunction[S, C, T] extends SideEffectBaseOperation[C] with Function[C]

145. class SideEffectMapFunction[S, C, T] extends SideEffectBaseOperation[C] with Function[C]

146. trait SingleMappable[T] extends Source with Mappable[T]

     Mappable extension that defines the proper converter implementation for a Mappable with a single item.

147. sealed abstract class SkewReplication extends AnyRef

     Represents a strategy for replicating rows when performing skewed joins.

148. case class SkewReplicationA(replicationFactor: Int = 1) extends SkewReplication with Product with Serializable

     See https://github.

149. case class SkewReplicationB(maxKeysInMemory: Int = 1000000.0.toInt, maxReducerOutput: Int = 1.0E7.toInt) extends SkewReplication with Product with Serializable

     See https://github.

150. trait Sortable[+Self] extends AnyRef

151. abstract class Source extends Serializable

     Every source must have a correct toString method.

152. trait Stat extends Serializable

153. case class StatKey(counter: String, group: String) extends Serializable with Product with Serializable

154. trait Stateful extends AnyRef

     A simple trait for releasable resource.

155. class StatsFlowListener extends FlowListener

     FlowListener that checks counter values against a function.

156. trait StreamOperations[+Self <: StreamOperations[Self]] extends Sortable[Self] with Serializable

     Implements reductions on top of a simple abstraction for the Fields-API We use the f-bounded polymorphism trick to return the type called Self in each operation.

157. case class StringField[T](id: String)(implicit ord: Ordering[T], mf: Option[Manifest[T]]) extends Field[T] with Product with Serializable

     Annotations

     @DefaultSerializer()

158. trait SuccessFileSource extends FileSource

     Ensures that a _SUCCESS file is present in every directory included by a glob, as well as the requirements of FileSource.pathIsGood.

159. class SummingMapsideCache[K, V] extends MapsideCache[K, V]

160. abstract class TemplateSource extends SchemedSource with HfsTapProvider

     This is a base class for template based output sources

161. case class TemplatedSequenceFile(basePath: String, template: String, sequenceFields: Fields = cascading.tuple.Fields.ALL, pathFields: Fields = cascading.tuple.Fields.ALL, sinkMode: SinkMode = cascading.tap.SinkMode.REPLACE) extends TemplateSource with SequenceFileScheme with Product with Serializable

     An implementation of SequenceFile output, split over a template tap.

162. case class TemplatedTsv(basePath: String, template: String, pathFields: Fields = cascading.tuple.Fields.ALL, writeHeader: Boolean = false, sinkMode: SinkMode = cascading.tap.SinkMode.REPLACE, fields: Fields = cascading.tuple.Fields.ALL) extends TemplateSource with DelimitedScheme with Product with Serializable

     An implementation of TSV output, split over a template tap.

163. case class Test(buffers: (Source) ⇒ Option[Buffer[Tuple]]) extends TestMode with CascadingLocal with Product with Serializable

     Memory only testing for unit tests

164. trait TestMode extends Mode

165. class TestTapFactory extends Serializable

166. class TextLine extends FixedPathSource with TextLineScheme

167. trait TextLineScheme extends SchemedSource with TextSourceScheme with SingleMappable[String]

168. trait TextSourceScheme extends SchemedSource

     The fields here are ('offset, 'line)

169. abstract class TimePathedSource extends TimeSeqPathedSource

     This will automatically produce a globbed version of the given path.

170. abstract class TimeSeqPathedSource extends FileSource

171. class Tool extends Configured with org.apache.hadoop.util.Tool

172. case class Tsv(p: String, fields: Fields = cascading.tuple.Fields.ALL, skipHeader: Boolean = false, writeHeader: Boolean = false, sinkMode: SinkMode = cascading.tap.SinkMode.REPLACE) extends FixedPathSource with DelimitedScheme with Product with Serializable

     Tab separated value source

173. trait TupleArity extends AnyRef

     Mixed in to both TupleConverter and TupleSetter to improve arity safety of cascading jobs before we run anything on Hadoop.

174. trait TupleConverter[T] extends Serializable with TupleArity

     Typeclass to represent converting from cascading TupleEntry to some type T.

175. trait TupleGetter[T] extends Serializable

     Typeclass roughly equivalent to a Lens, which allows getting items out of a tuple.

176. trait TuplePacker[T] extends Serializable

     Typeclass for packing a cascading Tuple into some type T, this is used to put fields of a cascading tuple into Thrift, Protobuf, or case classes, for instance, but you can add your own instances to control how this is done.

177. trait TupleSetter[T] extends Serializable with TupleArity

     Typeclass to represent converting back to (setting into) a cascading Tuple This looks like it can be contravariant, but it can't because of our approach of falling back to the singleSetter, you really want the most specific setter you can get.

178. trait TupleUnpacker[T] extends Serializable

179. class TupleUnpackerException extends Exception

180. trait TypeDescriptor[T] extends Serializable

     This class is used to bind together a Fields instance which may contain a type array via getTypes, a TupleConverter and TupleSetter, which are inverses of one another.

181. class TypedBufferOp[K, V, U] extends BaseOperation[Any] with Buffer[Any] with ScaldingPrepare[Any]

     In the typed API every reduce operation is handled by this Buffer

182. class TypedMapsideReduce[K, V] extends BaseOperation[MapsideCache[K, V]] with Function[MapsideCache[K, V]] with ScaldingPrepare[MapsideCache[K, V]]

183. type TypedPipe[+T] = scalding.typed.TypedPipe[T]

184. trait TypedSeperatedFile extends Serializable

     Trait to assist with creating objects such as TypedTsv to read from separated files.

185. type TypedSink[-T] = scalding.typed.TypedSink[T]

186. trait TypedSink1[A] extends TypedSink[(A)]

187. trait TypedSink10[A, B, C, D, E, F, G, H, I, J] extends TypedSink[(A, B, C, D, E, F, G, H, I, J)]

188. trait TypedSink11[A, B, C, D, E, F, G, H, I, J, K] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K)]

189. trait TypedSink12[A, B, C, D, E, F, G, H, I, J, K, L] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L)]

190. trait TypedSink13[A, B, C, D, E, F, G, H, I, J, K, L, M] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L, M)]

191. trait TypedSink14[A, B, C, D, E, F, G, H, I, J, K, L, M, N] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]

192. trait TypedSink15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]

193. trait TypedSink16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]

194. trait TypedSink17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]

195. trait TypedSink18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]

196. trait TypedSink19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

197. trait TypedSink2[A, B] extends TypedSink[(A, B)]

198. trait TypedSink20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]

199. trait TypedSink21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]

200. trait TypedSink22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]

201. trait TypedSink3[A, B, C] extends TypedSink[(A, B, C)]

202. trait TypedSink4[A, B, C, D] extends TypedSink[(A, B, C, D)]

203. trait TypedSink5[A, B, C, D, E] extends TypedSink[(A, B, C, D, E)]

204. trait TypedSink6[A, B, C, D, E, F] extends TypedSink[(A, B, C, D, E, F)]

205. trait TypedSink7[A, B, C, D, E, F, G] extends TypedSink[(A, B, C, D, E, F, G)]

206. trait TypedSink8[A, B, C, D, E, F, G, H] extends TypedSink[(A, B, C, D, E, F, G, H)]

207. trait TypedSink9[A, B, C, D, E, F, G, H, I] extends TypedSink[(A, B, C, D, E, F, G, H, I)]

208. type TypedSource[+T] = scalding.typed.TypedSource[T]

209. trait TypedSource1[A] extends TypedSource[(A)]

210. trait TypedSource10[A, B, C, D, E, F, G, H, I, J] extends TypedSource[(A, B, C, D, E, F, G, H, I, J)]

211. trait TypedSource11[A, B, C, D, E, F, G, H, I, J, K] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K)]

212. trait TypedSource12[A, B, C, D, E, F, G, H, I, J, K, L] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L)]

213. trait TypedSource13[A, B, C, D, E, F, G, H, I, J, K, L, M] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L, M)]

214. trait TypedSource14[A, B, C, D, E, F, G, H, I, J, K, L, M, N] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]

215. trait TypedSource15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]

216. trait TypedSource16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]

217. trait TypedSource17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]

218. trait TypedSource18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]

219. trait TypedSource19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

220. trait TypedSource2[A, B] extends TypedSource[(A, B)]

221. trait TypedSource20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]

222. trait TypedSource21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]

223. trait TypedSource22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]

224. trait TypedSource3[A, B, C] extends TypedSource[(A, B, C)]

225. trait TypedSource4[A, B, C, D] extends TypedSource[(A, B, C, D)]

226. trait TypedSource5[A, B, C, D, E] extends TypedSource[(A, B, C, D, E)]

227. trait TypedSource6[A, B, C, D, E, F] extends TypedSource[(A, B, C, D, E, F)]

228. trait TypedSource7[A, B, C, D, E, F, G] extends TypedSource[(A, B, C, D, E, F, G)]

229. trait TypedSource8[A, B, C, D, E, F, G, H] extends TypedSource[(A, B, C, D, E, F, G, H)]

230. trait TypedSource9[A, B, C, D, E, F, G, H, I] extends TypedSource[(A, B, C, D, E, F, G, H, I)]

231. case class UniqueID(get: String) extends Product with Serializable

     Used to inject a typed unique identifier to uniquely name each scalding flow.

232. trait UtcDateRangeJob extends Job with DefaultDateRangeJob

233. type ValuePipe[+T] = scalding.typed.ValuePipe[T]

234. case class WritableSequenceFile[K <: Writable, V <: Writable](p: String, f: Fields, sinkMode: SinkMode = cascading.tap.SinkMode.REPLACE)(implicit evidence$3: Manifest[K], evidence$4: Manifest[V]) extends FixedPathSource with WritableSequenceFileScheme with LocalTapSource with TypedSink[(K, V)] with TypedSource[(K, V)] with Product with Serializable

235. trait WritableSequenceFileScheme extends SchemedSource

236. class XHandler extends AnyRef

     Provide handlers and mapping for exceptions

237. class FixedPathTypedDelimited[T] extends FixedPathSource with TypedDelimited[T]

     Annotations

     @deprecated

     Deprecated

     (Since version 2015-07) Use FixedTypedText instead

238. trait TupleConversions extends AnyRef

     Annotations

     @deprecated

     Deprecated

     (Since version 0.9.0) This trait does nothing now

239. trait TypedDelimited[T] extends SchemedSource with DelimitedScheme with Mappable[T] with TypedSink[T]

     Allows you to set the types, prefer this: If T is a subclass of Product, we assume it is a tuple.