/*
 * Copyright 2009-2017 Alibaba Cloud All rights reserved.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <alibabacloud/apds/ApdsClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>

using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::Apds;
using namespace AlibabaCloud::Apds::Model;

namespace
{
	const std::string SERVICE_NAME = "apds";
}

ApdsClient::ApdsClient(const Credentials &credentials, const ClientConfiguration &configuration) :
	RoaServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}

ApdsClient::ApdsClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
	RoaServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}

ApdsClient::ApdsClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
	RoaServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}

ApdsClient::~ApdsClient()
{}

ApdsClient::CreateFileJobOutcome ApdsClient::createFileJob(const CreateFileJobRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return CreateFileJobOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return CreateFileJobOutcome(CreateFileJobResult(outcome.result()));
	else
		return CreateFileJobOutcome(outcome.error());
}

void ApdsClient::createFileJobAsync(const CreateFileJobRequest& request, const CreateFileJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, createFileJob(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::CreateFileJobOutcomeCallable ApdsClient::createFileJobCallable(const CreateFileJobRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<CreateFileJobOutcome()>>(
			[this, request]()
			{
			return this->createFileJob(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::CreateMigrationGroupOutcome ApdsClient::createMigrationGroup(const CreateMigrationGroupRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return CreateMigrationGroupOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return CreateMigrationGroupOutcome(CreateMigrationGroupResult(outcome.result()));
	else
		return CreateMigrationGroupOutcome(outcome.error());
}

void ApdsClient::createMigrationGroupAsync(const CreateMigrationGroupRequest& request, const CreateMigrationGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, createMigrationGroup(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::CreateMigrationGroupOutcomeCallable ApdsClient::createMigrationGroupCallable(const CreateMigrationGroupRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<CreateMigrationGroupOutcome()>>(
			[this, request]()
			{
			return this->createMigrationGroup(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::CreateMigrationJobOutcome ApdsClient::createMigrationJob(const CreateMigrationJobRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return CreateMigrationJobOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return CreateMigrationJobOutcome(CreateMigrationJobResult(outcome.result()));
	else
		return CreateMigrationJobOutcome(outcome.error());
}

void ApdsClient::createMigrationJobAsync(const CreateMigrationJobRequest& request, const CreateMigrationJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, createMigrationJob(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::CreateMigrationJobOutcomeCallable ApdsClient::createMigrationJobCallable(const CreateMigrationJobRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<CreateMigrationJobOutcome()>>(
			[this, request]()
			{
			return this->createMigrationJob(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::CreateSurveyJobOutcome ApdsClient::createSurveyJob(const CreateSurveyJobRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return CreateSurveyJobOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return CreateSurveyJobOutcome(CreateSurveyJobResult(outcome.result()));
	else
		return CreateSurveyJobOutcome(outcome.error());
}

void ApdsClient::createSurveyJobAsync(const CreateSurveyJobRequest& request, const CreateSurveyJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, createSurveyJob(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::CreateSurveyJobOutcomeCallable ApdsClient::createSurveyJobCallable(const CreateSurveyJobRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<CreateSurveyJobOutcome()>>(
			[this, request]()
			{
			return this->createSurveyJob(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::CreateSurveyJobOfflineOutcome ApdsClient::createSurveyJobOffline(const CreateSurveyJobOfflineRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return CreateSurveyJobOfflineOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return CreateSurveyJobOfflineOutcome(CreateSurveyJobOfflineResult(outcome.result()));
	else
		return CreateSurveyJobOfflineOutcome(outcome.error());
}

void ApdsClient::createSurveyJobOfflineAsync(const CreateSurveyJobOfflineRequest& request, const CreateSurveyJobOfflineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, createSurveyJobOffline(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::CreateSurveyJobOfflineOutcomeCallable ApdsClient::createSurveyJobOfflineCallable(const CreateSurveyJobOfflineRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<CreateSurveyJobOfflineOutcome()>>(
			[this, request]()
			{
			return this->createSurveyJobOffline(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::DeleteMigrationGroupOutcome ApdsClient::deleteMigrationGroup(const DeleteMigrationGroupRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DeleteMigrationGroupOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DeleteMigrationGroupOutcome(DeleteMigrationGroupResult(outcome.result()));
	else
		return DeleteMigrationGroupOutcome(outcome.error());
}

void ApdsClient::deleteMigrationGroupAsync(const DeleteMigrationGroupRequest& request, const DeleteMigrationGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, deleteMigrationGroup(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::DeleteMigrationGroupOutcomeCallable ApdsClient::deleteMigrationGroupCallable(const DeleteMigrationGroupRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DeleteMigrationGroupOutcome()>>(
			[this, request]()
			{
			return this->deleteMigrationGroup(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::DeleteMigrationJobOutcome ApdsClient::deleteMigrationJob(const DeleteMigrationJobRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DeleteMigrationJobOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DeleteMigrationJobOutcome(DeleteMigrationJobResult(outcome.result()));
	else
		return DeleteMigrationJobOutcome(outcome.error());
}

void ApdsClient::deleteMigrationJobAsync(const DeleteMigrationJobRequest& request, const DeleteMigrationJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, deleteMigrationJob(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::DeleteMigrationJobOutcomeCallable ApdsClient::deleteMigrationJobCallable(const DeleteMigrationJobRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DeleteMigrationJobOutcome()>>(
			[this, request]()
			{
			return this->deleteMigrationJob(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::DeleteOssFileOutcome ApdsClient::deleteOssFile(const DeleteOssFileRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DeleteOssFileOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DeleteOssFileOutcome(DeleteOssFileResult(outcome.result()));
	else
		return DeleteOssFileOutcome(outcome.error());
}

void ApdsClient::deleteOssFileAsync(const DeleteOssFileRequest& request, const DeleteOssFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, deleteOssFile(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::DeleteOssFileOutcomeCallable ApdsClient::deleteOssFileCallable(const DeleteOssFileRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DeleteOssFileOutcome()>>(
			[this, request]()
			{
			return this->deleteOssFile(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::DeleteSurveyJobOutcome ApdsClient::deleteSurveyJob(const DeleteSurveyJobRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DeleteSurveyJobOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DeleteSurveyJobOutcome(DeleteSurveyJobResult(outcome.result()));
	else
		return DeleteSurveyJobOutcome(outcome.error());
}

void ApdsClient::deleteSurveyJobAsync(const DeleteSurveyJobRequest& request, const DeleteSurveyJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, deleteSurveyJob(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::DeleteSurveyJobOutcomeCallable ApdsClient::deleteSurveyJobCallable(const DeleteSurveyJobRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DeleteSurveyJobOutcome()>>(
			[this, request]()
			{
			return this->deleteSurveyJob(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::DeleteSurveyResourcesOutcome ApdsClient::deleteSurveyResources(const DeleteSurveyResourcesRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DeleteSurveyResourcesOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DeleteSurveyResourcesOutcome(DeleteSurveyResourcesResult(outcome.result()));
	else
		return DeleteSurveyResourcesOutcome(outcome.error());
}

void ApdsClient::deleteSurveyResourcesAsync(const DeleteSurveyResourcesRequest& request, const DeleteSurveyResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, deleteSurveyResources(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::DeleteSurveyResourcesOutcomeCallable ApdsClient::deleteSurveyResourcesCallable(const DeleteSurveyResourcesRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DeleteSurveyResourcesOutcome()>>(
			[this, request]()
			{
			return this->deleteSurveyResources(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::DescribeMigrationJobConfigOutcome ApdsClient::describeMigrationJobConfig(const DescribeMigrationJobConfigRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DescribeMigrationJobConfigOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DescribeMigrationJobConfigOutcome(DescribeMigrationJobConfigResult(outcome.result()));
	else
		return DescribeMigrationJobConfigOutcome(outcome.error());
}

void ApdsClient::describeMigrationJobConfigAsync(const DescribeMigrationJobConfigRequest& request, const DescribeMigrationJobConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, describeMigrationJobConfig(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::DescribeMigrationJobConfigOutcomeCallable ApdsClient::describeMigrationJobConfigCallable(const DescribeMigrationJobConfigRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DescribeMigrationJobConfigOutcome()>>(
			[this, request]()
			{
			return this->describeMigrationJobConfig(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::DescribeMigrationJobCountOutcome ApdsClient::describeMigrationJobCount(const DescribeMigrationJobCountRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DescribeMigrationJobCountOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DescribeMigrationJobCountOutcome(DescribeMigrationJobCountResult(outcome.result()));
	else
		return DescribeMigrationJobCountOutcome(outcome.error());
}

void ApdsClient::describeMigrationJobCountAsync(const DescribeMigrationJobCountRequest& request, const DescribeMigrationJobCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, describeMigrationJobCount(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::DescribeMigrationJobCountOutcomeCallable ApdsClient::describeMigrationJobCountCallable(const DescribeMigrationJobCountRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DescribeMigrationJobCountOutcome()>>(
			[this, request]()
			{
			return this->describeMigrationJobCount(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::DescribeOssStsOutcome ApdsClient::describeOssSts(const DescribeOssStsRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DescribeOssStsOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DescribeOssStsOutcome(DescribeOssStsResult(outcome.result()));
	else
		return DescribeOssStsOutcome(outcome.error());
}

void ApdsClient::describeOssStsAsync(const DescribeOssStsRequest& request, const DescribeOssStsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, describeOssSts(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::DescribeOssStsOutcomeCallable ApdsClient::describeOssStsCallable(const DescribeOssStsRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DescribeOssStsOutcome()>>(
			[this, request]()
			{
			return this->describeOssSts(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::DescribeSummaryByStatusOutcome ApdsClient::describeSummaryByStatus(const DescribeSummaryByStatusRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DescribeSummaryByStatusOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DescribeSummaryByStatusOutcome(DescribeSummaryByStatusResult(outcome.result()));
	else
		return DescribeSummaryByStatusOutcome(outcome.error());
}

void ApdsClient::describeSummaryByStatusAsync(const DescribeSummaryByStatusRequest& request, const DescribeSummaryByStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, describeSummaryByStatus(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::DescribeSummaryByStatusOutcomeCallable ApdsClient::describeSummaryByStatusCallable(const DescribeSummaryByStatusRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DescribeSummaryByStatusOutcome()>>(
			[this, request]()
			{
			return this->describeSummaryByStatus(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::DescribeSummaryByStatusAndGroupOutcome ApdsClient::describeSummaryByStatusAndGroup(const DescribeSummaryByStatusAndGroupRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DescribeSummaryByStatusAndGroupOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DescribeSummaryByStatusAndGroupOutcome(DescribeSummaryByStatusAndGroupResult(outcome.result()));
	else
		return DescribeSummaryByStatusAndGroupOutcome(outcome.error());
}

void ApdsClient::describeSummaryByStatusAndGroupAsync(const DescribeSummaryByStatusAndGroupRequest& request, const DescribeSummaryByStatusAndGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, describeSummaryByStatusAndGroup(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::DescribeSummaryByStatusAndGroupOutcomeCallable ApdsClient::describeSummaryByStatusAndGroupCallable(const DescribeSummaryByStatusAndGroupRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DescribeSummaryByStatusAndGroupOutcome()>>(
			[this, request]()
			{
			return this->describeSummaryByStatusAndGroup(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::DescribeSurveyJobOutcome ApdsClient::describeSurveyJob(const DescribeSurveyJobRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DescribeSurveyJobOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DescribeSurveyJobOutcome(DescribeSurveyJobResult(outcome.result()));
	else
		return DescribeSurveyJobOutcome(outcome.error());
}

void ApdsClient::describeSurveyJobAsync(const DescribeSurveyJobRequest& request, const DescribeSurveyJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, describeSurveyJob(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::DescribeSurveyJobOutcomeCallable ApdsClient::describeSurveyJobCallable(const DescribeSurveyJobRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DescribeSurveyJobOutcome()>>(
			[this, request]()
			{
			return this->describeSurveyJob(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::DescribeSurveyJobCountOutcome ApdsClient::describeSurveyJobCount(const DescribeSurveyJobCountRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DescribeSurveyJobCountOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DescribeSurveyJobCountOutcome(DescribeSurveyJobCountResult(outcome.result()));
	else
		return DescribeSurveyJobCountOutcome(outcome.error());
}

void ApdsClient::describeSurveyJobCountAsync(const DescribeSurveyJobCountRequest& request, const DescribeSurveyJobCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, describeSurveyJobCount(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::DescribeSurveyJobCountOutcomeCallable ApdsClient::describeSurveyJobCountCallable(const DescribeSurveyJobCountRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DescribeSurveyJobCountOutcome()>>(
			[this, request]()
			{
			return this->describeSurveyJobCount(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::DescribeSurveyResourceTagOutcome ApdsClient::describeSurveyResourceTag(const DescribeSurveyResourceTagRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DescribeSurveyResourceTagOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DescribeSurveyResourceTagOutcome(DescribeSurveyResourceTagResult(outcome.result()));
	else
		return DescribeSurveyResourceTagOutcome(outcome.error());
}

void ApdsClient::describeSurveyResourceTagAsync(const DescribeSurveyResourceTagRequest& request, const DescribeSurveyResourceTagAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, describeSurveyResourceTag(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::DescribeSurveyResourceTagOutcomeCallable ApdsClient::describeSurveyResourceTagCallable(const DescribeSurveyResourceTagRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DescribeSurveyResourceTagOutcome()>>(
			[this, request]()
			{
			return this->describeSurveyResourceTag(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::DescribeSurveyTemplateOutcome ApdsClient::describeSurveyTemplate(const DescribeSurveyTemplateRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DescribeSurveyTemplateOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return DescribeSurveyTemplateOutcome(DescribeSurveyTemplateResult(outcome.result()));
	else
		return DescribeSurveyTemplateOutcome(outcome.error());
}

void ApdsClient::describeSurveyTemplateAsync(const DescribeSurveyTemplateRequest& request, const DescribeSurveyTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, describeSurveyTemplate(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::DescribeSurveyTemplateOutcomeCallable ApdsClient::describeSurveyTemplateCallable(const DescribeSurveyTemplateRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DescribeSurveyTemplateOutcome()>>(
			[this, request]()
			{
			return this->describeSurveyTemplate(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::ListMigrationJobsOutcome ApdsClient::listMigrationJobs(const ListMigrationJobsRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return ListMigrationJobsOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return ListMigrationJobsOutcome(ListMigrationJobsResult(outcome.result()));
	else
		return ListMigrationJobsOutcome(outcome.error());
}

void ApdsClient::listMigrationJobsAsync(const ListMigrationJobsRequest& request, const ListMigrationJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, listMigrationJobs(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::ListMigrationJobsOutcomeCallable ApdsClient::listMigrationJobsCallable(const ListMigrationJobsRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<ListMigrationJobsOutcome()>>(
			[this, request]()
			{
			return this->listMigrationJobs(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::ListRegionsOutcome ApdsClient::listRegions(const ListRegionsRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return ListRegionsOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return ListRegionsOutcome(ListRegionsResult(outcome.result()));
	else
		return ListRegionsOutcome(outcome.error());
}

void ApdsClient::listRegionsAsync(const ListRegionsRequest& request, const ListRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, listRegions(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::ListRegionsOutcomeCallable ApdsClient::listRegionsCallable(const ListRegionsRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<ListRegionsOutcome()>>(
			[this, request]()
			{
			return this->listRegions(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::ListSurveyJobDownLoadJobsOutcome ApdsClient::listSurveyJobDownLoadJobs(const ListSurveyJobDownLoadJobsRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return ListSurveyJobDownLoadJobsOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return ListSurveyJobDownLoadJobsOutcome(ListSurveyJobDownLoadJobsResult(outcome.result()));
	else
		return ListSurveyJobDownLoadJobsOutcome(outcome.error());
}

void ApdsClient::listSurveyJobDownLoadJobsAsync(const ListSurveyJobDownLoadJobsRequest& request, const ListSurveyJobDownLoadJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, listSurveyJobDownLoadJobs(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::ListSurveyJobDownLoadJobsOutcomeCallable ApdsClient::listSurveyJobDownLoadJobsCallable(const ListSurveyJobDownLoadJobsRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<ListSurveyJobDownLoadJobsOutcome()>>(
			[this, request]()
			{
			return this->listSurveyJobDownLoadJobs(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::ListSurveyJobsOutcome ApdsClient::listSurveyJobs(const ListSurveyJobsRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return ListSurveyJobsOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return ListSurveyJobsOutcome(ListSurveyJobsResult(outcome.result()));
	else
		return ListSurveyJobsOutcome(outcome.error());
}

void ApdsClient::listSurveyJobsAsync(const ListSurveyJobsRequest& request, const ListSurveyJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, listSurveyJobs(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::ListSurveyJobsOutcomeCallable ApdsClient::listSurveyJobsCallable(const ListSurveyJobsRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<ListSurveyJobsOutcome()>>(
			[this, request]()
			{
			return this->listSurveyJobs(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::ListSurveyResourceByMigrationGroupsOutcome ApdsClient::listSurveyResourceByMigrationGroups(const ListSurveyResourceByMigrationGroupsRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return ListSurveyResourceByMigrationGroupsOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return ListSurveyResourceByMigrationGroupsOutcome(ListSurveyResourceByMigrationGroupsResult(outcome.result()));
	else
		return ListSurveyResourceByMigrationGroupsOutcome(outcome.error());
}

void ApdsClient::listSurveyResourceByMigrationGroupsAsync(const ListSurveyResourceByMigrationGroupsRequest& request, const ListSurveyResourceByMigrationGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, listSurveyResourceByMigrationGroups(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::ListSurveyResourceByMigrationGroupsOutcomeCallable ApdsClient::listSurveyResourceByMigrationGroupsCallable(const ListSurveyResourceByMigrationGroupsRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<ListSurveyResourceByMigrationGroupsOutcome()>>(
			[this, request]()
			{
			return this->listSurveyResourceByMigrationGroups(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::ListSurveyResourceConnectionsOutcome ApdsClient::listSurveyResourceConnections(const ListSurveyResourceConnectionsRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return ListSurveyResourceConnectionsOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return ListSurveyResourceConnectionsOutcome(ListSurveyResourceConnectionsResult(outcome.result()));
	else
		return ListSurveyResourceConnectionsOutcome(outcome.error());
}

void ApdsClient::listSurveyResourceConnectionsAsync(const ListSurveyResourceConnectionsRequest& request, const ListSurveyResourceConnectionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, listSurveyResourceConnections(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::ListSurveyResourceConnectionsOutcomeCallable ApdsClient::listSurveyResourceConnectionsCallable(const ListSurveyResourceConnectionsRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<ListSurveyResourceConnectionsOutcome()>>(
			[this, request]()
			{
			return this->listSurveyResourceConnections(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::ListSurveyResourceTypesOutcome ApdsClient::listSurveyResourceTypes(const ListSurveyResourceTypesRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return ListSurveyResourceTypesOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return ListSurveyResourceTypesOutcome(ListSurveyResourceTypesResult(outcome.result()));
	else
		return ListSurveyResourceTypesOutcome(outcome.error());
}

void ApdsClient::listSurveyResourceTypesAsync(const ListSurveyResourceTypesRequest& request, const ListSurveyResourceTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, listSurveyResourceTypes(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::ListSurveyResourceTypesOutcomeCallable ApdsClient::listSurveyResourceTypesCallable(const ListSurveyResourceTypesRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<ListSurveyResourceTypesOutcome()>>(
			[this, request]()
			{
			return this->listSurveyResourceTypes(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::ListSurveyResourcesDetailOutcome ApdsClient::listSurveyResourcesDetail(const ListSurveyResourcesDetailRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return ListSurveyResourcesDetailOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return ListSurveyResourcesDetailOutcome(ListSurveyResourcesDetailResult(outcome.result()));
	else
		return ListSurveyResourcesDetailOutcome(outcome.error());
}

void ApdsClient::listSurveyResourcesDetailAsync(const ListSurveyResourcesDetailRequest& request, const ListSurveyResourcesDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, listSurveyResourcesDetail(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::ListSurveyResourcesDetailOutcomeCallable ApdsClient::listSurveyResourcesDetailCallable(const ListSurveyResourcesDetailRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<ListSurveyResourcesDetailOutcome()>>(
			[this, request]()
			{
			return this->listSurveyResourcesDetail(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::RecoverMigrationJobOutcome ApdsClient::recoverMigrationJob(const RecoverMigrationJobRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return RecoverMigrationJobOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return RecoverMigrationJobOutcome(RecoverMigrationJobResult(outcome.result()));
	else
		return RecoverMigrationJobOutcome(outcome.error());
}

void ApdsClient::recoverMigrationJobAsync(const RecoverMigrationJobRequest& request, const RecoverMigrationJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, recoverMigrationJob(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::RecoverMigrationJobOutcomeCallable ApdsClient::recoverMigrationJobCallable(const RecoverMigrationJobRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<RecoverMigrationJobOutcome()>>(
			[this, request]()
			{
			return this->recoverMigrationJob(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::StopSyncMigrationJobOutcome ApdsClient::stopSyncMigrationJob(const StopSyncMigrationJobRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return StopSyncMigrationJobOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return StopSyncMigrationJobOutcome(StopSyncMigrationJobResult(outcome.result()));
	else
		return StopSyncMigrationJobOutcome(outcome.error());
}

void ApdsClient::stopSyncMigrationJobAsync(const StopSyncMigrationJobRequest& request, const StopSyncMigrationJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, stopSyncMigrationJob(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::StopSyncMigrationJobOutcomeCallable ApdsClient::stopSyncMigrationJobCallable(const StopSyncMigrationJobRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<StopSyncMigrationJobOutcome()>>(
			[this, request]()
			{
			return this->stopSyncMigrationJob(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}

ApdsClient::SyncMigrationJobOutcome ApdsClient::syncMigrationJob(const SyncMigrationJobRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return SyncMigrationJobOutcome(endpointOutcome.error());

	auto outcome = makeRequest(endpointOutcome.result(), request);

	if (outcome.isSuccess())
		return SyncMigrationJobOutcome(SyncMigrationJobResult(outcome.result()));
	else
		return SyncMigrationJobOutcome(outcome.error());
}

void ApdsClient::syncMigrationJobAsync(const SyncMigrationJobRequest& request, const SyncMigrationJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, syncMigrationJob(request), context);
	};

	asyncExecute(new Runnable(fn));
}

ApdsClient::SyncMigrationJobOutcomeCallable ApdsClient::syncMigrationJobCallable(const SyncMigrationJobRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<SyncMigrationJobOutcome()>>(
			[this, request]()
			{
			return this->syncMigrationJob(request);
			});

	asyncExecute(new Runnable([task]() { (*task)(); }));
	return task->get_future();
}