model.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 <cereal/cereal.hpp>

#include <bsoncxx/oid.hpp>
#include <mangrove/collection_wrapper.hpp>
#include <mangrove/config/prelude.hpp>
#include <mangrove/util.hpp>
#include <mongocxx/collection.hpp>

namespace mangrove {
MANGROVE_INLINE_NAMESPACE_BEGIN

template <typename T, typename IdType = bsoncxx::oid>
class model {
   private:
// TODO: When XCode 8 is released, this can always be thread_local. Until then, the model class
//       will not be thread-safe on OS X.
#ifdef __APPLE__
    static collection_wrapper<T> _coll;
#else
    static thread_local collection_wrapper<T> _coll;
#endif

   public:
    template <typename... Ts,
              typename = std::enable_if_t<!first_two_types_are_same<model, Ts...>::value>>
    model(Ts&&... ts) : _id(std::forward<Ts>(ts)...) {
    }

    model() = default;

    static std::int64_t count(
        bsoncxx::document::view_or_value filter = bsoncxx::document::view_or_value{},
        const mongocxx::options::count& options = mongocxx::options::count()) {
        return _coll.collection().count(filter, options);
    }

    static const mongocxx::collection collection() {
        return _coll.collection();
    }

    static mongocxx::stdx::optional<mongocxx::result::delete_result> delete_many(
        bsoncxx::document::view_or_value filter,
        const mongocxx::options::delete_options& options = mongocxx::options::delete_options()) {
        return _coll.collection().delete_many(filter, options);
    }

    static mongocxx::stdx::optional<mongocxx::result::delete_result> delete_one(
        bsoncxx::document::view_or_value filter,
        const mongocxx::options::delete_options& options = mongocxx::options::delete_options()) {
        return _coll.collection().delete_one(filter, options);
    }

    static void drop() {
        _coll.collection().drop();
    }

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

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

    template <typename container_type,
              typename = std::enable_if_t<container_of_v<container_type, T>>>
    static 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,
              typename = std::enable_if_t<iterator_of_v<object_iterator_type, T>>>
    static 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(begin, end, options);
    }

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

    void remove() {
        auto id_match_filter = bsoncxx::builder::stream::document{}
                               << "_id" << this->_id << bsoncxx::builder::stream::finalize;

        _coll.collection().delete_one(id_match_filter.view());
    }

    static void setCollection(const mongocxx::collection& coll) {
        _coll = collection_wrapper<T>(coll);
    }
    static void setCollection(mongocxx::collection&& coll) {
        _coll = collection_wrapper<T>(std::move(coll));
    }

    void save() {
        auto id_match_filter = bsoncxx::builder::stream::document{}
                               << "_id" << this->_id << bsoncxx::builder::stream::finalize;

        auto update = bsoncxx::builder::stream::document{}
                      << "$set" << boson::to_dotted_notation_document(*static_cast<T*>(this))
                      << bsoncxx::builder::stream::finalize;

        mongocxx::options::update opts{};

        opts.upsert(true);

        _coll.collection().update_one(id_match_filter.view(), update.view(), opts);
    };

    static mongocxx::stdx::optional<mongocxx::result::update> update_many(
        bsoncxx::document::view_or_value filter, bsoncxx::document::view_or_value update,
        const mongocxx::options::update& options = mongocxx::options::update()) {
        return _coll.collection().update_many(filter, update, options);
    }

    static mongocxx::stdx::optional<mongocxx::result::update> update_one(
        bsoncxx::document::view_or_value filter, bsoncxx::document::view_or_value update,
        const mongocxx::options::update& options = mongocxx::options::update()) {
        return _coll.collection().update_many(filter, update, options);
    }

   protected:
    IdType _id;
};

#ifdef __APPLE__
template <typename T, typename IdType>
collection_wrapper<T> model<T, IdType>::_coll;
#else
template <typename T, typename IdType>
thread_local collection_wrapper<T> model<T, IdType>::_coll;
#endif

MANGROVE_INLINE_NAMESPACE_END
}  // namespace mangrove