1926 lines
68 KiB
C++
1926 lines
68 KiB
C++
/*
|
|
* 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/polardbx/PolardbxClient.h>
|
|
#include <alibabacloud/core/SimpleCredentialsProvider.h>
|
|
|
|
using namespace AlibabaCloud;
|
|
using namespace AlibabaCloud::Location;
|
|
using namespace AlibabaCloud::Polardbx;
|
|
using namespace AlibabaCloud::Polardbx::Model;
|
|
|
|
namespace
|
|
{
|
|
const std::string SERVICE_NAME = "polardbx";
|
|
}
|
|
|
|
PolardbxClient::PolardbxClient(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, "polardbx");
|
|
}
|
|
|
|
PolardbxClient::PolardbxClient(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, "polardbx");
|
|
}
|
|
|
|
PolardbxClient::PolardbxClient(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, "polardbx");
|
|
}
|
|
|
|
PolardbxClient::~PolardbxClient()
|
|
{}
|
|
|
|
PolardbxClient::AllocateInstancePublicConnectionOutcome PolardbxClient::allocateInstancePublicConnection(const AllocateInstancePublicConnectionRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return AllocateInstancePublicConnectionOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return AllocateInstancePublicConnectionOutcome(AllocateInstancePublicConnectionResult(outcome.result()));
|
|
else
|
|
return AllocateInstancePublicConnectionOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::allocateInstancePublicConnectionAsync(const AllocateInstancePublicConnectionRequest& request, const AllocateInstancePublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, allocateInstancePublicConnection(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::AllocateInstancePublicConnectionOutcomeCallable PolardbxClient::allocateInstancePublicConnectionCallable(const AllocateInstancePublicConnectionRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<AllocateInstancePublicConnectionOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->allocateInstancePublicConnection(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::CancelPolarxOrderOutcome PolardbxClient::cancelPolarxOrder(const CancelPolarxOrderRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CancelPolarxOrderOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CancelPolarxOrderOutcome(CancelPolarxOrderResult(outcome.result()));
|
|
else
|
|
return CancelPolarxOrderOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::cancelPolarxOrderAsync(const CancelPolarxOrderRequest& request, const CancelPolarxOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, cancelPolarxOrder(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::CancelPolarxOrderOutcomeCallable PolardbxClient::cancelPolarxOrderCallable(const CancelPolarxOrderRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CancelPolarxOrderOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->cancelPolarxOrder(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::CheckHealthOutcome PolardbxClient::checkHealth(const CheckHealthRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CheckHealthOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CheckHealthOutcome(CheckHealthResult(outcome.result()));
|
|
else
|
|
return CheckHealthOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::checkHealthAsync(const CheckHealthRequest& request, const CheckHealthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, checkHealth(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::CheckHealthOutcomeCallable PolardbxClient::checkHealthCallable(const CheckHealthRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CheckHealthOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->checkHealth(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::CreateAccountOutcome PolardbxClient::createAccount(const CreateAccountRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateAccountOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateAccountOutcome(CreateAccountResult(outcome.result()));
|
|
else
|
|
return CreateAccountOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::createAccountAsync(const CreateAccountRequest& request, const CreateAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createAccount(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::CreateAccountOutcomeCallable PolardbxClient::createAccountCallable(const CreateAccountRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateAccountOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createAccount(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::CreateDBOutcome PolardbxClient::createDB(const CreateDBRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateDBOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateDBOutcome(CreateDBResult(outcome.result()));
|
|
else
|
|
return CreateDBOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::createDBAsync(const CreateDBRequest& request, const CreateDBAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createDB(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::CreateDBOutcomeCallable PolardbxClient::createDBCallable(const CreateDBRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateDBOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createDB(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::CreateDBInstanceOutcome PolardbxClient::createDBInstance(const CreateDBInstanceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateDBInstanceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateDBInstanceOutcome(CreateDBInstanceResult(outcome.result()));
|
|
else
|
|
return CreateDBInstanceOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::createDBInstanceAsync(const CreateDBInstanceRequest& request, const CreateDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createDBInstance(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::CreateDBInstanceOutcomeCallable PolardbxClient::createDBInstanceCallable(const CreateDBInstanceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateDBInstanceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createDBInstance(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::CreatePolarxInstanceOutcome PolardbxClient::createPolarxInstance(const CreatePolarxInstanceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreatePolarxInstanceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreatePolarxInstanceOutcome(CreatePolarxInstanceResult(outcome.result()));
|
|
else
|
|
return CreatePolarxInstanceOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::createPolarxInstanceAsync(const CreatePolarxInstanceRequest& request, const CreatePolarxInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createPolarxInstance(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::CreatePolarxInstanceOutcomeCallable PolardbxClient::createPolarxInstanceCallable(const CreatePolarxInstanceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreatePolarxInstanceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createPolarxInstance(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::CreatePolarxOrderOutcome PolardbxClient::createPolarxOrder(const CreatePolarxOrderRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreatePolarxOrderOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreatePolarxOrderOutcome(CreatePolarxOrderResult(outcome.result()));
|
|
else
|
|
return CreatePolarxOrderOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::createPolarxOrderAsync(const CreatePolarxOrderRequest& request, const CreatePolarxOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createPolarxOrder(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::CreatePolarxOrderOutcomeCallable PolardbxClient::createPolarxOrderCallable(const CreatePolarxOrderRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreatePolarxOrderOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createPolarxOrder(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::CreateSuperAccountOutcome PolardbxClient::createSuperAccount(const CreateSuperAccountRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateSuperAccountOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateSuperAccountOutcome(CreateSuperAccountResult(outcome.result()));
|
|
else
|
|
return CreateSuperAccountOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::createSuperAccountAsync(const CreateSuperAccountRequest& request, const CreateSuperAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createSuperAccount(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::CreateSuperAccountOutcomeCallable PolardbxClient::createSuperAccountCallable(const CreateSuperAccountRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateSuperAccountOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createSuperAccount(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DeleteAccountOutcome PolardbxClient::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 PolardbxClient::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));
|
|
}
|
|
|
|
PolardbxClient::DeleteAccountOutcomeCallable PolardbxClient::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();
|
|
}
|
|
|
|
PolardbxClient::DeleteDBOutcome PolardbxClient::deleteDB(const DeleteDBRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteDBOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteDBOutcome(DeleteDBResult(outcome.result()));
|
|
else
|
|
return DeleteDBOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::deleteDBAsync(const DeleteDBRequest& request, const DeleteDBAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteDB(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DeleteDBOutcomeCallable PolardbxClient::deleteDBCallable(const DeleteDBRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteDBOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteDB(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DeleteDBInstanceOutcome PolardbxClient::deleteDBInstance(const DeleteDBInstanceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteDBInstanceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteDBInstanceOutcome(DeleteDBInstanceResult(outcome.result()));
|
|
else
|
|
return DeleteDBInstanceOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::deleteDBInstanceAsync(const DeleteDBInstanceRequest& request, const DeleteDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteDBInstance(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DeleteDBInstanceOutcomeCallable PolardbxClient::deleteDBInstanceCallable(const DeleteDBInstanceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteDBInstanceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteDBInstance(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DescribeAccountListOutcome PolardbxClient::describeAccountList(const DescribeAccountListRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeAccountListOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeAccountListOutcome(DescribeAccountListResult(outcome.result()));
|
|
else
|
|
return DescribeAccountListOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::describeAccountListAsync(const DescribeAccountListRequest& request, const DescribeAccountListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeAccountList(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DescribeAccountListOutcomeCallable PolardbxClient::describeAccountListCallable(const DescribeAccountListRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeAccountListOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeAccountList(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DescribeCharacterSetOutcome PolardbxClient::describeCharacterSet(const DescribeCharacterSetRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeCharacterSetOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeCharacterSetOutcome(DescribeCharacterSetResult(outcome.result()));
|
|
else
|
|
return DescribeCharacterSetOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::describeCharacterSetAsync(const DescribeCharacterSetRequest& request, const DescribeCharacterSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeCharacterSet(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DescribeCharacterSetOutcomeCallable PolardbxClient::describeCharacterSetCallable(const DescribeCharacterSetRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeCharacterSetOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeCharacterSet(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DescribeDBInstanceAttributeOutcome PolardbxClient::describeDBInstanceAttribute(const DescribeDBInstanceAttributeRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeDBInstanceAttributeOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeDBInstanceAttributeOutcome(DescribeDBInstanceAttributeResult(outcome.result()));
|
|
else
|
|
return DescribeDBInstanceAttributeOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::describeDBInstanceAttributeAsync(const DescribeDBInstanceAttributeRequest& request, const DescribeDBInstanceAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeDBInstanceAttribute(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DescribeDBInstanceAttributeOutcomeCallable PolardbxClient::describeDBInstanceAttributeCallable(const DescribeDBInstanceAttributeRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeDBInstanceAttributeOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeDBInstanceAttribute(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DescribeDBInstanceConfigOutcome PolardbxClient::describeDBInstanceConfig(const DescribeDBInstanceConfigRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeDBInstanceConfigOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeDBInstanceConfigOutcome(DescribeDBInstanceConfigResult(outcome.result()));
|
|
else
|
|
return DescribeDBInstanceConfigOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::describeDBInstanceConfigAsync(const DescribeDBInstanceConfigRequest& request, const DescribeDBInstanceConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeDBInstanceConfig(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DescribeDBInstanceConfigOutcomeCallable PolardbxClient::describeDBInstanceConfigCallable(const DescribeDBInstanceConfigRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeDBInstanceConfigOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeDBInstanceConfig(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DescribeDBInstancesOutcome PolardbxClient::describeDBInstances(const DescribeDBInstancesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeDBInstancesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeDBInstancesOutcome(DescribeDBInstancesResult(outcome.result()));
|
|
else
|
|
return DescribeDBInstancesOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::describeDBInstancesAsync(const DescribeDBInstancesRequest& request, const DescribeDBInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeDBInstances(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DescribeDBInstancesOutcomeCallable PolardbxClient::describeDBInstancesCallable(const DescribeDBInstancesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeDBInstancesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeDBInstances(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DescribeDbListOutcome PolardbxClient::describeDbList(const DescribeDbListRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeDbListOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeDbListOutcome(DescribeDbListResult(outcome.result()));
|
|
else
|
|
return DescribeDbListOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::describeDbListAsync(const DescribeDbListRequest& request, const DescribeDbListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeDbList(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DescribeDbListOutcomeCallable PolardbxClient::describeDbListCallable(const DescribeDbListRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeDbListOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeDbList(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DescribeDistributeTableListOutcome PolardbxClient::describeDistributeTableList(const DescribeDistributeTableListRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeDistributeTableListOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeDistributeTableListOutcome(DescribeDistributeTableListResult(outcome.result()));
|
|
else
|
|
return DescribeDistributeTableListOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::describeDistributeTableListAsync(const DescribeDistributeTableListRequest& request, const DescribeDistributeTableListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeDistributeTableList(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DescribeDistributeTableListOutcomeCallable PolardbxClient::describeDistributeTableListCallable(const DescribeDistributeTableListRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeDistributeTableListOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeDistributeTableList(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DescribeInstanceDbPerformanceOutcome PolardbxClient::describeInstanceDbPerformance(const DescribeInstanceDbPerformanceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeInstanceDbPerformanceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeInstanceDbPerformanceOutcome(DescribeInstanceDbPerformanceResult(outcome.result()));
|
|
else
|
|
return DescribeInstanceDbPerformanceOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::describeInstanceDbPerformanceAsync(const DescribeInstanceDbPerformanceRequest& request, const DescribeInstanceDbPerformanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeInstanceDbPerformance(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DescribeInstanceDbPerformanceOutcomeCallable PolardbxClient::describeInstanceDbPerformanceCallable(const DescribeInstanceDbPerformanceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeInstanceDbPerformanceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeInstanceDbPerformance(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DescribeInstancePerformanceOutcome PolardbxClient::describeInstancePerformance(const DescribeInstancePerformanceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeInstancePerformanceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeInstancePerformanceOutcome(DescribeInstancePerformanceResult(outcome.result()));
|
|
else
|
|
return DescribeInstancePerformanceOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::describeInstancePerformanceAsync(const DescribeInstancePerformanceRequest& request, const DescribeInstancePerformanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeInstancePerformance(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DescribeInstancePerformanceOutcomeCallable PolardbxClient::describeInstancePerformanceCallable(const DescribeInstancePerformanceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeInstancePerformanceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeInstancePerformance(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DescribeInstanceStoragePerformanceOutcome PolardbxClient::describeInstanceStoragePerformance(const DescribeInstanceStoragePerformanceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeInstanceStoragePerformanceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeInstanceStoragePerformanceOutcome(DescribeInstanceStoragePerformanceResult(outcome.result()));
|
|
else
|
|
return DescribeInstanceStoragePerformanceOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::describeInstanceStoragePerformanceAsync(const DescribeInstanceStoragePerformanceRequest& request, const DescribeInstanceStoragePerformanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeInstanceStoragePerformance(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DescribeInstanceStoragePerformanceOutcomeCallable PolardbxClient::describeInstanceStoragePerformanceCallable(const DescribeInstanceStoragePerformanceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeInstanceStoragePerformanceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeInstanceStoragePerformance(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DescribeModifyParameterLogOutcome PolardbxClient::describeModifyParameterLog(const DescribeModifyParameterLogRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeModifyParameterLogOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeModifyParameterLogOutcome(DescribeModifyParameterLogResult(outcome.result()));
|
|
else
|
|
return DescribeModifyParameterLogOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::describeModifyParameterLogAsync(const DescribeModifyParameterLogRequest& request, const DescribeModifyParameterLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeModifyParameterLog(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DescribeModifyParameterLogOutcomeCallable PolardbxClient::describeModifyParameterLogCallable(const DescribeModifyParameterLogRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeModifyParameterLogOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeModifyParameterLog(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DescribeParameterTemplatesOutcome PolardbxClient::describeParameterTemplates(const DescribeParameterTemplatesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeParameterTemplatesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeParameterTemplatesOutcome(DescribeParameterTemplatesResult(outcome.result()));
|
|
else
|
|
return DescribeParameterTemplatesOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::describeParameterTemplatesAsync(const DescribeParameterTemplatesRequest& request, const DescribeParameterTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeParameterTemplates(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DescribeParameterTemplatesOutcomeCallable PolardbxClient::describeParameterTemplatesCallable(const DescribeParameterTemplatesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeParameterTemplatesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeParameterTemplates(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DescribeParametersOutcome PolardbxClient::describeParameters(const DescribeParametersRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeParametersOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeParametersOutcome(DescribeParametersResult(outcome.result()));
|
|
else
|
|
return DescribeParametersOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::describeParametersAsync(const DescribeParametersRequest& request, const DescribeParametersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeParameters(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DescribeParametersOutcomeCallable PolardbxClient::describeParametersCallable(const DescribeParametersRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeParametersOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeParameters(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DescribePolarxDbInstancesOutcome PolardbxClient::describePolarxDbInstances(const DescribePolarxDbInstancesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribePolarxDbInstancesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribePolarxDbInstancesOutcome(DescribePolarxDbInstancesResult(outcome.result()));
|
|
else
|
|
return DescribePolarxDbInstancesOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::describePolarxDbInstancesAsync(const DescribePolarxDbInstancesRequest& request, const DescribePolarxDbInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describePolarxDbInstances(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DescribePolarxDbInstancesOutcomeCallable PolardbxClient::describePolarxDbInstancesCallable(const DescribePolarxDbInstancesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribePolarxDbInstancesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describePolarxDbInstances(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DescribeRegionsOutcome PolardbxClient::describeRegions(const DescribeRegionsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeRegionsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeRegionsOutcome(DescribeRegionsResult(outcome.result()));
|
|
else
|
|
return DescribeRegionsOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::describeRegionsAsync(const DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeRegions(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DescribeRegionsOutcomeCallable PolardbxClient::describeRegionsCallable(const DescribeRegionsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeRegionsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeRegions(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DescribeScaleOutMigrateTaskListOutcome PolardbxClient::describeScaleOutMigrateTaskList(const DescribeScaleOutMigrateTaskListRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeScaleOutMigrateTaskListOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeScaleOutMigrateTaskListOutcome(DescribeScaleOutMigrateTaskListResult(outcome.result()));
|
|
else
|
|
return DescribeScaleOutMigrateTaskListOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::describeScaleOutMigrateTaskListAsync(const DescribeScaleOutMigrateTaskListRequest& request, const DescribeScaleOutMigrateTaskListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeScaleOutMigrateTaskList(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DescribeScaleOutMigrateTaskListOutcomeCallable PolardbxClient::describeScaleOutMigrateTaskListCallable(const DescribeScaleOutMigrateTaskListRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeScaleOutMigrateTaskListOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeScaleOutMigrateTaskList(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DescribeSecurityIpsOutcome PolardbxClient::describeSecurityIps(const DescribeSecurityIpsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeSecurityIpsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeSecurityIpsOutcome(DescribeSecurityIpsResult(outcome.result()));
|
|
else
|
|
return DescribeSecurityIpsOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::describeSecurityIpsAsync(const DescribeSecurityIpsRequest& request, const DescribeSecurityIpsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeSecurityIps(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DescribeSecurityIpsOutcomeCallable PolardbxClient::describeSecurityIpsCallable(const DescribeSecurityIpsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeSecurityIpsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeSecurityIps(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DescribeSqlAuditInfoOutcome PolardbxClient::describeSqlAuditInfo(const DescribeSqlAuditInfoRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeSqlAuditInfoOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeSqlAuditInfoOutcome(DescribeSqlAuditInfoResult(outcome.result()));
|
|
else
|
|
return DescribeSqlAuditInfoOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::describeSqlAuditInfoAsync(const DescribeSqlAuditInfoRequest& request, const DescribeSqlAuditInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeSqlAuditInfo(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DescribeSqlAuditInfoOutcomeCallable PolardbxClient::describeSqlAuditInfoCallable(const DescribeSqlAuditInfoRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeSqlAuditInfoOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeSqlAuditInfo(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DescribeTableDetailOutcome PolardbxClient::describeTableDetail(const DescribeTableDetailRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeTableDetailOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeTableDetailOutcome(DescribeTableDetailResult(outcome.result()));
|
|
else
|
|
return DescribeTableDetailOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::describeTableDetailAsync(const DescribeTableDetailRequest& request, const DescribeTableDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeTableDetail(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DescribeTableDetailOutcomeCallable PolardbxClient::describeTableDetailCallable(const DescribeTableDetailRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeTableDetailOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeTableDetail(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DescribeTasksOutcome PolardbxClient::describeTasks(const DescribeTasksRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeTasksOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeTasksOutcome(DescribeTasksResult(outcome.result()));
|
|
else
|
|
return DescribeTasksOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::describeTasksAsync(const DescribeTasksRequest& request, const DescribeTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeTasks(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DescribeTasksOutcomeCallable PolardbxClient::describeTasksCallable(const DescribeTasksRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeTasksOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeTasks(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::DisableSqlAuditOutcome PolardbxClient::disableSqlAudit(const DisableSqlAuditRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DisableSqlAuditOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DisableSqlAuditOutcome(DisableSqlAuditResult(outcome.result()));
|
|
else
|
|
return DisableSqlAuditOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::disableSqlAuditAsync(const DisableSqlAuditRequest& request, const DisableSqlAuditAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, disableSqlAudit(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::DisableSqlAuditOutcomeCallable PolardbxClient::disableSqlAuditCallable(const DisableSqlAuditRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DisableSqlAuditOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->disableSqlAudit(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::EnableSqlAuditOutcome PolardbxClient::enableSqlAudit(const EnableSqlAuditRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return EnableSqlAuditOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return EnableSqlAuditOutcome(EnableSqlAuditResult(outcome.result()));
|
|
else
|
|
return EnableSqlAuditOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::enableSqlAuditAsync(const EnableSqlAuditRequest& request, const EnableSqlAuditAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, enableSqlAudit(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::EnableSqlAuditOutcomeCallable PolardbxClient::enableSqlAuditCallable(const EnableSqlAuditRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<EnableSqlAuditOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->enableSqlAudit(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::GetPolarXPriceOutcome PolardbxClient::getPolarXPrice(const GetPolarXPriceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetPolarXPriceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetPolarXPriceOutcome(GetPolarXPriceResult(outcome.result()));
|
|
else
|
|
return GetPolarXPriceOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::getPolarXPriceAsync(const GetPolarXPriceRequest& request, const GetPolarXPriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getPolarXPrice(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::GetPolarXPriceOutcomeCallable PolardbxClient::getPolarXPriceCallable(const GetPolarXPriceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetPolarXPriceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getPolarXPrice(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::GetPolarxCommodityOutcome PolardbxClient::getPolarxCommodity(const GetPolarxCommodityRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetPolarxCommodityOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetPolarxCommodityOutcome(GetPolarxCommodityResult(outcome.result()));
|
|
else
|
|
return GetPolarxCommodityOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::getPolarxCommodityAsync(const GetPolarxCommodityRequest& request, const GetPolarxCommodityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getPolarxCommodity(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::GetPolarxCommodityOutcomeCallable PolardbxClient::getPolarxCommodityCallable(const GetPolarxCommodityRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetPolarxCommodityOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getPolarxCommodity(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::ModifyAccountDescriptionOutcome PolardbxClient::modifyAccountDescription(const ModifyAccountDescriptionRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ModifyAccountDescriptionOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ModifyAccountDescriptionOutcome(ModifyAccountDescriptionResult(outcome.result()));
|
|
else
|
|
return ModifyAccountDescriptionOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::modifyAccountDescriptionAsync(const ModifyAccountDescriptionRequest& request, const ModifyAccountDescriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, modifyAccountDescription(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::ModifyAccountDescriptionOutcomeCallable PolardbxClient::modifyAccountDescriptionCallable(const ModifyAccountDescriptionRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ModifyAccountDescriptionOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->modifyAccountDescription(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::ModifyAccountPrivilegeOutcome PolardbxClient::modifyAccountPrivilege(const ModifyAccountPrivilegeRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ModifyAccountPrivilegeOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ModifyAccountPrivilegeOutcome(ModifyAccountPrivilegeResult(outcome.result()));
|
|
else
|
|
return ModifyAccountPrivilegeOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::modifyAccountPrivilegeAsync(const ModifyAccountPrivilegeRequest& request, const ModifyAccountPrivilegeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, modifyAccountPrivilege(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::ModifyAccountPrivilegeOutcomeCallable PolardbxClient::modifyAccountPrivilegeCallable(const ModifyAccountPrivilegeRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ModifyAccountPrivilegeOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->modifyAccountPrivilege(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::ModifyDBInstanceClassOutcome PolardbxClient::modifyDBInstanceClass(const ModifyDBInstanceClassRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ModifyDBInstanceClassOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ModifyDBInstanceClassOutcome(ModifyDBInstanceClassResult(outcome.result()));
|
|
else
|
|
return ModifyDBInstanceClassOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::modifyDBInstanceClassAsync(const ModifyDBInstanceClassRequest& request, const ModifyDBInstanceClassAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, modifyDBInstanceClass(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::ModifyDBInstanceClassOutcomeCallable PolardbxClient::modifyDBInstanceClassCallable(const ModifyDBInstanceClassRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ModifyDBInstanceClassOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->modifyDBInstanceClass(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::ModifyDBInstanceConfigOutcome PolardbxClient::modifyDBInstanceConfig(const ModifyDBInstanceConfigRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ModifyDBInstanceConfigOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ModifyDBInstanceConfigOutcome(ModifyDBInstanceConfigResult(outcome.result()));
|
|
else
|
|
return ModifyDBInstanceConfigOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::modifyDBInstanceConfigAsync(const ModifyDBInstanceConfigRequest& request, const ModifyDBInstanceConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, modifyDBInstanceConfig(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::ModifyDBInstanceConfigOutcomeCallable PolardbxClient::modifyDBInstanceConfigCallable(const ModifyDBInstanceConfigRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ModifyDBInstanceConfigOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->modifyDBInstanceConfig(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::ModifyDBInstanceDescriptionOutcome PolardbxClient::modifyDBInstanceDescription(const ModifyDBInstanceDescriptionRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ModifyDBInstanceDescriptionOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ModifyDBInstanceDescriptionOutcome(ModifyDBInstanceDescriptionResult(outcome.result()));
|
|
else
|
|
return ModifyDBInstanceDescriptionOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::modifyDBInstanceDescriptionAsync(const ModifyDBInstanceDescriptionRequest& request, const ModifyDBInstanceDescriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, modifyDBInstanceDescription(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::ModifyDBInstanceDescriptionOutcomeCallable PolardbxClient::modifyDBInstanceDescriptionCallable(const ModifyDBInstanceDescriptionRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ModifyDBInstanceDescriptionOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->modifyDBInstanceDescription(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::ModifyDBInstanceMaintainTimeOutcome PolardbxClient::modifyDBInstanceMaintainTime(const ModifyDBInstanceMaintainTimeRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ModifyDBInstanceMaintainTimeOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ModifyDBInstanceMaintainTimeOutcome(ModifyDBInstanceMaintainTimeResult(outcome.result()));
|
|
else
|
|
return ModifyDBInstanceMaintainTimeOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::modifyDBInstanceMaintainTimeAsync(const ModifyDBInstanceMaintainTimeRequest& request, const ModifyDBInstanceMaintainTimeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, modifyDBInstanceMaintainTime(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::ModifyDBInstanceMaintainTimeOutcomeCallable PolardbxClient::modifyDBInstanceMaintainTimeCallable(const ModifyDBInstanceMaintainTimeRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ModifyDBInstanceMaintainTimeOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->modifyDBInstanceMaintainTime(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::ModifyDatabaseDescriptionOutcome PolardbxClient::modifyDatabaseDescription(const ModifyDatabaseDescriptionRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ModifyDatabaseDescriptionOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ModifyDatabaseDescriptionOutcome(ModifyDatabaseDescriptionResult(outcome.result()));
|
|
else
|
|
return ModifyDatabaseDescriptionOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::modifyDatabaseDescriptionAsync(const ModifyDatabaseDescriptionRequest& request, const ModifyDatabaseDescriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, modifyDatabaseDescription(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::ModifyDatabaseDescriptionOutcomeCallable PolardbxClient::modifyDatabaseDescriptionCallable(const ModifyDatabaseDescriptionRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ModifyDatabaseDescriptionOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->modifyDatabaseDescription(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::ModifyParameterOutcome PolardbxClient::modifyParameter(const ModifyParameterRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ModifyParameterOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ModifyParameterOutcome(ModifyParameterResult(outcome.result()));
|
|
else
|
|
return ModifyParameterOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::modifyParameterAsync(const ModifyParameterRequest& request, const ModifyParameterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, modifyParameter(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::ModifyParameterOutcomeCallable PolardbxClient::modifyParameterCallable(const ModifyParameterRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ModifyParameterOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->modifyParameter(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::ModifySecurityIpsOutcome PolardbxClient::modifySecurityIps(const ModifySecurityIpsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ModifySecurityIpsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ModifySecurityIpsOutcome(ModifySecurityIpsResult(outcome.result()));
|
|
else
|
|
return ModifySecurityIpsOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::modifySecurityIpsAsync(const ModifySecurityIpsRequest& request, const ModifySecurityIpsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, modifySecurityIps(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::ModifySecurityIpsOutcomeCallable PolardbxClient::modifySecurityIpsCallable(const ModifySecurityIpsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ModifySecurityIpsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->modifySecurityIps(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::ReleaseInstancePublicConnectionOutcome PolardbxClient::releaseInstancePublicConnection(const ReleaseInstancePublicConnectionRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ReleaseInstancePublicConnectionOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ReleaseInstancePublicConnectionOutcome(ReleaseInstancePublicConnectionResult(outcome.result()));
|
|
else
|
|
return ReleaseInstancePublicConnectionOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::releaseInstancePublicConnectionAsync(const ReleaseInstancePublicConnectionRequest& request, const ReleaseInstancePublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, releaseInstancePublicConnection(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::ReleaseInstancePublicConnectionOutcomeCallable PolardbxClient::releaseInstancePublicConnectionCallable(const ReleaseInstancePublicConnectionRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ReleaseInstancePublicConnectionOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->releaseInstancePublicConnection(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::ResetAccountPasswordOutcome PolardbxClient::resetAccountPassword(const ResetAccountPasswordRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ResetAccountPasswordOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ResetAccountPasswordOutcome(ResetAccountPasswordResult(outcome.result()));
|
|
else
|
|
return ResetAccountPasswordOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::resetAccountPasswordAsync(const ResetAccountPasswordRequest& request, const ResetAccountPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, resetAccountPassword(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::ResetAccountPasswordOutcomeCallable PolardbxClient::resetAccountPasswordCallable(const ResetAccountPasswordRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ResetAccountPasswordOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->resetAccountPassword(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::ResetPolarxPgAccountPasswordOutcome PolardbxClient::resetPolarxPgAccountPassword(const ResetPolarxPgAccountPasswordRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ResetPolarxPgAccountPasswordOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ResetPolarxPgAccountPasswordOutcome(ResetPolarxPgAccountPasswordResult(outcome.result()));
|
|
else
|
|
return ResetPolarxPgAccountPasswordOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::resetPolarxPgAccountPasswordAsync(const ResetPolarxPgAccountPasswordRequest& request, const ResetPolarxPgAccountPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, resetPolarxPgAccountPassword(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::ResetPolarxPgAccountPasswordOutcomeCallable PolardbxClient::resetPolarxPgAccountPasswordCallable(const ResetPolarxPgAccountPasswordRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ResetPolarxPgAccountPasswordOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->resetPolarxPgAccountPassword(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::RestartDBInstanceOutcome PolardbxClient::restartDBInstance(const RestartDBInstanceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return RestartDBInstanceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return RestartDBInstanceOutcome(RestartDBInstanceResult(outcome.result()));
|
|
else
|
|
return RestartDBInstanceOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::restartDBInstanceAsync(const RestartDBInstanceRequest& request, const RestartDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, restartDBInstance(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::RestartDBInstanceOutcomeCallable PolardbxClient::restartDBInstanceCallable(const RestartDBInstanceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<RestartDBInstanceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->restartDBInstance(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::RetryPolarxOrderOutcome PolardbxClient::retryPolarxOrder(const RetryPolarxOrderRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return RetryPolarxOrderOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return RetryPolarxOrderOutcome(RetryPolarxOrderResult(outcome.result()));
|
|
else
|
|
return RetryPolarxOrderOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::retryPolarxOrderAsync(const RetryPolarxOrderRequest& request, const RetryPolarxOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, retryPolarxOrder(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::RetryPolarxOrderOutcomeCallable PolardbxClient::retryPolarxOrderCallable(const RetryPolarxOrderRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<RetryPolarxOrderOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->retryPolarxOrder(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::UpdatePolarDBXInstanceNodeOutcome PolardbxClient::updatePolarDBXInstanceNode(const UpdatePolarDBXInstanceNodeRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UpdatePolarDBXInstanceNodeOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UpdatePolarDBXInstanceNodeOutcome(UpdatePolarDBXInstanceNodeResult(outcome.result()));
|
|
else
|
|
return UpdatePolarDBXInstanceNodeOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::updatePolarDBXInstanceNodeAsync(const UpdatePolarDBXInstanceNodeRequest& request, const UpdatePolarDBXInstanceNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, updatePolarDBXInstanceNode(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::UpdatePolarDBXInstanceNodeOutcomeCallable PolardbxClient::updatePolarDBXInstanceNodeCallable(const UpdatePolarDBXInstanceNodeRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UpdatePolarDBXInstanceNodeOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->updatePolarDBXInstanceNode(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PolardbxClient::UpgradeDBInstanceKernelVersionOutcome PolardbxClient::upgradeDBInstanceKernelVersion(const UpgradeDBInstanceKernelVersionRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UpgradeDBInstanceKernelVersionOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UpgradeDBInstanceKernelVersionOutcome(UpgradeDBInstanceKernelVersionResult(outcome.result()));
|
|
else
|
|
return UpgradeDBInstanceKernelVersionOutcome(outcome.error());
|
|
}
|
|
|
|
void PolardbxClient::upgradeDBInstanceKernelVersionAsync(const UpgradeDBInstanceKernelVersionRequest& request, const UpgradeDBInstanceKernelVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, upgradeDBInstanceKernelVersion(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PolardbxClient::UpgradeDBInstanceKernelVersionOutcomeCallable PolardbxClient::upgradeDBInstanceKernelVersionCallable(const UpgradeDBInstanceKernelVersionRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UpgradeDBInstanceKernelVersionOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->upgradeDBInstanceKernelVersion(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|