RedisDataStore

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def acquireCatalogLock(): Releasable

def acquireDistributedLock(key: String, timeOut: Long): Option[Releasable]

def acquireDistributedLock(key: String): Releasable

val adapter: RedisIndexAdapter

final def asInstanceOf[T0]: T0

def clone(): AnyRef

val config: RedisDataStoreConfig

datastore configuration

val connection: JedisPool

connection pool

def createSchema(schema: SimpleFeatureType): Unit

def delete(): Unit

def dispose(): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def getAllIndexTableNames(typeName: String): Seq[String]

def getAllTableNames(typeName: String): Seq[String]

final def getClass(): Class[_]

def getClientVersion: SemanticVersion

def getDistributedVersion: Option[SemanticVersion]

def getFeatureReader(query: Query, transaction: Transaction): GeoMesaFeatureReader

def getFeatureSource(typeName: String): GeoMesaFeatureStore

def getFeatureSource(typeName: Name): SimpleFeatureSource

def getFeatureWriter(typeName: String, filter: Filter, transaction: Transaction): FlushableFeatureWriter

def getFeatureWriter(typeName: String, transaction: Transaction): SimpleFeatureWriter

def getFeatureWriterAppend(typeName: String, transaction: Transaction): FlushableFeatureWriter

def getIndexWriterAppend(typeName: String, indices: Seq[GeoMesaFeatureIndex[_, _]]): FlushableFeatureWriter

def getInfo(): ServiceInfo

def getLockingManager(): LockingManager

def getNames(): List[Name]

def getQueryPlan(query: Query, index: Option[String], explainer: Explainer): Seq[RedisQueryPlan]

def getSchema(typeName: String): SimpleFeatureType

def getSchema(name: Name): SimpleFeatureType

def getTypeNames(): Array[String]

def hashCode(): Int

val interceptors: QueryInterceptorFactory

final def isInstanceOf[T0]: Boolean

def loadIteratorVersions: Set[String]

lazy val logger: Logger

val manager: IndexManager

val metadata: GeoMesaMetadata[String]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onSchemaCreated(sft: SimpleFeatureType): Unit

def onSchemaDeleted(sft: SimpleFeatureType): Unit

def onSchemaUpdated(sft: SimpleFeatureType, previous: SimpleFeatureType): Unit

def preSchemaCreate(sft: SimpleFeatureType): Unit

def preSchemaUpdate(sft: SimpleFeatureType, previous: SimpleFeatureType): Unit

val queryPlanner: QueryPlanner[RedisDataStore]

def removeSchema(typeName: Name): Unit

def removeSchema(typeName: String): Unit

val stats: GeoMesaStats

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

def toString(): String

def transitionIndices(sft: SimpleFeatureType): Unit

def updateSchema(typeName: Name, schema: SimpleFeatureType): Unit

def updateSchema(typeName: String, sft: SimpleFeatureType): Unit

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withLock[T](key: String, timeOut: Long, fn: ⇒ T, fallback: ⇒ T): T

def withLock[T](key: String, fn: ⇒ T): T

def catalog: String

def getDistributeVersion: Option[SemanticVersion]

def getVersion: (String, Set[String])