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

support/aws-sdk-cpp-master/aws-cpp-sdk-meteringmarketplace/source/MarketplaceMeteringClient.cpp

@@ -0,0 +1,208 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/core/utils/Outcome.h>
+#include <aws/core/auth/AWSAuthSigner.h>
+#include <aws/core/client/CoreErrors.h>
+#include <aws/core/client/RetryStrategy.h>
+#include <aws/core/http/HttpClient.h>
+#include <aws/core/http/HttpResponse.h>
+#include <aws/core/http/HttpClientFactory.h>
+#include <aws/core/auth/AWSCredentialsProviderChain.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+#include <aws/core/utils/threading/Executor.h>
+#include <aws/core/utils/DNS.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+#include <aws/meteringmarketplace/MarketplaceMeteringClient.h>
+#include <aws/meteringmarketplace/MarketplaceMeteringEndpoint.h>
+#include <aws/meteringmarketplace/MarketplaceMeteringErrorMarshaller.h>
+#include <aws/meteringmarketplace/model/BatchMeterUsageRequest.h>
+#include <aws/meteringmarketplace/model/MeterUsageRequest.h>
+#include <aws/meteringmarketplace/model/RegisterUsageRequest.h>
+#include <aws/meteringmarketplace/model/ResolveCustomerRequest.h>
+
+using namespace Aws;
+using namespace Aws::Auth;
+using namespace Aws::Client;
+using namespace Aws::MarketplaceMetering;
+using namespace Aws::MarketplaceMetering::Model;
+using namespace Aws::Http;
+using namespace Aws::Utils::Json;
+
+static const char* SERVICE_NAME = "aws-marketplace";
+static const char* ALLOCATION_TAG = "MarketplaceMeteringClient";
+
+
+MarketplaceMeteringClient::MarketplaceMeteringClient(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<MarketplaceMeteringErrorMarshaller>(ALLOCATION_TAG)),
+    m_executor(clientConfiguration.executor)
+{
+  init(clientConfiguration);
+}
+
+MarketplaceMeteringClient::MarketplaceMeteringClient(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<MarketplaceMeteringErrorMarshaller>(ALLOCATION_TAG)),
+    m_executor(clientConfiguration.executor)
+{
+  init(clientConfiguration);
+}
+
+MarketplaceMeteringClient::MarketplaceMeteringClient(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<MarketplaceMeteringErrorMarshaller>(ALLOCATION_TAG)),
+    m_executor(clientConfiguration.executor)
+{
+  init(clientConfiguration);
+}
+
+MarketplaceMeteringClient::~MarketplaceMeteringClient()
+{
+}
+
+void MarketplaceMeteringClient::init(const ClientConfiguration& config)
+{
+  SetServiceClientName("Marketplace Metering");
+  m_configScheme = SchemeMapper::ToString(config.scheme);
+  if (config.endpointOverride.empty())
+  {
+      m_uri = m_configScheme + "://" + MarketplaceMeteringEndpoint::ForRegion(config.region, config.useDualStack);
+  }
+  else
+  {
+      OverrideEndpoint(config.endpointOverride);
+  }
+}
+
+void MarketplaceMeteringClient::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;
+  }
+}
+
+BatchMeterUsageOutcome MarketplaceMeteringClient::BatchMeterUsage(const BatchMeterUsageRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return BatchMeterUsageOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+BatchMeterUsageOutcomeCallable MarketplaceMeteringClient::BatchMeterUsageCallable(const BatchMeterUsageRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< BatchMeterUsageOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchMeterUsage(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void MarketplaceMeteringClient::BatchMeterUsageAsync(const BatchMeterUsageRequest& request, const BatchMeterUsageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->BatchMeterUsageAsyncHelper( request, handler, context ); } );
+}
+
+void MarketplaceMeteringClient::BatchMeterUsageAsyncHelper(const BatchMeterUsageRequest& request, const BatchMeterUsageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, BatchMeterUsage(request), context);
+}
+
+MeterUsageOutcome MarketplaceMeteringClient::MeterUsage(const MeterUsageRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return MeterUsageOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+MeterUsageOutcomeCallable MarketplaceMeteringClient::MeterUsageCallable(const MeterUsageRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< MeterUsageOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->MeterUsage(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void MarketplaceMeteringClient::MeterUsageAsync(const MeterUsageRequest& request, const MeterUsageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->MeterUsageAsyncHelper( request, handler, context ); } );
+}
+
+void MarketplaceMeteringClient::MeterUsageAsyncHelper(const MeterUsageRequest& request, const MeterUsageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, MeterUsage(request), context);
+}
+
+RegisterUsageOutcome MarketplaceMeteringClient::RegisterUsage(const RegisterUsageRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return RegisterUsageOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+RegisterUsageOutcomeCallable MarketplaceMeteringClient::RegisterUsageCallable(const RegisterUsageRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< RegisterUsageOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->RegisterUsage(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void MarketplaceMeteringClient::RegisterUsageAsync(const RegisterUsageRequest& request, const RegisterUsageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->RegisterUsageAsyncHelper( request, handler, context ); } );
+}
+
+void MarketplaceMeteringClient::RegisterUsageAsyncHelper(const RegisterUsageRequest& request, const RegisterUsageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, RegisterUsage(request), context);
+}
+
+ResolveCustomerOutcome MarketplaceMeteringClient::ResolveCustomer(const ResolveCustomerRequest& request) const
+{
+  Aws::Http::URI uri = m_uri;
+  Aws::StringStream ss;
+  ss << "/";
+  uri.SetPath(uri.GetPath() + ss.str());
+  return ResolveCustomerOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
+}
+
+ResolveCustomerOutcomeCallable MarketplaceMeteringClient::ResolveCustomerCallable(const ResolveCustomerRequest& request) const
+{
+  auto task = Aws::MakeShared< std::packaged_task< ResolveCustomerOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ResolveCustomer(request); } );
+  auto packagedFunction = [task]() { (*task)(); };
+  m_executor->Submit(packagedFunction);
+  return task->get_future();
+}
+
+void MarketplaceMeteringClient::ResolveCustomerAsync(const ResolveCustomerRequest& request, const ResolveCustomerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  m_executor->Submit( [this, request, handler, context](){ this->ResolveCustomerAsyncHelper( request, handler, context ); } );
+}
+
+void MarketplaceMeteringClient::ResolveCustomerAsyncHelper(const ResolveCustomerRequest& request, const ResolveCustomerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
+{
+  handler(this, request, ResolveCustomer(request), context);
+}
+

support/aws-sdk-cpp-master/aws-cpp-sdk-meteringmarketplace/source/MarketplaceMeteringEndpoint.cpp

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

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

support/aws-sdk-cpp-master/aws-cpp-sdk-meteringmarketplace/source/MarketplaceMeteringErrors.cpp

@@ -0,0 +1,102 @@
+/**
+ * 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/meteringmarketplace/MarketplaceMeteringErrors.h>
+
+using namespace Aws::Client;
+using namespace Aws::Utils;
+using namespace Aws::MarketplaceMetering;
+
+namespace Aws
+{
+namespace MarketplaceMetering
+{
+namespace MarketplaceMeteringErrorMapper
+{
+
+static const int INVALID_CUSTOMER_IDENTIFIER_HASH = HashingUtils::HashString("InvalidCustomerIdentifierException");
+static const int INVALID_TOKEN_HASH = HashingUtils::HashString("InvalidTokenException");
+static const int INVALID_USAGE_DIMENSION_HASH = HashingUtils::HashString("InvalidUsageDimensionException");
+static const int EXPIRED_TOKEN_HASH = HashingUtils::HashString("ExpiredTokenException");
+static const int DISABLED_API_HASH = HashingUtils::HashString("DisabledApiException");
+static const int INVALID_ENDPOINT_REGION_HASH = HashingUtils::HashString("InvalidEndpointRegionException");
+static const int PLATFORM_NOT_SUPPORTED_HASH = HashingUtils::HashString("PlatformNotSupportedException");
+static const int INVALID_PRODUCT_CODE_HASH = HashingUtils::HashString("InvalidProductCodeException");
+static const int DUPLICATE_REQUEST_HASH = HashingUtils::HashString("DuplicateRequestException");
+static const int CUSTOMER_NOT_ENTITLED_HASH = HashingUtils::HashString("CustomerNotEntitledException");
+static const int INVALID_REGION_HASH = HashingUtils::HashString("InvalidRegionException");
+static const int TIMESTAMP_OUT_OF_BOUNDS_HASH = HashingUtils::HashString("TimestampOutOfBoundsException");
+static const int INVALID_PUBLIC_KEY_VERSION_HASH = HashingUtils::HashString("InvalidPublicKeyVersionException");
+static const int INTERNAL_SERVICE_ERROR_HASH = HashingUtils::HashString("InternalServiceErrorException");
+
+
+AWSError<CoreErrors> GetErrorForName(const char* errorName)
+{
+  int hashCode = HashingUtils::HashString(errorName);
+
+  if (hashCode == INVALID_CUSTOMER_IDENTIFIER_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(MarketplaceMeteringErrors::INVALID_CUSTOMER_IDENTIFIER), false);
+  }
+  else if (hashCode == INVALID_TOKEN_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(MarketplaceMeteringErrors::INVALID_TOKEN), false);
+  }
+  else if (hashCode == INVALID_USAGE_DIMENSION_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(MarketplaceMeteringErrors::INVALID_USAGE_DIMENSION), false);
+  }
+  else if (hashCode == EXPIRED_TOKEN_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(MarketplaceMeteringErrors::EXPIRED_TOKEN), false);
+  }
+  else if (hashCode == DISABLED_API_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(MarketplaceMeteringErrors::DISABLED_API), false);
+  }
+  else if (hashCode == INVALID_ENDPOINT_REGION_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(MarketplaceMeteringErrors::INVALID_ENDPOINT_REGION), false);
+  }
+  else if (hashCode == PLATFORM_NOT_SUPPORTED_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(MarketplaceMeteringErrors::PLATFORM_NOT_SUPPORTED), false);
+  }
+  else if (hashCode == INVALID_PRODUCT_CODE_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(MarketplaceMeteringErrors::INVALID_PRODUCT_CODE), false);
+  }
+  else if (hashCode == DUPLICATE_REQUEST_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(MarketplaceMeteringErrors::DUPLICATE_REQUEST), false);
+  }
+  else if (hashCode == CUSTOMER_NOT_ENTITLED_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(MarketplaceMeteringErrors::CUSTOMER_NOT_ENTITLED), false);
+  }
+  else if (hashCode == INVALID_REGION_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(MarketplaceMeteringErrors::INVALID_REGION), false);
+  }
+  else if (hashCode == TIMESTAMP_OUT_OF_BOUNDS_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(MarketplaceMeteringErrors::TIMESTAMP_OUT_OF_BOUNDS), false);
+  }
+  else if (hashCode == INVALID_PUBLIC_KEY_VERSION_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(MarketplaceMeteringErrors::INVALID_PUBLIC_KEY_VERSION), false);
+  }
+  else if (hashCode == INTERNAL_SERVICE_ERROR_HASH)
+  {
+    return AWSError<CoreErrors>(static_cast<CoreErrors>(MarketplaceMeteringErrors::INTERNAL_SERVICE_ERROR), false);
+  }
+  return AWSError<CoreErrors>(CoreErrors::UNKNOWN, false);
+}
+
+} // namespace MarketplaceMeteringErrorMapper
+} // namespace MarketplaceMetering
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-meteringmarketplace/source/model/BatchMeterUsageRequest.cpp

@@ -0,0 +1,55 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/meteringmarketplace/model/BatchMeterUsageRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::MarketplaceMetering::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+BatchMeterUsageRequest::BatchMeterUsageRequest() : 
+    m_usageRecordsHasBeenSet(false),
+    m_productCodeHasBeenSet(false)
+{
+}
+
+Aws::String BatchMeterUsageRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_usageRecordsHasBeenSet)
+  {
+   Array<JsonValue> usageRecordsJsonList(m_usageRecords.size());
+   for(unsigned usageRecordsIndex = 0; usageRecordsIndex < usageRecordsJsonList.GetLength(); ++usageRecordsIndex)
+   {
+     usageRecordsJsonList[usageRecordsIndex].AsObject(m_usageRecords[usageRecordsIndex].Jsonize());
+   }
+   payload.WithArray("UsageRecords", std::move(usageRecordsJsonList));
+
+  }
+
+  if(m_productCodeHasBeenSet)
+  {
+   payload.WithString("ProductCode", m_productCode);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection BatchMeterUsageRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "AWSMPMeteringService.BatchMeterUsage"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-meteringmarketplace/source/model/BatchMeterUsageResult.cpp

@@ -0,0 +1,52 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/meteringmarketplace/model/BatchMeterUsageResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::MarketplaceMetering::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+BatchMeterUsageResult::BatchMeterUsageResult()
+{
+}
+
+BatchMeterUsageResult::BatchMeterUsageResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+BatchMeterUsageResult& BatchMeterUsageResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("Results"))
+  {
+    Array<JsonView> resultsJsonList = jsonValue.GetArray("Results");
+    for(unsigned resultsIndex = 0; resultsIndex < resultsJsonList.GetLength(); ++resultsIndex)
+    {
+      m_results.push_back(resultsJsonList[resultsIndex].AsObject());
+    }
+  }
+
+  if(jsonValue.ValueExists("UnprocessedRecords"))
+  {
+    Array<JsonView> unprocessedRecordsJsonList = jsonValue.GetArray("UnprocessedRecords");
+    for(unsigned unprocessedRecordsIndex = 0; unprocessedRecordsIndex < unprocessedRecordsJsonList.GetLength(); ++unprocessedRecordsIndex)
+    {
+      m_unprocessedRecords.push_back(unprocessedRecordsJsonList[unprocessedRecordsIndex].AsObject());
+    }
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-meteringmarketplace/source/model/MeterUsageRequest.cpp

@@ -0,0 +1,72 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/meteringmarketplace/model/MeterUsageRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::MarketplaceMetering::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+MeterUsageRequest::MeterUsageRequest() : 
+    m_productCodeHasBeenSet(false),
+    m_timestampHasBeenSet(false),
+    m_usageDimensionHasBeenSet(false),
+    m_usageQuantity(0),
+    m_usageQuantityHasBeenSet(false),
+    m_dryRun(false),
+    m_dryRunHasBeenSet(false)
+{
+}
+
+Aws::String MeterUsageRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_productCodeHasBeenSet)
+  {
+   payload.WithString("ProductCode", m_productCode);
+
+  }
+
+  if(m_timestampHasBeenSet)
+  {
+   payload.WithDouble("Timestamp", m_timestamp.SecondsWithMSPrecision());
+  }
+
+  if(m_usageDimensionHasBeenSet)
+  {
+   payload.WithString("UsageDimension", m_usageDimension);
+
+  }
+
+  if(m_usageQuantityHasBeenSet)
+  {
+   payload.WithInteger("UsageQuantity", m_usageQuantity);
+
+  }
+
+  if(m_dryRunHasBeenSet)
+  {
+   payload.WithBool("DryRun", m_dryRun);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection MeterUsageRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "AWSMPMeteringService.MeterUsage"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-meteringmarketplace/source/model/MeterUsageResult.cpp

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

support/aws-sdk-cpp-master/aws-cpp-sdk-meteringmarketplace/source/model/RegisterUsageRequest.cpp

@@ -0,0 +1,58 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/meteringmarketplace/model/RegisterUsageRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::MarketplaceMetering::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+RegisterUsageRequest::RegisterUsageRequest() : 
+    m_productCodeHasBeenSet(false),
+    m_publicKeyVersion(0),
+    m_publicKeyVersionHasBeenSet(false),
+    m_nonceHasBeenSet(false)
+{
+}
+
+Aws::String RegisterUsageRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_productCodeHasBeenSet)
+  {
+   payload.WithString("ProductCode", m_productCode);
+
+  }
+
+  if(m_publicKeyVersionHasBeenSet)
+  {
+   payload.WithInteger("PublicKeyVersion", m_publicKeyVersion);
+
+  }
+
+  if(m_nonceHasBeenSet)
+  {
+   payload.WithString("Nonce", m_nonce);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection RegisterUsageRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "AWSMPMeteringService.RegisterUsage"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-meteringmarketplace/source/model/RegisterUsageResult.cpp

@@ -0,0 +1,46 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/meteringmarketplace/model/RegisterUsageResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/AmazonWebServiceResult.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+#include <utility>
+
+using namespace Aws::MarketplaceMetering::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+using namespace Aws;
+
+RegisterUsageResult::RegisterUsageResult()
+{
+}
+
+RegisterUsageResult::RegisterUsageResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  *this = result;
+}
+
+RegisterUsageResult& RegisterUsageResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
+{
+  JsonView jsonValue = result.GetPayload().View();
+  if(jsonValue.ValueExists("PublicKeyRotationTimestamp"))
+  {
+    m_publicKeyRotationTimestamp = jsonValue.GetDouble("PublicKeyRotationTimestamp");
+
+  }
+
+  if(jsonValue.ValueExists("Signature"))
+  {
+    m_signature = jsonValue.GetString("Signature");
+
+  }
+
+
+
+  return *this;
+}

support/aws-sdk-cpp-master/aws-cpp-sdk-meteringmarketplace/source/model/ResolveCustomerRequest.cpp

@@ -0,0 +1,43 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/meteringmarketplace/model/ResolveCustomerRequest.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::MarketplaceMetering::Model;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+ResolveCustomerRequest::ResolveCustomerRequest() : 
+    m_registrationTokenHasBeenSet(false)
+{
+}
+
+Aws::String ResolveCustomerRequest::SerializePayload() const
+{
+  JsonValue payload;
+
+  if(m_registrationTokenHasBeenSet)
+  {
+   payload.WithString("RegistrationToken", m_registrationToken);
+
+  }
+
+  return payload.View().WriteReadable();
+}
+
+Aws::Http::HeaderValueCollection ResolveCustomerRequest::GetRequestSpecificHeaders() const
+{
+  Aws::Http::HeaderValueCollection headers;
+  headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "AWSMPMeteringService.ResolveCustomer"));
+  return headers;
+
+}
+
+
+
+

support/aws-sdk-cpp-master/aws-cpp-sdk-meteringmarketplace/source/model/ResolveCustomerResult.cpp

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

support/aws-sdk-cpp-master/aws-cpp-sdk-meteringmarketplace/source/model/UsageRecord.cpp

@@ -0,0 +1,105 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/meteringmarketplace/model/UsageRecord.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace MarketplaceMetering
+{
+namespace Model
+{
+
+UsageRecord::UsageRecord() : 
+    m_timestampHasBeenSet(false),
+    m_customerIdentifierHasBeenSet(false),
+    m_dimensionHasBeenSet(false),
+    m_quantity(0),
+    m_quantityHasBeenSet(false)
+{
+}
+
+UsageRecord::UsageRecord(JsonView jsonValue) : 
+    m_timestampHasBeenSet(false),
+    m_customerIdentifierHasBeenSet(false),
+    m_dimensionHasBeenSet(false),
+    m_quantity(0),
+    m_quantityHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+UsageRecord& UsageRecord::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("Timestamp"))
+  {
+    m_timestamp = jsonValue.GetDouble("Timestamp");
+
+    m_timestampHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("CustomerIdentifier"))
+  {
+    m_customerIdentifier = jsonValue.GetString("CustomerIdentifier");
+
+    m_customerIdentifierHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Dimension"))
+  {
+    m_dimension = jsonValue.GetString("Dimension");
+
+    m_dimensionHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Quantity"))
+  {
+    m_quantity = jsonValue.GetInteger("Quantity");
+
+    m_quantityHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue UsageRecord::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_timestampHasBeenSet)
+  {
+   payload.WithDouble("Timestamp", m_timestamp.SecondsWithMSPrecision());
+  }
+
+  if(m_customerIdentifierHasBeenSet)
+  {
+   payload.WithString("CustomerIdentifier", m_customerIdentifier);
+
+  }
+
+  if(m_dimensionHasBeenSet)
+  {
+   payload.WithString("Dimension", m_dimension);
+
+  }
+
+  if(m_quantityHasBeenSet)
+  {
+   payload.WithInteger("Quantity", m_quantity);
+
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace MarketplaceMetering
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-meteringmarketplace/source/model/UsageRecordResult.cpp

@@ -0,0 +1,90 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/meteringmarketplace/model/UsageRecordResult.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+
+#include <utility>
+
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils;
+
+namespace Aws
+{
+namespace MarketplaceMetering
+{
+namespace Model
+{
+
+UsageRecordResult::UsageRecordResult() : 
+    m_usageRecordHasBeenSet(false),
+    m_meteringRecordIdHasBeenSet(false),
+    m_status(UsageRecordResultStatus::NOT_SET),
+    m_statusHasBeenSet(false)
+{
+}
+
+UsageRecordResult::UsageRecordResult(JsonView jsonValue) : 
+    m_usageRecordHasBeenSet(false),
+    m_meteringRecordIdHasBeenSet(false),
+    m_status(UsageRecordResultStatus::NOT_SET),
+    m_statusHasBeenSet(false)
+{
+  *this = jsonValue;
+}
+
+UsageRecordResult& UsageRecordResult::operator =(JsonView jsonValue)
+{
+  if(jsonValue.ValueExists("UsageRecord"))
+  {
+    m_usageRecord = jsonValue.GetObject("UsageRecord");
+
+    m_usageRecordHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("MeteringRecordId"))
+  {
+    m_meteringRecordId = jsonValue.GetString("MeteringRecordId");
+
+    m_meteringRecordIdHasBeenSet = true;
+  }
+
+  if(jsonValue.ValueExists("Status"))
+  {
+    m_status = UsageRecordResultStatusMapper::GetUsageRecordResultStatusForName(jsonValue.GetString("Status"));
+
+    m_statusHasBeenSet = true;
+  }
+
+  return *this;
+}
+
+JsonValue UsageRecordResult::Jsonize() const
+{
+  JsonValue payload;
+
+  if(m_usageRecordHasBeenSet)
+  {
+   payload.WithObject("UsageRecord", m_usageRecord.Jsonize());
+
+  }
+
+  if(m_meteringRecordIdHasBeenSet)
+  {
+   payload.WithString("MeteringRecordId", m_meteringRecordId);
+
+  }
+
+  if(m_statusHasBeenSet)
+  {
+   payload.WithString("Status", UsageRecordResultStatusMapper::GetNameForUsageRecordResultStatus(m_status));
+  }
+
+  return payload;
+}
+
+} // namespace Model
+} // namespace MarketplaceMetering
+} // namespace Aws

support/aws-sdk-cpp-master/aws-cpp-sdk-meteringmarketplace/source/model/UsageRecordResultStatus.cpp

@@ -0,0 +1,77 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/meteringmarketplace/model/UsageRecordResultStatus.h>
+#include <aws/core/utils/HashingUtils.h>
+#include <aws/core/Globals.h>
+#include <aws/core/utils/EnumParseOverflowContainer.h>
+
+using namespace Aws::Utils;
+
+
+namespace Aws
+{
+  namespace MarketplaceMetering
+  {
+    namespace Model
+    {
+      namespace UsageRecordResultStatusMapper
+      {
+
+        static const int Success_HASH = HashingUtils::HashString("Success");
+        static const int CustomerNotSubscribed_HASH = HashingUtils::HashString("CustomerNotSubscribed");
+        static const int DuplicateRecord_HASH = HashingUtils::HashString("DuplicateRecord");
+
+
+        UsageRecordResultStatus GetUsageRecordResultStatusForName(const Aws::String& name)
+        {
+          int hashCode = HashingUtils::HashString(name.c_str());
+          if (hashCode == Success_HASH)
+          {
+            return UsageRecordResultStatus::Success;
+          }
+          else if (hashCode == CustomerNotSubscribed_HASH)
+          {
+            return UsageRecordResultStatus::CustomerNotSubscribed;
+          }
+          else if (hashCode == DuplicateRecord_HASH)
+          {
+            return UsageRecordResultStatus::DuplicateRecord;
+          }
+          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+          if(overflowContainer)
+          {
+            overflowContainer->StoreOverflow(hashCode, name);
+            return static_cast<UsageRecordResultStatus>(hashCode);
+          }
+
+          return UsageRecordResultStatus::NOT_SET;
+        }
+
+        Aws::String GetNameForUsageRecordResultStatus(UsageRecordResultStatus enumValue)
+        {
+          switch(enumValue)
+          {
+          case UsageRecordResultStatus::Success:
+            return "Success";
+          case UsageRecordResultStatus::CustomerNotSubscribed:
+            return "CustomerNotSubscribed";
+          case UsageRecordResultStatus::DuplicateRecord:
+            return "DuplicateRecord";
+          default:
+            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
+            if(overflowContainer)
+            {
+              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
+            }
+
+            return {};
+          }
+        }
+
+      } // namespace UsageRecordResultStatusMapper
+    } // namespace Model
+  } // namespace MarketplaceMetering
+} // namespace Aws