Class RemoteStore<K,​V>

    • Constructor Detail

      • RemoteStore

        public RemoteStore()
    • Method Detail

      • contains

        public boolean contains​(java.lang.Object key)
                         throws PersistenceException
        Description copied from interface: CacheLoader
        Returns true if the storage contains an entry associated with the given key.
        Specified by:
        contains in interface CacheLoader<K,​V>
        Throws:
        PersistenceException - in case of an error, e.g. communicating with the external storage
      • publishKeys

        public io.reactivex.Flowable<K> publishKeys​(java.util.function.Predicate<? super K> filter)
        Description copied from interface: AdvancedCacheLoader
        Publishes all the keys from this store. The given publisher can be used by as many Subscribers as desired. Keys are not retrieved until a given Subscriber requests them from the Subscription.

        Stores will return only non expired keys

        Specified by:
        publishKeys in interface AdvancedCacheLoader<K,​V>
        Parameters:
        filter - a filter - null is treated as allowing all entries
        Returns:
        a publisher that will provide the keys from the store
      • publishKeys

        public io.reactivex.Flowable<K> publishKeys​(IntSet segments,
                                                    java.util.function.Predicate<? super K> filter)
        Description copied from interface: SegmentedAdvancedLoadWriteStore
        Publishes all the keys that map to the given segments from this store. The given publisher can be used by as many Subscribers as desired. Keys are not retrieved until a given Subscriber requests them from the Subscription.

        Stores will return only non expired keys

        The segments here must be adhered to and the keys published must not include any that don't belong to the provided segments.

        This method is not invoked invoked when the store is not configured to be StoreConfiguration.segmented().

        Specified by:
        publishKeys in interface SegmentedAdvancedLoadWriteStore<K,​V>
        Parameters:
        segments - the segments that the keys must map to. Always non null.
        filter - a filter
        Returns:
        a publisher that will provide the keys from the store
      • publishEntries

        public org.reactivestreams.Publisher<MarshalledEntry<K,​V>> publishEntries​(java.util.function.Predicate<? super K> filter,
                                                                                        boolean fetchValue,
                                                                                        boolean fetchMetadata)
        Description copied from interface: AdvancedCacheLoader
        Publishes all entries from this store. The given publisher can be used by as many Subscribers as desired. Entries are not retrieved until a given Subscriber requests them from the Subscription.

        If fetchMetadata is true this store must guarantee to not return any expired entries.

        Specified by:
        publishEntries in interface AdvancedCacheLoader<K,​V>
        Parameters:
        filter - a filter - null is treated as allowing all entries
        fetchValue - whether or not to fetch the value from the persistent store. E.g. if the iteration is intended only over the key set, no point fetching the values from the persistent store as well
        fetchMetadata - whether or not to fetch the metadata from the persistent store. E.g. if the iteration is intended only ove the key set, then no point fetching the metadata from the persistent store as well
        Returns:
        a publisher that will provide the entries from the store
      • publishEntries

        public org.reactivestreams.Publisher<MarshalledEntry<K,​V>> publishEntries​(IntSet segments,
                                                                                        java.util.function.Predicate<? super K> filter,
                                                                                        boolean fetchValue,
                                                                                        boolean fetchMetadata)
        Description copied from interface: SegmentedAdvancedLoadWriteStore
        Publishes all entries from this store. The given publisher can be used by as many Subscribers as desired. Entries are not retrieved until a given Subscriber requests them from the Subscription.

        If fetchMetadata is true this store must guarantee to not return any expired entries.

        The segments here must be adhered to and the entries published must not include any that don't belong to the provided segments.

        This method is not invoked invoked when the store is not configured to be StoreConfiguration.segmented(). StoreConfiguration.segmented().

        Specified by:
        publishEntries in interface SegmentedAdvancedLoadWriteStore<K,​V>
        Parameters:
        segments - the segments that the keys of the entries must map to. Always non null.
        filter - a filter on the keys of the entries that if passed will allow the given entry to be returned from the publisher
        fetchValue - whether the value should be included in the marshalled entry
        fetchMetadata - whether the metadata should be included in the marshalled entry
        Returns:
        a publisher that will provide the entries from the store that map to the given segments
      • size

        public int size​(IntSet segments)
        Description copied from interface: SegmentedAdvancedLoadWriteStore
        Returns the number of elements in the store that map to the given segments that aren't expired.

        The segments here must be adhered to and the size must not count any entries that don't belong to the provided segments.

        This method is not invoked invoked when the store is not configured to be StoreConfiguration.segmented().

        Specified by:
        size in interface SegmentedAdvancedLoadWriteStore<K,​V>
        Parameters:
        segments - the segments which should have their entries counted. Always non null.
        Returns:
        the count of entries in the given segments
      • purge

        public void purge​(java.util.concurrent.Executor threadPool,
                          AdvancedCacheWriter.PurgeListener task)
        Description copied from interface: AdvancedCacheWriter
        Using the thread in the pool, removed all the expired data from the persistence storage. For each removed entry, the supplied listener is invoked.

        When this method returns all entries will be purged and no tasks will be running due to this loader in the provided executor. If however an exception is thrown there could be tasks still pending or running in the executor.

        Specified by:
        purge in interface AdvancedCacheWriter<K,​V>
      • writeBatch

        public void writeBatch​(java.lang.Iterable<MarshalledEntry<? extends K,​? extends V>> marshalledEntries)
        Description copied from interface: CacheWriter
        Persist all provided entries to the store in a single batch update. If this is not supported by the underlying store, then entries are written to the store individually via CacheWriter.write(MarshalledEntry).
        Specified by:
        writeBatch in interface CacheWriter<K,​V>
        Parameters:
        marshalledEntries - an Iterable of MarshalledEntry to be written to the store.
      • delete

        public boolean delete​(java.lang.Object key)
                       throws PersistenceException
        Specified by:
        delete in interface CacheWriter<K,​V>
        Returns:
        true if the entry existed in the persistent store and it was deleted.
        Throws:
        PersistenceException - in case of an error, e.g. communicating with the external storage
      • setInternalCacheEntryFactory

        public void setInternalCacheEntryFactory​(org.infinispan.container.impl.InternalEntryFactory iceFactory)
      • getRemoteCache

        public RemoteCache<java.lang.Object,​java.lang.Object> getRemoteCache()