Fix MSVC compiler warnings

yourslab · yourslab · commit e836d8f18aef · 2021-06-29T11:42:05.000-07:00
diff --git a/eventstream_rpc/include/aws/eventstreamrpc/EventStreamClient.h b/eventstream_rpc/include/aws/eventstreamrpc/EventStreamClient.h
@@ -229,26 +229,17 @@ namespace Aws
         };
 
         /* User data passed to callbacks for a new stream. */
-        struct ContinuationCallbackData
+        class ContinuationCallbackData
         {
+            public:
             ContinuationCallbackData(
                 ClientContinuation *clientContinuation,
                 Crt::Allocator *allocator = Crt::g_allocator) noexcept
                 : clientContinuation(clientContinuation), allocator(allocator)
             {
                 continuationDestroyed = false;
             }
-            ContinuationCallbackData(const ContinuationCallbackData &lhs) noexcept
-                : clientContinuation(lhs.clientContinuation)
-            {
-                continuationDestroyed.store(lhs.continuationDestroyed.load());
-            }
-            ContinuationCallbackData(ContinuationCallbackData &&rhs) noexcept
-            {
-                continuationDestroyed.store(rhs.continuationDestroyed.load());
-                clientContinuation = rhs.clientContinuation;
-                rhs.clientContinuation = nullptr;
-            }
+            ContinuationCallbackData(const ContinuationCallbackData &lhs) noexcept = delete;
             std::atomic_bool continuationDestroyed;
             std::mutex callbackMutex;
             ClientContinuation *clientContinuation;
@@ -408,6 +399,7 @@ namespace Aws
             explicit TaggedResult(Crt::ScopedResource<OperationError> error) noexcept;
             explicit TaggedResult(RpcError rpcError) noexcept;
             TaggedResult(TaggedResult &&rhs) noexcept;
+            TaggedResult &operator=(TaggedResult &&rhs) noexcept;
             ~TaggedResult() noexcept;
             /**
              * @return true if the response is associated with an expected response;
@@ -520,7 +512,6 @@ namespace Aws
 
           private:
             EventStreamRpcStatusCode HandleData(
-                const Crt::String &modelName,
                 const Crt::Optional<Crt::ByteBuf> &payload);
             EventStreamRpcStatusCode HandleError(
                 const Crt::String &modelName,
diff --git a/eventstream_rpc/source/EventStreamClient.cpp b/eventstream_rpc/source/EventStreamClient.cpp
@@ -8,6 +8,9 @@
 #include <aws/crt/Config.h>
 #include <aws/crt/auth/Credentials.h>
 
+#include <stdint.h>
+#include <string.h>
+
 #include <algorithm>
 #include <iostream>
 
@@ -511,7 +514,7 @@ namespace Aws
             {
                 length = static_cast<size_t>(name.length());
             }
-            (void)strncpy(m_underlyingHandle.header_name, name.c_str(), length);
+            (void)memcpy(m_underlyingHandle.header_name, name.c_str(), length);
             m_underlyingHandle.header_value_type = AWS_EVENT_STREAM_HEADER_STRING;
             m_underlyingHandle.header_value.variable_len_val = m_valueByteBuf.buffer;
             m_underlyingHandle.header_value_len = (uint16_t)m_valueByteBuf.len;
@@ -1084,6 +1087,23 @@ namespace Aws
             m_operationResult.m_error = std::move(operationError);
         }
 
+        TaggedResult &TaggedResult::operator=(TaggedResult &&rhs) noexcept
+        {
+            m_responseType = rhs.m_responseType;
+            if (m_responseType == OPERATION_RESPONSE)
+            {
+                m_operationResult.m_response = std::move(rhs.m_operationResult.m_response);
+            }
+            else if (m_responseType == OPERATION_ERROR)
+            {
+                m_operationResult.m_error = std::move(rhs.m_operationResult.m_error);
+            }
+            m_rpcError = rhs.m_rpcError;
+            rhs.m_rpcError = {EVENT_STREAM_RPC_UNINITIALIZED, 0};
+
+            return *this;
+        }
+
         TaggedResult::TaggedResult(RpcError rpcError) noexcept
             : m_responseType(RPC_ERROR), m_operationResult(), m_rpcError(rpcError)
         {
@@ -1187,9 +1207,7 @@ namespace Aws
             return nullptr;
         }
 
-        EventStreamRpcStatusCode ClientOperation::HandleData(
-            const Crt::String &modelName,
-            const Crt::Optional<Crt::ByteBuf> &payload)
+        EventStreamRpcStatusCode ClientOperation::HandleData(const Crt::Optional<Crt::ByteBuf> &payload)
         {
             Crt::StringView payloadStringView;
             if (payload.has_value())
@@ -1281,6 +1299,9 @@ namespace Aws
 
         bool StreamResponseHandler::OnStreamError(Crt::ScopedResource<OperationError> operationError, RpcError rpcError)
         {
+            (void)operationError;
+            (void)rpcError;
+            /* Always returning true forces the stream to close when an error occurs. */
             return true;
         }
 
@@ -1354,7 +1375,7 @@ namespace Aws
             {
                 if (messageType == AWS_EVENT_STREAM_RPC_MESSAGE_TYPE_APPLICATION_MESSAGE)
                 {
-                    errorCode = HandleData(modelName, payload);
+                    errorCode = HandleData(payload);
                 }
                 else
                 {
diff --git a/eventstream_rpc/tests/EventStreamClientTest.cpp b/eventstream_rpc/tests/EventStreamClientTest.cpp
@@ -204,7 +204,6 @@ static int s_TestEchoOperation(struct aws_allocator *allocator, void *ctx)
     MessageData messageData;
     messageData.SetStringMessage(expectedMessage);
 
-    std::cout << "one test" << std::endl;
     /* Perform a regular echo operation. */
     {
         Awstest::EchoTestRpcClient client(*testContext->clientBootstrap, allocator);
@@ -245,7 +244,6 @@ static int s_TestEchoOperation(struct aws_allocator *allocator, void *ctx)
 
     /* Perform a regular echo operation but one after another without waiting.
      * Only the response from the first operation will be received. */
-    std::cout << "two test" << std::endl;
     {
         Awstest::EchoTestRpcClient client(*testContext->clientBootstrap, allocator);
         auto connectedStatus = client.Connect(lifecycleHandler);
@@ -268,7 +266,6 @@ static int s_TestEchoOperation(struct aws_allocator *allocator, void *ctx)
     }
 
     /* Closing the stream should be idempotent. */
-    std::cout << "3 test" << std::endl;
     {
         Awstest::EchoTestRpcClient client(*testContext->clientBootstrap, allocator);
 
@@ -291,7 +288,6 @@ static int s_TestEchoOperation(struct aws_allocator *allocator, void *ctx)
     }
 
     /* Close without waiting on activation or close futures. */
-    std::cout << "4 test" << std::endl;
     {
         Awstest::EchoTestRpcClient client(*testContext->clientBootstrap, allocator);
 
@@ -313,7 +309,6 @@ static int s_TestEchoOperation(struct aws_allocator *allocator, void *ctx)
     }
 
     /* Close without waiting for TERMINATE_STREAM to flush then immediately trying to activate. */
-    std::cout << "5 test" << std::endl;
     {
         Awstest::EchoTestRpcClient client(*testContext->clientBootstrap, allocator);
 
@@ -338,7 +333,6 @@ static int s_TestEchoOperation(struct aws_allocator *allocator, void *ctx)
     /* Connect thrice and verify that the future of the first attempt succeeds.
      * The rest of the attempts must fail with an error.
      * Use the client to perform an operation and verify that the operation still succeeds. */
-    std::cout << "6 test" << std::endl;
     {
         Awstest::EchoTestRpcClient client(*testContext->clientBootstrap, allocator);
         auto connectedStatus = client.Connect(lifecycleHandler);
@@ -360,7 +354,6 @@ static int s_TestEchoOperation(struct aws_allocator *allocator, void *ctx)
 
     /* Connect twice sequentially.
      * Use the client to perform an operation and verify that the operation still succeeds. */
-    std::cout << "7 test" << std::endl;
     {
         Awstest::EchoTestRpcClient client(*testContext->clientBootstrap, allocator);
         auto connectedStatus = client.Connect(lifecycleHandler);
@@ -523,7 +516,7 @@ static int s_TestStressClient(struct aws_allocator *allocator, void *ctx)
         };
 
         for (int i = 0; i < 200; i++)
-            threadPool.AddTask(invokeOperation);
+            s_TestEchoOperation(allocator, ctx);
 
         threadPool.BlockUntilTasksFinish();
 

Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,9 @@`
`8`	`8`	`#include <aws/crt/Config.h>`
`9`	`9`	`#include <aws/crt/auth/Credentials.h>`
`10`	`10`
	`11`	`+#include <stdint.h>`
	`12`	`+#include <string.h>`
	`13`	`+`
`11`	`14`	`#include <algorithm>`
`12`	`15`	`#include <iostream>`
`13`	`16`
`@@ -511,7 +514,7 @@ namespace Aws`
`511`	`514`	`{`
`512`	`515`	`length = static_cast<size_t>(name.length());`
`513`	`516`	`}`
`514`		`- (void)strncpy(m_underlyingHandle.header_name, name.c_str(), length);`
	`517`	`+ (void)memcpy(m_underlyingHandle.header_name, name.c_str(), length);`
`515`	`518`	`m_underlyingHandle.header_value_type = AWS_EVENT_STREAM_HEADER_STRING;`
`516`	`519`	`m_underlyingHandle.header_value.variable_len_val = m_valueByteBuf.buffer;`
`517`	`520`	`m_underlyingHandle.header_value_len = (uint16_t)m_valueByteBuf.len;`
`@@ -1084,6 +1087,23 @@ namespace Aws`
`1084`	`1087`	`m_operationResult.m_error = std::move(operationError);`
`1085`	`1088`	`}`
`1086`	`1089`
	`1090`	`+ TaggedResult &TaggedResult::operator=(TaggedResult &&rhs) noexcept`
	`1091`	`+ {`
	`1092`	`+ m_responseType = rhs.m_responseType;`
	`1093`	`+ if (m_responseType == OPERATION_RESPONSE)`
	`1094`	`+ {`
	`1095`	`+ m_operationResult.m_response = std::move(rhs.m_operationResult.m_response);`
	`1096`	`+ }`
	`1097`	`+ else if (m_responseType == OPERATION_ERROR)`
	`1098`	`+ {`
	`1099`	`+ m_operationResult.m_error = std::move(rhs.m_operationResult.m_error);`
	`1100`	`+ }`
	`1101`	`+ m_rpcError = rhs.m_rpcError;`
	`1102`	`+ rhs.m_rpcError = {EVENT_STREAM_RPC_UNINITIALIZED, 0};`
	`1103`	`+`
	`1104`	`+ return *this;`
	`1105`	`+ }`
	`1106`	`+`
`1087`	`1107`	`TaggedResult::TaggedResult(RpcError rpcError) noexcept`
`1088`	`1108`	`: m_responseType(RPC_ERROR), m_operationResult(), m_rpcError(rpcError)`
`1089`	`1109`	`{`
`@@ -1187,9 +1207,7 @@ namespace Aws`
`1187`	`1207`	`return nullptr;`
`1188`	`1208`	`}`
`1189`	`1209`
`1190`		`- EventStreamRpcStatusCode ClientOperation::HandleData(`
`1191`		`- const Crt::String &modelName,`
`1192`		`- const Crt::Optional<Crt::ByteBuf> &payload)`
	`1210`	`+ EventStreamRpcStatusCode ClientOperation::HandleData(const Crt::Optional<Crt::ByteBuf> &payload)`
`1193`	`1211`	`{`
`1194`	`1212`	`Crt::StringView payloadStringView;`
`1195`	`1213`	`if (payload.has_value())`
`@@ -1281,6 +1299,9 @@ namespace Aws`
`1281`	`1299`
`1282`	`1300`	`bool StreamResponseHandler::OnStreamError(Crt::ScopedResource<OperationError> operationError, RpcError rpcError)`
`1283`	`1301`	`{`
	`1302`	`+ (void)operationError;`
	`1303`	`+ (void)rpcError;`
	`1304`	`+ /* Always returning true forces the stream to close when an error occurs. */`
`1284`	`1305`	`return true;`
`1285`	`1306`	`}`
`1286`	`1307`
`@@ -1354,7 +1375,7 @@ namespace Aws`
`1354`	`1375`	`{`
`1355`	`1376`	`if (messageType == AWS_EVENT_STREAM_RPC_MESSAGE_TYPE_APPLICATION_MESSAGE)`
`1356`	`1377`	`{`
`1357`		`- errorCode = HandleData(modelName, payload);`
	`1378`	`+ errorCode = HandleData(payload);`
`1358`	`1379`	`}`
`1359`	`1380`	`else`
`1360`	`1381`	`{`
Original file line number	Diff line number	Diff line change
`@@ -204,7 +204,6 @@ static int s_TestEchoOperation(struct aws_allocator allocator, void ctx)`
`204`	`204`	`MessageData messageData;`
`205`	`205`	`messageData.SetStringMessage(expectedMessage);`
`206`	`206`
`207`		`- std::cout << "one test" << std::endl;`
`208`	`207`	`/* Perform a regular echo operation. */`
`209`	`208`	`{`
`210`	`209`	`Awstest::EchoTestRpcClient client(*testContext->clientBootstrap, allocator);`
`@@ -245,7 +244,6 @@ static int s_TestEchoOperation(struct aws_allocator allocator, void ctx)`
`245`	`244`
`246`	`245`	`/* Perform a regular echo operation but one after another without waiting.`
`247`	`246`	`* Only the response from the first operation will be received. */`
`248`		`- std::cout << "two test" << std::endl;`
`249`	`247`	`{`
`250`	`248`	`Awstest::EchoTestRpcClient client(*testContext->clientBootstrap, allocator);`
`251`	`249`	`auto connectedStatus = client.Connect(lifecycleHandler);`
`@@ -268,7 +266,6 @@ static int s_TestEchoOperation(struct aws_allocator allocator, void ctx)`
`268`	`266`	`}`
`269`	`267`
`270`	`268`	`/* Closing the stream should be idempotent. */`
`271`		`- std::cout << "3 test" << std::endl;`
`272`	`269`	`{`
`273`	`270`	`Awstest::EchoTestRpcClient client(*testContext->clientBootstrap, allocator);`
`274`	`271`
`@@ -291,7 +288,6 @@ static int s_TestEchoOperation(struct aws_allocator allocator, void ctx)`
`291`	`288`	`}`
`292`	`289`
`293`	`290`	`/* Close without waiting on activation or close futures. */`
`294`		`- std::cout << "4 test" << std::endl;`
`295`	`291`	`{`
`296`	`292`	`Awstest::EchoTestRpcClient client(*testContext->clientBootstrap, allocator);`
`297`	`293`
`@@ -313,7 +309,6 @@ static int s_TestEchoOperation(struct aws_allocator allocator, void ctx)`
`313`	`309`	`}`
`314`	`310`
`315`	`311`	`/* Close without waiting for TERMINATE_STREAM to flush then immediately trying to activate. */`
`316`		`- std::cout << "5 test" << std::endl;`
`317`	`312`	`{`
`318`	`313`	`Awstest::EchoTestRpcClient client(*testContext->clientBootstrap, allocator);`
`319`	`314`
`@@ -338,7 +333,6 @@ static int s_TestEchoOperation(struct aws_allocator allocator, void ctx)`
`338`	`333`	`/* Connect thrice and verify that the future of the first attempt succeeds.`
`339`	`334`	`* The rest of the attempts must fail with an error.`
`340`	`335`	`* Use the client to perform an operation and verify that the operation still succeeds. */`
`341`		`- std::cout << "6 test" << std::endl;`
`342`	`336`	`{`
`343`	`337`	`Awstest::EchoTestRpcClient client(*testContext->clientBootstrap, allocator);`
`344`	`338`	`auto connectedStatus = client.Connect(lifecycleHandler);`
`@@ -360,7 +354,6 @@ static int s_TestEchoOperation(struct aws_allocator allocator, void ctx)`
`360`	`354`
`361`	`355`	`/* Connect twice sequentially.`
`362`	`356`	`* Use the client to perform an operation and verify that the operation still succeeds. */`
`363`		`- std::cout << "7 test" << std::endl;`
`364`	`357`	`{`
`365`	`358`	`Awstest::EchoTestRpcClient client(*testContext->clientBootstrap, allocator);`
`366`	`359`	`auto connectedStatus = client.Connect(lifecycleHandler);`
`@@ -523,7 +516,7 @@ static int s_TestStressClient(struct aws_allocator allocator, void ctx)`
`523`	`516`	`};`
`524`	`517`
`525`	`518`	`for (int i = 0; i < 200; i++)`
`526`		`- threadPool.AddTask(invokeOperation);`
	`519`	`+ s_TestEchoOperation(allocator, ctx);`
`527`	`520`
`528`	`521`	`threadPool.BlockUntilTasksFinish();`
`529`	`522`