com.mastfrog.asyncpromises.mongo.BulkWriteBuilderImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of mongo-promises Show documentation
There is a newer version: 2.9.7
/*
 * The MIT License
 *
 * Copyright 2015 Tim Boudreau.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
package com.mastfrog.asyncpromises.mongo;

import com.mastfrog.asyncpromises.AsyncPromise;
import com.mongodb.bulk.BulkWriteResult;
import com.mongodb.client.model.BulkWriteOptions;
import com.mongodb.client.model.DeleteManyModel;
import com.mongodb.client.model.DeleteOneModel;
import com.mongodb.client.model.InsertOneModel;
import com.mongodb.client.model.UpdateManyModel;
import com.mongodb.client.model.UpdateOneModel;
import com.mongodb.client.model.UpdateOptions;
import com.mongodb.client.model.WriteModel;
import java.util.LinkedList;
import java.util.List;
import org.bson.Document;
import org.bson.conversions.Bson;

/**
 *
 * @author Tim Boudreau
 */
final class BulkWriteBuilderImpl implements BulkWriteBuilder {

    private final BulkWriteOptions opts = new BulkWriteOptions();
    private final List> requests = new LinkedList<>();
    private final Factory factory;

    BulkWriteBuilderImpl(Factory factory) {
        this.factory = factory;
    }

    public AsyncPromise build() {
        return factory.createPromise(this);
    }

    static  BulkWriteBuilderImpl create(CollectionPromises promises) {
        return new BulkWriteBuilderImpl<>(new StdFactory<>(promises));
    }

    @Override
    public BulkWriteBuilder ordered() {
        return ordered(true);
    }

    @Override
    public BulkWriteBuilder unordered() {
        return ordered(false);
    }

    interface Factory {

        AsyncPromise createPromise(BulkWriteBuilderImpl builder);
    }

    static final class StdFactory implements Factory {

        private final CollectionPromises promises;

        public StdFactory(CollectionPromises promises) {
            this.promises = promises;
        }

        @Override
        public AsyncPromise createPromise(BulkWriteBuilderImpl builder) {
            return promises.bulkWrite(builder.requests, builder.opts);
        }
    }

    @Override
    public BulkWriteBuilder ordered(boolean ordered) {
        opts.ordered(ordered);
        return this;
    }

    @Override
    public BulkWriteBuilder insert(T doc) {
        requests.add(new InsertOneModel<>(doc));
        return this;
    }

    @Override
    public BulkWriteBuilder deleteMany(Bson filter) {
        requests.add(new DeleteManyModel(filter));
        return this;
    }

    @Override
    public BulkWriteBuilder deleteOne(Bson filter) {
        requests.add(new DeleteOneModel(filter));
        return this;
    }

    @Override
    public QueryBuilder> deleteMany() {
        return new QueryBuilderImpl<>(new QueryBuilderImpl.Factory>() {

            @Override
            public BulkWriteBuilderImpl create(Document document) {
                requests.add(new DeleteManyModel(document));
                return BulkWriteBuilderImpl.this;
            }
        });
    }

    @Override
    public QueryBuilder> deleteOne() {
        return new QueryBuilderImpl<>(new QueryBuilderImpl.Factory>() {

            @Override
            public BulkWriteBuilderImpl create(Document document) {
                requests.add(new DeleteOneModel(document));
                return BulkWriteBuilderImpl.this;
            }
        });
    }

    public BulkWriteBuilder updateMany(Bson filter, Bson update, UpdateOptions options) {
        requests.add(new UpdateManyModel(filter, update, options));
        return this;
    }

    public BulkWriteBuilder updateOne(Bson filter, Bson update, UpdateOptions options) {
        requests.add(new UpdateOneModel(filter, update, options));
        return this;
    }

    @Override
    public QueryBuilder>>> update() {
        return QueryBuilderImpl.createForBulkWrite(this);
    }
}