Interface RStreamAsync<K,​V>

  • Type Parameters:
    K - key type
    V - value type
    All Superinterfaces:
    RExpirableAsync, RObjectAsync
    All Known Subinterfaces:
    RStream<K,​V>
    All Known Implementing Classes:
    RedissonStream

    public interface RStreamAsync<K,​V>
    extends RExpirableAsync
    Async interface for Redis Stream object.

    Requires Redis 5.0.0 and higher.

    Author:
    Nikita Koksharov
    • Method Detail

      • createGroupAsync

        RFuture<Void> createGroupAsync​(String groupName)
        Creates consumer group by name.
        Parameters:
        groupName - - name of group
        Returns:
        void
      • createGroupAsync

        RFuture<Void> createGroupAsync​(String groupName,
                                       StreamMessageId id)
        Creates consumer group by name and stream id. Only new messages after defined stream id will be available for consumers of this group.

        StreamMessageId.NEWEST is used for messages arrived since the moment of group creating

        Parameters:
        groupName - - name of group
        id - - stream id
        Returns:
        void
      • removeGroupAsync

        RFuture<Void> removeGroupAsync​(String groupName)
        Removes group by name.
        Parameters:
        groupName - - name of group
        Returns:
        void
      • removeConsumerAsync

        RFuture<Long> removeConsumerAsync​(String groupName,
                                          String consumerName)
        Removes consumer of the group by name.
        Parameters:
        groupName - - name of group
        consumerName - - name of consumer
        Returns:
        number of pending messages owned by consumer
      • updateGroupMessageIdAsync

        RFuture<Void> updateGroupMessageIdAsync​(String groupName,
                                                StreamMessageId id)
        Updates next message id delivered to consumers.
        Parameters:
        groupName - - name of group
        id - - Stream Message ID
        Returns:
        void
      • ackAsync

        RFuture<Long> ackAsync​(String groupName,
                               StreamMessageId... ids)
        Marks pending messages by group name and stream ids as correctly processed.
        Parameters:
        groupName - - name of group
        ids - - stream ids
        Returns:
        marked messages amount
      • listPendingAsync

        RFuture<PendingResult> listPendingAsync​(String groupName)
        Returns pending messages by group name
        Parameters:
        groupName - - name of group
        Returns:
        result object
      • listPendingAsync

        RFuture<List<PendingEntry>> listPendingAsync​(String groupName,
                                                     String consumerName,
                                                     StreamMessageId startId,
                                                     StreamMessageId endId,
                                                     int count)
        Returns list of pending messages by group name and consumer name. Limited by start stream id and end stream id and count.

        StreamMessageId.MAX is used as max stream id StreamMessageId.MIN is used as min stream id

        Parameters:
        consumerName - - name of consumer
        groupName - - name of group
        startId - - start stream id
        endId - - end stream id
        count - - amount of messages
        Returns:
        list
      • claimAsync

        RFuture<Map<StreamMessageId,​Map<K,​V>>> claimAsync​(String groupName,
                                                                      String consumerName,
                                                                      long idleTime,
                                                                      TimeUnit idleTimeUnit,
                                                                      StreamMessageId... ids)
        Transfers ownership of pending messages by id to a new consumer by name if idle time of messages is greater than defined value.
        Parameters:
        groupName - - name of group
        consumerName - - name of consumer
        idleTime - - minimum idle time of messages
        idleTimeUnit - - idle time unit
        ids - - stream ids
        Returns:
        stream data mapped by Stream ID
      • fastClaimAsync

        RFuture<List<StreamMessageId>> fastClaimAsync​(String groupName,
                                                      String consumerName,
                                                      long idleTime,
                                                      TimeUnit idleTimeUnit,
                                                      StreamMessageId... ids)
        Transfers ownership of pending messages by id to a new consumer by name if idle time of messages is greater than defined value.
        Parameters:
        groupName - - name of group
        consumerName - - name of consumer
        idleTime - - minimum idle time of messages
        idleTimeUnit - - idle time unit
        ids - - Stream Message IDs
        Returns:
        list of Stream Message IDs
      • readGroupAsync

        RFuture<Map<StreamMessageId,​Map<K,​V>>> readGroupAsync​(String groupName,
                                                                          String consumerName,
                                                                          StreamMessageId... ids)
        Read stream data from groupName by consumerName and specified collection of Stream IDs.
        Parameters:
        groupName - - name of group
        consumerName - - name of consumer
        ids - - collection of Stream IDs
        Returns:
        stream data mapped by Stream ID
      • readGroupAsync

        RFuture<Map<StreamMessageId,​Map<K,​V>>> readGroupAsync​(String groupName,
                                                                          String consumerName,
                                                                          int count,
                                                                          StreamMessageId... ids)
        Read stream data from groupName by consumerName and specified collection of Stream IDs.
        Parameters:
        groupName - - name of group
        consumerName - - name of consumer
        count - - stream data size limit
        ids - - collection of Stream IDs
        Returns:
        stream data mapped by Stream ID
      • readGroupAsync

        RFuture<Map<StreamMessageId,​Map<K,​V>>> readGroupAsync​(String groupName,
                                                                          String consumerName,
                                                                          long timeout,
                                                                          TimeUnit unit,
                                                                          StreamMessageId... ids)
        Read stream data from groupName by consumerName and specified collection of Stream IDs. Wait for stream data availability for specified timeout interval.
        Parameters:
        groupName - - name of group
        consumerName - - name of consumer
        timeout - - time interval to wait for stream data availability
        unit - - time interval unit
        ids - - collection of Stream IDs
        Returns:
        stream data mapped by Stream ID
      • readGroupAsync

        RFuture<Map<StreamMessageId,​Map<K,​V>>> readGroupAsync​(String groupName,
                                                                          String consumerName,
                                                                          int count,
                                                                          long timeout,
                                                                          TimeUnit unit,
                                                                          StreamMessageId... ids)
        Read stream data from groupName by consumerName and specified collection of Stream IDs. Wait for stream data availability for specified timeout interval.
        Parameters:
        groupName - - name of group
        consumerName - - name of consumer
        count - - stream data size limit
        timeout - - time interval to wait for stream data availability
        unit - - time interval unit
        ids - - collection of Stream IDs
        Returns:
        stream data mapped by Stream ID
      • readGroupAsync

        RFuture<Map<String,​Map<StreamMessageId,​Map<K,​V>>>> readGroupAsync​(String groupName,
                                                                                            String consumerName,
                                                                                            StreamMessageId id,
                                                                                            Map<String,​StreamMessageId> nameToId)
        Read stream data from groupName by consumerName, starting by specified message ids for this and other streams.
        Parameters:
        groupName - - name of group
        consumerName - - name of consumer
        id - - starting message id for this stream
        nameToId - - Stream Message ID mapped by stream name
        Returns:
        stream data mapped by key and Stream Message ID
      • readGroupAsync

        RFuture<Map<String,​Map<StreamMessageId,​Map<K,​V>>>> readGroupAsync​(String groupName,
                                                                                            String consumerName,
                                                                                            int count,
                                                                                            StreamMessageId id,
                                                                                            Map<String,​StreamMessageId> nameToId)
        Read stream data from groupName by consumerName, starting by specified message ids for this and other streams.
        Parameters:
        groupName - - name of group
        consumerName - - name of consumer
        count - - stream data size limit
        id - - starting message id for this stream
        nameToId - - Stream Message ID mapped by stream name
        Returns:
        stream data mapped by key and Stream Message ID
      • readGroupAsync

        RFuture<Map<String,​Map<StreamMessageId,​Map<K,​V>>>> readGroupAsync​(String groupName,
                                                                                            String consumerName,
                                                                                            int count,
                                                                                            long timeout,
                                                                                            TimeUnit unit,
                                                                                            StreamMessageId id,
                                                                                            String key2,
                                                                                            StreamMessageId id2)
        Read stream data from groupName by consumerName, starting by specified message ids for this and other streams. Waits for the first stream data availability for specified timeout interval.
        Parameters:
        groupName - - name of group
        consumerName - - name of consumer
        count - - stream data size limit
        timeout - - time interval to wait for stream data availability
        unit - - time interval unit
        id - - starting message id for this stream
        key2 - - name of second stream
        id2 - - starting message id for second stream
        Returns:
        stream data mapped by key and Stream Message ID
      • readGroupAsync

        RFuture<Map<String,​Map<StreamMessageId,​Map<K,​V>>>> readGroupAsync​(String groupName,
                                                                                            String consumerName,
                                                                                            int count,
                                                                                            long timeout,
                                                                                            TimeUnit unit,
                                                                                            StreamMessageId id,
                                                                                            String key2,
                                                                                            StreamMessageId id2,
                                                                                            String key3,
                                                                                            StreamMessageId id3)
        Read stream data from groupName by consumerName, starting by specified message ids for this and other streams. Waits for the first stream data availability for specified timeout interval.
        Parameters:
        groupName - - name of group
        consumerName - - name of consumer
        count - - stream data size limit
        timeout - - time interval to wait for stream data availability
        unit - - time interval unit
        id - - starting message id for this stream
        key2 - - name of second stream
        id2 - - starting message id for second stream
        key3 - - name of third stream
        id3 - - starting message id for third stream
        Returns:
        stream data mapped by key and Stream Message ID
      • readGroupAsync

        RFuture<Map<String,​Map<StreamMessageId,​Map<K,​V>>>> readGroupAsync​(String groupName,
                                                                                            String consumerName,
                                                                                            long timeout,
                                                                                            TimeUnit unit,
                                                                                            StreamMessageId id,
                                                                                            Map<String,​StreamMessageId> nameToId)
        Read stream data from groupName by consumerName, starting by specified message ids for this and other streams. Waits for the first stream data availability for specified timeout interval.
        Parameters:
        groupName - - name of group
        consumerName - - name of consumer
        timeout - - time interval to wait for stream data availability
        unit - - time interval unit
        id - - starting message id for this stream
        nameToId - - Stream Message ID mapped by stream name
        Returns:
        stream data mapped by key and Stream Message ID
      • readGroupAsync

        RFuture<Map<String,​Map<StreamMessageId,​Map<K,​V>>>> readGroupAsync​(String groupName,
                                                                                            String consumerName,
                                                                                            StreamMessageId id,
                                                                                            String key2,
                                                                                            StreamMessageId id2)
        Read stream data from groupName by consumerName, starting by specified message ids for this and other streams.
        Parameters:
        groupName - - name of group
        consumerName - - name of consumer
        id - - starting message id for this stream
        key2 - - name of second stream
        id2 - - starting message id for second stream
        Returns:
        stream data mapped by key and Stream Message ID
      • readGroupAsync

        RFuture<Map<String,​Map<StreamMessageId,​Map<K,​V>>>> readGroupAsync​(String groupName,
                                                                                            String consumerName,
                                                                                            StreamMessageId id,
                                                                                            String key2,
                                                                                            StreamMessageId id2,
                                                                                            String key3,
                                                                                            StreamMessageId id3)
        Read stream data from groupName by consumerName, starting by specified message ids for this and other streams.
        Parameters:
        groupName - - name of group
        consumerName - - name of consumer
        id - - starting message id for this stream
        key2 - - name of second stream
        id2 - - starting message id for second stream
        key3 - - name of third stream
        id3 - - starting message id for third stream
        Returns:
        stream data mapped by key and Stream Message ID
      • readGroupAsync

        RFuture<Map<String,​Map<StreamMessageId,​Map<K,​V>>>> readGroupAsync​(String groupName,
                                                                                            String consumerName,
                                                                                            int count,
                                                                                            StreamMessageId id,
                                                                                            String key2,
                                                                                            StreamMessageId id2)
        Read stream data from groupName by consumerName, starting by specified message ids for this and other streams.
        Parameters:
        groupName - - name of group
        consumerName - - name of consumer
        count - - stream data size limit
        id - - starting message id for this stream
        key2 - - name of second stream
        id2 - - starting message id for second stream
        Returns:
        stream data mapped by key and Stream Message ID
      • readGroupAsync

        RFuture<Map<String,​Map<StreamMessageId,​Map<K,​V>>>> readGroupAsync​(String groupName,
                                                                                            String consumerName,
                                                                                            int count,
                                                                                            StreamMessageId id,
                                                                                            String key2,
                                                                                            StreamMessageId id2,
                                                                                            String key3,
                                                                                            StreamMessageId id3)
        Read stream data from groupName by consumerName, starting by specified message ids for this and other streams.
        Parameters:
        groupName - - name of group
        consumerName - - name of consumer
        count - - stream data size limit
        id - - starting message id for this stream
        key2 - - name of second stream
        id2 - - starting message id for second stream
        key3 - - name of third stream
        id3 - - starting message id for third stream
        Returns:
        stream data mapped by key and Stream Message ID
      • readGroupAsync

        RFuture<Map<String,​Map<StreamMessageId,​Map<K,​V>>>> readGroupAsync​(String groupName,
                                                                                            String consumerName,
                                                                                            long timeout,
                                                                                            TimeUnit unit,
                                                                                            StreamMessageId id,
                                                                                            String key2,
                                                                                            StreamMessageId id2)
        Read stream data from groupName by consumerName, starting by specified message ids for this and other streams. Waits for the first stream data availability for specified timeout interval.
        Parameters:
        groupName - - name of group
        consumerName - - name of consumer
        timeout - - time interval to wait for stream data availability
        unit - - time interval unit
        id - - starting message id for this stream
        key2 - - name of second stream
        id2 - - starting message id for second stream
        Returns:
        stream data mapped by key and Stream Message ID
      • readGroupAsync

        RFuture<Map<String,​Map<StreamMessageId,​Map<K,​V>>>> readGroupAsync​(String groupName,
                                                                                            String consumerName,
                                                                                            long timeout,
                                                                                            TimeUnit unit,
                                                                                            StreamMessageId id,
                                                                                            String key2,
                                                                                            StreamMessageId id2,
                                                                                            String key3,
                                                                                            StreamMessageId id3)
        Read stream data from groupName by consumerName, starting by specified message ids for this and other streams. Waits for the first stream data availability for specified timeout interval.
        Parameters:
        groupName - - name of group
        consumerName - - name of consumer
        timeout - - time interval to wait for stream data availability
        unit - - time interval unit
        id - - starting message id for this stream
        key2 - - name of second stream
        id2 - - starting message id for second stream
        key3 - - name of third stream
        id3 - - starting message id for third stream
        Returns:
        stream data mapped by key and Stream Message ID
      • sizeAsync

        RFuture<Long> sizeAsync()
        Returns number of entries in stream
        Returns:
        size of stream
      • addAsync

        RFuture<StreamMessageId> addAsync​(K key,
                                          V value)
        Appends a new entry and returns generated Stream ID
        Parameters:
        key - - key of entry
        value - - value of entry
        Returns:
        Stream ID
      • addAsync

        RFuture<Void> addAsync​(StreamMessageId id,
                               K key,
                               V value)
        Appends a new entry by specified Stream ID
        Parameters:
        id - - Stream ID
        key - - key of entry
        value - - value of entry
        Returns:
        void
      • addAsync

        RFuture<StreamMessageId> addAsync​(K key,
                                          V value,
                                          int trimLen,
                                          boolean trimStrict)
        Appends a new entry and returns generated Stream ID. Trims stream to a specified trimLen size. If trimStrict is false then trims to few tens of entries more than specified length to trim.
        Parameters:
        key - - key of entry
        value - - value of entry
        trimLen - - length to trim
        trimStrict - - if false then trims to few tens of entries more than specified length to trim
        Returns:
        Stream ID
      • addAsync

        RFuture<Void> addAsync​(StreamMessageId id,
                               K key,
                               V value,
                               int trimLen,
                               boolean trimStrict)
        Appends a new entry by specified Stream ID. Trims stream to a specified trimLen size. If trimStrict is false then trims to few tens of entries more than specified length to trim.
        Parameters:
        id - - Stream ID
        key - - key of entry
        value - - value of entry
        trimLen - - length to trim
        trimStrict - - if false then trims to few tens of entries more than specified length to trim
        Returns:
        void
      • addAllAsync

        RFuture<StreamMessageId> addAllAsync​(Map<K,​V> entries)
        Appends new entries and returns generated Stream ID
        Parameters:
        entries - - entries to add
        Returns:
        Stream ID
      • addAllAsync

        RFuture<Void> addAllAsync​(StreamMessageId id,
                                  Map<K,​V> entries)
        Appends new entries by specified Stream ID
        Parameters:
        id - - Stream ID
        entries - - entries to add
        Returns:
        void
      • addAllAsync

        RFuture<StreamMessageId> addAllAsync​(Map<K,​V> entries,
                                             int trimLen,
                                             boolean trimStrict)
        Appends new entries and returns generated Stream ID. Trims stream to a specified trimLen size. If trimStrict is false then trims to few tens of entries more than specified length to trim.
        Parameters:
        entries - - entries to add
        trimLen - - length to trim
        trimStrict - - if false then trims to few tens of entries more than specified length to trim
        Returns:
        Stream ID
      • addAllAsync

        RFuture<Void> addAllAsync​(StreamMessageId id,
                                  Map<K,​V> entries,
                                  int trimLen,
                                  boolean trimStrict)
        Appends new entries by specified Stream ID. Trims stream to a specified trimLen size. If trimStrict is false then trims to few tens of entries more than specified length to trim.
        Parameters:
        id - - Stream ID
        entries - - entries to add
        trimLen - - length to trim
        trimStrict - - if false then trims to few tens of entries more than specified length to trim
        Returns:
        void
      • readAsync

        RFuture<Map<StreamMessageId,​Map<K,​V>>> readAsync​(StreamMessageId... ids)
        Read stream data by specified collection of Stream IDs.
        Parameters:
        ids - - collection of Stream IDs
        Returns:
        stream data mapped by Stream ID
      • readAsync

        RFuture<Map<StreamMessageId,​Map<K,​V>>> readAsync​(int count,
                                                                     StreamMessageId... ids)
        Read stream data by specified collection of Stream IDs.
        Parameters:
        count - - stream data size limit
        ids - - collection of Stream IDs
        Returns:
        stream data mapped by Stream ID
      • readAsync

        RFuture<Map<StreamMessageId,​Map<K,​V>>> readAsync​(long timeout,
                                                                     TimeUnit unit,
                                                                     StreamMessageId... ids)
        Read stream data by specified collection of Stream IDs. Wait for stream data availability for specified timeout interval.
        Parameters:
        timeout - - time interval to wait for stream data availability
        unit - - time interval unit
        ids - - collection of Stream IDs
        Returns:
        stream data mapped by Stream ID
      • readAsync

        RFuture<Map<StreamMessageId,​Map<K,​V>>> readAsync​(int count,
                                                                     long timeout,
                                                                     TimeUnit unit,
                                                                     StreamMessageId... ids)
        Read stream data by specified collection of Stream IDs. Wait for stream data availability for specified timeout interval.
        Parameters:
        count - - stream data size limit
        timeout - - time interval to wait for stream data availability
        unit - - time interval unit
        ids - - collection of Stream IDs
        Returns:
        stream data mapped by Stream ID
      • readAsync

        RFuture<Map<String,​Map<StreamMessageId,​Map<K,​V>>>> readAsync​(int count,
                                                                                       StreamMessageId id,
                                                                                       String name2,
                                                                                       StreamMessageId id2)
        Read stream data by specified stream name including this stream.
        Parameters:
        count - - stream data size limit
        id - - id of this stream
        name2 - - name of second stream
        id2 - - id of second stream
        Returns:
        stream data mapped by key and Stream ID
      • readAsync

        RFuture<Map<String,​Map<StreamMessageId,​Map<K,​V>>>> readAsync​(int count,
                                                                                       StreamMessageId id,
                                                                                       String name2,
                                                                                       StreamMessageId id2,
                                                                                       String name3,
                                                                                       StreamMessageId id3)
        Read stream data by specified stream names including this stream.
        Parameters:
        count - - stream data size limit
        id - - id of this stream
        name2 - - name of second stream
        id2 - - id of second stream
        name3 - - name of third stream
        id3 - - id of third stream
        Returns:
        stream data mapped by key and Stream ID
      • readAsync

        RFuture<Map<String,​Map<StreamMessageId,​Map<K,​V>>>> readAsync​(int count,
                                                                                       StreamMessageId id,
                                                                                       Map<String,​StreamMessageId> nameToId)
        Read stream data by specified stream id mapped by name including this stream.
        Parameters:
        count - - stream data size limit
        id - - id of this stream
        nameToId - - stream id mapped by name
        Returns:
        stream data mapped by key and Stream ID
      • readAsync

        RFuture<Map<String,​Map<StreamMessageId,​Map<K,​V>>>> readAsync​(long timeout,
                                                                                       TimeUnit unit,
                                                                                       StreamMessageId id,
                                                                                       String name2,
                                                                                       StreamMessageId id2)
        Read stream data by specified stream name including this stream. Wait for the first stream data availability for specified timeout interval.
        Parameters:
        timeout - - time interval to wait for stream data availability
        unit - - time interval unit
        id - - id of this stream
        name2 - - name of second stream
        id2 - - id of second stream
        Returns:
        stream data mapped by key and Stream ID
      • readAsync

        RFuture<Map<String,​Map<StreamMessageId,​Map<K,​V>>>> readAsync​(long timeout,
                                                                                       TimeUnit unit,
                                                                                       StreamMessageId id,
                                                                                       String name2,
                                                                                       StreamMessageId id2,
                                                                                       String name3,
                                                                                       StreamMessageId id3)
        Read stream data by specified stream names including this stream. Wait for the first stream data availability for specified timeout interval.
        Parameters:
        timeout - - time interval to wait for stream data availability
        unit - - time interval unit
        id - - id of this stream
        name2 - - name of second stream
        id2 - - id of second stream
        name3 - - name of third stream
        id3 - - id of third stream
        Returns:
        stream data mapped by key and Stream ID
      • readAsync

        RFuture<Map<String,​Map<StreamMessageId,​Map<K,​V>>>> readAsync​(long timeout,
                                                                                       TimeUnit unit,
                                                                                       StreamMessageId id,
                                                                                       Map<String,​StreamMessageId> nameToId)
        Read stream data by specified stream id mapped by name including this stream. Wait for the first stream data availability for specified timeout interval.
        Parameters:
        timeout - - time interval to wait for stream data availability
        unit - - time interval unit
        id - - id of this stream
        nameToId - - stream id mapped by name
        Returns:
        stream data mapped by key and Stream ID
      • readAsync

        RFuture<Map<String,​Map<StreamMessageId,​Map<K,​V>>>> readAsync​(int count,
                                                                                       long timeout,
                                                                                       TimeUnit unit,
                                                                                       StreamMessageId id,
                                                                                       String name2,
                                                                                       StreamMessageId id2)
        Read stream data by specified stream name including this stream. Wait for the first stream data availability for specified timeout interval.
        Parameters:
        count - - stream data size limit
        timeout - - time interval to wait for stream data availability
        unit - - time interval unit
        id - - id of this stream
        name2 - - name of second stream
        id2 - - id of second stream
        Returns:
        stream data mapped by key and Stream ID
      • readAsync

        RFuture<Map<String,​Map<StreamMessageId,​Map<K,​V>>>> readAsync​(int count,
                                                                                       long timeout,
                                                                                       TimeUnit unit,
                                                                                       StreamMessageId id,
                                                                                       String name2,
                                                                                       StreamMessageId id2,
                                                                                       String name3,
                                                                                       StreamMessageId id3)
        Read stream data by specified stream names including this stream. Wait for the first stream data availability for specified timeout interval.
        Parameters:
        count - - stream data size limit
        timeout - - time interval to wait for stream data availability
        unit - - time interval unit
        id - - id of this stream
        name2 - - name of second stream
        id2 - - id of second stream
        name3 - - name of third stream
        id3 - - id of third stream
        Returns:
        stream data mapped by key and Stream ID
      • readAsync

        RFuture<Map<String,​Map<StreamMessageId,​Map<K,​V>>>> readAsync​(int count,
                                                                                       long timeout,
                                                                                       TimeUnit unit,
                                                                                       StreamMessageId id,
                                                                                       Map<String,​StreamMessageId> nameToId)
        Read stream data by specified stream id mapped by name including this stream. Wait for the first stream data availability for specified timeout interval.
        Parameters:
        count - - stream data size limit
        timeout - - time interval to wait for stream data availability
        unit - - time interval unit
        id - - id of this stream
        nameToId - - stream id mapped by name
        Returns:
        stream data mapped by key and Stream ID
      • rangeAsync

        RFuture<Map<StreamMessageId,​Map<K,​V>>> rangeAsync​(StreamMessageId startId,
                                                                      StreamMessageId endId)
        Read stream data in range by specified start Stream ID (included) and end Stream ID (included).
        Parameters:
        startId - - start Stream ID
        endId - - end Stream ID
        Returns:
        stream data mapped by Stream ID
      • rangeAsync

        RFuture<Map<StreamMessageId,​Map<K,​V>>> rangeAsync​(int count,
                                                                      StreamMessageId startId,
                                                                      StreamMessageId endId)
        Read stream data in range by specified start Stream ID (included) and end Stream ID (included).
        Parameters:
        count - - stream data size limit
        startId - - start Stream ID
        endId - - end Stream ID
        Returns:
        stream data mapped by Stream ID
      • rangeReversedAsync

        RFuture<Map<StreamMessageId,​Map<K,​V>>> rangeReversedAsync​(StreamMessageId startId,
                                                                              StreamMessageId endId)
        Read stream data in reverse order in range by specified start Stream ID (included) and end Stream ID (included).
        Parameters:
        startId - - start Stream ID
        endId - - end Stream ID
        Returns:
        stream data mapped by Stream ID
      • rangeReversedAsync

        RFuture<Map<StreamMessageId,​Map<K,​V>>> rangeReversedAsync​(int count,
                                                                              StreamMessageId startId,
                                                                              StreamMessageId endId)
        Read stream data in reverse order in range by specified start Stream ID (included) and end Stream ID (included).
        Parameters:
        count - - stream data size limit
        startId - - start Stream ID
        endId - - end Stream ID
        Returns:
        stream data mapped by Stream ID
      • removeAsync

        RFuture<Long> removeAsync​(StreamMessageId... ids)
        Removes messages by id.
        Parameters:
        ids - - id of messages to remove
        Returns:
        deleted messages amount
      • trimAsync

        RFuture<Long> trimAsync​(int size)
        Trims stream to specified size
        Parameters:
        size - - new size of stream
        Returns:
        number of deleted messages
      • trimNonStrictAsync

        RFuture<Long> trimNonStrictAsync​(int size)
        Trims stream to few tens of entries more than specified length to trim.
        Parameters:
        size - - new size of stream
        Returns:
        number of deleted messages