CassandraTieredFeatureIndex

abstract def columns: Seq[NamedColumn]

abstract def createValues(shards: ShardStrategy, toIndexKey: (SimpleFeature) ⇒ Seq[U], toTieredIndexKey: ToIndexKeyBytes, includeFeature: Boolean)(cf: CassandraFeature): Seq[Seq[RowValue]]

Create values for insert with a tiered row key

abstract def createValues(shards: ShardStrategy, toIndexKey: (SimpleFeature) ⇒ Seq[U], includeFeature: Boolean)(cf: CassandraFeature): Seq[Seq[RowValue]]

Create values for insert

abstract def getCost(sft: SimpleFeatureType, stats: Option[GeoMesaStats], filter: TypedFilterStrategy, transform: Option[SimpleFeatureType]): Long

abstract def getFilterStrategy(sft: SimpleFeatureType, filter: Filter, transform: Option[SimpleFeatureType]): Seq[TypedFilterStrategy]

abstract def keySpace: IndexKeySpace[T, U]

Primary key space used by this index

abstract def name: String

abstract def shardStrategy(sft: SimpleFeatureType): ShardStrategy

Strategy for sharding

abstract def tieredKeySpace(sft: SimpleFeatureType): Option[IndexKeySpace[_, _]]

Tiered key space beyond the primary one, if any

abstract def toRowRanges(sft: SimpleFeatureType, range: ScanRange[U]): Seq[RowRange]

Convert a generic scan into a c* select

abstract def toTieredRowRange(lower: Array[Byte], upper: Array[Byte]): RowRange

Convert a secondary scan into a c* select

abstract def version: Int

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def configure(sft: SimpleFeatureType, ds: CassandraDataStore, partition: Option[String]): String

def delete(sft: SimpleFeatureType, ds: CassandraDataStore, partition: Option[String]): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def generateTableName(sft: SimpleFeatureType, ds: CassandraDataStore, partition: Option[String]): String

final def getClass(): Class[_]

def getIdFromRow(sft: SimpleFeatureType): (Array[Byte], Int, Int, SimpleFeature) ⇒ String

def getPartitions(sft: SimpleFeatureType, ds: CassandraDataStore): Seq[String]

def getQueryPlan(sft: SimpleFeatureType, ds: CassandraDataStore, filter: CassandraFilterStrategyType, hints: Hints, explain: Explainer): CassandraQueryPlanType

def getSplits(sft: SimpleFeatureType, partition: Option[String]): Seq[Array[Byte]]

def getTableNames(sft: SimpleFeatureType, ds: CassandraDataStore, partition: Option[String]): Seq[String]

def getTablesForQuery(sft: SimpleFeatureType, ds: CassandraDataStore, filter: Option[Filter]): Seq[String]

def hashCode(): Int

lazy val identifier: String

final def isInstanceOf[T0]: Boolean

lazy val logger: Logger

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def removeAll(sft: SimpleFeatureType, ds: CassandraDataStore): Unit

def remover(sft: SimpleFeatureType, ds: CassandraDataStore): (CassandraFeature) ⇒ Seq[Seq[RowValue]]

def resultsToFeatures(sft: SimpleFeatureType, ecql: Option[Filter], transform: Option[(String, SimpleFeatureType)]): (Iterator[Row]) ⇒ Iterator[SimpleFeature]

def rowAndValue(result: Row): RowAndValue

def supports(sft: SimpleFeatureType): Boolean

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

def tableNameKey(partition: Option[String]): String

def toFeaturesDirect(sft: SimpleFeatureType): (Row) ⇒ SimpleFeature

def toFeaturesWithFilter(sft: SimpleFeatureType, ecql: Filter): (Row) ⇒ Option[SimpleFeature]

def toFeaturesWithFilterTransform(sft: SimpleFeatureType, ecql: Filter, transforms: Array[Definition], indices: Array[Int], transformSft: SimpleFeatureType): (Row) ⇒ Option[SimpleFeature]

def toFeaturesWithTransform(sft: SimpleFeatureType, transforms: Array[Definition], indices: Array[Int], transformSft: SimpleFeatureType): (Row) ⇒ SimpleFeature

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def writer(sft: SimpleFeatureType, ds: CassandraDataStore): (CassandraFeature) ⇒ Seq[Seq[RowValue]]

def serializedWithId: Boolean