CDRIVER-366: delete is a reserved keyword in C++

Author: bjori

src/mongoc/mongoc-bulk-operation.c

@@ -127,7 +127,7 @@ mongoc_bulk_operation_remove (mongoc_bulk_operation_t *bulk,     /* IN */
                                    mongoc_write_command_t,
                                    bulk->commands.len - 1);
       if ((last->type == MONGOC_WRITE_COMMAND_DELETE) &&
-          last->u.delete.multi) {
+          last->u.delete_.multi) {
          _mongoc_write_command_delete_append (last, selector);
          EXIT;
       }
@@ -158,7 +158,7 @@ mongoc_bulk_operation_remove_one (mongoc_bulk_operation_t *bulk,     /* IN */
                                    mongoc_write_command_t,
                                    bulk->commands.len - 1);
       if ((last->type == MONGOC_WRITE_COMMAND_DELETE) &&
-          !last->u.delete.multi) {
+          !last->u.delete_.multi) {
          _mongoc_write_command_delete_append (last, selector);
          EXIT;
       }

src/mongoc/mongoc-cluster.c

@@ -2210,7 +2210,7 @@ mongoc_cluster_sendv_to_server (mongoc_cluster_t              *cluster,
             DB_AND_CMD_FROM_COLLECTION(cmdname, rpcs[i].insert.collection);
             break;
          case MONGOC_OPCODE_DELETE:
-            DB_AND_CMD_FROM_COLLECTION(cmdname, rpcs[i].delete.collection);
+            DB_AND_CMD_FROM_COLLECTION(cmdname, rpcs[i].delete_.collection);
             break;
          case MONGOC_OPCODE_UPDATE:
             DB_AND_CMD_FROM_COLLECTION(cmdname, rpcs[i].update.collection);

src/mongoc/mongoc-rpc-private.h

@@ -58,7 +58,7 @@ BSON_BEGIN_DECLS
 
 typedef union
 {
-   mongoc_rpc_delete_t       delete;
+   mongoc_rpc_delete_t       delete_;
    mongoc_rpc_get_more_t     get_more;
    mongoc_rpc_header_t       header;
    mongoc_rpc_insert_t       insert;

src/mongoc/mongoc-rpc.c

@@ -463,7 +463,7 @@ _mongoc_rpc_gather (mongoc_rpc_t   *rpc,
       _mongoc_rpc_gather_get_more(&rpc->get_more, array);
       return;
    case MONGOC_OPCODE_DELETE:
-      _mongoc_rpc_gather_delete(&rpc->delete, array);
+      _mongoc_rpc_gather_delete(&rpc->delete_, array);
       return;
    case MONGOC_OPCODE_KILL_CURSORS:
       _mongoc_rpc_gather_kill_cursors(&rpc->kill_cursors, array);
@@ -505,7 +505,7 @@ _mongoc_rpc_swab_to_le (mongoc_rpc_t *rpc)
       _mongoc_rpc_swab_to_le_get_more(&rpc->get_more);
       break;
    case MONGOC_OPCODE_DELETE:
-      _mongoc_rpc_swab_to_le_delete(&rpc->delete);
+      _mongoc_rpc_swab_to_le_delete(&rpc->delete_);
       break;
    case MONGOC_OPCODE_KILL_CURSORS:
       _mongoc_rpc_swab_to_le_kill_cursors(&rpc->kill_cursors);
@@ -548,7 +548,7 @@ _mongoc_rpc_swab_from_le (mongoc_rpc_t *rpc)
       _mongoc_rpc_swab_from_le_get_more(&rpc->get_more);
       break;
    case MONGOC_OPCODE_DELETE:
-      _mongoc_rpc_swab_from_le_delete(&rpc->delete);
+      _mongoc_rpc_swab_from_le_delete(&rpc->delete_);
       break;
    case MONGOC_OPCODE_KILL_CURSORS:
       _mongoc_rpc_swab_from_le_kill_cursors(&rpc->kill_cursors);
@@ -586,7 +586,7 @@ _mongoc_rpc_printf (mongoc_rpc_t *rpc)
       _mongoc_rpc_printf_get_more(&rpc->get_more);
       break;
    case MONGOC_OPCODE_DELETE:
-      _mongoc_rpc_printf_delete(&rpc->delete);
+      _mongoc_rpc_printf_delete(&rpc->delete_);
       break;
    case MONGOC_OPCODE_KILL_CURSORS:
       _mongoc_rpc_printf_kill_cursors(&rpc->kill_cursors);
@@ -635,7 +635,7 @@ _mongoc_rpc_scatter (mongoc_rpc_t  *rpc,
    case MONGOC_OPCODE_GET_MORE:
       return _mongoc_rpc_scatter_get_more(&rpc->get_more, buf, buflen);
    case MONGOC_OPCODE_DELETE:
-      return _mongoc_rpc_scatter_delete(&rpc->delete, buf, buflen);
+      return _mongoc_rpc_scatter_delete(&rpc->delete_, buf, buflen);
    case MONGOC_OPCODE_KILL_CURSORS:
       return _mongoc_rpc_scatter_kill_cursors(&rpc->kill_cursors, buf, buflen);
    default:

src/mongoc/mongoc-write-command-private.h

@@ -45,7 +45,7 @@ typedef struct
    union {
       struct {
          bool multi;
-      } delete;
+      } delete_;
       struct {
          bool allow_bulk_op_insert;
       } insert;

src/mongoc/mongoc-write-command.c

@@ -158,7 +158,7 @@ _mongoc_write_command_delete_append (mongoc_write_command_t *command,
 
    bson_init (&doc);
    BSON_APPEND_DOCUMENT (&doc, "q", selector);
-   BSON_APPEND_INT32 (&doc, "limit", command->u.delete.multi ? 0 : 1);
+   BSON_APPEND_INT32 (&doc, "limit", command->u.delete_.multi ? 0 : 1);
 
    key = NULL;
    bson_uint32_to_string (command->n_documents, &key, keydata, sizeof keydata);
@@ -211,7 +211,7 @@ _mongoc_write_command_init_delete (mongoc_write_command_t *command,  /* IN */
    command->type = MONGOC_WRITE_COMMAND_DELETE;
    command->documents = bson_new ();
    command->n_documents = 0;
-   command->u.delete.multi = (uint8_t)multi;
+   command->u.delete_.multi = (uint8_t)multi;
    command->ordered = (uint8_t)ordered;
 
    _mongoc_write_command_delete_append (command, selector);
@@ -306,15 +306,15 @@ _mongoc_write_command_delete_legacy (mongoc_write_command_t       *command,
       BSON_ASSERT (data);
       BSON_ASSERT (len >= 5);
 
-      rpc.delete.msg_len = 0;
-      rpc.delete.request_id = 0;
-      rpc.delete.response_to = 0;
-      rpc.delete.opcode = MONGOC_OPCODE_DELETE;
-      rpc.delete.zero = 0;
-      rpc.delete.collection = ns;
-      rpc.delete.flags = command->u.delete.multi ? MONGOC_DELETE_NONE
+      rpc.delete_.msg_len = 0;
+      rpc.delete_.request_id = 0;
+      rpc.delete_.response_to = 0;
+      rpc.delete_.opcode = MONGOC_OPCODE_DELETE;
+      rpc.delete_.zero = 0;
+      rpc.delete_.collection = ns;
+      rpc.delete_.flags = command->u.delete_.multi ? MONGOC_DELETE_NONE
                          : MONGOC_DELETE_SINGLE_REMOVE;
-      rpc.delete.selector = data;
+      rpc.delete_.selector = data;
 
       hint = _mongoc_client_sendv (client, &rpc, 1, hint, write_concern,
                                    NULL, error);

tests/test-mongoc-rpc.c

@@ -110,14 +110,14 @@ test_mongoc_rpc_delete_gather (void)
 
    bson_init(&sel);
 
-   rpc.delete.msg_len = 0;
-   rpc.delete.request_id = 1234;
-   rpc.delete.response_to = -1;
-   rpc.delete.opcode = MONGOC_OPCODE_DELETE;
-   rpc.delete.zero = 0;
-   rpc.delete.collection = "test.test";
-   rpc.delete.flags = MONGOC_DELETE_SINGLE_REMOVE;
-   rpc.delete.selector = bson_get_data(&sel);
+   rpc.delete_.msg_len = 0;
+   rpc.delete_.request_id = 1234;
+   rpc.delete_.response_to = -1;
+   rpc.delete_.opcode = MONGOC_OPCODE_DELETE;
+   rpc.delete_.zero = 0;
+   rpc.delete_.collection = "test.test";
+   rpc.delete_.flags = MONGOC_DELETE_SINGLE_REMOVE;
+   rpc.delete_.selector = bson_get_data(&sel);
 
    assert_rpc_equal("delete1.dat", &rpc);
 }
@@ -141,14 +141,14 @@ test_mongoc_rpc_delete_scatter (void)
    ASSERT(r);
    _mongoc_rpc_swab_from_le(&rpc);
 
-   ASSERT_CMPINT(rpc.delete.msg_len, ==, 39);
-   ASSERT_CMPINT(rpc.delete.request_id, ==, 1234);
-   ASSERT_CMPINT(rpc.delete.response_to, ==, -1);
-   ASSERT_CMPINT(rpc.delete.opcode, ==, MONGOC_OPCODE_DELETE);
-   ASSERT_CMPINT(rpc.delete.zero, ==, 0);
-   ASSERT(!strcmp("test.test", rpc.delete.collection));
-   ASSERT_CMPINT(rpc.delete.flags, ==, MONGOC_DELETE_SINGLE_REMOVE);
-   ASSERT(!memcmp(rpc.delete.selector, bson_get_data(&sel), sel.len));
+   ASSERT_CMPINT(rpc.delete_.msg_len, ==, 39);
+   ASSERT_CMPINT(rpc.delete_.request_id, ==, 1234);
+   ASSERT_CMPINT(rpc.delete_.response_to, ==, -1);
+   ASSERT_CMPINT(rpc.delete_.opcode, ==, MONGOC_OPCODE_DELETE);
+   ASSERT_CMPINT(rpc.delete_.zero, ==, 0);
+   ASSERT(!strcmp("test.test", rpc.delete_.collection));
+   ASSERT_CMPINT(rpc.delete_.flags, ==, MONGOC_DELETE_SINGLE_REMOVE);
+   ASSERT(!memcmp(rpc.delete_.selector, bson_get_data(&sel), sel.len));
 
    assert_rpc_equal("delete1.dat", &rpc);
    bson_free(data);