minor: clang-format pass

acmorrow · acmorrow · commit 1a85e8bb7cc8 · 2016-01-09T19:55:41.000-05:00
diff --git a/examples/bsoncxx/getting_values.cpp b/examples/bsoncxx/getting_values.cpp
@@ -90,6 +90,6 @@ int main(int, char**) {
     };
 
     // Make all variables used.
-    return (awards && first_award_year && second_award_year && last_name) ?
-        EXIT_SUCCESS : EXIT_FAILURE;
+    return (awards && first_award_year && second_award_year && last_name) ? EXIT_SUCCESS
+                                                                          : EXIT_FAILURE;
 }
diff --git a/examples/bsoncxx/view_and_value.cpp b/examples/bsoncxx/view_and_value.cpp
@@ -25,14 +25,10 @@ int main(int, char**) {
     using builder::basic::sub_array;
 
     auto doc = builder::basic::document{};
-    doc.append(kvp("team", "platforms"),
-               kvp("id", types::b_oid{oid(oid::init_tag)}),
+    doc.append(kvp("team", "platforms"), kvp("id", types::b_oid{oid(oid::init_tag)}),
                kvp("members", [](sub_array sa) {
-                   sa.append("tyler", "jason", "drew",
-                             "sam", "ernie", "john",
-                             "mark", "crystal");
-               })
-    );
+                   sa.append("tyler", "jason", "drew", "sam", "ernie", "john", "mark", "crystal");
+               }));
 
     // document::value is an owning bson document conceptually similar to string.
     document::value value{doc.extract()};
@@ -49,7 +45,6 @@ int main(int, char**) {
 
     // iterate over the elements in a bson document
     for (document::element 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.
@@ -59,31 +54,32 @@ int main(int, char**) {
 
         // we can use type() to get the type of the value.
         switch (ele.type()) {
-        case type::k_utf8:
-            std::cout << "Got String!" << std::endl;
-            break;
-        case type::k_oid:
-            std::cout << "Got ObjectId!" << std::endl;
-            break;
-        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) {
-                std::cout << "array element: " << to_json(ele.get_value()) << std::endl;
+            case type::k_utf8:
+                std::cout << "Got String!" << std::endl;
+                break;
+            case type::k_oid:
+                std::cout << "Got ObjectId!" << std::endl;
+                break;
+            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) {
+                    std::cout << "array element: " << to_json(ele.get_value()) << std::endl;
+                }
+                break;
             }
-            break;
-        }
-        default:
-            std::cout << "We messed up!" << std::endl;
+            default:
+                std::cout << "We messed up!" << std::endl;
         }
 
         // 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::value ele_val{ele.get_value()};
         // if we need to print an arbitrary value, we can use to_json, which provides
         // a suitable overload.
-        std::cout << "the value is " << to_json(ele_val) << std::endl;;
+        std::cout << "the value is " << to_json(ele_val) << std::endl;
+        ;
     }
 
     // If we want to search for an element we can use operator[]
diff --git a/examples/mongocxx/bulk_write.cpp b/examples/mongocxx/bulk_write.cpp
@@ -93,8 +93,9 @@ int main(int, char**) {
     }
 
     std::cout << "Upserted IDs" << std::endl;
-    for (const auto &id : result->upserted_ids()) {
-        std::cout << "Bulk write index: " << id.first << std::endl << bsoncxx::to_json(id.second) << std::endl;
+    for (const auto& id : result->upserted_ids()) {
+        std::cout << "Bulk write index: " << id.first << std::endl
+                  << bsoncxx::to_json(id.second) << std::endl;
     }
 
     // The collection should contain two copies of {"a": 2}.
diff --git a/src/bsoncxx/document/view.cpp b/src/bsoncxx/document/view.cpp
@@ -35,7 +35,7 @@ bson_iter_t to_bson_iter_t(element e) {
     i.next_off = e.offset();
     return i;
 }
-} // namespace
+}  // namespace
 
 view::iterator::iterator() {
 }
diff --git a/src/bsoncxx/json.cpp b/src/bsoncxx/json.cpp
@@ -288,11 +288,10 @@ std::string to_json(types::value value) {
 
 stdx::optional<document::value> from_json(stdx::string_view json) {
     bson_error_t error;
-    bson_t* result = bson_new_from_json(
-        reinterpret_cast<const uint8_t*>(json.data()), json.size(), &error);
+    bson_t* result =
+        bson_new_from_json(reinterpret_cast<const uint8_t*>(json.data()), json.size(), &error);
 
-    if (!result)
-        return stdx::nullopt;
+    if (!result) return stdx::nullopt;
 
     std::uint32_t length;
     std::uint8_t* buf = bson_destroy_with_steal(result, true, &length);
diff --git a/src/bsoncxx/test/bson_get_values.cpp b/src/bsoncxx/test/bson_get_values.cpp
@@ -49,7 +49,6 @@ TEST_CASE("[] can reach into nested arrays", "[bsoncxx]") {
         REQUIRE(!doc["ints"][2][9]);
         REQUIRE(!doc["bools"][9]);
     }
-
 }
 
 TEST_CASE("[] can reach into nested documents", "[bsoncxx]") {
diff --git a/src/bsoncxx/test/json.cpp b/src/bsoncxx/test/json.cpp
@@ -4,8 +4,8 @@
 #include <bsoncxx/json.hpp>
 
 namespace {
-    constexpr auto k_invalid_json = R"({])";
-    constexpr auto k_valid_json = R"({ "a" : 1, "b" : 2.0 })";
+constexpr auto k_invalid_json = R"({])";
+constexpr auto k_valid_json = R"({ "a" : 1, "b" : 2.0 })";
 }
 
 TEST_CASE("invalid json returns disengaged optional") {
@@ -21,7 +21,8 @@ TEST_CASE("valid json returns an engaged optional") {
 TEST_CASE("valid json is converted to equivalent BSON") {
     using namespace bsoncxx;
 
-    const auto expected = builder::stream::document{} << "a" << 1 << "b" << 2.0 << builder::stream::finalize;
+    const auto expected = builder::stream::document{} << "a" << 1 << "b" << 2.0
+                                                      << builder::stream::finalize;
     const auto expected_view = expected.view();
 
     const auto actual = from_json(k_valid_json);
diff --git a/src/bsoncxx/types/value.cpp b/src/bsoncxx/types/value.cpp
@@ -30,17 +30,17 @@ namespace types {
 // Boost doesn't mark the copy constructor and copy-assignment operator of string_ref as noexcept
 // so we can't rely on automatic noexcept propagation. It really is though, so it is OK.
 #if !defined(BSONCXX_POLY_USE_BOOST)
-#define BSONCXX_ENUM(name, val)                                         \
-    value::value(b_##name value) noexcept : _type(static_cast<bsoncxx::type>(val)), \
-        _b_##name(std::move(value)) {                                   \
-        static_assert(std::is_nothrow_copy_constructible<b_##name>::value, "Copy may throw"); \
-        static_assert(std::is_nothrow_copy_assignable<b_##name>::value, "Copy may throw"); \
+#define BSONCXX_ENUM(name, val)                                                                \
+    value::value(b_##name value) noexcept : _type(static_cast<bsoncxx::type>(val)),            \
+                                            _b_##name(std::move(value)) {                      \
+        static_assert(std::is_nothrow_copy_constructible<b_##name>::value, "Copy may throw");  \
+        static_assert(std::is_nothrow_copy_assignable<b_##name>::value, "Copy may throw");     \
         static_assert(std::is_nothrow_destructible<b_##name>::value, "Destruction may throw"); \
     }
 #else
-#define BSONCXX_ENUM(name, val)                                         \
-    value::value(b_##name value) noexcept : _type(static_cast<bsoncxx::type>(val)), \
-        _b_##name(std::move(value)) {                                   \
+#define BSONCXX_ENUM(name, val)                                                                \
+    value::value(b_##name value) noexcept : _type(static_cast<bsoncxx::type>(val)),            \
+                                            _b_##name(std::move(value)) {                      \
         static_assert(std::is_nothrow_destructible<b_##name>::value, "Destruction may throw"); \
     }
 #endif
diff --git a/src/mongocxx/exception/operation_exception.cpp b/src/mongocxx/exception/operation_exception.cpp
@@ -22,7 +22,9 @@
 namespace mongocxx {
 MONGOCXX_INLINE_NAMESPACE_BEGIN
 
-operation_exception::operation_exception(std::error_code ec, bsoncxx::document::value&& raw_server_error, std::string what_arg)
+operation_exception::operation_exception(std::error_code ec,
+                                         bsoncxx::document::value&& raw_server_error,
+                                         std::string what_arg)
     : exception(ec, what_arg), _raw_server_error{std::move(raw_server_error)} {
 }
 
diff --git a/src/mongocxx/insert_many_builder.cpp b/src/mongocxx/insert_many_builder.cpp
@@ -36,11 +36,10 @@ options::bulk_write make_bulk_write_options(const options::insert& insert_option
     return bw;
 }
 
-} // namespace
+}  // namespace
 
 insert_many_builder::insert_many_builder(const options::insert& options)
-    : _writes{make_bulk_write_options(options)}, _inserted_ids{}, _index{0} {
-};
+    : _writes{make_bulk_write_options(options)}, _inserted_ids{}, _index{0} {};
 
 void insert_many_builder::operator()(const bsoncxx::document::view& doc) {
     if (!doc["_id"]) {
diff --git a/src/mongocxx/model/write.cpp b/src/mongocxx/model/write.cpp
@@ -23,27 +23,33 @@ MONGOCXX_INLINE_NAMESPACE_BEGIN
 namespace model {
 
 write::write(insert_one value) : _type(write_type::k_insert_one), _insert_one(std::move(value)) {
-    static_assert(std::is_nothrow_move_constructible<insert_one>::value, "Move-construct may throw");
+    static_assert(std::is_nothrow_move_constructible<insert_one>::value,
+                  "Move-construct may throw");
     static_assert(std::is_nothrow_move_assignable<insert_one>::value, "Move-assign may throw");
 }
 write::write(delete_one value) : _type(write_type::k_delete_one), _delete_one(std::move(value)) {
-    static_assert(std::is_nothrow_move_constructible<delete_one>::value, "Move-construct may throw");
+    static_assert(std::is_nothrow_move_constructible<delete_one>::value,
+                  "Move-construct may throw");
     static_assert(std::is_nothrow_move_assignable<delete_one>::value, "Move-assign may throw");
 }
 write::write(delete_many value) : _type(write_type::k_delete_many), _delete_many(std::move(value)) {
-    static_assert(std::is_nothrow_move_constructible<delete_many>::value, "Move-construct may throw");
+    static_assert(std::is_nothrow_move_constructible<delete_many>::value,
+                  "Move-construct may throw");
     static_assert(std::is_nothrow_move_assignable<delete_many>::value, "Move-assign may throw");
 }
 write::write(update_one value) : _type(write_type::k_update_one), _update_one(std::move(value)) {
-    static_assert(std::is_nothrow_move_constructible<update_one>::value, "Move-construct may throw");
+    static_assert(std::is_nothrow_move_constructible<update_one>::value,
+                  "Move-construct may throw");
     static_assert(std::is_nothrow_move_assignable<update_one>::value, "Move-assign may throw");
 }
 write::write(update_many value) : _type(write_type::k_update_many), _update_many(std::move(value)) {
-    static_assert(std::is_nothrow_move_constructible<update_many>::value, "Move-construct may throw");
+    static_assert(std::is_nothrow_move_constructible<update_many>::value,
+                  "Move-construct may throw");
     static_assert(std::is_nothrow_move_assignable<update_many>::value, "Move-assign may throw");
 }
 write::write(replace_one value) : _type(write_type::k_replace_one), _replace_one(std::move(value)) {
-    static_assert(std::is_nothrow_move_constructible<replace_one>::value, "Move-construct may throw");
+    static_assert(std::is_nothrow_move_constructible<replace_one>::value,
+                  "Move-construct may throw");
     static_assert(std::is_nothrow_move_assignable<replace_one>::value, "Move-assign may throw");
 }
 
diff --git a/src/mongocxx/options/bulk_write.cpp b/src/mongocxx/options/bulk_write.cpp
@@ -20,8 +20,8 @@ namespace mongocxx {
 MONGOCXX_INLINE_NAMESPACE_BEGIN
 namespace options {
 
-bulk_write::bulk_write()
-    : _ordered(true) {}
+bulk_write::bulk_write() : _ordered(true) {
+}
 
 void bulk_write::ordered(bool ordered) {
     _ordered = ordered;
diff --git a/src/mongocxx/options/find_one_and_replace.cpp b/src/mongocxx/options/find_one_and_replace.cpp
@@ -56,7 +56,8 @@ const stdx::optional<bsoncxx::document::view_or_value>& find_one_and_replace::pr
     return _projection;
 }
 
-const stdx::optional<mongocxx::options::return_document>& find_one_and_replace::return_document() const {
+const stdx::optional<mongocxx::options::return_document>& find_one_and_replace::return_document()
+    const {
     return _return_document;
 }
 
diff --git a/src/mongocxx/pool.cpp b/src/mongocxx/pool.cpp
@@ -64,12 +64,9 @@ pool::entry pool::acquire() {
 
 stdx::optional<pool::entry> pool::try_acquire() {
     auto cli = libmongoc::client_pool_try_pop(_impl->client_pool_t);
-    if (!cli)
-        return stdx::nullopt;
+    if (!cli) return stdx::nullopt;
 
-    return pool::entry{new client(cli), [this](client* client) {
-            _release(client);
-        }};
+    return pool::entry{new client(cli), [this](client* client) { _release(client); }};
 }
 
 MONGOCXX_INLINE_NAMESPACE_END
diff --git a/src/mongocxx/result/replace_one.cpp b/src/mongocxx/result/replace_one.cpp
@@ -36,10 +36,10 @@ std::int32_t replace_one::modified_count() const {
 }
 
 stdx::optional<bsoncxx::document::element> replace_one::upserted_id() const {
-	if (_result.upserted_ids().size() == 0) {
-		return stdx::nullopt;
-	}
-	return _result.upserted_ids()[0];
+    if (_result.upserted_ids().size() == 0) {
+        return stdx::nullopt;
+    }
+    return _result.upserted_ids()[0];
 }
 
 }  // namespace result
diff --git a/src/mongocxx/result/update.cpp b/src/mongocxx/result/update.cpp
@@ -36,9 +36,9 @@ std::int32_t update::modified_count() const {
 
 stdx::optional<bsoncxx::document::element> update::upserted_id() const {
     if (_result.upserted_ids().size() == 0) {
-		return stdx::nullopt;
-	}
-	return _result.upserted_ids()[0];
+        return stdx::nullopt;
+    }
+    return _result.upserted_ids()[0];
 }
 
 }  // namespace result
diff --git a/src/mongocxx/test/bulk_write.cpp b/src/mongocxx/test/bulk_write.cpp
@@ -47,7 +47,6 @@ TEST_CASE("a bulk_write will setup a mongoc bulk operation", "[bulk_write]") {
         REQUIRE(construct_called);
         REQUIRE(!ordered_value);
     }
-
 }
 
 TEST_CASE("destruction of a bulk_write will destroy mongoc operation", "[bulk_write]") {
diff --git a/src/mongocxx/test/client.cpp b/src/mongocxx/test/client.cpp
@@ -123,17 +123,15 @@ TEST_CASE("A client's read preferences may be set and obtained", "[client]") {
     auto deleter = [](mongoc_read_prefs_t* var) { mongoc_read_prefs_destroy(var); };
     std::unique_ptr<mongoc_read_prefs_t, decltype(deleter)> saved_preference(nullptr, deleter);
 
-    client_set_preference->interpose([&](mongoc_client_t*,
-                                         const mongoc_read_prefs_t* read_prefs) {
+    client_set_preference->interpose([&](mongoc_client_t*, const mongoc_read_prefs_t* read_prefs) {
         called_set = true;
         saved_preference.reset(mongoc_read_prefs_copy(read_prefs));
         REQUIRE(mongoc_read_prefs_get_mode(read_prefs) ==
                 static_cast<mongoc_read_mode_t>(read_preference::read_mode::k_secondary_preferred));
     });
 
-    client_get_preference->interpose([&](const mongoc_client_t*) {
-        return saved_preference.get();
-    }).forever();
+    client_get_preference->interpose([&](const mongoc_client_t*) { return saved_preference.get(); })
+        .forever();
 
     mongo_client.read_preference(std::move(preference));
     REQUIRE(called_set);
@@ -152,11 +150,10 @@ TEST_CASE("A client's write concern may be set and obtained", "[client]") {
     mongoc_write_concern_t* underlying_wc;
 
     bool set_called = false;
-    client_set_concern->interpose(
-        [&](mongoc_client_t*, const mongoc_write_concern_t* concern) {
-            set_called = true;
-            underlying_wc = mongoc_write_concern_copy(concern);
-        });
+    client_set_concern->interpose([&](mongoc_client_t*, const mongoc_write_concern_t* concern) {
+        set_called = true;
+        underlying_wc = mongoc_write_concern_copy(concern);
+    });
 
     bool get_called = false;
     client_get_concern->interpose([&](const mongoc_client_t*) {
diff --git a/src/mongocxx/test/collection.cpp b/src/mongocxx/test/collection.cpp
@@ -527,7 +527,7 @@ TEST_CASE("CRUD functionality", "[driver::collection]") {
         auto distinct_cname = "distinct_coll";
         auto distinct_coll = db[distinct_cname];
         distinct_coll.drop();
-        
+
         auto doc1 = document{} << "foo"
                                << "baz"
                                << "garply" << 1 << finalize;
diff --git a/src/mongocxx/test/collection_mocked.cpp b/src/mongocxx/test/collection_mocked.cpp
diff --git a/src/mongocxx/test/private/write_concern.cpp b/src/mongocxx/test/private/write_concern.cpp
diff --git a/src/mongocxx/write_concern.cpp b/src/mongocxx/write_concern.cpp

Original file line number	Diff line number	Diff line change
`@@ -90,6 +90,6 @@ int main(int, char**) {`
`90`	`90`	`};`
`91`	`91`
`92`	`92`	`// Make all variables used.`
`93`		`- return (awards && first_award_year && second_award_year && last_name) ?`
`94`		`- EXIT_SUCCESS : EXIT_FAILURE;`
	`93`	`+ return (awards && first_award_year && second_award_year && last_name) ? EXIT_SUCCESS`
	`94`	`+ : EXIT_FAILURE;`
`95`	`95`	`}`
Original file line number	Diff line number	Diff line change
`@@ -93,8 +93,9 @@ int main(int, char**) {`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`std::cout << "Upserted IDs" << std::endl;`
`96`		`- for (const auto &id : result->upserted_ids()) {`
`97`		`- std::cout << "Bulk write index: " << id.first << std::endl << bsoncxx::to_json(id.second) << std::endl;`
	`96`	`+ for (const auto& id : result->upserted_ids()) {`
	`97`	`+ std::cout << "Bulk write index: " << id.first << std::endl`
	`98`	`+ << bsoncxx::to_json(id.second) << std::endl;`
`98`	`99`	`}`
`99`	`100`
`100`	`101`	`// The collection should contain two copies of {"a": 2}.`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ bson_iter_t to_bson_iter_t(element e) {`
`35`	`35`	`i.next_off = e.offset();`
`36`	`36`	`return i;`
`37`	`37`	`}`
`38`		`-} // namespace`
	`38`	`+} // namespace`
`39`	`39`
`40`	`40`	`view::iterator::iterator() {`
`41`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,6 @@ TEST_CASE("[] can reach into nested arrays", "[bsoncxx]") {`
`49`	`49`	`REQUIRE(!doc["ints"][2][9]);`
`50`	`50`	`REQUIRE(!doc["bools"][9]);`
`51`	`51`	`}`
`52`		`-`
`53`	`52`	`}`
`54`	`53`
`55`	`54`	`TEST_CASE("[] can reach into nested documents", "[bsoncxx]") {`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,9 @@`
`22`	`22`	`namespace mongocxx {`
`23`	`23`	`MONGOCXX_INLINE_NAMESPACE_BEGIN`
`24`	`24`
`25`		`-operation_exception::operation_exception(std::error_code ec, bsoncxx::document::value&& raw_server_error, std::string what_arg)`
	`25`	`+operation_exception::operation_exception(std::error_code ec,`
	`26`	`+ bsoncxx::document::value&& raw_server_error,`
	`27`	`+ std::string what_arg)`
`26`	`28`	`: exception(ec, what_arg), _raw_server_error{std::move(raw_server_error)} {`
`27`	`29`	`}`
`28`	`30`