collection.hxx

Go to the documentation of this file.

/*
 *     Copyright 2021 Couchbase, 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 <chrono>
#include <couchbase/client/bucket.hxx>
#include <couchbase/client/lookup_in_spec.hxx>
#include <couchbase/client/mutate_in_spec.hxx>
#include <couchbase/client/options.hxx>
#include <couchbase/client/result.hxx>
#include <couchbase/support.hxx>
#include <string>
#include <thread>
#include <vector>

namespace couchbase
{

enum class store_operation { upsert, insert, replace };

result
store_impl(collection* coll, store_operation op, const std::string& id, const std::string& payload, uint64_t cas, durability_level level);

class collection
{
    friend class bucket;

  private:
    std::string scope_;
    std::string name_;
    std::weak_ptr<bucket> bucket_;
    std::chrono::microseconds kv_timeout_;
    static const std::string DEFAULT;

    friend result store_impl(collection* coll,
                             store_operation op,
                             const std::string& id,
                             const std::string& payload,
                             uint64_t cas,
                             durability_level level,
                             std::chrono::microseconds timeout);

    template<typename Content>
    result store(store_operation operation,
                 const std::string& id,
                 const Content& value,
                 uint64_t cas,
                 durability_level level,
                 std::chrono::microseconds timeout)
    {
        nlohmann::json j = value;
        std::string payload = j.dump();
        return store_impl(this, operation, id, payload, cas, level, timeout);
    }

    std::unique_ptr<pool<lcb_st*>>& instance_pool()
    {
        return bucket_.lock()->instance_pool_;
    }
    result wrap_call_for_retry(std::chrono::microseconds timeout, std::function<result(std::chrono::microseconds)> fn);

    collection(std::shared_ptr<bucket> bucket, std::string scope, std::string name, std::chrono::microseconds kv_timeout);

    static void install_callbacks(lcb_st* lcb);

    bool set_collection()
    {
        return (name_ != bucket::default_name || scope_ != bucket::default_name);
    }

  public:
    result get(const std::string& id, const get_options& opts = get_options());

    result exists(const std::string& id, const exists_options& opts = exists_options());

    template<typename Content>
    result upsert(const std::string& id, const Content& value, const upsert_options& opts = upsert_options())
    {
        return wrap_call_for_retry(boost::get_optional_value_or(opts.timeout(), default_kv_timeout()),
                                   [&](std::chrono::microseconds timeout) -> result {
                                       return store(store_operation::upsert,
                                                    id,
                                                    value,
                                                    boost::get_optional_value_or(opts.cas(), 0),
                                                    boost::get_optional_value_or(opts.durability(), durability_level::none),
                                                    timeout);
                                   });
    }

    template<typename Content>
    result insert(const std::string& id, const Content& value, const insert_options& opts = insert_options())
    {
        return wrap_call_for_retry(
          boost::get_optional_value_or(opts.timeout(), default_kv_timeout()), [&](std::chrono::microseconds timeout) -> result {
              return store(
                store_operation::insert, id, value, 0, boost::get_optional_value_or(opts.durability(), durability_level::none), timeout);
          });
    }

    template<typename Content>
    result replace(const std::string& id, const Content& value, const replace_options& opts = replace_options())
    {
        return wrap_call_for_retry(boost::get_optional_value_or(opts.timeout(), default_kv_timeout()),
                                   [&](std::chrono::microseconds timeout) -> result {
                                       return store(store_operation::replace,
                                                    id,
                                                    value,
                                                    boost::get_optional_value_or(opts.cas(), 0),
                                                    boost::get_optional_value_or(opts.durability(), durability_level::none),
                                                    timeout);
                                   });
    }

    result remove(const std::string& id, const remove_options& opts = remove_options());

    result mutate_in(const std::string& id, std::vector<mutate_in_spec> specs, const mutate_in_options& opts = mutate_in_options());

    result lookup_in(const std::string& id, std::vector<lookup_in_spec> specs, const lookup_in_options& opts = lookup_in_options());

    CB_NODISCARD const std::string& name() const
    {
        return name_;
    }

    CB_NODISCARD const std::string& scope() const
    {
        return scope_;
    }

    CB_NODISCARD const std::string& bucket_name() const
    {
        return bucket_.lock()->name();
    }

    CB_NODISCARD std::shared_ptr<couchbase::bucket> get_bucket()
    {
        return bucket_.lock();
    }

    CB_NODISCARD std::chrono::microseconds default_kv_timeout() const
    {
        return kv_timeout_;
    }
};
} // namespace couchbase