1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update Open API.

Browse Source
This commit is contained in:
sdk-team
2021-01-25 02:08:21 +00:00
parent 32dccef2ae
commit eaa6b3cb18
46 changed files with 130 additions and 3034 deletions
Download Patch File Download Diff File Expand all files Collapse all files

324
rds/src/RdsClient.cc
View File

@@ -843,114 +843,6 @@ RdsClient::CreateDedicatedHostOutcomeCallable RdsClient::createDedicatedHostCall
return task->get_future();
}
RdsClient::CreateDedicatedHostAccountOutcome RdsClient::createDedicatedHostAccount(const CreateDedicatedHostAccountRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateDedicatedHostAccountOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateDedicatedHostAccountOutcome(CreateDedicatedHostAccountResult(outcome.result()));
else
return CreateDedicatedHostAccountOutcome(outcome.error());
}
void RdsClient::createDedicatedHostAccountAsync(const CreateDedicatedHostAccountRequest& request, const CreateDedicatedHostAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createDedicatedHostAccount(request), context);
};
asyncExecute(new Runnable(fn));
}
RdsClient::CreateDedicatedHostAccountOutcomeCallable RdsClient::createDedicatedHostAccountCallable(const CreateDedicatedHostAccountRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateDedicatedHostAccountOutcome()>>(
[this, request]()
{
return this->createDedicatedHostAccount(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
RdsClient::CreateDedicatedHostGroupOutcome RdsClient::createDedicatedHostGroup(const CreateDedicatedHostGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateDedicatedHostGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateDedicatedHostGroupOutcome(CreateDedicatedHostGroupResult(outcome.result()));
else
return CreateDedicatedHostGroupOutcome(outcome.error());
}
void RdsClient::createDedicatedHostGroupAsync(const CreateDedicatedHostGroupRequest& request, const CreateDedicatedHostGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createDedicatedHostGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
RdsClient::CreateDedicatedHostGroupOutcomeCallable RdsClient::createDedicatedHostGroupCallable(const CreateDedicatedHostGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateDedicatedHostGroupOutcome()>>(
[this, request]()
{
return this->createDedicatedHostGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
RdsClient::CreateDedicatedHostUserOutcome RdsClient::createDedicatedHostUser(const CreateDedicatedHostUserRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateDedicatedHostUserOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateDedicatedHostUserOutcome(CreateDedicatedHostUserResult(outcome.result()));
else
return CreateDedicatedHostUserOutcome(outcome.error());
}
void RdsClient::createDedicatedHostUserAsync(const CreateDedicatedHostUserRequest& request, const CreateDedicatedHostUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createDedicatedHostUser(request), context);
};
asyncExecute(new Runnable(fn));
}
RdsClient::CreateDedicatedHostUserOutcomeCallable RdsClient::createDedicatedHostUserCallable(const CreateDedicatedHostUserRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateDedicatedHostUserOutcome()>>(
[this, request]()
{
return this->createDedicatedHostUser(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
RdsClient::CreateDiagnosticReportOutcome RdsClient::createDiagnosticReport(const CreateDiagnosticReportRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1455,78 +1347,6 @@ RdsClient::DeleteDatabaseOutcomeCallable RdsClient::deleteDatabaseCallable(const
return task->get_future();
}
RdsClient::DeleteDedicatedHostAccountOutcome RdsClient::deleteDedicatedHostAccount(const DeleteDedicatedHostAccountRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteDedicatedHostAccountOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteDedicatedHostAccountOutcome(DeleteDedicatedHostAccountResult(outcome.result()));
else
return DeleteDedicatedHostAccountOutcome(outcome.error());
}
void RdsClient::deleteDedicatedHostAccountAsync(const DeleteDedicatedHostAccountRequest& request, const DeleteDedicatedHostAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteDedicatedHostAccount(request), context);
};
asyncExecute(new Runnable(fn));
}
RdsClient::DeleteDedicatedHostAccountOutcomeCallable RdsClient::deleteDedicatedHostAccountCallable(const DeleteDedicatedHostAccountRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteDedicatedHostAccountOutcome()>>(
[this, request]()
{
return this->deleteDedicatedHostAccount(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
RdsClient::DeleteDedicatedHostGroupOutcome RdsClient::deleteDedicatedHostGroup(const DeleteDedicatedHostGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteDedicatedHostGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteDedicatedHostGroupOutcome(DeleteDedicatedHostGroupResult(outcome.result()));
else
return DeleteDedicatedHostGroupOutcome(outcome.error());
}
void RdsClient::deleteDedicatedHostGroupAsync(const DeleteDedicatedHostGroupRequest& request, const DeleteDedicatedHostGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteDedicatedHostGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
RdsClient::DeleteDedicatedHostGroupOutcomeCallable RdsClient::deleteDedicatedHostGroupCallable(const DeleteDedicatedHostGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteDedicatedHostGroupOutcome()>>(
[this, request]()
{
return this->deleteDedicatedHostGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
RdsClient::DeleteHostAccountOutcome RdsClient::deleteHostAccount(const DeleteHostAccountRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1815,42 +1635,6 @@ RdsClient::DescribeAvailableDedicatedHostClassesOutcomeCallable RdsClient::descr
return task->get_future();
}
RdsClient::DescribeAvailableDedicatedHostZonesOutcome RdsClient::describeAvailableDedicatedHostZones(const DescribeAvailableDedicatedHostZonesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeAvailableDedicatedHostZonesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeAvailableDedicatedHostZonesOutcome(DescribeAvailableDedicatedHostZonesResult(outcome.result()));
else
return DescribeAvailableDedicatedHostZonesOutcome(outcome.error());
}
void RdsClient::describeAvailableDedicatedHostZonesAsync(const DescribeAvailableDedicatedHostZonesRequest& request, const DescribeAvailableDedicatedHostZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeAvailableDedicatedHostZones(request), context);
};
asyncExecute(new Runnable(fn));
}
RdsClient::DescribeAvailableDedicatedHostZonesOutcomeCallable RdsClient::describeAvailableDedicatedHostZonesCallable(const DescribeAvailableDedicatedHostZonesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeAvailableDedicatedHostZonesOutcome()>>(
[this, request]()
{
return this->describeAvailableDedicatedHostZones(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
RdsClient::DescribeAvailableRecoveryTimeOutcome RdsClient::describeAvailableRecoveryTime(const DescribeAvailableRecoveryTimeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4767,78 +4551,6 @@ RdsClient::DestroyDBInstanceOutcomeCallable RdsClient::destroyDBInstanceCallable
return task->get_future();
}
RdsClient::DropDedicatedHostUserOutcome RdsClient::dropDedicatedHostUser(const DropDedicatedHostUserRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DropDedicatedHostUserOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DropDedicatedHostUserOutcome(DropDedicatedHostUserResult(outcome.result()));
else
return DropDedicatedHostUserOutcome(outcome.error());
}
void RdsClient::dropDedicatedHostUserAsync(const DropDedicatedHostUserRequest& request, const DropDedicatedHostUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, dropDedicatedHostUser(request), context);
};
asyncExecute(new Runnable(fn));
}
RdsClient::DropDedicatedHostUserOutcomeCallable RdsClient::dropDedicatedHostUserCallable(const DropDedicatedHostUserRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DropDedicatedHostUserOutcome()>>(
[this, request]()
{
return this->dropDedicatedHostUser(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
RdsClient::EvaluateDedicatedHostInstanceResourceOutcome RdsClient::evaluateDedicatedHostInstanceResource(const EvaluateDedicatedHostInstanceResourceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return EvaluateDedicatedHostInstanceResourceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return EvaluateDedicatedHostInstanceResourceOutcome(EvaluateDedicatedHostInstanceResourceResult(outcome.result()));
else
return EvaluateDedicatedHostInstanceResourceOutcome(outcome.error());
}
void RdsClient::evaluateDedicatedHostInstanceResourceAsync(const EvaluateDedicatedHostInstanceResourceRequest& request, const EvaluateDedicatedHostInstanceResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, evaluateDedicatedHostInstanceResource(request), context);
};
asyncExecute(new Runnable(fn));
}
RdsClient::EvaluateDedicatedHostInstanceResourceOutcomeCallable RdsClient::evaluateDedicatedHostInstanceResourceCallable(const EvaluateDedicatedHostInstanceResourceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<EvaluateDedicatedHostInstanceResourceOutcome()>>(
[this, request]()
{
return this->evaluateDedicatedHostInstanceResource(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
RdsClient::GetDBInstanceTopologyOutcome RdsClient::getDBInstanceTopology(const GetDBInstanceTopologyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -6315,42 +6027,6 @@ RdsClient::ModifyDedicatedHostGroupAttributeOutcomeCallable RdsClient::modifyDed
return task->get_future();
}
RdsClient::ModifyDedicatedHostUserOutcome RdsClient::modifyDedicatedHostUser(const ModifyDedicatedHostUserRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyDedicatedHostUserOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyDedicatedHostUserOutcome(ModifyDedicatedHostUserResult(outcome.result()));
else
return ModifyDedicatedHostUserOutcome(outcome.error());
}
void RdsClient::modifyDedicatedHostUserAsync(const ModifyDedicatedHostUserRequest& request, const ModifyDedicatedHostUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyDedicatedHostUser(request), context);
};
asyncExecute(new Runnable(fn));
}
RdsClient::ModifyDedicatedHostUserOutcomeCallable RdsClient::modifyDedicatedHostUserCallable(const ModifyDedicatedHostUserRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyDedicatedHostUserOutcome()>>(
[this, request]()
{
return this->modifyDedicatedHostUser(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
RdsClient::ModifyHASwitchConfigOutcome RdsClient::modifyHASwitchConfig(const ModifyHASwitchConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

117
rds/src/model/CreateDedicatedHostAccountRequest.cc
View File

@@ -1,117 +0,0 @@
/*
* 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/rds/model/CreateDedicatedHostAccountRequest.h>
using AlibabaCloud::Rds::Model::CreateDedicatedHostAccountRequest;
CreateDedicatedHostAccountRequest::CreateDedicatedHostAccountRequest() :
RpcServiceRequest("rds", "2014-08-15", "CreateDedicatedHostAccount")
{
setMethod(HttpRequest::Method::Post);
}
CreateDedicatedHostAccountRequest::~CreateDedicatedHostAccountRequest()
{}
long CreateDedicatedHostAccountRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateDedicatedHostAccountRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateDedicatedHostAccountRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateDedicatedHostAccountRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateDedicatedHostAccountRequest::getAccountName()const
{
return accountName_;
}
void CreateDedicatedHostAccountRequest::setAccountName(const std::string& accountName)
{
accountName_ = accountName;
setParameter("AccountName", accountName);
}
std::string CreateDedicatedHostAccountRequest::getRegionId()const
{
return regionId_;
}
void CreateDedicatedHostAccountRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateDedicatedHostAccountRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateDedicatedHostAccountRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateDedicatedHostAccountRequest::getDedicatedHostId()const
{
return dedicatedHostId_;
}
void CreateDedicatedHostAccountRequest::setDedicatedHostId(const std::string& dedicatedHostId)
{
dedicatedHostId_ = dedicatedHostId;
setParameter("DedicatedHostId", dedicatedHostId);
}
long CreateDedicatedHostAccountRequest::getOwnerId()const
{
return ownerId_;
}
void CreateDedicatedHostAccountRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateDedicatedHostAccountRequest::getAccountPassword()const
{
return accountPassword_;
}
void CreateDedicatedHostAccountRequest::setAccountPassword(const std::string& accountPassword)
{
accountPassword_ = accountPassword;
setParameter("AccountPassword", accountPassword);
}

44
rds/src/model/CreateDedicatedHostAccountResult.cc
View File

@@ -1,44 +0,0 @@
/*
* 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/rds/model/CreateDedicatedHostAccountResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
CreateDedicatedHostAccountResult::CreateDedicatedHostAccountResult() :
ServiceResult()
{}
CreateDedicatedHostAccountResult::CreateDedicatedHostAccountResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateDedicatedHostAccountResult::~CreateDedicatedHostAccountResult()
{}
void CreateDedicatedHostAccountResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

183
rds/src/model/CreateDedicatedHostGroupRequest.cc
View File

@@ -1,183 +0,0 @@
/*
* 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/rds/model/CreateDedicatedHostGroupRequest.h>
using AlibabaCloud::Rds::Model::CreateDedicatedHostGroupRequest;
CreateDedicatedHostGroupRequest::CreateDedicatedHostGroupRequest() :
RpcServiceRequest("rds", "2014-08-15", "CreateDedicatedHostGroup")
{
setMethod(HttpRequest::Method::Post);
}
CreateDedicatedHostGroupRequest::~CreateDedicatedHostGroupRequest()
{}
long CreateDedicatedHostGroupRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateDedicatedHostGroupRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
int CreateDedicatedHostGroupRequest::getCpuAllocationRatio()const
{
return cpuAllocationRatio_;
}
void CreateDedicatedHostGroupRequest::setCpuAllocationRatio(int cpuAllocationRatio)
{
cpuAllocationRatio_ = cpuAllocationRatio;
setParameter("CpuAllocationRatio", std::to_string(cpuAllocationRatio));
}
std::string CreateDedicatedHostGroupRequest::getClientToken()const
{
return clientToken_;
}
void CreateDedicatedHostGroupRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CreateDedicatedHostGroupRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateDedicatedHostGroupRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateDedicatedHostGroupRequest::getRegionId()const
{
return regionId_;
}
void CreateDedicatedHostGroupRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateDedicatedHostGroupRequest::getEngine()const
{
return engine_;
}
void CreateDedicatedHostGroupRequest::setEngine(const std::string& engine)
{
engine_ = engine;
setParameter("Engine", engine);
}
std::string CreateDedicatedHostGroupRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateDedicatedHostGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
int CreateDedicatedHostGroupRequest::getDiskAllocationRatio()const
{
return diskAllocationRatio_;
}
void CreateDedicatedHostGroupRequest::setDiskAllocationRatio(int diskAllocationRatio)
{
diskAllocationRatio_ = diskAllocationRatio;
setParameter("DiskAllocationRatio", std::to_string(diskAllocationRatio));
}
int CreateDedicatedHostGroupRequest::getOpenPermission()const
{
return openPermission_;
}
void CreateDedicatedHostGroupRequest::setOpenPermission(int openPermission)
{
openPermission_ = openPermission;
setParameter("OpenPermission", std::to_string(openPermission));
}
int CreateDedicatedHostGroupRequest::getMemAllocationRatio()const
{
return memAllocationRatio_;
}
void CreateDedicatedHostGroupRequest::setMemAllocationRatio(int memAllocationRatio)
{
memAllocationRatio_ = memAllocationRatio;
setParameter("MemAllocationRatio", std::to_string(memAllocationRatio));
}
long CreateDedicatedHostGroupRequest::getOwnerId()const
{
return ownerId_;
}
void CreateDedicatedHostGroupRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateDedicatedHostGroupRequest::getHostReplacePolicy()const
{
return hostReplacePolicy_;
}
void CreateDedicatedHostGroupRequest::setHostReplacePolicy(const std::string& hostReplacePolicy)
{
hostReplacePolicy_ = hostReplacePolicy;
setParameter("HostReplacePolicy", hostReplacePolicy);
}
std::string CreateDedicatedHostGroupRequest::getAllocationPolicy()const
{
return allocationPolicy_;
}
void CreateDedicatedHostGroupRequest::setAllocationPolicy(const std::string& allocationPolicy)
{
allocationPolicy_ = allocationPolicy;
setParameter("AllocationPolicy", allocationPolicy);
}
std::string CreateDedicatedHostGroupRequest::getVPCId()const
{
return vPCId_;
}
void CreateDedicatedHostGroupRequest::setVPCId(const std::string& vPCId)
{
vPCId_ = vPCId;
setParameter("VPCId", vPCId);
}

51
rds/src/model/CreateDedicatedHostGroupResult.cc
View File

@@ -1,51 +0,0 @@
/*
* 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/rds/model/CreateDedicatedHostGroupResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
CreateDedicatedHostGroupResult::CreateDedicatedHostGroupResult() :
ServiceResult()
{}
CreateDedicatedHostGroupResult::CreateDedicatedHostGroupResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateDedicatedHostGroupResult::~CreateDedicatedHostGroupResult()
{}
void CreateDedicatedHostGroupResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["DedicatedHostGroupId"].isNull())
dedicatedHostGroupId_ = value["DedicatedHostGroupId"].asString();
}
std::string CreateDedicatedHostGroupResult::getDedicatedHostGroupId()const
{
return dedicatedHostGroupId_;
}

117
rds/src/model/CreateDedicatedHostUserRequest.cc
View File

@@ -1,117 +0,0 @@
/*
* 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/rds/model/CreateDedicatedHostUserRequest.h>
using AlibabaCloud::Rds::Model::CreateDedicatedHostUserRequest;
CreateDedicatedHostUserRequest::CreateDedicatedHostUserRequest() :
RpcServiceRequest("rds", "2014-08-15", "CreateDedicatedHostUser")
{
setMethod(HttpRequest::Method::Post);
}
CreateDedicatedHostUserRequest::~CreateDedicatedHostUserRequest()
{}
long CreateDedicatedHostUserRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateDedicatedHostUserRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateDedicatedHostUserRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateDedicatedHostUserRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateDedicatedHostUserRequest::getUserPassword()const
{
return userPassword_;
}
void CreateDedicatedHostUserRequest::setUserPassword(const std::string& userPassword)
{
userPassword_ = userPassword;
setParameter("UserPassword", userPassword);
}
std::string CreateDedicatedHostUserRequest::getRegionId()const
{
return regionId_;
}
void CreateDedicatedHostUserRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateDedicatedHostUserRequest::getDedicatedHostName()const
{
return dedicatedHostName_;
}
void CreateDedicatedHostUserRequest::setDedicatedHostName(const std::string& dedicatedHostName)
{
dedicatedHostName_ = dedicatedHostName;
setParameter("DedicatedHostName", dedicatedHostName);
}
std::string CreateDedicatedHostUserRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateDedicatedHostUserRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long CreateDedicatedHostUserRequest::getOwnerId()const
{
return ownerId_;
}
void CreateDedicatedHostUserRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateDedicatedHostUserRequest::getUserName()const
{
return userName_;
}
void CreateDedicatedHostUserRequest::setUserName(const std::string& userName)
{
userName_ = userName;
setParameter("UserName", userName);
}

44
rds/src/model/CreateDedicatedHostUserResult.cc
View File

@@ -1,44 +0,0 @@
/*
* 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/rds/model/CreateDedicatedHostUserResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
CreateDedicatedHostUserResult::CreateDedicatedHostUserResult() :
ServiceResult()
{}
CreateDedicatedHostUserResult::CreateDedicatedHostUserResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateDedicatedHostUserResult::~CreateDedicatedHostUserResult()
{}
void CreateDedicatedHostUserResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

106
rds/src/model/DeleteDedicatedHostAccountRequest.cc
View File

@@ -1,106 +0,0 @@
/*
* 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/rds/model/DeleteDedicatedHostAccountRequest.h>
using AlibabaCloud::Rds::Model::DeleteDedicatedHostAccountRequest;
DeleteDedicatedHostAccountRequest::DeleteDedicatedHostAccountRequest() :
RpcServiceRequest("rds", "2014-08-15", "DeleteDedicatedHostAccount")
{
setMethod(HttpRequest::Method::Post);
}
DeleteDedicatedHostAccountRequest::~DeleteDedicatedHostAccountRequest()
{}
long DeleteDedicatedHostAccountRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteDedicatedHostAccountRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteDedicatedHostAccountRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteDedicatedHostAccountRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteDedicatedHostAccountRequest::getDedicatedHostId()const
{
return dedicatedHostId_;
}
void DeleteDedicatedHostAccountRequest::setDedicatedHostId(const std::string& dedicatedHostId)
{
dedicatedHostId_ = dedicatedHostId;
setParameter("DedicatedHostId", dedicatedHostId);
}
long DeleteDedicatedHostAccountRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteDedicatedHostAccountRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteDedicatedHostAccountRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteDedicatedHostAccountRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DeleteDedicatedHostAccountRequest::getAccountName()const
{
return accountName_;
}
void DeleteDedicatedHostAccountRequest::setAccountName(const std::string& accountName)
{
accountName_ = accountName;
setParameter("AccountName", accountName);
}
std::string DeleteDedicatedHostAccountRequest::getRegionId()const
{
return regionId_;
}
void DeleteDedicatedHostAccountRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}

44
rds/src/model/DeleteDedicatedHostAccountResult.cc
View File

@@ -1,44 +0,0 @@
/*
* 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/rds/model/DeleteDedicatedHostAccountResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
DeleteDedicatedHostAccountResult::DeleteDedicatedHostAccountResult() :
ServiceResult()
{}
DeleteDedicatedHostAccountResult::DeleteDedicatedHostAccountResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteDedicatedHostAccountResult::~DeleteDedicatedHostAccountResult()
{}
void DeleteDedicatedHostAccountResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

95
rds/src/model/DeleteDedicatedHostGroupRequest.cc
View File

@@ -1,95 +0,0 @@
/*
* 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/rds/model/DeleteDedicatedHostGroupRequest.h>
using AlibabaCloud::Rds::Model::DeleteDedicatedHostGroupRequest;
DeleteDedicatedHostGroupRequest::DeleteDedicatedHostGroupRequest() :
RpcServiceRequest("rds", "2014-08-15", "DeleteDedicatedHostGroup")
{
setMethod(HttpRequest::Method::Post);
}
DeleteDedicatedHostGroupRequest::~DeleteDedicatedHostGroupRequest()
{}
long DeleteDedicatedHostGroupRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteDedicatedHostGroupRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteDedicatedHostGroupRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteDedicatedHostGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long DeleteDedicatedHostGroupRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteDedicatedHostGroupRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteDedicatedHostGroupRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteDedicatedHostGroupRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DeleteDedicatedHostGroupRequest::getRegionId()const
{
return regionId_;
}
void DeleteDedicatedHostGroupRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DeleteDedicatedHostGroupRequest::getDedicatedHostGroupId()const
{
return dedicatedHostGroupId_;
}
void DeleteDedicatedHostGroupRequest::setDedicatedHostGroupId(const std::string& dedicatedHostGroupId)
{
dedicatedHostGroupId_ = dedicatedHostGroupId;
setParameter("DedicatedHostGroupId", dedicatedHostGroupId);
}

44
rds/src/model/DeleteDedicatedHostGroupResult.cc
View File

@@ -1,44 +0,0 @@
/*
* 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/rds/model/DeleteDedicatedHostGroupResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
DeleteDedicatedHostGroupResult::DeleteDedicatedHostGroupResult() :
ServiceResult()
{}
DeleteDedicatedHostGroupResult::DeleteDedicatedHostGroupResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteDedicatedHostGroupResult::~DeleteDedicatedHostGroupResult()
{}
void DeleteDedicatedHostGroupResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

84
rds/src/model/DescribeAvailableDedicatedHostZonesRequest.cc
View File

@@ -1,84 +0,0 @@
/*
* 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/rds/model/DescribeAvailableDedicatedHostZonesRequest.h>
using AlibabaCloud::Rds::Model::DescribeAvailableDedicatedHostZonesRequest;
DescribeAvailableDedicatedHostZonesRequest::DescribeAvailableDedicatedHostZonesRequest() :
RpcServiceRequest("rds", "2014-08-15", "DescribeAvailableDedicatedHostZones")
{
setMethod(HttpRequest::Method::Post);
}
DescribeAvailableDedicatedHostZonesRequest::~DescribeAvailableDedicatedHostZonesRequest()
{}
long DescribeAvailableDedicatedHostZonesRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeAvailableDedicatedHostZonesRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeAvailableDedicatedHostZonesRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeAvailableDedicatedHostZonesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long DescribeAvailableDedicatedHostZonesRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeAvailableDedicatedHostZonesRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeAvailableDedicatedHostZonesRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeAvailableDedicatedHostZonesRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeAvailableDedicatedHostZonesRequest::getRegionId()const
{
return regionId_;
}
void DescribeAvailableDedicatedHostZonesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}

59
rds/src/model/DescribeAvailableDedicatedHostZonesResult.cc
View File

@@ -1,59 +0,0 @@
/*
* 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/rds/model/DescribeAvailableDedicatedHostZonesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
DescribeAvailableDedicatedHostZonesResult::DescribeAvailableDedicatedHostZonesResult() :
ServiceResult()
{}
DescribeAvailableDedicatedHostZonesResult::DescribeAvailableDedicatedHostZonesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeAvailableDedicatedHostZonesResult::~DescribeAvailableDedicatedHostZonesResult()
{}
void DescribeAvailableDedicatedHostZonesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allZonesNode = value["Zones"]["DedicatedHostZones"];
for (auto valueZonesDedicatedHostZones : allZonesNode)
{
DedicatedHostZones zonesObject;
if(!valueZonesDedicatedHostZones["ZoneId"].isNull())
zonesObject.zoneId = valueZonesDedicatedHostZones["ZoneId"].asString();
if(!valueZonesDedicatedHostZones["Description"].isNull())
zonesObject.description = valueZonesDedicatedHostZones["Description"].asString();
zones_.push_back(zonesObject);
}
}
std::vector<DescribeAvailableDedicatedHostZonesResult::DedicatedHostZones> DescribeAvailableDedicatedHostZonesResult::getZones()const
{
return zones_;
}

31
rds/src/model/DescribeDBProxyEndpointResult.cc
View File

@@ -39,6 +39,18 @@ void DescribeDBProxyEndpointResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allEndpointConnectItemsNode = value["EndpointConnectItems"]["EndpointConnectItemsItem"];
for (auto valueEndpointConnectItemsEndpointConnectItemsItem : allEndpointConnectItemsNode)
{
EndpointConnectItemsItem endpointConnectItemsObject;
if(!valueEndpointConnectItemsEndpointConnectItemsItem["DbProxyEndpointConnectString"].isNull())
endpointConnectItemsObject.dbProxyEndpointConnectString = valueEndpointConnectItemsEndpointConnectItemsItem["DbProxyEndpointConnectString"].asString();
if(!valueEndpointConnectItemsEndpointConnectItemsItem["DbProxyEndpointPort"].isNull())
endpointConnectItemsObject.dbProxyEndpointPort = valueEndpointConnectItemsEndpointConnectItemsItem["DbProxyEndpointPort"].asString();
if(!valueEndpointConnectItemsEndpointConnectItemsItem["DbProxyEndpointNetType"].isNull())
endpointConnectItemsObject.dbProxyEndpointNetType = valueEndpointConnectItemsEndpointConnectItemsItem["DbProxyEndpointNetType"].asString();
endpointConnectItems_.push_back(endpointConnectItemsObject);
}
if(!value["DBProxyEndpointId"].isNull())
dBProxyEndpointId_ = value["DBProxyEndpointId"].asString();
if(!value["DBProxyConnectString"].isNull())
@@ -55,6 +67,10 @@ void DescribeDBProxyEndpointResult::parse(const std::string &payload)
readOnlyInstanceDistributionType_ = value["ReadOnlyInstanceDistributionType"].asString();
if(!value["ReadOnlyInstanceWeight"].isNull())
readOnlyInstanceWeight_ = value["ReadOnlyInstanceWeight"].asString();
if(!value["DbProxyEndpointAliases"].isNull())
dbProxyEndpointAliases_ = value["DbProxyEndpointAliases"].asString();
if(!value["DbProxyEndpointReadWriteMode"].isNull())
dbProxyEndpointReadWriteMode_ = value["DbProxyEndpointReadWriteMode"].asString();
}
@@ -63,6 +79,11 @@ std::string DescribeDBProxyEndpointResult::getReadOnlyInstanceDistributionType()
return readOnlyInstanceDistributionType_;
}
std::string DescribeDBProxyEndpointResult::getDbProxyEndpointReadWriteMode()const
{
return dbProxyEndpointReadWriteMode_;
}
std::string DescribeDBProxyEndpointResult::getDBProxyConnectString()const
{
return dBProxyConnectString_;
@@ -73,6 +94,11 @@ std::string DescribeDBProxyEndpointResult::getDBProxyEndpointId()const
return dBProxyEndpointId_;
}
std::string DescribeDBProxyEndpointResult::getDbProxyEndpointAliases()const
{
return dbProxyEndpointAliases_;
}
std::string DescribeDBProxyEndpointResult::getDBProxyFeatures()const
{
return dBProxyFeatures_;
@@ -93,6 +119,11 @@ std::string DescribeDBProxyEndpointResult::getDBProxyConnectStringNetType()const
return dBProxyConnectStringNetType_;
}
std::vector<DescribeDBProxyEndpointResult::EndpointConnectItemsItem> DescribeDBProxyEndpointResult::getEndpointConnectItems()const
{
return endpointConnectItems_;
}
std::string DescribeDBProxyEndpointResult::getDBProxyConnectStringPort()const
{
return dBProxyConnectStringPort_;

19
rds/src/model/DescribeDBProxyResult.cc
View File

@@ -59,6 +59,20 @@ void DescribeDBProxyResult::parse(const std::string &payload)
dBProxyConnectStringItemsObject.dBProxyConnectStringNetWorkType = valueDBProxyConnectStringItemsDBProxyConnectStringItemsItem["DBProxyConnectStringNetWorkType"].asString();
dBProxyConnectStringItems_.push_back(dBProxyConnectStringItemsObject);
}
auto allDbProxyEndpointItemsNode = value["DbProxyEndpointItems"]["DbProxyEndpointItemsItem"];
for (auto valueDbProxyEndpointItemsDbProxyEndpointItemsItem : allDbProxyEndpointItemsNode)
{
DbProxyEndpointItemsItem dbProxyEndpointItemsObject;
if(!valueDbProxyEndpointItemsDbProxyEndpointItemsItem["DbProxyEndpointName"].isNull())
dbProxyEndpointItemsObject.dbProxyEndpointName = valueDbProxyEndpointItemsDbProxyEndpointItemsItem["DbProxyEndpointName"].asString();
if(!valueDbProxyEndpointItemsDbProxyEndpointItemsItem["DbProxyEndpointType"].isNull())
dbProxyEndpointItemsObject.dbProxyEndpointType = valueDbProxyEndpointItemsDbProxyEndpointItemsItem["DbProxyEndpointType"].asString();
if(!valueDbProxyEndpointItemsDbProxyEndpointItemsItem["DbProxyReadWriteMode"].isNull())
dbProxyEndpointItemsObject.dbProxyReadWriteMode = valueDbProxyEndpointItemsDbProxyEndpointItemsItem["DbProxyReadWriteMode"].asString();
if(!valueDbProxyEndpointItemsDbProxyEndpointItemsItem["DbProxyEndpointAliases"].isNull())
dbProxyEndpointItemsObject.dbProxyEndpointAliases = valueDbProxyEndpointItemsDbProxyEndpointItemsItem["DbProxyEndpointAliases"].asString();
dbProxyEndpointItems_.push_back(dbProxyEndpointItemsObject);
}
if(!value["DBProxyServiceStatus"].isNull())
dBProxyServiceStatus_ = value["DBProxyServiceStatus"].asString();
if(!value["DBProxyInstanceType"].isNull())
@@ -101,6 +115,11 @@ std::string DescribeDBProxyResult::getDBProxyInstanceLatestMinorVersion()const
return dBProxyInstanceLatestMinorVersion_;
}
std::vector<DescribeDBProxyResult::DbProxyEndpointItemsItem> DescribeDBProxyResult::getDbProxyEndpointItems()const
{
return dbProxyEndpointItems_;
}
std::vector<DescribeDBProxyResult::DBProxyConnectStringItemsItem> DescribeDBProxyResult::getDBProxyConnectStringItems()const
{
return dBProxyConnectStringItems_;

106
rds/src/model/DropDedicatedHostUserRequest.cc
View File

@@ -1,106 +0,0 @@
/*
* 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/rds/model/DropDedicatedHostUserRequest.h>
using AlibabaCloud::Rds::Model::DropDedicatedHostUserRequest;
DropDedicatedHostUserRequest::DropDedicatedHostUserRequest() :
RpcServiceRequest("rds", "2014-08-15", "DropDedicatedHostUser")
{
setMethod(HttpRequest::Method::Post);
}
DropDedicatedHostUserRequest::~DropDedicatedHostUserRequest()
{}
long DropDedicatedHostUserRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DropDedicatedHostUserRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DropDedicatedHostUserRequest::getDedicatedHostName()const
{
return dedicatedHostName_;
}
void DropDedicatedHostUserRequest::setDedicatedHostName(const std::string& dedicatedHostName)
{
dedicatedHostName_ = dedicatedHostName;
setParameter("DedicatedHostName", dedicatedHostName);
}
std::string DropDedicatedHostUserRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DropDedicatedHostUserRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long DropDedicatedHostUserRequest::getOwnerId()const
{
return ownerId_;
}
void DropDedicatedHostUserRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DropDedicatedHostUserRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DropDedicatedHostUserRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DropDedicatedHostUserRequest::getRegionId()const
{
return regionId_;
}
void DropDedicatedHostUserRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DropDedicatedHostUserRequest::getUserName()const
{
return userName_;
}
void DropDedicatedHostUserRequest::setUserName(const std::string& userName)
{
userName_ = userName;
setParameter("UserName", userName);
}

44
rds/src/model/DropDedicatedHostUserResult.cc
View File

@@ -1,44 +0,0 @@
/*
* 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/rds/model/DropDedicatedHostUserResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
DropDedicatedHostUserResult::DropDedicatedHostUserResult() :
ServiceResult()
{}
DropDedicatedHostUserResult::DropDedicatedHostUserResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DropDedicatedHostUserResult::~DropDedicatedHostUserResult()
{}
void DropDedicatedHostUserResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

150
rds/src/model/EvaluateDedicatedHostInstanceResourceRequest.cc
View File

@@ -1,150 +0,0 @@
/*
* 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/rds/model/EvaluateDedicatedHostInstanceResourceRequest.h>
using AlibabaCloud::Rds::Model::EvaluateDedicatedHostInstanceResourceRequest;
EvaluateDedicatedHostInstanceResourceRequest::EvaluateDedicatedHostInstanceResourceRequest() :
RpcServiceRequest("rds", "2014-08-15", "EvaluateDedicatedHostInstanceResource")
{
setMethod(HttpRequest::Method::Post);
}
EvaluateDedicatedHostInstanceResourceRequest::~EvaluateDedicatedHostInstanceResourceRequest()
{}
long EvaluateDedicatedHostInstanceResourceRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string EvaluateDedicatedHostInstanceResourceRequest::getEngineVersion()const
{
return engineVersion_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setEngineVersion(const std::string& engineVersion)
{
engineVersion_ = engineVersion;
setParameter("EngineVersion", engineVersion);
}
std::string EvaluateDedicatedHostInstanceResourceRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string EvaluateDedicatedHostInstanceResourceRequest::getRegionId()const
{
return regionId_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string EvaluateDedicatedHostInstanceResourceRequest::getEngine()const
{
return engine_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setEngine(const std::string& engine)
{
engine_ = engine;
setParameter("Engine", engine);
}
std::string EvaluateDedicatedHostInstanceResourceRequest::getDedicatedHostGroupId()const
{
return dedicatedHostGroupId_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setDedicatedHostGroupId(const std::string& dedicatedHostGroupId)
{
dedicatedHostGroupId_ = dedicatedHostGroupId;
setParameter("DedicatedHostGroupId", dedicatedHostGroupId);
}
std::string EvaluateDedicatedHostInstanceResourceRequest::getInstanceClassNames()const
{
return instanceClassNames_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setInstanceClassNames(const std::string& instanceClassNames)
{
instanceClassNames_ = instanceClassNames;
setParameter("InstanceClassNames", instanceClassNames);
}
std::string EvaluateDedicatedHostInstanceResourceRequest::getDiskSize()const
{
return diskSize_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setDiskSize(const std::string& diskSize)
{
diskSize_ = diskSize;
setParameter("DiskSize", diskSize);
}
std::string EvaluateDedicatedHostInstanceResourceRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long EvaluateDedicatedHostInstanceResourceRequest::getOwnerId()const
{
return ownerId_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string EvaluateDedicatedHostInstanceResourceRequest::getDiskType()const
{
return diskType_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setDiskType(const std::string& diskType)
{
diskType_ = diskType;
setParameter("DiskType", diskType);
}

58
rds/src/model/EvaluateDedicatedHostInstanceResourceResult.cc
View File

@@ -1,58 +0,0 @@
/*
* 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/rds/model/EvaluateDedicatedHostInstanceResourceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
EvaluateDedicatedHostInstanceResourceResult::EvaluateDedicatedHostInstanceResourceResult() :
ServiceResult()
{}
EvaluateDedicatedHostInstanceResourceResult::EvaluateDedicatedHostInstanceResourceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
EvaluateDedicatedHostInstanceResourceResult::~EvaluateDedicatedHostInstanceResourceResult()
{}
void EvaluateDedicatedHostInstanceResourceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["DBInstanceClass"].isNull())
dBInstanceClass_ = value["DBInstanceClass"].asString();
if(!value["Available"].isNull())
available_ = std::stoi(value["Available"].asString());
}
std::string EvaluateDedicatedHostInstanceResourceResult::getDBInstanceClass()const
{
return dBInstanceClass_;
}
int EvaluateDedicatedHostInstanceResourceResult::getAvailable()const
{
return available_;
}

44
rds/src/model/ModifyDBProxyEndpointRequest.cc
View File

@@ -115,6 +115,39 @@ void ModifyDBProxyEndpointRequest::setResourceOwnerAccount(const std::string& re
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string ModifyDBProxyEndpointRequest::getDbEndpointAliases()const
{
return dbEndpointAliases_;
}
void ModifyDBProxyEndpointRequest::setDbEndpointAliases(const std::string& dbEndpointAliases)
{
dbEndpointAliases_ = dbEndpointAliases;
setParameter("DbEndpointAliases", dbEndpointAliases);
}
std::string ModifyDBProxyEndpointRequest::getDbEndpointOperator()const
{
return dbEndpointOperator_;
}
void ModifyDBProxyEndpointRequest::setDbEndpointOperator(const std::string& dbEndpointOperator)
{
dbEndpointOperator_ = dbEndpointOperator;
setParameter("DbEndpointOperator", dbEndpointOperator);
}
std::string ModifyDBProxyEndpointRequest::getDbEndpointType()const
{
return dbEndpointType_;
}
void ModifyDBProxyEndpointRequest::setDbEndpointType(const std::string& dbEndpointType)
{
dbEndpointType_ = dbEndpointType;
setParameter("DbEndpointType", dbEndpointType);
}
long ModifyDBProxyEndpointRequest::getOwnerId()const
{
return ownerId_;
@@ -126,6 +159,17 @@ void ModifyDBProxyEndpointRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string ModifyDBProxyEndpointRequest::getDbEndpointReadWriteMode()const
{
return dbEndpointReadWriteMode_;
}
void ModifyDBProxyEndpointRequest::setDbEndpointReadWriteMode(const std::string& dbEndpointReadWriteMode)
{
dbEndpointReadWriteMode_ = dbEndpointReadWriteMode;
setParameter("DbEndpointReadWriteMode", dbEndpointReadWriteMode);
}
std::string ModifyDBProxyEndpointRequest::getDBProxyEndpointId()const
{
return dBProxyEndpointId_;

128
rds/src/model/ModifyDedicatedHostUserRequest.cc
View File

@@ -1,128 +0,0 @@
/*
* 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/rds/model/ModifyDedicatedHostUserRequest.h>
using AlibabaCloud::Rds::Model::ModifyDedicatedHostUserRequest;
ModifyDedicatedHostUserRequest::ModifyDedicatedHostUserRequest() :
RpcServiceRequest("rds", "2014-08-15", "ModifyDedicatedHostUser")
{
setMethod(HttpRequest::Method::Post);
}
ModifyDedicatedHostUserRequest::~ModifyDedicatedHostUserRequest()
{}
long ModifyDedicatedHostUserRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void ModifyDedicatedHostUserRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string ModifyDedicatedHostUserRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void ModifyDedicatedHostUserRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string ModifyDedicatedHostUserRequest::getRegionId()const
{
return regionId_;
}
void ModifyDedicatedHostUserRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string ModifyDedicatedHostUserRequest::getDedicatedHostName()const
{
return dedicatedHostName_;
}
void ModifyDedicatedHostUserRequest::setDedicatedHostName(const std::string& dedicatedHostName)
{
dedicatedHostName_ = dedicatedHostName;
setParameter("DedicatedHostName", dedicatedHostName);
}
std::string ModifyDedicatedHostUserRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void ModifyDedicatedHostUserRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string ModifyDedicatedHostUserRequest::getOldPassword()const
{
return oldPassword_;
}
void ModifyDedicatedHostUserRequest::setOldPassword(const std::string& oldPassword)
{
oldPassword_ = oldPassword;
setParameter("OldPassword", oldPassword);
}
long ModifyDedicatedHostUserRequest::getOwnerId()const
{
return ownerId_;
}
void ModifyDedicatedHostUserRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string ModifyDedicatedHostUserRequest::getNewPassword()const
{
return newPassword_;
}
void ModifyDedicatedHostUserRequest::setNewPassword(const std::string& newPassword)
{
newPassword_ = newPassword;
setParameter("NewPassword", newPassword);
}
std::string ModifyDedicatedHostUserRequest::getUserName()const
{
return userName_;
}
void ModifyDedicatedHostUserRequest::setUserName(const std::string& userName)
{
userName_ = userName;
setParameter("UserName", userName);
}

44
rds/src/model/ModifyDedicatedHostUserResult.cc
View File

@@ -1,44 +0,0 @@
/*
* 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/rds/model/ModifyDedicatedHostUserResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
ModifyDedicatedHostUserResult::ModifyDedicatedHostUserResult() :
ServiceResult()
{}
ModifyDedicatedHostUserResult::ModifyDedicatedHostUserResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ModifyDedicatedHostUserResult::~ModifyDedicatedHostUserResult()
{}
void ModifyDedicatedHostUserResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}