MscrInputChannel

abstract def bypassOutputNodes: Seq[ParallelDo]

output nodes (parallelDos) which are not going in a reducer

abstract def createEmitter(tag: Int, context: InputOutputContext): EmitterWriter

create an emitter for a given output tag, which will either emit values with auto-generated keys for a FloatingInputChannel, or key/values for a GbkInputChannel

abstract def keyTypes: KeyTypes

types of the keys which are emitted by this InputChannel, by tag

abstract def lastMappers: Seq[ParallelDo]

last mappers in the "tree" of mappers using the input channel source node A mapper is not the "last" if its parent is a parallelDo that is included in the list of mappers

abstract def nodes: Layering

abstract def outputNodes: Seq[CompNode]

nodes where this input channel writes to

abstract def outputTags(mapper: ParallelDo): Seq[Int]

abstract def processNodes: Seq[ProcessNode]

abstract def sourceNode: CompNode

main source node providing data for this input channel

abstract def tags: Seq[Int]

set of tags, which are node ids consuming the values produced by this input channel

abstract def terminalNodes: Seq[CompNode]

nodes defining the output values of this channel, group by keys for a GbkInputChannel or parallelDo nodes for a FloatingInputChannel

abstract def valueTypes: ValueTypes

types of the values which are emitted by this InputChannel, by tag

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def cleanup(context: InputOutputContext): Unit

setup the parallelDos of this input channel

def clone(): AnyRef

implicit var configuration: Configuration

var emitters: Map[Int, EmitterWriter]

var environments: Map[ParallelDo, Any]

final def eq(arg0: AnyRef): Boolean

def equals(a: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

lazy val graphNodes: Layering

def hashCode(): Int

def id: Int

lazy val inputNodes: Seq[CompNode]

sourceNode + environments for the parallelDo nodes

final def isInstanceOf[T0]: Boolean

implicit lazy val logger: Log

def map(key: Any, value: Any, context: InputOutputContext): Unit

map a given key/value and emit it

lazy val mappers: Seq[ParallelDo]

collect all the mappers which are connected to the source node and connect to one of the terminal nodes for this channel

def mappersToString(name: String, mps: Seq[ParallelDo]): String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def scoobiConfiguration(configuration: Configuration): ScoobiConfigurationImpl

implicit var scoobiConfiguration: ScoobiConfiguration

def setup(context: InputOutputContext): Unit

store the current TaggedKey/TaggedValue which are going to be a container for all key/values to map, by tag

lazy val source: Source

data source for this input channel if the

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

var tks: Map[Int, TaggedKey]

def toString(): String

var tvs: Map[Int, TaggedValue]

var vectorEmitter: VectorEmitterWriter

final def wait(): Unit

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

final def wait(arg0: Long): Unit