index.hpp

Go to the documentation of this file.

// Copyright 2009-present 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 <mongocxx/options/index-fwd.hpp> // IWYU pragma: export
 
//
 
#include <mongocxx/v1/indexes.hpp> // IWYU pragma: export
 
#include <chrono>
#include <cstdint>
#include <memory>
#include <string>
#include <utility>
 
#include <mongocxx/collection-fwd.hpp>
 
#include <bsoncxx/document/value.hpp> // IWYU pragma: keep: backward compatibility, to be removed.
#include <bsoncxx/document/view.hpp>
#include <bsoncxx/document/view_or_value.hpp>
#include <bsoncxx/stdx/optional.hpp>
#include <bsoncxx/string/view_or_value.hpp>
 
#include <bsoncxx/config/prelude.hpp>
 
#include <mongocxx/config/prelude.hpp>
 
namespace mongocxx {
namespace v_noabi {
namespace options {

class index {
   public:
    BSONCXX_PRIVATE_WARNINGS_PUSH();
    BSONCXX_PRIVATE_WARNINGS_DISABLE(MSVC(4251));
    BSONCXX_PRIVATE_WARNINGS_DISABLE(MSVC(4275));

    class MONGOCXX_ABI_EXPORT base_storage_options {
       public:
        virtual ~base_storage_options();
 
        base_storage_options(base_storage_options&&) = default;
        base_storage_options& operator=(base_storage_options&&) = default;
        base_storage_options(base_storage_options const&) = default;
        base_storage_options& operator=(base_storage_options const&) = default;
 
        base_storage_options() = default;
 
       private:
        friend v_noabi::options::index;
 
        virtual int type() const = 0;
    };

    class MONGOCXX_ABI_EXPORT wiredtiger_storage_options final : public base_storage_options {
       public:
        ~wiredtiger_storage_options() override;
 
        wiredtiger_storage_options(wiredtiger_storage_options&&) = default;
        wiredtiger_storage_options& operator=(wiredtiger_storage_options&&) = default;
        wiredtiger_storage_options(wiredtiger_storage_options const&) = default;
        wiredtiger_storage_options& operator=(wiredtiger_storage_options const&) = default;
 
        wiredtiger_storage_options() = default;

        void config_string(bsoncxx::v_noabi::string::view_or_value config_string) {
            _config_string = std::move(config_string);
        }

        bsoncxx::v_noabi::stdx::optional<bsoncxx::v_noabi::string::view_or_value> const& config_string() const {
            return _config_string;
        }
 
       private:
        friend v_noabi::collection;
 
        MONGOCXX_ABI_NO_EXPORT int type() const override;
 
        bsoncxx::v_noabi::stdx::optional<bsoncxx::v_noabi::string::view_or_value> _config_string;
    };
 
    BSONCXX_PRIVATE_WARNINGS_POP();

    index() = default;

    /* explicit(false) */ MONGOCXX_ABI_EXPORT_CDECL() index(v1::indexes::options const& opts);

    explicit operator v1::indexes::options() const {
        using bsoncxx::v_noabi::to_v1;
 
        v1::indexes::options ret;
 
        if (_background) {
            ret.background(*_background);
        }
 
        if (_unique) {
            ret.unique(*_unique);
        }
 
        if (_hidden) {
            ret.hidden(*_hidden);
        }
 
        if (_name) {
            ret.name(std::string{_name->view()});
        }
 
        if (_collation) {
            ret.collation(bsoncxx::v1::document::value{to_v1(*_collation)});
        }
 
        if (_sparse) {
            ret.sparse(*_sparse);
        }
 
        // _storage_options
 
        if (_storage_engine) {
            ret.storage_engine(bsoncxx::v1::document::value{to_v1(*_storage_engine)});
        }
 
        if (_expire_after) {
            ret.expire_after(*_expire_after);
        }
 
        if (_version) {
            ret.version(*_version);
        }
 
        if (_weights) {
            ret.weights(bsoncxx::v1::document::value{to_v1(*_weights)});
        }
 
        if (_default_language) {
            ret.default_language(std::string{_default_language->view()});
        }
 
        if (_language_override) {
            ret.language_override(std::string{_language_override->view()});
        }
 
        if (_partial_filter_expression) {
            ret.partial_filter_expression(bsoncxx::v1::document::value{to_v1(*_partial_filter_expression)});
        }
 
        if (_twod_sphere_version) {
            ret.twod_sphere_version(*_twod_sphere_version);
        }
 
        if (_twod_bits_precision) {
            ret.twod_bits_precision(*_twod_bits_precision);
        }
 
        if (_twod_location_min) {
            ret.twod_location_min(*_twod_location_min);
        }
 
        if (_twod_location_max) {
            ret.twod_location_max(*_twod_location_max);
        }
 
        // _haystack_bucket_size
 
        return ret;
    }

    index& background(bool background) {
        _background = std::move(background);
        return *this;
    }

    bsoncxx::v_noabi::stdx::optional<bool> const& background() const {
        return _background;
    }

    index& unique(bool unique) {
        _unique = std::move(unique);
        return *this;
    }

    bsoncxx::v_noabi::stdx::optional<bool> const& unique() const {
        return _unique;
    }

    index& hidden(bool hidden) {
        _hidden = std::move(hidden);
        return *this;
    }

    bsoncxx::v_noabi::stdx::optional<bool> const& hidden() const {
        return _hidden;
    }

    index& name(bsoncxx::v_noabi::string::view_or_value name) {
        _name = std::move(name);
        return *this;
    }

    bsoncxx::v_noabi::stdx::optional<bsoncxx::v_noabi::string::view_or_value> const& name() const {
        return _name;
    }

    index& collation(bsoncxx::v_noabi::document::view collation) {
        _collation = std::move(collation);
        return *this;
    }

    bsoncxx::v_noabi::stdx::optional<bsoncxx::v_noabi::document::view> const& collation() const {
        return _collation;
    }

    index& sparse(bool sparse) {
        _sparse = std::move(sparse);
        return *this;
    }

    bsoncxx::v_noabi::stdx::optional<bool> const& sparse() const {
        return _sparse;
    }

    MONGOCXX_DEPRECATED index& storage_options(std::unique_ptr<base_storage_options> storage_options) {
        _storage_options = std::move(storage_options);
        return *this;
    }

    MONGOCXX_DEPRECATED index& storage_options(std::unique_ptr<wiredtiger_storage_options> storage_options) {
        _storage_options = std::move(storage_options);
        return *this;
    }

    index& storage_engine(bsoncxx::v_noabi::stdx::optional<bsoncxx::v_noabi::document::view> storage_engine) {
        _storage_engine = std::move(storage_engine);
        return *this;
    }

    bsoncxx::v_noabi::stdx::optional<bsoncxx::v_noabi::document::view> const& storage_engine() const {
        return _storage_engine;
    }

    index& expire_after(std::chrono::seconds seconds) {
        _expire_after = std::move(seconds);
        return *this;
    }

    bsoncxx::v_noabi::stdx::optional<std::chrono::seconds> const& expire_after() const {
        return _expire_after;
    }

    index& version(std::int32_t v) {
        _version = std::move(v);
        return *this;
    }

    bsoncxx::v_noabi::stdx::optional<std::int32_t> const& version() const {
        return _version;
    }

    index& weights(bsoncxx::v_noabi::document::view weights) {
        _weights = std::move(weights);
        return *this;
    }

    bsoncxx::v_noabi::stdx::optional<bsoncxx::v_noabi::document::view> const& weights() const {
        return _weights;
    }

    index& default_language(bsoncxx::v_noabi::string::view_or_value default_language) {
        _default_language = std::move(default_language);
        return *this;
    }

    bsoncxx::v_noabi::stdx::optional<bsoncxx::v_noabi::string::view_or_value> const& default_language() const {
        return _default_language;
    }

    index& language_override(bsoncxx::v_noabi::string::view_or_value language_override) {
        _language_override = std::move(language_override);
        return *this;
    }

    bsoncxx::v_noabi::stdx::optional<bsoncxx::v_noabi::string::view_or_value> const& language_override() const {
        return _language_override;
    }

    index& partial_filter_expression(bsoncxx::v_noabi::document::view partial_filter_expression) {
        _partial_filter_expression = std::move(partial_filter_expression);
        return *this;
    }

    bsoncxx::v_noabi::stdx::optional<bsoncxx::v_noabi::document::view> const& partial_filter_expression() const {
        return _partial_filter_expression;
    }

    index& twod_sphere_version(std::uint8_t twod_sphere_version) {
        _twod_sphere_version = std::move(twod_sphere_version);
        return *this;
    }

    bsoncxx::v_noabi::stdx::optional<std::uint8_t> const& twod_sphere_version() const {
        return _twod_sphere_version;
    }

    index& twod_bits_precision(std::uint8_t twod_bits_precision) {
        _twod_bits_precision = std::move(twod_bits_precision);
        return *this;
    }

    bsoncxx::v_noabi::stdx::optional<std::uint8_t> const& twod_bits_precision() const {
        return _twod_bits_precision;
    }

    index& twod_location_min(double twod_location_min) {
        _twod_location_min = std::move(twod_location_min);
        return *this;
    }

    bsoncxx::v_noabi::stdx::optional<double> const& twod_location_min() const {
        return _twod_location_min;
    }

    index& twod_location_max(double twod_location_max) {
        _twod_location_max = std::move(twod_location_max);
        return *this;
    }

    bsoncxx::v_noabi::stdx::optional<double> const& twod_location_max() const {
        return _twod_location_max;
    }

    MONGOCXX_DEPRECATED index& haystack_bucket_size(double haystack_bucket_size) {
        return this->haystack_bucket_size_deprecated(haystack_bucket_size);
    }
 
    index& haystack_bucket_size_deprecated(double haystack_bucket_size) {
        _haystack_bucket_size = haystack_bucket_size;
        return *this;
    }

    MONGOCXX_DEPRECATED bsoncxx::v_noabi::stdx::optional<double> const& haystack_bucket_size() const {
        return this->haystack_bucket_size_deprecated();
    }
 
    bsoncxx::v_noabi::stdx::optional<double> const& haystack_bucket_size_deprecated() const {
        return _haystack_bucket_size;
    }

    MONGOCXX_ABI_EXPORT_CDECL() operator bsoncxx::v_noabi::document::view_or_value();
 
    class internal;
 
   private:
    bsoncxx::v_noabi::stdx::optional<bool> _background;
    bsoncxx::v_noabi::stdx::optional<bool> _unique;
    bsoncxx::v_noabi::stdx::optional<bool> _hidden;
    bsoncxx::v_noabi::stdx::optional<bsoncxx::v_noabi::string::view_or_value> _name;
    bsoncxx::v_noabi::stdx::optional<bsoncxx::v_noabi::document::view> _collation;
    bsoncxx::v_noabi::stdx::optional<bool> _sparse;
    std::unique_ptr<base_storage_options> _storage_options;
    bsoncxx::v_noabi::stdx::optional<bsoncxx::v_noabi::document::view> _storage_engine;
    bsoncxx::v_noabi::stdx::optional<std::chrono::seconds> _expire_after;
    bsoncxx::v_noabi::stdx::optional<std::int32_t> _version;
    bsoncxx::v_noabi::stdx::optional<bsoncxx::v_noabi::document::view> _weights;
    bsoncxx::v_noabi::stdx::optional<bsoncxx::v_noabi::string::view_or_value> _default_language;
    bsoncxx::v_noabi::stdx::optional<bsoncxx::v_noabi::string::view_or_value> _language_override;
    bsoncxx::v_noabi::stdx::optional<bsoncxx::v_noabi::document::view> _partial_filter_expression;
    bsoncxx::v_noabi::stdx::optional<std::uint8_t> _twod_sphere_version;
    bsoncxx::v_noabi::stdx::optional<std::uint8_t> _twod_bits_precision;
    bsoncxx::v_noabi::stdx::optional<double> _twod_location_min;
    bsoncxx::v_noabi::stdx::optional<double> _twod_location_max;
    bsoncxx::v_noabi::stdx::optional<double> _haystack_bucket_size;
};
 
} // namespace options
} // namespace v_noabi
} // namespace mongocxx
 
namespace mongocxx {
namespace v_noabi {

inline v_noabi::options::index from_v1(v1::indexes::options const& v) {
    return {v};
}

inline v1::indexes::options to_v1(v_noabi::options::index const& v) {
    return v1::indexes::options{v};
}
 
} // namespace v_noabi
} // namespace mongocxx
 
#include <bsoncxx/config/postlude.hpp>
 
#include <mongocxx/config/postlude.hpp>