AccumuloAttributeIndex

abstract def version: Int

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val AllowJoinPlans: ThreadLocal[Boolean]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def configure(sft: SimpleFeatureType, ds: AccumuloDataStore): Unit

def configureSplits(sft: SimpleFeatureType, ds: AccumuloDataStore): Unit

def createDelete(row: Array[Byte], feature: AccumuloFeature): Mutation

def createDelete(row: Array[Byte], feature: AccumuloFeature, coverage: IndexCoverage): Mutation

def createInsert(row: Array[Byte], feature: AccumuloFeature): Mutation

def createInsert(row: Array[Byte], feature: AccumuloFeature, coverage: IndexCoverage): Mutation

def decodeRowValue(sft: SimpleFeatureType, index: Int): (Array[Byte], Int, Int) ⇒ Try[AnyRef]

def delete(sft: SimpleFeatureType, ds: AccumuloDataStore, shared: Boolean): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def generateTableName(sft: SimpleFeatureType, ds: AccumuloDataStore): String

final def getClass(): Class[_]

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

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

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

def getQueryPlan(sft: SimpleFeatureType, ds: AccumuloDataStore, filter: FilterStrategy[AccumuloDataStore, AccumuloFeature, Mutation], hints: Hints, explain: Explainer): QueryPlan[AccumuloDataStore, AccumuloFeature, Mutation]

def getRowKeys(sft: SimpleFeatureType): (AccumuloFeature) ⇒ Seq[(Int, Array[Byte])]

def getSecondaryIndexKeyLength(sft: SimpleFeatureType): Int

def getShards(sft: SimpleFeatureType): IndexedSeq[Array[Byte]]

def getSplits(sft: SimpleFeatureType): Seq[Array[Byte]]

def getTableName(typeName: String, ds: AccumuloDataStore): String

def hasDuplicates(sft: SimpleFeatureType, filter: Option[Filter]): Boolean

val hasPrecomputedBins: Boolean

def hashCode(): Int

lazy val identifier: String

final def isInstanceOf[T0]: Boolean

lazy val logger: Logger

val name: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def queryThreads(ds: AccumuloDataStore): Int

def range(start: Array[Byte], end: Array[Byte]): Range

def rangeExact(row: Array[Byte]): Range

def rangePrefix(prefix: Array[Byte]): Range

def remover(sft: SimpleFeatureType, ds: AccumuloDataStore): (AccumuloFeature) ⇒ Seq[Mutation]

def scanConfig(sft: SimpleFeatureType, ds: AccumuloDataStore, filter: FilterStrategy[AccumuloDataStore, AccumuloFeature, Mutation], indexValues: Option[Unit], ecql: Option[Filter], hints: Hints, dedupe: Boolean): ScanConfig

Sets up everything needed to execute the scan - iterators, column families, deserialization, etc

def scanPlan(sft: SimpleFeatureType, ds: AccumuloDataStore, filter: FilterStrategy[AccumuloDataStore, AccumuloFeature, Mutation], indexValues: Option[Unit], ranges: Seq[Range], ecql: Option[Filter], hints: Hints): QueryPlan[AccumuloDataStore, AccumuloFeature, Mutation]

def secondaryIndex(sft: SimpleFeatureType): Option[IndexKeySpace[_]]

val serializedWithId: Boolean

def supports(sft: SimpleFeatureType): Boolean

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

lazy val tableNameKey: String

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: AccumuloDataStore): (AccumuloFeature) ⇒ Seq[Mutation]