✨feat(hos_client_create, hos_client_destory): 多次调用destory不会导致重复释放

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesis-video-signaling/source/KinesisVideoSignalingChannelsClient.cpp

@@ -0,0 +1,152 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/core/utils/Outcome.h>
+#include <aws/core/auth/AWSAuthSigner.h>
+#include <aws/core/client/CoreErrors.h>
+#include <aws/core/client/RetryStrategy.h>
+#include <aws/core/http/HttpClient.h>
+#include <aws/core/http/HttpResponse.h>
+#include <aws/core/http/HttpClientFactory.h>
+#include <aws/core/auth/AWSCredentialsProviderChain.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+#include <aws/core/utils/threading/Executor.h>
+#include <aws/core/utils/DNS.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <aws/kinesis-video-signaling/KinesisVideoSignalingChannelsClient.h>
+#include <aws/kinesis-video-signaling/KinesisVideoSignalingChannelsEndpoint.h>
+#include <aws/kinesis-video-signaling/KinesisVideoSignalingChannelsErrorMarshaller.h>
+#include <aws/kinesis-video-signaling/model/GetIceServerConfigRequest.h>
+#include <aws/kinesis-video-signaling/model/SendAlexaOfferToMasterRequest.h>
+
+using namespace Aws;
+using namespace Aws::Auth;
+using namespace Aws::Client;
+using namespace Aws::KinesisVideoSignalingChannels;
+using namespace Aws::KinesisVideoSignalingChannels::Model;
+using namespace Aws::Http;
+using namespace Aws::Utils::Json;
+
+static const char* SERVICE_NAME = "kinesisvideo";
+static const char* ALLOCATION_TAG = "KinesisVideoSignalingChannelsClient";
+
+
+KinesisVideoSignalingChannelsClient::KinesisVideoSignalingChannelsClient(const Client::ClientConfiguration& clientConfiguration) :
+  BASECLASS(clientConfiguration,
+    Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG),
+        SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
+    Aws::MakeShared<KinesisVideoSignalingChannelsErrorMarshaller>(ALLOCATION_TAG)),
+    m_executor(clientConfiguration.executor)
+{
+  init(clientConfiguration);
+}
+
+KinesisVideoSignalingChannelsClient::KinesisVideoSignalingChannelsClient(const AWSCredentials& credentials, const Client::ClientConfiguration& clientConfiguration) :
+  BASECLASS(clientConfiguration,
+    Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<SimpleAWSCredentialsProvider>(ALLOCATION_TAG, credentials),
+         SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
+    Aws::MakeShared<KinesisVideoSignalingChannelsErrorMarshaller>(ALLOCATION_TAG)),
+    m_executor(clientConfiguration.executor)
+{
+  init(clientConfiguration);
+}
+
+KinesisVideoSignalingChannelsClient::KinesisVideoSignalingChannelsClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
+  const Client::ClientConfiguration& clientConfiguration) :
+  BASECLASS(clientConfiguration,
+    Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, credentialsProvider,
+         SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
+    Aws::MakeShared<KinesisVideoSignalingChannelsErrorMarshaller>(ALLOCATION_TAG)),
+    m_executor(clientConfiguration.executor)
+{
+  init(clientConfiguration);
+}
+
+KinesisVideoSignalingChannelsClient::~KinesisVideoSignalingChannelsClient()
+{
+}
+
+void KinesisVideoSignalingChannelsClient::init(const ClientConfiguration& config)
+{
+  SetServiceClientName("Kinesis Video Signaling");
+  m_configScheme = SchemeMapper::ToString(config.scheme);
+  if (config.endpointOverride.empty())
+  {
+      m_uri = m_configScheme + "://" + KinesisVideoSignalingChannelsEndpoint::ForRegion(config.region, config.useDualStack);
+  }
+  else
+  {
+      OverrideEndpoint(config.endpointOverride);
+  }
+}
+
+void KinesisVideoSignalingChannelsClient::OverrideEndpoint(const Aws::String& endpoint)
+{
+  if (endpoint.compare(0, 7, "http://") == 0 || endpoint.compare(0, 8, "https://") == 0)
+  {
+      m_uri = endpoint;
+  }
+  else
+  {
+      m_uri = m_configScheme + "://" + endpoint;
+  }
+}
+
+GetIceServerConfigOutcome KinesisVideoSignalingChannelsClient::GetIceServerConfig(const GetIceServerConfigRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/v1/get-ice-server-config";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return GetIceServerConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+GetIceServerConfigOutcomeCallable KinesisVideoSignalingChannelsClient::GetIceServerConfigCallable(const GetIceServerConfigRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< GetIceServerConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetIceServerConfig(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void KinesisVideoSignalingChannelsClient::GetIceServerConfigAsync(const GetIceServerConfigRequest& request, const GetIceServerConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->GetIceServerConfigAsyncHelper( request, handler, context ); } );
+}
+
+void KinesisVideoSignalingChannelsClient::GetIceServerConfigAsyncHelper(const GetIceServerConfigRequest& request, const GetIceServerConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, GetIceServerConfig(request), context);
+}
+
+SendAlexaOfferToMasterOutcome KinesisVideoSignalingChannelsClient::SendAlexaOfferToMaster(const SendAlexaOfferToMasterRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/v1/send-alexa-offer-to-master";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return SendAlexaOfferToMasterOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+SendAlexaOfferToMasterOutcomeCallable KinesisVideoSignalingChannelsClient::SendAlexaOfferToMasterCallable(const SendAlexaOfferToMasterRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< SendAlexaOfferToMasterOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->SendAlexaOfferToMaster(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void KinesisVideoSignalingChannelsClient::SendAlexaOfferToMasterAsync(const SendAlexaOfferToMasterRequest& request, const SendAlexaOfferToMasterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->SendAlexaOfferToMasterAsyncHelper( request, handler, context ); } );
+}
+
+void KinesisVideoSignalingChannelsClient::SendAlexaOfferToMasterAsyncHelper(const SendAlexaOfferToMasterRequest& request, const SendAlexaOfferToMasterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, SendAlexaOfferToMaster(request), context);
+}
+

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesis-video-signaling/source/KinesisVideoSignalingChannelsEndpoint.cpp

@@ -0,0 +1,64 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/kinesis-video-signaling/KinesisVideoSignalingChannelsEndpoint.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+#include <aws/core/utils/HashingUtils.h>
+
+using namespace Aws;
+using namespace Aws::KinesisVideoSignalingChannels;
+
+namespace Aws
+{
+namespace KinesisVideoSignalingChannels
+{
+namespace KinesisVideoSignalingChannelsEndpoint
+{
+  static const int CN_NORTH_1_HASH = Aws::Utils::HashingUtils::HashString("cn-north-1");
+  static const int CN_NORTHWEST_1_HASH = Aws::Utils::HashingUtils::HashString("cn-northwest-1");
+  static const int US_ISO_EAST_1_HASH = Aws::Utils::HashingUtils::HashString("us-iso-east-1");
+  static const int US_ISOB_EAST_1_HASH = Aws::Utils::HashingUtils::HashString("us-isob-east-1");
+
+
+  Aws::String ForRegion(const Aws::String& regionName, bool useDualStack)
+  {
+    // Fallback to us-east-1 if global endpoint does not exists.
+    Aws::String region = regionName == Aws::Region::AWS_GLOBAL ? Aws::Region::US_EAST_1 : regionName;
+    auto hash = Aws::Utils::HashingUtils::HashString(region.c_str());
+
+    Aws::StringStream ss;
+    ss << "kinesisvideo" << ".";
+
+    if(useDualStack)
+    {
+      ss << "dualstack.";
+    }
+
+    ss << region;
+
+    if (hash == CN_NORTH_1_HASH || hash == CN_NORTHWEST_1_HASH)
+    {
+      ss << ".amazonaws.com.cn";
+    }
+    else if (hash == US_ISO_EAST_1_HASH)
+    {
+      ss << ".c2s.ic.gov";
+    }
+    else if (hash == US_ISOB_EAST_1_HASH)
+    {
+      ss << ".sc2s.sgov.gov";
+    }
+    else
+    {
+      ss << ".amazonaws.com";
+    }
+
+    return ss.str();
+  }
+
+} // namespace KinesisVideoSignalingChannelsEndpoint
+} // namespace KinesisVideoSignalingChannels
+} // namespace Aws
+

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesis-video-signaling/source/KinesisVideoSignalingChannelsErrorMarshaller.cpp

@@ -0,0 +1,22 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/core/client/AWSError.h>
+#include <aws/kinesis-video-signaling/KinesisVideoSignalingChannelsErrorMarshaller.h>
+#include <aws/kinesis-video-signaling/KinesisVideoSignalingChannelsErrors.h>
+
+using namespace Aws::Client;
+using namespace Aws::KinesisVideoSignalingChannels;
+
+AWSError<CoreErrors> KinesisVideoSignalingChannelsErrorMarshaller::FindErrorByName(const char* errorName) const
+{
+  AWSError<CoreErrors> error = KinesisVideoSignalingChannelsErrorMapper::GetErrorForName(errorName);
+  if(error.GetErrorType() != CoreErrors::UNKNOWN)
+  {
+    return error;
+  }
+
+  return AWSErrorMarshaller::FindErrorByName(errorName);
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesis-video-signaling/source/KinesisVideoSignalingChannelsErrors.cpp

@@ -0,0 +1,57 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/core/client/AWSError.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/kinesis-video-signaling/KinesisVideoSignalingChannelsErrors.h>
+
+using namespace Aws::Client;
+using namespace Aws::Utils;
+using namespace Aws::KinesisVideoSignalingChannels;
+
+namespace Aws
+{
+namespace KinesisVideoSignalingChannels
+{
+namespace KinesisVideoSignalingChannelsErrorMapper
+{
+
+static const int SESSION_EXPIRED_HASH = HashingUtils::HashString("SessionExpiredException");
+static const int NOT_AUTHORIZED_HASH = HashingUtils::HashString("NotAuthorizedException");
+static const int INVALID_CLIENT_HASH = HashingUtils::HashString("InvalidClientException");
+static const int CLIENT_LIMIT_EXCEEDED_HASH = HashingUtils::HashString("ClientLimitExceededException");
+static const int INVALID_ARGUMENT_HASH = HashingUtils::HashString("InvalidArgumentException");
+
+
+AWSError<CoreErrors> GetErrorForName(const char* errorName)
+{
+  int hashCode = HashingUtils::HashString(errorName);
+
+  if (hashCode == SESSION_EXPIRED_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(KinesisVideoSignalingChannelsErrors::SESSION_EXPIRED), false);
+  }
+  else if (hashCode == NOT_AUTHORIZED_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(KinesisVideoSignalingChannelsErrors::NOT_AUTHORIZED), false);
+  }
+  else if (hashCode == INVALID_CLIENT_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(KinesisVideoSignalingChannelsErrors::INVALID_CLIENT), false);
+  }
+  else if (hashCode == CLIENT_LIMIT_EXCEEDED_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(KinesisVideoSignalingChannelsErrors::CLIENT_LIMIT_EXCEEDED), false);
+  }
+  else if (hashCode == INVALID_ARGUMENT_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(KinesisVideoSignalingChannelsErrors::INVALID_ARGUMENT), false);
+  }
+  return AWSError<CoreErrors>(CoreErrors::UNKNOWN, false);
+}
+
+} // namespace KinesisVideoSignalingChannelsErrorMapper
+} // namespace KinesisVideoSignalingChannels
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesis-video-signaling/source/model/GetIceServerConfigRequest.cpp

@@ -0,0 +1,56 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/kinesis-video-signaling/model/GetIceServerConfigRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::KinesisVideoSignalingChannels::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+GetIceServerConfigRequest::GetIceServerConfigRequest() : 
+    m_channelARNHasBeenSet(false),
+    m_clientIdHasBeenSet(false),
+    m_service(Service::NOT_SET),
+    m_serviceHasBeenSet(false),
+    m_usernameHasBeenSet(false)
+{
+}
+
+Aws::String GetIceServerConfigRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_channelARNHasBeenSet)
+  {
+   payload.WithString("ChannelARN", m_channelARN);
+
+  }
+
+  if(m_clientIdHasBeenSet)
+  {
+   payload.WithString("ClientId", m_clientId);
+
+  }
+
+  if(m_serviceHasBeenSet)
+  {
+   payload.WithString("Service", ServiceMapper::GetNameForService(m_service));
+  }
+
+  if(m_usernameHasBeenSet)
+  {
+   payload.WithString("Username", m_username);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesis-video-signaling/source/model/GetIceServerConfigResult.cpp

@@ -0,0 +1,43 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/kinesis-video-signaling/model/GetIceServerConfigResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::KinesisVideoSignalingChannels::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+GetIceServerConfigResult::GetIceServerConfigResult()
+{
+}
+
+GetIceServerConfigResult::GetIceServerConfigResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+GetIceServerConfigResult& GetIceServerConfigResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("IceServerList"))
+  {
+    Array<JsonView> iceServerListJsonList = jsonValue.GetArray("IceServerList");
+    for(unsigned iceServerListIndex = 0; iceServerListIndex < iceServerListJsonList.GetLength(); ++iceServerListIndex)
+    {
+      m_iceServerList.push_back(iceServerListJsonList[iceServerListIndex].AsObject());
+    }
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesis-video-signaling/source/model/IceServer.cpp

@@ -0,0 +1,114 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/kinesis-video-signaling/model/IceServer.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace KinesisVideoSignalingChannels
+{
+namespace Model
+{
+
+IceServer::IceServer() : 
+    m_urisHasBeenSet(false),
+    m_usernameHasBeenSet(false),
+    m_passwordHasBeenSet(false),
+    m_ttl(0),
+    m_ttlHasBeenSet(false)
+{
+}
+
+IceServer::IceServer(JsonView jsonValue) : 
+    m_urisHasBeenSet(false),
+    m_usernameHasBeenSet(false),
+    m_passwordHasBeenSet(false),
+    m_ttl(0),
+    m_ttlHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+IceServer& IceServer::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Uris"))
+  {
+    Array<JsonView> urisJsonList = jsonValue.GetArray("Uris");
+    for(unsigned urisIndex = 0; urisIndex < urisJsonList.GetLength(); ++urisIndex)
+    {
+      m_uris.push_back(urisJsonList[urisIndex].AsString());
+    }
+    m_urisHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Username"))
+  {
+    m_username = jsonValue.GetString("Username");
+
+    m_usernameHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Password"))
+  {
+    m_password = jsonValue.GetString("Password");
+
+    m_passwordHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Ttl"))
+  {
+    m_ttl = jsonValue.GetInteger("Ttl");
+
+    m_ttlHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue IceServer::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_urisHasBeenSet)
+  {
+   Array<JsonValue> urisJsonList(m_uris.size());
+   for(unsigned urisIndex = 0; urisIndex < urisJsonList.GetLength(); ++urisIndex)
+   {
+     urisJsonList[urisIndex].AsString(m_uris[urisIndex]);
+   }
+   payload.WithArray("Uris", std::move(urisJsonList));
+
+  }
+
+  if(m_usernameHasBeenSet)
+  {
+   payload.WithString("Username", m_username);
+
+  }
+
+  if(m_passwordHasBeenSet)
+  {
+   payload.WithString("Password", m_password);
+
+  }
+
+  if(m_ttlHasBeenSet)
+  {
+   payload.WithInteger("Ttl", m_ttl);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace KinesisVideoSignalingChannels
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesis-video-signaling/source/model/SendAlexaOfferToMasterRequest.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/kinesis-video-signaling/model/SendAlexaOfferToMasterRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::KinesisVideoSignalingChannels::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+SendAlexaOfferToMasterRequest::SendAlexaOfferToMasterRequest() : 
+    m_channelARNHasBeenSet(false),
+    m_senderClientIdHasBeenSet(false),
+    m_messagePayloadHasBeenSet(false)
+{
+}
+
+Aws::String SendAlexaOfferToMasterRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_channelARNHasBeenSet)
+  {
+   payload.WithString("ChannelARN", m_channelARN);
+
+  }
+
+  if(m_senderClientIdHasBeenSet)
+  {
+   payload.WithString("SenderClientId", m_senderClientId);
+
+  }
+
+  if(m_messagePayloadHasBeenSet)
+  {
+   payload.WithString("MessagePayload", m_messagePayload);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesis-video-signaling/source/model/SendAlexaOfferToMasterResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/kinesis-video-signaling/model/SendAlexaOfferToMasterResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::KinesisVideoSignalingChannels::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+SendAlexaOfferToMasterResult::SendAlexaOfferToMasterResult()
+{
+}
+
+SendAlexaOfferToMasterResult::SendAlexaOfferToMasterResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+SendAlexaOfferToMasterResult& SendAlexaOfferToMasterResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("Answer"))
+  {
+    m_answer = jsonValue.GetString("Answer");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-kinesis-video-signaling/source/model/Service.cpp

@@ -0,0 +1,63 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/kinesis-video-signaling/model/Service.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/core/Globals.h>
+#include <aws/core/utils/EnumParseOverflowContainer.h>
+
+using namespace Aws::Utils;
+
+
+namespace Aws
+{
+  namespace KinesisVideoSignalingChannels
+  {
+    namespace Model
+    {
+      namespace ServiceMapper
+      {
+
+        static const int TURN_HASH = HashingUtils::HashString("TURN");
+
+
+        Service GetServiceForName(const Aws::String& name)
+        {
+          int hashCode = HashingUtils::HashString(name.c_str());
+          if (hashCode == TURN_HASH)
+          {
+            return Service::TURN;
+          }
+          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+          if(overflowContainer)
+          {
+            overflowContainer->StoreOverflow(hashCode, name);
+            return static_cast<Service>(hashCode);
+          }
+
+          return Service::NOT_SET;
+        }
+
+        Aws::String GetNameForService(Service enumValue)
+        {
+          switch(enumValue)
+          {
+          case Service::TURN:
+            return "TURN";
+          default:
+            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+            if(overflowContainer)
+            {
+              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
+            }
+
+            return {};
+          }
+        }
+
+      } // namespace ServiceMapper
+    } // namespace Model
+  } // namespace KinesisVideoSignalingChannels
+} // namespace Aws