aliyun-openapi-cpp-sdk/openanalytics-open/src/Openanalytics-openClient.cc

/*
 * 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/openanalytics-open/Openanalytics_openClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>

using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::Openanalytics_open;
using namespace AlibabaCloud::Openanalytics_open::Model;

namespace
{
	const std::string SERVICE_NAME = "openanalytics-open";
}

Openanalytics_openClient::Openanalytics_openClient(const Credentials &credentials, const ClientConfiguration &configuration) :
	RpcServiceClient(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, "openanalytics");
}

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

Openanalytics_openClient::Openanalytics_openClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
	RpcServiceClient(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, "openanalytics");
}

Openanalytics_openClient::~Openanalytics_openClient()
{}

Openanalytics_openClient::AddAccountOutcome Openanalytics_openClient::addAccount(const AddAccountRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return AddAccountOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return AddAccountOutcome(AddAccountResult(outcome.result()));
	else
		return AddAccountOutcome(outcome.error());
}

void Openanalytics_openClient::addAccountAsync(const AddAccountRequest& request, const AddAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, addAccount(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::AddAccountOutcomeCallable Openanalytics_openClient::addAccountCallable(const AddAccountRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<AddAccountOutcome()>>(
			[this, request]()
			{
			return this->addAccount(request);
			});

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

Openanalytics_openClient::AddEndPointOutcome Openanalytics_openClient::addEndPoint(const AddEndPointRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return AddEndPointOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return AddEndPointOutcome(AddEndPointResult(outcome.result()));
	else
		return AddEndPointOutcome(outcome.error());
}

void Openanalytics_openClient::addEndPointAsync(const AddEndPointRequest& request, const AddEndPointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, addEndPoint(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::AddEndPointOutcomeCallable Openanalytics_openClient::addEndPointCallable(const AddEndPointRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<AddEndPointOutcome()>>(
			[this, request]()
			{
			return this->addEndPoint(request);
			});

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

Openanalytics_openClient::AddPartitionsOutcome Openanalytics_openClient::addPartitions(const AddPartitionsRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return AddPartitionsOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return AddPartitionsOutcome(AddPartitionsResult(outcome.result()));
	else
		return AddPartitionsOutcome(outcome.error());
}

void Openanalytics_openClient::addPartitionsAsync(const AddPartitionsRequest& request, const AddPartitionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, addPartitions(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::AddPartitionsOutcomeCallable Openanalytics_openClient::addPartitionsCallable(const AddPartitionsRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<AddPartitionsOutcome()>>(
			[this, request]()
			{
			return this->addPartitions(request);
			});

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

Openanalytics_openClient::AlterDatabaseOutcome Openanalytics_openClient::alterDatabase(const AlterDatabaseRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return AlterDatabaseOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return AlterDatabaseOutcome(AlterDatabaseResult(outcome.result()));
	else
		return AlterDatabaseOutcome(outcome.error());
}

void Openanalytics_openClient::alterDatabaseAsync(const AlterDatabaseRequest& request, const AlterDatabaseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, alterDatabase(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::AlterDatabaseOutcomeCallable Openanalytics_openClient::alterDatabaseCallable(const AlterDatabaseRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<AlterDatabaseOutcome()>>(
			[this, request]()
			{
			return this->alterDatabase(request);
			});

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

Openanalytics_openClient::AlterTableOutcome Openanalytics_openClient::alterTable(const AlterTableRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return AlterTableOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return AlterTableOutcome(AlterTableResult(outcome.result()));
	else
		return AlterTableOutcome(outcome.error());
}

void Openanalytics_openClient::alterTableAsync(const AlterTableRequest& request, const AlterTableAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, alterTable(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::AlterTableOutcomeCallable Openanalytics_openClient::alterTableCallable(const AlterTableRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<AlterTableOutcome()>>(
			[this, request]()
			{
			return this->alterTable(request);
			});

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

Openanalytics_openClient::CreateDatabaseOutcome Openanalytics_openClient::createDatabase(const CreateDatabaseRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return CreateDatabaseOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return CreateDatabaseOutcome(CreateDatabaseResult(outcome.result()));
	else
		return CreateDatabaseOutcome(outcome.error());
}

void Openanalytics_openClient::createDatabaseAsync(const CreateDatabaseRequest& request, const CreateDatabaseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, createDatabase(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::CreateDatabaseOutcomeCallable Openanalytics_openClient::createDatabaseCallable(const CreateDatabaseRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<CreateDatabaseOutcome()>>(
			[this, request]()
			{
			return this->createDatabase(request);
			});

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

Openanalytics_openClient::CreateInstanceOutcome Openanalytics_openClient::createInstance(const CreateInstanceRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return CreateInstanceOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return CreateInstanceOutcome(CreateInstanceResult(outcome.result()));
	else
		return CreateInstanceOutcome(outcome.error());
}

void Openanalytics_openClient::createInstanceAsync(const CreateInstanceRequest& request, const CreateInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, createInstance(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::CreateInstanceOutcomeCallable Openanalytics_openClient::createInstanceCallable(const CreateInstanceRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<CreateInstanceOutcome()>>(
			[this, request]()
			{
			return this->createInstance(request);
			});

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

Openanalytics_openClient::CreateTableOutcome Openanalytics_openClient::createTable(const CreateTableRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return CreateTableOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return CreateTableOutcome(CreateTableResult(outcome.result()));
	else
		return CreateTableOutcome(outcome.error());
}

void Openanalytics_openClient::createTableAsync(const CreateTableRequest& request, const CreateTableAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, createTable(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::CreateTableOutcomeCallable Openanalytics_openClient::createTableCallable(const CreateTableRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<CreateTableOutcome()>>(
			[this, request]()
			{
			return this->createTable(request);
			});

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

Openanalytics_openClient::DeleteAccountOutcome Openanalytics_openClient::deleteAccount(const DeleteAccountRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DeleteAccountOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return DeleteAccountOutcome(DeleteAccountResult(outcome.result()));
	else
		return DeleteAccountOutcome(outcome.error());
}

void Openanalytics_openClient::deleteAccountAsync(const DeleteAccountRequest& request, const DeleteAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, deleteAccount(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::DeleteAccountOutcomeCallable Openanalytics_openClient::deleteAccountCallable(const DeleteAccountRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DeleteAccountOutcome()>>(
			[this, request]()
			{
			return this->deleteAccount(request);
			});

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

Openanalytics_openClient::DropDatabaseOutcome Openanalytics_openClient::dropDatabase(const DropDatabaseRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DropDatabaseOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return DropDatabaseOutcome(DropDatabaseResult(outcome.result()));
	else
		return DropDatabaseOutcome(outcome.error());
}

void Openanalytics_openClient::dropDatabaseAsync(const DropDatabaseRequest& request, const DropDatabaseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, dropDatabase(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::DropDatabaseOutcomeCallable Openanalytics_openClient::dropDatabaseCallable(const DropDatabaseRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DropDatabaseOutcome()>>(
			[this, request]()
			{
			return this->dropDatabase(request);
			});

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

Openanalytics_openClient::DropPartitionOutcome Openanalytics_openClient::dropPartition(const DropPartitionRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DropPartitionOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return DropPartitionOutcome(DropPartitionResult(outcome.result()));
	else
		return DropPartitionOutcome(outcome.error());
}

void Openanalytics_openClient::dropPartitionAsync(const DropPartitionRequest& request, const DropPartitionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, dropPartition(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::DropPartitionOutcomeCallable Openanalytics_openClient::dropPartitionCallable(const DropPartitionRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DropPartitionOutcome()>>(
			[this, request]()
			{
			return this->dropPartition(request);
			});

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

Openanalytics_openClient::DropTableOutcome Openanalytics_openClient::dropTable(const DropTableRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return DropTableOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return DropTableOutcome(DropTableResult(outcome.result()));
	else
		return DropTableOutcome(outcome.error());
}

void Openanalytics_openClient::dropTableAsync(const DropTableRequest& request, const DropTableAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, dropTable(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::DropTableOutcomeCallable Openanalytics_openClient::dropTableCallable(const DropTableRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<DropTableOutcome()>>(
			[this, request]()
			{
			return this->dropTable(request);
			});

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

Openanalytics_openClient::GetAllDatabasesOutcome Openanalytics_openClient::getAllDatabases(const GetAllDatabasesRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return GetAllDatabasesOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return GetAllDatabasesOutcome(GetAllDatabasesResult(outcome.result()));
	else
		return GetAllDatabasesOutcome(outcome.error());
}

void Openanalytics_openClient::getAllDatabasesAsync(const GetAllDatabasesRequest& request, const GetAllDatabasesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, getAllDatabases(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::GetAllDatabasesOutcomeCallable Openanalytics_openClient::getAllDatabasesCallable(const GetAllDatabasesRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<GetAllDatabasesOutcome()>>(
			[this, request]()
			{
			return this->getAllDatabases(request);
			});

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

Openanalytics_openClient::GetAllTablesOutcome Openanalytics_openClient::getAllTables(const GetAllTablesRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return GetAllTablesOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return GetAllTablesOutcome(GetAllTablesResult(outcome.result()));
	else
		return GetAllTablesOutcome(outcome.error());
}

void Openanalytics_openClient::getAllTablesAsync(const GetAllTablesRequest& request, const GetAllTablesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, getAllTables(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::GetAllTablesOutcomeCallable Openanalytics_openClient::getAllTablesCallable(const GetAllTablesRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<GetAllTablesOutcome()>>(
			[this, request]()
			{
			return this->getAllTables(request);
			});

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

Openanalytics_openClient::GetAllowIPOutcome Openanalytics_openClient::getAllowIP(const GetAllowIPRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return GetAllowIPOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return GetAllowIPOutcome(GetAllowIPResult(outcome.result()));
	else
		return GetAllowIPOutcome(outcome.error());
}

void Openanalytics_openClient::getAllowIPAsync(const GetAllowIPRequest& request, const GetAllowIPAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, getAllowIP(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::GetAllowIPOutcomeCallable Openanalytics_openClient::getAllowIPCallable(const GetAllowIPRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<GetAllowIPOutcome()>>(
			[this, request]()
			{
			return this->getAllowIP(request);
			});

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

Openanalytics_openClient::GetDatabaseOutcome Openanalytics_openClient::getDatabase(const GetDatabaseRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return GetDatabaseOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return GetDatabaseOutcome(GetDatabaseResult(outcome.result()));
	else
		return GetDatabaseOutcome(outcome.error());
}

void Openanalytics_openClient::getDatabaseAsync(const GetDatabaseRequest& request, const GetDatabaseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, getDatabase(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::GetDatabaseOutcomeCallable Openanalytics_openClient::getDatabaseCallable(const GetDatabaseRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<GetDatabaseOutcome()>>(
			[this, request]()
			{
			return this->getDatabase(request);
			});

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

Openanalytics_openClient::GetEndPointOutcome Openanalytics_openClient::getEndPoint(const GetEndPointRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return GetEndPointOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return GetEndPointOutcome(GetEndPointResult(outcome.result()));
	else
		return GetEndPointOutcome(outcome.error());
}

void Openanalytics_openClient::getEndPointAsync(const GetEndPointRequest& request, const GetEndPointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, getEndPoint(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::GetEndPointOutcomeCallable Openanalytics_openClient::getEndPointCallable(const GetEndPointRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<GetEndPointOutcome()>>(
			[this, request]()
			{
			return this->getEndPoint(request);
			});

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

Openanalytics_openClient::GetEndPointByDomainOutcome Openanalytics_openClient::getEndPointByDomain(const GetEndPointByDomainRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return GetEndPointByDomainOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return GetEndPointByDomainOutcome(GetEndPointByDomainResult(outcome.result()));
	else
		return GetEndPointByDomainOutcome(outcome.error());
}

void Openanalytics_openClient::getEndPointByDomainAsync(const GetEndPointByDomainRequest& request, const GetEndPointByDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, getEndPointByDomain(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::GetEndPointByDomainOutcomeCallable Openanalytics_openClient::getEndPointByDomainCallable(const GetEndPointByDomainRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<GetEndPointByDomainOutcome()>>(
			[this, request]()
			{
			return this->getEndPointByDomain(request);
			});

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

Openanalytics_openClient::GetJobDetailOutcome Openanalytics_openClient::getJobDetail(const GetJobDetailRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return GetJobDetailOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return GetJobDetailOutcome(GetJobDetailResult(outcome.result()));
	else
		return GetJobDetailOutcome(outcome.error());
}

void Openanalytics_openClient::getJobDetailAsync(const GetJobDetailRequest& request, const GetJobDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, getJobDetail(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::GetJobDetailOutcomeCallable Openanalytics_openClient::getJobDetailCallable(const GetJobDetailRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<GetJobDetailOutcome()>>(
			[this, request]()
			{
			return this->getJobDetail(request);
			});

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

Openanalytics_openClient::GetJobLogOutcome Openanalytics_openClient::getJobLog(const GetJobLogRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return GetJobLogOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return GetJobLogOutcome(GetJobLogResult(outcome.result()));
	else
		return GetJobLogOutcome(outcome.error());
}

void Openanalytics_openClient::getJobLogAsync(const GetJobLogRequest& request, const GetJobLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, getJobLog(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::GetJobLogOutcomeCallable Openanalytics_openClient::getJobLogCallable(const GetJobLogRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<GetJobLogOutcome()>>(
			[this, request]()
			{
			return this->getJobLog(request);
			});

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

Openanalytics_openClient::GetJobStatusOutcome Openanalytics_openClient::getJobStatus(const GetJobStatusRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return GetJobStatusOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return GetJobStatusOutcome(GetJobStatusResult(outcome.result()));
	else
		return GetJobStatusOutcome(outcome.error());
}

void Openanalytics_openClient::getJobStatusAsync(const GetJobStatusRequest& request, const GetJobStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, getJobStatus(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::GetJobStatusOutcomeCallable Openanalytics_openClient::getJobStatusCallable(const GetJobStatusRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<GetJobStatusOutcome()>>(
			[this, request]()
			{
			return this->getJobStatus(request);
			});

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

Openanalytics_openClient::GetPartitionOutcome Openanalytics_openClient::getPartition(const GetPartitionRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return GetPartitionOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return GetPartitionOutcome(GetPartitionResult(outcome.result()));
	else
		return GetPartitionOutcome(outcome.error());
}

void Openanalytics_openClient::getPartitionAsync(const GetPartitionRequest& request, const GetPartitionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, getPartition(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::GetPartitionOutcomeCallable Openanalytics_openClient::getPartitionCallable(const GetPartitionRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<GetPartitionOutcome()>>(
			[this, request]()
			{
			return this->getPartition(request);
			});

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

Openanalytics_openClient::GetPartitionsOutcome Openanalytics_openClient::getPartitions(const GetPartitionsRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return GetPartitionsOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return GetPartitionsOutcome(GetPartitionsResult(outcome.result()));
	else
		return GetPartitionsOutcome(outcome.error());
}

void Openanalytics_openClient::getPartitionsAsync(const GetPartitionsRequest& request, const GetPartitionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, getPartitions(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::GetPartitionsOutcomeCallable Openanalytics_openClient::getPartitionsCallable(const GetPartitionsRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<GetPartitionsOutcome()>>(
			[this, request]()
			{
			return this->getPartitions(request);
			});

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

Openanalytics_openClient::GetTableOutcome Openanalytics_openClient::getTable(const GetTableRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return GetTableOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return GetTableOutcome(GetTableResult(outcome.result()));
	else
		return GetTableOutcome(outcome.error());
}

void Openanalytics_openClient::getTableAsync(const GetTableRequest& request, const GetTableAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, getTable(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::GetTableOutcomeCallable Openanalytics_openClient::getTableCallable(const GetTableRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<GetTableOutcome()>>(
			[this, request]()
			{
			return this->getTable(request);
			});

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

Openanalytics_openClient::GrantPrivilegesOutcome Openanalytics_openClient::grantPrivileges(const GrantPrivilegesRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return GrantPrivilegesOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return GrantPrivilegesOutcome(GrantPrivilegesResult(outcome.result()));
	else
		return GrantPrivilegesOutcome(outcome.error());
}

void Openanalytics_openClient::grantPrivilegesAsync(const GrantPrivilegesRequest& request, const GrantPrivilegesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, grantPrivileges(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::GrantPrivilegesOutcomeCallable Openanalytics_openClient::grantPrivilegesCallable(const GrantPrivilegesRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<GrantPrivilegesOutcome()>>(
			[this, request]()
			{
			return this->grantPrivileges(request);
			});

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

Openanalytics_openClient::KillSparkJobOutcome Openanalytics_openClient::killSparkJob(const KillSparkJobRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return KillSparkJobOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return KillSparkJobOutcome(KillSparkJobResult(outcome.result()));
	else
		return KillSparkJobOutcome(outcome.error());
}

void Openanalytics_openClient::killSparkJobAsync(const KillSparkJobRequest& request, const KillSparkJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, killSparkJob(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::KillSparkJobOutcomeCallable Openanalytics_openClient::killSparkJobCallable(const KillSparkJobRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<KillSparkJobOutcome()>>(
			[this, request]()
			{
			return this->killSparkJob(request);
			});

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

Openanalytics_openClient::ListSparkJobOutcome Openanalytics_openClient::listSparkJob(const ListSparkJobRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return ListSparkJobOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return ListSparkJobOutcome(ListSparkJobResult(outcome.result()));
	else
		return ListSparkJobOutcome(outcome.error());
}

void Openanalytics_openClient::listSparkJobAsync(const ListSparkJobRequest& request, const ListSparkJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, listSparkJob(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::ListSparkJobOutcomeCallable Openanalytics_openClient::listSparkJobCallable(const ListSparkJobRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<ListSparkJobOutcome()>>(
			[this, request]()
			{
			return this->listSparkJob(request);
			});

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

Openanalytics_openClient::QueryAccountListOutcome Openanalytics_openClient::queryAccountList(const QueryAccountListRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return QueryAccountListOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return QueryAccountListOutcome(QueryAccountListResult(outcome.result()));
	else
		return QueryAccountListOutcome(outcome.error());
}

void Openanalytics_openClient::queryAccountListAsync(const QueryAccountListRequest& request, const QueryAccountListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, queryAccountList(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::QueryAccountListOutcomeCallable Openanalytics_openClient::queryAccountListCallable(const QueryAccountListRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<QueryAccountListOutcome()>>(
			[this, request]()
			{
			return this->queryAccountList(request);
			});

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

Openanalytics_openClient::QueryEndPointListOutcome Openanalytics_openClient::queryEndPointList(const QueryEndPointListRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return QueryEndPointListOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return QueryEndPointListOutcome(QueryEndPointListResult(outcome.result()));
	else
		return QueryEndPointListOutcome(outcome.error());
}

void Openanalytics_openClient::queryEndPointListAsync(const QueryEndPointListRequest& request, const QueryEndPointListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, queryEndPointList(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::QueryEndPointListOutcomeCallable Openanalytics_openClient::queryEndPointListCallable(const QueryEndPointListRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<QueryEndPointListOutcome()>>(
			[this, request]()
			{
			return this->queryEndPointList(request);
			});

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

Openanalytics_openClient::ReleaseInstanceOutcome Openanalytics_openClient::releaseInstance(const ReleaseInstanceRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return ReleaseInstanceOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return ReleaseInstanceOutcome(ReleaseInstanceResult(outcome.result()));
	else
		return ReleaseInstanceOutcome(outcome.error());
}

void Openanalytics_openClient::releaseInstanceAsync(const ReleaseInstanceRequest& request, const ReleaseInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, releaseInstance(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::ReleaseInstanceOutcomeCallable Openanalytics_openClient::releaseInstanceCallable(const ReleaseInstanceRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<ReleaseInstanceOutcome()>>(
			[this, request]()
			{
			return this->releaseInstance(request);
			});

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

Openanalytics_openClient::RemoveEndPointOutcome Openanalytics_openClient::removeEndPoint(const RemoveEndPointRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return RemoveEndPointOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return RemoveEndPointOutcome(RemoveEndPointResult(outcome.result()));
	else
		return RemoveEndPointOutcome(outcome.error());
}

void Openanalytics_openClient::removeEndPointAsync(const RemoveEndPointRequest& request, const RemoveEndPointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, removeEndPoint(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::RemoveEndPointOutcomeCallable Openanalytics_openClient::removeEndPointCallable(const RemoveEndPointRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<RemoveEndPointOutcome()>>(
			[this, request]()
			{
			return this->removeEndPoint(request);
			});

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

Openanalytics_openClient::ResetMainPasswordOutcome Openanalytics_openClient::resetMainPassword(const ResetMainPasswordRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return ResetMainPasswordOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return ResetMainPasswordOutcome(ResetMainPasswordResult(outcome.result()));
	else
		return ResetMainPasswordOutcome(outcome.error());
}

void Openanalytics_openClient::resetMainPasswordAsync(const ResetMainPasswordRequest& request, const ResetMainPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, resetMainPassword(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::ResetMainPasswordOutcomeCallable Openanalytics_openClient::resetMainPasswordCallable(const ResetMainPasswordRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<ResetMainPasswordOutcome()>>(
			[this, request]()
			{
			return this->resetMainPassword(request);
			});

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

Openanalytics_openClient::RevokePrivilegesOutcome Openanalytics_openClient::revokePrivileges(const RevokePrivilegesRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return RevokePrivilegesOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return RevokePrivilegesOutcome(RevokePrivilegesResult(outcome.result()));
	else
		return RevokePrivilegesOutcome(outcome.error());
}

void Openanalytics_openClient::revokePrivilegesAsync(const RevokePrivilegesRequest& request, const RevokePrivilegesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, revokePrivileges(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::RevokePrivilegesOutcomeCallable Openanalytics_openClient::revokePrivilegesCallable(const RevokePrivilegesRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<RevokePrivilegesOutcome()>>(
			[this, request]()
			{
			return this->revokePrivileges(request);
			});

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

Openanalytics_openClient::SetAllowIPOutcome Openanalytics_openClient::setAllowIP(const SetAllowIPRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return SetAllowIPOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return SetAllowIPOutcome(SetAllowIPResult(outcome.result()));
	else
		return SetAllowIPOutcome(outcome.error());
}

void Openanalytics_openClient::setAllowIPAsync(const SetAllowIPRequest& request, const SetAllowIPAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, setAllowIP(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::SetAllowIPOutcomeCallable Openanalytics_openClient::setAllowIPCallable(const SetAllowIPRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<SetAllowIPOutcome()>>(
			[this, request]()
			{
			return this->setAllowIP(request);
			});

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

Openanalytics_openClient::SubmitSparkJobOutcome Openanalytics_openClient::submitSparkJob(const SubmitSparkJobRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return SubmitSparkJobOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return SubmitSparkJobOutcome(SubmitSparkJobResult(outcome.result()));
	else
		return SubmitSparkJobOutcome(outcome.error());
}

void Openanalytics_openClient::submitSparkJobAsync(const SubmitSparkJobRequest& request, const SubmitSparkJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, submitSparkJob(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::SubmitSparkJobOutcomeCallable Openanalytics_openClient::submitSparkJobCallable(const SubmitSparkJobRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<SubmitSparkJobOutcome()>>(
			[this, request]()
			{
			return this->submitSparkJob(request);
			});

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

Openanalytics_openClient::UnSubscribeRegionOutcome Openanalytics_openClient::unSubscribeRegion(const UnSubscribeRegionRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return UnSubscribeRegionOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return UnSubscribeRegionOutcome(UnSubscribeRegionResult(outcome.result()));
	else
		return UnSubscribeRegionOutcome(outcome.error());
}

void Openanalytics_openClient::unSubscribeRegionAsync(const UnSubscribeRegionRequest& request, const UnSubscribeRegionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, unSubscribeRegion(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::UnSubscribeRegionOutcomeCallable Openanalytics_openClient::unSubscribeRegionCallable(const UnSubscribeRegionRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<UnSubscribeRegionOutcome()>>(
			[this, request]()
			{
			return this->unSubscribeRegion(request);
			});

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

Openanalytics_openClient::UpdateAccountPasswordOutcome Openanalytics_openClient::updateAccountPassword(const UpdateAccountPasswordRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return UpdateAccountPasswordOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return UpdateAccountPasswordOutcome(UpdateAccountPasswordResult(outcome.result()));
	else
		return UpdateAccountPasswordOutcome(outcome.error());
}

void Openanalytics_openClient::updateAccountPasswordAsync(const UpdateAccountPasswordRequest& request, const UpdateAccountPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, updateAccountPassword(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::UpdateAccountPasswordOutcomeCallable Openanalytics_openClient::updateAccountPasswordCallable(const UpdateAccountPasswordRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<UpdateAccountPasswordOutcome()>>(
			[this, request]()
			{
			return this->updateAccountPassword(request);
			});

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

Openanalytics_openClient::UpgradeInstanceOutcome Openanalytics_openClient::upgradeInstance(const UpgradeInstanceRequest &request) const
{
	auto endpointOutcome = endpointProvider_->getEndpoint();
	if (!endpointOutcome.isSuccess())
		return UpgradeInstanceOutcome(endpointOutcome.error());

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

	if (outcome.isSuccess())
		return UpgradeInstanceOutcome(UpgradeInstanceResult(outcome.result()));
	else
		return UpgradeInstanceOutcome(outcome.error());
}

void Openanalytics_openClient::upgradeInstanceAsync(const UpgradeInstanceRequest& request, const UpgradeInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
	auto fn = [this, request, handler, context]()
	{
		handler(this, request, upgradeInstance(request), context);
	};

	asyncExecute(new Runnable(fn));
}

Openanalytics_openClient::UpgradeInstanceOutcomeCallable Openanalytics_openClient::upgradeInstanceCallable(const UpgradeInstanceRequest &request) const
{
	auto task = std::make_shared<std::packaged_task<UpgradeInstanceOutcome()>>(
			[this, request]()
			{
			return this->upgradeInstance(request);
			});

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