[CXX-2625] Bring our very own string_view (plus: Some iterators + ranges backports)

.mci.yml

@@ -608,7 +608,6 @@ tasks:
     - name: compile_with_shared_libs
       commands:
       - func: "setup"
-      - func: "start_mongod"
       - func: "fetch_c_driver_source"
       - func: "compile"
 

Doxyfile

@@ -900,7 +900,8 @@ RECURSIVE              = YES
 # Note that relative paths are relative to the directory from which doxygen is
 # run.
 
-EXCLUDE                =
+EXCLUDE                = src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/stdx/operators.hpp \
+                         src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/stdx/type_traits.hpp
 
 # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
 # directories that are symbolic links (a Unix file system feature) are excluded

src/bsoncxx/include/CMakeLists.txt

@@ -63,6 +63,7 @@ set_dist_list(src_bsoncxx_include_DIST
     bsoncxx/v_noabi/bsoncxx/config/compiler.hpp
     bsoncxx/v_noabi/bsoncxx/config/postlude.hpp
     bsoncxx/v_noabi/bsoncxx/config/prelude.hpp
+    bsoncxx/v_noabi/bsoncxx/config/util.hpp
     bsoncxx/v_noabi/bsoncxx/decimal128-fwd.hpp
     bsoncxx/v_noabi/bsoncxx/decimal128.hpp
     bsoncxx/v_noabi/bsoncxx/document/element-fwd.hpp
@@ -83,6 +84,7 @@ set_dist_list(src_bsoncxx_include_DIST
     bsoncxx/v_noabi/bsoncxx/oid-fwd.hpp
     bsoncxx/v_noabi/bsoncxx/oid.hpp
     bsoncxx/v_noabi/bsoncxx/stdx/make_unique.hpp
+    bsoncxx/v_noabi/bsoncxx/stdx/operators.hpp
     bsoncxx/v_noabi/bsoncxx/stdx/optional.hpp
     bsoncxx/v_noabi/bsoncxx/stdx/string_view.hpp
     bsoncxx/v_noabi/bsoncxx/stdx/type_traits.hpp

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/config/compiler.hpp

@@ -12,21 +12,35 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#if defined(_MSC_VER)
+// clang-format off
+
+#define BSONCXX_IF_MSVC(...)
+#define BSONCXX_IF_GCC(...)
+#define BSONCXX_IF_CLANG(...)
+#define BSONCXX_IF_GNU_LIKE(...) \
+    BSONCXX_IF_GCC(__VA_ARGS__) \
+    BSONCXX_IF_CLANG(__VA_ARGS__)
+
+#ifdef __GNUC__
+    #ifdef __clang__
+        #undef BSONCXX_IF_CLANG
+        #define BSONCXX_IF_CLANG(...) __VA_ARGS__
+    #else
+        #undef BSONCXX_IF_GCC
+        #define BSONCXX_IF_GCC(...) __VA_ARGS__
+    #endif
+#elif defined(_MSC_VER)
+    #undef BSONCXX_IF_MSVC
+    #define BSONCXX_IF_MSVC(...) __VA_ARGS__
+#endif
+
+// clang-format on
 
 // Disable MSVC warnings that cause a lot of noise related to DLL visibility
 // for types that we don't control (like std::unique_ptr).
-#pragma warning(push)
-#pragma warning(disable : 4251 4275)
+BSONCXX_PUSH_WARNINGS();
+BSONCXX_DISABLE_WARNING(MSVC(4251));
+BSONCXX_DISABLE_WARNING(MSVC(5275));
 
 #define BSONCXX_INLINE inline BSONCXX_PRIVATE
-
-#define BSONCXX_CALL __cdecl
-
-#else
-
-#define BSONCXX_INLINE inline BSONCXX_PRIVATE
-
-#define BSONCXX_CALL
-
-#endif
+#define BSONCXX_CALL BSONCXX_IF_MSVC(__cdecl)

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/config/postlude.hpp

@@ -15,9 +15,7 @@
 // compiler.hpp
 #undef BSONCXX_INLINE
 #pragma pop_macro("BSONCXX_INLINE")
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
+BSONCXX_POP_WARNINGS();
 #undef BSONCXX_CALL
 #pragma pop_macro("BSONCXX_CALL")
 
@@ -67,8 +65,35 @@
 #undef BSONCXX_UNREACHABLE
 #pragma pop_macro("BSONCXX_UNREACHABLE")
 
+#pragma pop_macro("bsoncxx_cxx14_constexpr")
+#pragma pop_macro("BSONCXX_RETURNS")
+
 // CXX-2769: out-of-place, but remains for backward compatibility.
 #ifdef BSONCXX_ENUM
 static_assert(false, "BSONCXX_ENUM must be undef'ed");
 #endif
 #pragma pop_macro("BSONCXX_ENUM")
+
+// util.hpp
+#pragma pop_macro("BSONCXX_PUSH_WARNINGS")
+#pragma pop_macro("BSONCXX_POP_WARNINGS")
+#pragma pop_macro("BSONCXX_DISABLE_WARNING")
+
+#pragma pop_macro("_bsoncxxDisableWarningImpl_for_MSVC")
+#pragma pop_macro("_bsoncxxDisableWarningImpl_for_GCC")
+#pragma pop_macro("_bsoncxxDisableWarningImpl_for_GNU")
+#pragma pop_macro("_bsoncxxDisableWarningImpl_for_Clang")
+
+#pragma pop_macro("BSONCXX_CONCAT")
+#pragma pop_macro("BSONCXX_CONCAT_IMPL")
+
+#pragma pop_macro("BSONCXX_PRAGMA")
+#pragma pop_macro("_bsoncxxPragma")
+#pragma pop_macro("BSONCXX_STRINGIFY_IMPL")
+#pragma pop_macro("BSONCXX_STRINGIFY")
+#pragma pop_macro("BSONCXX_FORCE_SEMICOLON")
+
+#pragma pop_macro("BSONCXX_IF_MSVC")
+#pragma pop_macro("BSONCXX_IF_GCC")
+#pragma pop_macro("BSONCXX_IF_CLANG")
+#pragma pop_macro("BSONCXX_IF_GNU_LIKE")

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/config/prelude.hpp

@@ -12,11 +12,53 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// util.hpp
+#pragma push_macro("BSONCXX_CONCAT")
+#undef BSONCXX_CONCAT
+#pragma push_macro("BSONCXX_CONCAT_IMPL")
+#undef BSONCXX_CONCAT_IMPL
+#pragma push_macro("BSONCXX_STRINGIFY")
+#undef BSONCXX_STRINGIFY
+#pragma push_macro("BSONCXX_STRINGIFY_IMPL")
+#undef BSONCXX_STRINGIFY_IMPL
+#pragma push_macro("BSONCXX_PRAGMA")
+#undef BSONCXX_PRAGMA
+#pragma push_macro("_bsoncxxPragma")
+#undef _bsoncxxPragma
+#pragma push_macro("BSONCXX_FORCE_SEMICOLON")
+#undef BSONCXX_FORCE_SEMICOLON
+#pragma push_macro("BSONCXX_RETURNS")
+#undef BSONCXX_RETURNS
+#pragma push_macro("bsoncxx_cxx14_constexpr")
+#undef bsoncxx_cxx14_constexpr
+#pragma push_macro("BSONCXX_DISABLE_WARNING")
+#undef BSONCXX_DISABLE_WARNING
+#pragma push_macro("BSONCXX_PUSH_WARNINGS")
+#undef BSONCXX_PUSH_WARNINGS
+#pragma push_macro("BSONCXX_POP_WARNINGS")
+#undef BSONCXX_POP_WARNINGS
+#pragma push_macro("_bsoncxxDisableWarningImpl_for_GCC")
+#undef _bsoncxxDisableWarningImpl_for_GCC
+#pragma push_macro("_bsoncxxDisableWarningImpl_for_Clang")
+#undef _bsoncxxDisableWarningImpl_for_Clang
+#pragma push_macro("_bsoncxxDisableWarningImpl_for_MSVC")
+#undef _bsoncxxDisableWarningImpl_for_MSVC
+#pragma push_macro("_bsoncxxDisableWarningImpl_for_GNU")
+#undef _bsoncxxDisableWarningImpl_for_GNU
+
 // compiler.hpp
 #pragma push_macro("BSONCXX_INLINE")
 #undef BSONCXX_INLINE
 #pragma push_macro("BSONCXX_CALL")
 #undef BSONCXX_CALL
+#pragma push_macro("BSONCXX_IF_MSVC")
+#undef BSONCXX_IF_MSVC
+#pragma push_macro("BSONCXX_IF_GCC")
+#undef BSONCXX_IF_GCC
+#pragma push_macro("BSONCXX_IF_CLANG")
+#undef BSONCXX_IF_CLANG
+#pragma push_macro("BSONCXX_IF_GNU_LIKE")
+#undef BSONCXX_IF_GNU_LIKE
 
 // config.hpp (generated by CMake)
 #pragma push_macro("BSONCXX_INLINE_NAMESPACE_BEGIN")
@@ -60,6 +102,8 @@
 #pragma push_macro("BSONCXX_NO_DEPRECATED")
 #undef BSONCXX_NO_DEPRECATED
 
+#include <bsoncxx/config/util.hpp>
+//
 #include <bsoncxx/config/compiler.hpp>
 #include <bsoncxx/config/config.hpp>
 #include <bsoncxx/config/export.hpp>

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/config/util.hpp

@@ -0,0 +1,133 @@
+// clang-format off
+/**
+ * @internal
+ * @brief Convert the given macro argument to a string literal, after macro expansion
+ */
+#define BSONCXX_STRINGIFY(...) BSONCXX_STRINGIFY_IMPL(__VA_ARGS__)
+#define BSONCXX_STRINGIFY_IMPL(...) #__VA_ARGS__
+
+/**
+ * @brief Token-paste two macro arguments, after macro expansion
+ */
+#define BSONCXX_CONCAT(A, ...) BSONCXX_CONCAT_IMPL(A, __VA_ARGS__)
+#define BSONCXX_CONCAT_IMPL(A, ...) A##__VA_ARGS__
+
+/**
+ * @internal
+ * @brief Expands to a _Pragma() preprocessor directive, after macro expansion
+ *
+ * The arguments an arbitrary "token soup", and should not be quoted like a regular
+ * _Pragma. This macro will stringify-them itself.
+ *
+ * Example:
+ *
+ *      BSONCXX_PRAGMA(GCC diagnostic ignore "-Wconversion")
+ *
+ * will become:
+ *
+ *      _Pragma("GCC diagnostic ignore \"-Wconversion\"")
+ *
+ */
+#define BSONCXX_PRAGMA(...) _bsoncxxPragma(__VA_ARGS__)
+#ifdef _MSC_VER
+// Old MSVC doesn't recognize C++11 _Pragma(), but it always recognized __pragma
+#define _bsoncxxPragma(...) __pragma(__VA_ARGS__)
+#else
+#define _bsoncxxPragma(...) _Pragma(BSONCXX_STRINGIFY(__VA_ARGS__))
+#endif
+
+/**
+ * @internal
+ * @brief Use in a declaration position to force the appearence of a semicolon
+ * as the next token. Use this for statement-like or declaration-like macros to
+ * enforce that their call sites are followed by a semicolon
+ */
+#define BSONCXX_FORCE_SEMICOLON static_assert(true, "")
+
+/**
+ * @internal
+ * @brief Add a trailing noexcept, decltype-return, and return-body to a
+ * function definition. (Not compatible with lambda expressions.)
+ *
+ * Example:
+ *
+ *      template <typename T>
+ *      auto foo(T x, T y) BSONCXX_RETURNS(x + y);
+ *
+ * Becomes:
+ *
+ *      template <typename T>
+ *      auto foo(T x, T y) noexcept(noexcept(x + y))
+ *          -> decltype(x + y)
+ *      { return x + y };
+ *
+ */
+#define BSONCXX_RETURNS(...)                                 \
+    noexcept(noexcept(__VA_ARGS__))->decltype(__VA_ARGS__) { \
+        return __VA_ARGS__;                                  \
+    }                                                        \
+    BSONCXX_FORCE_SEMICOLON
+
+/**
+ * @internal
+ * @macro mongocxx_cxx14_constexpr
+ * @brief Expands to `constexpr` if compiling as c++14 or greater, otherwise
+ * expands to `inline`.
+ *
+ * Use this on functions that can only be constexpr in C++14 or newer, including
+ * non-const member functions.
+ */
+#if __cplusplus >= 201402L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L && _MSC_VER > 1910)
+#define bsoncxx_cxx14_constexpr constexpr
+#else
+#define bsoncxx_cxx14_constexpr inline
+#endif
+
+/**
+ * @internal
+ * @brief Disable a warning for a particular compiler.
+ *
+ * The argument should be of the form:
+ *
+ * - Clang(<flag-string-literal>)
+ * - GCC(<flag-string-literal>)
+ * - GNU(<flag-string-literal>)
+ * - MSVC(<id-integer-literal>)
+ *
+ * The "GNU" form applies to both GCC and Clang
+ */
+#define BSONCXX_DISABLE_WARNING(Spec) \
+    BSONCXX_CONCAT(_bsoncxxDisableWarningImpl_for_, Spec) \
+    BSONCXX_FORCE_SEMICOLON
+
+/**
+ * @internal
+ * @brief Push the current compiler diagnostics settings state
+ */
+#define BSONCXX_PUSH_WARNINGS() \
+    BSONCXX_IF_GNU_LIKE(BSONCXX_PRAGMA(GCC diagnostic push)) \
+    BSONCXX_IF_MSVC(BSONCXX_PRAGMA(warning(push))) \
+    BSONCXX_FORCE_SEMICOLON
+
+/**
+ * @internal
+ * @brief Restore prior compiler diagnostics settings from before the most
+ * recent BSONCXX_PUSH_WARNINGS()
+ */
+#define BSONCXX_POP_WARNINGS() \
+    BSONCXX_IF_GNU_LIKE(BSONCXX_PRAGMA(GCC diagnostic pop)) \
+    BSONCXX_IF_MSVC(BSONCXX_PRAGMA(warning(pop))) \
+    BSONCXX_FORCE_SEMICOLON
+
+#define _bsoncxxDisableWarningImpl_for_GCC(...) \
+    BSONCXX_IF_GCC(BSONCXX_PRAGMA(GCC diagnostic ignored __VA_ARGS__))
+
+#define _bsoncxxDisableWarningImpl_for_Clang(...) \
+    BSONCXX_IF_CLANG(BSONCXX_PRAGMA(GCC diagnostic ignored __VA_ARGS__))
+
+#define _bsoncxxDisableWarningImpl_for_GNU(...) \
+    _bsoncxxDisableWarningImpl_for_GCC(__VA_ARGS__) \
+    _bsoncxxDisableWarningImpl_for_Clang(__VA_ARGS__)
+
+#define _bsoncxxDisableWarningImpl_for_MSVC(...) \
+    BSONCXX_IF_MSVC(BSONCXX_PRAGMA(warning(disable : __VA_ARGS__)))

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/document/value.hpp

@@ -235,17 +235,13 @@ class value {
     std::size_t _length{0};
 };
 
-#if !defined(__clang__) && defined(__GNUC__) && (__cplusplus >= 201709L)
-// Silence false positive with g++ 10.2.1 on Debian 11.
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif
 BSONCXX_INLINE document::view value::view() const noexcept {
+    // Silence false positive with g++ 10.2.1 on Debian 11.
+    BSONCXX_PUSH_WARNINGS();
+    BSONCXX_DISABLE_WARNING(GCC("-Wmaybe-uninitialized"));
     return document::view{static_cast<uint8_t*>(_data.get()), _length};
+    BSONCXX_POP_WARNINGS();
 }
-#if !defined(__clang__) && defined(__GNUC__) && (__cplusplus >= 201709L)
-#pragma GCC diagnostic pop
-#endif
 
 BSONCXX_INLINE value::operator document::view() const noexcept {
     return view();