AbstractConverter

Instance Constructors

new AbstractConverter(sft: SimpleFeatureType, config: C, fields: Seq[F], options: O)

sft
simple feature type
config
converter config
fields
converter fields
options
converter options

Abstract Value Members

abstract def parse(is: InputStream, ec: EvaluationContext): CloseableIterator[T]

Parse objects out of the input stream.
Parse objects out of the input stream. This should be lazily evaluated, so that any exceptions occur in the call to hasNext (and not during the iterator creation), which lets us handle them appropriately in ErrorHandlingIterator. If there is any sense of 'lines', they should be indicated with ec.counter.incLineCount
is
input
ec
evaluation context
returns
raw extracted values, one iterator entry per simple feature

Attributes
protected
abstract def values(parsed: CloseableIterator[T], ec: EvaluationContext): CloseableIterator[Array[Any]]

Convert parsed values into the raw array used for reading fields.
Convert parsed values into the raw array used for reading fields. If line counting was not handled in parse (due to no sense of 'lines' in the input), then the line count should be incremented here instead
parsed
parsed values
ec
evaluation context

Attributes
protected

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def close(): Unit

Definition Classes
AbstractConverter → Closeable → AutoCloseable
val config: C

converter config
def convert(values: CloseableIterator[T], ec: EvaluationContext): CloseableIterator[SimpleFeature]

Convert parsed values into simple features
Convert parsed values into simple features
values
parsed values, from parse
ec
evaluation context

Definition Classes
AbstractConverter → ParsingConverter
def createEvaluationContext(globalParams: Map[String, Any], caches: Map[String, EnrichmentCache], counter: Counter): EvaluationContext

Creates a context used for local state while processing
Creates a context used for local state while processing

Definition Classes
AbstractConverter → SimpleFeatureConverter
def createEvaluationContext(globalParams: Map[String, Any]): EvaluationContext

Create a context used for local state while processing
Create a context used for local state while processing
globalParams
global key-values to make accessible through the evaluation context

Definition Classes
AbstractConverter → SimpleFeatureConverter
final def createEvaluationContext(globalParams: Map[String, Any]): EvaluationContext

Java API for createEvaluationContext
Java API for createEvaluationContext
globalParams
global params, accessible in the converter for each input

Definition Classes
SimpleFeatureConverter
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
val fields: Seq[F]

converter fields
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
lazy val logger: Logger

Attributes
protected
Definition Classes
LazyLogging
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val options: O

converter options
def process(is: InputStream, ec: EvaluationContext): CloseableIterator[SimpleFeature]

Process an input stream into simple features
Process an input stream into simple features
is
input
ec
evaluation context

Definition Classes
AbstractConverter → SimpleFeatureConverter
val sft: SimpleFeatureType

simple feature type
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def targetSft: SimpleFeatureType

Result feature type
Result feature type

Definition Classes
AbstractConverter → SimpleFeatureConverter
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: object AbstractConverter | package convert2

abstract class AbstractConverter[T, C <: ConverterConfig, F <: Field, O <: ConverterOptions] extends SimpleFeatureConverter with ParsingConverter[T] with LazyLogging

Instance Constructors

new AbstractConverter(sft: SimpleFeatureType, config: C, fields: Seq[F], options: O)

Abstract Value Members

abstract def parse(is: InputStream, ec: EvaluationContext): CloseableIterator[T]

abstract def values(parsed: CloseableIterator[T], ec: EvaluationContext): CloseableIterator[Array[Any]]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def close(): Unit

val config: C

def convert(values: CloseableIterator[T], ec: EvaluationContext): CloseableIterator[SimpleFeature]

def createEvaluationContext(globalParams: Map[String, Any], caches: Map[String, EnrichmentCache], counter: Counter): EvaluationContext

def createEvaluationContext(globalParams: Map[String, Any]): EvaluationContext

final def createEvaluationContext(globalParams: Map[String, Any]): EvaluationContext

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val fields: Seq[F]

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

lazy val logger: Logger

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val options: O

def process(is: InputStream, ec: EvaluationContext): CloseableIterator[SimpleFeature]

val sft: SimpleFeatureType

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

def targetSft: SimpleFeatureType

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from ParsingConverter[T]

Inherited from SimpleFeatureConverter

Inherited from LazyLogging

Inherited from Closeable

Inherited from AutoCloseable

Inherited from AnyRef

Inherited from Any

Ungrouped