CXX-739 Apply string::view_or_value to client, database, and collection

Author: samantharitter

src/mongocxx/client.cpp

@@ -69,9 +69,8 @@ stdx::optional<class read_concern> client::read_concern() const {
     if (!libmongoc::read_concern_get_level(rc)) {
         return stdx::nullopt;
     }
-
     return {(class read_concern){
-            stdx::make_unique<read_concern::impl>(libmongoc::read_concern_copy(rc))}};
+        stdx::make_unique<read_concern::impl>(libmongoc::read_concern_copy(rc))}};
 }
 
 void client::read_preference(class read_preference rp) {
@@ -100,8 +99,8 @@ class write_concern client::write_concern() const {
     return wc;
 }
 
-class database client::database(stdx::string_view name) const & {
-    return mongocxx::database(*this, name);
+class database client::database(bsoncxx::string::view_or_value name) const & {
+    return mongocxx::database(*this, std::move(name));
 }
 
 cursor client::list_databases() const {
@@ -116,7 +115,7 @@ cursor client::list_databases() const {
 }
 
 const client::impl& client::_get_impl() const {
-    if(!_impl) {
+    if (!_impl) {
         throw logic_error{make_error_code(error_code::k_invalid_client_object)};
     }
     return *_impl;

src/mongocxx/client.hpp

@@ -18,8 +18,7 @@
 
 #include <memory>
 
-#include <bsoncxx/stdx/string_view.hpp>
-
+#include <bsoncxx/string/view_or_value.hpp>
 #include <mongocxx/database.hpp>
 #include <mongocxx/options/client.hpp>
 #include <mongocxx/read_concern.hpp>
@@ -48,9 +47,7 @@ MONGOCXX_INLINE_NAMESPACE_BEGIN
 /// @endcode
 ///
 class MONGOCXX_API client {
-
    public:
-
     ///
     /// Default constructs a new client. The client is not connected and is equivalent to the
     /// state of a moved-from client. The only valid actions to take with a default constructed
@@ -66,10 +63,7 @@ class MONGOCXX_API client {
     /// @param options
     ///   Additional options that cannot be specified via the mongodb_uri
     ///
-    client(
-        const class uri& mongodb_uri,
-        const options::client& options = options::client()
-    );
+    client(const class uri& mongodb_uri, const options::client& options = options::client());
 
     ///
     /// Move constructs a client.
@@ -171,8 +165,8 @@ class MONGOCXX_API client {
     ///
     /// @return The database
     ///
-    class database database(stdx::string_view name) const&;
-    class database database(stdx::string_view name) const&& = delete;
+    class database database(bsoncxx::string::view_or_value name) const&;
+    class database database(bsoncxx::string::view_or_value name) const&& = delete;
 
     ///
     /// Allows the syntax @c client["db_name"] as a convenient shorthand for the client::database()
@@ -185,8 +179,8 @@ class MONGOCXX_API client {
     ///
     /// @return Client side representation of a server side database
     ///
-    MONGOCXX_INLINE class database operator[](stdx::string_view name) const&;
-    MONGOCXX_INLINE class database operator[](stdx::string_view name) const&& = delete;
+    MONGOCXX_INLINE class database operator[](bsoncxx::string::view_or_value name) const&;
+    MONGOCXX_INLINE class database operator[](bsoncxx::string::view_or_value name) const&& = delete;
 
     ///
     /// Enumerates the databases in the client.
@@ -218,7 +212,7 @@ class MONGOCXX_API client {
     std::unique_ptr<impl> _impl;
 };
 
-MONGOCXX_INLINE database client::operator[](stdx::string_view name) const & {
+MONGOCXX_INLINE database client::operator[](bsoncxx::string::view_or_value name) const & {
     return database(name);
 }
 

src/mongocxx/collection.cpp

@@ -74,7 +74,8 @@ mongocxx::stdx::optional<bsoncxx::document::value> find_and_modify(
 
     if (!r) {
         auto gle = mongocxx::libmongoc::collection_get_last_error(collection);
-        mongocxx::throw_exception<mongocxx::write_exception>(bsoncxx::helpers::value_from_bson_t(gle), error);
+        mongocxx::throw_exception<mongocxx::write_exception>(
+            bsoncxx::helpers::value_from_bson_t(gle), error);
     }
 
     bsoncxx::document::view result = reply.view();
@@ -124,24 +125,25 @@ collection::operator bool() const noexcept {
 }
 
 stdx::string_view collection::name() const {
-    return stdx::string_view{libmongoc::collection_get_name(_get_impl().collection_t)};
+    return {libmongoc::collection_get_name(_get_impl().collection_t)};
 }
 
-void collection::rename(stdx::string_view new_name, bool drop_target_before_rename) {
+void collection::rename(bsoncxx::string::view_or_value new_name, bool drop_target_before_rename) {
     bson_error_t error;
 
-    auto result = libmongoc::collection_rename(_get_impl().collection_t, _get_impl().database_name.c_str(),
-                                               new_name.data(), drop_target_before_rename, &error);
+    auto result =
+        libmongoc::collection_rename(_get_impl().collection_t, _get_impl().database_name.c_str(),
+                                     new_name.c_str(), drop_target_before_rename, &error);
 
     if (!result) {
         throw_exception<operation_exception>(error);
     }
 }
 
-collection::collection(const database& database, stdx::string_view collection_name)
-    : _impl(stdx::make_unique<impl>(
-          libmongoc::database_get_collection(database._get_impl().database_t, collection_name.data()),
-          database.name(), database._get_impl().client_impl)) {
+collection::collection(const database& database, bsoncxx::string::view_or_value collection_name)
+    : _impl(stdx::make_unique<impl>(libmongoc::database_get_collection(
+                                        database._get_impl().database_t, collection_name.c_str()),
+                                    database.name(), database._get_impl().client_impl)) {
 }
 
 collection::collection(const database& database, void* collection)
@@ -166,6 +168,9 @@ stdx::optional<result::bulk_write> collection::bulk_write(const class bulk_write
     mongoc_bulk_operation_t* b = bulk_write._impl->operation_t;
     libmongoc::bulk_operation_set_client(b, _get_impl().client_impl->client_t);
     libmongoc::bulk_operation_set_database(b, _get_impl().database_name.c_str());
+
+    // collection::name() is guaranteed to return a null-terminated string, so it
+    // is safe to use .data() here.
     libmongoc::bulk_operation_set_collection(b, name().data());
 
     scoped_bson_t reply;
@@ -675,8 +680,8 @@ bsoncxx::document::value collection::create_index(view_or_value keys,
         opt.geo_options = &geo_opt;
     }
 
-    auto result =
-        libmongoc::collection_create_index(_get_impl().collection_t, bson_keys.bson(), &opt, &error);
+    auto result = libmongoc::collection_create_index(_get_impl().collection_t, bson_keys.bson(),
+                                                     &opt, &error);
 
     if (!result) {
         throw_exception<operation_exception>(error);
@@ -693,10 +698,10 @@ bsoncxx::document::value collection::create_index(view_or_value keys,
     }
 }
 
-cursor collection::distinct(stdx::string_view field_name, view_or_value query,
+cursor collection::distinct(bsoncxx::string::view_or_value field_name, view_or_value query,
                             const options::distinct& options) {
     bsoncxx::builder::stream::document command_builder{};
-    command_builder << "distinct" << name() << "key" << field_name << "query"
+    command_builder << "distinct" << name() << "key" << field_name.view() << "query"
                     << bsoncxx::types::b_document{query};
 
     if (options.max_time()) {
@@ -705,8 +710,8 @@ cursor collection::distinct(stdx::string_view field_name, view_or_value query,
 
     scoped_bson_t command_bson{command_builder.extract()};
 
-    auto database =
-        libmongoc::client_get_database(_get_impl().client_impl->client_t, _get_impl().database_name.data());
+    auto database = libmongoc::client_get_database(_get_impl().client_impl->client_t,
+                                                   _get_impl().database_name.c_str());
 
     auto result = libmongoc::database_command(database, MONGOC_QUERY_NONE, 0, 0, 0,
                                               command_bson.bson(), NULL, NULL);
@@ -744,16 +749,17 @@ stdx::optional<class read_concern> collection::read_concern() const {
     if (!libmongoc::read_concern_get_level(rc)) {
         return stdx::nullopt;
     }
-    return {(class read_concern){stdx::make_unique<read_concern::impl>(libmongoc::read_concern_copy(rc))}};
+    return {(class read_concern){
+        stdx::make_unique<read_concern::impl>(libmongoc::read_concern_copy(rc))}};
 }
 
 void collection::read_preference(class read_preference rp) {
     libmongoc::collection_set_read_prefs(_get_impl().collection_t, rp._impl->read_preference_t);
 }
 
 class read_preference collection::read_preference() const {
-    class read_preference rp(stdx::make_unique<read_preference::impl>(
-        libmongoc::read_prefs_copy(libmongoc::collection_get_read_prefs(_get_impl().collection_t))));
+    class read_preference rp(stdx::make_unique<read_preference::impl>(libmongoc::read_prefs_copy(
+        libmongoc::collection_get_read_prefs(_get_impl().collection_t))));
     return rp;
 }
 
@@ -768,7 +774,7 @@ class write_concern collection::write_concern() const {
 }
 
 const collection::impl& collection::_get_impl() const {
-    if(!_impl) {
+    if (!_impl) {
         throw logic_error{make_error_code(error_code::k_invalid_collection_object)};
     }
     return *_impl;

src/mongocxx/collection.hpp

@@ -24,7 +24,7 @@
 #include <bsoncxx/builder/stream/document.hpp>
 #include <bsoncxx/document/view_or_value.hpp>
 #include <bsoncxx/stdx/optional.hpp>
-#include <bsoncxx/stdx/string_view.hpp>
+#include <bsoncxx/string/view_or_value.hpp>
 
 #include <mongocxx/bulk_write.hpp>
 #include <mongocxx/cursor.hpp>
@@ -274,10 +274,9 @@ class MONGOCXX_API collection {
     ///
     /// @see http://docs.mongodb.org/manual/reference/command/distinct/
     ///
-    cursor distinct(stdx::string_view name, bsoncxx::document::view_or_value filter,
+    cursor distinct(bsoncxx::string::view_or_value name, bsoncxx::document::view_or_value filter,
                     const options::distinct& options = options::distinct());
 
-    ///
     /// Drops this collection and all its contained documents from the database.
     ///
     /// @throws exception::operation if the operation fails.
@@ -458,7 +457,7 @@ class MONGOCXX_API collection {
     cursor list_indexes() const;
 
     ///
-    /// Returns the name of this collection.
+    /// Returns the name of this collection as a view of a null-terminated string.
     ///
     /// @return The name of the collection.
     ///
@@ -475,7 +474,7 @@ class MONGOCXX_API collection {
     ///
     /// @see https://docs.mongodb.org/manual/reference/command/renameCollection/
     ///
-    void rename(stdx::string_view new_name, bool drop_target_before_rename = false);
+    void rename(bsoncxx::string::view_or_value new_name, bool drop_target_before_rename = false);
 
     ///
     /// Sets the read_concern for this collection. Changes will not have any effect on existing
@@ -592,7 +591,8 @@ class MONGOCXX_API collection {
    private:
     friend class database;
 
-    MONGOCXX_PRIVATE collection(const database& database, stdx::string_view collection_name);
+    MONGOCXX_PRIVATE collection(const database& database,
+                                bsoncxx::string::view_or_value collection_name);
 
     MONGOCXX_PRIVATE collection(const database& database, void* collection);
 

src/mongocxx/database.cpp

@@ -46,10 +46,10 @@ database& database::operator=(database&&) noexcept = default;
 
 database::~database() = default;
 
-database::database(const class client& client, stdx::string_view name)
+database::database(const class client& client, bsoncxx::string::view_or_value name)
     : _impl(stdx::make_unique<impl>(
-          libmongoc::client_get_database(client._get_impl().client_t, name.data()), &client._get_impl(),
-          name.data())) {
+          libmongoc::client_get_database(client._get_impl().client_t, name.c_str()),
+          &client._get_impl(), name.c_str())) {
 }
 
 database::database(const database& d) {
@@ -82,6 +82,7 @@ cursor database::list_collections(bsoncxx::document::view_or_value filter) {
 
     return cursor(result);
 }
+
 stdx::string_view database::name() const {
     return _get_impl().name;
 }
@@ -92,8 +93,8 @@ bsoncxx::document::value database::run_command(bsoncxx::document::view_or_value
     bson_error_t error;
 
     reply_bson.flag_init();
-    auto result = libmongoc::database_command_simple(_get_impl().database_t, command_bson.bson(), NULL,
-                                                     reply_bson.bson(), &error);
+    auto result = libmongoc::database_command_simple(_get_impl().database_t, command_bson.bson(),
+                                                     NULL, reply_bson.bson(), &error);
 
     if (!result) {
         throw_exception<operation_exception>(std::move(reply_bson.steal()), error);
@@ -109,12 +110,12 @@ bsoncxx::document::value database::modify_collection(stdx::string_view name,
     return run_command(doc.view());
 }
 
-class collection database::create_collection(stdx::string_view name,
+class collection database::create_collection(bsoncxx::string::view_or_value name,
                                              const options::create_collection& options) {
     bson_error_t error;
 
     libbson::scoped_bson_t opts_bson{options.to_document()};
-    auto result = libmongoc::database_create_collection(_get_impl().database_t, name.data(),
+    auto result = libmongoc::database_create_collection(_get_impl().database_t, name.c_str(),
                                                         opts_bson.bson(), &error);
 
     if (!result) {
@@ -140,16 +141,17 @@ stdx::optional<class read_concern> database::read_concern() const {
     if (!libmongoc::read_concern_get_level(rc)) {
         return stdx::nullopt;
     }
-    return {(class read_concern){stdx::make_unique<read_concern::impl>(libmongoc::read_concern_copy(rc))}};
+    return {(class read_concern){
+        stdx::make_unique<read_concern::impl>(libmongoc::read_concern_copy(rc))}};
 }
 
 void database::read_preference(class read_preference rp) {
     libmongoc::database_set_read_prefs(_get_impl().database_t, rp._impl->read_preference_t);
 }
 
-bool database::has_collection(stdx::string_view name) const {
+bool database::has_collection(bsoncxx::string::view_or_value name) const {
     bson_error_t error;
-    return libmongoc::database_has_collection(_get_impl().database_t, name.data(), &error);
+    return libmongoc::database_has_collection(_get_impl().database_t, name.c_str(), &error);
 }
 
 class read_preference database::read_preference() const {
@@ -163,17 +165,17 @@ void database::write_concern(class write_concern wc) {
 }
 
 class write_concern database::write_concern() const {
-    class write_concern wc(stdx::make_unique<write_concern::impl>(
-        libmongoc::write_concern_copy(libmongoc::database_get_write_concern(_get_impl().database_t))));
+    class write_concern wc(stdx::make_unique<write_concern::impl>(libmongoc::write_concern_copy(
+        libmongoc::database_get_write_concern(_get_impl().database_t))));
     return wc;
 }
 
-collection database::collection(stdx::string_view name) const {
-    return mongocxx::collection(*this, name);
+collection database::collection(bsoncxx::string::view_or_value name) const {
+    return mongocxx::collection(*this, std::move(name));
 }
 
 const database::impl& database::_get_impl() const {
-    if(!_impl) {
+    if (!_impl) {
         throw logic_error{make_error_code(error_code::k_invalid_database_object)};
     }
     return *_impl;