collection_wrapper.hpp

// Copyright 2016 MongoDB Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#pragma once

#include <mangrove/config/prelude.hpp>

#include <iostream>

#include <bsoncxx/builder/basic/document.hpp>
#include <bsoncxx/stdx/optional.hpp>
#include <mongocxx/collection.hpp>

#include <boson/mapping_functions.hpp>
#include <mangrove/deserializing_cursor.hpp>

namespace mangrove {
MANGROVE_INLINE_NAMESPACE_BEGIN

template <class T>
class collection_wrapper {
   public:
    collection_wrapper() noexcept = default;

    collection_wrapper(const mongocxx::collection& c) noexcept : _coll(c) {
    }

    collection_wrapper(mongocxx::collection&& c) noexcept : _coll(c) {
    }

    collection_wrapper(collection_wrapper&&) noexcept = default;
    collection_wrapper& operator=(collection_wrapper&&) noexcept = default;
    ~collection_wrapper() = default;

    mongocxx::collection collection() {
        return _coll;
    }

    template <class Result = T>
    deserializing_cursor<Result> aggregate(
        const mongocxx::pipeline& pipeline,
        const mongocxx::options::aggregate& options = mongocxx::options::aggregate()) {
        return deserializing_cursor<Result>(_coll.aggregate(pipeline, options));
    }

    deserializing_cursor<T> find(
        bsoncxx::document::view_or_value filter,
        const mongocxx::options::find& options = mongocxx::options::find()) {
        return deserializing_cursor<T>(_coll.find(filter, options));
    }

    mongocxx::stdx::optional<T> find_one(
        bsoncxx::document::view_or_value filter,
        const mongocxx::options::find& options = mongocxx::options::find()) {
        return boson::to_optional_obj<T>(_coll.find_one(filter, options));
    }

    mongocxx::stdx::optional<T> find_one_and_delete(
        bsoncxx::document::view_or_value filter,
        const mongocxx::options::find_one_and_delete& options =
            mongocxx::options::find_one_and_delete()) {
        return boson::to_optional_obj<T>(_coll.find_one_and_delete(filter, options));
    }

    mongocxx::stdx::optional<T> find_one_and_replace(
        bsoncxx::document::view_or_value filter, const T& replacement,
        const mongocxx::options::find_one_and_replace& options =
            mongocxx::options::find_one_and_replace()) {
        return boson::to_optional_obj<T>(
            _coll.find_one_and_replace(filter, boson::to_document(replacement), options));
    }

    mongocxx::stdx::optional<mongocxx::result::insert_one> insert_one(
        T obj, const mongocxx::options::insert& options = mongocxx::options::insert()) {
        return _coll.insert_one(boson::to_document(obj), options);
    }

    //
    template <typename container_type>
    mongocxx::stdx::optional<mongocxx::result::insert_many> insert_many(
        const container_type& container,
        const mongocxx::options::insert& options = mongocxx::options::insert()) {
        return insert_many(container.begin(), container.end(), options);
    }

    template <typename object_iterator_type>
    mongocxx::stdx::optional<mongocxx::result::insert_many> insert_many(
        object_iterator_type begin, object_iterator_type end,
        const mongocxx::options::insert& options = mongocxx::options::insert()) {
        return _coll.insert_many(boson::serializing_iterator<object_iterator_type>(begin),
                                 boson::serializing_iterator<object_iterator_type>(end), options);
    }

    mongocxx::stdx::optional<mongocxx::result::replace_one> replace_one(
        bsoncxx::document::view_or_value filter, const T& replacement,
        const mongocxx::options::update& options = mongocxx::options::update()) {
        return _coll.replace_one(filter, boson::to_document(replacement), options);
    }

   private:
    mongocxx::collection _coll;
};

MANGROVE_INLINE_NAMESPACE_END
}  // namespace mangrove

#include <mangrove/config/postlude.hpp>