CouchbaseAsyncBucket (java-client 2.0.0 API)

java.lang.Object
- com.couchbase.client.java.CouchbaseAsyncBucket

All Implemented Interfaces:: AsyncBucket

public class CouchbaseAsyncBucket
extends java.lang.Object
implements AsyncBucket

Field Summary

Fields
Modifier and Type	Field and Description
`static BinaryTranscoder`	`BINARY_TRANSCODER`
`static JsonArrayTranscoder`	`JSON_ARRAY_TRANSCODER`
`static JsonBooleanTranscoder`	`JSON_BOOLEAN_TRANSCODER`
`static JsonDoubleTranscoder`	`JSON_DOUBLE_TRANSCODER`
`static JsonLongTranscoder`	`JSON_LONG_TRANSCODER`
`static JsonTranscoder`	`JSON_OBJECT_TRANSCODER`
`static JsonStringTranscoder`	`JSON_STRING_TRANSCODER`
`static LegacyTranscoder`	`LEGACY_TRANSCODER`
`static SerializableTranscoder`	`SERIALIZABLE_TRANSCODER`
`static StringTranscoder`	`STRING_TRANSCODER`

Constructor Summary

Constructors
Constructor and Description
`CouchbaseAsyncBucket(com.couchbase.client.core.ClusterFacade core, java.lang.String name, java.lang.String password, java.util.List<Transcoder<? extends Document,?>> customTranscoders)`

Method Summary

Methods
Modifier and Type	Method and Description
`<D extends Document<?>> rx.Observable<D>`	`append(D document)` Append a `Document` to another one.
`rx.Observable<AsyncBucketManager>`	`bucketManager()` Provides access to the `AsyncBucketManager` for administrative access.
`rx.Observable<java.lang.Boolean>`	`close()` Closes the `AsyncBucket`.
`rx.Observable<JsonLongDocument>`	`counter(java.lang.String id, long delta)` Increment or decrement a counter with the given value and a default value of 0.
`rx.Observable<JsonLongDocument>`	`counter(java.lang.String id, long delta, long initial)` Increment or decrement a counter with the given value and a initial value if it does not exist.
`rx.Observable<JsonLongDocument>`	`counter(java.lang.String id, long delta, long initial, int expiry)` Increment or decrement a counter with the given value and a initial value if it does not exist.
`<D extends Document<?>> rx.Observable<D>`	`get(D document)` Retrieves any type of `Document` by its unique ID.
`rx.Observable<JsonDocument>`	`get(java.lang.String id)` Retrieves a `JsonDocument` by its unique ID.
`<D extends Document<?>> rx.Observable<D>`	`get(java.lang.String id, java.lang.Class<D> target)` Retrieves any type of `Document` by its unique ID.
`<D extends Document<?>> rx.Observable<D>`	`getAndLock(D document, int lockTime)` Retrieve and lock a `Document` by its unique ID.
`rx.Observable<JsonDocument>`	`getAndLock(java.lang.String id, int lockTime)` Retrieve and lock a `JsonDocument` by its unique ID.
`<D extends Document<?>> rx.Observable<D>`	`getAndLock(java.lang.String id, int lockTime, java.lang.Class<D> target)` Retrieve and lock a `Document` by its unique ID.
`<D extends Document<?>> rx.Observable<D>`	`getAndTouch(D document)` Retrieve and touch a `Document` by its unique ID.
`rx.Observable<JsonDocument>`	`getAndTouch(java.lang.String id, int expiry)` Retrieve and touch a `JsonDocument` by its unique ID.
`<D extends Document<?>> rx.Observable<D>`	`getAndTouch(java.lang.String id, int expiry, java.lang.Class<D> target)` Retrieve and touch a `Document` by its unique ID.
`<D extends Document<?>> rx.Observable<D>`	`getFromReplica(D document, ReplicaMode type)` Retrieves one or more, possibly stale, representations of a `Document` by its unique ID.
`rx.Observable<JsonDocument>`	`getFromReplica(java.lang.String id, ReplicaMode type)` Retrieves one or more, possibly stale, representations of a `JsonDocument` by its unique ID.
`<D extends Document<?>> rx.Observable<D>`	`getFromReplica(java.lang.String id, ReplicaMode type, java.lang.Class<D> target)` Retrieves one or more, possibly stale, representations of a `Document` by its unique ID.
`<D extends Document<?>> rx.Observable<D>`	`insert(D document)` Insert a `Document` if it does not exist already.
`<D extends Document<?>> rx.Observable<D>`	`insert(D document, PersistTo persistTo)` Insert a `Document` if it does not exist already and watch for durability constraints.
`<D extends Document<?>> rx.Observable<D>`	`insert(D document, PersistTo persistTo, ReplicateTo replicateTo)` Insert a `Document` if it does not exist already and watch for durability constraints.
`<D extends Document<?>> rx.Observable<D>`	`insert(D document, ReplicateTo replicateTo)` Insert a `Document` if it does not exist already and watch for durability constraints.
`java.lang.String`	`name()` The name of the `Bucket`.
`<D extends Document<?>> rx.Observable<D>`	`prepend(D document)` Prepend a `Document` to another one.
`rx.Observable<AsyncQueryResult>`	`query(Query query)` Experimental: Queries a N1QL secondary index.
`rx.Observable<AsyncQueryResult>`	`query(java.lang.String query)` Experimental: Queries a N1QL secondary index.
`rx.Observable<AsyncViewResult>`	`query(ViewQuery query)` Queries a Couchbase Server `View`.
`<D extends Document<?>> rx.Observable<D>`	`remove(D document)` Removes a `Document` from the Server.
`<D extends Document<?>> rx.Observable<D>`	`remove(D document, PersistTo persistTo)` Removes a `Document` from the Server and apply a durability requirement.
`<D extends Document<?>> rx.Observable<D>`	`remove(D document, PersistTo persistTo, ReplicateTo replicateTo)` Removes a `Document` from the Server and apply a durability requirement.
`<D extends Document<?>> rx.Observable<D>`	`remove(D document, ReplicateTo replicateTo)` Removes a `Document` from the Server and apply a durability requirement.
`rx.Observable<JsonDocument>`	`remove(java.lang.String id)` Removes a `Document` from the Server identified by its ID.
`<D extends Document<?>> rx.Observable<D>`	`remove(java.lang.String id, java.lang.Class<D> target)` Removes a `Document` from the Server identified by its ID.
`rx.Observable<JsonDocument>`	`remove(java.lang.String id, PersistTo persistTo)` Removes a `Document` from the Server by its ID and apply a durability requirement.
`<D extends Document<?>> rx.Observable<D>`	`remove(java.lang.String id, PersistTo persistTo, java.lang.Class<D> target)` Removes a `Document` from the Server by its ID and apply a durability requirement.
`rx.Observable<JsonDocument>`	`remove(java.lang.String id, PersistTo persistTo, ReplicateTo replicateTo)` Removes a `Document` from the Server by its ID and apply a durability requirement.
`<D extends Document<?>> rx.Observable<D>`	`remove(java.lang.String id, PersistTo persistTo, ReplicateTo replicateTo, java.lang.Class<D> target)` Removes a `Document` from the Server by its ID and apply a durability requirement.
`rx.Observable<JsonDocument>`	`remove(java.lang.String id, ReplicateTo replicateTo)` Removes a `Document` from the Server by its ID and apply a durability requirement.
`<D extends Document<?>> rx.Observable<D>`	`remove(java.lang.String id, ReplicateTo replicateTo, java.lang.Class<D> target)` Removes a `Document` from the Server by its ID and apply a durability requirement.
`<D extends Document<?>> rx.Observable<D>`	`replace(D document)` Replace a `Document` if it does already exist.
`<D extends Document<?>> rx.Observable<D>`	`replace(D document, PersistTo persistTo)` Replace a `Document` if it does exist and watch for durability constraints.
`<D extends Document<?>> rx.Observable<D>`	`replace(D document, PersistTo persistTo, ReplicateTo replicateTo)` Replace a `Document` if it does exist and watch for durability constraints.
`<D extends Document<?>> rx.Observable<D>`	`replace(D document, ReplicateTo replicateTo)` Replace a `Document` if it does exist and watch for durability constraints.
`<D extends Document<?>> rx.Observable<java.lang.Boolean>`	`touch(D document)` Renews the expiration time of a `Document`.
`rx.Observable<java.lang.Boolean>`	`touch(java.lang.String id, int expiry)` Renews the expiration time of a `Document`.
`<D extends Document<?>> rx.Observable<java.lang.Boolean>`	`unlock(D document)` Unlocks a write-locked `Document`.
`rx.Observable<java.lang.Boolean>`	`unlock(java.lang.String id, long cas)` Unlocks a write-locked `Document`.
`<D extends Document<?>> rx.Observable<D>`	`upsert(D document)` Insert or replace a `Document`.
`<D extends Document<?>> rx.Observable<D>`	`upsert(D document, PersistTo persistTo)` Insert or replace a `Document` and watch for durability constraints.
`<D extends Document<?>> rx.Observable<D>`	`upsert(D document, PersistTo persistTo, ReplicateTo replicateTo)` Insert or replace a `Document` and watch for durability constraints.
`<D extends Document<?>> rx.Observable<D>`	`upsert(D document, ReplicateTo replicateTo)` Insert or replace a `Document` and watch for durability constraints.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - JSON_OBJECT_TRANSCODER
```
public static final JsonTranscoder JSON_OBJECT_TRANSCODER
```
  - JSON_ARRAY_TRANSCODER
```
public static final JsonArrayTranscoder JSON_ARRAY_TRANSCODER
```
  - JSON_BOOLEAN_TRANSCODER
```
public static final JsonBooleanTranscoder JSON_BOOLEAN_TRANSCODER
```
  - JSON_DOUBLE_TRANSCODER
```
public static final JsonDoubleTranscoder JSON_DOUBLE_TRANSCODER
```
  - JSON_LONG_TRANSCODER
```
public static final JsonLongTranscoder JSON_LONG_TRANSCODER
```
  - JSON_STRING_TRANSCODER
```
public static final JsonStringTranscoder JSON_STRING_TRANSCODER
```
  - LEGACY_TRANSCODER
```
public static final LegacyTranscoder LEGACY_TRANSCODER
```
  - BINARY_TRANSCODER
```
public static final BinaryTranscoder BINARY_TRANSCODER
```
  - STRING_TRANSCODER
```
public static final StringTranscoder STRING_TRANSCODER
```
  - SERIALIZABLE_TRANSCODER
```
public static final SerializableTranscoder SERIALIZABLE_TRANSCODER
```
- Constructor Detail
  - CouchbaseAsyncBucket
```
public CouchbaseAsyncBucket(com.couchbase.client.core.ClusterFacade core,
                    java.lang.String name,
                    java.lang.String password,
                    java.util.List<Transcoder<? extends Document,?>> customTranscoders)
```
- Method Detail
  - name
```
public java.lang.String name()
```
    Description copied from interface: AsyncBucket
    
    The name of the Bucket.
    
    Specified by:
    
    name in interface AsyncBucket
    
    Returns:
    the name of the bucket.
  - get
```
public rx.Observable<JsonDocument> get(java.lang.String id)
```
    Description copied from interface: AsyncBucket
    Retrieves a JsonDocument by its unique ID.
    If the document is found, a JsonDocument is returned. If the document is not found, the Observable completes without an item emitted.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    get in interface AsyncBucket
    
    Parameters:
    id - the unique ID of the document.
    
    Returns:
    an Observable eventually containing the found JsonDocument.
  - get
```
public <D extends Document<?>> rx.Observable<D> get(D document)
```
    Description copied from interface: AsyncBucket
    Retrieves any type of Document by its unique ID.
    The document ID is taken out of the Document provided, as well as the target type to return. Note that not the same document is returned, but rather a new one of the same type with the freshly loaded properties.
    If the document is found, a Document is returned. If the document is not found, the Observable completes without an item emitted.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    get in interface AsyncBucket
    
    Parameters:
    document - the source document from which the ID is taken and the type is inferred.
    
    Returns:
    an Observable eventually containing the found Document.
  - get
```
public <D extends Document<?>> rx.Observable<D> get(java.lang.String id,
                                           java.lang.Class<D> target)
```
    Description copied from interface: AsyncBucket
    Retrieves any type of Document by its unique ID.
    This method differs from AsyncBucket.get(String) in that if a specific Document type is passed in, the appropriate Transcoder will be selected (and not JSON conversion).
    If the document is found, a Document is returned. If the document is not found, the Observable completes without an item emitted.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    get in interface AsyncBucket
    
    Parameters:
    id - the unique ID of the document.
    target - the target document type to use.
    
    Returns:
    an Observable eventually containing the found Document.
  - getAndLock
```
public rx.Observable<JsonDocument> getAndLock(java.lang.String id,
                                     int lockTime)
```
    Description copied from interface: AsyncBucket
    Retrieve and lock a JsonDocument by its unique ID.
    If the document is found, a JsonDocument is returned. If the document is not found, the Observable completes without an item emitted.
    This method works similar to AsyncBucket.get(String), but in addition it (write) locks the document for the given lock time interval. Note that this lock time is hard capped to 30 seconds, even if provided with a higher value and is not configurable. The document will unlock afterwards automatically.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    getAndLock in interface AsyncBucket
    
    Parameters:
    id - id the unique ID of the document.
    lockTime - the time to write lock the document (max. 30 seconds).
    
    Returns:
    an Observable eventually containing the found JsonDocument.
  - getAndLock
```
public <D extends Document<?>> rx.Observable<D> getAndLock(D document,
                                                  int lockTime)
```
    Description copied from interface: AsyncBucket
    Retrieve and lock a Document by its unique ID.
    If the document is found, a Document is returned. If the document is not found, the Observable completes without an item emitted.
    This method works similar to AsyncBucket.get(Document), but in addition it (write) locks the document for the given lock time interval. Note that this lock time is hard capped to 30 seconds, even if provided with a higher value and is not configurable. The document will unlock afterwards automatically.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    getAndLock in interface AsyncBucket
    
    Parameters:
    document - the source document from which the ID is taken and the type is inferred.
    lockTime - the time to write lock the document (max. 30 seconds).
    
    Returns:
    an Observable eventually containing the found Document.
  - getAndLock
```
public <D extends Document<?>> rx.Observable<D> getAndLock(java.lang.String id,
                                                  int lockTime,
                                                  java.lang.Class<D> target)
```
    Description copied from interface: AsyncBucket
    Retrieve and lock a Document by its unique ID.
    This method differs from AsyncBucket.getAndLock(String, int) in that if a specific Document type is passed in, the appropriate Transcoder will be selected (and not JSON conversion).
    If the document is found, a Document is returned. If the document is not found, the Observable completes without an item emitted.
    This method works similar to AsyncBucket.get(String), but in addition it (write) locks the document for the given lock time interval. Note that this lock time is hard capped to 30 seconds, even if provided with a higher value and is not configurable. The document will unlock afterwards automatically.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    getAndLock in interface AsyncBucket
    
    Parameters:
    id - id the unique ID of the document.
    lockTime - the time to write lock the document (max. 30 seconds).
    target - the target document type to use.
    
    Returns:
    an Observable eventually containing the found Document.
  - getAndTouch
```
public rx.Observable<JsonDocument> getAndTouch(java.lang.String id,
                                      int expiry)
```
    Description copied from interface: AsyncBucket
    Retrieve and touch a JsonDocument by its unique ID.
    If the document is found, a JsonDocument is returned. If the document is not found, the Observable completes without an item emitted.
    This method works similar to AsyncBucket.get(String), but in addition it touches the document, which will reset its configured expiration time to the value provided.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    getAndTouch in interface AsyncBucket
    
    Parameters:
    id - id the unique ID of the document.
    expiry - the new expiration time for the document.
    
    Returns:
    an Observable eventually containing the found JsonDocument.
  - getAndTouch
```
public <D extends Document<?>> rx.Observable<D> getAndTouch(D document)
```
    Description copied from interface: AsyncBucket
    Retrieve and touch a Document by its unique ID.
    If the document is found, a Document is returned. If the document is not found, the Observable completes without an item emitted.
    This method works similar to AsyncBucket.get(Document), but in addition it touches the document, which will reset its configured expiration time set on the given document itself.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    getAndTouch in interface AsyncBucket
    
    Parameters:
    document - the source document from which the ID and expiry is taken and the type is inferred.
    
    Returns:
    an Observable eventually containing the found Document.
  - getAndTouch
```
public <D extends Document<?>> rx.Observable<D> getAndTouch(java.lang.String id,
                                                   int expiry,
                                                   java.lang.Class<D> target)
```
    Description copied from interface: AsyncBucket
    Retrieve and touch a Document by its unique ID.
    This method differs from AsyncBucket.getAndTouch(String, int) in that if a specific Document type is passed in, the appropriate Transcoder will be selected (and not JSON conversion).
    If the document is found, a JsonDocument is returned. If the document is not found, the Observable completes without an item emitted.
    This method works similar to AsyncBucket.get(String, Class), but in addition it touches the document, which will reset its configured expiration time to the value provided.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    getAndTouch in interface AsyncBucket
    
    Parameters:
    id - id the unique ID of the document.
    expiry - the new expiration time for the document.
    target - the target document type to use.
    
    Returns:
    an Observable eventually containing the found Document.
  - getFromReplica
```
public rx.Observable<JsonDocument> getFromReplica(java.lang.String id,
                                         ReplicaMode type)
```
    Description copied from interface: AsyncBucket
    Retrieves one or more, possibly stale, representations of a JsonDocument by its unique ID.
    Depending on the ReplicaMode selected, there can be none to four JsonDocument be returned from the Observable. If ReplicaMode.FIRST, ReplicaMode.SECOND or ReplicaMode.THIRD are selected zero or one documents are returned, if ReplicaMode.ALL is used, all configured replicas plus the master node may return a document.
    If the document has not been replicated yet or if the replica or master are not available (because a node has been failed over), no response is expected from these nodes.
    Since data is replicated asynchronously, all data returned from this method must be considered stale. If the appropriate ReplicateTo constraints are set on write and the operation returns successfully, then the data can be considered as non-stale.
    Note that the returning JsonDocument responses can come in any order.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    getFromReplica in interface AsyncBucket
    
    Parameters:
    id - id the unique ID of the document.
    type - the ReplicaMode to select.
    
    Returns:
    an Observable eventually containing zero to N JsonDocuments.
  - getFromReplica
```
public <D extends Document<?>> rx.Observable<D> getFromReplica(D document,
                                                      ReplicaMode type)
```
    Description copied from interface: AsyncBucket
    Retrieves one or more, possibly stale, representations of a Document by its unique ID.
    The document ID is taken out of the Document provided, as well as the target type to return. Note that not the same document is returned, but rather a new one of the same type with the freshly loaded properties.
    Depending on the ReplicaMode selected, there can be none to four Document be returned from the Observable. If ReplicaMode.FIRST, ReplicaMode.SECOND or ReplicaMode.THIRD are selected zero or one documents are returned, if ReplicaMode.ALL is used, all configured replicas plus the master node may return a document.
    If the document has not been replicated yet or if the replica or master are not available (because a node has been failed over), no response is expected from these nodes.
    Since data is replicated asynchronously, all data returned from this method must be considered stale. If the appropriate ReplicateTo constraints are set on write and the operation returns successfully, then the data can be considered as non-stale.
    Note that the returning Document responses can come in any order.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    getFromReplica in interface AsyncBucket
    
    Parameters:
    document - the source document from which the ID is taken and the type is inferred.
    type - the ReplicaMode to select.
    
    Returns:
    an Observable eventually containing zero to N Documents.
  - getFromReplica
```
public <D extends Document<?>> rx.Observable<D> getFromReplica(java.lang.String id,
                                                      ReplicaMode type,
                                                      java.lang.Class<D> target)
```
    Description copied from interface: AsyncBucket
    Retrieves one or more, possibly stale, representations of a Document by its unique ID.
    This method differs from AsyncBucket.getFromReplica(String, ReplicaMode) in that if a specific Document type is passed in, the appropriate Transcoder will be selected (and not JSON conversion).
    Depending on the ReplicaMode selected, there can be none to four Document be returned from the Observable. If ReplicaMode.FIRST, ReplicaMode.SECOND or ReplicaMode.THIRD are selected zero or one documents are returned, if ReplicaMode.ALL is used, all configured replicas plus the master node may return a document.
    If the document has not been replicated yet or if the replica or master are not available (because a node has been failed over), no response is expected from these nodes.
    Since data is replicated asynchronously, all data returned from this method must be considered stale. If the appropriate ReplicateTo constraints are set on write and the operation returns successfully, then the data can be considered as non-stale.
    Note that the returning Document responses can come in any order.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    getFromReplica in interface AsyncBucket
    
    Parameters:
    id - id the unique ID of the document.
    type - the ReplicaMode to select.
    target - the target document type to use.
    
    Returns:
    an Observable eventually containing zero to N Documents.
  - insert
```
public <D extends Document<?>> rx.Observable<D> insert(D document)
```
    Description copied from interface: AsyncBucket
    Insert a Document if it does not exist already.
    If the given Document (identified by its unique ID) already exists, the observable errors with a DocumentAlreadyExistsException. If the operation should also override the existing Document, AsyncBucket.upsert(Document) should be used instead. It will always either return a document or fail with an error.
    The returned Document contains original properties, but has the refreshed CAS value set.
    This operation will return successfully if the Document has been acknowledged in the managed cache layer on the master server node. If increased data durability is a concern, AsyncBucket.insert(Document, PersistTo, ReplicateTo) should be used instead.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The original insert failed because the document is already stored: DocumentAlreadyExistsException
    Specified by:
    
    insert in interface AsyncBucket
    
    Parameters:
    document - the Document to insert.
    
    Returns:
    an Observable eventually containing a new Document.
  - insert
```
public <D extends Document<?>> rx.Observable<D> insert(D document,
                                              PersistTo persistTo,
                                              ReplicateTo replicateTo)
```
    Description copied from interface: AsyncBucket
    Insert a Document if it does not exist already and watch for durability constraints.
    This method works exactly like AsyncBucket.insert(Document), but afterwards watches the server states if the given durability constraints are met. If this is the case, a new document is returned which contains the original properties, but has the refreshed CAS value set.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The original insert failed because the document is already stored: DocumentAlreadyExistsException
    - The durability constraint could not be fulfilled because of a temporary or persistent problem: DurabilityException.
    A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original insert has already happened, so the actual insert and the watching for durability constraints are two separate tasks internally.
    Specified by:
    
    insert in interface AsyncBucket
    
    Parameters:
    document - the Document to insert.
    persistTo - the persistence constraint to watch.
    replicateTo - the replication constraint to watch.
    
    Returns:
    an Observable eventually containing a new Document.
  - upsert
```
public <D extends Document<?>> rx.Observable<D> upsert(D document)
```
    Description copied from interface: AsyncBucket
    Insert or replace a Document.
    If the given Document (identified by its unique ID) already exists, it will be overridden by the current one. The returned Document contains original properties, but has the refreshed CAS value set.
    This operation will return successfully if the Document has been acknowledged in the managed cache layer on the master server node. If increased data durability is a concern, AsyncBucket.upsert(Document, PersistTo, ReplicateTo) should be used instead.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    upsert in interface AsyncBucket
    
    Parameters:
    document - the Document to upsert.
    
    Returns:
    an Observable eventually containing a new Document.
  - upsert
```
public <D extends Document<?>> rx.Observable<D> upsert(D document,
                                              PersistTo persistTo,
                                              ReplicateTo replicateTo)
```
    Description copied from interface: AsyncBucket
    Insert or replace a Document and watch for durability constraints.
    This method works exactly like AsyncBucket.upsert(Document), but afterwards watches the server states if the given durability constraints are met. If this is the case, a new document is returned which contains the original properties, but has the refreshed CAS value set.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The durability constraint could not be fulfilled because of a temporary or persistent problem: DurabilityException.
    A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original upsert has already happened, so the actual upsert and the watching for durability constraints are two separate tasks internally.
    Specified by:
    
    upsert in interface AsyncBucket
    
    Parameters:
    document - the Document to upsert.
    persistTo - the persistence constraint to watch.
    replicateTo - the replication constraint to watch.
    
    Returns:
    an Observable eventually containing a new Document.
  - replace
```
public <D extends Document<?>> rx.Observable<D> replace(D document)
```
    Description copied from interface: AsyncBucket
    Replace a Document if it does already exist.
    If the given Document (identified by its unique ID) does not exist already, the method errors with a DocumentDoesNotExistException. If the operation should also insert the Document, AsyncBucket.upsert(Document) should be used instead. It will always either return a document or fail with an error.
    The returned Document contains original properties, but has the refreshed CAS value set.
    This operation will return successfully if the Document has been acknowledged in the managed cache layer on the master server node. If increased data durability is a concern, AsyncBucket.replace(Document, PersistTo, ReplicateTo) should be used instead.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The original replace failed because the document does not exist: DocumentDoesNotExistException
    - A CAS value was set and it did not match with the server: CASMismatchException
    Specified by:
    
    replace in interface AsyncBucket
    
    Parameters:
    document - the Document to replace.
    
    Returns:
    an Observable eventually containing a new Document.
  - replace
```
public <D extends Document<?>> rx.Observable<D> replace(D document,
                                               PersistTo persistTo,
                                               ReplicateTo replicateTo)
```
    Description copied from interface: AsyncBucket
    Replace a Document if it does exist and watch for durability constraints.
    This method works exactly like AsyncBucket.replace(Document), but afterwards watches the server states if the given durability constraints are met. If this is the case, a new document is returned which contains the original properties, but has the refreshed CAS value set.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The original replace failed because the document does not exist: DocumentDoesNotExistException
    - The durability constraint could not be fulfilled because of a temporary or persistent problem: DurabilityException.
    - A CAS value was set and it did not match with the server: CASMismatchException
    A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original replace has already happened, so the actual replace and the watching for durability constraints are two separate tasks internally.
    Specified by:
    
    replace in interface AsyncBucket
    
    Parameters:
    document - the Document to replace.
    persistTo - the persistence constraint to watch.
    replicateTo - the replication constraint to watch.
    
    Returns:
    an Observable eventually containing a new Document.
  - remove
```
public <D extends Document<?>> rx.Observable<D> remove(D document)
```
    Description copied from interface: AsyncBucket
    Removes a Document from the Server.
    The Document returned just has the document ID set, since the value and all other associated properties have been removed from the server.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    remove in interface AsyncBucket
    
    Parameters:
    document - the document to remove, with the ID extracted.
    
    Returns:
    the document containing the ID.
  - remove
```
public rx.Observable<JsonDocument> remove(java.lang.String id)
```
    Description copied from interface: AsyncBucket
    Removes a Document from the Server identified by its ID.
    The Document returned just has the document ID set, since the value and all other associated properties have been removed from the server.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    remove in interface AsyncBucket
    
    Parameters:
    id - the id of the document to remove.
    
    Returns:
    the document containing the ID.
  - remove
```
public <D extends Document<?>> rx.Observable<D> remove(java.lang.String id,
                                              java.lang.Class<D> target)
```
    Description copied from interface: AsyncBucket
    Removes a Document from the Server identified by its ID.
    The Document returned just has the document ID set, since the value and all other associated properties have been removed from the server.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    remove in interface AsyncBucket
    
    Parameters:
    id - the id of the document to remove.
    target - the target document type to use.
    
    Returns:
    the document containing the ID.
  - remove
```
public <D extends Document<?>> rx.Observable<D> remove(D document,
                                              PersistTo persistTo,
                                              ReplicateTo replicateTo)
```
    Description copied from interface: AsyncBucket
    Removes a Document from the Server and apply a durability requirement.
    The Document returned just has the document ID set, since the value and all other associated properties have been removed from the server.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The durability constraint could not be fulfilled because of a temporary or persistent problem: DurabilityException.
    Specified by:
    
    remove in interface AsyncBucket
    
    Parameters:
    document - the document to remove, with the ID extracted.
    persistTo - the persistence constraint to watch.
    replicateTo - the replication constraint to watch.
    
    Returns:
    the document containing the ID.
  - remove
```
public rx.Observable<JsonDocument> remove(java.lang.String id,
                                 PersistTo persistTo,
                                 ReplicateTo replicateTo)
```
    Description copied from interface: AsyncBucket
    Removes a Document from the Server by its ID and apply a durability requirement.
    The Document returned just has the document ID set, since the value and all other associated properties have been removed from the server.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The durability constraint could not be fulfilled because of a temporary or persistent problem: DurabilityException.
    Specified by:
    
    remove in interface AsyncBucket
    
    Parameters:
    id - the id of the document to remove.
    persistTo - the persistence constraint to watch.
    replicateTo - the replication constraint to watch.
    
    Returns:
    the document containing the ID.
  - remove
```
public <D extends Document<?>> rx.Observable<D> remove(java.lang.String id,
                                              PersistTo persistTo,
                                              ReplicateTo replicateTo,
                                              java.lang.Class<D> target)
```
    Description copied from interface: AsyncBucket
    Removes a Document from the Server by its ID and apply a durability requirement.
    The Document returned just has the document ID set, since the value and all other associated properties have been removed from the server.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The durability constraint could not be fulfilled because of a temporary or persistent problem: DurabilityException.
    Specified by:
    
    remove in interface AsyncBucket
    
    Parameters:
    id - the id of the document to remove.
    persistTo - the persistence constraint to watch.
    replicateTo - the replication constraint to watch.
    target - the target document type to use.
    
    Returns:
    the document containing the ID.
  - query
```
public rx.Observable<AsyncViewResult> query(ViewQuery query)
```
    Description copied from interface: AsyncBucket
    Queries a Couchbase Server View.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - If the design document or view is not found: ViewDoesNotExistException
    Specified by:
    
    query in interface AsyncBucket
    
    Parameters:
    query - the query to perform.
    
    Returns:
    a result containing all the found rows and additional information.
  - query
```
public rx.Observable<AsyncQueryResult> query(Query query)
```
    Description copied from interface: AsyncBucket
    Experimental: Queries a N1QL secondary index.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    query in interface AsyncBucket
    
    Parameters:
    query - the query in a DSL form (start with a static select() import)
    
    Returns:
    a result containing all found rows and additional information.
  - query
```
public rx.Observable<AsyncQueryResult> query(java.lang.String query)
```
    Description copied from interface: AsyncBucket
    Experimental: Queries a N1QL secondary index.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    query in interface AsyncBucket
    
    Parameters:
    query - the query in a plain N1QL String
    
    Returns:
    a result containing all found rows and additional information.
  - counter
```
public rx.Observable<JsonLongDocument> counter(java.lang.String id,
                                      long delta)
```
    Description copied from interface: AsyncBucket
    Increment or decrement a counter with the given value and a default value of 0.
    It is not allowed that the delta value will bring the actual value below zero.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    counter in interface AsyncBucket
    
    Parameters:
    id - the id of the document.
    delta - the increment or decrement amount.
    
    Returns:
    a Document containing the resulting value.
  - counter
```
public rx.Observable<JsonLongDocument> counter(java.lang.String id,
                                      long delta,
                                      long initial)
```
    Description copied from interface: AsyncBucket
    Increment or decrement a counter with the given value and a initial value if it does not exist.
    It is not allowed that the delta value will bring the actual value below zero.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    counter in interface AsyncBucket
    
    Parameters:
    id - the id of the document.
    delta - the increment or decrement amount.
    
    Returns:
    a Document containing the resulting value.
  - counter
```
public rx.Observable<JsonLongDocument> counter(java.lang.String id,
                                      long delta,
                                      long initial,
                                      int expiry)
```
    Description copied from interface: AsyncBucket
    Increment or decrement a counter with the given value and a initial value if it does not exist.
    This method allows to set an expiration time for the document as well. It is not allowed that the delta value will bring the actual value below zero.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    counter in interface AsyncBucket
    
    Parameters:
    id - the id of the document.
    delta - the increment or decrement amount.
    
    Returns:
    a Document containing the resulting value.
  - unlock
```
public rx.Observable<java.lang.Boolean> unlock(java.lang.String id,
                                      long cas)
```
    Description copied from interface: AsyncBucket
    Unlocks a write-locked Document.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The document does not exist: DocumentDoesNotExistException
    - The CAS value was not correct: CASMismatchException
    Specified by:
    
    unlock in interface AsyncBucket
    
    Parameters:
    id - the id of the document to unlock.
    cas - the CAS value which is mandatory to unlock it.
    
    Returns:
    a Boolean indicating if the unlock was successful or not.
  - unlock
```
public <D extends Document<?>> rx.Observable<java.lang.Boolean> unlock(D document)
```
    Description copied from interface: AsyncBucket
    Unlocks a write-locked Document.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The document does not exist: DocumentDoesNotExistException
    - The CAS value was not correct: CASMismatchException
    Specified by:
    
    unlock in interface AsyncBucket
    
    Parameters:
    document - the document where ID and CAS are extracted from.
    
    Returns:
    a Boolean indicating if the unlock was successful or not.
  - touch
```
public rx.Observable<java.lang.Boolean> touch(java.lang.String id,
                                     int expiry)
```
    Description copied from interface: AsyncBucket
    Renews the expiration time of a Document.
    Compared to AsyncBucket.getAndTouch(Document), this method does not actually fetch the document from the server, but it just resets its expiration time to the given value.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    touch in interface AsyncBucket
    
    Parameters:
    id - the id of the document.
    expiry - the new expiration time. 0 means no expiry.
    
    Returns:
    a Boolean indicating if the touch had been successful or not.
  - touch
```
public <D extends Document<?>> rx.Observable<java.lang.Boolean> touch(D document)
```
    Description copied from interface: AsyncBucket
    Renews the expiration time of a Document.
    Compared to AsyncBucket.getAndTouch(Document), this method does not actually fetch the document from the server, but it just resets its expiration time to the given value.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    touch in interface AsyncBucket
    
    Parameters:
    document - the document to extract the ID and expiry from.
    
    Returns:
    a copy of the document inserted.
  - append
```
public <D extends Document<?>> rx.Observable<D> append(D document)
```
    Description copied from interface: AsyncBucket
    Append a Document to another one.
    If the Document does not exist, it needs to be created upfront. Note that JsonDocuments in all forms are not supported, it is advised that the following ones are used:
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    append in interface AsyncBucket
    
    Parameters:
    document - the document to be appended.
    
    Returns:
    a document which mirrors the one supplied as an argument.
  - prepend
```
public <D extends Document<?>> rx.Observable<D> prepend(D document)
```
    Description copied from interface: AsyncBucket
    Prepend a Document to another one.
    If the Document does not exist, it needs to be created upfront. Note that JsonDocuments in all forms are not supported, it is advised that the following ones are used:
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    Specified by:
    
    prepend in interface AsyncBucket
    
    Parameters:
    document - the document to be prepended.
    
    Returns:
    a document which mirrors the one supplied as an argument.
  - bucketManager
```
public rx.Observable<AsyncBucketManager> bucketManager()
```
    Description copied from interface: AsyncBucket
    
    Provides access to the AsyncBucketManager for administrative access.
    The manager lets you perform operations such as flushing a bucket or creating and managing design documents.
    
    Specified by:
    
    bucketManager in interface AsyncBucket
    
    Returns:
    the bucket manager for administrative operations.
  - insert
```
public <D extends Document<?>> rx.Observable<D> insert(D document,
                                              PersistTo persistTo)
```
    Description copied from interface: AsyncBucket
    Insert a Document if it does not exist already and watch for durability constraints.
    This method works exactly like AsyncBucket.insert(Document), but afterwards watches the server states if the given durability constraints are met. If this is the case, a new document is returned which contains the original properties, but has the refreshed CAS value set.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The original insert failed because the document is already stored: DocumentAlreadyExistsException
    - The durability constraint could not be fulfilled because of a temporary or persistent problem: DurabilityException.
    A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original insert has already happened, so the actual insert and the watching for durability constraints are two separate tasks internally.
    Specified by:
    
    insert in interface AsyncBucket
    
    Parameters:
    document - the Document to insert.
    persistTo - the persistence constraint to watch.
    
    Returns:
    an Observable eventually containing a new Document.
  - insert
```
public <D extends Document<?>> rx.Observable<D> insert(D document,
                                              ReplicateTo replicateTo)
```
    Description copied from interface: AsyncBucket
    Insert a Document if it does not exist already and watch for durability constraints.
    This method works exactly like AsyncBucket.insert(Document), but afterwards watches the server states if the given durability constraints are met. If this is the case, a new document is returned which contains the original properties, but has the refreshed CAS value set.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The original insert failed because the document is already stored: DocumentAlreadyExistsException
    - The durability constraint could not be fulfilled because of a temporary or persistent problem: DurabilityException.
    A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original insert has already happened, so the actual insert and the watching for durability constraints are two separate tasks internally.
    Specified by:
    
    insert in interface AsyncBucket
    
    Parameters:
    document - the Document to insert.
    replicateTo - the replication constraint to watch.
    
    Returns:
    an Observable eventually containing a new Document.
  - upsert
```
public <D extends Document<?>> rx.Observable<D> upsert(D document,
                                              PersistTo persistTo)
```
    Description copied from interface: AsyncBucket
    Insert or replace a Document and watch for durability constraints.
    This method works exactly like AsyncBucket.upsert(Document), but afterwards watches the server states if the given durability constraints are met. If this is the case, a new document is returned which contains the original properties, but has the refreshed CAS value set.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The durability constraint could not be fulfilled because of a temporary or persistent problem: DurabilityException.
    A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original upsert has already happened, so the actual upsert and the watching for durability constraints are two separate tasks internally.
    Specified by:
    
    upsert in interface AsyncBucket
    
    Parameters:
    document - the Document to upsert.
    persistTo - the persistence constraint to watch.
    
    Returns:
    an Observable eventually containing a new Document.
  - upsert
```
public <D extends Document<?>> rx.Observable<D> upsert(D document,
                                              ReplicateTo replicateTo)
```
    Description copied from interface: AsyncBucket
    Insert or replace a Document and watch for durability constraints.
    This method works exactly like AsyncBucket.upsert(Document), but afterwards watches the server states if the given durability constraints are met. If this is the case, a new document is returned which contains the original properties, but has the refreshed CAS value set.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The durability constraint could not be fulfilled because of a temporary or persistent problem: DurabilityException.
    A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original upsert has already happened, so the actual upsert and the watching for durability constraints are two separate tasks internally.
    Specified by:
    
    upsert in interface AsyncBucket
    
    Parameters:
    document - the Document to upsert.
    replicateTo - the replication constraint to watch.
    
    Returns:
    an Observable eventually containing a new Document.
  - replace
```
public <D extends Document<?>> rx.Observable<D> replace(D document,
                                               PersistTo persistTo)
```
    Description copied from interface: AsyncBucket
    Replace a Document if it does exist and watch for durability constraints.
    This method works exactly like AsyncBucket.replace(Document), but afterwards watches the server states if the given durability constraints are met. If this is the case, a new document is returned which contains the original properties, but has the refreshed CAS value set.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The original replace failed because the document does not exist: DocumentDoesNotExistException
    - The durability constraint could not be fulfilled because of a temporary or persistent problem: DurabilityException.
    - A CAS value was set and it did not match with the server: CASMismatchException
    A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original replace has already happened, so the actual replace and the watching for durability constraints are two separate tasks internally.
    Specified by:
    
    replace in interface AsyncBucket
    
    Parameters:
    document - the Document to replace.
    persistTo - the persistence constraint to watch.
    
    Returns:
    an Observable eventually containing a new Document.
  - replace
```
public <D extends Document<?>> rx.Observable<D> replace(D document,
                                               ReplicateTo replicateTo)
```
    Description copied from interface: AsyncBucket
    Replace a Document if it does exist and watch for durability constraints.
    This method works exactly like AsyncBucket.replace(Document), but afterwards watches the server states if the given durability constraints are met. If this is the case, a new document is returned which contains the original properties, but has the refreshed CAS value set.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The original replace failed because the document does not exist: DocumentDoesNotExistException
    - The durability constraint could not be fulfilled because of a temporary or persistent problem: DurabilityException.
    - A CAS value was set and it did not match with the server: CASMismatchException
    A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original replace has already happened, so the actual replace and the watching for durability constraints are two separate tasks internally.
    Specified by:
    
    replace in interface AsyncBucket
    
    Parameters:
    document - the Document to replace.
    replicateTo - the replication constraint to watch.
    
    Returns:
    an Observable eventually containing a new Document.
  - remove
```
public <D extends Document<?>> rx.Observable<D> remove(D document,
                                              PersistTo persistTo)
```
    Description copied from interface: AsyncBucket
    Removes a Document from the Server and apply a durability requirement.
    The Document returned just has the document ID set, since the value and all other associated properties have been removed from the server.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The durability constraint could not be fulfilled because of a temporary or persistent problem: DurabilityException.
    Specified by:
    
    remove in interface AsyncBucket
    
    Parameters:
    document - the document to remove, with the ID extracted.
    persistTo - the persistence constraint to watch.
    
    Returns:
    the document containing the ID.
  - remove
```
public <D extends Document<?>> rx.Observable<D> remove(D document,
                                              ReplicateTo replicateTo)
```
    Description copied from interface: AsyncBucket
    Removes a Document from the Server and apply a durability requirement.
    The Document returned just has the document ID set, since the value and all other associated properties have been removed from the server.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The durability constraint could not be fulfilled because of a temporary or persistent problem: DurabilityException.
    Specified by:
    
    remove in interface AsyncBucket
    
    Parameters:
    document - the document to remove, with the ID extracted.
    replicateTo - the replication constraint to watch.
    
    Returns:
    the document containing the ID.
  - remove
```
public rx.Observable<JsonDocument> remove(java.lang.String id,
                                 PersistTo persistTo)
```
    Description copied from interface: AsyncBucket
    Removes a Document from the Server by its ID and apply a durability requirement.
    The Document returned just has the document ID set, since the value and all other associated properties have been removed from the server.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The durability constraint could not be fulfilled because of a temporary or persistent problem: DurabilityException.
    Specified by:
    
    remove in interface AsyncBucket
    
    Parameters:
    id - the id of the document to remove.
    persistTo - the persistence constraint to watch.
    
    Returns:
    the document containing the ID.
  - remove
```
public rx.Observable<JsonDocument> remove(java.lang.String id,
                                 ReplicateTo replicateTo)
```
    Description copied from interface: AsyncBucket
    Removes a Document from the Server by its ID and apply a durability requirement.
    The Document returned just has the document ID set, since the value and all other associated properties have been removed from the server.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The durability constraint could not be fulfilled because of a temporary or persistent problem: DurabilityException.
    Specified by:
    
    remove in interface AsyncBucket
    
    Parameters:
    id - the id of the document to remove.
    replicateTo - the replication constraint to watch.
    
    Returns:
    the document containing the ID.
  - remove
```
public <D extends Document<?>> rx.Observable<D> remove(java.lang.String id,
                                              PersistTo persistTo,
                                              java.lang.Class<D> target)
```
    Description copied from interface: AsyncBucket
    Removes a Document from the Server by its ID and apply a durability requirement.
    The Document returned just has the document ID set, since the value and all other associated properties have been removed from the server.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The durability constraint could not be fulfilled because of a temporary or persistent problem: DurabilityException.
    Specified by:
    
    remove in interface AsyncBucket
    
    Parameters:
    id - the id of the document to remove.
    persistTo - the persistence constraint to watch.
    target - the target document type to use.
    
    Returns:
    the document containing the ID.
  - remove
```
public <D extends Document<?>> rx.Observable<D> remove(java.lang.String id,
                                              ReplicateTo replicateTo,
                                              java.lang.Class<D> target)
```
    Description copied from interface: AsyncBucket
    Removes a Document from the Server by its ID and apply a durability requirement.
    The Document returned just has the document ID set, since the value and all other associated properties have been removed from the server.
    The returned Observable can error under the following conditions:
    - The producer outpaces the SDK: BackpressureException
    - The operation had to be cancelled while “in flight” on the wire: RequestCancelledException
    - The durability constraint could not be fulfilled because of a temporary or persistent problem: DurabilityException.
    Specified by:
    
    remove in interface AsyncBucket
    
    Parameters:
    id - the id of the document to remove.
    replicateTo - the replication constraint to watch.
    target - the target document type to use.
    
    Returns:
    the document containing the ID.
  - close
```
public rx.Observable<java.lang.Boolean> close()
```
    Description copied from interface: AsyncBucket
    
    Closes the AsyncBucket.
    
    Specified by:
    
    close in interface AsyncBucket
    
    Returns:
    an Observable eventually containing a new Boolean after close.

Class CouchbaseAsyncBucket

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

JSON_OBJECT_TRANSCODER

JSON_ARRAY_TRANSCODER

JSON_BOOLEAN_TRANSCODER

JSON_DOUBLE_TRANSCODER

JSON_LONG_TRANSCODER

JSON_STRING_TRANSCODER

LEGACY_TRANSCODER

BINARY_TRANSCODER

STRING_TRANSCODER

SERIALIZABLE_TRANSCODER

Constructor Detail

CouchbaseAsyncBucket

Method Detail

name

get

get

get

getAndLock

getAndLock

getAndLock

getAndTouch

getAndTouch

getAndTouch

getFromReplica

getFromReplica

getFromReplica

insert

insert

upsert

upsert

replace

replace

remove

remove

remove

remove

remove

remove

query

query

query

counter

counter

counter

unlock

unlock

touch

touch

append

prepend

bucketManager

insert

insert

upsert

upsert

replace

replace

remove

remove

remove

remove

remove

remove

close