CascadeJob

abstract def jobs: Seq[Job]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def anyToFieldArg(f: Any): Comparable[_]

final def asInstanceOf[T0]: T0

def asList(f: Fields): List[Comparable[_]]

def asSet(f: Fields): Set[Comparable[_]]

def buildFlow: Flow[_]

combine the config, flowDef and the Mode to produce a flow

lazy val classIdentifier: String

def clear: Unit

def clone(nextargs: Args): Job

Copy this job By default, this uses reflection and the single argument Args constructor

def clone(): AnyRef

def config: Map[AnyRef, AnyRef]

This is the exact config that is passed to the Cascading FlowConnector.

implicit def dateParser: DateParser

Override this to control how dates are parsed

def defaultComparator: Option[Class[_ <: Comparator[_]]]

Override this if you want to customize comparisons/hashing for your job the config method overwrites using this before sending to cascading

def defaultMode(fromFields: Fields, toFields: Fields): Fields

Rather than give the full power of cascading's selectors, we have a simpler set of rules encoded below: 1) if the input is non-definite (ALL, GROUP, ARGS, etc.

def defaultSpillThreshold: Int

Keep 100k tuples in memory by default before spilling Turn this up as high as you can without getting OOM.

final def ensureUniqueFields(left: Fields, right: Fields, rightPipe: Pipe): (Fields, Pipe)

implicit def enumValueToFields(x: Value): Fields

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit def fieldFields[T <: TraversableOnce[Field[_]]](f: T): RichFields

implicit def fieldToFields(f: Field[_]): RichFields

implicit def fields[T <: TraversableOnce[Symbol]](f: T): Fields

implicit def fieldsToRichFields(fields: Fields): RichFields

We can't set the field Manifests because cascading doesn't (yet) expose field type information in the Fields API.

def finalize(): Unit

implicit val flowDef: FlowDef

implicit def fromEnum[T <: Enumeration](enumeration: T): Fields

Multi-entry fields.

def fromInputStream(s: InputStream): Array[Byte]

final def getClass(): Class[_]

def getField(f: Fields, idx: Int): Fields

def hasInts(f: Fields): Boolean

def hashCode(): Int

implicit def intFields[T <: TraversableOnce[Int]](f: T): Fields

implicit def intToFields(x: Int): Fields

implicit def integerToFields(x: Integer): Fields

def ioSerializations: List[Class[_ <: Serialization[_]]]

The exact list of Hadoop serializations passed into the config These replace the config serializations Cascading tuple serialization should be in this list, and probably before any custom code

final def isInstanceOf[T0]: Boolean

implicit def iterableToRichPipe[T](iter: Iterable[T])(implicit set: TupleSetter[T], conv: TupleConverter[T]): RichPipe

def listeners: List[FlowListener]

def md5Hex(bytes: Array[Byte]): String

implicit def mode: Mode

def name: String

final def ne(arg0: AnyRef): Boolean

final def newSymbol(avoid: Set[Symbol], guess: Symbol, trial: Int = 0): Symbol

def next: Option[Job]

Implement this method if you want some other jobs to run after the current job.

final def notify(): Unit

final def notifyAll(): Unit

implicit def parseAnySeqToFields[T <: TraversableOnce[Any]](anyf: T): Fields

Useful to convert f : Any* to Fields.

implicit def pipeToRichPipe(pipe: Pipe): RichPipe

you should never call this directly, it is here to make the DSL work.

def postProcessCascade(cascade: Cascade): Unit

def preProcessCascade(cascade: Cascade): Unit

implicit def productToFields(f: Product): Fields

Handles treating any TupleN as a Fields object.

implicit def read(src: Source): Pipe

This is implicit so that a Source can be used as the argument to a join or other method that accepts Pipe.

def run: Boolean

def runFlow: Flow[_]

def skipStrategy: Option[FlowSkipStrategy]

implicit def sourceToRichPipe(src: Source): RichPipe

This implicit is to enable RichPipe methods directly on Source objects, such as map/flatMap, etc.

def stepStrategy: Option[FlowStepStrategy[_]]

implicit def strFields[T <: TraversableOnce[String]](f: T): Fields

implicit def stringToFields(x: String): Fields

implicit def symbolToFields(x: Symbol): Fields

'* means Fields.

final def synchronized[T0](arg0: ⇒ T0): T0

def timeout[T](timeout: AbsoluteDuration)(t: ⇒ T): Option[T]

def toHexString(bytes: Array[Byte]): String

implicit def toPipe[T](iter: Iterable[T])(implicit set: TupleSetter[T], conv: TupleConverter[T]): Pipe

def toString(): String

implicit def tuple2ToFieldsPair[T, U](pair: (T, U))(implicit tf: (T) ⇒ Fields, uf: (U) ⇒ Fields): (Fields, Fields)

implicit def unitToFields(u: Unit): Fields

def validate: Unit

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def write(pipe: Pipe, src: Source): Unit

This is only here for Java jobs which cannot automatically access the implicit Pipe => RichPipe which makes: pipe.