CXX-2109 Deprecate all references to utf8

Author: bazile-clyde

docs/content/mongocxx-v3/tutorial.md

@@ -202,7 +202,7 @@ value is a string:
 
 ```c++
 bsoncxx::document::element element = view["name"];
-if(element.type() != bsoncxx::type::k_utf8) {
+if(element.type() != bsoncxx::type::k_string) {
   // Error
 }
 std::string name = element.get_string().value.to_string();

examples/bsoncxx/builder_basic.cpp

@@ -35,7 +35,7 @@ int main(int, char**) {
     using bsoncxx::builder::basic::kvp;
 
     doc.append(
-        kvp("foo", "bar"));  // string literal value will be converted to b_utf8 automatically
+        kvp("foo", "bar"));  // string literal value will be converted to b_string automatically
     doc.append(kvp("baz", types::b_bool{false}));
     doc.append(kvp("garply", types::b_double{3.14159}));
 

examples/bsoncxx/builder_core.cpp

@@ -61,8 +61,8 @@ int main(int, char**) {
     // Just call append() and pass a value wrapped in the corresponding BSON type.
     auto array = builder::core{true};  // we are building an array
 
-    array.append(types::b_utf8{"hello"});  // append a UTF-8 string
-    array.append(types::b_double{1.234});  // append a double
-    array.append(types::b_int32{1234});    // append an int32
+    array.append(types::b_string{"hello"});  // append a UTF-8 string
+    array.append(types::b_double{1.234});    // append a double
+    array.append(types::b_int32{1234});      // append an int32
     // ... etc.
 }

examples/bsoncxx/view_and_value.cpp

@@ -69,7 +69,7 @@ int main(int, char**) {
 
         // we can use type() to get the type of the value.
         switch (ele.type()) {
-            case type::k_utf8:
+            case type::k_string:
                 std::cout << "Got String!" << std::endl;
                 break;
             case type::k_oid:

examples/mongocxx/get_values_from_documents.cpp

@@ -75,7 +75,7 @@ void iterate_messagelist(const bsoncxx::document::element& ele) {
                 if (status && status.type() == type::k_int32) {
                     std::cout << "status: " << status.get_int32().value << std::endl;
                 }
-                if (msg && msg.type() == type::k_utf8) {
+                if (msg && msg.type() == type::k_string) {
                     std::cout << "msg: " << msg.get_string().value << std::endl;
                 }
             } else {

src/bsoncxx/builder/core.cpp

@@ -288,15 +288,15 @@ core& core::append(const types::b_double& value) {
     return *this;
 }
 
-core& core::append(const types::b_utf8& value) {
+core& core::append(const types::b_string& value) {
     stdx::string_view key = _impl->next_key();
 
     if (!bson_append_utf8(_impl->back(),
                           key.data(),
                           static_cast<std::int32_t>(key.length()),
                           value.value.data(),
                           static_cast<std::int32_t>(value.value.length()))) {
-        throw bsoncxx::exception{error_code::k_cannot_append_utf8};
+        throw bsoncxx::exception{error_code::k_cannot_append_string};
     }
 
     return *this;
@@ -545,13 +545,13 @@ core& core::append(const types::b_maxkey&) {
 }
 
 core& core::append(std::string str) {
-    append(types::b_utf8{std::move(str)});
+    append(types::b_string{std::move(str)});
 
     return *this;
 }
 
 core& core::append(stdx::string_view str) {
-    append(types::b_utf8{std::move(str)});
+    append(types::b_string{std::move(str)});
 
     return *this;
 }
@@ -647,15 +647,12 @@ core& core::concatenate(const bsoncxx::document::view& view) {
 
 core& core::append(const bsoncxx::types::bson_value::view& value) {
     switch (static_cast<int>(value.type())) {
-        // CXX-1817; deprecation warning suppressed for get_utf8()
-        BSONCXX_SUPPRESS_DEPRECATION_WARNINGS_BEGIN
 #define BSONCXX_ENUM(type, val)     \
     case val:                       \
         append(value.get_##type()); \
         break;
 #include <bsoncxx/enums/type.hpp>
 #undef BSONCXX_ENUM
-        BSONCXX_SUPPRESS_DEPRECATION_WARNINGS_END
     }
 
     return *this;

src/bsoncxx/builder/core.hpp

@@ -184,9 +184,9 @@ class BSONCXX_API core {
     /// @throws
     ///   bsoncxx::exception if the current BSON datum is a document that is waiting for a key to be
     ///   appended to start a new key/value pair.
-    ///   bsoncxx::exception if the utf8 fails to append.
+    ///   bsoncxx::exception if the string fails to append.
     ///
-    core& append(const types::b_utf8& value);
+    core& append(const types::b_string& value);
 
     ///
     /// Appends a BSON document.
@@ -510,7 +510,7 @@ class BSONCXX_API core {
     BSONCXX_INLINE core& append(T* v) {
         static_assert(std::is_same<typename std::remove_const<T>::type, char>::value,
                       "append is disabled for non-char pointer types");
-        append(types::b_utf8{v});
+        append(types::b_string{v});
 
         return *this;
     }

src/bsoncxx/document/element.cpp

@@ -78,32 +78,26 @@ stdx::string_view element::key() const {
     return stdx::string_view{key};
 }
 
-// CXX-1817; deprecation warning suppressed for get_utf8()
-BSONCXX_SUPPRESS_DEPRECATION_WARNINGS_BEGIN
 #define BSONCXX_ENUM(name, val)                                     \
     types::b_##name element::get_##name() const {                   \
         types::bson_value::view v{_raw, _length, _offset, _keylen}; \
         return v.get_##name();                                      \
     }
 #include <bsoncxx/enums/type.hpp>
 #undef BSONCXX_ENUM
-BSONCXX_SUPPRESS_DEPRECATION_WARNINGS_END
 
-types::b_utf8 element::get_string() const {
+types::b_string element::get_utf8() const {
     types::bson_value::view v{_raw, _length, _offset, _keylen};
     return v.get_string();
 }
 
 types::bson_value::view element::get_value() const {
     switch (static_cast<int>(type())) {
-        // CXX-1817; deprecation warning suppressed for get_utf8()
-        BSONCXX_SUPPRESS_DEPRECATION_WARNINGS_BEGIN
 #define BSONCXX_ENUM(type, val) \
     case val:                   \
         return types::bson_value::view{get_##type()};
 #include <bsoncxx/enums/type.hpp>
 #undef BSONCXX_ENUM
-        BSONCXX_SUPPRESS_DEPRECATION_WARNINGS_END
     }
 
     BSONCXX_UNREACHABLE;

src/bsoncxx/document/element.hpp

@@ -30,7 +30,7 @@ enum class binary_sub_type : std::uint8_t;
 namespace types {
 struct b_eod;
 struct b_double;
-struct b_utf8;
+struct b_string;
 struct b_document;
 struct b_array;
 struct b_binary;
@@ -145,25 +145,24 @@ class BSONCXX_API element {
     types::b_double get_double() const;
 
     ///
-    /// Getter for elements of the b_utf8 type.
+    /// Getter for elements of the b_string type.
     ///
     /// @deprecated use document::element::get_string() instead.
     ///
-    /// @throws bsoncxx::exception if this element is not a b_utf8.
+    /// @throws bsoncxx::exception if this element is not a b_string.
     ///
     /// @return the element's value.
     ///
-    BSONCXX_DEPRECATED types::b_utf8 get_utf8() const;
+    BSONCXX_DEPRECATED types::b_string get_utf8() const;
 
     ///
-    /// Getter for elements of the b_utf8, or string, type. This function acts as a
-    /// wrapper for get_utf8().
+    /// Getter for elements of the b_string type.
     ///
-    /// @throws bsoncxx::exception if this element is not a b_utf8.
+    /// @throws bsoncxx::exception if this element is not a b_string.
     ///
     /// @return the element's value.
     ///
-    types::b_utf8 get_string() const;
+    types::b_string get_string() const;
 
     ///
     /// Getter for elements of the b_document type.

src/bsoncxx/enums/type.hpp

@@ -17,7 +17,7 @@
 #endif
 
 BSONCXX_ENUM(double, 0x01)
-BSONCXX_ENUM(utf8, 0x02)
+BSONCXX_ENUM(string, 0x02)
 BSONCXX_ENUM(document, 0x03)
 BSONCXX_ENUM(array, 0x04)
 BSONCXX_ENUM(binary, 0x05)

src/bsoncxx/exception/error_code.hpp

@@ -95,6 +95,8 @@ enum class error_code : std::int32_t {
 #define BSONCXX_ENUM(name, value) k_cannot_append_##name,
 #include <bsoncxx/enums/type.hpp>
 #undef BSONCXX_ENUM
+    k_cannot_append_utf8 = k_cannot_append_string,
+    k_need_element_type_k_utf8 = k_need_element_type_k_string,
     // Add new constant string message to error_code.cpp as well!
 };
 

src/bsoncxx/test/bson_builder.cpp

@@ -52,7 +52,7 @@ void viewable_eq_viewable(const T& stream, const U& basic) {
     REQUIRE(std::memcmp(expected.data(), test.data(), expected.length()) == 0);
 }
 
-TEST_CASE("builder appends utf8", "[bsoncxx::builder::stream]") {
+TEST_CASE("builder appends string", "[bsoncxx::builder::stream]") {
     bson_t expected;
     bson_init(&expected);
 
@@ -73,8 +73,8 @@ TEST_CASE("builder appends utf8", "[bsoncxx::builder::stream]") {
         bson_eq_stream(&expected, b);
     }
 
-    SECTION("works with b_utf8") {
-        b << "hello" << types::b_utf8{"world"};
+    SECTION("works with b_string") {
+        b << "hello" << types::b_string{"world"};
 
         bson_eq_stream(&expected, b);
     }
@@ -812,7 +812,7 @@ TEST_CASE("core method chaining to build array works", "[bsoncxx::builder::core]
     auto array_view = array.view();
 
     REQUIRE(std::distance(array_view.begin(), array_view.end()) == 3);
-    REQUIRE(array_view[0].type() == type::k_utf8);
+    REQUIRE(array_view[0].type() == type::k_string);
     REQUIRE(string::to_string(array_view[0].get_string().value) == "foo");
     REQUIRE(array_view[1].type() == type::k_int32);
     REQUIRE(array_view[1].get_int32().value == 1);
@@ -1197,7 +1197,7 @@ TEST_CASE("builder::basic::make_array works", "[bsoncxx::builder::basic::make_ar
     auto array_view = array.view();
 
     REQUIRE(std::distance(array_view.begin(), array_view.end()) == 3);
-    REQUIRE(array_view[0].type() == type::k_utf8);
+    REQUIRE(array_view[0].type() == type::k_string);
     REQUIRE(string::to_string(array_view[0].get_string().value) == "foo");
     REQUIRE(array_view[1].type() == type::k_int32);
     REQUIRE(array_view[1].get_int32().value == 1);

src/bsoncxx/test/bson_types.cpp

@@ -45,10 +45,10 @@ TEST_CASE("b_double", "[bsoncxx::type::b_double]") {
     REQUIRE(!(a == c));
 }
 
-TEST_CASE("b_utf8", "[bsoncxx::type::b_utf8]") {
-    b_utf8 a{"hello"};
-    b_utf8 b{a};
-    b_utf8 c{"world"};
+TEST_CASE("b_string", "[bsoncxx::type::b_string]") {
+    b_string a{"hello"};
+    b_string b{a};
+    b_string c{"world"};
     REQUIRE(a == b);
     REQUIRE(!(a == c));
 }
@@ -196,9 +196,9 @@ TEST_CASE("bson_value::view with b_double", "[bsoncxx::types::bson_value::view]"
     REQUIRE(bson_value::view{double_val}.get_double() == double_val);
 }
 
-TEST_CASE("bson_value::view with b_utf8", "[bsoncxx::types::bson_value::view]") {
-    b_utf8 utf8_val{"hello"};
-    REQUIRE(bson_value::view{utf8_val}.get_string() == utf8_val);
+TEST_CASE("bson_value::view with b_string", "[bsoncxx::types::bson_value::view]") {
+    b_string string_val{"hello"};
+    REQUIRE(bson_value::view{string_val}.get_string() == string_val);
 }
 
 TEST_CASE("bson_value::view with b_document", "[bsoncxx::types::bson_value::view]") {

src/bsoncxx/test/bson_value.cpp

@@ -65,15 +65,15 @@ TEST_CASE("types::bson_value::value", "[bsoncxx::types::bson_value::value]") {
             coverting_construction_test(b_bool{true}, test_value);
         }
 
-        SECTION("utf8") {
+        SECTION("string") {
             std::string value = "super duper";
 
             auto test_doc = bson_value::make_value(value);
             value_construction_test(test_doc.view());
 
             coverting_construction_test(value, test_doc);
             coverting_construction_test(value.c_str(), test_doc);
-            coverting_construction_test(b_utf8{value}, test_doc);
+            coverting_construction_test(b_string{value}, test_doc);
             coverting_construction_test(stdx::string_view{value}, test_doc);
 
             const char raw_data[]{'s', 'u', 'p', 'e', 'r', ' ', 'd', 'u', 'p', 'e', 'r'};

src/bsoncxx/types.hpp

@@ -32,14 +32,15 @@ BSONCXX_INLINE_NAMESPACE_BEGIN
 /// An enumeration of each BSON type.
 /// These x-macros will expand to be of the form:
 ///    k_double = 0x01,
-///    k_utf8 = 0x02,
+///    k_string = 0x02,
 ///    k_document = 0x03,
 ///    k_array = 0x04 ...
 ///
 enum class type : std::uint8_t {
 #define BSONCXX_ENUM(name, val) k_##name = val,
 #include <bsoncxx/enums/type.hpp>
 #undef BSONCXX_ENUM
+    k_utf8 = 0x02,
 };
 
 ///
@@ -110,19 +111,19 @@ BSONCXX_INLINE bool operator==(const b_double& lhs, const b_double& rhs) {
 ///
 /// A BSON UTF-8 encoded string value.
 ///
-struct BSONCXX_API b_utf8 {
-    static constexpr auto type_id = type::k_utf8;
+struct BSONCXX_API b_string {
+    static constexpr auto type_id = type::k_string;
 
     ///
-    /// Constructor for b_utf8.
+    /// Constructor for b_string.
     ///
     /// @param t
     ///   The value to wrap.
     ///
     template <typename T,
-              typename std::enable_if<!std::is_same<b_utf8, typename std::decay<T>::type>::value,
+              typename std::enable_if<!std::is_same<b_string, typename std::decay<T>::type>::value,
                                       int>::type = 0>
-    BSONCXX_INLINE explicit b_utf8(T&& t) : value(std::forward<T>(t)) {}
+    BSONCXX_INLINE explicit b_string(T&& t) : value(std::forward<T>(t)) {}
 
     stdx::string_view value;
 
@@ -135,14 +136,21 @@ struct BSONCXX_API b_utf8 {
 };
 
 ///
-/// free function comparator for b_utf8
+/// free function comparator for b_string
 ///
-/// @relatesalso b_utf8
+/// @relatesalso b_string
 ///
-BSONCXX_INLINE bool operator==(const b_utf8& lhs, const b_utf8& rhs) {
+BSONCXX_INLINE bool operator==(const b_string& lhs, const b_string& rhs) {
     return lhs.value == rhs.value;
 }
 
+///
+/// This class has been renamed to b_string
+///
+/// @deprecated use b_string instead.
+///
+BSONCXX_DEPRECATED typedef b_string b_utf8;
+
 ///
 /// A BSON document value.
 ///

src/bsoncxx/types/bson_value/value.cpp

@@ -47,7 +47,7 @@ value::value(int64_t v) : _impl{stdx::make_unique<impl>()} {
 
 value::value(const char* v) : value(stdx::string_view{v}) {}
 value::value(std::string v) : value(stdx::string_view{v}) {}
-value::value(b_utf8 v) : value(v.value) {}
+value::value(b_string v) : value(v.value) {}
 value::value(stdx::string_view v) : _impl{stdx::make_unique<impl>()} {
     _impl->_value.value_type = BSON_TYPE_UTF8;
     _impl->_value.value.v_utf8.str = make_copy_for_libbson(v);

src/bsoncxx/types/bson_value/value.hpp

@@ -48,7 +48,7 @@ class BSONCXX_API value {
 ///
 /// These x-macros will expand to:
 ///    value(b_double v);
-///    value(b_utf8 v);
+///    value(b_string v);
 ///    value(b_document v);
 ///    value(b_array v); ...
 ///