All Classes and Interfaces

Class
Description
Base implementation for RedisCollection.
 
Base implementation for a subscription handling the channel/pattern registration so subclasses only have to deal with the actual registration/unregistration.
Sort aggregation operations.
RedisPersistentEntity implementation.
A collection of predefined BatchStrategy implementations using KEYS or SCAN command.
A BatchStrategy to be used with RedisCacheWriter.
HashMapper based on Apache Commons BeanUtils project.
The actual BITFIELD command representation holding several BitFieldSubCommands.BitFieldSubCommands to execute.
 
The GET sub command used with BitFieldSubCommands.
 
The INCRBY sub command used with BitFieldSubCommands.
 
The SET sub command used with BitFieldSubCommands.
 
Sub command to be used as part of BitFieldSubCommands.
The actual Redis bitfield type representation for signed and unsigned integers used with BitFieldSubCommands.BitFieldSubCommand.
GeoOperations bound to a certain key.
Hash operations bound to a certain key.
Represents a geospatial bounding box defined by width and height.
Operations over a Redis key.
List operations bound to a certain key.
Set operations bound to a certain key.
Redis stream specific operations bound to a certain key.
Value (or String in Redis terminology) operations bound to a certain key.
ZSet (or SortedSet) operations bound to a certain key.
Bounding box defined by width and height.
Bucket is the data bag for Redis hash structures to be used with RedisData.
Value object representing a path within a Bucket.
Mapper translating Redis bulk value responses (typically returned by a sort query) to actual objects.
 
Simple wrapper class used for wrapping arrays so they can be used as keys inside maps.
A Record within the stream backed by a collection of binary field/value pairs.
A Record within the stream backed by a collection of binary field/value pairs.
Some handy methods for dealing with byte arrays.
CacheKeyPrefix provides a hook for creating custom prefixes prepended to the actual key stored in Redis.
Cache statistics for a RedisCache.
The statistics collector supports capturing of relevant RedisCache operations such as hits & misses.
Interface to be implemented by objects that expose CacheStatistics identified by cacheName.
Cancelable allows stopping long running tasks and freeing underlying resources.
Base class for Bean wrappers.
Channel topic implementation (maps to a Redis channel).
Exception thrown when at least one call to a clustered redis environment fails.
ClusterCommandExecutor takes care of running commands across the known cluster nodes.
Callback interface for Redis 'low level' code using the cluster client directly.
Callback interface for Redis 'low level' code using the cluster client to execute multi key commands.
ClusterInfo gives access to cluster information such as cluster_state and cluster_slots_assigned provided by the CLUSTER INFO command.
 
ClusterNodeResourceProvider provides access to low level client api to directly execute operations against a Redis instance.
Redis operations for cluster specific operations.
ClusterRedirectException indicates that a requested slot is not served by the targeted server but can be obtained on another one.
 
DataAccessResourceFailureException indicating the current local snapshot of cluster state does no longer represent the actual remote state.
ClusterTopology holds snapshot like information about RedisClusterNodes.
ClusterTopologyProvider manages the current cluster topology and makes sure to refresh cluster information.
Utility class used mainly for type conversion by the default collection implementations.
Composite IndexResolver implementation that iterates over a given collection of delegate IndexResolver instances.
Utilities for examining a RedisConnection
Value object representing a Stream consumer within a consumer group.
Common type converters
ConvertingCursor wraps a given cursor and applies given Converter to items prior to returning them.
Cursor abstraction to scan over the keyspace or elements within a data structure using a variant of a SCAN command.
Enumeration of the Redis data types.
Simple class containing various decoding utilities.
Specifies that the connection decorates another RedisConnection.
Delegating hash mapper used for flattening objects into Strings.
Deprecated.
Deprecated.
Default message implementation.
Default implementation of ReactiveScriptExecutor.
Default implementation for RedisList.
Default implementation for RedisMap.
Default implementation of RedisScript.
Default implementation for RedisSet.
Default implementation of RedisTypeMapper allowing configuration of the key to lookup and store type information via Bucket.BucketPropertyPath in buckets.
Default implementation for RedisZSet.
Default implementation of ScriptExecutor.
Default implementation for SortParameters.
Default implementation of StringRedisConnection.
Default implementation for StringRedisConnection.StringTuple interface.
Default implementation for Tuple interface.
Default implementation of TypedTuple.
Utilties for working with MessageDigest
Annotation to activate Redis repositories.
Mapper for Query-by-Example examples to an actual query.
Potentially translates an Exception into appropriate DataAccessException.
Expiration holds a value with its associated TimeUnit.
The result of an asynchronous operation
Generic Jackson 2-based RedisSerializer that maps objects to JSON using dynamic typing.
Generic String to byte[] (and back) serializer.
 
Mark properties value to be included in a secondary index.
IndexedData implementation indicating storage of data within a Redis GEO structure.
 
Redis operations for geo commands.
Reference point for GEOSEARCH and GEOSEARCHSTORE commands.
 
 
Search predicate for GEOSEARCH and GEOSEARCHSTORE commands.
Core mapping contract between Java types and Redis hashes/maps.
Function that returns a HashMapper for a given type.
Redis map specific operations working on a hash.
 
IndexConfiguration allows programmatic setup of indexes.
IndexDefinition allow to set up a blueprint for creating secondary index structures in Redis.
 
Context in which a particular value is about to get indexed.
IndexDefinitionProvider give access to IndexDefinitions for creating secondary index structures.
Registry that allows adding IndexDefinition.
Mark properties value to be included in a secondary index.
IndexedData represents a secondary index for a property path in a given keyspace.
IndexResolver extracts secondary index structures to be applied on a given path, PersistentProperty and value.
Converter implementation that is used to transform values for usage in a particular secondary index.
ObjectMapper based HashMapper implementation that allows flattening.
RedisSerializer that can read and write JSON using Jackson's and Jackson Databind ObjectMapper.
Defines the contract for Object Mapping readers.
Defines the contract for Object Mapping writers.
Java Serialization Redis serializer.
Redis client configuration for jedis.
Builder for Pooling-related JedisClientConfiguration.
Builder for SSL-related JedisClientConfiguration.
RedisClusterConnection implementation on top of JedisCluster.
Uses the native JedisCluster api where possible and falls back to direct node communication using Jedis where needed.
Jedis specific implementation of ClusterTopologyProvider.
RedisConnection implementation on top of Jedis library.
Connection factory creating Jedis based connections.
Converts Exceptions thrown from Jedis to DataAccessExceptions
Converts the value returned by Jedis script eval to the expected ReturnType
 
Helper class to register JSR-310 specific Converter implementations in case the we're running on Java 8.
 
MessageListener publishing RedisKeyExpiredEvents via ApplicationEventPublisher by listening to Redis keyspace notifications for key expirations.
Options to be used for with SCAN commands.
KeyspaceConfiguration allows programmatic setup of keyspaces and time to live options for certain types.
 
Base MessageListener implementation for listening to Redis keyspace notifications.
Redis client configuration for lettuce.
 
Builder for SSL-related LettuceClientConfiguration.
RedisClusterConnection implementation on top of Lettuce Redis client.
Lettuce specific implementation of ClusterCommandExecutor.ClusterCommandCallback.
Lettuce specific implementation of ClusterCommandExecutor.MultiKeyClusterCommandCallback.
RedisConnection implementation on top of Lettuce Redis client.
Strategy interface to control pipelining flush behavior.
State object associated with flushing of the currently ongoing pipeline.
Connection factory creating Lettuce-based connections.
Defines a provider for Lettuce connections.
Extension to LettuceConnectionProvider for providers that allow connection creation to specific nodes.
Lettuce type converters
Converts Lettuce Exceptions to DataAccessExceptions
Redis client configuration for lettuce using a driver level pooled connection by adding pooling specific configuration to LettuceClientConfiguration.
 
 
 
Message subscription on top of Lettuce.
 
Converts a List of values of one type to a List of values of another type
Redis list specific operations.
Value object representing the where from part for the LMOVE command.
Value object representing the where to from part for the LMOVE command.
Converts Longs to Booleans
Converts a Map of values of one key/value type to a Map of values of another type
MappingConfiguration is used for programmatic configuration of secondary indexes, key prefixes, expirations and the such.
RedisConverter implementation creating flat binary map structure out of a given domain type.
Value object representing a binary Redis Hash/Object identifier composed from keyspace and object id in the form of keyspace:id.
Value object representing a Redis Hash/Object identifier composed from keyspace and object id in the form of keyspace:id.
RedisEntityInformation implementation using a RedisPersistentEntity instance to lookup the necessary information.
A Record within the stream backed by a collection of field/value pairs.
 
Class encapsulating a Redis message body and its properties.
Listener of messages published in Redis.
Message listener adapter that delegates the handling of messages to target listener methods via reflection, with flexible message type conversion.
Metrics supported by Redis.
Tracing adapter using Micrometer's Observation.
 
A Record within the stream mapped to a single object.
Serializer adapter on top of Spring's O/X Mapping.
PartialUpdate allows to issue individual property updates without the need of rewriting the whole entity.
 
 
IndexDefinition that is based on a property paths.
IndexResolver implementation considering properties annotated with Indexed or paths set up in IndexConfiguration.
Pattern topic (matching multiple channels).
Value object representing a single pending message containing its ID, the consumer that fetched the message and has still to acknowledge it, the time elapsed since the messages last delivery and the the total number of times delivered.
Value object holding detailed information about pending messages in consumer group for a given Range and offset.
Value Object summarizing pending messages in a consumer group.
Exception thrown when there are issues with a resource pool
Repository fragment implementing Redis Query-by-Example operations.
Utilities for SortQuery implementations.
Radius defined by Distance.
Interface for the cluster commands supported by Redis executed using reactive infrastructure.
 
 
 
 
 
 
 
 
Redis Server commands executed in cluster environment using reactive infrastructure.
 
 
 
 
Redis Geo commands executed using reactive infrastructure.
GEOADD command parameters.
GEODIST command parameters.
GEOHASH command parameters.
GEOPOS command parameters.
GEORADIUSBYMEMBER command parameters.
GEORADIUS command parameters.
GEOSEARCH command parameters.
GEOSEARCHSTORE command parameters.
Reactive Redis operations for geo commands.
Redis Hash commands executed using reactive infrastructure.
 
 
Redis map specific operations working on a hash.
Redis HyperLogLog commands executed using reactive infrastructure.
PFADD command parameters.
PFCOUNT command parameters.
PFMERGE command parameters.
Redis cardinality specific operations working on a HyperLogLog multiset.
Redis Key commands executed using reactive infrastructure.
MOVE command parameters.
EXPIREAT/PEXPIREAT command parameters.
EXPIRE/PEXPIRE command parameters.
MOVE command parameters.
RENAME command parameters.
Redis List commands executed using reactive infrastructure.
BLMOVE command parameters.
 
BRPOPLPUSH command parameters.
 
LINDEX command parameters.
LINSERT command parameters.
LMOVE command parameters.
LPOS command parameters.
LREM command parameters.
LSET command parameters.
LPOP/RPOP command parameters.
LPUSH/RPUSH command parameters.
RPOPLPUSH command parameters.
Redis list specific operations.
Redis numeric commands executed using reactive infrastructure.
DECRBY command parameters.
HINCRBY command parameters.
INCRBY command parameters.
Redis Pub/Sub commands executed using reactive infrastructure.
Generic callback interface for code that operates on a low-level ReactiveRedisConnection.
 
Redis connection using reactive infrastructure declaring entry points for reactive command execution.
ReactiveRedisConnection.CommandResponse implementation for ByteBuffer responses for absent keys.
ReactiveRedisConnection.CommandResponse implementation for Boolean responses.
Base interface for Redis commands executed with a reactive infrastructure.
Base class for command responses.
ReactiveRedisConnection.Command for key-bound operations.
ReactiveRedisConnection.Command for key-bound scan operations like SCAN, HSCAN, SSCAN and ZSCAN.
ReactiveRedisConnection.CommandResponse implementation for List responses.
ReactiveRedisConnection.CommandResponse implementation for numeric responses.
 
Thread-safe factory of reactive Redis connections.
Container providing a stream of ReactiveSubscription.ChannelMessage for messages received via Redis Pub/Sub listeners.
Interface that specified a basic set of Redis operations, implemented by ReactiveRedisTemplate.
Generic callback interface for code that wants to use the same ReactiveRedisConnection avoiding connection allocation overhead upon each Template API method call.
Central abstraction for reactive Redis data access implementing ReactiveRedisOperations.
Executes RedisScripts using reactive infrastructure.
Redis Scripting commands executed using reactive infrastructure.
Redis Server commands executed using reactive infrastructure.
Redis Set commands executed using reactive infrastructure.
SADD command parameters.
SDIFF command parameters.
SDIFFSTORE command parameters.
SINTER command parameters.
SINTERSTORE command parameters.
SISMEMBER command parameters.
SMISMEMBER command parameters.
SMOVE command parameters.
SPOP command parameters.
SRANDMEMBER command parameters.
SREM command parameters.
SUNION command parameters.
SUNIONSTORE command parameters.
Redis set specific operations.
Stream-specific Redis commands executed using reactive infrastructure.
XACK command parameters.
XADD command parameters.
XDEL command parameters.
 
 
Value Object holding parameters for obtaining pending messages.
XRANGE/XREVRANGE command parameters.
XRANGE/XREVRANGE command parameters.
XTRIM command parameters.
XCLAIM command parameters.
 
Redis stream specific operations.
Redis String commands executed using reactive infrastructure.
APPEND command parameters.
BITCOUNT command parameters.
BITFIELD command parameters.
BITOP command parameters.
 
GETBIT command parameters.
MSET command parameters.
SETBIT command parameters.
SET command parameters.
SETRANGE command parameters.
Subscription for Redis channels using reactive infrastructure.
Value object for a Redis channel message.
ReactiveSubscription.Message represents a Redis channel message within Redis pub/sub.
Value object for a Redis channel message received from a pattern subscription.
Reactive Redis operations for simple (or in Redis terminology 'string') values.
Redis Sorted Set commands executed using reactive infrastructure.
BZPOPMIN/BZPOPMAX command parameters.
 
ZADD command parameters.
ZINTER/ZUNION command parameters.
ZINTERSTORE/ZUNIONSTORE command parameters.
ZCOUNT command parameters.
ZDIFF command parameters.
ZDIFFSTORE command parameters.
ZINCRBY command parameters.
ZINTERSTORE command parameters.
ZLEXCOUNT command parameters.
ZMSCORE command parameters.
ZPOPMIN/ZPOPMAX command parameters.
ZRANDMEMBER command parameters.
ZRANGEBYLEX/ZREVRANGEBYLEX command parameters.
ZRANGEBYSCORE/ZREVRANGEBYSCORE.
ZRANGE/ZREVRANGE command parameters.
ZRANGESTORE command parameters.
 
ZRANK/ZREVRANK command parameters.
ZREM command parameters.
ZREMRANGEBYLEX command parameters.
ZREMRANGEBYRANK command parameters.
ZREMRANGEBYSCORE command parameters.
ZSCORE command parameters.
ZUNIONSTORE command parameters.
Redis ZSet/sorted set specific operations.
Value object representing read offset for a Stream.
A single entry in the stream consisting of the entry-id and the actual entry-value (typically a collection of field/value pairs).
The id of a single Record within a stream.
Base class for RedisTemplate defining common properties.
Atomic double backed by Redis.
Atomic integer backed by Redis.
Atomic long backed by Redis.
Cache implementation using for Redis as underlying store.
Immutable RedisCacheConfiguration helps customizing RedisCache behaviour such as caching null values, cache key prefixes and binary serialization.
CacheManager backed by a Redis cache.
Configurator for creating RedisCacheManager.
RedisCacheWriter provides low level access to Redis commands (SET, SETNX, GET, EXPIRE,...) used for caching.
Callback interface for Redis 'low level' code.
RedisClientInfo provides general and statistical information about client connections.
 
 
Callback interface for low level operations executed against a clustered Redis environment.
Interface for the cluster commands supported by Redis.
 
Provides access to RedisClusterCommands and the segregated command interfaces.
Configuration class used for setting up RedisConnection via RedisConnectionFactory using connecting to Redis Cluster.
RedisClusterConnection allows sending commands to dedicated nodes within the cluster.
Representation of a Redis server within the cluster.
 
 
Builder for creating new RedisClusterNode.
 
 
Redis extension for the Collection contract.
Factory bean that facilitates creation of Redis-based collections.
Collection types supported by this factory.
 
Interface for the commands supported by Redis.
Provides access to RedisCommands and the segregated command interfaces.
Marker interface for configuration classes related to Redis connection setup.
Configuration interface suitable for Redis cluster environments.
Configuration interface suitable for single node redis connections using local unix domain socket.
Configuration interface suitable for Redis Sentinel environments.
Configuration interface suitable for Redis master/replica environments with fixed hosts.
RedisConfiguration part suitable for configurations that may use authentication when connecting.
RedisConfiguration part suitable for configurations that use a specific database.
RedisConfiguration part suitable for configurations that use native domain sockets for connecting.
RedisConfiguration part suitable for configurations that use host/port combinations for connecting.
RedisConfiguration part suitable for configurations that may use authentication when connecting.
A connection to a Redis server.
Connection-specific commands supported by Redis.
Thread-safe factory of Redis connections.
Fatal exception thrown when the Redis connection fails completely.
Helper class that provides static methods for obtaining RedisConnection from a RedisConnectionFactory.
Subinterface of RedisConnection to be implemented by RedisConnection proxies.
Redis specific EntityConverter.
Factory interface to create RedisCredentialsProvider from a RedisConfiguration.
Default anonymous RedisCredentials without username/password.
Value object to capture custom conversion.
Data object holding Bucket representing the domain object to be stored in a Redis hash.
Strategy interface that specifies a deserializer that can deserialize a binary element representation stored in Redis into an object.
Strategy interface that specifies a serializer that can serialize an element to its binary representation to be used as Redis protocol payload.
 
Geo-specific Redis commands.
Metrics supported by Redis.
Arguments to be used with RedisGeoCommands.
A flag to be used.
RedisGeoCommands.GeoLocation representing a Point associated with a name.
Additional arguments (like count/sort/...) to be used with RedisGeoCommands.
 
Additional arguments (like count/sort/...) to be used with RedisGeoCommands.
Additional arguments (like count/sort/...) to be used with RedisGeoCommands.
RedisHash marks Objects as aggregate roots to be stored in a Redis hash.
Hash-specific commands supported by Redis.
HyperLogLog specific commands supported by Redis.
Base IndexDefinition implementation.
 
 
 
 
 
Exception thrown when subscribing to an expired/dead Subscription.
Key-specific commands supported by Redis.
RedisKeyExpiredEvent is a Redis specific ApplicationEvent published when a particular key in Redis expires.
Redis specific ApplicationEvent published when a key expires in Redis.
Redis specific KeyValueAdapter implementation.
 
Configuration flag controlling storage of phantom keys (shadow copies) of expiring entities to read them later when publishing RedisKeyspaceEvent.
CdiBean to create RedisKeyValueAdapter instances.
Redis specific implementation of KeyValueTemplate.
Redis specific KeyValueCallback.
CdiBean to create RedisKeyValueTemplate instances.
Redis extension for the List contract.
List-specific commands supported by Redis.
List move direction.
List insertion position.
Exception thrown when the execution of a listener method failed.
Map view of a Redis hash.
Redis specific MappingContext.
Container providing asynchronous behaviour for Redis message listeners.
 
 
Builder for creating new RedisNode.
Simple set of operations required to run queries against Redis.
 
 
Interface that specified a basic set of Redis operations, implemented by RedisTemplate.
Value object which may or may not contain a Redis password.
Redis specific PersistentEntity.
Redis specific PersistentProperty implementation.
Exception thrown when executing/closing a pipeline that contains one or multiple invalid/incorrect statements.
Properties extension for a Redis back-store.
PubSub-specific Redis commands.
Redis specific query creator.
CdiRepositoryBean to create Redis repository instances.
CDI extension to export Redis repositories.
RepositoryFactorySupport specific of handing Redis KeyValueRepository.
Adapter for Springs FactoryBean interface to allow easy setup of RedisRepositoryFactory via Spring configuration.
RuntimeHintsRegistrar for Redis operations and repository support.
A script to be executed using the Redis scripting support available as of version 2.6
Scripting commands.
Redis Sentinel-specific commands.
Configuration class used for setting up RedisConnection via RedisConnectionFactory using connecting to Redis Sentinel(s).
 
Serialization context for reactive use.
Typed serialization tuple.
Basic interface serialization and deserialization of Objects to byte arrays (binary data).
 
 
Server-specific commands supported by Redis.
 
 
 
Redis extension for the Set contract.
Set-specific commands supported by Redis.
Configuration class used for setting up RedisConnection via RedisConnectionFactory connecting to single Redis using a local unix domain socket.
Configuration class used for setting up RedisConnection via RedisConnectionFactory using connecting to a single node Redis installation.
Configuration class used for setting up RedisConnection via RedisConnectionFactory using the provided Master / Replica configuration to nodes know to not change address.
Basic interface for Redis-based collections.
Stream-specific Redis commands.
Additional options applicable for XADD command.
 
 
Value Object holding parameters for obtaining pending messages.
String/Value-specific commands supported by Redis.
 
SET command arguments for NX, XX.
Exception thrown when issuing commands on a connection that is subscribed and waiting for events.
Exception thrown when we can't classify a Redis exception into one of Spring generic data access exceptions.
Helper class that simplifies Redis data access code.
Transaction/Batch specific commands supported by Redis.
Redis-specific TypeMapper exposing that Bucket.BucketPropertyPaths might contain a type key.
Redis ZSet (or sorted set (by weight)).
ZSet(SortedSet)-specific commands supported by Redis.
Deprecated.
since 3.0, use Limit instead.
Deprecated.
since 3.0, use Range or RedisZSetCommands.Range.toRange() instead.
 
ZADD specific arguments.
 
ReferenceResolver retrieves Objects marked with Reference from Redis.
ReferenceResolver using RedisKeyValueAdapter to read raw data.
RemoveIndexedData represents a removed index entry from a secondary index for a property path in a given keyspace.
Represents a data type returned from Redis, currently used to denote the expected return type of Redis scripting commands
Redis client agnostic Cursor implementation continuously loading additional results from Redis server until reaching its starting point zero.
ScanIteration holds the values contained in Redis Multibulk reply on exectuting SCAN command.
Options to be used for with SCAN commands.
 
Executes RedisScripts
RuntimeException thrown when issues occur with RedisScripts
Generic exception indicating a serialization/deserialization error.
Utility class with various serialization-related methods.
Callback executing all operations against a surrogate 'session' (basically against the same underlying Redis connection).
Converts a Set of values of one type to a Set of values of another type preserving item order.
Redis set specific operations.
PathBasedRedisIndexDefinition for including property values in a secondary index.
IndexedData implementation indicating storage of data within a Redis Set.
Internal interface part of the Sort DSL.
Entity containing the parameters for the SORT operation.
Sorting order.
Utility class wrapping the 'LIMIT' setting.
High-level abstraction over a Redis SORT (generified equivalent of SortParameters).
Simple builder class for constructing SortQuery.
SpelIndexDefinition defines index that is evaluated based on a SpelExpression requires the SpelIndexResolver to be evaluated.
 
 
 
 
Value object holding general information about consumer groups associated with a Redis Stream.
 
Value object holding general information about a Redis Stream.
StreamListener<K,V extends Record<K,?>>
Listener interface to receive delivery of messages.
Abstraction used by the framework representing a message listener container.
Request to read a Redis Stream with a Consumer.
Request to read a Redis Stream.
Value object representing a Stream Id with its offset.
Redis stream specific operations.
Options for reading messages from a Redis Stream.
StreamReceiver<K,V extends Record<K,?>>
A receiver to consume Redis Streams using reactive infrastructure.
Options for StreamReceiver.
StreamRecords provides utilities to create specific Record instances.
Builder for Record.
A Record within the stream backed by a collection of String field/value pairs.
Convenience extension of RedisConnection that accepts and returns Strings instead of byte arrays.
String-friendly ZSet tuple.
Simple String to byte[] (and back) serializer.
String-focused extension of RedisTemplate.
Converts Strings to DataTypes
Converts Strings to Properties
Converter implementation to create one RedisClientInfo per line entry in given String array.
Subscription for Redis channels.
The Subscription is the link to the actual running Task.
Listener for subscription notifications.
The actual Task to run within the StreamMessageListenerContainer.
The Task.State defining the lifecycle phase the actual Task.
Helper class featuring methods for calculating Redis timeouts
TimeToLive marks a single numeric property on aggregate root to be used for setting expirations in Redis.
TimeToLiveAccessor extracts the objects time to live used for EXPIRE.
DataRetrievalFailureException thrown when following cluster redirects exceeds the max number of edges.
Topic for a Redis message.
Converts the results of transaction exec using a supplied Queue of FutureResults.
ZSet tuple.
ValueEncoding is used for the Redis internal data representation used in order to store the value associated with a key.
Default ValueEncoding implementation of encodings used in Redis.
Redis operations for simple (or in Redis terminology 'string') values.
Value object encapsulating a multiplication factor for each input sorted set.
Redis ZSet/sorted set specific operations.
Typed ZSet tuple.