Reduce Warnings - Address warnings in examples and redundant recompilations (#1201)

* Avoid redundant recompilation of mongocxx test components

* Address -Wmissing-prototypes warnings

* Address -Wold-style-cast warnings

* Address -Wmissing-noreturn warnings

* Address -Wsuggest-override warnings

* Address -Wreserved-identifier warnings

* Address -Wunreachable-code-return warnings

* Address -Wfloat-equal warnings

* Address -Wunused-exception-parameter warnings

* Address -Wswitch-enum warnings

* Address -Wunused* warnings

* Address "hides previous local declaration" warnings (C4456)

* Improve type consistency of key generation in examples

* Address -Wnewline-eof warnings

Author: eramongodb

examples/bsoncxx/decimal128.cpp

@@ -27,7 +27,7 @@ int main() {
     decimal128 d128;
     try {
         d128 = decimal128{"1.234E+3456"};
-    } catch (const bsoncxx::exception& e) {
+    } catch (const bsoncxx::exception&) {
         // The example won't fail, but in general, arbitrary strings
         // might not convert properly.
         return EXIT_FAILURE;

examples/bsoncxx/view_and_value.cpp

@@ -58,16 +58,16 @@ int main() {
     // note that all of the interesting methods for reading BSON are defined on the view type.
 
     // iterate over the elements in a bson document
-    for (document::element ele : view) {
+    for (document::element doc_ele : view) {
         // element is non owning view of a key-value pair within a document.
 
         // we can use the key() method to get a string_view of the key.
-        stdx::string_view field_key{ele.key()};
+        stdx::string_view field_key{doc_ele.key()};
 
         std::cout << "Got key, key = " << field_key << std::endl;
 
         // we can use type() to get the type of the value.
-        switch (ele.type()) {
+        switch (doc_ele.type()) {
             case type::k_string:
                 std::cout << "Got String!" << std::endl;
                 break;
@@ -77,20 +77,40 @@ int main() {
             case type::k_array: {
                 std::cout << "Got Array!" << std::endl;
                 // if we have a subarray, we can access it by getting a view of it.
-                array::view subarr{ele.get_array().value};
-                for (array::element ele : subarr) {
+                array::view subarr{doc_ele.get_array().value};
+                for (array::element arr_ele : subarr) {
                     std::cout << "array element: "
-                              << bsoncxx::string::to_string(ele.get_string().value) << std::endl;
+                              << bsoncxx::string::to_string(arr_ele.get_string().value)
+                              << std::endl;
                 }
                 break;
             }
-            default:
+
+            case type::k_double:
+            case type::k_document:
+            case type::k_binary:
+            case type::k_undefined:
+            case type::k_bool:
+            case type::k_date:
+            case type::k_null:
+            case type::k_regex:
+            case type::k_dbpointer:
+            case type::k_code:
+            case type::k_symbol:
+            case type::k_codewscope:
+            case type::k_int32:
+            case type::k_timestamp:
+            case type::k_int64:
+            case type::k_decimal128:
+            case type::k_maxkey:
+            case type::k_minkey:
                 std::cout << "We messed up!" << std::endl;
+                break;
         }
 
         // usually we don't need to actually use a switch statement, because we can also
         // get a variant 'value' that can hold any BSON type.
-        types::bson_value::view ele_val{ele.get_value()};
+        types::bson_value::view doc_ele_val{doc_ele.get_value()};
     }
 
     // If we want to search for an element we can use operator[]

examples/mongocxx/automatic_client_side_field_level_encryption.cpp

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include <algorithm>
+#include <cstdint>
 #include <fstream>
 #include <iostream>
 #include <random>
@@ -45,6 +46,8 @@ using bsoncxx::types::bson_value::make_value;
 
 using namespace mongocxx;
 
+namespace {
+
 const int kKeyLength = 96;
 
 using ns_pair = std::pair<std::string, std::string>;
@@ -92,15 +95,19 @@ bsoncxx::document::value doc_from_file(std::string path) {
     return bsoncxx::from_json(file_contents);
 }
 
+}  // namespace
+
 int main() {
     instance inst{};
 
     // This must be the same master key that was used to create
     // the encryption key; here, we use a random key as a placeholder.
-    char key_storage[kKeyLength];
-    std::generate_n(key_storage, kKeyLength, std::rand);
+    std::uint8_t key_storage[kKeyLength];
+    std::generate_n(key_storage, kKeyLength, []() {
+        return static_cast<std::uint8_t>(std::rand() % UINT8_MAX);
+    });
     bsoncxx::types::b_binary local_master_key{
-        bsoncxx::binary_sub_type::k_binary, kKeyLength, (const uint8_t*)&key_storage};
+        bsoncxx::binary_sub_type::k_binary, kKeyLength, key_storage};
 
     auto kms_providers = document{} << "local" << open_document << "key" << local_master_key
                                     << close_document << finalize;

examples/mongocxx/change_streams.cpp

@@ -29,7 +29,7 @@
 namespace {
 
 // watch_forever iterates the change stream until an error occurs.
-void watch_forever(mongocxx::collection& collection) {
+[[noreturn]] void watch_forever(mongocxx::collection& collection) {
     mongocxx::options::change_stream options;
     // Wait up to 1 second before polling again.
     const std::chrono::milliseconds await_time{1000};

examples/mongocxx/explicit_encryption.cpp

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include <algorithm>
+#include <cstdint>
 #include <iostream>
 #include <random>
 
@@ -49,10 +50,12 @@ int main() {
 
     // This must be the same master key that was used to create
     // the encryption key; here, we use a random key as a placeholder.
-    char key_storage[kKeyLength];
-    std::generate_n(key_storage, kKeyLength, std::rand);
+    std::uint8_t key_storage[kKeyLength];
+    std::generate_n(key_storage, kKeyLength, []() {
+        return static_cast<std::uint8_t>(std::rand() % UINT8_MAX);
+    });
     bsoncxx::types::b_binary local_master_key{
-        bsoncxx::binary_sub_type::k_binary, kKeyLength, (const uint8_t*)&key_storage};
+        bsoncxx::binary_sub_type::k_binary, kKeyLength, key_storage};
 
     auto kms_providers = document{} << "local" << open_document << "key" << local_master_key
                                     << close_document << finalize;

examples/mongocxx/explicit_encryption_auto_decryption.cpp

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include <algorithm>
+#include <cstdint>
 #include <iostream>
 #include <random>
 
@@ -49,10 +50,12 @@ int main() {
 
     // This must be the same master key that was used to create
     // the encryption key; here, we use a random key as a placeholder.
-    char key_storage[kKeyLength];
-    std::generate_n(key_storage, kKeyLength, std::rand);
+    std::uint8_t key_storage[kKeyLength];
+    std::generate_n(key_storage, kKeyLength, []() {
+        return static_cast<std::uint8_t>(std::rand() % UINT8_MAX);
+    });
     bsoncxx::types::b_binary local_master_key{
-        bsoncxx::binary_sub_type::k_binary, kKeyLength, (const uint8_t*)&key_storage};
+        bsoncxx::binary_sub_type::k_binary, kKeyLength, key_storage};
 
     auto kms_providers = document{} << "local" << open_document << "key" << local_master_key
                                     << close_document << finalize;

examples/mongocxx/get_values_from_documents.cpp

@@ -25,6 +25,8 @@ using bsoncxx::builder::basic::kvp;
 using bsoncxx::builder::basic::make_array;
 using bsoncxx::builder::basic::make_document;
 
+namespace {
+
 // Document model, showing array with nested documents:
 //
 // {
@@ -61,11 +63,11 @@ void iterate_messagelist(const bsoncxx::document::element& ele) {
     // Check validity and type before trying to iterate.
     if (ele.type() == type::k_array) {
         bsoncxx::array::view subarray{ele.get_array().value};
-        for (const bsoncxx::array::element& msg : subarray) {
+        for (const bsoncxx::array::element& message : subarray) {
             // Check correct type before trying to access elements.
             // Only print out fields if they exist; don't report missing fields.
-            if (msg.type() == type::k_document) {
-                bsoncxx::document::view subdoc = msg.get_document().value;
+            if (message.type() == type::k_document) {
+                bsoncxx::document::view subdoc = message.get_document().value;
                 bsoncxx::document::element uid = subdoc["uid"];
                 bsoncxx::document::element status = subdoc["status"];
                 bsoncxx::document::element msg = subdoc["msg"];
@@ -118,6 +120,8 @@ void iterate_documents(mongocxx::collection& coll) {
     }
 }
 
+}  // namespace
+
 int main() {
     // The mongocxx::instance constructor and destructor initialize and shut down the driver,
     // respectively. Therefore, a mongocxx::instance must be created before using the driver and

examples/mongocxx/instance_management.cpp

@@ -56,28 +56,22 @@ class mongo_access {
         return _pool->acquire();
     }
 
-    bsoncxx::stdx::optional<connection> try_get_connection() {
-        return _pool->try_acquire();
-    }
-
    private:
     mongo_access() = default;
 
     std::unique_ptr<mongocxx::instance> _instance = nullptr;
     std::unique_ptr<mongocxx::pool> _pool = nullptr;
 };
 
-}  // namespace
-
 // The 'configure' and 'do_work' functions use the same mongocxx::instance and mongocxx::pool
 // objects by way of the mongo_access singleton.
 
 void configure(mongocxx::uri uri) {
     class noop_logger : public mongocxx::logger {
        public:
-        virtual void operator()(mongocxx::log_level,
-                                bsoncxx::stdx::string_view,
-                                bsoncxx::stdx::string_view) noexcept {}
+        void operator()(mongocxx::log_level,
+                        bsoncxx::stdx::string_view,
+                        bsoncxx::stdx::string_view) noexcept override {}
     };
 
     // Use `std::make_unique` with C++14 and newer.
@@ -97,6 +91,8 @@ bool do_work() {
     return true;
 }
 
+}  // namespace
+
 int main(int argc, char* argv[]) {
     auto uri = mongocxx::uri{(argc >= 2) ? argv[1] : mongocxx::uri::k_default_uri};
     configure(std::move(uri));

examples/mongocxx/mongodb.com/aggregation_examples.cpp

@@ -26,11 +26,10 @@
 #include <mongocxx/exception/logic_error.hpp>
 #include <mongocxx/instance.hpp>
 
-// NOTE: Any time this file is modified, a DOCS ticket should be opened to sync the changes with the
-// corresponding page on mongodb.com/docs. See CXX-1514, CXX-1249, and DRIVERS-356 for more info.
-
 using namespace mongocxx;
 
+namespace {
+
 void aggregation_examples(const mongocxx::database& db) {
     {
         // Start Aggregation Example 1
@@ -143,6 +142,8 @@ void aggregation_examples(const mongocxx::database& db) {
     }
 }
 
+}  // namespace
+
 int main() {
     // The mongocxx::instance constructor and destructor initialize and shut down the driver,
     // respectively. Therefore, a mongocxx::instance must be created before using the driver and

examples/mongocxx/mongodb.com/documentation_examples.cpp

@@ -33,8 +33,7 @@
 #include <mongocxx/options/server_api.hpp>
 #include <mongocxx/uri.hpp>
 
-// NOTE: Any time this file is modified, a DOCS ticket should be opened to sync the changes with the
-// corresponding page on mongodb.com/docs. See CXX-1249 and DRIVERS-356 for more info.
+namespace {
 
 template <typename T>
 void check_field(const T& document,
@@ -141,7 +140,7 @@ std::string getenv_or_fail(const char* s) {
 // Returns a document with credentials for KMS providers.
 // If include_external is true, all KMS providers are set.
 // If include_external is false, only the local provider is set.
-bsoncxx::document::value _make_kms_doc(bool include_external = true) {
+bsoncxx::document::value make_kms_doc(bool include_external = true) {
     using bsoncxx::builder::basic::sub_document;
     using bsoncxx::builder::stream::close_array;
     using bsoncxx::builder::stream::close_document;
@@ -1442,19 +1441,19 @@ static bool is_snapshot_ready(mongocxx::client& client, mongocxx::collection& co
     opts.snapshot(true);
 
     auto session = client.start_session(opts);
+
     try {
-        auto maybe_value = collection.find_one(session, {});
-        if (maybe_value) {
+        if (collection.find_one(session, {})) {
             return true;
         }
-        return false;
     } catch (const mongocxx::operation_exception& e) {
         if (e.code().value() == 246) {  // snapshot unavailable
             return false;
         }
         throw;
     }
-    return true;
+
+    return false;
 }
 
 // Seed the pets database and wait for the snapshot to become available.
@@ -1612,7 +1611,7 @@ static void queryable_encryption_api(mongocxx::client& client) {
     options::client_encryption ce_opts;
     ce_opts.key_vault_client(&key_vault_client);
     ce_opts.key_vault_namespace({"keyvault", "datakeys"});
-    ce_opts.kms_providers(_make_kms_doc(false));
+    ce_opts.kms_providers(make_kms_doc(false));
     client_encryption client_encryption(std::move(ce_opts));
 
     auto key1_id = client_encryption.create_data_key("local");
@@ -1634,7 +1633,7 @@ static void queryable_encryption_api(mongocxx::client& client) {
     // Create an Queryable Encryption collection.
     options::auto_encryption auto_encrypt_opts{};
     auto_encrypt_opts.key_vault_namespace({"keyvault", "datakeys"});
-    auto_encrypt_opts.kms_providers(_make_kms_doc(false));
+    auto_encrypt_opts.kms_providers(make_kms_doc(false));
     auto_encrypt_opts.encrypted_fields_map(encrypted_fields_map.view());
 
     // Optional, If mongocryptd is not in PATH, then find the binary at MONGOCRYPTD_PATH.
@@ -1699,6 +1698,8 @@ static void queryable_encryption_api(mongocxx::client& client) {
     // End Queryable Encryption Example
 }
 
+}  // namespace
+
 int main() {
     // The mongocxx::instance constructor and destructor initialize and shut down the driver,
     // respectively. Therefore, a mongocxx::instance must be created before using the driver and