com.algolia.search

Class AsyncIndex<T>

java.lang.Object

com.algolia.search.AbstractIndex

com.algolia.search.AsyncIndex<T>

public class AsyncIndex<T>
extends AbstractIndex

Nested Class Summary

Nested classes/interfaces inherited from class com.algolia.search.AbstractIndex

AbstractIndex.Attributes

Method Summary

Modifier and Type	Method and Description
CompletableFuture<CreateUpdateKey>	addKey(ApiKey key) Add a key to this index
CompletableFuture<AsyncTaskIndexing>	addObject(String objectID, T object) Add an object in this index with a unique identifier
CompletableFuture<AsyncTaskIndexing>	addObject(T object) Add an object in this index
CompletableFuture<AsyncTaskSingleIndex>	addObjects(List<T> objects) Add several objects
CompletableFuture<AsyncTaskSingleIndex>	batch(List<BatchOperation> operations) Custom batch
CompletableFuture<AsyncTask>	batchSynonyms(List<AbstractSynonym> synonyms) Add or Replace a list of synonyms, no forward to slaves, and no replacement
CompletableFuture<AsyncTask>	batchSynonyms(List<AbstractSynonym> synonyms, boolean forwardToReplicas) Add or Replace a list of synonyms, no replacement
CompletableFuture<AsyncTask>	batchSynonyms(List<AbstractSynonym> synonyms, boolean forwardToReplicas, boolean replaceExistingSynonyms) Add or Replace a list of synonyms
CompletableFuture<AsyncTask>	clear() Delete the index content without removing settings and index specific API keys.
CompletableFuture<AsyncTask>	clearSynonyms() Clear all synonyms and NOT forwarding it to the slaves
CompletableFuture<AsyncTask>	clearSynonyms(boolean forwardToReplicas) Clears all synonyms
CompletableFuture<AsyncTask>	copyTo(String dstIndexName) Copy an existing index
CompletableFuture<AsyncTask>	delete() Deletes the index
CompletableFuture<DeleteKey>	deleteKey(String key) Delete a key by name from this index
CompletableFuture<AsyncTask>	deleteObject(String objectID) Delete an object from the index
CompletableFuture<AsyncTaskSingleIndex>	deleteObjects(List<String> objectIDs) Delete objects from the index
CompletableFuture<AsyncTask>	deleteSynonym(String synonymID) Deletes a synonym by ID and NOT forwarding it to the slaves
CompletableFuture<AsyncTask>	deleteSynonym(String synonymID, boolean forwardToReplicas) Deletes a synonym
CompletableFuture<Optional<ApiKey>>	getKey(String key) Get a key by name from this index
Class<T>	getKlass()
String	getName()
CompletableFuture<Optional<T>>	getObject(String objectID) Get an object from this index
CompletableFuture<List<T>>	getObjects(List<String> objectIDs) Get several objects from this index
CompletableFuture<List<T>>	getObjects(List<String> objectIDs, List<String> attributesToRetrieve) Get several objects from this index
CompletableFuture<IndexSettings>	getSettings() Get settings of this index
CompletableFuture<Optional<AbstractSynonym>>	getSynonym(String synonymID) Get a synonym by ID
CompletableFuture<List<ApiKey>>	listKeys() List keys of this index
CompletableFuture<AsyncTask>	moveTo(String dstIndexName) Moves an existing index
CompletableFuture<AsyncTaskSingleIndex>	partialUpdateObject(PartialUpdateOperation operation) Partially update an object, create the object if it does not exist
CompletableFuture<AsyncTaskSingleIndex>	partialUpdateObject(PartialUpdateOperation operation, boolean createIfNotExists) Partially update an object
CompletableFuture<AsyncTaskSingleIndex>	partialUpdateObject(String objectID, Object object) Partially update an object
CompletableFuture<AsyncTaskSingleIndex>	partialUpdateObjects(List<Object> objects) Partially update a objects
CompletableFuture<AsyncTask>	saveObject(String objectID, T object) Override the content of object
CompletableFuture<AsyncTaskSingleIndex>	saveObjects(List<T> objects) Override the content the list of objects
CompletableFuture<AsyncTask>	saveSynonym(String synonymID, AbstractSynonym content) Saves/updates a synonym without replacing it and NOT forwarding it to the slaves
CompletableFuture<AsyncTask>	saveSynonym(String synonymID, AbstractSynonym content, boolean forwardToReplicas) Saves/updates a synonym without replacing
CompletableFuture<AsyncTask>	saveSynonym(String synonymID, AbstractSynonym content, boolean forwardToReplicas, boolean replaceExistingSynonyms) Saves/updates a synonym
CompletableFuture<SearchResult<T>>	search(Query query) Search in the index
CompletableFuture<SearchSynonymResult>	searchSynonyms(SynonymQuery query) Search for synonyms
CompletableFuture<AsyncTask>	setSettings(IndexSettings settings) Set settings of this index, and do not forward to slaves
CompletableFuture<AsyncTask>	setSettings(IndexSettings settings, Boolean forwardToReplicas) Set settings of this index
CompletableFuture<CreateUpdateKey>	updateKey(String keyName, ApiKey key) Update a key by name from this index
void	waitTask(AsyncTask task) Wait for the completion of a task, for 100ms
void	waitTask(AsyncTask task, long timeToWait) Wait for the completion of a task

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

getName

public String getName()

Specified by:

getName in class AbstractIndex

getKlass

public Class<T> getKlass()

Specified by:

getKlass in class AbstractIndex

addObject

public CompletableFuture<AsyncTaskIndexing> addObject(@Nonnull
                                                      T object)
                                               throws AlgoliaException

Add an object in this index

Parameters:

object - object to add

Returns:

the related AsyncTask

Throws:

AlgoliaException

addObject

public CompletableFuture<AsyncTaskIndexing> addObject(@Nonnull
                                                      String objectID,
                                                      @Nonnull
                                                      T object)
                                               throws AlgoliaException

Add an object in this index with a unique identifier

Parameters:

objectID - the objectID associated to this object (if this objectID already exist the old object will be overridden)

object - object to add

Returns:

the related AsyncTask

Throws:

AlgoliaException

addObjects

public CompletableFuture<AsyncTaskSingleIndex> addObjects(@Nonnull
                                                          List<T> objects)
                                                   throws AlgoliaException

Add several objects

Parameters:

objects - objects to add

Returns:

the related AsyncTask

Throws:

AlgoliaException

getObject

public CompletableFuture<Optional<T>> getObject(@Nonnull
                                                String objectID)
                                         throws AlgoliaException

Get an object from this index

Parameters:

objectID - the unique identifier of the object to retrieve

Returns:

The object

Throws:

AlgoliaException

getObjects

public CompletableFuture<List<T>> getObjects(@Nonnull
                                             List<String> objectIDs)
                                      throws AlgoliaException

Get several objects from this index

Parameters:

objectIDs - the list of unique identifier of objects to retrieve

Returns:

the list of objects

Throws:

AlgoliaException

getObjects

public CompletableFuture<List<T>> getObjects(@Nonnull
                                             List<String> objectIDs,
                                             @Nonnull
                                             List<String> attributesToRetrieve)
                                      throws AlgoliaException

Get several objects from this index

Parameters:

objectIDs - the list of unique identifier of objects to retrieve

attributesToRetrieve - the list of attributes to retrieve for these objects

Returns:

the list of objects

Throws:

AlgoliaException

waitTask

public void waitTask(@Nonnull
                     AsyncTask task,
                     long timeToWait)
              throws AlgoliaException

Wait for the completion of a task

Parameters:

task - task to wait for

timeToWait - the time to wait in milliseconds

Throws:

AlgoliaException

waitTask

public void waitTask(@Nonnull
                     AsyncTask task)
              throws AlgoliaException

Wait for the completion of a task, for 100ms

Parameters:

task - task to wait for

Throws:

AlgoliaException

delete

public CompletableFuture<AsyncTask> delete()
                                    throws AlgoliaException

Deletes the index

Returns:

the related AsyncTask

Throws:

AlgoliaException

clear

public CompletableFuture<AsyncTask> clear()
                                   throws AlgoliaException

Delete the index content without removing settings and index specific API keys.

Returns:

the related AsyncTask

Throws:

AlgoliaException

saveObject

public CompletableFuture<AsyncTask> saveObject(@Nonnull
                                               String objectID,
                                               @Nonnull
                                               T object)
                                        throws AlgoliaException

Override the content of object

Parameters:

objectID - the unique identifier of the object to retrieve

object - the object to update

Returns:

the related AsyncTask

Throws:

AlgoliaException

saveObjects

public CompletableFuture<AsyncTaskSingleIndex> saveObjects(@Nonnull
                                                           List<T> objects)
                                                    throws AlgoliaException

Override the content the list of objects

Parameters:

objects - the list objects to update

Returns:

the related AsyncTask

Throws:

AlgoliaException

deleteObject

public CompletableFuture<AsyncTask> deleteObject(@Nonnull
                                                 String objectID)
                                          throws AlgoliaException

Delete an object from the index

Parameters:

objectID - the unique identifier of the object to retrieve

Returns:

the related AsyncTask

Throws:

AlgoliaException

deleteObjects

public CompletableFuture<AsyncTaskSingleIndex> deleteObjects(@Nonnull
                                                             List<String> objectIDs)
                                                      throws AlgoliaException

Delete objects from the index

Parameters:

objectIDs - the list of unique identifier of the object to retrieve

Returns:

the related AsyncTask

Throws:

AlgoliaException

getSettings

public CompletableFuture<IndexSettings> getSettings()
                                             throws AlgoliaException

Get settings of this index

Returns:

the settings

Throws:

AlgoliaException

setSettings

public CompletableFuture<AsyncTask> setSettings(@Nonnull
                                                IndexSettings settings)
                                         throws AlgoliaException

Set settings of this index, and do not forward to slaves

Parameters:

settings - the settings to set

Returns:

the related AsyncTask

Throws:

AlgoliaException

setSettings

public CompletableFuture<AsyncTask> setSettings(@Nonnull
                                                IndexSettings settings,
                                                @Nonnull
                                                Boolean forwardToReplicas)
                                         throws AlgoliaException

Set settings of this index

Parameters:

settings - the settings to set

forwardToReplicas - should these updates be forwarded to the slaves

Returns:

the related AsyncTask

Throws:

AlgoliaException

listKeys

public CompletableFuture<List<ApiKey>> listKeys()
                                         throws AlgoliaException

List keys of this index

Returns:

the list of keys

Throws:

AlgoliaException

getKey

public CompletableFuture<Optional<ApiKey>> getKey(@Nonnull
                                                  String key)
                                           throws AlgoliaException

Get a key by name from this index

Parameters:

key - the key name

Returns:

the key

Throws:

AlgoliaException

deleteKey

public CompletableFuture<DeleteKey> deleteKey(@Nonnull
                                              String key)
                                       throws AlgoliaException

Delete a key by name from this index

Parameters:

key - the key name

Returns:

the deleted key

Throws:

AlgoliaException

addKey

public CompletableFuture<CreateUpdateKey> addKey(@Nonnull
                                                 ApiKey key)
                                          throws AlgoliaException

Add a key to this index

Parameters:

key - the key

Returns:

the created key

Throws:

AlgoliaException

updateKey

public CompletableFuture<CreateUpdateKey> updateKey(@Nonnull
                                                    String keyName,
                                                    @Nonnull
                                                    ApiKey key)
                                             throws AlgoliaException

Update a key by name from this index

Parameters:

keyName - the key name

key - the key to update

Returns:

the updated key

Throws:

AlgoliaException

moveTo

public CompletableFuture<AsyncTask> moveTo(@Nonnull
                                           String dstIndexName)
                                    throws AlgoliaException

Moves an existing index

Parameters:

dstIndexName - the new index name that will contains a copy of srcIndexName (destination will be overriten if it already exist)

Returns:

The task associated

Throws:

AlgoliaException

copyTo

public CompletableFuture<AsyncTask> copyTo(@Nonnull
                                           String dstIndexName)
                                    throws AlgoliaException

Copy an existing index

Parameters:

dstIndexName - the new index name that will contains a copy of srcIndexName (destination will be overridden if it already exist)

Returns:

The task associated

Throws:

AlgoliaException

search

public CompletableFuture<SearchResult<T>> search(@Nonnull
                                                 Query query)
                                          throws AlgoliaException

Search in the index

Parameters:

query - the query

Returns:

the result of the search, or a failed Future if the index does not exists

Throws:

AlgoliaException

batch

public CompletableFuture<AsyncTaskSingleIndex> batch(@Nonnull
                                                     List<BatchOperation> operations)
                                              throws AlgoliaException

Custom batch

All operations must have index name set to null

Parameters:

operations - the list of operations to perform on this index

Returns:

the associated task

Throws:

AlgoliaException

See Also:

& subclasses

partialUpdateObject

public CompletableFuture<AsyncTaskSingleIndex> partialUpdateObject(@Nonnull
                                                                   String objectID,
                                                                   @Nonnull
                                                                   Object object)
                                                            throws AlgoliaException

Partially update an object

Parameters:

objectID - the ID of object to update

object - the object to update

Returns:

the associated task

Throws:

AlgoliaException

See Also:

& subclasses

partialUpdateObjects

public CompletableFuture<AsyncTaskSingleIndex> partialUpdateObjects(@Nonnull
                                                                    List<Object> objects)
                                                             throws AlgoliaException

Partially update a objects

Parameters:

objects - the list of objects to update (with an objectID)

Returns:

the associated task

Throws:

AlgoliaException

partialUpdateObject

public CompletableFuture<AsyncTaskSingleIndex> partialUpdateObject(@Nonnull
                                                                   PartialUpdateOperation operation)
                                                            throws AlgoliaException

Partially update an object, create the object if it does not exist

Parameters:

operation - the operation to perform on this object

Returns:

the associated task

Throws:

AlgoliaException

See Also:

& subclasses

partialUpdateObject

public CompletableFuture<AsyncTaskSingleIndex> partialUpdateObject(@Nonnull
                                                                   PartialUpdateOperation operation,
                                                                   boolean createIfNotExists)
                                                            throws AlgoliaException

Partially update an object

Parameters:

operation - the operation to perform on this object

createIfNotExists - should the object be created or not

Returns:

the associated task

Throws:

AlgoliaException

See Also:

& subclasses

saveSynonym

public CompletableFuture<AsyncTask> saveSynonym(@Nonnull
                                                String synonymID,
                                                @Nonnull
                                                AbstractSynonym content)
                                         throws AlgoliaException

Saves/updates a synonym without replacing it and NOT forwarding it to the slaves

Parameters:

synonymID - the id of the synonym

content - the synonym

Returns:

the associated task

Throws:

AlgoliaException

saveSynonym

public CompletableFuture<AsyncTask> saveSynonym(@Nonnull
                                                String synonymID,
                                                @Nonnull
                                                AbstractSynonym content,
                                                boolean forwardToReplicas)
                                         throws AlgoliaException

Saves/updates a synonym without replacing

Parameters:

synonymID - the id of the synonym

content - the synonym

forwardToReplicas - should this request be forwarded to slaves

Returns:

the associated task

Throws:

AlgoliaException

saveSynonym

public CompletableFuture<AsyncTask> saveSynonym(@Nonnull
                                                String synonymID,
                                                @Nonnull
                                                AbstractSynonym content,
                                                boolean forwardToReplicas,
                                                boolean replaceExistingSynonyms)
                                         throws AlgoliaException

Saves/updates a synonym

Parameters:

synonymID - the id of the synonym

content - the synonym

forwardToReplicas - should this request be forwarded to slaves

replaceExistingSynonyms - should replace if this synonyms exists

Returns:

the associated task

Throws:

AlgoliaException

getSynonym

public CompletableFuture<Optional<AbstractSynonym>> getSynonym(@Nonnull
                                                               String synonymID)
                                                        throws AlgoliaException

Get a synonym by ID

Parameters:

synonymID - the id of the synonym

Returns:

the associated task

Throws:

AlgoliaException

deleteSynonym

public CompletableFuture<AsyncTask> deleteSynonym(@Nonnull
                                                  String synonymID)
                                           throws AlgoliaException

Deletes a synonym by ID and NOT forwarding it to the slaves

Parameters:

synonymID - the id of the synonym

Returns:

the associated task

Throws:

AlgoliaException

deleteSynonym

public CompletableFuture<AsyncTask> deleteSynonym(@Nonnull
                                                  String synonymID,
                                                  boolean forwardToReplicas)
                                           throws AlgoliaException

Deletes a synonym

Parameters:

synonymID - the id of the synonym

forwardToReplicas - should this request be forwarded to slaves

Returns:

the associated task

Throws:

AlgoliaException

clearSynonyms

public CompletableFuture<AsyncTask> clearSynonyms()
                                           throws AlgoliaException

Clear all synonyms and NOT forwarding it to the slaves

Returns:

the associated task

Throws:

AlgoliaException

clearSynonyms

public CompletableFuture<AsyncTask> clearSynonyms(boolean forwardToReplicas)
                                           throws AlgoliaException

Clears all synonyms

Returns:

the associated task

Throws:

AlgoliaException

searchSynonyms

public CompletableFuture<SearchSynonymResult> searchSynonyms(@Nonnull
                                                             SynonymQuery query)
                                                      throws AlgoliaException

Search for synonyms

Parameters:

query - the query

Returns:

the results of the query

Throws:

AlgoliaException

batchSynonyms

public CompletableFuture<AsyncTask> batchSynonyms(@Nonnull
                                                  List<AbstractSynonym> synonyms,
                                                  boolean forwardToReplicas,
                                                  boolean replaceExistingSynonyms)
                                           throws AlgoliaException

Add or Replace a list of synonyms

Parameters:

synonyms - List of synonyms

forwardToReplicas - Forward the operation to the slave indices

replaceExistingSynonyms - Replace the existing synonyms with this batch

Returns:

the associated task

Throws:

AlgoliaException

batchSynonyms

public CompletableFuture<AsyncTask> batchSynonyms(@Nonnull
                                                  List<AbstractSynonym> synonyms,
                                                  boolean forwardToReplicas)
                                           throws AlgoliaException

Add or Replace a list of synonyms, no replacement

Parameters:

synonyms - List of synonyms

forwardToReplicas - Forward the operation to the slave indices

Returns:

the associated task

Throws:

AlgoliaException

batchSynonyms

public CompletableFuture<AsyncTask> batchSynonyms(@Nonnull
                                                  List<AbstractSynonym> synonyms)
                                           throws AlgoliaException

Add or Replace a list of synonyms, no forward to slaves, and no replacement

Parameters:

synonyms - List of synonyms

Returns:

the associated task

Throws:

AlgoliaException