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

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/CodeStarconnectionsClient.cpp

@@ -0,0 +1,404 @@
+/**
+ * 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/codestar-connections/CodeStarconnectionsClient.h>
+#include <aws/codestar-connections/CodeStarconnectionsEndpoint.h>
+#include <aws/codestar-connections/CodeStarconnectionsErrorMarshaller.h>
+#include <aws/codestar-connections/model/CreateConnectionRequest.h>
+#include <aws/codestar-connections/model/CreateHostRequest.h>
+#include <aws/codestar-connections/model/DeleteConnectionRequest.h>
+#include <aws/codestar-connections/model/DeleteHostRequest.h>
+#include <aws/codestar-connections/model/GetConnectionRequest.h>
+#include <aws/codestar-connections/model/GetHostRequest.h>
+#include <aws/codestar-connections/model/ListConnectionsRequest.h>
+#include <aws/codestar-connections/model/ListHostsRequest.h>
+#include <aws/codestar-connections/model/ListTagsForResourceRequest.h>
+#include <aws/codestar-connections/model/TagResourceRequest.h>
+#include <aws/codestar-connections/model/UntagResourceRequest.h>
+
+using namespace Aws;
+using namespace Aws::Auth;
+using namespace Aws::Client;
+using namespace Aws::CodeStarconnections;
+using namespace Aws::CodeStarconnections::Model;
+using namespace Aws::Http;
+using namespace Aws::Utils::Json;
+
+static const char* SERVICE_NAME = "codestar-connections";
+static const char* ALLOCATION_TAG = "CodeStarconnectionsClient";
+
+
+CodeStarconnectionsClient::CodeStarconnectionsClient(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<CodeStarconnectionsErrorMarshaller>(ALLOCATION_TAG)),
+    m_executor(clientConfiguration.executor)
+{
+  init(clientConfiguration);
+}
+
+CodeStarconnectionsClient::CodeStarconnectionsClient(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<CodeStarconnectionsErrorMarshaller>(ALLOCATION_TAG)),
+    m_executor(clientConfiguration.executor)
+{
+  init(clientConfiguration);
+}
+
+CodeStarconnectionsClient::CodeStarconnectionsClient(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<CodeStarconnectionsErrorMarshaller>(ALLOCATION_TAG)),
+    m_executor(clientConfiguration.executor)
+{
+  init(clientConfiguration);
+}
+
+CodeStarconnectionsClient::~CodeStarconnectionsClient()
+{
+}
+
+void CodeStarconnectionsClient::init(const ClientConfiguration& config)
+{
+  SetServiceClientName("CodeStar connections");
+  m_configScheme = SchemeMapper::ToString(config.scheme);
+  if (config.endpointOverride.empty())
+  {
+      m_uri = m_configScheme + "://" + CodeStarconnectionsEndpoint::ForRegion(config.region, config.useDualStack);
+  }
+  else
+  {
+      OverrideEndpoint(config.endpointOverride);
+  }
+}
+
+void CodeStarconnectionsClient::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;
+  }
+}
+
+CreateConnectionOutcome CodeStarconnectionsClient::CreateConnection(const CreateConnectionRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return CreateConnectionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+CreateConnectionOutcomeCallable CodeStarconnectionsClient::CreateConnectionCallable(const CreateConnectionRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< CreateConnectionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateConnection(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void CodeStarconnectionsClient::CreateConnectionAsync(const CreateConnectionRequest& request, const CreateConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->CreateConnectionAsyncHelper( request, handler, context ); } );
+}
+
+void CodeStarconnectionsClient::CreateConnectionAsyncHelper(const CreateConnectionRequest& request, const CreateConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, CreateConnection(request), context);
+}
+
+CreateHostOutcome CodeStarconnectionsClient::CreateHost(const CreateHostRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return CreateHostOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+CreateHostOutcomeCallable CodeStarconnectionsClient::CreateHostCallable(const CreateHostRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< CreateHostOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateHost(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void CodeStarconnectionsClient::CreateHostAsync(const CreateHostRequest& request, const CreateHostResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->CreateHostAsyncHelper( request, handler, context ); } );
+}
+
+void CodeStarconnectionsClient::CreateHostAsyncHelper(const CreateHostRequest& request, const CreateHostResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, CreateHost(request), context);
+}
+
+DeleteConnectionOutcome CodeStarconnectionsClient::DeleteConnection(const DeleteConnectionRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DeleteConnectionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+DeleteConnectionOutcomeCallable CodeStarconnectionsClient::DeleteConnectionCallable(const DeleteConnectionRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DeleteConnectionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteConnection(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void CodeStarconnectionsClient::DeleteConnectionAsync(const DeleteConnectionRequest& request, const DeleteConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DeleteConnectionAsyncHelper( request, handler, context ); } );
+}
+
+void CodeStarconnectionsClient::DeleteConnectionAsyncHelper(const DeleteConnectionRequest& request, const DeleteConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DeleteConnection(request), context);
+}
+
+DeleteHostOutcome CodeStarconnectionsClient::DeleteHost(const DeleteHostRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DeleteHostOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+DeleteHostOutcomeCallable CodeStarconnectionsClient::DeleteHostCallable(const DeleteHostRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DeleteHostOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteHost(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void CodeStarconnectionsClient::DeleteHostAsync(const DeleteHostRequest& request, const DeleteHostResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DeleteHostAsyncHelper( request, handler, context ); } );
+}
+
+void CodeStarconnectionsClient::DeleteHostAsyncHelper(const DeleteHostRequest& request, const DeleteHostResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DeleteHost(request), context);
+}
+
+GetConnectionOutcome CodeStarconnectionsClient::GetConnection(const GetConnectionRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return GetConnectionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+GetConnectionOutcomeCallable CodeStarconnectionsClient::GetConnectionCallable(const GetConnectionRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< GetConnectionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetConnection(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void CodeStarconnectionsClient::GetConnectionAsync(const GetConnectionRequest& request, const GetConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->GetConnectionAsyncHelper( request, handler, context ); } );
+}
+
+void CodeStarconnectionsClient::GetConnectionAsyncHelper(const GetConnectionRequest& request, const GetConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, GetConnection(request), context);
+}
+
+GetHostOutcome CodeStarconnectionsClient::GetHost(const GetHostRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return GetHostOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+GetHostOutcomeCallable CodeStarconnectionsClient::GetHostCallable(const GetHostRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< GetHostOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetHost(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void CodeStarconnectionsClient::GetHostAsync(const GetHostRequest& request, const GetHostResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->GetHostAsyncHelper( request, handler, context ); } );
+}
+
+void CodeStarconnectionsClient::GetHostAsyncHelper(const GetHostRequest& request, const GetHostResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, GetHost(request), context);
+}
+
+ListConnectionsOutcome CodeStarconnectionsClient::ListConnections(const ListConnectionsRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ListConnectionsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+ListConnectionsOutcomeCallable CodeStarconnectionsClient::ListConnectionsCallable(const ListConnectionsRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< ListConnectionsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListConnections(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void CodeStarconnectionsClient::ListConnectionsAsync(const ListConnectionsRequest& request, const ListConnectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->ListConnectionsAsyncHelper( request, handler, context ); } );
+}
+
+void CodeStarconnectionsClient::ListConnectionsAsyncHelper(const ListConnectionsRequest& request, const ListConnectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ListConnections(request), context);
+}
+
+ListHostsOutcome CodeStarconnectionsClient::ListHosts(const ListHostsRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ListHostsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+ListHostsOutcomeCallable CodeStarconnectionsClient::ListHostsCallable(const ListHostsRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< ListHostsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListHosts(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void CodeStarconnectionsClient::ListHostsAsync(const ListHostsRequest& request, const ListHostsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->ListHostsAsyncHelper( request, handler, context ); } );
+}
+
+void CodeStarconnectionsClient::ListHostsAsyncHelper(const ListHostsRequest& request, const ListHostsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ListHosts(request), context);
+}
+
+ListTagsForResourceOutcome CodeStarconnectionsClient::ListTagsForResource(const ListTagsForResourceRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ListTagsForResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+ListTagsForResourceOutcomeCallable CodeStarconnectionsClient::ListTagsForResourceCallable(const ListTagsForResourceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< ListTagsForResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTagsForResource(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void CodeStarconnectionsClient::ListTagsForResourceAsync(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->ListTagsForResourceAsyncHelper( request, handler, context ); } );
+}
+
+void CodeStarconnectionsClient::ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ListTagsForResource(request), context);
+}
+
+TagResourceOutcome CodeStarconnectionsClient::TagResource(const TagResourceRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return TagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+TagResourceOutcomeCallable CodeStarconnectionsClient::TagResourceCallable(const TagResourceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< TagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagResource(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void CodeStarconnectionsClient::TagResourceAsync(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->TagResourceAsyncHelper( request, handler, context ); } );
+}
+
+void CodeStarconnectionsClient::TagResourceAsyncHelper(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, TagResource(request), context);
+}
+
+UntagResourceOutcome CodeStarconnectionsClient::UntagResource(const UntagResourceRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return UntagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+UntagResourceOutcomeCallable CodeStarconnectionsClient::UntagResourceCallable(const UntagResourceRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< UntagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagResource(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void CodeStarconnectionsClient::UntagResourceAsync(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->UntagResourceAsyncHelper( request, handler, context ); } );
+}
+
+void CodeStarconnectionsClient::UntagResourceAsyncHelper(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, UntagResource(request), context);
+}
+

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/CodeStarconnectionsEndpoint.cpp

@@ -0,0 +1,64 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/CodeStarconnectionsEndpoint.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+#include <aws/core/utils/HashingUtils.h>
+
+using namespace Aws;
+using namespace Aws::CodeStarconnections;
+
+namespace Aws
+{
+namespace CodeStarconnections
+{
+namespace CodeStarconnectionsEndpoint
+{
+  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 << "codestar-connections" << ".";
+
+    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 CodeStarconnectionsEndpoint
+} // namespace CodeStarconnections
+} // namespace Aws
+

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/CodeStarconnectionsErrorMarshaller.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/codestar-connections/CodeStarconnectionsErrorMarshaller.h>
+#include <aws/codestar-connections/CodeStarconnectionsErrors.h>
+
+using namespace Aws::Client;
+using namespace Aws::CodeStarconnections;
+
+AWSError<CoreErrors> CodeStarconnectionsErrorMarshaller::FindErrorByName(const char* errorName) const
+{
+  AWSError<CoreErrors> error = CodeStarconnectionsErrorMapper::GetErrorForName(errorName);
+  if(error.GetErrorType() != CoreErrors::UNKNOWN)
+  {
+    return error;
+  }
+
+  return AWSErrorMarshaller::FindErrorByName(errorName);
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/CodeStarconnectionsErrors.cpp

@@ -0,0 +1,42 @@
+/**
+ * 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/codestar-connections/CodeStarconnectionsErrors.h>
+
+using namespace Aws::Client;
+using namespace Aws::Utils;
+using namespace Aws::CodeStarconnections;
+
+namespace Aws
+{
+namespace CodeStarconnections
+{
+namespace CodeStarconnectionsErrorMapper
+{
+
+static const int LIMIT_EXCEEDED_HASH = HashingUtils::HashString("LimitExceededException");
+static const int RESOURCE_UNAVAILABLE_HASH = HashingUtils::HashString("ResourceUnavailableException");
+
+
+AWSError<CoreErrors> GetErrorForName(const char* errorName)
+{
+  int hashCode = HashingUtils::HashString(errorName);
+
+  if (hashCode == LIMIT_EXCEEDED_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(CodeStarconnectionsErrors::LIMIT_EXCEEDED), true);
+  }
+  else if (hashCode == RESOURCE_UNAVAILABLE_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(CodeStarconnectionsErrors::RESOURCE_UNAVAILABLE), false);
+  }
+  return AWSError<CoreErrors>(CoreErrors::UNKNOWN, false);
+}
+
+} // namespace CodeStarconnectionsErrorMapper
+} // namespace CodeStarconnections
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/Connection.cpp

@@ -0,0 +1,136 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/Connection.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace CodeStarconnections
+{
+namespace Model
+{
+
+Connection::Connection() : 
+    m_connectionNameHasBeenSet(false),
+    m_connectionArnHasBeenSet(false),
+    m_providerType(ProviderType::NOT_SET),
+    m_providerTypeHasBeenSet(false),
+    m_ownerAccountIdHasBeenSet(false),
+    m_connectionStatus(ConnectionStatus::NOT_SET),
+    m_connectionStatusHasBeenSet(false),
+    m_hostArnHasBeenSet(false)
+{
+}
+
+Connection::Connection(JsonView jsonValue) : 
+    m_connectionNameHasBeenSet(false),
+    m_connectionArnHasBeenSet(false),
+    m_providerType(ProviderType::NOT_SET),
+    m_providerTypeHasBeenSet(false),
+    m_ownerAccountIdHasBeenSet(false),
+    m_connectionStatus(ConnectionStatus::NOT_SET),
+    m_connectionStatusHasBeenSet(false),
+    m_hostArnHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+Connection& Connection::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("ConnectionName"))
+  {
+    m_connectionName = jsonValue.GetString("ConnectionName");
+
+    m_connectionNameHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("ConnectionArn"))
+  {
+    m_connectionArn = jsonValue.GetString("ConnectionArn");
+
+    m_connectionArnHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("ProviderType"))
+  {
+    m_providerType = ProviderTypeMapper::GetProviderTypeForName(jsonValue.GetString("ProviderType"));
+
+    m_providerTypeHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("OwnerAccountId"))
+  {
+    m_ownerAccountId = jsonValue.GetString("OwnerAccountId");
+
+    m_ownerAccountIdHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("ConnectionStatus"))
+  {
+    m_connectionStatus = ConnectionStatusMapper::GetConnectionStatusForName(jsonValue.GetString("ConnectionStatus"));
+
+    m_connectionStatusHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("HostArn"))
+  {
+    m_hostArn = jsonValue.GetString("HostArn");
+
+    m_hostArnHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue Connection::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_connectionNameHasBeenSet)
+  {
+   payload.WithString("ConnectionName", m_connectionName);
+
+  }
+
+  if(m_connectionArnHasBeenSet)
+  {
+   payload.WithString("ConnectionArn", m_connectionArn);
+
+  }
+
+  if(m_providerTypeHasBeenSet)
+  {
+   payload.WithString("ProviderType", ProviderTypeMapper::GetNameForProviderType(m_providerType));
+  }
+
+  if(m_ownerAccountIdHasBeenSet)
+  {
+   payload.WithString("OwnerAccountId", m_ownerAccountId);
+
+  }
+
+  if(m_connectionStatusHasBeenSet)
+  {
+   payload.WithString("ConnectionStatus", ConnectionStatusMapper::GetNameForConnectionStatus(m_connectionStatus));
+  }
+
+  if(m_hostArnHasBeenSet)
+  {
+   payload.WithString("HostArn", m_hostArn);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace CodeStarconnections
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/ConnectionStatus.cpp

@@ -0,0 +1,77 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/ConnectionStatus.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 CodeStarconnections
+  {
+    namespace Model
+    {
+      namespace ConnectionStatusMapper
+      {
+
+        static const int PENDING_HASH = HashingUtils::HashString("PENDING");
+        static const int AVAILABLE_HASH = HashingUtils::HashString("AVAILABLE");
+        static const int ERROR__HASH = HashingUtils::HashString("ERROR");
+
+
+        ConnectionStatus GetConnectionStatusForName(const Aws::String& name)
+        {
+          int hashCode = HashingUtils::HashString(name.c_str());
+          if (hashCode == PENDING_HASH)
+          {
+            return ConnectionStatus::PENDING;
+          }
+          else if (hashCode == AVAILABLE_HASH)
+          {
+            return ConnectionStatus::AVAILABLE;
+          }
+          else if (hashCode == ERROR__HASH)
+          {
+            return ConnectionStatus::ERROR_;
+          }
+          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+          if(overflowContainer)
+          {
+            overflowContainer->StoreOverflow(hashCode, name);
+            return static_cast<ConnectionStatus>(hashCode);
+          }
+
+          return ConnectionStatus::NOT_SET;
+        }
+
+        Aws::String GetNameForConnectionStatus(ConnectionStatus enumValue)
+        {
+          switch(enumValue)
+          {
+          case ConnectionStatus::PENDING:
+            return "PENDING";
+          case ConnectionStatus::AVAILABLE:
+            return "AVAILABLE";
+          case ConnectionStatus::ERROR_:
+            return "ERROR";
+          default:
+            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+            if(overflowContainer)
+            {
+              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
+            }
+
+            return {};
+          }
+        }
+
+      } // namespace ConnectionStatusMapper
+    } // namespace Model
+  } // namespace CodeStarconnections
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/CreateConnectionRequest.cpp

@@ -0,0 +1,69 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/CreateConnectionRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+CreateConnectionRequest::CreateConnectionRequest() : 
+    m_providerType(ProviderType::NOT_SET),
+    m_providerTypeHasBeenSet(false),
+    m_connectionNameHasBeenSet(false),
+    m_tagsHasBeenSet(false),
+    m_hostArnHasBeenSet(false)
+{
+}
+
+Aws::String CreateConnectionRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_providerTypeHasBeenSet)
+  {
+   payload.WithString("ProviderType", ProviderTypeMapper::GetNameForProviderType(m_providerType));
+  }
+
+  if(m_connectionNameHasBeenSet)
+  {
+   payload.WithString("ConnectionName", m_connectionName);
+
+  }
+
+  if(m_tagsHasBeenSet)
+  {
+   Array<JsonValue> tagsJsonList(m_tags.size());
+   for(unsigned tagsIndex = 0; tagsIndex < tagsJsonList.GetLength(); ++tagsIndex)
+   {
+     tagsJsonList[tagsIndex].AsObject(m_tags[tagsIndex].Jsonize());
+   }
+   payload.WithArray("Tags", std::move(tagsJsonList));
+
+  }
+
+  if(m_hostArnHasBeenSet)
+  {
+   payload.WithString("HostArn", m_hostArn);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection CreateConnectionRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "com.amazonaws.codestar.connections.CodeStar_connections_20191201.CreateConnection"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/CreateConnectionResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/CreateConnectionResult.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::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+CreateConnectionResult::CreateConnectionResult()
+{
+}
+
+CreateConnectionResult::CreateConnectionResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+CreateConnectionResult& CreateConnectionResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("ConnectionArn"))
+  {
+    m_connectionArn = jsonValue.GetString("ConnectionArn");
+
+  }
+
+  if(jsonValue.ValueExists("Tags"))
+  {
+    Array<JsonView> tagsJsonList = jsonValue.GetArray("Tags");
+    for(unsigned tagsIndex = 0; tagsIndex < tagsJsonList.GetLength(); ++tagsIndex)
+    {
+      m_tags.push_back(tagsJsonList[tagsIndex].AsObject());
+    }
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/CreateHostRequest.cpp

@@ -0,0 +1,64 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/CreateHostRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+CreateHostRequest::CreateHostRequest() : 
+    m_nameHasBeenSet(false),
+    m_providerType(ProviderType::NOT_SET),
+    m_providerTypeHasBeenSet(false),
+    m_providerEndpointHasBeenSet(false),
+    m_vpcConfigurationHasBeenSet(false)
+{
+}
+
+Aws::String CreateHostRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_nameHasBeenSet)
+  {
+   payload.WithString("Name", m_name);
+
+  }
+
+  if(m_providerTypeHasBeenSet)
+  {
+   payload.WithString("ProviderType", ProviderTypeMapper::GetNameForProviderType(m_providerType));
+  }
+
+  if(m_providerEndpointHasBeenSet)
+  {
+   payload.WithString("ProviderEndpoint", m_providerEndpoint);
+
+  }
+
+  if(m_vpcConfigurationHasBeenSet)
+  {
+   payload.WithObject("VpcConfiguration", m_vpcConfiguration.Jsonize());
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection CreateHostRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "com.amazonaws.codestar.connections.CodeStar_connections_20191201.CreateHost"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/CreateHostResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/CreateHostResult.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::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+CreateHostResult::CreateHostResult()
+{
+}
+
+CreateHostResult::CreateHostResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+CreateHostResult& CreateHostResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("HostArn"))
+  {
+    m_hostArn = jsonValue.GetString("HostArn");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/DeleteConnectionRequest.cpp

@@ -0,0 +1,43 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/DeleteConnectionRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+DeleteConnectionRequest::DeleteConnectionRequest() : 
+    m_connectionArnHasBeenSet(false)
+{
+}
+
+Aws::String DeleteConnectionRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_connectionArnHasBeenSet)
+  {
+   payload.WithString("ConnectionArn", m_connectionArn);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection DeleteConnectionRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "com.amazonaws.codestar.connections.CodeStar_connections_20191201.DeleteConnection"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/DeleteConnectionResult.cpp

@@ -0,0 +1,34 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/DeleteConnectionResult.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::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+DeleteConnectionResult::DeleteConnectionResult()
+{
+}
+
+DeleteConnectionResult::DeleteConnectionResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+DeleteConnectionResult& DeleteConnectionResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  AWS_UNREFERENCED_PARAM(result);
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/DeleteHostRequest.cpp

@@ -0,0 +1,43 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/DeleteHostRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+DeleteHostRequest::DeleteHostRequest() : 
+    m_hostArnHasBeenSet(false)
+{
+}
+
+Aws::String DeleteHostRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_hostArnHasBeenSet)
+  {
+   payload.WithString("HostArn", m_hostArn);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection DeleteHostRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "com.amazonaws.codestar.connections.CodeStar_connections_20191201.DeleteHost"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/DeleteHostResult.cpp

@@ -0,0 +1,34 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/DeleteHostResult.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::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+DeleteHostResult::DeleteHostResult()
+{
+}
+
+DeleteHostResult::DeleteHostResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+DeleteHostResult& DeleteHostResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  AWS_UNREFERENCED_PARAM(result);
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/GetConnectionRequest.cpp

@@ -0,0 +1,43 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/GetConnectionRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+GetConnectionRequest::GetConnectionRequest() : 
+    m_connectionArnHasBeenSet(false)
+{
+}
+
+Aws::String GetConnectionRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_connectionArnHasBeenSet)
+  {
+   payload.WithString("ConnectionArn", m_connectionArn);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection GetConnectionRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "com.amazonaws.codestar.connections.CodeStar_connections_20191201.GetConnection"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/GetConnectionResult.cpp

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/GetConnectionResult.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::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+GetConnectionResult::GetConnectionResult()
+{
+}
+
+GetConnectionResult::GetConnectionResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+GetConnectionResult& GetConnectionResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("Connection"))
+  {
+    m_connection = jsonValue.GetObject("Connection");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/GetHostRequest.cpp

@@ -0,0 +1,43 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/GetHostRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+GetHostRequest::GetHostRequest() : 
+    m_hostArnHasBeenSet(false)
+{
+}
+
+Aws::String GetHostRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_hostArnHasBeenSet)
+  {
+   payload.WithString("HostArn", m_hostArn);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection GetHostRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "com.amazonaws.codestar.connections.CodeStar_connections_20191201.GetHost"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/GetHostResult.cpp

@@ -0,0 +1,66 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/GetHostResult.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::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+GetHostResult::GetHostResult() : 
+    m_providerType(ProviderType::NOT_SET)
+{
+}
+
+GetHostResult::GetHostResult(const Aws::AmazonWebServiceResult<JsonValue>& result) : 
+    m_providerType(ProviderType::NOT_SET)
+{
+  *this = result;
+}
+
+GetHostResult& GetHostResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("Name"))
+  {
+    m_name = jsonValue.GetString("Name");
+
+  }
+
+  if(jsonValue.ValueExists("Status"))
+  {
+    m_status = jsonValue.GetString("Status");
+
+  }
+
+  if(jsonValue.ValueExists("ProviderType"))
+  {
+    m_providerType = ProviderTypeMapper::GetProviderTypeForName(jsonValue.GetString("ProviderType"));
+
+  }
+
+  if(jsonValue.ValueExists("ProviderEndpoint"))
+  {
+    m_providerEndpoint = jsonValue.GetString("ProviderEndpoint");
+
+  }
+
+  if(jsonValue.ValueExists("VpcConfiguration"))
+  {
+    m_vpcConfiguration = jsonValue.GetObject("VpcConfiguration");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/Host.cpp

@@ -0,0 +1,150 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/Host.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace CodeStarconnections
+{
+namespace Model
+{
+
+Host::Host() : 
+    m_nameHasBeenSet(false),
+    m_hostArnHasBeenSet(false),
+    m_providerType(ProviderType::NOT_SET),
+    m_providerTypeHasBeenSet(false),
+    m_providerEndpointHasBeenSet(false),
+    m_vpcConfigurationHasBeenSet(false),
+    m_statusHasBeenSet(false),
+    m_statusMessageHasBeenSet(false)
+{
+}
+
+Host::Host(JsonView jsonValue) : 
+    m_nameHasBeenSet(false),
+    m_hostArnHasBeenSet(false),
+    m_providerType(ProviderType::NOT_SET),
+    m_providerTypeHasBeenSet(false),
+    m_providerEndpointHasBeenSet(false),
+    m_vpcConfigurationHasBeenSet(false),
+    m_statusHasBeenSet(false),
+    m_statusMessageHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+Host& Host::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Name"))
+  {
+    m_name = jsonValue.GetString("Name");
+
+    m_nameHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("HostArn"))
+  {
+    m_hostArn = jsonValue.GetString("HostArn");
+
+    m_hostArnHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("ProviderType"))
+  {
+    m_providerType = ProviderTypeMapper::GetProviderTypeForName(jsonValue.GetString("ProviderType"));
+
+    m_providerTypeHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("ProviderEndpoint"))
+  {
+    m_providerEndpoint = jsonValue.GetString("ProviderEndpoint");
+
+    m_providerEndpointHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("VpcConfiguration"))
+  {
+    m_vpcConfiguration = jsonValue.GetObject("VpcConfiguration");
+
+    m_vpcConfigurationHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Status"))
+  {
+    m_status = jsonValue.GetString("Status");
+
+    m_statusHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("StatusMessage"))
+  {
+    m_statusMessage = jsonValue.GetString("StatusMessage");
+
+    m_statusMessageHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue Host::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_nameHasBeenSet)
+  {
+   payload.WithString("Name", m_name);
+
+  }
+
+  if(m_hostArnHasBeenSet)
+  {
+   payload.WithString("HostArn", m_hostArn);
+
+  }
+
+  if(m_providerTypeHasBeenSet)
+  {
+   payload.WithString("ProviderType", ProviderTypeMapper::GetNameForProviderType(m_providerType));
+  }
+
+  if(m_providerEndpointHasBeenSet)
+  {
+   payload.WithString("ProviderEndpoint", m_providerEndpoint);
+
+  }
+
+  if(m_vpcConfigurationHasBeenSet)
+  {
+   payload.WithObject("VpcConfiguration", m_vpcConfiguration.Jsonize());
+
+  }
+
+  if(m_statusHasBeenSet)
+  {
+   payload.WithString("Status", m_status);
+
+  }
+
+  if(m_statusMessageHasBeenSet)
+  {
+   payload.WithString("StatusMessage", m_statusMessage);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace CodeStarconnections
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/ListConnectionsRequest.cpp

@@ -0,0 +1,65 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/ListConnectionsRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+ListConnectionsRequest::ListConnectionsRequest() : 
+    m_providerTypeFilter(ProviderType::NOT_SET),
+    m_providerTypeFilterHasBeenSet(false),
+    m_hostArnFilterHasBeenSet(false),
+    m_maxResults(0),
+    m_maxResultsHasBeenSet(false),
+    m_nextTokenHasBeenSet(false)
+{
+}
+
+Aws::String ListConnectionsRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_providerTypeFilterHasBeenSet)
+  {
+   payload.WithString("ProviderTypeFilter", ProviderTypeMapper::GetNameForProviderType(m_providerTypeFilter));
+  }
+
+  if(m_hostArnFilterHasBeenSet)
+  {
+   payload.WithString("HostArnFilter", m_hostArnFilter);
+
+  }
+
+  if(m_maxResultsHasBeenSet)
+  {
+   payload.WithInteger("MaxResults", m_maxResults);
+
+  }
+
+  if(m_nextTokenHasBeenSet)
+  {
+   payload.WithString("NextToken", m_nextToken);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection ListConnectionsRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "com.amazonaws.codestar.connections.CodeStar_connections_20191201.ListConnections"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/ListConnectionsResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/ListConnectionsResult.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::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+ListConnectionsResult::ListConnectionsResult()
+{
+}
+
+ListConnectionsResult::ListConnectionsResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+ListConnectionsResult& ListConnectionsResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("Connections"))
+  {
+    Array<JsonView> connectionsJsonList = jsonValue.GetArray("Connections");
+    for(unsigned connectionsIndex = 0; connectionsIndex < connectionsJsonList.GetLength(); ++connectionsIndex)
+    {
+      m_connections.push_back(connectionsJsonList[connectionsIndex].AsObject());
+    }
+  }
+
+  if(jsonValue.ValueExists("NextToken"))
+  {
+    m_nextToken = jsonValue.GetString("NextToken");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/ListHostsRequest.cpp

@@ -0,0 +1,51 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/ListHostsRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+ListHostsRequest::ListHostsRequest() : 
+    m_maxResults(0),
+    m_maxResultsHasBeenSet(false),
+    m_nextTokenHasBeenSet(false)
+{
+}
+
+Aws::String ListHostsRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_maxResultsHasBeenSet)
+  {
+   payload.WithInteger("MaxResults", m_maxResults);
+
+  }
+
+  if(m_nextTokenHasBeenSet)
+  {
+   payload.WithString("NextToken", m_nextToken);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection ListHostsRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "com.amazonaws.codestar.connections.CodeStar_connections_20191201.ListHosts"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/ListHostsResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/ListHostsResult.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::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+ListHostsResult::ListHostsResult()
+{
+}
+
+ListHostsResult::ListHostsResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+ListHostsResult& ListHostsResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("Hosts"))
+  {
+    Array<JsonView> hostsJsonList = jsonValue.GetArray("Hosts");
+    for(unsigned hostsIndex = 0; hostsIndex < hostsJsonList.GetLength(); ++hostsIndex)
+    {
+      m_hosts.push_back(hostsJsonList[hostsIndex].AsObject());
+    }
+  }
+
+  if(jsonValue.ValueExists("NextToken"))
+  {
+    m_nextToken = jsonValue.GetString("NextToken");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/ListTagsForResourceRequest.cpp

@@ -0,0 +1,43 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/ListTagsForResourceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+ListTagsForResourceRequest::ListTagsForResourceRequest() : 
+    m_resourceArnHasBeenSet(false)
+{
+}
+
+Aws::String ListTagsForResourceRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_resourceArnHasBeenSet)
+  {
+   payload.WithString("ResourceArn", m_resourceArn);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection ListTagsForResourceRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "com.amazonaws.codestar.connections.CodeStar_connections_20191201.ListTagsForResource"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/ListTagsForResourceResult.cpp

@@ -0,0 +1,43 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/ListTagsForResourceResult.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::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+ListTagsForResourceResult::ListTagsForResourceResult()
+{
+}
+
+ListTagsForResourceResult::ListTagsForResourceResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+ListTagsForResourceResult& ListTagsForResourceResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("Tags"))
+  {
+    Array<JsonView> tagsJsonList = jsonValue.GetArray("Tags");
+    for(unsigned tagsIndex = 0; tagsIndex < tagsJsonList.GetLength(); ++tagsIndex)
+    {
+      m_tags.push_back(tagsJsonList[tagsIndex].AsObject());
+    }
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/ProviderType.cpp

@@ -0,0 +1,70 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/ProviderType.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 CodeStarconnections
+  {
+    namespace Model
+    {
+      namespace ProviderTypeMapper
+      {
+
+        static const int Bitbucket_HASH = HashingUtils::HashString("Bitbucket");
+        static const int GitHubEnterpriseServer_HASH = HashingUtils::HashString("GitHubEnterpriseServer");
+
+
+        ProviderType GetProviderTypeForName(const Aws::String& name)
+        {
+          int hashCode = HashingUtils::HashString(name.c_str());
+          if (hashCode == Bitbucket_HASH)
+          {
+            return ProviderType::Bitbucket;
+          }
+          else if (hashCode == GitHubEnterpriseServer_HASH)
+          {
+            return ProviderType::GitHubEnterpriseServer;
+          }
+          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+          if(overflowContainer)
+          {
+            overflowContainer->StoreOverflow(hashCode, name);
+            return static_cast<ProviderType>(hashCode);
+          }
+
+          return ProviderType::NOT_SET;
+        }
+
+        Aws::String GetNameForProviderType(ProviderType enumValue)
+        {
+          switch(enumValue)
+          {
+          case ProviderType::Bitbucket:
+            return "Bitbucket";
+          case ProviderType::GitHubEnterpriseServer:
+            return "GitHubEnterpriseServer";
+          default:
+            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+            if(overflowContainer)
+            {
+              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
+            }
+
+            return {};
+          }
+        }
+
+      } // namespace ProviderTypeMapper
+    } // namespace Model
+  } // namespace CodeStarconnections
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/Tag.cpp

@@ -0,0 +1,74 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/Tag.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace CodeStarconnections
+{
+namespace Model
+{
+
+Tag::Tag() : 
+    m_keyHasBeenSet(false),
+    m_valueHasBeenSet(false)
+{
+}
+
+Tag::Tag(JsonView jsonValue) : 
+    m_keyHasBeenSet(false),
+    m_valueHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+Tag& Tag::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Key"))
+  {
+    m_key = jsonValue.GetString("Key");
+
+    m_keyHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Value"))
+  {
+    m_value = jsonValue.GetString("Value");
+
+    m_valueHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue Tag::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_keyHasBeenSet)
+  {
+   payload.WithString("Key", m_key);
+
+  }
+
+  if(m_valueHasBeenSet)
+  {
+   payload.WithString("Value", m_value);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace CodeStarconnections
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/TagResourceRequest.cpp

@@ -0,0 +1,55 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/TagResourceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+TagResourceRequest::TagResourceRequest() : 
+    m_resourceArnHasBeenSet(false),
+    m_tagsHasBeenSet(false)
+{
+}
+
+Aws::String TagResourceRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_resourceArnHasBeenSet)
+  {
+   payload.WithString("ResourceArn", m_resourceArn);
+
+  }
+
+  if(m_tagsHasBeenSet)
+  {
+   Array<JsonValue> tagsJsonList(m_tags.size());
+   for(unsigned tagsIndex = 0; tagsIndex < tagsJsonList.GetLength(); ++tagsIndex)
+   {
+     tagsJsonList[tagsIndex].AsObject(m_tags[tagsIndex].Jsonize());
+   }
+   payload.WithArray("Tags", std::move(tagsJsonList));
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection TagResourceRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "com.amazonaws.codestar.connections.CodeStar_connections_20191201.TagResource"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/TagResourceResult.cpp

@@ -0,0 +1,34 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/TagResourceResult.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::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+TagResourceResult::TagResourceResult()
+{
+}
+
+TagResourceResult::TagResourceResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+TagResourceResult& TagResourceResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  AWS_UNREFERENCED_PARAM(result);
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/UntagResourceRequest.cpp

@@ -0,0 +1,55 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/UntagResourceRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+UntagResourceRequest::UntagResourceRequest() : 
+    m_resourceArnHasBeenSet(false),
+    m_tagKeysHasBeenSet(false)
+{
+}
+
+Aws::String UntagResourceRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_resourceArnHasBeenSet)
+  {
+   payload.WithString("ResourceArn", m_resourceArn);
+
+  }
+
+  if(m_tagKeysHasBeenSet)
+  {
+   Array<JsonValue> tagKeysJsonList(m_tagKeys.size());
+   for(unsigned tagKeysIndex = 0; tagKeysIndex < tagKeysJsonList.GetLength(); ++tagKeysIndex)
+   {
+     tagKeysJsonList[tagKeysIndex].AsString(m_tagKeys[tagKeysIndex]);
+   }
+   payload.WithArray("TagKeys", std::move(tagKeysJsonList));
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection UntagResourceRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "com.amazonaws.codestar.connections.CodeStar_connections_20191201.UntagResource"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/UntagResourceResult.cpp

@@ -0,0 +1,34 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/UntagResourceResult.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::CodeStarconnections::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+UntagResourceResult::UntagResourceResult()
+{
+}
+
+UntagResourceResult::UntagResourceResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+UntagResourceResult& UntagResourceResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  AWS_UNREFERENCED_PARAM(result);
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-codestar-connections/source/model/VpcConfiguration.cpp

@@ -0,0 +1,120 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/codestar-connections/model/VpcConfiguration.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace CodeStarconnections
+{
+namespace Model
+{
+
+VpcConfiguration::VpcConfiguration() : 
+    m_vpcIdHasBeenSet(false),
+    m_subnetIdsHasBeenSet(false),
+    m_securityGroupIdsHasBeenSet(false),
+    m_tlsCertificateHasBeenSet(false)
+{
+}
+
+VpcConfiguration::VpcConfiguration(JsonView jsonValue) : 
+    m_vpcIdHasBeenSet(false),
+    m_subnetIdsHasBeenSet(false),
+    m_securityGroupIdsHasBeenSet(false),
+    m_tlsCertificateHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+VpcConfiguration& VpcConfiguration::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("VpcId"))
+  {
+    m_vpcId = jsonValue.GetString("VpcId");
+
+    m_vpcIdHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("SubnetIds"))
+  {
+    Array<JsonView> subnetIdsJsonList = jsonValue.GetArray("SubnetIds");
+    for(unsigned subnetIdsIndex = 0; subnetIdsIndex < subnetIdsJsonList.GetLength(); ++subnetIdsIndex)
+    {
+      m_subnetIds.push_back(subnetIdsJsonList[subnetIdsIndex].AsString());
+    }
+    m_subnetIdsHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("SecurityGroupIds"))
+  {
+    Array<JsonView> securityGroupIdsJsonList = jsonValue.GetArray("SecurityGroupIds");
+    for(unsigned securityGroupIdsIndex = 0; securityGroupIdsIndex < securityGroupIdsJsonList.GetLength(); ++securityGroupIdsIndex)
+    {
+      m_securityGroupIds.push_back(securityGroupIdsJsonList[securityGroupIdsIndex].AsString());
+    }
+    m_securityGroupIdsHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("TlsCertificate"))
+  {
+    m_tlsCertificate = jsonValue.GetString("TlsCertificate");
+
+    m_tlsCertificateHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue VpcConfiguration::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_vpcIdHasBeenSet)
+  {
+   payload.WithString("VpcId", m_vpcId);
+
+  }
+
+  if(m_subnetIdsHasBeenSet)
+  {
+   Array<JsonValue> subnetIdsJsonList(m_subnetIds.size());
+   for(unsigned subnetIdsIndex = 0; subnetIdsIndex < subnetIdsJsonList.GetLength(); ++subnetIdsIndex)
+   {
+     subnetIdsJsonList[subnetIdsIndex].AsString(m_subnetIds[subnetIdsIndex]);
+   }
+   payload.WithArray("SubnetIds", std::move(subnetIdsJsonList));
+
+  }
+
+  if(m_securityGroupIdsHasBeenSet)
+  {
+   Array<JsonValue> securityGroupIdsJsonList(m_securityGroupIds.size());
+   for(unsigned securityGroupIdsIndex = 0; securityGroupIdsIndex < securityGroupIdsJsonList.GetLength(); ++securityGroupIdsIndex)
+   {
+     securityGroupIdsJsonList[securityGroupIdsIndex].AsString(m_securityGroupIds[securityGroupIdsIndex]);
+   }
+   payload.WithArray("SecurityGroupIds", std::move(securityGroupIdsJsonList));
+
+  }
+
+  if(m_tlsCertificateHasBeenSet)
+  {
+   payload.WithString("TlsCertificate", m_tlsCertificate);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace CodeStarconnections
+} // namespace Aws