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

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/ElasticLoadBalancingClient.cpp

@@ -0,0 +1,921 @@
+/**
+ * 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/xml/XmlSerializer.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/elasticloadbalancing/ElasticLoadBalancingClient.h>
+#include <aws/elasticloadbalancing/ElasticLoadBalancingEndpoint.h>
+#include <aws/elasticloadbalancing/ElasticLoadBalancingErrorMarshaller.h>
+#include <aws/elasticloadbalancing/model/AddTagsRequest.h>
+#include <aws/elasticloadbalancing/model/ApplySecurityGroupsToLoadBalancerRequest.h>
+#include <aws/elasticloadbalancing/model/AttachLoadBalancerToSubnetsRequest.h>
+#include <aws/elasticloadbalancing/model/ConfigureHealthCheckRequest.h>
+#include <aws/elasticloadbalancing/model/CreateAppCookieStickinessPolicyRequest.h>
+#include <aws/elasticloadbalancing/model/CreateLBCookieStickinessPolicyRequest.h>
+#include <aws/elasticloadbalancing/model/CreateLoadBalancerRequest.h>
+#include <aws/elasticloadbalancing/model/CreateLoadBalancerListenersRequest.h>
+#include <aws/elasticloadbalancing/model/CreateLoadBalancerPolicyRequest.h>
+#include <aws/elasticloadbalancing/model/DeleteLoadBalancerRequest.h>
+#include <aws/elasticloadbalancing/model/DeleteLoadBalancerListenersRequest.h>
+#include <aws/elasticloadbalancing/model/DeleteLoadBalancerPolicyRequest.h>
+#include <aws/elasticloadbalancing/model/DeregisterInstancesFromLoadBalancerRequest.h>
+#include <aws/elasticloadbalancing/model/DescribeAccountLimitsRequest.h>
+#include <aws/elasticloadbalancing/model/DescribeInstanceHealthRequest.h>
+#include <aws/elasticloadbalancing/model/DescribeLoadBalancerAttributesRequest.h>
+#include <aws/elasticloadbalancing/model/DescribeLoadBalancerPoliciesRequest.h>
+#include <aws/elasticloadbalancing/model/DescribeLoadBalancerPolicyTypesRequest.h>
+#include <aws/elasticloadbalancing/model/DescribeLoadBalancersRequest.h>
+#include <aws/elasticloadbalancing/model/DescribeTagsRequest.h>
+#include <aws/elasticloadbalancing/model/DetachLoadBalancerFromSubnetsRequest.h>
+#include <aws/elasticloadbalancing/model/DisableAvailabilityZonesForLoadBalancerRequest.h>
+#include <aws/elasticloadbalancing/model/EnableAvailabilityZonesForLoadBalancerRequest.h>
+#include <aws/elasticloadbalancing/model/ModifyLoadBalancerAttributesRequest.h>
+#include <aws/elasticloadbalancing/model/RegisterInstancesWithLoadBalancerRequest.h>
+#include <aws/elasticloadbalancing/model/RemoveTagsRequest.h>
+#include <aws/elasticloadbalancing/model/SetLoadBalancerListenerSSLCertificateRequest.h>
+#include <aws/elasticloadbalancing/model/SetLoadBalancerPoliciesForBackendServerRequest.h>
+#include <aws/elasticloadbalancing/model/SetLoadBalancerPoliciesOfListenerRequest.h>
+
+using namespace Aws;
+using namespace Aws::Auth;
+using namespace Aws::Client;
+using namespace Aws::ElasticLoadBalancing;
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Http;
+using namespace Aws::Utils::Xml;
+
+
+static const char* SERVICE_NAME = "elasticloadbalancing";
+static const char* ALLOCATION_TAG = "ElasticLoadBalancingClient";
+
+
+ElasticLoadBalancingClient::ElasticLoadBalancingClient(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<ElasticLoadBalancingErrorMarshaller>(ALLOCATION_TAG)),
+    m_executor(clientConfiguration.executor)
+{
+  init(clientConfiguration);
+}
+
+ElasticLoadBalancingClient::ElasticLoadBalancingClient(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<ElasticLoadBalancingErrorMarshaller>(ALLOCATION_TAG)),
+    m_executor(clientConfiguration.executor)
+{
+  init(clientConfiguration);
+}
+
+ElasticLoadBalancingClient::ElasticLoadBalancingClient(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<ElasticLoadBalancingErrorMarshaller>(ALLOCATION_TAG)),
+    m_executor(clientConfiguration.executor)
+{
+  init(clientConfiguration);
+}
+
+ElasticLoadBalancingClient::~ElasticLoadBalancingClient()
+{
+}
+
+void ElasticLoadBalancingClient::init(const ClientConfiguration& config)
+{
+  SetServiceClientName("Elastic Load Balancing");
+  m_configScheme = SchemeMapper::ToString(config.scheme);
+  if (config.endpointOverride.empty())
+  {
+      m_uri = m_configScheme + "://" + ElasticLoadBalancingEndpoint::ForRegion(config.region, config.useDualStack);
+  }
+  else
+  {
+      OverrideEndpoint(config.endpointOverride);
+  }
+}
+
+void ElasticLoadBalancingClient::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;
+  }
+}
+
+Aws::String ElasticLoadBalancingClient::ConvertRequestToPresignedUrl(const AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const
+{
+  Aws::StringStream ss;
+  ss << "https://" << ElasticLoadBalancingEndpoint::ForRegion(region);
+  ss << "?" << requestToConvert.SerializePayload();
+
+  URI uri(ss.str());
+  return GeneratePresignedUrl(uri, Aws::Http::HttpMethod::HTTP_GET, region, 3600);
+}
+
+AddTagsOutcome ElasticLoadBalancingClient::AddTags(const AddTagsRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return AddTagsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+AddTagsOutcomeCallable ElasticLoadBalancingClient::AddTagsCallable(const AddTagsRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< AddTagsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AddTags(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::AddTagsAsync(const AddTagsRequest& request, const AddTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->AddTagsAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::AddTagsAsyncHelper(const AddTagsRequest& request, const AddTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, AddTags(request), context);
+}
+
+ApplySecurityGroupsToLoadBalancerOutcome ElasticLoadBalancingClient::ApplySecurityGroupsToLoadBalancer(const ApplySecurityGroupsToLoadBalancerRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ApplySecurityGroupsToLoadBalancerOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+ApplySecurityGroupsToLoadBalancerOutcomeCallable ElasticLoadBalancingClient::ApplySecurityGroupsToLoadBalancerCallable(const ApplySecurityGroupsToLoadBalancerRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< ApplySecurityGroupsToLoadBalancerOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ApplySecurityGroupsToLoadBalancer(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::ApplySecurityGroupsToLoadBalancerAsync(const ApplySecurityGroupsToLoadBalancerRequest& request, const ApplySecurityGroupsToLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->ApplySecurityGroupsToLoadBalancerAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::ApplySecurityGroupsToLoadBalancerAsyncHelper(const ApplySecurityGroupsToLoadBalancerRequest& request, const ApplySecurityGroupsToLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ApplySecurityGroupsToLoadBalancer(request), context);
+}
+
+AttachLoadBalancerToSubnetsOutcome ElasticLoadBalancingClient::AttachLoadBalancerToSubnets(const AttachLoadBalancerToSubnetsRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return AttachLoadBalancerToSubnetsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+AttachLoadBalancerToSubnetsOutcomeCallable ElasticLoadBalancingClient::AttachLoadBalancerToSubnetsCallable(const AttachLoadBalancerToSubnetsRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< AttachLoadBalancerToSubnetsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AttachLoadBalancerToSubnets(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::AttachLoadBalancerToSubnetsAsync(const AttachLoadBalancerToSubnetsRequest& request, const AttachLoadBalancerToSubnetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->AttachLoadBalancerToSubnetsAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::AttachLoadBalancerToSubnetsAsyncHelper(const AttachLoadBalancerToSubnetsRequest& request, const AttachLoadBalancerToSubnetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, AttachLoadBalancerToSubnets(request), context);
+}
+
+ConfigureHealthCheckOutcome ElasticLoadBalancingClient::ConfigureHealthCheck(const ConfigureHealthCheckRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ConfigureHealthCheckOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+ConfigureHealthCheckOutcomeCallable ElasticLoadBalancingClient::ConfigureHealthCheckCallable(const ConfigureHealthCheckRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< ConfigureHealthCheckOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ConfigureHealthCheck(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::ConfigureHealthCheckAsync(const ConfigureHealthCheckRequest& request, const ConfigureHealthCheckResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->ConfigureHealthCheckAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::ConfigureHealthCheckAsyncHelper(const ConfigureHealthCheckRequest& request, const ConfigureHealthCheckResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ConfigureHealthCheck(request), context);
+}
+
+CreateAppCookieStickinessPolicyOutcome ElasticLoadBalancingClient::CreateAppCookieStickinessPolicy(const CreateAppCookieStickinessPolicyRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return CreateAppCookieStickinessPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+CreateAppCookieStickinessPolicyOutcomeCallable ElasticLoadBalancingClient::CreateAppCookieStickinessPolicyCallable(const CreateAppCookieStickinessPolicyRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< CreateAppCookieStickinessPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateAppCookieStickinessPolicy(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::CreateAppCookieStickinessPolicyAsync(const CreateAppCookieStickinessPolicyRequest& request, const CreateAppCookieStickinessPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->CreateAppCookieStickinessPolicyAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::CreateAppCookieStickinessPolicyAsyncHelper(const CreateAppCookieStickinessPolicyRequest& request, const CreateAppCookieStickinessPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, CreateAppCookieStickinessPolicy(request), context);
+}
+
+CreateLBCookieStickinessPolicyOutcome ElasticLoadBalancingClient::CreateLBCookieStickinessPolicy(const CreateLBCookieStickinessPolicyRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return CreateLBCookieStickinessPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+CreateLBCookieStickinessPolicyOutcomeCallable ElasticLoadBalancingClient::CreateLBCookieStickinessPolicyCallable(const CreateLBCookieStickinessPolicyRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< CreateLBCookieStickinessPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateLBCookieStickinessPolicy(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::CreateLBCookieStickinessPolicyAsync(const CreateLBCookieStickinessPolicyRequest& request, const CreateLBCookieStickinessPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->CreateLBCookieStickinessPolicyAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::CreateLBCookieStickinessPolicyAsyncHelper(const CreateLBCookieStickinessPolicyRequest& request, const CreateLBCookieStickinessPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, CreateLBCookieStickinessPolicy(request), context);
+}
+
+CreateLoadBalancerOutcome ElasticLoadBalancingClient::CreateLoadBalancer(const CreateLoadBalancerRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return CreateLoadBalancerOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+CreateLoadBalancerOutcomeCallable ElasticLoadBalancingClient::CreateLoadBalancerCallable(const CreateLoadBalancerRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< CreateLoadBalancerOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateLoadBalancer(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::CreateLoadBalancerAsync(const CreateLoadBalancerRequest& request, const CreateLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->CreateLoadBalancerAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::CreateLoadBalancerAsyncHelper(const CreateLoadBalancerRequest& request, const CreateLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, CreateLoadBalancer(request), context);
+}
+
+CreateLoadBalancerListenersOutcome ElasticLoadBalancingClient::CreateLoadBalancerListeners(const CreateLoadBalancerListenersRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return CreateLoadBalancerListenersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+CreateLoadBalancerListenersOutcomeCallable ElasticLoadBalancingClient::CreateLoadBalancerListenersCallable(const CreateLoadBalancerListenersRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< CreateLoadBalancerListenersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateLoadBalancerListeners(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::CreateLoadBalancerListenersAsync(const CreateLoadBalancerListenersRequest& request, const CreateLoadBalancerListenersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->CreateLoadBalancerListenersAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::CreateLoadBalancerListenersAsyncHelper(const CreateLoadBalancerListenersRequest& request, const CreateLoadBalancerListenersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, CreateLoadBalancerListeners(request), context);
+}
+
+CreateLoadBalancerPolicyOutcome ElasticLoadBalancingClient::CreateLoadBalancerPolicy(const CreateLoadBalancerPolicyRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return CreateLoadBalancerPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+CreateLoadBalancerPolicyOutcomeCallable ElasticLoadBalancingClient::CreateLoadBalancerPolicyCallable(const CreateLoadBalancerPolicyRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< CreateLoadBalancerPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateLoadBalancerPolicy(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::CreateLoadBalancerPolicyAsync(const CreateLoadBalancerPolicyRequest& request, const CreateLoadBalancerPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->CreateLoadBalancerPolicyAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::CreateLoadBalancerPolicyAsyncHelper(const CreateLoadBalancerPolicyRequest& request, const CreateLoadBalancerPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, CreateLoadBalancerPolicy(request), context);
+}
+
+DeleteLoadBalancerOutcome ElasticLoadBalancingClient::DeleteLoadBalancer(const DeleteLoadBalancerRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DeleteLoadBalancerOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+DeleteLoadBalancerOutcomeCallable ElasticLoadBalancingClient::DeleteLoadBalancerCallable(const DeleteLoadBalancerRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DeleteLoadBalancerOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteLoadBalancer(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::DeleteLoadBalancerAsync(const DeleteLoadBalancerRequest& request, const DeleteLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DeleteLoadBalancerAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::DeleteLoadBalancerAsyncHelper(const DeleteLoadBalancerRequest& request, const DeleteLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DeleteLoadBalancer(request), context);
+}
+
+DeleteLoadBalancerListenersOutcome ElasticLoadBalancingClient::DeleteLoadBalancerListeners(const DeleteLoadBalancerListenersRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DeleteLoadBalancerListenersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+DeleteLoadBalancerListenersOutcomeCallable ElasticLoadBalancingClient::DeleteLoadBalancerListenersCallable(const DeleteLoadBalancerListenersRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DeleteLoadBalancerListenersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteLoadBalancerListeners(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::DeleteLoadBalancerListenersAsync(const DeleteLoadBalancerListenersRequest& request, const DeleteLoadBalancerListenersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DeleteLoadBalancerListenersAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::DeleteLoadBalancerListenersAsyncHelper(const DeleteLoadBalancerListenersRequest& request, const DeleteLoadBalancerListenersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DeleteLoadBalancerListeners(request), context);
+}
+
+DeleteLoadBalancerPolicyOutcome ElasticLoadBalancingClient::DeleteLoadBalancerPolicy(const DeleteLoadBalancerPolicyRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DeleteLoadBalancerPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+DeleteLoadBalancerPolicyOutcomeCallable ElasticLoadBalancingClient::DeleteLoadBalancerPolicyCallable(const DeleteLoadBalancerPolicyRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DeleteLoadBalancerPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteLoadBalancerPolicy(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::DeleteLoadBalancerPolicyAsync(const DeleteLoadBalancerPolicyRequest& request, const DeleteLoadBalancerPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DeleteLoadBalancerPolicyAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::DeleteLoadBalancerPolicyAsyncHelper(const DeleteLoadBalancerPolicyRequest& request, const DeleteLoadBalancerPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DeleteLoadBalancerPolicy(request), context);
+}
+
+DeregisterInstancesFromLoadBalancerOutcome ElasticLoadBalancingClient::DeregisterInstancesFromLoadBalancer(const DeregisterInstancesFromLoadBalancerRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DeregisterInstancesFromLoadBalancerOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+DeregisterInstancesFromLoadBalancerOutcomeCallable ElasticLoadBalancingClient::DeregisterInstancesFromLoadBalancerCallable(const DeregisterInstancesFromLoadBalancerRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DeregisterInstancesFromLoadBalancerOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeregisterInstancesFromLoadBalancer(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::DeregisterInstancesFromLoadBalancerAsync(const DeregisterInstancesFromLoadBalancerRequest& request, const DeregisterInstancesFromLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DeregisterInstancesFromLoadBalancerAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::DeregisterInstancesFromLoadBalancerAsyncHelper(const DeregisterInstancesFromLoadBalancerRequest& request, const DeregisterInstancesFromLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DeregisterInstancesFromLoadBalancer(request), context);
+}
+
+DescribeAccountLimitsOutcome ElasticLoadBalancingClient::DescribeAccountLimits(const DescribeAccountLimitsRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DescribeAccountLimitsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+DescribeAccountLimitsOutcomeCallable ElasticLoadBalancingClient::DescribeAccountLimitsCallable(const DescribeAccountLimitsRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DescribeAccountLimitsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeAccountLimits(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::DescribeAccountLimitsAsync(const DescribeAccountLimitsRequest& request, const DescribeAccountLimitsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DescribeAccountLimitsAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::DescribeAccountLimitsAsyncHelper(const DescribeAccountLimitsRequest& request, const DescribeAccountLimitsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DescribeAccountLimits(request), context);
+}
+
+DescribeInstanceHealthOutcome ElasticLoadBalancingClient::DescribeInstanceHealth(const DescribeInstanceHealthRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DescribeInstanceHealthOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+DescribeInstanceHealthOutcomeCallable ElasticLoadBalancingClient::DescribeInstanceHealthCallable(const DescribeInstanceHealthRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DescribeInstanceHealthOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeInstanceHealth(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::DescribeInstanceHealthAsync(const DescribeInstanceHealthRequest& request, const DescribeInstanceHealthResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DescribeInstanceHealthAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::DescribeInstanceHealthAsyncHelper(const DescribeInstanceHealthRequest& request, const DescribeInstanceHealthResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DescribeInstanceHealth(request), context);
+}
+
+DescribeLoadBalancerAttributesOutcome ElasticLoadBalancingClient::DescribeLoadBalancerAttributes(const DescribeLoadBalancerAttributesRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DescribeLoadBalancerAttributesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+DescribeLoadBalancerAttributesOutcomeCallable ElasticLoadBalancingClient::DescribeLoadBalancerAttributesCallable(const DescribeLoadBalancerAttributesRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DescribeLoadBalancerAttributesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeLoadBalancerAttributes(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::DescribeLoadBalancerAttributesAsync(const DescribeLoadBalancerAttributesRequest& request, const DescribeLoadBalancerAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DescribeLoadBalancerAttributesAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::DescribeLoadBalancerAttributesAsyncHelper(const DescribeLoadBalancerAttributesRequest& request, const DescribeLoadBalancerAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DescribeLoadBalancerAttributes(request), context);
+}
+
+DescribeLoadBalancerPoliciesOutcome ElasticLoadBalancingClient::DescribeLoadBalancerPolicies(const DescribeLoadBalancerPoliciesRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DescribeLoadBalancerPoliciesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+DescribeLoadBalancerPoliciesOutcomeCallable ElasticLoadBalancingClient::DescribeLoadBalancerPoliciesCallable(const DescribeLoadBalancerPoliciesRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DescribeLoadBalancerPoliciesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeLoadBalancerPolicies(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::DescribeLoadBalancerPoliciesAsync(const DescribeLoadBalancerPoliciesRequest& request, const DescribeLoadBalancerPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DescribeLoadBalancerPoliciesAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::DescribeLoadBalancerPoliciesAsyncHelper(const DescribeLoadBalancerPoliciesRequest& request, const DescribeLoadBalancerPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DescribeLoadBalancerPolicies(request), context);
+}
+
+DescribeLoadBalancerPolicyTypesOutcome ElasticLoadBalancingClient::DescribeLoadBalancerPolicyTypes(const DescribeLoadBalancerPolicyTypesRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DescribeLoadBalancerPolicyTypesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+DescribeLoadBalancerPolicyTypesOutcomeCallable ElasticLoadBalancingClient::DescribeLoadBalancerPolicyTypesCallable(const DescribeLoadBalancerPolicyTypesRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DescribeLoadBalancerPolicyTypesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeLoadBalancerPolicyTypes(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::DescribeLoadBalancerPolicyTypesAsync(const DescribeLoadBalancerPolicyTypesRequest& request, const DescribeLoadBalancerPolicyTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DescribeLoadBalancerPolicyTypesAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::DescribeLoadBalancerPolicyTypesAsyncHelper(const DescribeLoadBalancerPolicyTypesRequest& request, const DescribeLoadBalancerPolicyTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DescribeLoadBalancerPolicyTypes(request), context);
+}
+
+DescribeLoadBalancersOutcome ElasticLoadBalancingClient::DescribeLoadBalancers(const DescribeLoadBalancersRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DescribeLoadBalancersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+DescribeLoadBalancersOutcomeCallable ElasticLoadBalancingClient::DescribeLoadBalancersCallable(const DescribeLoadBalancersRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DescribeLoadBalancersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeLoadBalancers(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::DescribeLoadBalancersAsync(const DescribeLoadBalancersRequest& request, const DescribeLoadBalancersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DescribeLoadBalancersAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::DescribeLoadBalancersAsyncHelper(const DescribeLoadBalancersRequest& request, const DescribeLoadBalancersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DescribeLoadBalancers(request), context);
+}
+
+DescribeTagsOutcome ElasticLoadBalancingClient::DescribeTags(const DescribeTagsRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DescribeTagsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+DescribeTagsOutcomeCallable ElasticLoadBalancingClient::DescribeTagsCallable(const DescribeTagsRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DescribeTagsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeTags(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::DescribeTagsAsync(const DescribeTagsRequest& request, const DescribeTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DescribeTagsAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::DescribeTagsAsyncHelper(const DescribeTagsRequest& request, const DescribeTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DescribeTags(request), context);
+}
+
+DetachLoadBalancerFromSubnetsOutcome ElasticLoadBalancingClient::DetachLoadBalancerFromSubnets(const DetachLoadBalancerFromSubnetsRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DetachLoadBalancerFromSubnetsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+DetachLoadBalancerFromSubnetsOutcomeCallable ElasticLoadBalancingClient::DetachLoadBalancerFromSubnetsCallable(const DetachLoadBalancerFromSubnetsRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DetachLoadBalancerFromSubnetsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DetachLoadBalancerFromSubnets(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::DetachLoadBalancerFromSubnetsAsync(const DetachLoadBalancerFromSubnetsRequest& request, const DetachLoadBalancerFromSubnetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DetachLoadBalancerFromSubnetsAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::DetachLoadBalancerFromSubnetsAsyncHelper(const DetachLoadBalancerFromSubnetsRequest& request, const DetachLoadBalancerFromSubnetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DetachLoadBalancerFromSubnets(request), context);
+}
+
+DisableAvailabilityZonesForLoadBalancerOutcome ElasticLoadBalancingClient::DisableAvailabilityZonesForLoadBalancer(const DisableAvailabilityZonesForLoadBalancerRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return DisableAvailabilityZonesForLoadBalancerOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+DisableAvailabilityZonesForLoadBalancerOutcomeCallable ElasticLoadBalancingClient::DisableAvailabilityZonesForLoadBalancerCallable(const DisableAvailabilityZonesForLoadBalancerRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< DisableAvailabilityZonesForLoadBalancerOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DisableAvailabilityZonesForLoadBalancer(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::DisableAvailabilityZonesForLoadBalancerAsync(const DisableAvailabilityZonesForLoadBalancerRequest& request, const DisableAvailabilityZonesForLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->DisableAvailabilityZonesForLoadBalancerAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::DisableAvailabilityZonesForLoadBalancerAsyncHelper(const DisableAvailabilityZonesForLoadBalancerRequest& request, const DisableAvailabilityZonesForLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, DisableAvailabilityZonesForLoadBalancer(request), context);
+}
+
+EnableAvailabilityZonesForLoadBalancerOutcome ElasticLoadBalancingClient::EnableAvailabilityZonesForLoadBalancer(const EnableAvailabilityZonesForLoadBalancerRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return EnableAvailabilityZonesForLoadBalancerOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+EnableAvailabilityZonesForLoadBalancerOutcomeCallable ElasticLoadBalancingClient::EnableAvailabilityZonesForLoadBalancerCallable(const EnableAvailabilityZonesForLoadBalancerRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< EnableAvailabilityZonesForLoadBalancerOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->EnableAvailabilityZonesForLoadBalancer(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::EnableAvailabilityZonesForLoadBalancerAsync(const EnableAvailabilityZonesForLoadBalancerRequest& request, const EnableAvailabilityZonesForLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->EnableAvailabilityZonesForLoadBalancerAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::EnableAvailabilityZonesForLoadBalancerAsyncHelper(const EnableAvailabilityZonesForLoadBalancerRequest& request, const EnableAvailabilityZonesForLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, EnableAvailabilityZonesForLoadBalancer(request), context);
+}
+
+ModifyLoadBalancerAttributesOutcome ElasticLoadBalancingClient::ModifyLoadBalancerAttributes(const ModifyLoadBalancerAttributesRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ModifyLoadBalancerAttributesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+ModifyLoadBalancerAttributesOutcomeCallable ElasticLoadBalancingClient::ModifyLoadBalancerAttributesCallable(const ModifyLoadBalancerAttributesRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< ModifyLoadBalancerAttributesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ModifyLoadBalancerAttributes(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::ModifyLoadBalancerAttributesAsync(const ModifyLoadBalancerAttributesRequest& request, const ModifyLoadBalancerAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->ModifyLoadBalancerAttributesAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::ModifyLoadBalancerAttributesAsyncHelper(const ModifyLoadBalancerAttributesRequest& request, const ModifyLoadBalancerAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ModifyLoadBalancerAttributes(request), context);
+}
+
+RegisterInstancesWithLoadBalancerOutcome ElasticLoadBalancingClient::RegisterInstancesWithLoadBalancer(const RegisterInstancesWithLoadBalancerRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return RegisterInstancesWithLoadBalancerOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+RegisterInstancesWithLoadBalancerOutcomeCallable ElasticLoadBalancingClient::RegisterInstancesWithLoadBalancerCallable(const RegisterInstancesWithLoadBalancerRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< RegisterInstancesWithLoadBalancerOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->RegisterInstancesWithLoadBalancer(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::RegisterInstancesWithLoadBalancerAsync(const RegisterInstancesWithLoadBalancerRequest& request, const RegisterInstancesWithLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->RegisterInstancesWithLoadBalancerAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::RegisterInstancesWithLoadBalancerAsyncHelper(const RegisterInstancesWithLoadBalancerRequest& request, const RegisterInstancesWithLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, RegisterInstancesWithLoadBalancer(request), context);
+}
+
+RemoveTagsOutcome ElasticLoadBalancingClient::RemoveTags(const RemoveTagsRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return RemoveTagsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+RemoveTagsOutcomeCallable ElasticLoadBalancingClient::RemoveTagsCallable(const RemoveTagsRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< RemoveTagsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->RemoveTags(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::RemoveTagsAsync(const RemoveTagsRequest& request, const RemoveTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->RemoveTagsAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::RemoveTagsAsyncHelper(const RemoveTagsRequest& request, const RemoveTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, RemoveTags(request), context);
+}
+
+SetLoadBalancerListenerSSLCertificateOutcome ElasticLoadBalancingClient::SetLoadBalancerListenerSSLCertificate(const SetLoadBalancerListenerSSLCertificateRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return SetLoadBalancerListenerSSLCertificateOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+SetLoadBalancerListenerSSLCertificateOutcomeCallable ElasticLoadBalancingClient::SetLoadBalancerListenerSSLCertificateCallable(const SetLoadBalancerListenerSSLCertificateRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< SetLoadBalancerListenerSSLCertificateOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->SetLoadBalancerListenerSSLCertificate(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::SetLoadBalancerListenerSSLCertificateAsync(const SetLoadBalancerListenerSSLCertificateRequest& request, const SetLoadBalancerListenerSSLCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->SetLoadBalancerListenerSSLCertificateAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::SetLoadBalancerListenerSSLCertificateAsyncHelper(const SetLoadBalancerListenerSSLCertificateRequest& request, const SetLoadBalancerListenerSSLCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, SetLoadBalancerListenerSSLCertificate(request), context);
+}
+
+SetLoadBalancerPoliciesForBackendServerOutcome ElasticLoadBalancingClient::SetLoadBalancerPoliciesForBackendServer(const SetLoadBalancerPoliciesForBackendServerRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return SetLoadBalancerPoliciesForBackendServerOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+SetLoadBalancerPoliciesForBackendServerOutcomeCallable ElasticLoadBalancingClient::SetLoadBalancerPoliciesForBackendServerCallable(const SetLoadBalancerPoliciesForBackendServerRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< SetLoadBalancerPoliciesForBackendServerOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->SetLoadBalancerPoliciesForBackendServer(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::SetLoadBalancerPoliciesForBackendServerAsync(const SetLoadBalancerPoliciesForBackendServerRequest& request, const SetLoadBalancerPoliciesForBackendServerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->SetLoadBalancerPoliciesForBackendServerAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::SetLoadBalancerPoliciesForBackendServerAsyncHelper(const SetLoadBalancerPoliciesForBackendServerRequest& request, const SetLoadBalancerPoliciesForBackendServerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, SetLoadBalancerPoliciesForBackendServer(request), context);
+}
+
+SetLoadBalancerPoliciesOfListenerOutcome ElasticLoadBalancingClient::SetLoadBalancerPoliciesOfListener(const SetLoadBalancerPoliciesOfListenerRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return SetLoadBalancerPoliciesOfListenerOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST));
+}
+
+SetLoadBalancerPoliciesOfListenerOutcomeCallable ElasticLoadBalancingClient::SetLoadBalancerPoliciesOfListenerCallable(const SetLoadBalancerPoliciesOfListenerRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< SetLoadBalancerPoliciesOfListenerOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->SetLoadBalancerPoliciesOfListener(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void ElasticLoadBalancingClient::SetLoadBalancerPoliciesOfListenerAsync(const SetLoadBalancerPoliciesOfListenerRequest& request, const SetLoadBalancerPoliciesOfListenerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->SetLoadBalancerPoliciesOfListenerAsyncHelper( request, handler, context ); } );
+}
+
+void ElasticLoadBalancingClient::SetLoadBalancerPoliciesOfListenerAsyncHelper(const SetLoadBalancerPoliciesOfListenerRequest& request, const SetLoadBalancerPoliciesOfListenerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, SetLoadBalancerPoliciesOfListener(request), context);
+}
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/ElasticLoadBalancingEndpoint.cpp

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

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

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/ElasticLoadBalancingErrors.cpp

@@ -0,0 +1,142 @@
+/**
+ * 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/elasticloadbalancing/ElasticLoadBalancingErrors.h>
+
+using namespace Aws::Client;
+using namespace Aws::Utils;
+using namespace Aws::ElasticLoadBalancing;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace ElasticLoadBalancingErrorMapper
+{
+
+static const int OPERATION_NOT_PERMITTED_HASH = HashingUtils::HashString("OperationNotPermitted");
+static const int INVALID_SUBNET_HASH = HashingUtils::HashString("InvalidSubnet");
+static const int INVALID_SCHEME_HASH = HashingUtils::HashString("InvalidScheme");
+static const int POLICY_TYPE_NOT_FOUND_HASH = HashingUtils::HashString("PolicyTypeNotFound");
+static const int DUPLICATE_ACCESS_POINT_NAME_HASH = HashingUtils::HashString("DuplicateLoadBalancerName");
+static const int INVALID_END_POINT_HASH = HashingUtils::HashString("InvalidInstance");
+static const int DUPLICATE_LISTENER_HASH = HashingUtils::HashString("DuplicateListener");
+static const int LOAD_BALANCER_ATTRIBUTE_NOT_FOUND_HASH = HashingUtils::HashString("LoadBalancerAttributeNotFound");
+static const int POLICY_NOT_FOUND_HASH = HashingUtils::HashString("PolicyNotFound");
+static const int TOO_MANY_ACCESS_POINTS_HASH = HashingUtils::HashString("TooManyLoadBalancers");
+static const int DUPLICATE_TAG_KEYS_HASH = HashingUtils::HashString("DuplicateTagKeys");
+static const int LISTENER_NOT_FOUND_HASH = HashingUtils::HashString("ListenerNotFound");
+static const int DUPLICATE_POLICY_NAME_HASH = HashingUtils::HashString("DuplicatePolicyName");
+static const int DEPENDENCY_THROTTLE_HASH = HashingUtils::HashString("DependencyThrottle");
+static const int INVALID_CONFIGURATION_REQUEST_HASH = HashingUtils::HashString("InvalidConfigurationRequest");
+static const int UNSUPPORTED_PROTOCOL_HASH = HashingUtils::HashString("UnsupportedProtocol");
+static const int ACCESS_POINT_NOT_FOUND_HASH = HashingUtils::HashString("LoadBalancerNotFound");
+static const int TOO_MANY_TAGS_HASH = HashingUtils::HashString("TooManyTags");
+static const int SUBNET_NOT_FOUND_HASH = HashingUtils::HashString("SubnetNotFound");
+static const int INVALID_SECURITY_GROUP_HASH = HashingUtils::HashString("InvalidSecurityGroup");
+static const int TOO_MANY_POLICIES_HASH = HashingUtils::HashString("TooManyPolicies");
+static const int CERTIFICATE_NOT_FOUND_HASH = HashingUtils::HashString("CertificateNotFound");
+
+
+AWSError<CoreErrors> GetErrorForName(const char* errorName)
+{
+  int hashCode = HashingUtils::HashString(errorName);
+
+  if (hashCode == OPERATION_NOT_PERMITTED_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::OPERATION_NOT_PERMITTED), false);
+  }
+  else if (hashCode == INVALID_SUBNET_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::INVALID_SUBNET), false);
+  }
+  else if (hashCode == INVALID_SCHEME_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::INVALID_SCHEME), false);
+  }
+  else if (hashCode == POLICY_TYPE_NOT_FOUND_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::POLICY_TYPE_NOT_FOUND), false);
+  }
+  else if (hashCode == DUPLICATE_ACCESS_POINT_NAME_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::DUPLICATE_ACCESS_POINT_NAME), false);
+  }
+  else if (hashCode == INVALID_END_POINT_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::INVALID_END_POINT), false);
+  }
+  else if (hashCode == DUPLICATE_LISTENER_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::DUPLICATE_LISTENER), false);
+  }
+  else if (hashCode == LOAD_BALANCER_ATTRIBUTE_NOT_FOUND_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::LOAD_BALANCER_ATTRIBUTE_NOT_FOUND), false);
+  }
+  else if (hashCode == POLICY_NOT_FOUND_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::POLICY_NOT_FOUND), false);
+  }
+  else if (hashCode == TOO_MANY_ACCESS_POINTS_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::TOO_MANY_ACCESS_POINTS), false);
+  }
+  else if (hashCode == DUPLICATE_TAG_KEYS_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::DUPLICATE_TAG_KEYS), false);
+  }
+  else if (hashCode == LISTENER_NOT_FOUND_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::LISTENER_NOT_FOUND), false);
+  }
+  else if (hashCode == DUPLICATE_POLICY_NAME_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::DUPLICATE_POLICY_NAME), false);
+  }
+  else if (hashCode == DEPENDENCY_THROTTLE_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::DEPENDENCY_THROTTLE), false);
+  }
+  else if (hashCode == INVALID_CONFIGURATION_REQUEST_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::INVALID_CONFIGURATION_REQUEST), false);
+  }
+  else if (hashCode == UNSUPPORTED_PROTOCOL_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::UNSUPPORTED_PROTOCOL), false);
+  }
+  else if (hashCode == ACCESS_POINT_NOT_FOUND_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::ACCESS_POINT_NOT_FOUND), false);
+  }
+  else if (hashCode == TOO_MANY_TAGS_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::TOO_MANY_TAGS), false);
+  }
+  else if (hashCode == SUBNET_NOT_FOUND_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::SUBNET_NOT_FOUND), false);
+  }
+  else if (hashCode == INVALID_SECURITY_GROUP_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::INVALID_SECURITY_GROUP), false);
+  }
+  else if (hashCode == TOO_MANY_POLICIES_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::TOO_MANY_POLICIES), false);
+  }
+  else if (hashCode == CERTIFICATE_NOT_FOUND_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(ElasticLoadBalancingErrors::CERTIFICATE_NOT_FOUND), false);
+  }
+  return AWSError<CoreErrors>(CoreErrors::UNKNOWN, false);
+}
+
+} // namespace ElasticLoadBalancingErrorMapper
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/AccessLog.cpp

@@ -0,0 +1,125 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/AccessLog.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+AccessLog::AccessLog() : 
+    m_enabled(false),
+    m_enabledHasBeenSet(false),
+    m_s3BucketNameHasBeenSet(false),
+    m_emitInterval(0),
+    m_emitIntervalHasBeenSet(false),
+    m_s3BucketPrefixHasBeenSet(false)
+{
+}
+
+AccessLog::AccessLog(const XmlNode& xmlNode) : 
+    m_enabled(false),
+    m_enabledHasBeenSet(false),
+    m_s3BucketNameHasBeenSet(false),
+    m_emitInterval(0),
+    m_emitIntervalHasBeenSet(false),
+    m_s3BucketPrefixHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+AccessLog& AccessLog::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode enabledNode = resultNode.FirstChild("Enabled");
+    if(!enabledNode.IsNull())
+    {
+      m_enabled = StringUtils::ConvertToBool(StringUtils::Trim(Aws::Utils::Xml::DecodeEscapedXmlText(enabledNode.GetText()).c_str()).c_str());
+      m_enabledHasBeenSet = true;
+    }
+    XmlNode s3BucketNameNode = resultNode.FirstChild("S3BucketName");
+    if(!s3BucketNameNode.IsNull())
+    {
+      m_s3BucketName = Aws::Utils::Xml::DecodeEscapedXmlText(s3BucketNameNode.GetText());
+      m_s3BucketNameHasBeenSet = true;
+    }
+    XmlNode emitIntervalNode = resultNode.FirstChild("EmitInterval");
+    if(!emitIntervalNode.IsNull())
+    {
+      m_emitInterval = StringUtils::ConvertToInt32(StringUtils::Trim(Aws::Utils::Xml::DecodeEscapedXmlText(emitIntervalNode.GetText()).c_str()).c_str());
+      m_emitIntervalHasBeenSet = true;
+    }
+    XmlNode s3BucketPrefixNode = resultNode.FirstChild("S3BucketPrefix");
+    if(!s3BucketPrefixNode.IsNull())
+    {
+      m_s3BucketPrefix = Aws::Utils::Xml::DecodeEscapedXmlText(s3BucketPrefixNode.GetText());
+      m_s3BucketPrefixHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void AccessLog::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_enabledHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".Enabled=" << std::boolalpha << m_enabled << "&";
+  }
+
+  if(m_s3BucketNameHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".S3BucketName=" << StringUtils::URLEncode(m_s3BucketName.c_str()) << "&";
+  }
+
+  if(m_emitIntervalHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".EmitInterval=" << m_emitInterval << "&";
+  }
+
+  if(m_s3BucketPrefixHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".S3BucketPrefix=" << StringUtils::URLEncode(m_s3BucketPrefix.c_str()) << "&";
+  }
+
+}
+
+void AccessLog::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_enabledHasBeenSet)
+  {
+      oStream << location << ".Enabled=" << std::boolalpha << m_enabled << "&";
+  }
+  if(m_s3BucketNameHasBeenSet)
+  {
+      oStream << location << ".S3BucketName=" << StringUtils::URLEncode(m_s3BucketName.c_str()) << "&";
+  }
+  if(m_emitIntervalHasBeenSet)
+  {
+      oStream << location << ".EmitInterval=" << m_emitInterval << "&";
+  }
+  if(m_s3BucketPrefixHasBeenSet)
+  {
+      oStream << location << ".S3BucketPrefix=" << StringUtils::URLEncode(m_s3BucketPrefix.c_str()) << "&";
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/AddTagsRequest.cpp

@@ -0,0 +1,52 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/AddTagsRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+AddTagsRequest::AddTagsRequest() : 
+    m_loadBalancerNamesHasBeenSet(false),
+    m_tagsHasBeenSet(false)
+{
+}
+
+Aws::String AddTagsRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=AddTags&";
+  if(m_loadBalancerNamesHasBeenSet)
+  {
+    unsigned loadBalancerNamesCount = 1;
+    for(auto& item : m_loadBalancerNames)
+    {
+      ss << "LoadBalancerNames.member." << loadBalancerNamesCount << "="
+          << StringUtils::URLEncode(item.c_str()) << "&";
+      loadBalancerNamesCount++;
+    }
+  }
+
+  if(m_tagsHasBeenSet)
+  {
+    unsigned tagsCount = 1;
+    for(auto& item : m_tags)
+    {
+      item.OutputToStream(ss, "Tags.member.", tagsCount, "");
+      tagsCount++;
+    }
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  AddTagsRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/AddTagsResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/AddTagsResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+AddTagsResult::AddTagsResult()
+{
+}
+
+AddTagsResult::AddTagsResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+AddTagsResult& AddTagsResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "AddTagsResult"))
+  {
+    resultNode = rootNode.FirstChild("AddTagsResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::AddTagsResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/AdditionalAttribute.cpp

@@ -0,0 +1,87 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/AdditionalAttribute.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+AdditionalAttribute::AdditionalAttribute() : 
+    m_keyHasBeenSet(false),
+    m_valueHasBeenSet(false)
+{
+}
+
+AdditionalAttribute::AdditionalAttribute(const XmlNode& xmlNode) : 
+    m_keyHasBeenSet(false),
+    m_valueHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+AdditionalAttribute& AdditionalAttribute::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode keyNode = resultNode.FirstChild("Key");
+    if(!keyNode.IsNull())
+    {
+      m_key = Aws::Utils::Xml::DecodeEscapedXmlText(keyNode.GetText());
+      m_keyHasBeenSet = true;
+    }
+    XmlNode valueNode = resultNode.FirstChild("Value");
+    if(!valueNode.IsNull())
+    {
+      m_value = Aws::Utils::Xml::DecodeEscapedXmlText(valueNode.GetText());
+      m_valueHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void AdditionalAttribute::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_keyHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".Key=" << StringUtils::URLEncode(m_key.c_str()) << "&";
+  }
+
+  if(m_valueHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".Value=" << StringUtils::URLEncode(m_value.c_str()) << "&";
+  }
+
+}
+
+void AdditionalAttribute::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_keyHasBeenSet)
+  {
+      oStream << location << ".Key=" << StringUtils::URLEncode(m_key.c_str()) << "&";
+  }
+  if(m_valueHasBeenSet)
+  {
+      oStream << location << ".Value=" << StringUtils::URLEncode(m_value.c_str()) << "&";
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/AppCookieStickinessPolicy.cpp

@@ -0,0 +1,87 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/AppCookieStickinessPolicy.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+AppCookieStickinessPolicy::AppCookieStickinessPolicy() : 
+    m_policyNameHasBeenSet(false),
+    m_cookieNameHasBeenSet(false)
+{
+}
+
+AppCookieStickinessPolicy::AppCookieStickinessPolicy(const XmlNode& xmlNode) : 
+    m_policyNameHasBeenSet(false),
+    m_cookieNameHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+AppCookieStickinessPolicy& AppCookieStickinessPolicy::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode policyNameNode = resultNode.FirstChild("PolicyName");
+    if(!policyNameNode.IsNull())
+    {
+      m_policyName = Aws::Utils::Xml::DecodeEscapedXmlText(policyNameNode.GetText());
+      m_policyNameHasBeenSet = true;
+    }
+    XmlNode cookieNameNode = resultNode.FirstChild("CookieName");
+    if(!cookieNameNode.IsNull())
+    {
+      m_cookieName = Aws::Utils::Xml::DecodeEscapedXmlText(cookieNameNode.GetText());
+      m_cookieNameHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void AppCookieStickinessPolicy::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_policyNameHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".PolicyName=" << StringUtils::URLEncode(m_policyName.c_str()) << "&";
+  }
+
+  if(m_cookieNameHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".CookieName=" << StringUtils::URLEncode(m_cookieName.c_str()) << "&";
+  }
+
+}
+
+void AppCookieStickinessPolicy::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_policyNameHasBeenSet)
+  {
+      oStream << location << ".PolicyName=" << StringUtils::URLEncode(m_policyName.c_str()) << "&";
+  }
+  if(m_cookieNameHasBeenSet)
+  {
+      oStream << location << ".CookieName=" << StringUtils::URLEncode(m_cookieName.c_str()) << "&";
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/ApplySecurityGroupsToLoadBalancerRequest.cpp

@@ -0,0 +1,47 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/ApplySecurityGroupsToLoadBalancerRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+ApplySecurityGroupsToLoadBalancerRequest::ApplySecurityGroupsToLoadBalancerRequest() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_securityGroupsHasBeenSet(false)
+{
+}
+
+Aws::String ApplySecurityGroupsToLoadBalancerRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=ApplySecurityGroupsToLoadBalancer&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_securityGroupsHasBeenSet)
+  {
+    unsigned securityGroupsCount = 1;
+    for(auto& item : m_securityGroups)
+    {
+      ss << "SecurityGroups.member." << securityGroupsCount << "="
+          << StringUtils::URLEncode(item.c_str()) << "&";
+      securityGroupsCount++;
+    }
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  ApplySecurityGroupsToLoadBalancerRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/ApplySecurityGroupsToLoadBalancerResult.cpp

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/ApplySecurityGroupsToLoadBalancerResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+ApplySecurityGroupsToLoadBalancerResult::ApplySecurityGroupsToLoadBalancerResult()
+{
+}
+
+ApplySecurityGroupsToLoadBalancerResult::ApplySecurityGroupsToLoadBalancerResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+ApplySecurityGroupsToLoadBalancerResult& ApplySecurityGroupsToLoadBalancerResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "ApplySecurityGroupsToLoadBalancerResult"))
+  {
+    resultNode = rootNode.FirstChild("ApplySecurityGroupsToLoadBalancerResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode securityGroupsNode = resultNode.FirstChild("SecurityGroups");
+    if(!securityGroupsNode.IsNull())
+    {
+      XmlNode securityGroupsMember = securityGroupsNode.FirstChild("member");
+      while(!securityGroupsMember.IsNull())
+      {
+        m_securityGroups.push_back(securityGroupsMember.GetText());
+        securityGroupsMember = securityGroupsMember.NextNode("member");
+      }
+
+    }
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::ApplySecurityGroupsToLoadBalancerResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/AttachLoadBalancerToSubnetsRequest.cpp

@@ -0,0 +1,47 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/AttachLoadBalancerToSubnetsRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+AttachLoadBalancerToSubnetsRequest::AttachLoadBalancerToSubnetsRequest() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_subnetsHasBeenSet(false)
+{
+}
+
+Aws::String AttachLoadBalancerToSubnetsRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=AttachLoadBalancerToSubnets&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_subnetsHasBeenSet)
+  {
+    unsigned subnetsCount = 1;
+    for(auto& item : m_subnets)
+    {
+      ss << "Subnets.member." << subnetsCount << "="
+          << StringUtils::URLEncode(item.c_str()) << "&";
+      subnetsCount++;
+    }
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  AttachLoadBalancerToSubnetsRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/AttachLoadBalancerToSubnetsResult.cpp

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/AttachLoadBalancerToSubnetsResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+AttachLoadBalancerToSubnetsResult::AttachLoadBalancerToSubnetsResult()
+{
+}
+
+AttachLoadBalancerToSubnetsResult::AttachLoadBalancerToSubnetsResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+AttachLoadBalancerToSubnetsResult& AttachLoadBalancerToSubnetsResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "AttachLoadBalancerToSubnetsResult"))
+  {
+    resultNode = rootNode.FirstChild("AttachLoadBalancerToSubnetsResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode subnetsNode = resultNode.FirstChild("Subnets");
+    if(!subnetsNode.IsNull())
+    {
+      XmlNode subnetsMember = subnetsNode.FirstChild("member");
+      while(!subnetsMember.IsNull())
+      {
+        m_subnets.push_back(subnetsMember.GetText());
+        subnetsMember = subnetsMember.NextNode("member");
+      }
+
+    }
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::AttachLoadBalancerToSubnetsResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/BackendServerDescription.cpp

@@ -0,0 +1,103 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/BackendServerDescription.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+BackendServerDescription::BackendServerDescription() : 
+    m_instancePort(0),
+    m_instancePortHasBeenSet(false),
+    m_policyNamesHasBeenSet(false)
+{
+}
+
+BackendServerDescription::BackendServerDescription(const XmlNode& xmlNode) : 
+    m_instancePort(0),
+    m_instancePortHasBeenSet(false),
+    m_policyNamesHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+BackendServerDescription& BackendServerDescription::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode instancePortNode = resultNode.FirstChild("InstancePort");
+    if(!instancePortNode.IsNull())
+    {
+      m_instancePort = StringUtils::ConvertToInt32(StringUtils::Trim(Aws::Utils::Xml::DecodeEscapedXmlText(instancePortNode.GetText()).c_str()).c_str());
+      m_instancePortHasBeenSet = true;
+    }
+    XmlNode policyNamesNode = resultNode.FirstChild("PolicyNames");
+    if(!policyNamesNode.IsNull())
+    {
+      XmlNode policyNamesMember = policyNamesNode.FirstChild("member");
+      while(!policyNamesMember.IsNull())
+      {
+        m_policyNames.push_back(policyNamesMember.GetText());
+        policyNamesMember = policyNamesMember.NextNode("member");
+      }
+
+      m_policyNamesHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void BackendServerDescription::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_instancePortHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".InstancePort=" << m_instancePort << "&";
+  }
+
+  if(m_policyNamesHasBeenSet)
+  {
+      unsigned policyNamesIdx = 1;
+      for(auto& item : m_policyNames)
+      {
+        oStream << location << index << locationValue << ".PolicyNames.member." << policyNamesIdx++ << "=" << StringUtils::URLEncode(item.c_str()) << "&";
+      }
+  }
+
+}
+
+void BackendServerDescription::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_instancePortHasBeenSet)
+  {
+      oStream << location << ".InstancePort=" << m_instancePort << "&";
+  }
+  if(m_policyNamesHasBeenSet)
+  {
+      unsigned policyNamesIdx = 1;
+      for(auto& item : m_policyNames)
+      {
+        oStream << location << ".PolicyNames.member." << policyNamesIdx++ << "=" << StringUtils::URLEncode(item.c_str()) << "&";
+      }
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/ConfigureHealthCheckRequest.cpp

@@ -0,0 +1,41 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/ConfigureHealthCheckRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+ConfigureHealthCheckRequest::ConfigureHealthCheckRequest() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_healthCheckHasBeenSet(false)
+{
+}
+
+Aws::String ConfigureHealthCheckRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=ConfigureHealthCheck&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_healthCheckHasBeenSet)
+  {
+    m_healthCheck.OutputToStream(ss, "HealthCheck");
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  ConfigureHealthCheckRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/ConfigureHealthCheckResult.cpp

@@ -0,0 +1,54 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/ConfigureHealthCheckResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+ConfigureHealthCheckResult::ConfigureHealthCheckResult()
+{
+}
+
+ConfigureHealthCheckResult::ConfigureHealthCheckResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+ConfigureHealthCheckResult& ConfigureHealthCheckResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "ConfigureHealthCheckResult"))
+  {
+    resultNode = rootNode.FirstChild("ConfigureHealthCheckResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode healthCheckNode = resultNode.FirstChild("HealthCheck");
+    if(!healthCheckNode.IsNull())
+    {
+      m_healthCheck = healthCheckNode;
+    }
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::ConfigureHealthCheckResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/ConnectionDraining.cpp

@@ -0,0 +1,91 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/ConnectionDraining.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+ConnectionDraining::ConnectionDraining() : 
+    m_enabled(false),
+    m_enabledHasBeenSet(false),
+    m_timeout(0),
+    m_timeoutHasBeenSet(false)
+{
+}
+
+ConnectionDraining::ConnectionDraining(const XmlNode& xmlNode) : 
+    m_enabled(false),
+    m_enabledHasBeenSet(false),
+    m_timeout(0),
+    m_timeoutHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+ConnectionDraining& ConnectionDraining::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode enabledNode = resultNode.FirstChild("Enabled");
+    if(!enabledNode.IsNull())
+    {
+      m_enabled = StringUtils::ConvertToBool(StringUtils::Trim(Aws::Utils::Xml::DecodeEscapedXmlText(enabledNode.GetText()).c_str()).c_str());
+      m_enabledHasBeenSet = true;
+    }
+    XmlNode timeoutNode = resultNode.FirstChild("Timeout");
+    if(!timeoutNode.IsNull())
+    {
+      m_timeout = StringUtils::ConvertToInt32(StringUtils::Trim(Aws::Utils::Xml::DecodeEscapedXmlText(timeoutNode.GetText()).c_str()).c_str());
+      m_timeoutHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void ConnectionDraining::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_enabledHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".Enabled=" << std::boolalpha << m_enabled << "&";
+  }
+
+  if(m_timeoutHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".Timeout=" << m_timeout << "&";
+  }
+
+}
+
+void ConnectionDraining::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_enabledHasBeenSet)
+  {
+      oStream << location << ".Enabled=" << std::boolalpha << m_enabled << "&";
+  }
+  if(m_timeoutHasBeenSet)
+  {
+      oStream << location << ".Timeout=" << m_timeout << "&";
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/ConnectionSettings.cpp

@@ -0,0 +1,72 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/ConnectionSettings.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+ConnectionSettings::ConnectionSettings() : 
+    m_idleTimeout(0),
+    m_idleTimeoutHasBeenSet(false)
+{
+}
+
+ConnectionSettings::ConnectionSettings(const XmlNode& xmlNode) : 
+    m_idleTimeout(0),
+    m_idleTimeoutHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+ConnectionSettings& ConnectionSettings::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode idleTimeoutNode = resultNode.FirstChild("IdleTimeout");
+    if(!idleTimeoutNode.IsNull())
+    {
+      m_idleTimeout = StringUtils::ConvertToInt32(StringUtils::Trim(Aws::Utils::Xml::DecodeEscapedXmlText(idleTimeoutNode.GetText()).c_str()).c_str());
+      m_idleTimeoutHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void ConnectionSettings::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_idleTimeoutHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".IdleTimeout=" << m_idleTimeout << "&";
+  }
+
+}
+
+void ConnectionSettings::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_idleTimeoutHasBeenSet)
+  {
+      oStream << location << ".IdleTimeout=" << m_idleTimeout << "&";
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/CreateAppCookieStickinessPolicyRequest.cpp

@@ -0,0 +1,47 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/CreateAppCookieStickinessPolicyRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+CreateAppCookieStickinessPolicyRequest::CreateAppCookieStickinessPolicyRequest() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_policyNameHasBeenSet(false),
+    m_cookieNameHasBeenSet(false)
+{
+}
+
+Aws::String CreateAppCookieStickinessPolicyRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=CreateAppCookieStickinessPolicy&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_policyNameHasBeenSet)
+  {
+    ss << "PolicyName=" << StringUtils::URLEncode(m_policyName.c_str()) << "&";
+  }
+
+  if(m_cookieNameHasBeenSet)
+  {
+    ss << "CookieName=" << StringUtils::URLEncode(m_cookieName.c_str()) << "&";
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  CreateAppCookieStickinessPolicyRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/CreateAppCookieStickinessPolicyResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/CreateAppCookieStickinessPolicyResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+CreateAppCookieStickinessPolicyResult::CreateAppCookieStickinessPolicyResult()
+{
+}
+
+CreateAppCookieStickinessPolicyResult::CreateAppCookieStickinessPolicyResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+CreateAppCookieStickinessPolicyResult& CreateAppCookieStickinessPolicyResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "CreateAppCookieStickinessPolicyResult"))
+  {
+    resultNode = rootNode.FirstChild("CreateAppCookieStickinessPolicyResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::CreateAppCookieStickinessPolicyResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/CreateLBCookieStickinessPolicyRequest.cpp

@@ -0,0 +1,48 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/CreateLBCookieStickinessPolicyRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+CreateLBCookieStickinessPolicyRequest::CreateLBCookieStickinessPolicyRequest() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_policyNameHasBeenSet(false),
+    m_cookieExpirationPeriod(0),
+    m_cookieExpirationPeriodHasBeenSet(false)
+{
+}
+
+Aws::String CreateLBCookieStickinessPolicyRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=CreateLBCookieStickinessPolicy&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_policyNameHasBeenSet)
+  {
+    ss << "PolicyName=" << StringUtils::URLEncode(m_policyName.c_str()) << "&";
+  }
+
+  if(m_cookieExpirationPeriodHasBeenSet)
+  {
+    ss << "CookieExpirationPeriod=" << m_cookieExpirationPeriod << "&";
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  CreateLBCookieStickinessPolicyRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/CreateLBCookieStickinessPolicyResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/CreateLBCookieStickinessPolicyResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+CreateLBCookieStickinessPolicyResult::CreateLBCookieStickinessPolicyResult()
+{
+}
+
+CreateLBCookieStickinessPolicyResult::CreateLBCookieStickinessPolicyResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+CreateLBCookieStickinessPolicyResult& CreateLBCookieStickinessPolicyResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "CreateLBCookieStickinessPolicyResult"))
+  {
+    resultNode = rootNode.FirstChild("CreateLBCookieStickinessPolicyResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::CreateLBCookieStickinessPolicyResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/CreateLoadBalancerListenersRequest.cpp

@@ -0,0 +1,46 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/CreateLoadBalancerListenersRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+CreateLoadBalancerListenersRequest::CreateLoadBalancerListenersRequest() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_listenersHasBeenSet(false)
+{
+}
+
+Aws::String CreateLoadBalancerListenersRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=CreateLoadBalancerListeners&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_listenersHasBeenSet)
+  {
+    unsigned listenersCount = 1;
+    for(auto& item : m_listeners)
+    {
+      item.OutputToStream(ss, "Listeners.member.", listenersCount, "");
+      listenersCount++;
+    }
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  CreateLoadBalancerListenersRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/CreateLoadBalancerListenersResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/CreateLoadBalancerListenersResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+CreateLoadBalancerListenersResult::CreateLoadBalancerListenersResult()
+{
+}
+
+CreateLoadBalancerListenersResult::CreateLoadBalancerListenersResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+CreateLoadBalancerListenersResult& CreateLoadBalancerListenersResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "CreateLoadBalancerListenersResult"))
+  {
+    resultNode = rootNode.FirstChild("CreateLoadBalancerListenersResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::CreateLoadBalancerListenersResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/CreateLoadBalancerPolicyRequest.cpp

@@ -0,0 +1,58 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/CreateLoadBalancerPolicyRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+CreateLoadBalancerPolicyRequest::CreateLoadBalancerPolicyRequest() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_policyNameHasBeenSet(false),
+    m_policyTypeNameHasBeenSet(false),
+    m_policyAttributesHasBeenSet(false)
+{
+}
+
+Aws::String CreateLoadBalancerPolicyRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=CreateLoadBalancerPolicy&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_policyNameHasBeenSet)
+  {
+    ss << "PolicyName=" << StringUtils::URLEncode(m_policyName.c_str()) << "&";
+  }
+
+  if(m_policyTypeNameHasBeenSet)
+  {
+    ss << "PolicyTypeName=" << StringUtils::URLEncode(m_policyTypeName.c_str()) << "&";
+  }
+
+  if(m_policyAttributesHasBeenSet)
+  {
+    unsigned policyAttributesCount = 1;
+    for(auto& item : m_policyAttributes)
+    {
+      item.OutputToStream(ss, "PolicyAttributes.member.", policyAttributesCount, "");
+      policyAttributesCount++;
+    }
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  CreateLoadBalancerPolicyRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/CreateLoadBalancerPolicyResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/CreateLoadBalancerPolicyResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+CreateLoadBalancerPolicyResult::CreateLoadBalancerPolicyResult()
+{
+}
+
+CreateLoadBalancerPolicyResult::CreateLoadBalancerPolicyResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+CreateLoadBalancerPolicyResult& CreateLoadBalancerPolicyResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "CreateLoadBalancerPolicyResult"))
+  {
+    resultNode = rootNode.FirstChild("CreateLoadBalancerPolicyResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::CreateLoadBalancerPolicyResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/CreateLoadBalancerRequest.cpp

@@ -0,0 +1,99 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/CreateLoadBalancerRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+CreateLoadBalancerRequest::CreateLoadBalancerRequest() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_listenersHasBeenSet(false),
+    m_availabilityZonesHasBeenSet(false),
+    m_subnetsHasBeenSet(false),
+    m_securityGroupsHasBeenSet(false),
+    m_schemeHasBeenSet(false),
+    m_tagsHasBeenSet(false)
+{
+}
+
+Aws::String CreateLoadBalancerRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=CreateLoadBalancer&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_listenersHasBeenSet)
+  {
+    unsigned listenersCount = 1;
+    for(auto& item : m_listeners)
+    {
+      item.OutputToStream(ss, "Listeners.member.", listenersCount, "");
+      listenersCount++;
+    }
+  }
+
+  if(m_availabilityZonesHasBeenSet)
+  {
+    unsigned availabilityZonesCount = 1;
+    for(auto& item : m_availabilityZones)
+    {
+      ss << "AvailabilityZones.member." << availabilityZonesCount << "="
+          << StringUtils::URLEncode(item.c_str()) << "&";
+      availabilityZonesCount++;
+    }
+  }
+
+  if(m_subnetsHasBeenSet)
+  {
+    unsigned subnetsCount = 1;
+    for(auto& item : m_subnets)
+    {
+      ss << "Subnets.member." << subnetsCount << "="
+          << StringUtils::URLEncode(item.c_str()) << "&";
+      subnetsCount++;
+    }
+  }
+
+  if(m_securityGroupsHasBeenSet)
+  {
+    unsigned securityGroupsCount = 1;
+    for(auto& item : m_securityGroups)
+    {
+      ss << "SecurityGroups.member." << securityGroupsCount << "="
+          << StringUtils::URLEncode(item.c_str()) << "&";
+      securityGroupsCount++;
+    }
+  }
+
+  if(m_schemeHasBeenSet)
+  {
+    ss << "Scheme=" << StringUtils::URLEncode(m_scheme.c_str()) << "&";
+  }
+
+  if(m_tagsHasBeenSet)
+  {
+    unsigned tagsCount = 1;
+    for(auto& item : m_tags)
+    {
+      item.OutputToStream(ss, "Tags.member.", tagsCount, "");
+      tagsCount++;
+    }
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  CreateLoadBalancerRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/CreateLoadBalancerResult.cpp

@@ -0,0 +1,54 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/CreateLoadBalancerResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+CreateLoadBalancerResult::CreateLoadBalancerResult()
+{
+}
+
+CreateLoadBalancerResult::CreateLoadBalancerResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+CreateLoadBalancerResult& CreateLoadBalancerResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "CreateLoadBalancerResult"))
+  {
+    resultNode = rootNode.FirstChild("CreateLoadBalancerResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode dNSNameNode = resultNode.FirstChild("DNSName");
+    if(!dNSNameNode.IsNull())
+    {
+      m_dNSName = Aws::Utils::Xml::DecodeEscapedXmlText(dNSNameNode.GetText());
+    }
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::CreateLoadBalancerResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/CrossZoneLoadBalancing.cpp

@@ -0,0 +1,72 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/CrossZoneLoadBalancing.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+CrossZoneLoadBalancing::CrossZoneLoadBalancing() : 
+    m_enabled(false),
+    m_enabledHasBeenSet(false)
+{
+}
+
+CrossZoneLoadBalancing::CrossZoneLoadBalancing(const XmlNode& xmlNode) : 
+    m_enabled(false),
+    m_enabledHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+CrossZoneLoadBalancing& CrossZoneLoadBalancing::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode enabledNode = resultNode.FirstChild("Enabled");
+    if(!enabledNode.IsNull())
+    {
+      m_enabled = StringUtils::ConvertToBool(StringUtils::Trim(Aws::Utils::Xml::DecodeEscapedXmlText(enabledNode.GetText()).c_str()).c_str());
+      m_enabledHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void CrossZoneLoadBalancing::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_enabledHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".Enabled=" << std::boolalpha << m_enabled << "&";
+  }
+
+}
+
+void CrossZoneLoadBalancing::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_enabledHasBeenSet)
+  {
+      oStream << location << ".Enabled=" << std::boolalpha << m_enabled << "&";
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DeleteLoadBalancerListenersRequest.cpp

@@ -0,0 +1,47 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DeleteLoadBalancerListenersRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+DeleteLoadBalancerListenersRequest::DeleteLoadBalancerListenersRequest() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_loadBalancerPortsHasBeenSet(false)
+{
+}
+
+Aws::String DeleteLoadBalancerListenersRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=DeleteLoadBalancerListeners&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_loadBalancerPortsHasBeenSet)
+  {
+    unsigned loadBalancerPortsCount = 1;
+    for(auto& item : m_loadBalancerPorts)
+    {
+      ss << "LoadBalancerPorts.member." << loadBalancerPortsCount << "="
+          << item << "&";
+      loadBalancerPortsCount++;
+    }
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  DeleteLoadBalancerListenersRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DeleteLoadBalancerListenersResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DeleteLoadBalancerListenersResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+DeleteLoadBalancerListenersResult::DeleteLoadBalancerListenersResult()
+{
+}
+
+DeleteLoadBalancerListenersResult::DeleteLoadBalancerListenersResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+DeleteLoadBalancerListenersResult& DeleteLoadBalancerListenersResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "DeleteLoadBalancerListenersResult"))
+  {
+    resultNode = rootNode.FirstChild("DeleteLoadBalancerListenersResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::DeleteLoadBalancerListenersResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DeleteLoadBalancerPolicyRequest.cpp

@@ -0,0 +1,41 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DeleteLoadBalancerPolicyRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+DeleteLoadBalancerPolicyRequest::DeleteLoadBalancerPolicyRequest() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_policyNameHasBeenSet(false)
+{
+}
+
+Aws::String DeleteLoadBalancerPolicyRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=DeleteLoadBalancerPolicy&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_policyNameHasBeenSet)
+  {
+    ss << "PolicyName=" << StringUtils::URLEncode(m_policyName.c_str()) << "&";
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  DeleteLoadBalancerPolicyRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DeleteLoadBalancerPolicyResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DeleteLoadBalancerPolicyResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+DeleteLoadBalancerPolicyResult::DeleteLoadBalancerPolicyResult()
+{
+}
+
+DeleteLoadBalancerPolicyResult::DeleteLoadBalancerPolicyResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+DeleteLoadBalancerPolicyResult& DeleteLoadBalancerPolicyResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "DeleteLoadBalancerPolicyResult"))
+  {
+    resultNode = rootNode.FirstChild("DeleteLoadBalancerPolicyResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::DeleteLoadBalancerPolicyResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DeleteLoadBalancerRequest.cpp

@@ -0,0 +1,35 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DeleteLoadBalancerRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+DeleteLoadBalancerRequest::DeleteLoadBalancerRequest() : 
+    m_loadBalancerNameHasBeenSet(false)
+{
+}
+
+Aws::String DeleteLoadBalancerRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=DeleteLoadBalancer&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  DeleteLoadBalancerRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DeleteLoadBalancerResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DeleteLoadBalancerResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+DeleteLoadBalancerResult::DeleteLoadBalancerResult()
+{
+}
+
+DeleteLoadBalancerResult::DeleteLoadBalancerResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+DeleteLoadBalancerResult& DeleteLoadBalancerResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "DeleteLoadBalancerResult"))
+  {
+    resultNode = rootNode.FirstChild("DeleteLoadBalancerResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::DeleteLoadBalancerResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DeregisterInstancesFromLoadBalancerRequest.cpp

@@ -0,0 +1,46 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DeregisterInstancesFromLoadBalancerRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+DeregisterInstancesFromLoadBalancerRequest::DeregisterInstancesFromLoadBalancerRequest() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_instancesHasBeenSet(false)
+{
+}
+
+Aws::String DeregisterInstancesFromLoadBalancerRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=DeregisterInstancesFromLoadBalancer&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_instancesHasBeenSet)
+  {
+    unsigned instancesCount = 1;
+    for(auto& item : m_instances)
+    {
+      item.OutputToStream(ss, "Instances.member.", instancesCount, "");
+      instancesCount++;
+    }
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  DeregisterInstancesFromLoadBalancerRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DeregisterInstancesFromLoadBalancerResult.cpp

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DeregisterInstancesFromLoadBalancerResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+DeregisterInstancesFromLoadBalancerResult::DeregisterInstancesFromLoadBalancerResult()
+{
+}
+
+DeregisterInstancesFromLoadBalancerResult::DeregisterInstancesFromLoadBalancerResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+DeregisterInstancesFromLoadBalancerResult& DeregisterInstancesFromLoadBalancerResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "DeregisterInstancesFromLoadBalancerResult"))
+  {
+    resultNode = rootNode.FirstChild("DeregisterInstancesFromLoadBalancerResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode instancesNode = resultNode.FirstChild("Instances");
+    if(!instancesNode.IsNull())
+    {
+      XmlNode instancesMember = instancesNode.FirstChild("member");
+      while(!instancesMember.IsNull())
+      {
+        m_instances.push_back(instancesMember);
+        instancesMember = instancesMember.NextNode("member");
+      }
+
+    }
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::DeregisterInstancesFromLoadBalancerResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DescribeAccountLimitsRequest.cpp

@@ -0,0 +1,42 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DescribeAccountLimitsRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+DescribeAccountLimitsRequest::DescribeAccountLimitsRequest() : 
+    m_markerHasBeenSet(false),
+    m_pageSize(0),
+    m_pageSizeHasBeenSet(false)
+{
+}
+
+Aws::String DescribeAccountLimitsRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=DescribeAccountLimits&";
+  if(m_markerHasBeenSet)
+  {
+    ss << "Marker=" << StringUtils::URLEncode(m_marker.c_str()) << "&";
+  }
+
+  if(m_pageSizeHasBeenSet)
+  {
+    ss << "PageSize=" << m_pageSize << "&";
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  DescribeAccountLimitsRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DescribeAccountLimitsResult.cpp

@@ -0,0 +1,65 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DescribeAccountLimitsResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+DescribeAccountLimitsResult::DescribeAccountLimitsResult()
+{
+}
+
+DescribeAccountLimitsResult::DescribeAccountLimitsResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+DescribeAccountLimitsResult& DescribeAccountLimitsResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "DescribeAccountLimitsResult"))
+  {
+    resultNode = rootNode.FirstChild("DescribeAccountLimitsResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode limitsNode = resultNode.FirstChild("Limits");
+    if(!limitsNode.IsNull())
+    {
+      XmlNode limitsMember = limitsNode.FirstChild("member");
+      while(!limitsMember.IsNull())
+      {
+        m_limits.push_back(limitsMember);
+        limitsMember = limitsMember.NextNode("member");
+      }
+
+    }
+    XmlNode nextMarkerNode = resultNode.FirstChild("NextMarker");
+    if(!nextMarkerNode.IsNull())
+    {
+      m_nextMarker = Aws::Utils::Xml::DecodeEscapedXmlText(nextMarkerNode.GetText());
+    }
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::DescribeAccountLimitsResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DescribeInstanceHealthRequest.cpp

@@ -0,0 +1,46 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DescribeInstanceHealthRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+DescribeInstanceHealthRequest::DescribeInstanceHealthRequest() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_instancesHasBeenSet(false)
+{
+}
+
+Aws::String DescribeInstanceHealthRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=DescribeInstanceHealth&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_instancesHasBeenSet)
+  {
+    unsigned instancesCount = 1;
+    for(auto& item : m_instances)
+    {
+      item.OutputToStream(ss, "Instances.member.", instancesCount, "");
+      instancesCount++;
+    }
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  DescribeInstanceHealthRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DescribeInstanceHealthResult.cpp

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DescribeInstanceHealthResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+DescribeInstanceHealthResult::DescribeInstanceHealthResult()
+{
+}
+
+DescribeInstanceHealthResult::DescribeInstanceHealthResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+DescribeInstanceHealthResult& DescribeInstanceHealthResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "DescribeInstanceHealthResult"))
+  {
+    resultNode = rootNode.FirstChild("DescribeInstanceHealthResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode instanceStatesNode = resultNode.FirstChild("InstanceStates");
+    if(!instanceStatesNode.IsNull())
+    {
+      XmlNode instanceStatesMember = instanceStatesNode.FirstChild("member");
+      while(!instanceStatesMember.IsNull())
+      {
+        m_instanceStates.push_back(instanceStatesMember);
+        instanceStatesMember = instanceStatesMember.NextNode("member");
+      }
+
+    }
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::DescribeInstanceHealthResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DescribeLoadBalancerAttributesRequest.cpp

@@ -0,0 +1,35 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DescribeLoadBalancerAttributesRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+DescribeLoadBalancerAttributesRequest::DescribeLoadBalancerAttributesRequest() : 
+    m_loadBalancerNameHasBeenSet(false)
+{
+}
+
+Aws::String DescribeLoadBalancerAttributesRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=DescribeLoadBalancerAttributes&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  DescribeLoadBalancerAttributesRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DescribeLoadBalancerAttributesResult.cpp

@@ -0,0 +1,54 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DescribeLoadBalancerAttributesResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+DescribeLoadBalancerAttributesResult::DescribeLoadBalancerAttributesResult()
+{
+}
+
+DescribeLoadBalancerAttributesResult::DescribeLoadBalancerAttributesResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+DescribeLoadBalancerAttributesResult& DescribeLoadBalancerAttributesResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "DescribeLoadBalancerAttributesResult"))
+  {
+    resultNode = rootNode.FirstChild("DescribeLoadBalancerAttributesResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode loadBalancerAttributesNode = resultNode.FirstChild("LoadBalancerAttributes");
+    if(!loadBalancerAttributesNode.IsNull())
+    {
+      m_loadBalancerAttributes = loadBalancerAttributesNode;
+    }
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::DescribeLoadBalancerAttributesResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DescribeLoadBalancerPoliciesRequest.cpp

@@ -0,0 +1,47 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DescribeLoadBalancerPoliciesRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+DescribeLoadBalancerPoliciesRequest::DescribeLoadBalancerPoliciesRequest() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_policyNamesHasBeenSet(false)
+{
+}
+
+Aws::String DescribeLoadBalancerPoliciesRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=DescribeLoadBalancerPolicies&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_policyNamesHasBeenSet)
+  {
+    unsigned policyNamesCount = 1;
+    for(auto& item : m_policyNames)
+    {
+      ss << "PolicyNames.member." << policyNamesCount << "="
+          << StringUtils::URLEncode(item.c_str()) << "&";
+      policyNamesCount++;
+    }
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  DescribeLoadBalancerPoliciesRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DescribeLoadBalancerPoliciesResult.cpp

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DescribeLoadBalancerPoliciesResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+DescribeLoadBalancerPoliciesResult::DescribeLoadBalancerPoliciesResult()
+{
+}
+
+DescribeLoadBalancerPoliciesResult::DescribeLoadBalancerPoliciesResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+DescribeLoadBalancerPoliciesResult& DescribeLoadBalancerPoliciesResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "DescribeLoadBalancerPoliciesResult"))
+  {
+    resultNode = rootNode.FirstChild("DescribeLoadBalancerPoliciesResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode policyDescriptionsNode = resultNode.FirstChild("PolicyDescriptions");
+    if(!policyDescriptionsNode.IsNull())
+    {
+      XmlNode policyDescriptionsMember = policyDescriptionsNode.FirstChild("member");
+      while(!policyDescriptionsMember.IsNull())
+      {
+        m_policyDescriptions.push_back(policyDescriptionsMember);
+        policyDescriptionsMember = policyDescriptionsMember.NextNode("member");
+      }
+
+    }
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::DescribeLoadBalancerPoliciesResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DescribeLoadBalancerPolicyTypesRequest.cpp

@@ -0,0 +1,41 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DescribeLoadBalancerPolicyTypesRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+DescribeLoadBalancerPolicyTypesRequest::DescribeLoadBalancerPolicyTypesRequest() : 
+    m_policyTypeNamesHasBeenSet(false)
+{
+}
+
+Aws::String DescribeLoadBalancerPolicyTypesRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=DescribeLoadBalancerPolicyTypes&";
+  if(m_policyTypeNamesHasBeenSet)
+  {
+    unsigned policyTypeNamesCount = 1;
+    for(auto& item : m_policyTypeNames)
+    {
+      ss << "PolicyTypeNames.member." << policyTypeNamesCount << "="
+          << StringUtils::URLEncode(item.c_str()) << "&";
+      policyTypeNamesCount++;
+    }
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  DescribeLoadBalancerPolicyTypesRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DescribeLoadBalancerPolicyTypesResult.cpp

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DescribeLoadBalancerPolicyTypesResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+DescribeLoadBalancerPolicyTypesResult::DescribeLoadBalancerPolicyTypesResult()
+{
+}
+
+DescribeLoadBalancerPolicyTypesResult::DescribeLoadBalancerPolicyTypesResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+DescribeLoadBalancerPolicyTypesResult& DescribeLoadBalancerPolicyTypesResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "DescribeLoadBalancerPolicyTypesResult"))
+  {
+    resultNode = rootNode.FirstChild("DescribeLoadBalancerPolicyTypesResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode policyTypeDescriptionsNode = resultNode.FirstChild("PolicyTypeDescriptions");
+    if(!policyTypeDescriptionsNode.IsNull())
+    {
+      XmlNode policyTypeDescriptionsMember = policyTypeDescriptionsNode.FirstChild("member");
+      while(!policyTypeDescriptionsMember.IsNull())
+      {
+        m_policyTypeDescriptions.push_back(policyTypeDescriptionsMember);
+        policyTypeDescriptionsMember = policyTypeDescriptionsMember.NextNode("member");
+      }
+
+    }
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::DescribeLoadBalancerPolicyTypesResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DescribeLoadBalancersRequest.cpp

@@ -0,0 +1,54 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DescribeLoadBalancersRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+DescribeLoadBalancersRequest::DescribeLoadBalancersRequest() : 
+    m_loadBalancerNamesHasBeenSet(false),
+    m_markerHasBeenSet(false),
+    m_pageSize(0),
+    m_pageSizeHasBeenSet(false)
+{
+}
+
+Aws::String DescribeLoadBalancersRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=DescribeLoadBalancers&";
+  if(m_loadBalancerNamesHasBeenSet)
+  {
+    unsigned loadBalancerNamesCount = 1;
+    for(auto& item : m_loadBalancerNames)
+    {
+      ss << "LoadBalancerNames.member." << loadBalancerNamesCount << "="
+          << StringUtils::URLEncode(item.c_str()) << "&";
+      loadBalancerNamesCount++;
+    }
+  }
+
+  if(m_markerHasBeenSet)
+  {
+    ss << "Marker=" << StringUtils::URLEncode(m_marker.c_str()) << "&";
+  }
+
+  if(m_pageSizeHasBeenSet)
+  {
+    ss << "PageSize=" << m_pageSize << "&";
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  DescribeLoadBalancersRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DescribeLoadBalancersResult.cpp

@@ -0,0 +1,65 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DescribeLoadBalancersResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+DescribeLoadBalancersResult::DescribeLoadBalancersResult()
+{
+}
+
+DescribeLoadBalancersResult::DescribeLoadBalancersResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+DescribeLoadBalancersResult& DescribeLoadBalancersResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "DescribeLoadBalancersResult"))
+  {
+    resultNode = rootNode.FirstChild("DescribeLoadBalancersResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode loadBalancerDescriptionsNode = resultNode.FirstChild("LoadBalancerDescriptions");
+    if(!loadBalancerDescriptionsNode.IsNull())
+    {
+      XmlNode loadBalancerDescriptionsMember = loadBalancerDescriptionsNode.FirstChild("member");
+      while(!loadBalancerDescriptionsMember.IsNull())
+      {
+        m_loadBalancerDescriptions.push_back(loadBalancerDescriptionsMember);
+        loadBalancerDescriptionsMember = loadBalancerDescriptionsMember.NextNode("member");
+      }
+
+    }
+    XmlNode nextMarkerNode = resultNode.FirstChild("NextMarker");
+    if(!nextMarkerNode.IsNull())
+    {
+      m_nextMarker = Aws::Utils::Xml::DecodeEscapedXmlText(nextMarkerNode.GetText());
+    }
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::DescribeLoadBalancersResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DescribeTagsRequest.cpp

@@ -0,0 +1,41 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DescribeTagsRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+DescribeTagsRequest::DescribeTagsRequest() : 
+    m_loadBalancerNamesHasBeenSet(false)
+{
+}
+
+Aws::String DescribeTagsRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=DescribeTags&";
+  if(m_loadBalancerNamesHasBeenSet)
+  {
+    unsigned loadBalancerNamesCount = 1;
+    for(auto& item : m_loadBalancerNames)
+    {
+      ss << "LoadBalancerNames.member." << loadBalancerNamesCount << "="
+          << StringUtils::URLEncode(item.c_str()) << "&";
+      loadBalancerNamesCount++;
+    }
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  DescribeTagsRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DescribeTagsResult.cpp

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DescribeTagsResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+DescribeTagsResult::DescribeTagsResult()
+{
+}
+
+DescribeTagsResult::DescribeTagsResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+DescribeTagsResult& DescribeTagsResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "DescribeTagsResult"))
+  {
+    resultNode = rootNode.FirstChild("DescribeTagsResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode tagDescriptionsNode = resultNode.FirstChild("TagDescriptions");
+    if(!tagDescriptionsNode.IsNull())
+    {
+      XmlNode tagDescriptionsMember = tagDescriptionsNode.FirstChild("member");
+      while(!tagDescriptionsMember.IsNull())
+      {
+        m_tagDescriptions.push_back(tagDescriptionsMember);
+        tagDescriptionsMember = tagDescriptionsMember.NextNode("member");
+      }
+
+    }
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::DescribeTagsResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DetachLoadBalancerFromSubnetsRequest.cpp

@@ -0,0 +1,47 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DetachLoadBalancerFromSubnetsRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+DetachLoadBalancerFromSubnetsRequest::DetachLoadBalancerFromSubnetsRequest() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_subnetsHasBeenSet(false)
+{
+}
+
+Aws::String DetachLoadBalancerFromSubnetsRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=DetachLoadBalancerFromSubnets&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_subnetsHasBeenSet)
+  {
+    unsigned subnetsCount = 1;
+    for(auto& item : m_subnets)
+    {
+      ss << "Subnets.member." << subnetsCount << "="
+          << StringUtils::URLEncode(item.c_str()) << "&";
+      subnetsCount++;
+    }
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  DetachLoadBalancerFromSubnetsRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DetachLoadBalancerFromSubnetsResult.cpp

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DetachLoadBalancerFromSubnetsResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+DetachLoadBalancerFromSubnetsResult::DetachLoadBalancerFromSubnetsResult()
+{
+}
+
+DetachLoadBalancerFromSubnetsResult::DetachLoadBalancerFromSubnetsResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+DetachLoadBalancerFromSubnetsResult& DetachLoadBalancerFromSubnetsResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "DetachLoadBalancerFromSubnetsResult"))
+  {
+    resultNode = rootNode.FirstChild("DetachLoadBalancerFromSubnetsResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode subnetsNode = resultNode.FirstChild("Subnets");
+    if(!subnetsNode.IsNull())
+    {
+      XmlNode subnetsMember = subnetsNode.FirstChild("member");
+      while(!subnetsMember.IsNull())
+      {
+        m_subnets.push_back(subnetsMember.GetText());
+        subnetsMember = subnetsMember.NextNode("member");
+      }
+
+    }
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::DetachLoadBalancerFromSubnetsResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DisableAvailabilityZonesForLoadBalancerRequest.cpp

@@ -0,0 +1,47 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DisableAvailabilityZonesForLoadBalancerRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+DisableAvailabilityZonesForLoadBalancerRequest::DisableAvailabilityZonesForLoadBalancerRequest() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_availabilityZonesHasBeenSet(false)
+{
+}
+
+Aws::String DisableAvailabilityZonesForLoadBalancerRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=DisableAvailabilityZonesForLoadBalancer&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_availabilityZonesHasBeenSet)
+  {
+    unsigned availabilityZonesCount = 1;
+    for(auto& item : m_availabilityZones)
+    {
+      ss << "AvailabilityZones.member." << availabilityZonesCount << "="
+          << StringUtils::URLEncode(item.c_str()) << "&";
+      availabilityZonesCount++;
+    }
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  DisableAvailabilityZonesForLoadBalancerRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/DisableAvailabilityZonesForLoadBalancerResult.cpp

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/DisableAvailabilityZonesForLoadBalancerResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+DisableAvailabilityZonesForLoadBalancerResult::DisableAvailabilityZonesForLoadBalancerResult()
+{
+}
+
+DisableAvailabilityZonesForLoadBalancerResult::DisableAvailabilityZonesForLoadBalancerResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+DisableAvailabilityZonesForLoadBalancerResult& DisableAvailabilityZonesForLoadBalancerResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "DisableAvailabilityZonesForLoadBalancerResult"))
+  {
+    resultNode = rootNode.FirstChild("DisableAvailabilityZonesForLoadBalancerResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode availabilityZonesNode = resultNode.FirstChild("AvailabilityZones");
+    if(!availabilityZonesNode.IsNull())
+    {
+      XmlNode availabilityZonesMember = availabilityZonesNode.FirstChild("member");
+      while(!availabilityZonesMember.IsNull())
+      {
+        m_availabilityZones.push_back(availabilityZonesMember.GetText());
+        availabilityZonesMember = availabilityZonesMember.NextNode("member");
+      }
+
+    }
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::DisableAvailabilityZonesForLoadBalancerResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/EnableAvailabilityZonesForLoadBalancerRequest.cpp

@@ -0,0 +1,47 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/EnableAvailabilityZonesForLoadBalancerRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+EnableAvailabilityZonesForLoadBalancerRequest::EnableAvailabilityZonesForLoadBalancerRequest() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_availabilityZonesHasBeenSet(false)
+{
+}
+
+Aws::String EnableAvailabilityZonesForLoadBalancerRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=EnableAvailabilityZonesForLoadBalancer&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_availabilityZonesHasBeenSet)
+  {
+    unsigned availabilityZonesCount = 1;
+    for(auto& item : m_availabilityZones)
+    {
+      ss << "AvailabilityZones.member." << availabilityZonesCount << "="
+          << StringUtils::URLEncode(item.c_str()) << "&";
+      availabilityZonesCount++;
+    }
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  EnableAvailabilityZonesForLoadBalancerRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/EnableAvailabilityZonesForLoadBalancerResult.cpp

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/EnableAvailabilityZonesForLoadBalancerResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+EnableAvailabilityZonesForLoadBalancerResult::EnableAvailabilityZonesForLoadBalancerResult()
+{
+}
+
+EnableAvailabilityZonesForLoadBalancerResult::EnableAvailabilityZonesForLoadBalancerResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+EnableAvailabilityZonesForLoadBalancerResult& EnableAvailabilityZonesForLoadBalancerResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "EnableAvailabilityZonesForLoadBalancerResult"))
+  {
+    resultNode = rootNode.FirstChild("EnableAvailabilityZonesForLoadBalancerResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode availabilityZonesNode = resultNode.FirstChild("AvailabilityZones");
+    if(!availabilityZonesNode.IsNull())
+    {
+      XmlNode availabilityZonesMember = availabilityZonesNode.FirstChild("member");
+      while(!availabilityZonesMember.IsNull())
+      {
+        m_availabilityZones.push_back(availabilityZonesMember.GetText());
+        availabilityZonesMember = availabilityZonesMember.NextNode("member");
+      }
+
+    }
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::EnableAvailabilityZonesForLoadBalancerResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/HealthCheck.cpp

@@ -0,0 +1,146 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/HealthCheck.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+HealthCheck::HealthCheck() : 
+    m_targetHasBeenSet(false),
+    m_interval(0),
+    m_intervalHasBeenSet(false),
+    m_timeout(0),
+    m_timeoutHasBeenSet(false),
+    m_unhealthyThreshold(0),
+    m_unhealthyThresholdHasBeenSet(false),
+    m_healthyThreshold(0),
+    m_healthyThresholdHasBeenSet(false)
+{
+}
+
+HealthCheck::HealthCheck(const XmlNode& xmlNode) : 
+    m_targetHasBeenSet(false),
+    m_interval(0),
+    m_intervalHasBeenSet(false),
+    m_timeout(0),
+    m_timeoutHasBeenSet(false),
+    m_unhealthyThreshold(0),
+    m_unhealthyThresholdHasBeenSet(false),
+    m_healthyThreshold(0),
+    m_healthyThresholdHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+HealthCheck& HealthCheck::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode targetNode = resultNode.FirstChild("Target");
+    if(!targetNode.IsNull())
+    {
+      m_target = Aws::Utils::Xml::DecodeEscapedXmlText(targetNode.GetText());
+      m_targetHasBeenSet = true;
+    }
+    XmlNode intervalNode = resultNode.FirstChild("Interval");
+    if(!intervalNode.IsNull())
+    {
+      m_interval = StringUtils::ConvertToInt32(StringUtils::Trim(Aws::Utils::Xml::DecodeEscapedXmlText(intervalNode.GetText()).c_str()).c_str());
+      m_intervalHasBeenSet = true;
+    }
+    XmlNode timeoutNode = resultNode.FirstChild("Timeout");
+    if(!timeoutNode.IsNull())
+    {
+      m_timeout = StringUtils::ConvertToInt32(StringUtils::Trim(Aws::Utils::Xml::DecodeEscapedXmlText(timeoutNode.GetText()).c_str()).c_str());
+      m_timeoutHasBeenSet = true;
+    }
+    XmlNode unhealthyThresholdNode = resultNode.FirstChild("UnhealthyThreshold");
+    if(!unhealthyThresholdNode.IsNull())
+    {
+      m_unhealthyThreshold = StringUtils::ConvertToInt32(StringUtils::Trim(Aws::Utils::Xml::DecodeEscapedXmlText(unhealthyThresholdNode.GetText()).c_str()).c_str());
+      m_unhealthyThresholdHasBeenSet = true;
+    }
+    XmlNode healthyThresholdNode = resultNode.FirstChild("HealthyThreshold");
+    if(!healthyThresholdNode.IsNull())
+    {
+      m_healthyThreshold = StringUtils::ConvertToInt32(StringUtils::Trim(Aws::Utils::Xml::DecodeEscapedXmlText(healthyThresholdNode.GetText()).c_str()).c_str());
+      m_healthyThresholdHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void HealthCheck::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_targetHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".Target=" << StringUtils::URLEncode(m_target.c_str()) << "&";
+  }
+
+  if(m_intervalHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".Interval=" << m_interval << "&";
+  }
+
+  if(m_timeoutHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".Timeout=" << m_timeout << "&";
+  }
+
+  if(m_unhealthyThresholdHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".UnhealthyThreshold=" << m_unhealthyThreshold << "&";
+  }
+
+  if(m_healthyThresholdHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".HealthyThreshold=" << m_healthyThreshold << "&";
+  }
+
+}
+
+void HealthCheck::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_targetHasBeenSet)
+  {
+      oStream << location << ".Target=" << StringUtils::URLEncode(m_target.c_str()) << "&";
+  }
+  if(m_intervalHasBeenSet)
+  {
+      oStream << location << ".Interval=" << m_interval << "&";
+  }
+  if(m_timeoutHasBeenSet)
+  {
+      oStream << location << ".Timeout=" << m_timeout << "&";
+  }
+  if(m_unhealthyThresholdHasBeenSet)
+  {
+      oStream << location << ".UnhealthyThreshold=" << m_unhealthyThreshold << "&";
+  }
+  if(m_healthyThresholdHasBeenSet)
+  {
+      oStream << location << ".HealthyThreshold=" << m_healthyThreshold << "&";
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/Instance.cpp

@@ -0,0 +1,70 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/Instance.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+Instance::Instance() : 
+    m_instanceIdHasBeenSet(false)
+{
+}
+
+Instance::Instance(const XmlNode& xmlNode) : 
+    m_instanceIdHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+Instance& Instance::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode instanceIdNode = resultNode.FirstChild("InstanceId");
+    if(!instanceIdNode.IsNull())
+    {
+      m_instanceId = Aws::Utils::Xml::DecodeEscapedXmlText(instanceIdNode.GetText());
+      m_instanceIdHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void Instance::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_instanceIdHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".InstanceId=" << StringUtils::URLEncode(m_instanceId.c_str()) << "&";
+  }
+
+}
+
+void Instance::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_instanceIdHasBeenSet)
+  {
+      oStream << location << ".InstanceId=" << StringUtils::URLEncode(m_instanceId.c_str()) << "&";
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/InstanceState.cpp

@@ -0,0 +1,121 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/InstanceState.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+InstanceState::InstanceState() : 
+    m_instanceIdHasBeenSet(false),
+    m_stateHasBeenSet(false),
+    m_reasonCodeHasBeenSet(false),
+    m_descriptionHasBeenSet(false)
+{
+}
+
+InstanceState::InstanceState(const XmlNode& xmlNode) : 
+    m_instanceIdHasBeenSet(false),
+    m_stateHasBeenSet(false),
+    m_reasonCodeHasBeenSet(false),
+    m_descriptionHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+InstanceState& InstanceState::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode instanceIdNode = resultNode.FirstChild("InstanceId");
+    if(!instanceIdNode.IsNull())
+    {
+      m_instanceId = Aws::Utils::Xml::DecodeEscapedXmlText(instanceIdNode.GetText());
+      m_instanceIdHasBeenSet = true;
+    }
+    XmlNode stateNode = resultNode.FirstChild("State");
+    if(!stateNode.IsNull())
+    {
+      m_state = Aws::Utils::Xml::DecodeEscapedXmlText(stateNode.GetText());
+      m_stateHasBeenSet = true;
+    }
+    XmlNode reasonCodeNode = resultNode.FirstChild("ReasonCode");
+    if(!reasonCodeNode.IsNull())
+    {
+      m_reasonCode = Aws::Utils::Xml::DecodeEscapedXmlText(reasonCodeNode.GetText());
+      m_reasonCodeHasBeenSet = true;
+    }
+    XmlNode descriptionNode = resultNode.FirstChild("Description");
+    if(!descriptionNode.IsNull())
+    {
+      m_description = Aws::Utils::Xml::DecodeEscapedXmlText(descriptionNode.GetText());
+      m_descriptionHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void InstanceState::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_instanceIdHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".InstanceId=" << StringUtils::URLEncode(m_instanceId.c_str()) << "&";
+  }
+
+  if(m_stateHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".State=" << StringUtils::URLEncode(m_state.c_str()) << "&";
+  }
+
+  if(m_reasonCodeHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".ReasonCode=" << StringUtils::URLEncode(m_reasonCode.c_str()) << "&";
+  }
+
+  if(m_descriptionHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".Description=" << StringUtils::URLEncode(m_description.c_str()) << "&";
+  }
+
+}
+
+void InstanceState::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_instanceIdHasBeenSet)
+  {
+      oStream << location << ".InstanceId=" << StringUtils::URLEncode(m_instanceId.c_str()) << "&";
+  }
+  if(m_stateHasBeenSet)
+  {
+      oStream << location << ".State=" << StringUtils::URLEncode(m_state.c_str()) << "&";
+  }
+  if(m_reasonCodeHasBeenSet)
+  {
+      oStream << location << ".ReasonCode=" << StringUtils::URLEncode(m_reasonCode.c_str()) << "&";
+  }
+  if(m_descriptionHasBeenSet)
+  {
+      oStream << location << ".Description=" << StringUtils::URLEncode(m_description.c_str()) << "&";
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/LBCookieStickinessPolicy.cpp

@@ -0,0 +1,89 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/LBCookieStickinessPolicy.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+LBCookieStickinessPolicy::LBCookieStickinessPolicy() : 
+    m_policyNameHasBeenSet(false),
+    m_cookieExpirationPeriod(0),
+    m_cookieExpirationPeriodHasBeenSet(false)
+{
+}
+
+LBCookieStickinessPolicy::LBCookieStickinessPolicy(const XmlNode& xmlNode) : 
+    m_policyNameHasBeenSet(false),
+    m_cookieExpirationPeriod(0),
+    m_cookieExpirationPeriodHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+LBCookieStickinessPolicy& LBCookieStickinessPolicy::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode policyNameNode = resultNode.FirstChild("PolicyName");
+    if(!policyNameNode.IsNull())
+    {
+      m_policyName = Aws::Utils::Xml::DecodeEscapedXmlText(policyNameNode.GetText());
+      m_policyNameHasBeenSet = true;
+    }
+    XmlNode cookieExpirationPeriodNode = resultNode.FirstChild("CookieExpirationPeriod");
+    if(!cookieExpirationPeriodNode.IsNull())
+    {
+      m_cookieExpirationPeriod = StringUtils::ConvertToInt64(StringUtils::Trim(Aws::Utils::Xml::DecodeEscapedXmlText(cookieExpirationPeriodNode.GetText()).c_str()).c_str());
+      m_cookieExpirationPeriodHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void LBCookieStickinessPolicy::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_policyNameHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".PolicyName=" << StringUtils::URLEncode(m_policyName.c_str()) << "&";
+  }
+
+  if(m_cookieExpirationPeriodHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".CookieExpirationPeriod=" << m_cookieExpirationPeriod << "&";
+  }
+
+}
+
+void LBCookieStickinessPolicy::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_policyNameHasBeenSet)
+  {
+      oStream << location << ".PolicyName=" << StringUtils::URLEncode(m_policyName.c_str()) << "&";
+  }
+  if(m_cookieExpirationPeriodHasBeenSet)
+  {
+      oStream << location << ".CookieExpirationPeriod=" << m_cookieExpirationPeriod << "&";
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/Limit.cpp

@@ -0,0 +1,87 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/Limit.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+Limit::Limit() : 
+    m_nameHasBeenSet(false),
+    m_maxHasBeenSet(false)
+{
+}
+
+Limit::Limit(const XmlNode& xmlNode) : 
+    m_nameHasBeenSet(false),
+    m_maxHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+Limit& Limit::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode nameNode = resultNode.FirstChild("Name");
+    if(!nameNode.IsNull())
+    {
+      m_name = Aws::Utils::Xml::DecodeEscapedXmlText(nameNode.GetText());
+      m_nameHasBeenSet = true;
+    }
+    XmlNode maxNode = resultNode.FirstChild("Max");
+    if(!maxNode.IsNull())
+    {
+      m_max = Aws::Utils::Xml::DecodeEscapedXmlText(maxNode.GetText());
+      m_maxHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void Limit::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_nameHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".Name=" << StringUtils::URLEncode(m_name.c_str()) << "&";
+  }
+
+  if(m_maxHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".Max=" << StringUtils::URLEncode(m_max.c_str()) << "&";
+  }
+
+}
+
+void Limit::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_nameHasBeenSet)
+  {
+      oStream << location << ".Name=" << StringUtils::URLEncode(m_name.c_str()) << "&";
+  }
+  if(m_maxHasBeenSet)
+  {
+      oStream << location << ".Max=" << StringUtils::URLEncode(m_max.c_str()) << "&";
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/Listener.cpp

@@ -0,0 +1,142 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/Listener.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+Listener::Listener() : 
+    m_protocolHasBeenSet(false),
+    m_loadBalancerPort(0),
+    m_loadBalancerPortHasBeenSet(false),
+    m_instanceProtocolHasBeenSet(false),
+    m_instancePort(0),
+    m_instancePortHasBeenSet(false),
+    m_sSLCertificateIdHasBeenSet(false)
+{
+}
+
+Listener::Listener(const XmlNode& xmlNode) : 
+    m_protocolHasBeenSet(false),
+    m_loadBalancerPort(0),
+    m_loadBalancerPortHasBeenSet(false),
+    m_instanceProtocolHasBeenSet(false),
+    m_instancePort(0),
+    m_instancePortHasBeenSet(false),
+    m_sSLCertificateIdHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+Listener& Listener::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode protocolNode = resultNode.FirstChild("Protocol");
+    if(!protocolNode.IsNull())
+    {
+      m_protocol = Aws::Utils::Xml::DecodeEscapedXmlText(protocolNode.GetText());
+      m_protocolHasBeenSet = true;
+    }
+    XmlNode loadBalancerPortNode = resultNode.FirstChild("LoadBalancerPort");
+    if(!loadBalancerPortNode.IsNull())
+    {
+      m_loadBalancerPort = StringUtils::ConvertToInt32(StringUtils::Trim(Aws::Utils::Xml::DecodeEscapedXmlText(loadBalancerPortNode.GetText()).c_str()).c_str());
+      m_loadBalancerPortHasBeenSet = true;
+    }
+    XmlNode instanceProtocolNode = resultNode.FirstChild("InstanceProtocol");
+    if(!instanceProtocolNode.IsNull())
+    {
+      m_instanceProtocol = Aws::Utils::Xml::DecodeEscapedXmlText(instanceProtocolNode.GetText());
+      m_instanceProtocolHasBeenSet = true;
+    }
+    XmlNode instancePortNode = resultNode.FirstChild("InstancePort");
+    if(!instancePortNode.IsNull())
+    {
+      m_instancePort = StringUtils::ConvertToInt32(StringUtils::Trim(Aws::Utils::Xml::DecodeEscapedXmlText(instancePortNode.GetText()).c_str()).c_str());
+      m_instancePortHasBeenSet = true;
+    }
+    XmlNode sSLCertificateIdNode = resultNode.FirstChild("SSLCertificateId");
+    if(!sSLCertificateIdNode.IsNull())
+    {
+      m_sSLCertificateId = Aws::Utils::Xml::DecodeEscapedXmlText(sSLCertificateIdNode.GetText());
+      m_sSLCertificateIdHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void Listener::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_protocolHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".Protocol=" << StringUtils::URLEncode(m_protocol.c_str()) << "&";
+  }
+
+  if(m_loadBalancerPortHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".LoadBalancerPort=" << m_loadBalancerPort << "&";
+  }
+
+  if(m_instanceProtocolHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".InstanceProtocol=" << StringUtils::URLEncode(m_instanceProtocol.c_str()) << "&";
+  }
+
+  if(m_instancePortHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".InstancePort=" << m_instancePort << "&";
+  }
+
+  if(m_sSLCertificateIdHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".SSLCertificateId=" << StringUtils::URLEncode(m_sSLCertificateId.c_str()) << "&";
+  }
+
+}
+
+void Listener::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_protocolHasBeenSet)
+  {
+      oStream << location << ".Protocol=" << StringUtils::URLEncode(m_protocol.c_str()) << "&";
+  }
+  if(m_loadBalancerPortHasBeenSet)
+  {
+      oStream << location << ".LoadBalancerPort=" << m_loadBalancerPort << "&";
+  }
+  if(m_instanceProtocolHasBeenSet)
+  {
+      oStream << location << ".InstanceProtocol=" << StringUtils::URLEncode(m_instanceProtocol.c_str()) << "&";
+  }
+  if(m_instancePortHasBeenSet)
+  {
+      oStream << location << ".InstancePort=" << m_instancePort << "&";
+  }
+  if(m_sSLCertificateIdHasBeenSet)
+  {
+      oStream << location << ".SSLCertificateId=" << StringUtils::URLEncode(m_sSLCertificateId.c_str()) << "&";
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/ListenerDescription.cpp

@@ -0,0 +1,105 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/ListenerDescription.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+ListenerDescription::ListenerDescription() : 
+    m_listenerHasBeenSet(false),
+    m_policyNamesHasBeenSet(false)
+{
+}
+
+ListenerDescription::ListenerDescription(const XmlNode& xmlNode) : 
+    m_listenerHasBeenSet(false),
+    m_policyNamesHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+ListenerDescription& ListenerDescription::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode listenerNode = resultNode.FirstChild("Listener");
+    if(!listenerNode.IsNull())
+    {
+      m_listener = listenerNode;
+      m_listenerHasBeenSet = true;
+    }
+    XmlNode policyNamesNode = resultNode.FirstChild("PolicyNames");
+    if(!policyNamesNode.IsNull())
+    {
+      XmlNode policyNamesMember = policyNamesNode.FirstChild("member");
+      while(!policyNamesMember.IsNull())
+      {
+        m_policyNames.push_back(policyNamesMember.GetText());
+        policyNamesMember = policyNamesMember.NextNode("member");
+      }
+
+      m_policyNamesHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void ListenerDescription::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_listenerHasBeenSet)
+  {
+      Aws::StringStream listenerLocationAndMemberSs;
+      listenerLocationAndMemberSs << location << index << locationValue << ".Listener";
+      m_listener.OutputToStream(oStream, listenerLocationAndMemberSs.str().c_str());
+  }
+
+  if(m_policyNamesHasBeenSet)
+  {
+      unsigned policyNamesIdx = 1;
+      for(auto& item : m_policyNames)
+      {
+        oStream << location << index << locationValue << ".PolicyNames.member." << policyNamesIdx++ << "=" << StringUtils::URLEncode(item.c_str()) << "&";
+      }
+  }
+
+}
+
+void ListenerDescription::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_listenerHasBeenSet)
+  {
+      Aws::String listenerLocationAndMember(location);
+      listenerLocationAndMember += ".Listener";
+      m_listener.OutputToStream(oStream, listenerLocationAndMember.c_str());
+  }
+  if(m_policyNamesHasBeenSet)
+  {
+      unsigned policyNamesIdx = 1;
+      for(auto& item : m_policyNames)
+      {
+        oStream << location << ".PolicyNames.member." << policyNamesIdx++ << "=" << StringUtils::URLEncode(item.c_str()) << "&";
+      }
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/LoadBalancerAttributes.cpp

@@ -0,0 +1,172 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/LoadBalancerAttributes.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+LoadBalancerAttributes::LoadBalancerAttributes() : 
+    m_crossZoneLoadBalancingHasBeenSet(false),
+    m_accessLogHasBeenSet(false),
+    m_connectionDrainingHasBeenSet(false),
+    m_connectionSettingsHasBeenSet(false),
+    m_additionalAttributesHasBeenSet(false)
+{
+}
+
+LoadBalancerAttributes::LoadBalancerAttributes(const XmlNode& xmlNode) : 
+    m_crossZoneLoadBalancingHasBeenSet(false),
+    m_accessLogHasBeenSet(false),
+    m_connectionDrainingHasBeenSet(false),
+    m_connectionSettingsHasBeenSet(false),
+    m_additionalAttributesHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+LoadBalancerAttributes& LoadBalancerAttributes::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode crossZoneLoadBalancingNode = resultNode.FirstChild("CrossZoneLoadBalancing");
+    if(!crossZoneLoadBalancingNode.IsNull())
+    {
+      m_crossZoneLoadBalancing = crossZoneLoadBalancingNode;
+      m_crossZoneLoadBalancingHasBeenSet = true;
+    }
+    XmlNode accessLogNode = resultNode.FirstChild("AccessLog");
+    if(!accessLogNode.IsNull())
+    {
+      m_accessLog = accessLogNode;
+      m_accessLogHasBeenSet = true;
+    }
+    XmlNode connectionDrainingNode = resultNode.FirstChild("ConnectionDraining");
+    if(!connectionDrainingNode.IsNull())
+    {
+      m_connectionDraining = connectionDrainingNode;
+      m_connectionDrainingHasBeenSet = true;
+    }
+    XmlNode connectionSettingsNode = resultNode.FirstChild("ConnectionSettings");
+    if(!connectionSettingsNode.IsNull())
+    {
+      m_connectionSettings = connectionSettingsNode;
+      m_connectionSettingsHasBeenSet = true;
+    }
+    XmlNode additionalAttributesNode = resultNode.FirstChild("AdditionalAttributes");
+    if(!additionalAttributesNode.IsNull())
+    {
+      XmlNode additionalAttributesMember = additionalAttributesNode.FirstChild("member");
+      while(!additionalAttributesMember.IsNull())
+      {
+        m_additionalAttributes.push_back(additionalAttributesMember);
+        additionalAttributesMember = additionalAttributesMember.NextNode("member");
+      }
+
+      m_additionalAttributesHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void LoadBalancerAttributes::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_crossZoneLoadBalancingHasBeenSet)
+  {
+      Aws::StringStream crossZoneLoadBalancingLocationAndMemberSs;
+      crossZoneLoadBalancingLocationAndMemberSs << location << index << locationValue << ".CrossZoneLoadBalancing";
+      m_crossZoneLoadBalancing.OutputToStream(oStream, crossZoneLoadBalancingLocationAndMemberSs.str().c_str());
+  }
+
+  if(m_accessLogHasBeenSet)
+  {
+      Aws::StringStream accessLogLocationAndMemberSs;
+      accessLogLocationAndMemberSs << location << index << locationValue << ".AccessLog";
+      m_accessLog.OutputToStream(oStream, accessLogLocationAndMemberSs.str().c_str());
+  }
+
+  if(m_connectionDrainingHasBeenSet)
+  {
+      Aws::StringStream connectionDrainingLocationAndMemberSs;
+      connectionDrainingLocationAndMemberSs << location << index << locationValue << ".ConnectionDraining";
+      m_connectionDraining.OutputToStream(oStream, connectionDrainingLocationAndMemberSs.str().c_str());
+  }
+
+  if(m_connectionSettingsHasBeenSet)
+  {
+      Aws::StringStream connectionSettingsLocationAndMemberSs;
+      connectionSettingsLocationAndMemberSs << location << index << locationValue << ".ConnectionSettings";
+      m_connectionSettings.OutputToStream(oStream, connectionSettingsLocationAndMemberSs.str().c_str());
+  }
+
+  if(m_additionalAttributesHasBeenSet)
+  {
+      unsigned additionalAttributesIdx = 1;
+      for(auto& item : m_additionalAttributes)
+      {
+        Aws::StringStream additionalAttributesSs;
+        additionalAttributesSs << location << index << locationValue << ".AdditionalAttributes.member." << additionalAttributesIdx++;
+        item.OutputToStream(oStream, additionalAttributesSs.str().c_str());
+      }
+  }
+
+}
+
+void LoadBalancerAttributes::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_crossZoneLoadBalancingHasBeenSet)
+  {
+      Aws::String crossZoneLoadBalancingLocationAndMember(location);
+      crossZoneLoadBalancingLocationAndMember += ".CrossZoneLoadBalancing";
+      m_crossZoneLoadBalancing.OutputToStream(oStream, crossZoneLoadBalancingLocationAndMember.c_str());
+  }
+  if(m_accessLogHasBeenSet)
+  {
+      Aws::String accessLogLocationAndMember(location);
+      accessLogLocationAndMember += ".AccessLog";
+      m_accessLog.OutputToStream(oStream, accessLogLocationAndMember.c_str());
+  }
+  if(m_connectionDrainingHasBeenSet)
+  {
+      Aws::String connectionDrainingLocationAndMember(location);
+      connectionDrainingLocationAndMember += ".ConnectionDraining";
+      m_connectionDraining.OutputToStream(oStream, connectionDrainingLocationAndMember.c_str());
+  }
+  if(m_connectionSettingsHasBeenSet)
+  {
+      Aws::String connectionSettingsLocationAndMember(location);
+      connectionSettingsLocationAndMember += ".ConnectionSettings";
+      m_connectionSettings.OutputToStream(oStream, connectionSettingsLocationAndMember.c_str());
+  }
+  if(m_additionalAttributesHasBeenSet)
+  {
+      unsigned additionalAttributesIdx = 1;
+      for(auto& item : m_additionalAttributes)
+      {
+        Aws::StringStream additionalAttributesSs;
+        additionalAttributesSs << location <<  ".AdditionalAttributes.member." << additionalAttributesIdx++;
+        item.OutputToStream(oStream, additionalAttributesSs.str().c_str());
+      }
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/LoadBalancerDescription.cpp

@@ -0,0 +1,433 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/LoadBalancerDescription.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+LoadBalancerDescription::LoadBalancerDescription() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_dNSNameHasBeenSet(false),
+    m_canonicalHostedZoneNameHasBeenSet(false),
+    m_canonicalHostedZoneNameIDHasBeenSet(false),
+    m_listenerDescriptionsHasBeenSet(false),
+    m_policiesHasBeenSet(false),
+    m_backendServerDescriptionsHasBeenSet(false),
+    m_availabilityZonesHasBeenSet(false),
+    m_subnetsHasBeenSet(false),
+    m_vPCIdHasBeenSet(false),
+    m_instancesHasBeenSet(false),
+    m_healthCheckHasBeenSet(false),
+    m_sourceSecurityGroupHasBeenSet(false),
+    m_securityGroupsHasBeenSet(false),
+    m_createdTimeHasBeenSet(false),
+    m_schemeHasBeenSet(false)
+{
+}
+
+LoadBalancerDescription::LoadBalancerDescription(const XmlNode& xmlNode) : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_dNSNameHasBeenSet(false),
+    m_canonicalHostedZoneNameHasBeenSet(false),
+    m_canonicalHostedZoneNameIDHasBeenSet(false),
+    m_listenerDescriptionsHasBeenSet(false),
+    m_policiesHasBeenSet(false),
+    m_backendServerDescriptionsHasBeenSet(false),
+    m_availabilityZonesHasBeenSet(false),
+    m_subnetsHasBeenSet(false),
+    m_vPCIdHasBeenSet(false),
+    m_instancesHasBeenSet(false),
+    m_healthCheckHasBeenSet(false),
+    m_sourceSecurityGroupHasBeenSet(false),
+    m_securityGroupsHasBeenSet(false),
+    m_createdTimeHasBeenSet(false),
+    m_schemeHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+LoadBalancerDescription& LoadBalancerDescription::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode loadBalancerNameNode = resultNode.FirstChild("LoadBalancerName");
+    if(!loadBalancerNameNode.IsNull())
+    {
+      m_loadBalancerName = Aws::Utils::Xml::DecodeEscapedXmlText(loadBalancerNameNode.GetText());
+      m_loadBalancerNameHasBeenSet = true;
+    }
+    XmlNode dNSNameNode = resultNode.FirstChild("DNSName");
+    if(!dNSNameNode.IsNull())
+    {
+      m_dNSName = Aws::Utils::Xml::DecodeEscapedXmlText(dNSNameNode.GetText());
+      m_dNSNameHasBeenSet = true;
+    }
+    XmlNode canonicalHostedZoneNameNode = resultNode.FirstChild("CanonicalHostedZoneName");
+    if(!canonicalHostedZoneNameNode.IsNull())
+    {
+      m_canonicalHostedZoneName = Aws::Utils::Xml::DecodeEscapedXmlText(canonicalHostedZoneNameNode.GetText());
+      m_canonicalHostedZoneNameHasBeenSet = true;
+    }
+    XmlNode canonicalHostedZoneNameIDNode = resultNode.FirstChild("CanonicalHostedZoneNameID");
+    if(!canonicalHostedZoneNameIDNode.IsNull())
+    {
+      m_canonicalHostedZoneNameID = Aws::Utils::Xml::DecodeEscapedXmlText(canonicalHostedZoneNameIDNode.GetText());
+      m_canonicalHostedZoneNameIDHasBeenSet = true;
+    }
+    XmlNode listenerDescriptionsNode = resultNode.FirstChild("ListenerDescriptions");
+    if(!listenerDescriptionsNode.IsNull())
+    {
+      XmlNode listenerDescriptionsMember = listenerDescriptionsNode.FirstChild("member");
+      while(!listenerDescriptionsMember.IsNull())
+      {
+        m_listenerDescriptions.push_back(listenerDescriptionsMember);
+        listenerDescriptionsMember = listenerDescriptionsMember.NextNode("member");
+      }
+
+      m_listenerDescriptionsHasBeenSet = true;
+    }
+    XmlNode policiesNode = resultNode.FirstChild("Policies");
+    if(!policiesNode.IsNull())
+    {
+      m_policies = policiesNode;
+      m_policiesHasBeenSet = true;
+    }
+    XmlNode backendServerDescriptionsNode = resultNode.FirstChild("BackendServerDescriptions");
+    if(!backendServerDescriptionsNode.IsNull())
+    {
+      XmlNode backendServerDescriptionsMember = backendServerDescriptionsNode.FirstChild("member");
+      while(!backendServerDescriptionsMember.IsNull())
+      {
+        m_backendServerDescriptions.push_back(backendServerDescriptionsMember);
+        backendServerDescriptionsMember = backendServerDescriptionsMember.NextNode("member");
+      }
+
+      m_backendServerDescriptionsHasBeenSet = true;
+    }
+    XmlNode availabilityZonesNode = resultNode.FirstChild("AvailabilityZones");
+    if(!availabilityZonesNode.IsNull())
+    {
+      XmlNode availabilityZonesMember = availabilityZonesNode.FirstChild("member");
+      while(!availabilityZonesMember.IsNull())
+      {
+        m_availabilityZones.push_back(availabilityZonesMember.GetText());
+        availabilityZonesMember = availabilityZonesMember.NextNode("member");
+      }
+
+      m_availabilityZonesHasBeenSet = true;
+    }
+    XmlNode subnetsNode = resultNode.FirstChild("Subnets");
+    if(!subnetsNode.IsNull())
+    {
+      XmlNode subnetsMember = subnetsNode.FirstChild("member");
+      while(!subnetsMember.IsNull())
+      {
+        m_subnets.push_back(subnetsMember.GetText());
+        subnetsMember = subnetsMember.NextNode("member");
+      }
+
+      m_subnetsHasBeenSet = true;
+    }
+    XmlNode vPCIdNode = resultNode.FirstChild("VPCId");
+    if(!vPCIdNode.IsNull())
+    {
+      m_vPCId = Aws::Utils::Xml::DecodeEscapedXmlText(vPCIdNode.GetText());
+      m_vPCIdHasBeenSet = true;
+    }
+    XmlNode instancesNode = resultNode.FirstChild("Instances");
+    if(!instancesNode.IsNull())
+    {
+      XmlNode instancesMember = instancesNode.FirstChild("member");
+      while(!instancesMember.IsNull())
+      {
+        m_instances.push_back(instancesMember);
+        instancesMember = instancesMember.NextNode("member");
+      }
+
+      m_instancesHasBeenSet = true;
+    }
+    XmlNode healthCheckNode = resultNode.FirstChild("HealthCheck");
+    if(!healthCheckNode.IsNull())
+    {
+      m_healthCheck = healthCheckNode;
+      m_healthCheckHasBeenSet = true;
+    }
+    XmlNode sourceSecurityGroupNode = resultNode.FirstChild("SourceSecurityGroup");
+    if(!sourceSecurityGroupNode.IsNull())
+    {
+      m_sourceSecurityGroup = sourceSecurityGroupNode;
+      m_sourceSecurityGroupHasBeenSet = true;
+    }
+    XmlNode securityGroupsNode = resultNode.FirstChild("SecurityGroups");
+    if(!securityGroupsNode.IsNull())
+    {
+      XmlNode securityGroupsMember = securityGroupsNode.FirstChild("member");
+      while(!securityGroupsMember.IsNull())
+      {
+        m_securityGroups.push_back(securityGroupsMember.GetText());
+        securityGroupsMember = securityGroupsMember.NextNode("member");
+      }
+
+      m_securityGroupsHasBeenSet = true;
+    }
+    XmlNode createdTimeNode = resultNode.FirstChild("CreatedTime");
+    if(!createdTimeNode.IsNull())
+    {
+      m_createdTime = DateTime(StringUtils::Trim(Aws::Utils::Xml::DecodeEscapedXmlText(createdTimeNode.GetText()).c_str()).c_str(), DateFormat::ISO_8601);
+      m_createdTimeHasBeenSet = true;
+    }
+    XmlNode schemeNode = resultNode.FirstChild("Scheme");
+    if(!schemeNode.IsNull())
+    {
+      m_scheme = Aws::Utils::Xml::DecodeEscapedXmlText(schemeNode.GetText());
+      m_schemeHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void LoadBalancerDescription::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_loadBalancerNameHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_dNSNameHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".DNSName=" << StringUtils::URLEncode(m_dNSName.c_str()) << "&";
+  }
+
+  if(m_canonicalHostedZoneNameHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".CanonicalHostedZoneName=" << StringUtils::URLEncode(m_canonicalHostedZoneName.c_str()) << "&";
+  }
+
+  if(m_canonicalHostedZoneNameIDHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".CanonicalHostedZoneNameID=" << StringUtils::URLEncode(m_canonicalHostedZoneNameID.c_str()) << "&";
+  }
+
+  if(m_listenerDescriptionsHasBeenSet)
+  {
+      unsigned listenerDescriptionsIdx = 1;
+      for(auto& item : m_listenerDescriptions)
+      {
+        Aws::StringStream listenerDescriptionsSs;
+        listenerDescriptionsSs << location << index << locationValue << ".ListenerDescriptions.member." << listenerDescriptionsIdx++;
+        item.OutputToStream(oStream, listenerDescriptionsSs.str().c_str());
+      }
+  }
+
+  if(m_policiesHasBeenSet)
+  {
+      Aws::StringStream policiesLocationAndMemberSs;
+      policiesLocationAndMemberSs << location << index << locationValue << ".Policies";
+      m_policies.OutputToStream(oStream, policiesLocationAndMemberSs.str().c_str());
+  }
+
+  if(m_backendServerDescriptionsHasBeenSet)
+  {
+      unsigned backendServerDescriptionsIdx = 1;
+      for(auto& item : m_backendServerDescriptions)
+      {
+        Aws::StringStream backendServerDescriptionsSs;
+        backendServerDescriptionsSs << location << index << locationValue << ".BackendServerDescriptions.member." << backendServerDescriptionsIdx++;
+        item.OutputToStream(oStream, backendServerDescriptionsSs.str().c_str());
+      }
+  }
+
+  if(m_availabilityZonesHasBeenSet)
+  {
+      unsigned availabilityZonesIdx = 1;
+      for(auto& item : m_availabilityZones)
+      {
+        oStream << location << index << locationValue << ".AvailabilityZones.member." << availabilityZonesIdx++ << "=" << StringUtils::URLEncode(item.c_str()) << "&";
+      }
+  }
+
+  if(m_subnetsHasBeenSet)
+  {
+      unsigned subnetsIdx = 1;
+      for(auto& item : m_subnets)
+      {
+        oStream << location << index << locationValue << ".Subnets.member." << subnetsIdx++ << "=" << StringUtils::URLEncode(item.c_str()) << "&";
+      }
+  }
+
+  if(m_vPCIdHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".VPCId=" << StringUtils::URLEncode(m_vPCId.c_str()) << "&";
+  }
+
+  if(m_instancesHasBeenSet)
+  {
+      unsigned instancesIdx = 1;
+      for(auto& item : m_instances)
+      {
+        Aws::StringStream instancesSs;
+        instancesSs << location << index << locationValue << ".Instances.member." << instancesIdx++;
+        item.OutputToStream(oStream, instancesSs.str().c_str());
+      }
+  }
+
+  if(m_healthCheckHasBeenSet)
+  {
+      Aws::StringStream healthCheckLocationAndMemberSs;
+      healthCheckLocationAndMemberSs << location << index << locationValue << ".HealthCheck";
+      m_healthCheck.OutputToStream(oStream, healthCheckLocationAndMemberSs.str().c_str());
+  }
+
+  if(m_sourceSecurityGroupHasBeenSet)
+  {
+      Aws::StringStream sourceSecurityGroupLocationAndMemberSs;
+      sourceSecurityGroupLocationAndMemberSs << location << index << locationValue << ".SourceSecurityGroup";
+      m_sourceSecurityGroup.OutputToStream(oStream, sourceSecurityGroupLocationAndMemberSs.str().c_str());
+  }
+
+  if(m_securityGroupsHasBeenSet)
+  {
+      unsigned securityGroupsIdx = 1;
+      for(auto& item : m_securityGroups)
+      {
+        oStream << location << index << locationValue << ".SecurityGroups.member." << securityGroupsIdx++ << "=" << StringUtils::URLEncode(item.c_str()) << "&";
+      }
+  }
+
+  if(m_createdTimeHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".CreatedTime=" << StringUtils::URLEncode(m_createdTime.ToGmtString(DateFormat::ISO_8601).c_str()) << "&";
+  }
+
+  if(m_schemeHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".Scheme=" << StringUtils::URLEncode(m_scheme.c_str()) << "&";
+  }
+
+}
+
+void LoadBalancerDescription::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_loadBalancerNameHasBeenSet)
+  {
+      oStream << location << ".LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+  if(m_dNSNameHasBeenSet)
+  {
+      oStream << location << ".DNSName=" << StringUtils::URLEncode(m_dNSName.c_str()) << "&";
+  }
+  if(m_canonicalHostedZoneNameHasBeenSet)
+  {
+      oStream << location << ".CanonicalHostedZoneName=" << StringUtils::URLEncode(m_canonicalHostedZoneName.c_str()) << "&";
+  }
+  if(m_canonicalHostedZoneNameIDHasBeenSet)
+  {
+      oStream << location << ".CanonicalHostedZoneNameID=" << StringUtils::URLEncode(m_canonicalHostedZoneNameID.c_str()) << "&";
+  }
+  if(m_listenerDescriptionsHasBeenSet)
+  {
+      unsigned listenerDescriptionsIdx = 1;
+      for(auto& item : m_listenerDescriptions)
+      {
+        Aws::StringStream listenerDescriptionsSs;
+        listenerDescriptionsSs << location <<  ".ListenerDescriptions.member." << listenerDescriptionsIdx++;
+        item.OutputToStream(oStream, listenerDescriptionsSs.str().c_str());
+      }
+  }
+  if(m_policiesHasBeenSet)
+  {
+      Aws::String policiesLocationAndMember(location);
+      policiesLocationAndMember += ".Policies";
+      m_policies.OutputToStream(oStream, policiesLocationAndMember.c_str());
+  }
+  if(m_backendServerDescriptionsHasBeenSet)
+  {
+      unsigned backendServerDescriptionsIdx = 1;
+      for(auto& item : m_backendServerDescriptions)
+      {
+        Aws::StringStream backendServerDescriptionsSs;
+        backendServerDescriptionsSs << location <<  ".BackendServerDescriptions.member." << backendServerDescriptionsIdx++;
+        item.OutputToStream(oStream, backendServerDescriptionsSs.str().c_str());
+      }
+  }
+  if(m_availabilityZonesHasBeenSet)
+  {
+      unsigned availabilityZonesIdx = 1;
+      for(auto& item : m_availabilityZones)
+      {
+        oStream << location << ".AvailabilityZones.member." << availabilityZonesIdx++ << "=" << StringUtils::URLEncode(item.c_str()) << "&";
+      }
+  }
+  if(m_subnetsHasBeenSet)
+  {
+      unsigned subnetsIdx = 1;
+      for(auto& item : m_subnets)
+      {
+        oStream << location << ".Subnets.member." << subnetsIdx++ << "=" << StringUtils::URLEncode(item.c_str()) << "&";
+      }
+  }
+  if(m_vPCIdHasBeenSet)
+  {
+      oStream << location << ".VPCId=" << StringUtils::URLEncode(m_vPCId.c_str()) << "&";
+  }
+  if(m_instancesHasBeenSet)
+  {
+      unsigned instancesIdx = 1;
+      for(auto& item : m_instances)
+      {
+        Aws::StringStream instancesSs;
+        instancesSs << location <<  ".Instances.member." << instancesIdx++;
+        item.OutputToStream(oStream, instancesSs.str().c_str());
+      }
+  }
+  if(m_healthCheckHasBeenSet)
+  {
+      Aws::String healthCheckLocationAndMember(location);
+      healthCheckLocationAndMember += ".HealthCheck";
+      m_healthCheck.OutputToStream(oStream, healthCheckLocationAndMember.c_str());
+  }
+  if(m_sourceSecurityGroupHasBeenSet)
+  {
+      Aws::String sourceSecurityGroupLocationAndMember(location);
+      sourceSecurityGroupLocationAndMember += ".SourceSecurityGroup";
+      m_sourceSecurityGroup.OutputToStream(oStream, sourceSecurityGroupLocationAndMember.c_str());
+  }
+  if(m_securityGroupsHasBeenSet)
+  {
+      unsigned securityGroupsIdx = 1;
+      for(auto& item : m_securityGroups)
+      {
+        oStream << location << ".SecurityGroups.member." << securityGroupsIdx++ << "=" << StringUtils::URLEncode(item.c_str()) << "&";
+      }
+  }
+  if(m_createdTimeHasBeenSet)
+  {
+      oStream << location << ".CreatedTime=" << StringUtils::URLEncode(m_createdTime.ToGmtString(DateFormat::ISO_8601).c_str()) << "&";
+  }
+  if(m_schemeHasBeenSet)
+  {
+      oStream << location << ".Scheme=" << StringUtils::URLEncode(m_scheme.c_str()) << "&";
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/ModifyLoadBalancerAttributesRequest.cpp

@@ -0,0 +1,41 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/ModifyLoadBalancerAttributesRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+ModifyLoadBalancerAttributesRequest::ModifyLoadBalancerAttributesRequest() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_loadBalancerAttributesHasBeenSet(false)
+{
+}
+
+Aws::String ModifyLoadBalancerAttributesRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=ModifyLoadBalancerAttributes&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_loadBalancerAttributesHasBeenSet)
+  {
+    m_loadBalancerAttributes.OutputToStream(ss, "LoadBalancerAttributes");
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  ModifyLoadBalancerAttributesRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/ModifyLoadBalancerAttributesResult.cpp

@@ -0,0 +1,59 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/ModifyLoadBalancerAttributesResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+ModifyLoadBalancerAttributesResult::ModifyLoadBalancerAttributesResult()
+{
+}
+
+ModifyLoadBalancerAttributesResult::ModifyLoadBalancerAttributesResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+ModifyLoadBalancerAttributesResult& ModifyLoadBalancerAttributesResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "ModifyLoadBalancerAttributesResult"))
+  {
+    resultNode = rootNode.FirstChild("ModifyLoadBalancerAttributesResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode loadBalancerNameNode = resultNode.FirstChild("LoadBalancerName");
+    if(!loadBalancerNameNode.IsNull())
+    {
+      m_loadBalancerName = Aws::Utils::Xml::DecodeEscapedXmlText(loadBalancerNameNode.GetText());
+    }
+    XmlNode loadBalancerAttributesNode = resultNode.FirstChild("LoadBalancerAttributes");
+    if(!loadBalancerAttributesNode.IsNull())
+    {
+      m_loadBalancerAttributes = loadBalancerAttributesNode;
+    }
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::ModifyLoadBalancerAttributesResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/Policies.cpp

@@ -0,0 +1,154 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/Policies.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+Policies::Policies() : 
+    m_appCookieStickinessPoliciesHasBeenSet(false),
+    m_lBCookieStickinessPoliciesHasBeenSet(false),
+    m_otherPoliciesHasBeenSet(false)
+{
+}
+
+Policies::Policies(const XmlNode& xmlNode) : 
+    m_appCookieStickinessPoliciesHasBeenSet(false),
+    m_lBCookieStickinessPoliciesHasBeenSet(false),
+    m_otherPoliciesHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+Policies& Policies::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode appCookieStickinessPoliciesNode = resultNode.FirstChild("AppCookieStickinessPolicies");
+    if(!appCookieStickinessPoliciesNode.IsNull())
+    {
+      XmlNode appCookieStickinessPoliciesMember = appCookieStickinessPoliciesNode.FirstChild("member");
+      while(!appCookieStickinessPoliciesMember.IsNull())
+      {
+        m_appCookieStickinessPolicies.push_back(appCookieStickinessPoliciesMember);
+        appCookieStickinessPoliciesMember = appCookieStickinessPoliciesMember.NextNode("member");
+      }
+
+      m_appCookieStickinessPoliciesHasBeenSet = true;
+    }
+    XmlNode lBCookieStickinessPoliciesNode = resultNode.FirstChild("LBCookieStickinessPolicies");
+    if(!lBCookieStickinessPoliciesNode.IsNull())
+    {
+      XmlNode lBCookieStickinessPoliciesMember = lBCookieStickinessPoliciesNode.FirstChild("member");
+      while(!lBCookieStickinessPoliciesMember.IsNull())
+      {
+        m_lBCookieStickinessPolicies.push_back(lBCookieStickinessPoliciesMember);
+        lBCookieStickinessPoliciesMember = lBCookieStickinessPoliciesMember.NextNode("member");
+      }
+
+      m_lBCookieStickinessPoliciesHasBeenSet = true;
+    }
+    XmlNode otherPoliciesNode = resultNode.FirstChild("OtherPolicies");
+    if(!otherPoliciesNode.IsNull())
+    {
+      XmlNode otherPoliciesMember = otherPoliciesNode.FirstChild("member");
+      while(!otherPoliciesMember.IsNull())
+      {
+        m_otherPolicies.push_back(otherPoliciesMember.GetText());
+        otherPoliciesMember = otherPoliciesMember.NextNode("member");
+      }
+
+      m_otherPoliciesHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void Policies::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_appCookieStickinessPoliciesHasBeenSet)
+  {
+      unsigned appCookieStickinessPoliciesIdx = 1;
+      for(auto& item : m_appCookieStickinessPolicies)
+      {
+        Aws::StringStream appCookieStickinessPoliciesSs;
+        appCookieStickinessPoliciesSs << location << index << locationValue << ".AppCookieStickinessPolicies.member." << appCookieStickinessPoliciesIdx++;
+        item.OutputToStream(oStream, appCookieStickinessPoliciesSs.str().c_str());
+      }
+  }
+
+  if(m_lBCookieStickinessPoliciesHasBeenSet)
+  {
+      unsigned lBCookieStickinessPoliciesIdx = 1;
+      for(auto& item : m_lBCookieStickinessPolicies)
+      {
+        Aws::StringStream lBCookieStickinessPoliciesSs;
+        lBCookieStickinessPoliciesSs << location << index << locationValue << ".LBCookieStickinessPolicies.member." << lBCookieStickinessPoliciesIdx++;
+        item.OutputToStream(oStream, lBCookieStickinessPoliciesSs.str().c_str());
+      }
+  }
+
+  if(m_otherPoliciesHasBeenSet)
+  {
+      unsigned otherPoliciesIdx = 1;
+      for(auto& item : m_otherPolicies)
+      {
+        oStream << location << index << locationValue << ".OtherPolicies.member." << otherPoliciesIdx++ << "=" << StringUtils::URLEncode(item.c_str()) << "&";
+      }
+  }
+
+}
+
+void Policies::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_appCookieStickinessPoliciesHasBeenSet)
+  {
+      unsigned appCookieStickinessPoliciesIdx = 1;
+      for(auto& item : m_appCookieStickinessPolicies)
+      {
+        Aws::StringStream appCookieStickinessPoliciesSs;
+        appCookieStickinessPoliciesSs << location <<  ".AppCookieStickinessPolicies.member." << appCookieStickinessPoliciesIdx++;
+        item.OutputToStream(oStream, appCookieStickinessPoliciesSs.str().c_str());
+      }
+  }
+  if(m_lBCookieStickinessPoliciesHasBeenSet)
+  {
+      unsigned lBCookieStickinessPoliciesIdx = 1;
+      for(auto& item : m_lBCookieStickinessPolicies)
+      {
+        Aws::StringStream lBCookieStickinessPoliciesSs;
+        lBCookieStickinessPoliciesSs << location <<  ".LBCookieStickinessPolicies.member." << lBCookieStickinessPoliciesIdx++;
+        item.OutputToStream(oStream, lBCookieStickinessPoliciesSs.str().c_str());
+      }
+  }
+  if(m_otherPoliciesHasBeenSet)
+  {
+      unsigned otherPoliciesIdx = 1;
+      for(auto& item : m_otherPolicies)
+      {
+        oStream << location << ".OtherPolicies.member." << otherPoliciesIdx++ << "=" << StringUtils::URLEncode(item.c_str()) << "&";
+      }
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/PolicyAttribute.cpp

@@ -0,0 +1,87 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/PolicyAttribute.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+PolicyAttribute::PolicyAttribute() : 
+    m_attributeNameHasBeenSet(false),
+    m_attributeValueHasBeenSet(false)
+{
+}
+
+PolicyAttribute::PolicyAttribute(const XmlNode& xmlNode) : 
+    m_attributeNameHasBeenSet(false),
+    m_attributeValueHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+PolicyAttribute& PolicyAttribute::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode attributeNameNode = resultNode.FirstChild("AttributeName");
+    if(!attributeNameNode.IsNull())
+    {
+      m_attributeName = Aws::Utils::Xml::DecodeEscapedXmlText(attributeNameNode.GetText());
+      m_attributeNameHasBeenSet = true;
+    }
+    XmlNode attributeValueNode = resultNode.FirstChild("AttributeValue");
+    if(!attributeValueNode.IsNull())
+    {
+      m_attributeValue = Aws::Utils::Xml::DecodeEscapedXmlText(attributeValueNode.GetText());
+      m_attributeValueHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void PolicyAttribute::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_attributeNameHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".AttributeName=" << StringUtils::URLEncode(m_attributeName.c_str()) << "&";
+  }
+
+  if(m_attributeValueHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".AttributeValue=" << StringUtils::URLEncode(m_attributeValue.c_str()) << "&";
+  }
+
+}
+
+void PolicyAttribute::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_attributeNameHasBeenSet)
+  {
+      oStream << location << ".AttributeName=" << StringUtils::URLEncode(m_attributeName.c_str()) << "&";
+  }
+  if(m_attributeValueHasBeenSet)
+  {
+      oStream << location << ".AttributeValue=" << StringUtils::URLEncode(m_attributeValue.c_str()) << "&";
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/PolicyAttributeDescription.cpp

@@ -0,0 +1,87 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/PolicyAttributeDescription.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+PolicyAttributeDescription::PolicyAttributeDescription() : 
+    m_attributeNameHasBeenSet(false),
+    m_attributeValueHasBeenSet(false)
+{
+}
+
+PolicyAttributeDescription::PolicyAttributeDescription(const XmlNode& xmlNode) : 
+    m_attributeNameHasBeenSet(false),
+    m_attributeValueHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+PolicyAttributeDescription& PolicyAttributeDescription::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode attributeNameNode = resultNode.FirstChild("AttributeName");
+    if(!attributeNameNode.IsNull())
+    {
+      m_attributeName = Aws::Utils::Xml::DecodeEscapedXmlText(attributeNameNode.GetText());
+      m_attributeNameHasBeenSet = true;
+    }
+    XmlNode attributeValueNode = resultNode.FirstChild("AttributeValue");
+    if(!attributeValueNode.IsNull())
+    {
+      m_attributeValue = Aws::Utils::Xml::DecodeEscapedXmlText(attributeValueNode.GetText());
+      m_attributeValueHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void PolicyAttributeDescription::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_attributeNameHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".AttributeName=" << StringUtils::URLEncode(m_attributeName.c_str()) << "&";
+  }
+
+  if(m_attributeValueHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".AttributeValue=" << StringUtils::URLEncode(m_attributeValue.c_str()) << "&";
+  }
+
+}
+
+void PolicyAttributeDescription::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_attributeNameHasBeenSet)
+  {
+      oStream << location << ".AttributeName=" << StringUtils::URLEncode(m_attributeName.c_str()) << "&";
+  }
+  if(m_attributeValueHasBeenSet)
+  {
+      oStream << location << ".AttributeValue=" << StringUtils::URLEncode(m_attributeValue.c_str()) << "&";
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/PolicyAttributeTypeDescription.cpp

@@ -0,0 +1,138 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/PolicyAttributeTypeDescription.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+PolicyAttributeTypeDescription::PolicyAttributeTypeDescription() : 
+    m_attributeNameHasBeenSet(false),
+    m_attributeTypeHasBeenSet(false),
+    m_descriptionHasBeenSet(false),
+    m_defaultValueHasBeenSet(false),
+    m_cardinalityHasBeenSet(false)
+{
+}
+
+PolicyAttributeTypeDescription::PolicyAttributeTypeDescription(const XmlNode& xmlNode) : 
+    m_attributeNameHasBeenSet(false),
+    m_attributeTypeHasBeenSet(false),
+    m_descriptionHasBeenSet(false),
+    m_defaultValueHasBeenSet(false),
+    m_cardinalityHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+PolicyAttributeTypeDescription& PolicyAttributeTypeDescription::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode attributeNameNode = resultNode.FirstChild("AttributeName");
+    if(!attributeNameNode.IsNull())
+    {
+      m_attributeName = Aws::Utils::Xml::DecodeEscapedXmlText(attributeNameNode.GetText());
+      m_attributeNameHasBeenSet = true;
+    }
+    XmlNode attributeTypeNode = resultNode.FirstChild("AttributeType");
+    if(!attributeTypeNode.IsNull())
+    {
+      m_attributeType = Aws::Utils::Xml::DecodeEscapedXmlText(attributeTypeNode.GetText());
+      m_attributeTypeHasBeenSet = true;
+    }
+    XmlNode descriptionNode = resultNode.FirstChild("Description");
+    if(!descriptionNode.IsNull())
+    {
+      m_description = Aws::Utils::Xml::DecodeEscapedXmlText(descriptionNode.GetText());
+      m_descriptionHasBeenSet = true;
+    }
+    XmlNode defaultValueNode = resultNode.FirstChild("DefaultValue");
+    if(!defaultValueNode.IsNull())
+    {
+      m_defaultValue = Aws::Utils::Xml::DecodeEscapedXmlText(defaultValueNode.GetText());
+      m_defaultValueHasBeenSet = true;
+    }
+    XmlNode cardinalityNode = resultNode.FirstChild("Cardinality");
+    if(!cardinalityNode.IsNull())
+    {
+      m_cardinality = Aws::Utils::Xml::DecodeEscapedXmlText(cardinalityNode.GetText());
+      m_cardinalityHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void PolicyAttributeTypeDescription::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_attributeNameHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".AttributeName=" << StringUtils::URLEncode(m_attributeName.c_str()) << "&";
+  }
+
+  if(m_attributeTypeHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".AttributeType=" << StringUtils::URLEncode(m_attributeType.c_str()) << "&";
+  }
+
+  if(m_descriptionHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".Description=" << StringUtils::URLEncode(m_description.c_str()) << "&";
+  }
+
+  if(m_defaultValueHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".DefaultValue=" << StringUtils::URLEncode(m_defaultValue.c_str()) << "&";
+  }
+
+  if(m_cardinalityHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".Cardinality=" << StringUtils::URLEncode(m_cardinality.c_str()) << "&";
+  }
+
+}
+
+void PolicyAttributeTypeDescription::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_attributeNameHasBeenSet)
+  {
+      oStream << location << ".AttributeName=" << StringUtils::URLEncode(m_attributeName.c_str()) << "&";
+  }
+  if(m_attributeTypeHasBeenSet)
+  {
+      oStream << location << ".AttributeType=" << StringUtils::URLEncode(m_attributeType.c_str()) << "&";
+  }
+  if(m_descriptionHasBeenSet)
+  {
+      oStream << location << ".Description=" << StringUtils::URLEncode(m_description.c_str()) << "&";
+  }
+  if(m_defaultValueHasBeenSet)
+  {
+      oStream << location << ".DefaultValue=" << StringUtils::URLEncode(m_defaultValue.c_str()) << "&";
+  }
+  if(m_cardinalityHasBeenSet)
+  {
+      oStream << location << ".Cardinality=" << StringUtils::URLEncode(m_cardinality.c_str()) << "&";
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/PolicyDescription.cpp

@@ -0,0 +1,122 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/PolicyDescription.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+PolicyDescription::PolicyDescription() : 
+    m_policyNameHasBeenSet(false),
+    m_policyTypeNameHasBeenSet(false),
+    m_policyAttributeDescriptionsHasBeenSet(false)
+{
+}
+
+PolicyDescription::PolicyDescription(const XmlNode& xmlNode) : 
+    m_policyNameHasBeenSet(false),
+    m_policyTypeNameHasBeenSet(false),
+    m_policyAttributeDescriptionsHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+PolicyDescription& PolicyDescription::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode policyNameNode = resultNode.FirstChild("PolicyName");
+    if(!policyNameNode.IsNull())
+    {
+      m_policyName = Aws::Utils::Xml::DecodeEscapedXmlText(policyNameNode.GetText());
+      m_policyNameHasBeenSet = true;
+    }
+    XmlNode policyTypeNameNode = resultNode.FirstChild("PolicyTypeName");
+    if(!policyTypeNameNode.IsNull())
+    {
+      m_policyTypeName = Aws::Utils::Xml::DecodeEscapedXmlText(policyTypeNameNode.GetText());
+      m_policyTypeNameHasBeenSet = true;
+    }
+    XmlNode policyAttributeDescriptionsNode = resultNode.FirstChild("PolicyAttributeDescriptions");
+    if(!policyAttributeDescriptionsNode.IsNull())
+    {
+      XmlNode policyAttributeDescriptionsMember = policyAttributeDescriptionsNode.FirstChild("member");
+      while(!policyAttributeDescriptionsMember.IsNull())
+      {
+        m_policyAttributeDescriptions.push_back(policyAttributeDescriptionsMember);
+        policyAttributeDescriptionsMember = policyAttributeDescriptionsMember.NextNode("member");
+      }
+
+      m_policyAttributeDescriptionsHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void PolicyDescription::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_policyNameHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".PolicyName=" << StringUtils::URLEncode(m_policyName.c_str()) << "&";
+  }
+
+  if(m_policyTypeNameHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".PolicyTypeName=" << StringUtils::URLEncode(m_policyTypeName.c_str()) << "&";
+  }
+
+  if(m_policyAttributeDescriptionsHasBeenSet)
+  {
+      unsigned policyAttributeDescriptionsIdx = 1;
+      for(auto& item : m_policyAttributeDescriptions)
+      {
+        Aws::StringStream policyAttributeDescriptionsSs;
+        policyAttributeDescriptionsSs << location << index << locationValue << ".PolicyAttributeDescriptions.member." << policyAttributeDescriptionsIdx++;
+        item.OutputToStream(oStream, policyAttributeDescriptionsSs.str().c_str());
+      }
+  }
+
+}
+
+void PolicyDescription::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_policyNameHasBeenSet)
+  {
+      oStream << location << ".PolicyName=" << StringUtils::URLEncode(m_policyName.c_str()) << "&";
+  }
+  if(m_policyTypeNameHasBeenSet)
+  {
+      oStream << location << ".PolicyTypeName=" << StringUtils::URLEncode(m_policyTypeName.c_str()) << "&";
+  }
+  if(m_policyAttributeDescriptionsHasBeenSet)
+  {
+      unsigned policyAttributeDescriptionsIdx = 1;
+      for(auto& item : m_policyAttributeDescriptions)
+      {
+        Aws::StringStream policyAttributeDescriptionsSs;
+        policyAttributeDescriptionsSs << location <<  ".PolicyAttributeDescriptions.member." << policyAttributeDescriptionsIdx++;
+        item.OutputToStream(oStream, policyAttributeDescriptionsSs.str().c_str());
+      }
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/PolicyTypeDescription.cpp

@@ -0,0 +1,122 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/PolicyTypeDescription.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+PolicyTypeDescription::PolicyTypeDescription() : 
+    m_policyTypeNameHasBeenSet(false),
+    m_descriptionHasBeenSet(false),
+    m_policyAttributeTypeDescriptionsHasBeenSet(false)
+{
+}
+
+PolicyTypeDescription::PolicyTypeDescription(const XmlNode& xmlNode) : 
+    m_policyTypeNameHasBeenSet(false),
+    m_descriptionHasBeenSet(false),
+    m_policyAttributeTypeDescriptionsHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+PolicyTypeDescription& PolicyTypeDescription::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode policyTypeNameNode = resultNode.FirstChild("PolicyTypeName");
+    if(!policyTypeNameNode.IsNull())
+    {
+      m_policyTypeName = Aws::Utils::Xml::DecodeEscapedXmlText(policyTypeNameNode.GetText());
+      m_policyTypeNameHasBeenSet = true;
+    }
+    XmlNode descriptionNode = resultNode.FirstChild("Description");
+    if(!descriptionNode.IsNull())
+    {
+      m_description = Aws::Utils::Xml::DecodeEscapedXmlText(descriptionNode.GetText());
+      m_descriptionHasBeenSet = true;
+    }
+    XmlNode policyAttributeTypeDescriptionsNode = resultNode.FirstChild("PolicyAttributeTypeDescriptions");
+    if(!policyAttributeTypeDescriptionsNode.IsNull())
+    {
+      XmlNode policyAttributeTypeDescriptionsMember = policyAttributeTypeDescriptionsNode.FirstChild("member");
+      while(!policyAttributeTypeDescriptionsMember.IsNull())
+      {
+        m_policyAttributeTypeDescriptions.push_back(policyAttributeTypeDescriptionsMember);
+        policyAttributeTypeDescriptionsMember = policyAttributeTypeDescriptionsMember.NextNode("member");
+      }
+
+      m_policyAttributeTypeDescriptionsHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void PolicyTypeDescription::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_policyTypeNameHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".PolicyTypeName=" << StringUtils::URLEncode(m_policyTypeName.c_str()) << "&";
+  }
+
+  if(m_descriptionHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".Description=" << StringUtils::URLEncode(m_description.c_str()) << "&";
+  }
+
+  if(m_policyAttributeTypeDescriptionsHasBeenSet)
+  {
+      unsigned policyAttributeTypeDescriptionsIdx = 1;
+      for(auto& item : m_policyAttributeTypeDescriptions)
+      {
+        Aws::StringStream policyAttributeTypeDescriptionsSs;
+        policyAttributeTypeDescriptionsSs << location << index << locationValue << ".PolicyAttributeTypeDescriptions.member." << policyAttributeTypeDescriptionsIdx++;
+        item.OutputToStream(oStream, policyAttributeTypeDescriptionsSs.str().c_str());
+      }
+  }
+
+}
+
+void PolicyTypeDescription::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_policyTypeNameHasBeenSet)
+  {
+      oStream << location << ".PolicyTypeName=" << StringUtils::URLEncode(m_policyTypeName.c_str()) << "&";
+  }
+  if(m_descriptionHasBeenSet)
+  {
+      oStream << location << ".Description=" << StringUtils::URLEncode(m_description.c_str()) << "&";
+  }
+  if(m_policyAttributeTypeDescriptionsHasBeenSet)
+  {
+      unsigned policyAttributeTypeDescriptionsIdx = 1;
+      for(auto& item : m_policyAttributeTypeDescriptions)
+      {
+        Aws::StringStream policyAttributeTypeDescriptionsSs;
+        policyAttributeTypeDescriptionsSs << location <<  ".PolicyAttributeTypeDescriptions.member." << policyAttributeTypeDescriptionsIdx++;
+        item.OutputToStream(oStream, policyAttributeTypeDescriptionsSs.str().c_str());
+      }
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/RegisterInstancesWithLoadBalancerRequest.cpp

@@ -0,0 +1,46 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/RegisterInstancesWithLoadBalancerRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+RegisterInstancesWithLoadBalancerRequest::RegisterInstancesWithLoadBalancerRequest() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_instancesHasBeenSet(false)
+{
+}
+
+Aws::String RegisterInstancesWithLoadBalancerRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=RegisterInstancesWithLoadBalancer&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_instancesHasBeenSet)
+  {
+    unsigned instancesCount = 1;
+    for(auto& item : m_instances)
+    {
+      item.OutputToStream(ss, "Instances.member.", instancesCount, "");
+      instancesCount++;
+    }
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  RegisterInstancesWithLoadBalancerRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/RegisterInstancesWithLoadBalancerResult.cpp

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/RegisterInstancesWithLoadBalancerResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+RegisterInstancesWithLoadBalancerResult::RegisterInstancesWithLoadBalancerResult()
+{
+}
+
+RegisterInstancesWithLoadBalancerResult::RegisterInstancesWithLoadBalancerResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+RegisterInstancesWithLoadBalancerResult& RegisterInstancesWithLoadBalancerResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "RegisterInstancesWithLoadBalancerResult"))
+  {
+    resultNode = rootNode.FirstChild("RegisterInstancesWithLoadBalancerResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode instancesNode = resultNode.FirstChild("Instances");
+    if(!instancesNode.IsNull())
+    {
+      XmlNode instancesMember = instancesNode.FirstChild("member");
+      while(!instancesMember.IsNull())
+      {
+        m_instances.push_back(instancesMember);
+        instancesMember = instancesMember.NextNode("member");
+      }
+
+    }
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::RegisterInstancesWithLoadBalancerResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/RemoveTagsRequest.cpp

@@ -0,0 +1,52 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/RemoveTagsRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+RemoveTagsRequest::RemoveTagsRequest() : 
+    m_loadBalancerNamesHasBeenSet(false),
+    m_tagsHasBeenSet(false)
+{
+}
+
+Aws::String RemoveTagsRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=RemoveTags&";
+  if(m_loadBalancerNamesHasBeenSet)
+  {
+    unsigned loadBalancerNamesCount = 1;
+    for(auto& item : m_loadBalancerNames)
+    {
+      ss << "LoadBalancerNames.member." << loadBalancerNamesCount << "="
+          << StringUtils::URLEncode(item.c_str()) << "&";
+      loadBalancerNamesCount++;
+    }
+  }
+
+  if(m_tagsHasBeenSet)
+  {
+    unsigned tagsCount = 1;
+    for(auto& item : m_tags)
+    {
+      item.OutputToStream(ss, "Tags.member.", tagsCount, "");
+      tagsCount++;
+    }
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  RemoveTagsRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/RemoveTagsResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/RemoveTagsResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+RemoveTagsResult::RemoveTagsResult()
+{
+}
+
+RemoveTagsResult::RemoveTagsResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+RemoveTagsResult& RemoveTagsResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "RemoveTagsResult"))
+  {
+    resultNode = rootNode.FirstChild("RemoveTagsResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::RemoveTagsResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/ResponseMetadata.cpp

@@ -0,0 +1,70 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/ResponseMetadata.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+ResponseMetadata::ResponseMetadata() : 
+    m_requestIdHasBeenSet(false)
+{
+}
+
+ResponseMetadata::ResponseMetadata(const XmlNode& xmlNode) : 
+    m_requestIdHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+ResponseMetadata& ResponseMetadata::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode requestIdNode = resultNode.FirstChild("RequestId");
+    if(!requestIdNode.IsNull())
+    {
+      m_requestId = Aws::Utils::Xml::DecodeEscapedXmlText(requestIdNode.GetText());
+      m_requestIdHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void ResponseMetadata::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_requestIdHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".RequestId=" << StringUtils::URLEncode(m_requestId.c_str()) << "&";
+  }
+
+}
+
+void ResponseMetadata::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_requestIdHasBeenSet)
+  {
+      oStream << location << ".RequestId=" << StringUtils::URLEncode(m_requestId.c_str()) << "&";
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/SetLoadBalancerListenerSSLCertificateRequest.cpp

@@ -0,0 +1,48 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/SetLoadBalancerListenerSSLCertificateRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+SetLoadBalancerListenerSSLCertificateRequest::SetLoadBalancerListenerSSLCertificateRequest() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_loadBalancerPort(0),
+    m_loadBalancerPortHasBeenSet(false),
+    m_sSLCertificateIdHasBeenSet(false)
+{
+}
+
+Aws::String SetLoadBalancerListenerSSLCertificateRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=SetLoadBalancerListenerSSLCertificate&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_loadBalancerPortHasBeenSet)
+  {
+    ss << "LoadBalancerPort=" << m_loadBalancerPort << "&";
+  }
+
+  if(m_sSLCertificateIdHasBeenSet)
+  {
+    ss << "SSLCertificateId=" << StringUtils::URLEncode(m_sSLCertificateId.c_str()) << "&";
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  SetLoadBalancerListenerSSLCertificateRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/SetLoadBalancerListenerSSLCertificateResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/SetLoadBalancerListenerSSLCertificateResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+SetLoadBalancerListenerSSLCertificateResult::SetLoadBalancerListenerSSLCertificateResult()
+{
+}
+
+SetLoadBalancerListenerSSLCertificateResult::SetLoadBalancerListenerSSLCertificateResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+SetLoadBalancerListenerSSLCertificateResult& SetLoadBalancerListenerSSLCertificateResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "SetLoadBalancerListenerSSLCertificateResult"))
+  {
+    resultNode = rootNode.FirstChild("SetLoadBalancerListenerSSLCertificateResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::SetLoadBalancerListenerSSLCertificateResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/SetLoadBalancerPoliciesForBackendServerRequest.cpp

@@ -0,0 +1,54 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/SetLoadBalancerPoliciesForBackendServerRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+SetLoadBalancerPoliciesForBackendServerRequest::SetLoadBalancerPoliciesForBackendServerRequest() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_instancePort(0),
+    m_instancePortHasBeenSet(false),
+    m_policyNamesHasBeenSet(false)
+{
+}
+
+Aws::String SetLoadBalancerPoliciesForBackendServerRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=SetLoadBalancerPoliciesForBackendServer&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_instancePortHasBeenSet)
+  {
+    ss << "InstancePort=" << m_instancePort << "&";
+  }
+
+  if(m_policyNamesHasBeenSet)
+  {
+    unsigned policyNamesCount = 1;
+    for(auto& item : m_policyNames)
+    {
+      ss << "PolicyNames.member." << policyNamesCount << "="
+          << StringUtils::URLEncode(item.c_str()) << "&";
+      policyNamesCount++;
+    }
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  SetLoadBalancerPoliciesForBackendServerRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/SetLoadBalancerPoliciesForBackendServerResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/SetLoadBalancerPoliciesForBackendServerResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+SetLoadBalancerPoliciesForBackendServerResult::SetLoadBalancerPoliciesForBackendServerResult()
+{
+}
+
+SetLoadBalancerPoliciesForBackendServerResult::SetLoadBalancerPoliciesForBackendServerResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+SetLoadBalancerPoliciesForBackendServerResult& SetLoadBalancerPoliciesForBackendServerResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "SetLoadBalancerPoliciesForBackendServerResult"))
+  {
+    resultNode = rootNode.FirstChild("SetLoadBalancerPoliciesForBackendServerResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::SetLoadBalancerPoliciesForBackendServerResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/SetLoadBalancerPoliciesOfListenerRequest.cpp

@@ -0,0 +1,54 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/SetLoadBalancerPoliciesOfListenerRequest.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils;
+
+SetLoadBalancerPoliciesOfListenerRequest::SetLoadBalancerPoliciesOfListenerRequest() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_loadBalancerPort(0),
+    m_loadBalancerPortHasBeenSet(false),
+    m_policyNamesHasBeenSet(false)
+{
+}
+
+Aws::String SetLoadBalancerPoliciesOfListenerRequest::SerializePayload() const
+{
+  Aws::StringStream ss;
+  ss << "Action=SetLoadBalancerPoliciesOfListener&";
+  if(m_loadBalancerNameHasBeenSet)
+  {
+    ss << "LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_loadBalancerPortHasBeenSet)
+  {
+    ss << "LoadBalancerPort=" << m_loadBalancerPort << "&";
+  }
+
+  if(m_policyNamesHasBeenSet)
+  {
+    unsigned policyNamesCount = 1;
+    for(auto& item : m_policyNames)
+    {
+      ss << "PolicyNames.member." << policyNamesCount << "="
+          << StringUtils::URLEncode(item.c_str()) << "&";
+      policyNamesCount++;
+    }
+  }
+
+  ss << "Version=2012-06-01";
+  return ss.str();
+}
+
+
+void  SetLoadBalancerPoliciesOfListenerRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
+{
+  uri.SetQueryString(SerializePayload());
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/SetLoadBalancerPoliciesOfListenerResult.cpp

@@ -0,0 +1,49 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/SetLoadBalancerPoliciesOfListenerResult.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <utility>
+
+using namespace Aws::ElasticLoadBalancing::Model;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils;
+using namespace Aws;
+
+SetLoadBalancerPoliciesOfListenerResult::SetLoadBalancerPoliciesOfListenerResult()
+{
+}
+
+SetLoadBalancerPoliciesOfListenerResult::SetLoadBalancerPoliciesOfListenerResult(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  *this = result;
+}
+
+SetLoadBalancerPoliciesOfListenerResult& SetLoadBalancerPoliciesOfListenerResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
+{
+  const XmlDocument& xmlDocument = result.GetPayload();
+  XmlNode rootNode = xmlDocument.GetRootElement();
+  XmlNode resultNode = rootNode;
+  if (!rootNode.IsNull() && (rootNode.GetName() != "SetLoadBalancerPoliciesOfListenerResult"))
+  {
+    resultNode = rootNode.FirstChild("SetLoadBalancerPoliciesOfListenerResult");
+  }
+
+  if(!resultNode.IsNull())
+  {
+  }
+
+  if (!rootNode.IsNull()) {
+    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
+    m_responseMetadata = responseMetadataNode;
+    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::SetLoadBalancerPoliciesOfListenerResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
+  }
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/SourceSecurityGroup.cpp

@@ -0,0 +1,87 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/SourceSecurityGroup.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+SourceSecurityGroup::SourceSecurityGroup() : 
+    m_ownerAliasHasBeenSet(false),
+    m_groupNameHasBeenSet(false)
+{
+}
+
+SourceSecurityGroup::SourceSecurityGroup(const XmlNode& xmlNode) : 
+    m_ownerAliasHasBeenSet(false),
+    m_groupNameHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+SourceSecurityGroup& SourceSecurityGroup::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode ownerAliasNode = resultNode.FirstChild("OwnerAlias");
+    if(!ownerAliasNode.IsNull())
+    {
+      m_ownerAlias = Aws::Utils::Xml::DecodeEscapedXmlText(ownerAliasNode.GetText());
+      m_ownerAliasHasBeenSet = true;
+    }
+    XmlNode groupNameNode = resultNode.FirstChild("GroupName");
+    if(!groupNameNode.IsNull())
+    {
+      m_groupName = Aws::Utils::Xml::DecodeEscapedXmlText(groupNameNode.GetText());
+      m_groupNameHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void SourceSecurityGroup::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_ownerAliasHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".OwnerAlias=" << StringUtils::URLEncode(m_ownerAlias.c_str()) << "&";
+  }
+
+  if(m_groupNameHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".GroupName=" << StringUtils::URLEncode(m_groupName.c_str()) << "&";
+  }
+
+}
+
+void SourceSecurityGroup::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_ownerAliasHasBeenSet)
+  {
+      oStream << location << ".OwnerAlias=" << StringUtils::URLEncode(m_ownerAlias.c_str()) << "&";
+  }
+  if(m_groupNameHasBeenSet)
+  {
+      oStream << location << ".GroupName=" << StringUtils::URLEncode(m_groupName.c_str()) << "&";
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/Tag.cpp

@@ -0,0 +1,87 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/Tag.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+Tag::Tag() : 
+    m_keyHasBeenSet(false),
+    m_valueHasBeenSet(false)
+{
+}
+
+Tag::Tag(const XmlNode& xmlNode) : 
+    m_keyHasBeenSet(false),
+    m_valueHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+Tag& Tag::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode keyNode = resultNode.FirstChild("Key");
+    if(!keyNode.IsNull())
+    {
+      m_key = Aws::Utils::Xml::DecodeEscapedXmlText(keyNode.GetText());
+      m_keyHasBeenSet = true;
+    }
+    XmlNode valueNode = resultNode.FirstChild("Value");
+    if(!valueNode.IsNull())
+    {
+      m_value = Aws::Utils::Xml::DecodeEscapedXmlText(valueNode.GetText());
+      m_valueHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void Tag::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_keyHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".Key=" << StringUtils::URLEncode(m_key.c_str()) << "&";
+  }
+
+  if(m_valueHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".Value=" << StringUtils::URLEncode(m_value.c_str()) << "&";
+  }
+
+}
+
+void Tag::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_keyHasBeenSet)
+  {
+      oStream << location << ".Key=" << StringUtils::URLEncode(m_key.c_str()) << "&";
+  }
+  if(m_valueHasBeenSet)
+  {
+      oStream << location << ".Value=" << StringUtils::URLEncode(m_value.c_str()) << "&";
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/TagDescription.cpp

@@ -0,0 +1,105 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/TagDescription.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+TagDescription::TagDescription() : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_tagsHasBeenSet(false)
+{
+}
+
+TagDescription::TagDescription(const XmlNode& xmlNode) : 
+    m_loadBalancerNameHasBeenSet(false),
+    m_tagsHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+TagDescription& TagDescription::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode loadBalancerNameNode = resultNode.FirstChild("LoadBalancerName");
+    if(!loadBalancerNameNode.IsNull())
+    {
+      m_loadBalancerName = Aws::Utils::Xml::DecodeEscapedXmlText(loadBalancerNameNode.GetText());
+      m_loadBalancerNameHasBeenSet = true;
+    }
+    XmlNode tagsNode = resultNode.FirstChild("Tags");
+    if(!tagsNode.IsNull())
+    {
+      XmlNode tagsMember = tagsNode.FirstChild("member");
+      while(!tagsMember.IsNull())
+      {
+        m_tags.push_back(tagsMember);
+        tagsMember = tagsMember.NextNode("member");
+      }
+
+      m_tagsHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void TagDescription::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_loadBalancerNameHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+
+  if(m_tagsHasBeenSet)
+  {
+      unsigned tagsIdx = 1;
+      for(auto& item : m_tags)
+      {
+        Aws::StringStream tagsSs;
+        tagsSs << location << index << locationValue << ".Tags.member." << tagsIdx++;
+        item.OutputToStream(oStream, tagsSs.str().c_str());
+      }
+  }
+
+}
+
+void TagDescription::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_loadBalancerNameHasBeenSet)
+  {
+      oStream << location << ".LoadBalancerName=" << StringUtils::URLEncode(m_loadBalancerName.c_str()) << "&";
+  }
+  if(m_tagsHasBeenSet)
+  {
+      unsigned tagsIdx = 1;
+      for(auto& item : m_tags)
+      {
+        Aws::StringStream tagsSs;
+        tagsSs << location <<  ".Tags.member." << tagsIdx++;
+        item.OutputToStream(oStream, tagsSs.str().c_str());
+      }
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-elasticloadbalancing/source/model/TagKeyOnly.cpp

@@ -0,0 +1,70 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/elasticloadbalancing/model/TagKeyOnly.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Xml;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace ElasticLoadBalancing
+{
+namespace Model
+{
+
+TagKeyOnly::TagKeyOnly() : 
+    m_keyHasBeenSet(false)
+{
+}
+
+TagKeyOnly::TagKeyOnly(const XmlNode& xmlNode) : 
+    m_keyHasBeenSet(false)
+{
+  *this = xmlNode;
+}
+
+TagKeyOnly& TagKeyOnly::operator =(const XmlNode& xmlNode)
+{
+  XmlNode resultNode = xmlNode;
+
+  if(!resultNode.IsNull())
+  {
+    XmlNode keyNode = resultNode.FirstChild("Key");
+    if(!keyNode.IsNull())
+    {
+      m_key = Aws::Utils::Xml::DecodeEscapedXmlText(keyNode.GetText());
+      m_keyHasBeenSet = true;
+    }
+  }
+
+  return *this;
+}
+
+void TagKeyOnly::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
+{
+  if(m_keyHasBeenSet)
+  {
+      oStream << location << index << locationValue << ".Key=" << StringUtils::URLEncode(m_key.c_str()) << "&";
+  }
+
+}
+
+void TagKeyOnly::OutputToStream(Aws::OStream& oStream, const char* location) const
+{
+  if(m_keyHasBeenSet)
+  {
+      oStream << location << ".Key=" << StringUtils::URLEncode(m_key.c_str()) << "&";
+  }
+}
+
+} // namespace Model
+} // namespace ElasticLoadBalancing
+} // namespace Aws