Builder

abstract def attributes: ModelAttributes

abstract def build(reader: XMLEventReader, attrs: XmlAttrs, parent: Model): T

Builds a PMML model from a specified XML reader.

abstract def name: String

Name of the builder.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def ??????: Nothing

?????? can be used for marking methods that never invoked

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def defaultFieldScope: FieldScope

val derivedFieldScope: MutableFieldScope[DerivedField]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def extHandler: (XMLEventReader, MetaData) ⇒ Option[Extension]

val extensions: ArrayBuffer[Extension]

def extractArray(text: String): Array[String]

def extractText(reader: XMLEventReader, parent: String): String

def field(name: String): Field

Returns the field of a given name.

def finalize(): Unit

def function(name: String): Function

final def getClass(): Class[_]

def getField(name: String): Option[Field]

Returns the field of a given name, None if a field with the given name does not exist

def getFunction(name: String): Option[Function]

def getTarget: Option[Field]

def handleElem(reader: XMLEventReader, event: EvElemStart): Unit

def handleElem(reader: XMLEventReader, label: String, attrs: MetaData = scala.xml.Null): Unit

def hashCode(): Int

def inferDataType(feature: ResultFeature, targetField: Option[String]): DataType

final def isInstanceOf[T0]: Boolean

var localTransformations: Option[LocalTransformations]

def makeArray(reader: XMLEventReader, attrs: XmlAttrs): Array[_]

def makeAttributes(attrs: XmlAttrs): ModelAttributes

Extracts these common attributes from a model

def makeCategoricalPredictor(reader: XMLEventReader, attrs: MetaData): CategoricalPredictor

def makeComparisonMeasure(reader: XMLEventReader, attrs: MetaData): ComparisonMeasure

def makeContinuousDistribution(reader: XMLEventReader, event: EvElemStart): ContinuousDistribution

def makeDefineFunction(reader: XMLEventReader, attrs: XmlAttrs): DefineFunction

def makeDerivedField(reader: XMLEventReader, attrs: XmlAttrs): DerivedField

def makeElem[T](reader: XMLEventReader, event: EvElemStart, builder: GroupElemBuilder[T]): T

def makeElem[A, B](reader: XMLEventReader, parent: String, child1: String, builder1: ElemBuilder[A], child2: String, builder2: ElemBuilder[B]): (Option[A], Option[B])

def makeElem[T](reader: XMLEventReader, parent: String, child: String, builder: ElemBuilder[T]): Option[T]

def makeElem[T](reader: XMLEventReader, event: EvElemStart, builder: ElemBuilder[T]): T

def makeElem[T](reader: XMLEventReader, attrs: MetaData, builder: ElemBuilder[T]): T

def makeElems[T](reader: XMLEventReader, parent: String, children: Set[String], builder: GroupElemBuilder[T])(implicit arg0: ClassTag[T]): Array[T]

def makeElems[A, B](reader: XMLEventReader, parent: String, child1: String, builder1: ElemBuilder[A], child2: String, builder2: ElemBuilder[B])(implicit arg0: ClassTag[A], arg1: ClassTag[B]): (Array[A], Array[B])

def makeElems[T](reader: XMLEventReader, parent: String, child: String, builder: ElemBuilder[T], sizeHint: Option[Int] = None)(implicit arg0: ClassTag[T]): Array[T]

def makeExpression(reader: XMLEventReader, event: EvElemStart, scope: FieldScope): Expression

def makeFieldRef(reader: XMLEventReader, attrs: MetaData, scope: FieldScope): FieldRef

def makeIntArray(reader: XMLEventReader, attrs: XmlAttrs): Array[Int]

def makeIntSparseArray(reader: XMLEventReader, attrs: XmlAttrs): SparseVector[Int]

def makeInterval(reader: XMLEventReader, attrs: XmlAttrs): Interval

def makeLocalTransformations(reader: XMLEventReader): LocalTransformations

Parses the local transformations

def makeMatrix(reader: XMLEventReader, attrs: XmlAttrs): Matrix

def makeMiningSchema(reader: XMLEventReader): MiningSchema

Parses the mining fields under MiningSchema

def makeModelExplanation(reader: XMLEventReader): Option[ModelExplanation]

def makeModelStats(reader: XMLEventReader): Option[ModelStats]

def makeModelVerification(reader: XMLEventReader, attrs: MetaData): Option[ModelVerification]

def makeOutput(reader: XMLEventReader): Option[Output]

Parses the output fields

def makePartition(reader: XMLEventReader, attrs: XmlAttrs): Partition

def makePredicate(reader: XMLEventReader, event: EvElemStart): Predicate

Parses one of predicates: SimplePredicate, CompoundPredicate, SimpleSetPredicate, True, or False

def makeRealArray(reader: XMLEventReader, attrs: XmlAttrs): Array[Double]

def makeRealSparseArray(reader: XMLEventReader, attrs: XmlAttrs): SparseVector[Double]

def makeScoreDistribution(reader: XMLEventReader, attrs: MetaData): ScoreDistribution

def makeStringArray(reader: XMLEventReader, attrs: XmlAttrs): Array[String]

def makeTable(reader: XMLEventReader, event: EvElemStart, dataTypes: Map[String, DataType] = Map.empty): Table

def makeTargets(reader: XMLEventReader): Option[Targets]

Parses the targets

def makeTransformationDictionary(reader: XMLEventReader): TransformationDictionary

Parses the transformation dictionary.

def makeValue(reader: XMLEventReader, attrs: XmlAttrs): Value

var miningSchema: MiningSchema

var modelExplanation: Option[ModelExplanation]

var modelStats: Option[ModelStats]

var modelVerification: Option[ModelVerification]

final def ne(arg0: AnyRef): Boolean

def nextLabel(reader: XMLEventReader): XMLEvent

final def notify(): Unit

final def notifyAll(): Unit

var output: Option[Output]

val outputFieldScope: MutableFieldScope[OutputField]

OutputField with feature="transformedValue" in a PMML model can refer to some field after it

var parent: Model

def postBuild(): Unit

val provider: MutableFunctionProvider

def scope: FieldScope

def skipLabel(reader: XMLEventReader): Unit

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

def target: Field

var targets: Option[Targets]

def toString(): String

def toVal(s: String, dataType: DataType): Any

def traverseElems(reader: XMLEventReader, parent: String, f: PartialFunction[XMLEvent, Any], handleText: Boolean = false, handleEnd: Boolean = false, handleEntityRef: Boolean = false, handleExtension: Boolean = false): Any

def traverseModel(reader: XMLEventReader, parent: String, f: PartialFunction[XMLEvent, Any]): Any

def verifyScore(s: String): Any

def verifyValue(s: String, f: Field): Any

Verifies if the input sting values is valid for the specified field, here, we need to check if the field is null, because this method is always called to verify the target field that could be absent for any model, for example the child model under the Mining Model.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

lazy val wrappedFields: ArrayBuffer[WrappedField]