Java SingleResultCallback类代码示例

import com.mongodb.async.SingleResultCallback; //导入依赖的package包/类
/**
 * Returns the timestamp of the latest oplog entry.
 *
 * @param collection The oplog {@link MongoCollection}
 * @return The latest timestamp or {@code null} if no entry is available
 */
public static BsonTimestamp getLatestOplogTimestamp(MongoCollection<BsonDocument> collection) {
    final AtomicReference<BsonTimestamp> timestamp = new AtomicReference<>();
    final AtomicReference<Throwable> error = new AtomicReference<>();
    final CountDownLatch waiter = new CountDownLatch(1);
    collection.find().sort(new Document("$natural", -1)).limit(1).first(new SingleResultCallback<BsonDocument>() {
        @Override
        public void onResult(BsonDocument document, Throwable throwable) {
            if (throwable != null)
                error.set(throwable);
            if (document != null)
                timestamp.set(document.getTimestamp("ts"));
            waiter.countDown();
        }
    });
    ConcurrentUtils.safeAwait(waiter);
    Throwable realError = error.get();
    if (realError != null)
        throw Throwables.propagate(realError);
    return timestamp.get();
}
 

import com.mongodb.async.SingleResultCallback; //导入依赖的package包/类
public List<JSONObject> getWithinBoundingBox(double btm, double tp, double rght, double lft) {
    List<JSONObject> finalList = Collections.synchronizedList(new ArrayList<>());

    MongoCollection<Document> roadsNodes = this.database.getCollection("ollie_roads");

    Block<Document> getBlock = new Block<Document>() {
        @Override
        public void apply(final Document document) {
            finalList.add(new JSONObject(document));
        }
    };


    SingleResultCallback<Void> callbackWhenFinished = new SingleResultCallback<Void>() {
        @Override
        public void onResult(final Void result, final Throwable t) {
            latch.countDown();
        }
    };

    roadsNodes.find(and(gte("startNode.latitude", btm), lte("startNode.latitude", tp), gte("startNode.longitude", lft), lte("startNode.longitude", rght),
            gte("endNode.latitude", btm), lte("endNode.latitude", tp), gte("endNode.longitude", lft), lte("endNode.longitude", rght))).
            forEach(getBlock, callbackWhenFinished);

    try {
        latch.await();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return finalList;
}
 

import com.mongodb.async.SingleResultCallback; //导入依赖的package包/类
/**
 *
 * @param resultHandler
 * @param converter
 * @param <T>
 * @param <R>
 * @return
 */
private <T, R> SingleResultCallback<T> convertCallback(Handler<AsyncResult<R>> resultHandler, Function<T, R> converter) {
    Context context = mongi.vertx.getOrCreateContext();
    return (result, error) -> {
        context.runOnContext(v -> {
            if (error != null) {
                resultHandler.handle(Future.failedFuture(error));
            } else {
                resultHandler.handle(Future.succeededFuture(converter.apply(result)));
            }
        });
    };
}
 

import com.mongodb.async.SingleResultCallback; //导入依赖的package包/类
@Override
public Publisher<Success> createView(final String viewName, final String viewOn, final List<? extends Bson> pipeline,
                                     final CreateViewOptions createViewOptions) {
    return new ObservableToPublisher<Success>(observe(new Block<SingleResultCallback<Success>>() {
        @Override
        public void apply(final SingleResultCallback<Success> callback) {
            wrapped.createView(viewName, viewOn, pipeline, createViewOptions, voidToSuccessCallback(callback));
        }
    }));
}
 

import com.mongodb.async.SingleResultCallback; //导入依赖的package包/类
@Override
public Observable<Success> close() {
    return RxObservables.create(Observables.observe(new Block<SingleResultCallback<Success>>() {
        @Override
        public void apply(final SingleResultCallback<Success> callback) {
            wrapped.close(voidToSuccessCallback(callback));
        }
    }), observableAdapter);
}
 

import com.mongodb.async.SingleResultCallback; //导入依赖的package包/类
@Override
public Observable<Success> abort() {
    return RxObservables.create(Observables.observe(new Block<SingleResultCallback<Success>>() {
        @Override
        public void apply(final SingleResultCallback<Success> callback) {
            wrapped.abort(voidToSuccessCallback(callback));
        }
    }), observableAdapter);
}
 

import com.mongodb.async.SingleResultCallback; //导入依赖的package包/类
@Override
public Publisher<Success> delete(final ClientSession clientSession, final BsonValue id) {
    return new ObservableToPublisher<Success>(observe(new Block<SingleResultCallback<Success>>() {
        @Override
        public void apply(final SingleResultCallback<Success> callback) {
            wrapped.delete(clientSession, id, voidToSuccessCallback(callback));
        }
    }));
}
 

import com.mongodb.async.SingleResultCallback; //导入依赖的package包/类
@Override
public Observable<BulkWriteResult> bulkWrite(final List<? extends WriteModel<? extends TDocument>> requests,
                                            final BulkWriteOptions options) {
    return RxObservables.create(Observables.observe(new Block<SingleResultCallback<BulkWriteResult>>() {
        @Override
        public void apply(final SingleResultCallback<BulkWriteResult> callback) {
            wrapped.bulkWrite(requests, options, callback);
        }
    }), observableAdapter);
}
 

import com.mongodb.async.SingleResultCallback; //导入依赖的package包/类
@Override
public Observable<Success> insertOne(final TDocument document, final InsertOneOptions options) {
    return RxObservables.create(Observables.observe(new Block<SingleResultCallback<Success>>() {
        @Override
        public void apply(final SingleResultCallback<Success> callback) {
            wrapped.insertOne(document, options, voidToSuccessCallback(callback));
        }
    }), observableAdapter);
}
 

import com.mongodb.async.SingleResultCallback; //导入依赖的package包/类
@Override
public Observable<Success> insertMany(final List<? extends TDocument> documents, final InsertManyOptions options) {
    return RxObservables.create(Observables.observe(new Block<SingleResultCallback<Success>>() {
        @Override
        public void apply(final SingleResultCallback<Success> callback) {
            wrapped.insertMany(documents, options, voidToSuccessCallback(callback));
        }
    }), observableAdapter);
}
 

import com.mongodb.async.SingleResultCallback; //导入依赖的package包/类
@Override
public Observable<DeleteResult> deleteOne(final Bson filter) {
    return RxObservables.create(Observables.observe(new Block<SingleResultCallback<DeleteResult>>() {
        @Override
        public void apply(final SingleResultCallback<DeleteResult> callback) {
            wrapped.deleteOne(filter, callback);
        }
    }), observableAdapter);
}
 

import com.mongodb.async.SingleResultCallback; //导入依赖的package包/类
<T> void callResult(final SingleResultCallback<T> callback) {
    Object response = responses.remove(0);
    if (response instanceof Throwable) {
        callback.onResult(null, (Throwable) response);
    } else {
        callback.onResult((T) response, null);
    }
}
 

import com.mongodb.async.SingleResultCallback; //导入依赖的package包/类
@Override
public Observable<DeleteResult> deleteMany(final Bson filter) {
    return RxObservables.create(Observables.observe(new Block<SingleResultCallback<DeleteResult>>() {
        @Override
        public void apply(final SingleResultCallback<DeleteResult> callback) {
            wrapped.deleteMany(filter, callback);
        }
    }), observableAdapter);
}
 

import com.mongodb.async.SingleResultCallback; //导入依赖的package包/类
@Override
public Observable<UpdateResult> replaceOne(final Bson filter, final TDocument replacement, final UpdateOptions options) {
    return RxObservables.create(Observables.observe(new Block<SingleResultCallback<UpdateResult>>() {
        @Override
        public void apply(final SingleResultCallback<UpdateResult> callback) {
            wrapped.replaceOne(filter, replacement, options, callback);
        }
    }), observableAdapter);
}
 

import com.mongodb.async.SingleResultCallback; //导入依赖的package包/类
@Override
public Observable<UpdateResult> updateOne(final Bson filter, final Bson update, final UpdateOptions options) {
    return RxObservables.create(Observables.observe(new Block<SingleResultCallback<UpdateResult>>() {
        @Override
        public void apply(final SingleResultCallback<UpdateResult> callback) {
            wrapped.updateOne(filter, update, options, callback);
        }
    }), observableAdapter);
}