Config

abstract def toMap: Map[String, String]

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(kv: (String, String)): Config

def ++(that: Config): Config

def -(k: String): Config

final def ==(arg0: Any): Boolean

def addCascadingClassSerializationTokens(clazzes: Set[Class[_]]): Config

The serialization of your data will be smaller if any classes passed between tasks in your job are listed here.

def addFlowListener(flowListenerProvider: (Mode, Config) ⇒ FlowListener): Config

configure flow listeneres for observability

def addFlowStepListener(flowListenerProvider: (Mode, Config) ⇒ FlowStepListener): Config

def addFlowStepStrategy(flowStrategyProvider: (Mode, Config) ⇒ FlowStepStrategy[JobConf]): Config

def addReducerEstimator(clsName: String): Config

Prepend an estimator so it will be tried first.

def addReducerEstimator[T](cls: Class[T]): Config

Prepend an estimator so it will be tried first.

def addUniqueId(u: UniqueID): Config

final def asInstanceOf[T0]: T0

def clearFlowStepStrategies: Config

def clone(): AnyRef

def ensureUniqueId: (UniqueID, Config)

Allocate a new UniqueID if there is not one present

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

def finalize(): Unit

def get(key: String): Option[String]

def getArgs: Args

def getCascadingAppJar: Option[Try[Class[_]]]

Returns None if not set, otherwise reflection is used to create the Class.forName

def getCascadingAppName: Option[String]

This is a name that if present is passed to flow.setName, which should appear in the job tracker.

def getCascadingSerializationTokens: Map[Int, String]

final def getClass(): Class[_]

def getFlowListeners: List[Try[(Mode, Config) ⇒ FlowListener]]

def getFlowStepListeners: List[Try[(Mode, Config) ⇒ FlowStepListener]]

def getFlowStepStrategies: List[Try[(Mode, Config) ⇒ FlowStepStrategy[JobConf]]]

def getHashJoinAutoForceRight: Boolean

def getKryo: Option[KryoInstantiator]

def getKryoRegisteredClasses: Set[Class[_]]

This function gets the set of classes that have been registered to Kryo.

def getNumReducers: Option[Int]

Get the number of reducers (this is the parameter Hadoop will use)

def getRequireOrderedSerialization: Boolean

def getScaldingExecutionId: Option[String]

def getScaldingVersion: Option[String]

def getSubmittedTimestamp: Option[RichDate]

def getUniqueIds: Set[UniqueID]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def maybeSetSubmittedTimestamp(date: RichDate = RichDate.now): (Option[RichDate], Config)

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def setArgs(args: Args): Config

def setCascadingAppId(id: String): Config

def setCascadingAppJar(clazz: Class[_]): Config

Non-fat-jar use cases require this, BUT using it with fat jars can cause problems.

def setCascadingAppName(name: String): Config

def setDefaultComparator(clazz: Class[_ <: Comparator[_]]): Config

def setHRavenHistoryUserName: Config

Set username from System.used for querying hRaven.

def setHashJoinAutoForceRight(b: Boolean): Config

def setListSpillThreshold(count: Int): Config

def setMapSideAggregationThreshold(count: Int): Config

def setMapSpillThreshold(count: Int): Config

def setNumReducers(n: Int): Config

def setReducerEstimators(clsList: String): Config

Set the entire list of reducer estimators (overriding the existing list)

def setRequireOrderedSerialization(b: Boolean): Config

Set this configuration option to require all grouping/cogrouping to use OrderedSerialization

def setScaldingExecutionId(id: String): Config

Set an ID to be shared across this usage of run for Execution

def setScaldingFlowClass(clazz: Class[_]): Config

def setScaldingVersion: Config

def setSerialization(kryo: Either[(Class[_ <: KryoInstantiator], KryoInstantiator), Class[_ <: KryoInstantiator]], userHadoop: Seq[Class[_ <: Serialization[_]]] = Nil): Config

def setVerboseFileSourceLogging(b: Boolean): Config

Set to true to enable very verbose logging during FileSource's validation and planning.

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

def toString(): String

def update[R](k: String)(fn: (Option[String]) ⇒ (Option[String], R)): (R, Config)

final def wait(): Unit

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

final def wait(arg0: Long): Unit