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

update Rds module

Browse Source
This commit is contained in:
fenglc
2018-02-05 15:14:22 +08:00
parent ac5a683e3d
commit eaaa575e1d
571 changed files with 31516 additions and 31437 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1810
rds/src/RdsClient.cc
View File

File diff suppressed because it is too large Load Diff

27
rds/src/RdsRequest.cc
View File

@@ -1,27 +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/RdsRequest.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Rds;
RdsRequest::RdsRequest(const std::string & action) :
RpcServiceRequest("rds", "2014-08-15", action)
{ }
RdsRequest::~RdsRequest()
{ }

137
rds/src/model/AddBuDBInstanceRelationRequest.cc
View File

@@ -16,79 +16,78 @@
#include <alibabacloud/rds/model/AddBuDBInstanceRelationRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::AddBuDBInstanceRelationRequest;
AddBuDBInstanceRelationRequest::AddBuDBInstanceRelationRequest() :
RdsRequest("AddBuDBInstanceRelation")
RpcServiceRequest("rds", "2014-08-15", "AddBuDBInstanceRelation")
{}
AddBuDBInstanceRelationRequest::~AddBuDBInstanceRelationRequest()
{}
std::string AddBuDBInstanceRelationRequest::getBusinessUnit()const
{
return businessUnit_;
}
void AddBuDBInstanceRelationRequest::setBusinessUnit(const std::string& businessUnit)
{
businessUnit_ = businessUnit;
setParameter("BusinessUnit", businessUnit);
}
long AddBuDBInstanceRelationRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void AddBuDBInstanceRelationRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string AddBuDBInstanceRelationRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void AddBuDBInstanceRelationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string AddBuDBInstanceRelationRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void AddBuDBInstanceRelationRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long AddBuDBInstanceRelationRequest::getOwnerId()const
{
return ownerId_;
}
void AddBuDBInstanceRelationRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string AddBuDBInstanceRelationRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void AddBuDBInstanceRelationRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string AddBuDBInstanceRelationRequest::getBusinessUnit()const
{
return businessUnit_;
}
void AddBuDBInstanceRelationRequest::setBusinessUnit(const std::string& businessUnit)
{
businessUnit_ = businessUnit;
setParameter("BusinessUnit", businessUnit);
}
long AddBuDBInstanceRelationRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void AddBuDBInstanceRelationRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string AddBuDBInstanceRelationRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void AddBuDBInstanceRelationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string AddBuDBInstanceRelationRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void AddBuDBInstanceRelationRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long AddBuDBInstanceRelationRequest::getOwnerId()const
{
return ownerId_;
}
void AddBuDBInstanceRelationRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string AddBuDBInstanceRelationRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void AddBuDBInstanceRelationRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

36
rds/src/model/AddBuDBInstanceRelationResult.cc
View File

@@ -40,28 +40,20 @@ void AddBuDBInstanceRelationResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
businessUnit_ = value["BusinessUnit"].asString();
dBInstanceName_ = value["DBInstanceName"].asString();
if(!value["BusinessUnit"].isNull())
businessUnit_ = value["BusinessUnit"].asString();
if(!value["DBInstanceName"].isNull())
dBInstanceName_ = value["DBInstanceName"].asString();
}
std::string AddBuDBInstanceRelationResult::getBusinessUnit()const
{
return businessUnit_;
}
void AddBuDBInstanceRelationResult::setBusinessUnit(const std::string& businessUnit)
{
businessUnit_ = businessUnit;
}
std::string AddBuDBInstanceRelationResult::getDBInstanceName()const
{
return dBInstanceName_;
}
void AddBuDBInstanceRelationResult::setDBInstanceName(const std::string& dBInstanceName)
{
dBInstanceName_ = dBInstanceName;
}
std::string AddBuDBInstanceRelationResult::getBusinessUnit()const
{
return businessUnit_;
}
std::string AddBuDBInstanceRelationResult::getDBInstanceName()const
{
return dBInstanceName_;
}

445
rds/src/model/AddTagsToResourceRequest.cc
View File

@@ -16,233 +16,232 @@
#include <alibabacloud/rds/model/AddTagsToResourceRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::AddTagsToResourceRequest;
AddTagsToResourceRequest::AddTagsToResourceRequest() :
RdsRequest("AddTagsToResource")
RpcServiceRequest("rds", "2014-08-15", "AddTagsToResource")
{}
AddTagsToResourceRequest::~AddTagsToResourceRequest()
{}
std::string AddTagsToResourceRequest::getTag4value()const
{
return tag4value_;
}
void AddTagsToResourceRequest::setTag4value(const std::string& tag4value)
{
tag4value_ = tag4value;
setParameter("Tag4value", tag4value);
}
long AddTagsToResourceRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void AddTagsToResourceRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string AddTagsToResourceRequest::getTag2key()const
{
return tag2key_;
}
void AddTagsToResourceRequest::setTag2key(const std::string& tag2key)
{
tag2key_ = tag2key;
setParameter("Tag2key", tag2key);
}
std::string AddTagsToResourceRequest::getTag5key()const
{
return tag5key_;
}
void AddTagsToResourceRequest::setTag5key(const std::string& tag5key)
{
tag5key_ = tag5key;
setParameter("Tag5key", tag5key);
}
std::string AddTagsToResourceRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void AddTagsToResourceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string AddTagsToResourceRequest::getClientToken()const
{
return clientToken_;
}
void AddTagsToResourceRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string AddTagsToResourceRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void AddTagsToResourceRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string AddTagsToResourceRequest::getTag3key()const
{
return tag3key_;
}
void AddTagsToResourceRequest::setTag3key(const std::string& tag3key)
{
tag3key_ = tag3key;
setParameter("Tag3key", tag3key);
}
long AddTagsToResourceRequest::getOwnerId()const
{
return ownerId_;
}
void AddTagsToResourceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string AddTagsToResourceRequest::getTag5value()const
{
return tag5value_;
}
void AddTagsToResourceRequest::setTag5value(const std::string& tag5value)
{
tag5value_ = tag5value;
setParameter("Tag5value", tag5value);
}
std::string AddTagsToResourceRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void AddTagsToResourceRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string AddTagsToResourceRequest::getTags()const
{
return tags_;
}
void AddTagsToResourceRequest::setTags(const std::string& tags)
{
tags_ = tags;
setParameter("Tags", tags);
}
std::string AddTagsToResourceRequest::getTag1key()const
{
return tag1key_;
}
void AddTagsToResourceRequest::setTag1key(const std::string& tag1key)
{
tag1key_ = tag1key;
setParameter("Tag1key", tag1key);
}
std::string AddTagsToResourceRequest::getTag1value()const
{
return tag1value_;
}
void AddTagsToResourceRequest::setTag1value(const std::string& tag1value)
{
tag1value_ = tag1value;
setParameter("Tag1value", tag1value);
}
std::string AddTagsToResourceRequest::getRegionId()const
{
return regionId_;
}
void AddTagsToResourceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string AddTagsToResourceRequest::getTag2value()const
{
return tag2value_;
}
void AddTagsToResourceRequest::setTag2value(const std::string& tag2value)
{
tag2value_ = tag2value;
setParameter("Tag2value", tag2value);
}
std::string AddTagsToResourceRequest::getTag4key()const
{
return tag4key_;
}
void AddTagsToResourceRequest::setTag4key(const std::string& tag4key)
{
tag4key_ = tag4key;
setParameter("Tag4key", tag4key);
}
std::string AddTagsToResourceRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void AddTagsToResourceRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string AddTagsToResourceRequest::getTag3value()const
{
return tag3value_;
}
void AddTagsToResourceRequest::setTag3value(const std::string& tag3value)
{
tag3value_ = tag3value;
setParameter("Tag3value", tag3value);
}
std::string AddTagsToResourceRequest::getProxyId()const
{
return proxyId_;
}
void AddTagsToResourceRequest::setProxyId(const std::string& proxyId)
{
proxyId_ = proxyId;
setParameter("ProxyId", proxyId);
}
std::string AddTagsToResourceRequest::getTag4value()const
{
return tag4value_;
}
void AddTagsToResourceRequest::setTag4value(const std::string& tag4value)
{
tag4value_ = tag4value;
setParameter("Tag4value", tag4value);
}
long AddTagsToResourceRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void AddTagsToResourceRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string AddTagsToResourceRequest::getTag2key()const
{
return tag2key_;
}
void AddTagsToResourceRequest::setTag2key(const std::string& tag2key)
{
tag2key_ = tag2key;
setParameter("Tag2key", tag2key);
}
std::string AddTagsToResourceRequest::getTag5key()const
{
return tag5key_;
}
void AddTagsToResourceRequest::setTag5key(const std::string& tag5key)
{
tag5key_ = tag5key;
setParameter("Tag5key", tag5key);
}
std::string AddTagsToResourceRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void AddTagsToResourceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string AddTagsToResourceRequest::getClientToken()const
{
return clientToken_;
}
void AddTagsToResourceRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string AddTagsToResourceRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void AddTagsToResourceRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string AddTagsToResourceRequest::getTag3key()const
{
return tag3key_;
}
void AddTagsToResourceRequest::setTag3key(const std::string& tag3key)
{
tag3key_ = tag3key;
setParameter("Tag3key", tag3key);
}
long AddTagsToResourceRequest::getOwnerId()const
{
return ownerId_;
}
void AddTagsToResourceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string AddTagsToResourceRequest::getTag5value()const
{
return tag5value_;
}
void AddTagsToResourceRequest::setTag5value(const std::string& tag5value)
{
tag5value_ = tag5value;
setParameter("Tag5value", tag5value);
}
std::string AddTagsToResourceRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void AddTagsToResourceRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string AddTagsToResourceRequest::getTags()const
{
return tags_;
}
void AddTagsToResourceRequest::setTags(const std::string& tags)
{
tags_ = tags;
setParameter("Tags", tags);
}
std::string AddTagsToResourceRequest::getTag1key()const
{
return tag1key_;
}
void AddTagsToResourceRequest::setTag1key(const std::string& tag1key)
{
tag1key_ = tag1key;
setParameter("Tag1key", tag1key);
}
std::string AddTagsToResourceRequest::getTag1value()const
{
return tag1value_;
}
void AddTagsToResourceRequest::setTag1value(const std::string& tag1value)
{
tag1value_ = tag1value;
setParameter("Tag1value", tag1value);
}
std::string AddTagsToResourceRequest::getRegionId()const
{
return regionId_;
}
void AddTagsToResourceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string AddTagsToResourceRequest::getTag2value()const
{
return tag2value_;
}
void AddTagsToResourceRequest::setTag2value(const std::string& tag2value)
{
tag2value_ = tag2value;
setParameter("Tag2value", tag2value);
}
std::string AddTagsToResourceRequest::getTag4key()const
{
return tag4key_;
}
void AddTagsToResourceRequest::setTag4key(const std::string& tag4key)
{
tag4key_ = tag4key;
setParameter("Tag4key", tag4key);
}
std::string AddTagsToResourceRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void AddTagsToResourceRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string AddTagsToResourceRequest::getTag3value()const
{
return tag3value_;
}
void AddTagsToResourceRequest::setTag3value(const std::string& tag3value)
{
tag3value_ = tag3value;
setParameter("Tag3value", tag3value);
}
std::string AddTagsToResourceRequest::getProxyId()const
{
return proxyId_;
}
void AddTagsToResourceRequest::setProxyId(const std::string& proxyId)
{
proxyId_ = proxyId;
setParameter("ProxyId", proxyId);
}

181
rds/src/model/AllocateInstancePrivateConnectionRequest.cc
View File

@@ -16,101 +16,100 @@
#include <alibabacloud/rds/model/AllocateInstancePrivateConnectionRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::AllocateInstancePrivateConnectionRequest;
AllocateInstancePrivateConnectionRequest::AllocateInstancePrivateConnectionRequest() :
RdsRequest("AllocateInstancePrivateConnection")
RpcServiceRequest("rds", "2014-08-15", "AllocateInstancePrivateConnection")
{}
AllocateInstancePrivateConnectionRequest::~AllocateInstancePrivateConnectionRequest()
{}
long AllocateInstancePrivateConnectionRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void AllocateInstancePrivateConnectionRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string AllocateInstancePrivateConnectionRequest::getConnectionStringPrefix()const
{
return connectionStringPrefix_;
}
void AllocateInstancePrivateConnectionRequest::setConnectionStringPrefix(const std::string& connectionStringPrefix)
{
connectionStringPrefix_ = connectionStringPrefix;
setParameter("ConnectionStringPrefix", connectionStringPrefix);
}
std::string AllocateInstancePrivateConnectionRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void AllocateInstancePrivateConnectionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string AllocateInstancePrivateConnectionRequest::getPort()const
{
return port_;
}
void AllocateInstancePrivateConnectionRequest::setPort(const std::string& port)
{
port_ = port;
setParameter("Port", port);
}
std::string AllocateInstancePrivateConnectionRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void AllocateInstancePrivateConnectionRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string AllocateInstancePrivateConnectionRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void AllocateInstancePrivateConnectionRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long AllocateInstancePrivateConnectionRequest::getOwnerId()const
{
return ownerId_;
}
void AllocateInstancePrivateConnectionRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string AllocateInstancePrivateConnectionRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void AllocateInstancePrivateConnectionRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long AllocateInstancePrivateConnectionRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void AllocateInstancePrivateConnectionRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string AllocateInstancePrivateConnectionRequest::getConnectionStringPrefix()const
{
return connectionStringPrefix_;
}
void AllocateInstancePrivateConnectionRequest::setConnectionStringPrefix(const std::string& connectionStringPrefix)
{
connectionStringPrefix_ = connectionStringPrefix;
setParameter("ConnectionStringPrefix", connectionStringPrefix);
}
std::string AllocateInstancePrivateConnectionRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void AllocateInstancePrivateConnectionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string AllocateInstancePrivateConnectionRequest::getPort()const
{
return port_;
}
void AllocateInstancePrivateConnectionRequest::setPort(const std::string& port)
{
port_ = port;
setParameter("Port", port);
}
std::string AllocateInstancePrivateConnectionRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void AllocateInstancePrivateConnectionRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string AllocateInstancePrivateConnectionRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void AllocateInstancePrivateConnectionRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long AllocateInstancePrivateConnectionRequest::getOwnerId()const
{
return ownerId_;
}
void AllocateInstancePrivateConnectionRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string AllocateInstancePrivateConnectionRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void AllocateInstancePrivateConnectionRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

181
rds/src/model/AllocateInstancePublicConnectionRequest.cc
View File

@@ -16,101 +16,100 @@
#include <alibabacloud/rds/model/AllocateInstancePublicConnectionRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::AllocateInstancePublicConnectionRequest;
AllocateInstancePublicConnectionRequest::AllocateInstancePublicConnectionRequest() :
RdsRequest("AllocateInstancePublicConnection")
RpcServiceRequest("rds", "2014-08-15", "AllocateInstancePublicConnection")
{}
AllocateInstancePublicConnectionRequest::~AllocateInstancePublicConnectionRequest()
{}
long AllocateInstancePublicConnectionRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void AllocateInstancePublicConnectionRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string AllocateInstancePublicConnectionRequest::getConnectionStringPrefix()const
{
return connectionStringPrefix_;
}
void AllocateInstancePublicConnectionRequest::setConnectionStringPrefix(const std::string& connectionStringPrefix)
{
connectionStringPrefix_ = connectionStringPrefix;
setParameter("ConnectionStringPrefix", connectionStringPrefix);
}
std::string AllocateInstancePublicConnectionRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void AllocateInstancePublicConnectionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string AllocateInstancePublicConnectionRequest::getPort()const
{
return port_;
}
void AllocateInstancePublicConnectionRequest::setPort(const std::string& port)
{
port_ = port;
setParameter("Port", port);
}
std::string AllocateInstancePublicConnectionRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void AllocateInstancePublicConnectionRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string AllocateInstancePublicConnectionRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void AllocateInstancePublicConnectionRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long AllocateInstancePublicConnectionRequest::getOwnerId()const
{
return ownerId_;
}
void AllocateInstancePublicConnectionRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string AllocateInstancePublicConnectionRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void AllocateInstancePublicConnectionRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long AllocateInstancePublicConnectionRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void AllocateInstancePublicConnectionRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string AllocateInstancePublicConnectionRequest::getConnectionStringPrefix()const
{
return connectionStringPrefix_;
}
void AllocateInstancePublicConnectionRequest::setConnectionStringPrefix(const std::string& connectionStringPrefix)
{
connectionStringPrefix_ = connectionStringPrefix;
setParameter("ConnectionStringPrefix", connectionStringPrefix);
}
std::string AllocateInstancePublicConnectionRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void AllocateInstancePublicConnectionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string AllocateInstancePublicConnectionRequest::getPort()const
{
return port_;
}
void AllocateInstancePublicConnectionRequest::setPort(const std::string& port)
{
port_ = port;
setParameter("Port", port);
}
std::string AllocateInstancePublicConnectionRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void AllocateInstancePublicConnectionRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string AllocateInstancePublicConnectionRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void AllocateInstancePublicConnectionRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long AllocateInstancePublicConnectionRequest::getOwnerId()const
{
return ownerId_;
}
void AllocateInstancePublicConnectionRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string AllocateInstancePublicConnectionRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void AllocateInstancePublicConnectionRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

269
rds/src/model/AllocateReadWriteSplittingConnectionRequest.cc
View File

@@ -16,145 +16,144 @@
#include <alibabacloud/rds/model/AllocateReadWriteSplittingConnectionRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::AllocateReadWriteSplittingConnectionRequest;
AllocateReadWriteSplittingConnectionRequest::AllocateReadWriteSplittingConnectionRequest() :
RdsRequest("AllocateReadWriteSplittingConnection")
RpcServiceRequest("rds", "2014-08-15", "AllocateReadWriteSplittingConnection")
{}
AllocateReadWriteSplittingConnectionRequest::~AllocateReadWriteSplittingConnectionRequest()
{}
long AllocateReadWriteSplittingConnectionRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void AllocateReadWriteSplittingConnectionRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string AllocateReadWriteSplittingConnectionRequest::getConnectionStringPrefix()const
{
return connectionStringPrefix_;
}
void AllocateReadWriteSplittingConnectionRequest::setConnectionStringPrefix(const std::string& connectionStringPrefix)
{
connectionStringPrefix_ = connectionStringPrefix;
setParameter("ConnectionStringPrefix", connectionStringPrefix);
}
std::string AllocateReadWriteSplittingConnectionRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void AllocateReadWriteSplittingConnectionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string AllocateReadWriteSplittingConnectionRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void AllocateReadWriteSplittingConnectionRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string AllocateReadWriteSplittingConnectionRequest::getWeight()const
{
return weight_;
}
void AllocateReadWriteSplittingConnectionRequest::setWeight(const std::string& weight)
{
weight_ = weight;
setParameter("Weight", weight);
}
long AllocateReadWriteSplittingConnectionRequest::getOwnerId()const
{
return ownerId_;
}
void AllocateReadWriteSplittingConnectionRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string AllocateReadWriteSplittingConnectionRequest::getIPType()const
{
return iPType_;
}
void AllocateReadWriteSplittingConnectionRequest::setIPType(const std::string& iPType)
{
iPType_ = iPType;
setParameter("IPType", iPType);
}
std::string AllocateReadWriteSplittingConnectionRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void AllocateReadWriteSplittingConnectionRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string AllocateReadWriteSplittingConnectionRequest::getPort()const
{
return port_;
}
void AllocateReadWriteSplittingConnectionRequest::setPort(const std::string& port)
{
port_ = port;
setParameter("Port", port);
}
std::string AllocateReadWriteSplittingConnectionRequest::getDistributionType()const
{
return distributionType_;
}
void AllocateReadWriteSplittingConnectionRequest::setDistributionType(const std::string& distributionType)
{
distributionType_ = distributionType;
setParameter("DistributionType", distributionType);
}
std::string AllocateReadWriteSplittingConnectionRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void AllocateReadWriteSplittingConnectionRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string AllocateReadWriteSplittingConnectionRequest::getMaxDelayTime()const
{
return maxDelayTime_;
}
void AllocateReadWriteSplittingConnectionRequest::setMaxDelayTime(const std::string& maxDelayTime)
{
maxDelayTime_ = maxDelayTime;
setParameter("MaxDelayTime", maxDelayTime);
}
long AllocateReadWriteSplittingConnectionRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void AllocateReadWriteSplittingConnectionRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string AllocateReadWriteSplittingConnectionRequest::getConnectionStringPrefix()const
{
return connectionStringPrefix_;
}
void AllocateReadWriteSplittingConnectionRequest::setConnectionStringPrefix(const std::string& connectionStringPrefix)
{
connectionStringPrefix_ = connectionStringPrefix;
setParameter("ConnectionStringPrefix", connectionStringPrefix);
}
std::string AllocateReadWriteSplittingConnectionRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void AllocateReadWriteSplittingConnectionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string AllocateReadWriteSplittingConnectionRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void AllocateReadWriteSplittingConnectionRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string AllocateReadWriteSplittingConnectionRequest::getWeight()const
{
return weight_;
}
void AllocateReadWriteSplittingConnectionRequest::setWeight(const std::string& weight)
{
weight_ = weight;
setParameter("Weight", weight);
}
long AllocateReadWriteSplittingConnectionRequest::getOwnerId()const
{
return ownerId_;
}
void AllocateReadWriteSplittingConnectionRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string AllocateReadWriteSplittingConnectionRequest::getIPType()const
{
return iPType_;
}
void AllocateReadWriteSplittingConnectionRequest::setIPType(const std::string& iPType)
{
iPType_ = iPType;
setParameter("IPType", iPType);
}
std::string AllocateReadWriteSplittingConnectionRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void AllocateReadWriteSplittingConnectionRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string AllocateReadWriteSplittingConnectionRequest::getPort()const
{
return port_;
}
void AllocateReadWriteSplittingConnectionRequest::setPort(const std::string& port)
{
port_ = port;
setParameter("Port", port);
}
std::string AllocateReadWriteSplittingConnectionRequest::getDistributionType()const
{
return distributionType_;
}
void AllocateReadWriteSplittingConnectionRequest::setDistributionType(const std::string& distributionType)
{
distributionType_ = distributionType;
setParameter("DistributionType", distributionType);
}
std::string AllocateReadWriteSplittingConnectionRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void AllocateReadWriteSplittingConnectionRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string AllocateReadWriteSplittingConnectionRequest::getMaxDelayTime()const
{
return maxDelayTime_;
}
void AllocateReadWriteSplittingConnectionRequest::setMaxDelayTime(const std::string& maxDelayTime)
{
maxDelayTime_ = maxDelayTime;
setParameter("MaxDelayTime", maxDelayTime);
}

137
rds/src/model/CalculateDBInstanceWeightRequest.cc
View File

@@ -16,79 +16,78 @@
#include <alibabacloud/rds/model/CalculateDBInstanceWeightRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CalculateDBInstanceWeightRequest;
CalculateDBInstanceWeightRequest::CalculateDBInstanceWeightRequest() :
RdsRequest("CalculateDBInstanceWeight")
RpcServiceRequest("rds", "2014-08-15", "CalculateDBInstanceWeight")
{}
CalculateDBInstanceWeightRequest::~CalculateDBInstanceWeightRequest()
{}
long CalculateDBInstanceWeightRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CalculateDBInstanceWeightRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CalculateDBInstanceWeightRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CalculateDBInstanceWeightRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CalculateDBInstanceWeightRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CalculateDBInstanceWeightRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CalculateDBInstanceWeightRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CalculateDBInstanceWeightRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CalculateDBInstanceWeightRequest::getOwnerId()const
{
return ownerId_;
}
void CalculateDBInstanceWeightRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CalculateDBInstanceWeightRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CalculateDBInstanceWeightRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long CalculateDBInstanceWeightRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CalculateDBInstanceWeightRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CalculateDBInstanceWeightRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CalculateDBInstanceWeightRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CalculateDBInstanceWeightRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CalculateDBInstanceWeightRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CalculateDBInstanceWeightRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CalculateDBInstanceWeightRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CalculateDBInstanceWeightRequest::getOwnerId()const
{
return ownerId_;
}
void CalculateDBInstanceWeightRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CalculateDBInstanceWeightRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CalculateDBInstanceWeightRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

29
rds/src/model/CalculateDBInstanceWeightResult.cc
View File

@@ -40,16 +40,25 @@ void CalculateDBInstanceWeightResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["DBInstanceWeight"];
for (auto value : allItems)
{
DBInstanceWeight dBInstanceWeightObject;
dBInstanceWeightObject.dBInstanceId = value["DBInstanceId"].asString();
dBInstanceWeightObject.dBInstanceType = value["DBInstanceType"].asString();
dBInstanceWeightObject.availability = value["Availability"].asString();
dBInstanceWeightObject.weight = value["Weight"].asString();
items_.push_back(dBInstanceWeightObject);
}
auto allItems = value["Items"]["DBInstanceWeight"];
for (auto value : allItems)
{
DBInstanceWeight itemsObject;
if(!value["DBInstanceId"].isNull())
itemsObject.dBInstanceId = value["DBInstanceId"].asString();
if(!value["DBInstanceType"].isNull())
itemsObject.dBInstanceType = value["DBInstanceType"].asString();
if(!value["Availability"].isNull())
itemsObject.availability = value["Availability"].asString();
if(!value["Weight"].isNull())
itemsObject.weight = value["Weight"].asString();
items_.push_back(itemsObject);
}
}
std::vector<CalculateDBInstanceWeightResult::DBInstanceWeight> CalculateDBInstanceWeightResult::getItems()const
{
return items_;
}

159
rds/src/model/CancelImportRequest.cc
View File

@@ -16,90 +16,89 @@
#include <alibabacloud/rds/model/CancelImportRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CancelImportRequest;
CancelImportRequest::CancelImportRequest() :
RdsRequest("CancelImport")
RpcServiceRequest("rds", "2014-08-15", "CancelImport")
{}
CancelImportRequest::~CancelImportRequest()
{}
long CancelImportRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CancelImportRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
int CancelImportRequest::getImportId()const
{
return importId_;
}
void CancelImportRequest::setImportId(int importId)
{
importId_ = importId;
setParameter("ImportId", std::to_string(importId));
}
std::string CancelImportRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CancelImportRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CancelImportRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CancelImportRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CancelImportRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CancelImportRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CancelImportRequest::getOwnerId()const
{
return ownerId_;
}
void CancelImportRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CancelImportRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CancelImportRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long CancelImportRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CancelImportRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
int CancelImportRequest::getImportId()const
{
return importId_;
}
void CancelImportRequest::setImportId(int importId)
{
importId_ = importId;
setParameter("ImportId", std::to_string(importId));
}
std::string CancelImportRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CancelImportRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CancelImportRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CancelImportRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CancelImportRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CancelImportRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CancelImportRequest::getOwnerId()const
{
return ownerId_;
}
void CancelImportRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CancelImportRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CancelImportRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

181
rds/src/model/CheckAccountNameAvailableRequest.cc
View File

@@ -16,101 +16,100 @@
#include <alibabacloud/rds/model/CheckAccountNameAvailableRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CheckAccountNameAvailableRequest;
CheckAccountNameAvailableRequest::CheckAccountNameAvailableRequest() :
RdsRequest("CheckAccountNameAvailable")
RpcServiceRequest("rds", "2014-08-15", "CheckAccountNameAvailable")
{}
CheckAccountNameAvailableRequest::~CheckAccountNameAvailableRequest()
{}
long CheckAccountNameAvailableRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CheckAccountNameAvailableRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CheckAccountNameAvailableRequest::getAccountName()const
{
return accountName_;
}
void CheckAccountNameAvailableRequest::setAccountName(const std::string& accountName)
{
accountName_ = accountName;
setParameter("AccountName", accountName);
}
std::string CheckAccountNameAvailableRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CheckAccountNameAvailableRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CheckAccountNameAvailableRequest::getClientToken()const
{
return clientToken_;
}
void CheckAccountNameAvailableRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CheckAccountNameAvailableRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CheckAccountNameAvailableRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CheckAccountNameAvailableRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CheckAccountNameAvailableRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CheckAccountNameAvailableRequest::getOwnerId()const
{
return ownerId_;
}
void CheckAccountNameAvailableRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CheckAccountNameAvailableRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CheckAccountNameAvailableRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long CheckAccountNameAvailableRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CheckAccountNameAvailableRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CheckAccountNameAvailableRequest::getAccountName()const
{
return accountName_;
}
void CheckAccountNameAvailableRequest::setAccountName(const std::string& accountName)
{
accountName_ = accountName;
setParameter("AccountName", accountName);
}
std::string CheckAccountNameAvailableRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CheckAccountNameAvailableRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CheckAccountNameAvailableRequest::getClientToken()const
{
return clientToken_;
}
void CheckAccountNameAvailableRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CheckAccountNameAvailableRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CheckAccountNameAvailableRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CheckAccountNameAvailableRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CheckAccountNameAvailableRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CheckAccountNameAvailableRequest::getOwnerId()const
{
return ownerId_;
}
void CheckAccountNameAvailableRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CheckAccountNameAvailableRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CheckAccountNameAvailableRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

181
rds/src/model/CheckDBNameAvailableRequest.cc
View File

@@ -16,101 +16,100 @@
#include <alibabacloud/rds/model/CheckDBNameAvailableRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CheckDBNameAvailableRequest;
CheckDBNameAvailableRequest::CheckDBNameAvailableRequest() :
RdsRequest("CheckDBNameAvailable")
RpcServiceRequest("rds", "2014-08-15", "CheckDBNameAvailable")
{}
CheckDBNameAvailableRequest::~CheckDBNameAvailableRequest()
{}
long CheckDBNameAvailableRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CheckDBNameAvailableRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CheckDBNameAvailableRequest::getDBName()const
{
return dBName_;
}
void CheckDBNameAvailableRequest::setDBName(const std::string& dBName)
{
dBName_ = dBName;
setParameter("DBName", dBName);
}
std::string CheckDBNameAvailableRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CheckDBNameAvailableRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CheckDBNameAvailableRequest::getClientToken()const
{
return clientToken_;
}
void CheckDBNameAvailableRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CheckDBNameAvailableRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CheckDBNameAvailableRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CheckDBNameAvailableRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CheckDBNameAvailableRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CheckDBNameAvailableRequest::getOwnerId()const
{
return ownerId_;
}
void CheckDBNameAvailableRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CheckDBNameAvailableRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CheckDBNameAvailableRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long CheckDBNameAvailableRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CheckDBNameAvailableRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CheckDBNameAvailableRequest::getDBName()const
{
return dBName_;
}
void CheckDBNameAvailableRequest::setDBName(const std::string& dBName)
{
dBName_ = dBName;
setParameter("DBName", dBName);
}
std::string CheckDBNameAvailableRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CheckDBNameAvailableRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CheckDBNameAvailableRequest::getClientToken()const
{
return clientToken_;
}
void CheckDBNameAvailableRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CheckDBNameAvailableRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CheckDBNameAvailableRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CheckDBNameAvailableRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CheckDBNameAvailableRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CheckDBNameAvailableRequest::getOwnerId()const
{
return ownerId_;
}
void CheckDBNameAvailableRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CheckDBNameAvailableRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CheckDBNameAvailableRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

203
rds/src/model/CheckRecoveryConditionsRequest.cc
View File

@@ -16,112 +16,111 @@
#include <alibabacloud/rds/model/CheckRecoveryConditionsRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CheckRecoveryConditionsRequest;
CheckRecoveryConditionsRequest::CheckRecoveryConditionsRequest() :
RdsRequest("CheckRecoveryConditions")
RpcServiceRequest("rds", "2014-08-15", "CheckRecoveryConditions")
{}
CheckRecoveryConditionsRequest::~CheckRecoveryConditionsRequest()
{}
long CheckRecoveryConditionsRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CheckRecoveryConditionsRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CheckRecoveryConditionsRequest::getRestoreTime()const
{
return restoreTime_;
}
void CheckRecoveryConditionsRequest::setRestoreTime(const std::string& restoreTime)
{
restoreTime_ = restoreTime;
setParameter("RestoreTime", restoreTime);
}
std::string CheckRecoveryConditionsRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CheckRecoveryConditionsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CheckRecoveryConditionsRequest::getBackupFile()const
{
return backupFile_;
}
void CheckRecoveryConditionsRequest::setBackupFile(const std::string& backupFile)
{
backupFile_ = backupFile;
setParameter("BackupFile", backupFile);
}
std::string CheckRecoveryConditionsRequest::getBackupId()const
{
return backupId_;
}
void CheckRecoveryConditionsRequest::setBackupId(const std::string& backupId)
{
backupId_ = backupId;
setParameter("BackupId", backupId);
}
std::string CheckRecoveryConditionsRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CheckRecoveryConditionsRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CheckRecoveryConditionsRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CheckRecoveryConditionsRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CheckRecoveryConditionsRequest::getOwnerId()const
{
return ownerId_;
}
void CheckRecoveryConditionsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CheckRecoveryConditionsRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CheckRecoveryConditionsRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long CheckRecoveryConditionsRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CheckRecoveryConditionsRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CheckRecoveryConditionsRequest::getRestoreTime()const
{
return restoreTime_;
}
void CheckRecoveryConditionsRequest::setRestoreTime(const std::string& restoreTime)
{
restoreTime_ = restoreTime;
setParameter("RestoreTime", restoreTime);
}
std::string CheckRecoveryConditionsRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CheckRecoveryConditionsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CheckRecoveryConditionsRequest::getBackupFile()const
{
return backupFile_;
}
void CheckRecoveryConditionsRequest::setBackupFile(const std::string& backupFile)
{
backupFile_ = backupFile;
setParameter("BackupFile", backupFile);
}
std::string CheckRecoveryConditionsRequest::getBackupId()const
{
return backupId_;
}
void CheckRecoveryConditionsRequest::setBackupId(const std::string& backupId)
{
backupId_ = backupId;
setParameter("BackupId", backupId);
}
std::string CheckRecoveryConditionsRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CheckRecoveryConditionsRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CheckRecoveryConditionsRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CheckRecoveryConditionsRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CheckRecoveryConditionsRequest::getOwnerId()const
{
return ownerId_;
}
void CheckRecoveryConditionsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CheckRecoveryConditionsRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CheckRecoveryConditionsRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

36
rds/src/model/CheckRecoveryConditionsResult.cc
View File

@@ -40,28 +40,20 @@ void CheckRecoveryConditionsResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
dBInstanceId_ = value["DBInstanceId"].asString();
recoveryStatus_ = value["RecoveryStatus"].asString();
if(!value["DBInstanceId"].isNull())
dBInstanceId_ = value["DBInstanceId"].asString();
if(!value["RecoveryStatus"].isNull())
recoveryStatus_ = value["RecoveryStatus"].asString();
}
std::string CheckRecoveryConditionsResult::getDBInstanceId()const
{
return dBInstanceId_;
}
void CheckRecoveryConditionsResult::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
}
std::string CheckRecoveryConditionsResult::getRecoveryStatus()const
{
return recoveryStatus_;
}
void CheckRecoveryConditionsResult::setRecoveryStatus(const std::string& recoveryStatus)
{
recoveryStatus_ = recoveryStatus;
}
std::string CheckRecoveryConditionsResult::getDBInstanceId()const
{
return dBInstanceId_;
}
std::string CheckRecoveryConditionsResult::getRecoveryStatus()const
{
return recoveryStatus_;
}

291
rds/src/model/CheckResourceRequest.cc
View File

@@ -16,156 +16,155 @@
#include <alibabacloud/rds/model/CheckResourceRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CheckResourceRequest;
CheckResourceRequest::CheckResourceRequest() :
RdsRequest("CheckResource")
RpcServiceRequest("rds", "2014-08-15", "CheckResource")
{}
CheckResourceRequest::~CheckResourceRequest()
{}
long CheckResourceRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CheckResourceRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CheckResourceRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CheckResourceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CheckResourceRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CheckResourceRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CheckResourceRequest::getSpecifyCount()const
{
return specifyCount_;
}
void CheckResourceRequest::setSpecifyCount(const std::string& specifyCount)
{
specifyCount_ = specifyCount;
setParameter("SpecifyCount", specifyCount);
}
std::string CheckResourceRequest::getEngineVersion()const
{
return engineVersion_;
}
void CheckResourceRequest::setEngineVersion(const std::string& engineVersion)
{
engineVersion_ = engineVersion;
setParameter("EngineVersion", engineVersion);
}
long CheckResourceRequest::getOwnerId()const
{
return ownerId_;
}
void CheckResourceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CheckResourceRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CheckResourceRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CheckResourceRequest::getDBInstanceClass()const
{
return dBInstanceClass_;
}
void CheckResourceRequest::setDBInstanceClass(const std::string& dBInstanceClass)
{
dBInstanceClass_ = dBInstanceClass;
setParameter("DBInstanceClass", dBInstanceClass);
}
std::string CheckResourceRequest::getEngine()const
{
return engine_;
}
void CheckResourceRequest::setEngine(const std::string& engine)
{
engine_ = engine;
setParameter("Engine", engine);
}
std::string CheckResourceRequest::getRegionId()const
{
return regionId_;
}
void CheckResourceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CheckResourceRequest::getZoneId()const
{
return zoneId_;
}
void CheckResourceRequest::setZoneId(const std::string& zoneId)
{
zoneId_ = zoneId;
setParameter("ZoneId", zoneId);
}
std::string CheckResourceRequest::getDBInstanceUseType()const
{
return dBInstanceUseType_;
}
void CheckResourceRequest::setDBInstanceUseType(const std::string& dBInstanceUseType)
{
dBInstanceUseType_ = dBInstanceUseType;
setParameter("DBInstanceUseType", dBInstanceUseType);
}
std::string CheckResourceRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CheckResourceRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CheckResourceRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CheckResourceRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CheckResourceRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CheckResourceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CheckResourceRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CheckResourceRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CheckResourceRequest::getSpecifyCount()const
{
return specifyCount_;
}
void CheckResourceRequest::setSpecifyCount(const std::string& specifyCount)
{
specifyCount_ = specifyCount;
setParameter("SpecifyCount", specifyCount);
}
std::string CheckResourceRequest::getEngineVersion()const
{
return engineVersion_;
}
void CheckResourceRequest::setEngineVersion(const std::string& engineVersion)
{
engineVersion_ = engineVersion;
setParameter("EngineVersion", engineVersion);
}
long CheckResourceRequest::getOwnerId()const
{
return ownerId_;
}
void CheckResourceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CheckResourceRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CheckResourceRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CheckResourceRequest::getDBInstanceClass()const
{
return dBInstanceClass_;
}
void CheckResourceRequest::setDBInstanceClass(const std::string& dBInstanceClass)
{
dBInstanceClass_ = dBInstanceClass;
setParameter("DBInstanceClass", dBInstanceClass);
}
std::string CheckResourceRequest::getEngine()const
{
return engine_;
}
void CheckResourceRequest::setEngine(const std::string& engine)
{
engine_ = engine;
setParameter("Engine", engine);
}
std::string CheckResourceRequest::getRegionId()const
{
return regionId_;
}
void CheckResourceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CheckResourceRequest::getZoneId()const
{
return zoneId_;
}
void CheckResourceRequest::setZoneId(const std::string& zoneId)
{
zoneId_ = zoneId;
setParameter("ZoneId", zoneId);
}
std::string CheckResourceRequest::getDBInstanceUseType()const
{
return dBInstanceUseType_;
}
void CheckResourceRequest::setDBInstanceUseType(const std::string& dBInstanceUseType)
{
dBInstanceUseType_ = dBInstanceUseType;
setParameter("DBInstanceUseType", dBInstanceUseType);
}
std::string CheckResourceRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CheckResourceRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}

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

@@ -40,26 +40,30 @@ void CheckResourceResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allResources = value["Resources"]["Resource"];
for (auto value : allResources)
{
Resource resourceObject;
resourceObject.dBInstanceAvailable = value["DBInstanceAvailable"].asString();
resourceObject.engine = value["Engine"].asString();
resourceObject.engineVersion = value["EngineVersion"].asString();
resources_.push_back(resourceObject);
}
specifyCount_ = value["SpecifyCount"].asString();
auto allResources = value["Resources"]["Resource"];
for (auto value : allResources)
{
Resource resourcesObject;
if(!value["DBInstanceAvailable"].isNull())
resourcesObject.dBInstanceAvailable = value["DBInstanceAvailable"].asString();
if(!value["Engine"].isNull())
resourcesObject.engine = value["Engine"].asString();
if(!value["EngineVersion"].isNull())
resourcesObject.engineVersion = value["EngineVersion"].asString();
resources_.push_back(resourcesObject);
}
if(!value["SpecifyCount"].isNull())
specifyCount_ = value["SpecifyCount"].asString();
}
std::string CheckResourceResult::getSpecifyCount()const
{
return specifyCount_;
}
void CheckResourceResult::setSpecifyCount(const std::string& specifyCount)
{
specifyCount_ = specifyCount;
}
std::string CheckResourceResult::getSpecifyCount()const
{
return specifyCount_;
}
std::vector<CheckResourceResult::Resource> CheckResourceResult::getResources()const
{
return resources_;
}

445
rds/src/model/CloneDBInstanceRequest.cc
View File

@@ -16,233 +16,232 @@
#include <alibabacloud/rds/model/CloneDBInstanceRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CloneDBInstanceRequest;
CloneDBInstanceRequest::CloneDBInstanceRequest() :
RdsRequest("CloneDBInstance")
RpcServiceRequest("rds", "2014-08-15", "CloneDBInstance")
{}
CloneDBInstanceRequest::~CloneDBInstanceRequest()
{}
long CloneDBInstanceRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CloneDBInstanceRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CloneDBInstanceRequest::getRestoreTime()const
{
return restoreTime_;
}
void CloneDBInstanceRequest::setRestoreTime(const std::string& restoreTime)
{
restoreTime_ = restoreTime;
setParameter("RestoreTime", restoreTime);
}
std::string CloneDBInstanceRequest::getPeriod()const
{
return period_;
}
void CloneDBInstanceRequest::setPeriod(const std::string& period)
{
period_ = period;
setParameter("Period", period);
}
int CloneDBInstanceRequest::getDBInstanceStorage()const
{
return dBInstanceStorage_;
}
void CloneDBInstanceRequest::setDBInstanceStorage(int dBInstanceStorage)
{
dBInstanceStorage_ = dBInstanceStorage;
setParameter("DBInstanceStorage", std::to_string(dBInstanceStorage));
}
std::string CloneDBInstanceRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CloneDBInstanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CloneDBInstanceRequest::getClientToken()const
{
return clientToken_;
}
void CloneDBInstanceRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CloneDBInstanceRequest::getBackupId()const
{
return backupId_;
}
void CloneDBInstanceRequest::setBackupId(const std::string& backupId)
{
backupId_ = backupId;
setParameter("BackupId", backupId);
}
std::string CloneDBInstanceRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CloneDBInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CloneDBInstanceRequest::getOwnerId()const
{
return ownerId_;
}
void CloneDBInstanceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CloneDBInstanceRequest::getUsedTime()const
{
return usedTime_;
}
void CloneDBInstanceRequest::setUsedTime(const std::string& usedTime)
{
usedTime_ = usedTime;
setParameter("UsedTime", usedTime);
}
std::string CloneDBInstanceRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CloneDBInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CloneDBInstanceRequest::getDBInstanceClass()const
{
return dBInstanceClass_;
}
void CloneDBInstanceRequest::setDBInstanceClass(const std::string& dBInstanceClass)
{
dBInstanceClass_ = dBInstanceClass;
setParameter("DBInstanceClass", dBInstanceClass);
}
std::string CloneDBInstanceRequest::getVSwitchId()const
{
return vSwitchId_;
}
void CloneDBInstanceRequest::setVSwitchId(const std::string& vSwitchId)
{
vSwitchId_ = vSwitchId;
setParameter("VSwitchId", vSwitchId);
}
std::string CloneDBInstanceRequest::getPrivateIpAddress()const
{
return privateIpAddress_;
}
void CloneDBInstanceRequest::setPrivateIpAddress(const std::string& privateIpAddress)
{
privateIpAddress_ = privateIpAddress;
setParameter("PrivateIpAddress", privateIpAddress);
}
std::string CloneDBInstanceRequest::getResourceGroupId()const
{
return resourceGroupId_;
}
void CloneDBInstanceRequest::setResourceGroupId(const std::string& resourceGroupId)
{
resourceGroupId_ = resourceGroupId;
setParameter("ResourceGroupId", resourceGroupId);
}
std::string CloneDBInstanceRequest::getVPCId()const
{
return vPCId_;
}
void CloneDBInstanceRequest::setVPCId(const std::string& vPCId)
{
vPCId_ = vPCId;
setParameter("VPCId", vPCId);
}
std::string CloneDBInstanceRequest::getDBInstanceDescription()const
{
return dBInstanceDescription_;
}
void CloneDBInstanceRequest::setDBInstanceDescription(const std::string& dBInstanceDescription)
{
dBInstanceDescription_ = dBInstanceDescription;
setParameter("DBInstanceDescription", dBInstanceDescription);
}
std::string CloneDBInstanceRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CloneDBInstanceRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string CloneDBInstanceRequest::getPayType()const
{
return payType_;
}
void CloneDBInstanceRequest::setPayType(const std::string& payType)
{
payType_ = payType;
setParameter("PayType", payType);
}
std::string CloneDBInstanceRequest::getInstanceNetworkType()const
{
return instanceNetworkType_;
}
void CloneDBInstanceRequest::setInstanceNetworkType(const std::string& instanceNetworkType)
{
instanceNetworkType_ = instanceNetworkType;
setParameter("InstanceNetworkType", instanceNetworkType);
}
long CloneDBInstanceRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CloneDBInstanceRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CloneDBInstanceRequest::getRestoreTime()const
{
return restoreTime_;
}
void CloneDBInstanceRequest::setRestoreTime(const std::string& restoreTime)
{
restoreTime_ = restoreTime;
setParameter("RestoreTime", restoreTime);
}
std::string CloneDBInstanceRequest::getPeriod()const
{
return period_;
}
void CloneDBInstanceRequest::setPeriod(const std::string& period)
{
period_ = period;
setParameter("Period", period);
}
int CloneDBInstanceRequest::getDBInstanceStorage()const
{
return dBInstanceStorage_;
}
void CloneDBInstanceRequest::setDBInstanceStorage(int dBInstanceStorage)
{
dBInstanceStorage_ = dBInstanceStorage;
setParameter("DBInstanceStorage", std::to_string(dBInstanceStorage));
}
std::string CloneDBInstanceRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CloneDBInstanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CloneDBInstanceRequest::getClientToken()const
{
return clientToken_;
}
void CloneDBInstanceRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CloneDBInstanceRequest::getBackupId()const
{
return backupId_;
}
void CloneDBInstanceRequest::setBackupId(const std::string& backupId)
{
backupId_ = backupId;
setParameter("BackupId", backupId);
}
std::string CloneDBInstanceRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CloneDBInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CloneDBInstanceRequest::getOwnerId()const
{
return ownerId_;
}
void CloneDBInstanceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CloneDBInstanceRequest::getUsedTime()const
{
return usedTime_;
}
void CloneDBInstanceRequest::setUsedTime(const std::string& usedTime)
{
usedTime_ = usedTime;
setParameter("UsedTime", usedTime);
}
std::string CloneDBInstanceRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CloneDBInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CloneDBInstanceRequest::getDBInstanceClass()const
{
return dBInstanceClass_;
}
void CloneDBInstanceRequest::setDBInstanceClass(const std::string& dBInstanceClass)
{
dBInstanceClass_ = dBInstanceClass;
setParameter("DBInstanceClass", dBInstanceClass);
}
std::string CloneDBInstanceRequest::getVSwitchId()const
{
return vSwitchId_;
}
void CloneDBInstanceRequest::setVSwitchId(const std::string& vSwitchId)
{
vSwitchId_ = vSwitchId;
setParameter("VSwitchId", vSwitchId);
}
std::string CloneDBInstanceRequest::getPrivateIpAddress()const
{
return privateIpAddress_;
}
void CloneDBInstanceRequest::setPrivateIpAddress(const std::string& privateIpAddress)
{
privateIpAddress_ = privateIpAddress;
setParameter("PrivateIpAddress", privateIpAddress);
}
std::string CloneDBInstanceRequest::getResourceGroupId()const
{
return resourceGroupId_;
}
void CloneDBInstanceRequest::setResourceGroupId(const std::string& resourceGroupId)
{
resourceGroupId_ = resourceGroupId;
setParameter("ResourceGroupId", resourceGroupId);
}
std::string CloneDBInstanceRequest::getVPCId()const
{
return vPCId_;
}
void CloneDBInstanceRequest::setVPCId(const std::string& vPCId)
{
vPCId_ = vPCId;
setParameter("VPCId", vPCId);
}
std::string CloneDBInstanceRequest::getDBInstanceDescription()const
{
return dBInstanceDescription_;
}
void CloneDBInstanceRequest::setDBInstanceDescription(const std::string& dBInstanceDescription)
{
dBInstanceDescription_ = dBInstanceDescription;
setParameter("DBInstanceDescription", dBInstanceDescription);
}
std::string CloneDBInstanceRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CloneDBInstanceRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string CloneDBInstanceRequest::getPayType()const
{
return payType_;
}
void CloneDBInstanceRequest::setPayType(const std::string& payType)
{
payType_ = payType;
setParameter("PayType", payType);
}
std::string CloneDBInstanceRequest::getInstanceNetworkType()const
{
return instanceNetworkType_;
}
void CloneDBInstanceRequest::setInstanceNetworkType(const std::string& instanceNetworkType)
{
instanceNetworkType_ = instanceNetworkType;
setParameter("InstanceNetworkType", instanceNetworkType);
}

72
rds/src/model/CloneDBInstanceResult.cc
View File

@@ -40,50 +40,34 @@ void CloneDBInstanceResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
dBInstanceId_ = value["DBInstanceId"].asString();
orderId_ = value["OrderId"].asString();
connectionString_ = value["ConnectionString"].asString();
port_ = value["Port"].asString();
if(!value["DBInstanceId"].isNull())
dBInstanceId_ = value["DBInstanceId"].asString();
if(!value["OrderId"].isNull())
orderId_ = value["OrderId"].asString();
if(!value["ConnectionString"].isNull())
connectionString_ = value["ConnectionString"].asString();
if(!value["Port"].isNull())
port_ = value["Port"].asString();
}
std::string CloneDBInstanceResult::getDBInstanceId()const
{
return dBInstanceId_;
}
void CloneDBInstanceResult::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
}
std::string CloneDBInstanceResult::getPort()const
{
return port_;
}
void CloneDBInstanceResult::setPort(const std::string& port)
{
port_ = port;
}
std::string CloneDBInstanceResult::getOrderId()const
{
return orderId_;
}
void CloneDBInstanceResult::setOrderId(const std::string& orderId)
{
orderId_ = orderId;
}
std::string CloneDBInstanceResult::getConnectionString()const
{
return connectionString_;
}
void CloneDBInstanceResult::setConnectionString(const std::string& connectionString)
{
connectionString_ = connectionString;
}
std::string CloneDBInstanceResult::getDBInstanceId()const
{
return dBInstanceId_;
}
std::string CloneDBInstanceResult::getPort()const
{
return port_;
}
std::string CloneDBInstanceResult::getOrderId()const
{
return orderId_;
}
std::string CloneDBInstanceResult::getConnectionString()const
{
return connectionString_;
}

93
rds/src/model/CopyDatabaseRequest.cc
View File

@@ -16,57 +16,56 @@
#include <alibabacloud/rds/model/CopyDatabaseRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CopyDatabaseRequest;
CopyDatabaseRequest::CopyDatabaseRequest() :
RdsRequest("CopyDatabase")
RpcServiceRequest("rds", "2014-08-15", "CopyDatabase")
{}
CopyDatabaseRequest::~CopyDatabaseRequest()
{}
long CopyDatabaseRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CopyDatabaseRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CopyDatabaseRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CopyDatabaseRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long CopyDatabaseRequest::getOwnerId()const
{
return ownerId_;
}
void CopyDatabaseRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CopyDatabaseRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CopyDatabaseRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long CopyDatabaseRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CopyDatabaseRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CopyDatabaseRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CopyDatabaseRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long CopyDatabaseRequest::getOwnerId()const
{
return ownerId_;
}
void CopyDatabaseRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CopyDatabaseRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CopyDatabaseRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

54
rds/src/model/CopyDatabaseResult.cc
View File

@@ -40,39 +40,27 @@ void CopyDatabaseResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
dBName_ = value["DBName"].asString();
dBStatus_ = value["DBStatus"].asString();
taskId_ = value["TaskId"].asString();
if(!value["DBName"].isNull())
dBName_ = value["DBName"].asString();
if(!value["DBStatus"].isNull())
dBStatus_ = value["DBStatus"].asString();
if(!value["TaskId"].isNull())
taskId_ = value["TaskId"].asString();
}
std::string CopyDatabaseResult::getTaskId()const
{
return taskId_;
}
void CopyDatabaseResult::setTaskId(const std::string& taskId)
{
taskId_ = taskId;
}
std::string CopyDatabaseResult::getDBName()const
{
return dBName_;
}
void CopyDatabaseResult::setDBName(const std::string& dBName)
{
dBName_ = dBName;
}
std::string CopyDatabaseResult::getDBStatus()const
{
return dBStatus_;
}
void CopyDatabaseResult::setDBStatus(const std::string& dBStatus)
{
dBStatus_ = dBStatus;
}
std::string CopyDatabaseResult::getTaskId()const
{
return taskId_;
}
std::string CopyDatabaseResult::getDBName()const
{
return dBName_;
}
std::string CopyDatabaseResult::getDBStatus()const
{
return dBStatus_;
}

225
rds/src/model/CreateAccountRequest.cc
View File

@@ -16,123 +16,122 @@
#include <alibabacloud/rds/model/CreateAccountRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CreateAccountRequest;
CreateAccountRequest::CreateAccountRequest() :
RdsRequest("CreateAccount")
RpcServiceRequest("rds", "2014-08-15", "CreateAccount")
{}
CreateAccountRequest::~CreateAccountRequest()
{}
long CreateAccountRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateAccountRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateAccountRequest::getAccountPassword()const
{
return accountPassword_;
}
void CreateAccountRequest::setAccountPassword(const std::string& accountPassword)
{
accountPassword_ = accountPassword;
setParameter("AccountPassword", accountPassword);
}
std::string CreateAccountRequest::getAccountName()const
{
return accountName_;
}
void CreateAccountRequest::setAccountName(const std::string& accountName)
{
accountName_ = accountName;
setParameter("AccountName", accountName);
}
std::string CreateAccountRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateAccountRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateAccountRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateAccountRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CreateAccountRequest::getAccountType()const
{
return accountType_;
}
void CreateAccountRequest::setAccountType(const std::string& accountType)
{
accountType_ = accountType;
setParameter("AccountType", accountType);
}
std::string CreateAccountRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateAccountRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CreateAccountRequest::getOwnerId()const
{
return ownerId_;
}
void CreateAccountRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateAccountRequest::getAccountDescription()const
{
return accountDescription_;
}
void CreateAccountRequest::setAccountDescription(const std::string& accountDescription)
{
accountDescription_ = accountDescription;
setParameter("AccountDescription", accountDescription);
}
std::string CreateAccountRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateAccountRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long CreateAccountRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateAccountRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateAccountRequest::getAccountPassword()const
{
return accountPassword_;
}
void CreateAccountRequest::setAccountPassword(const std::string& accountPassword)
{
accountPassword_ = accountPassword;
setParameter("AccountPassword", accountPassword);
}
std::string CreateAccountRequest::getAccountName()const
{
return accountName_;
}
void CreateAccountRequest::setAccountName(const std::string& accountName)
{
accountName_ = accountName;
setParameter("AccountName", accountName);
}
std::string CreateAccountRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateAccountRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateAccountRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateAccountRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CreateAccountRequest::getAccountType()const
{
return accountType_;
}
void CreateAccountRequest::setAccountType(const std::string& accountType)
{
accountType_ = accountType;
setParameter("AccountType", accountType);
}
std::string CreateAccountRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateAccountRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CreateAccountRequest::getOwnerId()const
{
return ownerId_;
}
void CreateAccountRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateAccountRequest::getAccountDescription()const
{
return accountDescription_;
}
void CreateAccountRequest::setAccountDescription(const std::string& accountDescription)
{
accountDescription_ = accountDescription;
setParameter("AccountDescription", accountDescription);
}
std::string CreateAccountRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateAccountRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

203
rds/src/model/CreateBackupRequest.cc
View File

@@ -16,112 +16,111 @@
#include <alibabacloud/rds/model/CreateBackupRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CreateBackupRequest;
CreateBackupRequest::CreateBackupRequest() :
RdsRequest("CreateBackup")
RpcServiceRequest("rds", "2014-08-15", "CreateBackup")
{}
CreateBackupRequest::~CreateBackupRequest()
{}
std::string CreateBackupRequest::getBackupMethod()const
{
return backupMethod_;
}
void CreateBackupRequest::setBackupMethod(const std::string& backupMethod)
{
backupMethod_ = backupMethod;
setParameter("BackupMethod", backupMethod);
}
long CreateBackupRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateBackupRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateBackupRequest::getDBName()const
{
return dBName_;
}
void CreateBackupRequest::setDBName(const std::string& dBName)
{
dBName_ = dBName;
setParameter("DBName", dBName);
}
std::string CreateBackupRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateBackupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateBackupRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateBackupRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CreateBackupRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateBackupRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CreateBackupRequest::getOwnerId()const
{
return ownerId_;
}
void CreateBackupRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateBackupRequest::getBackupType()const
{
return backupType_;
}
void CreateBackupRequest::setBackupType(const std::string& backupType)
{
backupType_ = backupType;
setParameter("BackupType", backupType);
}
std::string CreateBackupRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateBackupRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateBackupRequest::getBackupMethod()const
{
return backupMethod_;
}
void CreateBackupRequest::setBackupMethod(const std::string& backupMethod)
{
backupMethod_ = backupMethod;
setParameter("BackupMethod", backupMethod);
}
long CreateBackupRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateBackupRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateBackupRequest::getDBName()const
{
return dBName_;
}
void CreateBackupRequest::setDBName(const std::string& dBName)
{
dBName_ = dBName;
setParameter("DBName", dBName);
}
std::string CreateBackupRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateBackupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateBackupRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateBackupRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CreateBackupRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateBackupRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CreateBackupRequest::getOwnerId()const
{
return ownerId_;
}
void CreateBackupRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateBackupRequest::getBackupType()const
{
return backupType_;
}
void CreateBackupRequest::setBackupType(const std::string& backupType)
{
backupType_ = backupType;
setParameter("BackupType", backupType);
}
std::string CreateBackupRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateBackupRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

621
rds/src/model/CreateDBInstanceReplicaRequest.cc
View File

@@ -16,321 +16,320 @@
#include <alibabacloud/rds/model/CreateDBInstanceReplicaRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CreateDBInstanceReplicaRequest;
CreateDBInstanceReplicaRequest::CreateDBInstanceReplicaRequest() :
RdsRequest("CreateDBInstanceReplica")
RpcServiceRequest("rds", "2014-08-15", "CreateDBInstanceReplica")
{}
CreateDBInstanceReplicaRequest::~CreateDBInstanceReplicaRequest()
{}
std::string CreateDBInstanceReplicaRequest::getConnectionMode()const
{
return connectionMode_;
}
void CreateDBInstanceReplicaRequest::setConnectionMode(const std::string& connectionMode)
{
connectionMode_ = connectionMode;
setParameter("ConnectionMode", connectionMode);
}
std::string CreateDBInstanceReplicaRequest::getDomainMode()const
{
return domainMode_;
}
void CreateDBInstanceReplicaRequest::setDomainMode(const std::string& domainMode)
{
domainMode_ = domainMode;
setParameter("DomainMode", domainMode);
}
std::string CreateDBInstanceReplicaRequest::getReplicaDescription()const
{
return replicaDescription_;
}
void CreateDBInstanceReplicaRequest::setReplicaDescription(const std::string& replicaDescription)
{
replicaDescription_ = replicaDescription;
setParameter("ReplicaDescription", replicaDescription);
}
long CreateDBInstanceReplicaRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateDBInstanceReplicaRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
int CreateDBInstanceReplicaRequest::getDBInstanceStorage()const
{
return dBInstanceStorage_;
}
void CreateDBInstanceReplicaRequest::setDBInstanceStorage(int dBInstanceStorage)
{
dBInstanceStorage_ = dBInstanceStorage;
setParameter("DBInstanceStorage", std::to_string(dBInstanceStorage));
}
std::string CreateDBInstanceReplicaRequest::getSystemDBCharset()const
{
return systemDBCharset_;
}
void CreateDBInstanceReplicaRequest::setSystemDBCharset(const std::string& systemDBCharset)
{
systemDBCharset_ = systemDBCharset;
setParameter("SystemDBCharset", systemDBCharset);
}
std::string CreateDBInstanceReplicaRequest::getClientToken()const
{
return clientToken_;
}
void CreateDBInstanceReplicaRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CreateDBInstanceReplicaRequest::getEngineVersion()const
{
return engineVersion_;
}
void CreateDBInstanceReplicaRequest::setEngineVersion(const std::string& engineVersion)
{
engineVersion_ = engineVersion;
setParameter("EngineVersion", engineVersion);
}
std::string CreateDBInstanceReplicaRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateDBInstanceReplicaRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateDBInstanceReplicaRequest::getRegionId()const
{
return regionId_;
}
void CreateDBInstanceReplicaRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateDBInstanceReplicaRequest::getEngine()const
{
return engine_;
}
void CreateDBInstanceReplicaRequest::setEngine(const std::string& engine)
{
engine_ = engine;
setParameter("Engine", engine);
}
std::string CreateDBInstanceReplicaRequest::getDBInstanceDescription()const
{
return dBInstanceDescription_;
}
void CreateDBInstanceReplicaRequest::setDBInstanceDescription(const std::string& dBInstanceDescription)
{
dBInstanceDescription_ = dBInstanceDescription;
setParameter("DBInstanceDescription", dBInstanceDescription);
}
std::string CreateDBInstanceReplicaRequest::getDBInstanceNetType()const
{
return dBInstanceNetType_;
}
void CreateDBInstanceReplicaRequest::setDBInstanceNetType(const std::string& dBInstanceNetType)
{
dBInstanceNetType_ = dBInstanceNetType;
setParameter("DBInstanceNetType", dBInstanceNetType);
}
std::string CreateDBInstanceReplicaRequest::getPeriod()const
{
return period_;
}
void CreateDBInstanceReplicaRequest::setPeriod(const std::string& period)
{
period_ = period;
setParameter("Period", period);
}
std::string CreateDBInstanceReplicaRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateDBInstanceReplicaRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateDBInstanceReplicaRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateDBInstanceReplicaRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CreateDBInstanceReplicaRequest::getOwnerId()const
{
return ownerId_;
}
void CreateDBInstanceReplicaRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateDBInstanceReplicaRequest::getUsedTime()const
{
return usedTime_;
}
void CreateDBInstanceReplicaRequest::setUsedTime(const std::string& usedTime)
{
usedTime_ = usedTime;
setParameter("UsedTime", usedTime);
}
std::string CreateDBInstanceReplicaRequest::getDBInstanceClass()const
{
return dBInstanceClass_;
}
void CreateDBInstanceReplicaRequest::setDBInstanceClass(const std::string& dBInstanceClass)
{
dBInstanceClass_ = dBInstanceClass;
setParameter("DBInstanceClass", dBInstanceClass);
}
std::string CreateDBInstanceReplicaRequest::getSecurityIPList()const
{
return securityIPList_;
}
void CreateDBInstanceReplicaRequest::setSecurityIPList(const std::string& securityIPList)
{
securityIPList_ = securityIPList;
setParameter("SecurityIPList", securityIPList);
}
std::string CreateDBInstanceReplicaRequest::getVSwitchId()const
{
return vSwitchId_;
}
void CreateDBInstanceReplicaRequest::setVSwitchId(const std::string& vSwitchId)
{
vSwitchId_ = vSwitchId;
setParameter("VSwitchId", vSwitchId);
}
std::string CreateDBInstanceReplicaRequest::getPrivateIpAddress()const
{
return privateIpAddress_;
}
void CreateDBInstanceReplicaRequest::setPrivateIpAddress(const std::string& privateIpAddress)
{
privateIpAddress_ = privateIpAddress;
setParameter("PrivateIpAddress", privateIpAddress);
}
std::string CreateDBInstanceReplicaRequest::getSourceDBInstanceId()const
{
return sourceDBInstanceId_;
}
void CreateDBInstanceReplicaRequest::setSourceDBInstanceId(const std::string& sourceDBInstanceId)
{
sourceDBInstanceId_ = sourceDBInstanceId;
setParameter("SourceDBInstanceId", sourceDBInstanceId);
}
std::string CreateDBInstanceReplicaRequest::getReplicaMode()const
{
return replicaMode_;
}
void CreateDBInstanceReplicaRequest::setReplicaMode(const std::string& replicaMode)
{
replicaMode_ = replicaMode;
setParameter("ReplicaMode", replicaMode);
}
std::string CreateDBInstanceReplicaRequest::getVPCId()const
{
return vPCId_;
}
void CreateDBInstanceReplicaRequest::setVPCId(const std::string& vPCId)
{
vPCId_ = vPCId;
setParameter("VPCId", vPCId);
}
std::string CreateDBInstanceReplicaRequest::getZoneId()const
{
return zoneId_;
}
void CreateDBInstanceReplicaRequest::setZoneId(const std::string& zoneId)
{
zoneId_ = zoneId;
setParameter("ZoneId", zoneId);
}
std::string CreateDBInstanceReplicaRequest::getPayType()const
{
return payType_;
}
void CreateDBInstanceReplicaRequest::setPayType(const std::string& payType)
{
payType_ = payType;
setParameter("PayType", payType);
}
std::string CreateDBInstanceReplicaRequest::getInstanceNetworkType()const
{
return instanceNetworkType_;
}
void CreateDBInstanceReplicaRequest::setInstanceNetworkType(const std::string& instanceNetworkType)
{
instanceNetworkType_ = instanceNetworkType;
setParameter("InstanceNetworkType", instanceNetworkType);
}
std::string CreateDBInstanceReplicaRequest::getConnectionMode()const
{
return connectionMode_;
}
void CreateDBInstanceReplicaRequest::setConnectionMode(const std::string& connectionMode)
{
connectionMode_ = connectionMode;
setParameter("ConnectionMode", connectionMode);
}
std::string CreateDBInstanceReplicaRequest::getDomainMode()const
{
return domainMode_;
}
void CreateDBInstanceReplicaRequest::setDomainMode(const std::string& domainMode)
{
domainMode_ = domainMode;
setParameter("DomainMode", domainMode);
}
std::string CreateDBInstanceReplicaRequest::getReplicaDescription()const
{
return replicaDescription_;
}
void CreateDBInstanceReplicaRequest::setReplicaDescription(const std::string& replicaDescription)
{
replicaDescription_ = replicaDescription;
setParameter("ReplicaDescription", replicaDescription);
}
long CreateDBInstanceReplicaRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateDBInstanceReplicaRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
int CreateDBInstanceReplicaRequest::getDBInstanceStorage()const
{
return dBInstanceStorage_;
}
void CreateDBInstanceReplicaRequest::setDBInstanceStorage(int dBInstanceStorage)
{
dBInstanceStorage_ = dBInstanceStorage;
setParameter("DBInstanceStorage", std::to_string(dBInstanceStorage));
}
std::string CreateDBInstanceReplicaRequest::getSystemDBCharset()const
{
return systemDBCharset_;
}
void CreateDBInstanceReplicaRequest::setSystemDBCharset(const std::string& systemDBCharset)
{
systemDBCharset_ = systemDBCharset;
setParameter("SystemDBCharset", systemDBCharset);
}
std::string CreateDBInstanceReplicaRequest::getClientToken()const
{
return clientToken_;
}
void CreateDBInstanceReplicaRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CreateDBInstanceReplicaRequest::getEngineVersion()const
{
return engineVersion_;
}
void CreateDBInstanceReplicaRequest::setEngineVersion(const std::string& engineVersion)
{
engineVersion_ = engineVersion;
setParameter("EngineVersion", engineVersion);
}
std::string CreateDBInstanceReplicaRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateDBInstanceReplicaRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateDBInstanceReplicaRequest::getRegionId()const
{
return regionId_;
}
void CreateDBInstanceReplicaRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateDBInstanceReplicaRequest::getEngine()const
{
return engine_;
}
void CreateDBInstanceReplicaRequest::setEngine(const std::string& engine)
{
engine_ = engine;
setParameter("Engine", engine);
}
std::string CreateDBInstanceReplicaRequest::getDBInstanceDescription()const
{
return dBInstanceDescription_;
}
void CreateDBInstanceReplicaRequest::setDBInstanceDescription(const std::string& dBInstanceDescription)
{
dBInstanceDescription_ = dBInstanceDescription;
setParameter("DBInstanceDescription", dBInstanceDescription);
}
std::string CreateDBInstanceReplicaRequest::getDBInstanceNetType()const
{
return dBInstanceNetType_;
}
void CreateDBInstanceReplicaRequest::setDBInstanceNetType(const std::string& dBInstanceNetType)
{
dBInstanceNetType_ = dBInstanceNetType;
setParameter("DBInstanceNetType", dBInstanceNetType);
}
std::string CreateDBInstanceReplicaRequest::getPeriod()const
{
return period_;
}
void CreateDBInstanceReplicaRequest::setPeriod(const std::string& period)
{
period_ = period;
setParameter("Period", period);
}
std::string CreateDBInstanceReplicaRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateDBInstanceReplicaRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateDBInstanceReplicaRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateDBInstanceReplicaRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CreateDBInstanceReplicaRequest::getOwnerId()const
{
return ownerId_;
}
void CreateDBInstanceReplicaRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateDBInstanceReplicaRequest::getUsedTime()const
{
return usedTime_;
}
void CreateDBInstanceReplicaRequest::setUsedTime(const std::string& usedTime)
{
usedTime_ = usedTime;
setParameter("UsedTime", usedTime);
}
std::string CreateDBInstanceReplicaRequest::getDBInstanceClass()const
{
return dBInstanceClass_;
}
void CreateDBInstanceReplicaRequest::setDBInstanceClass(const std::string& dBInstanceClass)
{
dBInstanceClass_ = dBInstanceClass;
setParameter("DBInstanceClass", dBInstanceClass);
}
std::string CreateDBInstanceReplicaRequest::getSecurityIPList()const
{
return securityIPList_;
}
void CreateDBInstanceReplicaRequest::setSecurityIPList(const std::string& securityIPList)
{
securityIPList_ = securityIPList;
setParameter("SecurityIPList", securityIPList);
}
std::string CreateDBInstanceReplicaRequest::getVSwitchId()const
{
return vSwitchId_;
}
void CreateDBInstanceReplicaRequest::setVSwitchId(const std::string& vSwitchId)
{
vSwitchId_ = vSwitchId;
setParameter("VSwitchId", vSwitchId);
}
std::string CreateDBInstanceReplicaRequest::getPrivateIpAddress()const
{
return privateIpAddress_;
}
void CreateDBInstanceReplicaRequest::setPrivateIpAddress(const std::string& privateIpAddress)
{
privateIpAddress_ = privateIpAddress;
setParameter("PrivateIpAddress", privateIpAddress);
}
std::string CreateDBInstanceReplicaRequest::getSourceDBInstanceId()const
{
return sourceDBInstanceId_;
}
void CreateDBInstanceReplicaRequest::setSourceDBInstanceId(const std::string& sourceDBInstanceId)
{
sourceDBInstanceId_ = sourceDBInstanceId;
setParameter("SourceDBInstanceId", sourceDBInstanceId);
}
std::string CreateDBInstanceReplicaRequest::getReplicaMode()const
{
return replicaMode_;
}
void CreateDBInstanceReplicaRequest::setReplicaMode(const std::string& replicaMode)
{
replicaMode_ = replicaMode;
setParameter("ReplicaMode", replicaMode);
}
std::string CreateDBInstanceReplicaRequest::getVPCId()const
{
return vPCId_;
}
void CreateDBInstanceReplicaRequest::setVPCId(const std::string& vPCId)
{
vPCId_ = vPCId;
setParameter("VPCId", vPCId);
}
std::string CreateDBInstanceReplicaRequest::getZoneId()const
{
return zoneId_;
}
void CreateDBInstanceReplicaRequest::setZoneId(const std::string& zoneId)
{
zoneId_ = zoneId;
setParameter("ZoneId", zoneId);
}
std::string CreateDBInstanceReplicaRequest::getPayType()const
{
return payType_;
}
void CreateDBInstanceReplicaRequest::setPayType(const std::string& payType)
{
payType_ = payType;
setParameter("PayType", payType);
}
std::string CreateDBInstanceReplicaRequest::getInstanceNetworkType()const
{
return instanceNetworkType_;
}
void CreateDBInstanceReplicaRequest::setInstanceNetworkType(const std::string& instanceNetworkType)
{
instanceNetworkType_ = instanceNetworkType;
setParameter("InstanceNetworkType", instanceNetworkType);
}

72
rds/src/model/CreateDBInstanceReplicaResult.cc
View File

@@ -40,50 +40,34 @@ void CreateDBInstanceReplicaResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
dBInstanceId_ = value["DBInstanceId"].asString();
orderId_ = std::stol(value["OrderId"].asString());
replicaId_ = value["ReplicaId"].asString();
workflowId_ = value["WorkflowId"].asString();
if(!value["DBInstanceId"].isNull())
dBInstanceId_ = value["DBInstanceId"].asString();
if(!value["OrderId"].isNull())
orderId_ = std::stol(value["OrderId"].asString());
if(!value["ReplicaId"].isNull())
replicaId_ = value["ReplicaId"].asString();
if(!value["WorkflowId"].isNull())
workflowId_ = value["WorkflowId"].asString();
}
std::string CreateDBInstanceReplicaResult::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateDBInstanceReplicaResult::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
}
long CreateDBInstanceReplicaResult::getOrderId()const
{
return orderId_;
}
void CreateDBInstanceReplicaResult::setOrderId(long orderId)
{
orderId_ = orderId;
}
std::string CreateDBInstanceReplicaResult::getWorkflowId()const
{
return workflowId_;
}
void CreateDBInstanceReplicaResult::setWorkflowId(const std::string& workflowId)
{
workflowId_ = workflowId;
}
std::string CreateDBInstanceReplicaResult::getReplicaId()const
{
return replicaId_;
}
void CreateDBInstanceReplicaResult::setReplicaId(const std::string& replicaId)
{
replicaId_ = replicaId;
}
std::string CreateDBInstanceReplicaResult::getDBInstanceId()const
{
return dBInstanceId_;
}
long CreateDBInstanceReplicaResult::getOrderId()const
{
return orderId_;
}
std::string CreateDBInstanceReplicaResult::getWorkflowId()const
{
return workflowId_;
}
std::string CreateDBInstanceReplicaResult::getReplicaId()const
{
return replicaId_;
}

577
rds/src/model/CreateDBInstanceRequest.cc
View File

@@ -16,299 +16,298 @@
#include <alibabacloud/rds/model/CreateDBInstanceRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CreateDBInstanceRequest;
CreateDBInstanceRequest::CreateDBInstanceRequest() :
RdsRequest("CreateDBInstance")
RpcServiceRequest("rds", "2014-08-15", "CreateDBInstance")
{}
CreateDBInstanceRequest::~CreateDBInstanceRequest()
{}
std::string CreateDBInstanceRequest::getConnectionMode()const
{
return connectionMode_;
}
void CreateDBInstanceRequest::setConnectionMode(const std::string& connectionMode)
{
connectionMode_ = connectionMode;
setParameter("ConnectionMode", connectionMode);
}
long CreateDBInstanceRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateDBInstanceRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
int CreateDBInstanceRequest::getDBInstanceStorage()const
{
return dBInstanceStorage_;
}
void CreateDBInstanceRequest::setDBInstanceStorage(int dBInstanceStorage)
{
dBInstanceStorage_ = dBInstanceStorage;
setParameter("DBInstanceStorage", std::to_string(dBInstanceStorage));
}
std::string CreateDBInstanceRequest::getSystemDBCharset()const
{
return systemDBCharset_;
}
void CreateDBInstanceRequest::setSystemDBCharset(const std::string& systemDBCharset)
{
systemDBCharset_ = systemDBCharset;
setParameter("SystemDBCharset", systemDBCharset);
}
std::string CreateDBInstanceRequest::getClientToken()const
{
return clientToken_;
}
void CreateDBInstanceRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CreateDBInstanceRequest::getEngineVersion()const
{
return engineVersion_;
}
void CreateDBInstanceRequest::setEngineVersion(const std::string& engineVersion)
{
engineVersion_ = engineVersion;
setParameter("EngineVersion", engineVersion);
}
std::string CreateDBInstanceRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateDBInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateDBInstanceRequest::getResourceGroupId()const
{
return resourceGroupId_;
}
void CreateDBInstanceRequest::setResourceGroupId(const std::string& resourceGroupId)
{
resourceGroupId_ = resourceGroupId;
setParameter("ResourceGroupId", resourceGroupId);
}
std::string CreateDBInstanceRequest::getRegionId()const
{
return regionId_;
}
void CreateDBInstanceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateDBInstanceRequest::getEngine()const
{
return engine_;
}
void CreateDBInstanceRequest::setEngine(const std::string& engine)
{
engine_ = engine;
setParameter("Engine", engine);
}
std::string CreateDBInstanceRequest::getDBInstanceDescription()const
{
return dBInstanceDescription_;
}
void CreateDBInstanceRequest::setDBInstanceDescription(const std::string& dBInstanceDescription)
{
dBInstanceDescription_ = dBInstanceDescription;
setParameter("DBInstanceDescription", dBInstanceDescription);
}
std::string CreateDBInstanceRequest::getDBInstanceNetType()const
{
return dBInstanceNetType_;
}
void CreateDBInstanceRequest::setDBInstanceNetType(const std::string& dBInstanceNetType)
{
dBInstanceNetType_ = dBInstanceNetType;
setParameter("DBInstanceNetType", dBInstanceNetType);
}
std::string CreateDBInstanceRequest::getPeriod()const
{
return period_;
}
void CreateDBInstanceRequest::setPeriod(const std::string& period)
{
period_ = period;
setParameter("Period", period);
}
std::string CreateDBInstanceRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateDBInstanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateDBInstanceRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateDBInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CreateDBInstanceRequest::getOwnerId()const
{
return ownerId_;
}
void CreateDBInstanceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateDBInstanceRequest::getUsedTime()const
{
return usedTime_;
}
void CreateDBInstanceRequest::setUsedTime(const std::string& usedTime)
{
usedTime_ = usedTime;
setParameter("UsedTime", usedTime);
}
std::string CreateDBInstanceRequest::getDBInstanceClass()const
{
return dBInstanceClass_;
}
void CreateDBInstanceRequest::setDBInstanceClass(const std::string& dBInstanceClass)
{
dBInstanceClass_ = dBInstanceClass;
setParameter("DBInstanceClass", dBInstanceClass);
}
std::string CreateDBInstanceRequest::getSecurityIPList()const
{
return securityIPList_;
}
void CreateDBInstanceRequest::setSecurityIPList(const std::string& securityIPList)
{
securityIPList_ = securityIPList;
setParameter("SecurityIPList", securityIPList);
}
std::string CreateDBInstanceRequest::getVSwitchId()const
{
return vSwitchId_;
}
void CreateDBInstanceRequest::setVSwitchId(const std::string& vSwitchId)
{
vSwitchId_ = vSwitchId;
setParameter("VSwitchId", vSwitchId);
}
std::string CreateDBInstanceRequest::getPrivateIpAddress()const
{
return privateIpAddress_;
}
void CreateDBInstanceRequest::setPrivateIpAddress(const std::string& privateIpAddress)
{
privateIpAddress_ = privateIpAddress;
setParameter("PrivateIpAddress", privateIpAddress);
}
std::string CreateDBInstanceRequest::getVPCId()const
{
return vPCId_;
}
void CreateDBInstanceRequest::setVPCId(const std::string& vPCId)
{
vPCId_ = vPCId;
setParameter("VPCId", vPCId);
}
std::string CreateDBInstanceRequest::getTunnelId()const
{
return tunnelId_;
}
void CreateDBInstanceRequest::setTunnelId(const std::string& tunnelId)
{
tunnelId_ = tunnelId;
setParameter("TunnelId", tunnelId);
}
std::string CreateDBInstanceRequest::getZoneId()const
{
return zoneId_;
}
void CreateDBInstanceRequest::setZoneId(const std::string& zoneId)
{
zoneId_ = zoneId;
setParameter("ZoneId", zoneId);
}
std::string CreateDBInstanceRequest::getPayType()const
{
return payType_;
}
void CreateDBInstanceRequest::setPayType(const std::string& payType)
{
payType_ = payType;
setParameter("PayType", payType);
}
std::string CreateDBInstanceRequest::getInstanceNetworkType()const
{
return instanceNetworkType_;
}
void CreateDBInstanceRequest::setInstanceNetworkType(const std::string& instanceNetworkType)
{
instanceNetworkType_ = instanceNetworkType;
setParameter("InstanceNetworkType", instanceNetworkType);
}
std::string CreateDBInstanceRequest::getConnectionMode()const
{
return connectionMode_;
}
void CreateDBInstanceRequest::setConnectionMode(const std::string& connectionMode)
{
connectionMode_ = connectionMode;
setParameter("ConnectionMode", connectionMode);
}
long CreateDBInstanceRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateDBInstanceRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
int CreateDBInstanceRequest::getDBInstanceStorage()const
{
return dBInstanceStorage_;
}
void CreateDBInstanceRequest::setDBInstanceStorage(int dBInstanceStorage)
{
dBInstanceStorage_ = dBInstanceStorage;
setParameter("DBInstanceStorage", std::to_string(dBInstanceStorage));
}
std::string CreateDBInstanceRequest::getSystemDBCharset()const
{
return systemDBCharset_;
}
void CreateDBInstanceRequest::setSystemDBCharset(const std::string& systemDBCharset)
{
systemDBCharset_ = systemDBCharset;
setParameter("SystemDBCharset", systemDBCharset);
}
std::string CreateDBInstanceRequest::getClientToken()const
{
return clientToken_;
}
void CreateDBInstanceRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CreateDBInstanceRequest::getEngineVersion()const
{
return engineVersion_;
}
void CreateDBInstanceRequest::setEngineVersion(const std::string& engineVersion)
{
engineVersion_ = engineVersion;
setParameter("EngineVersion", engineVersion);
}
std::string CreateDBInstanceRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateDBInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateDBInstanceRequest::getResourceGroupId()const
{
return resourceGroupId_;
}
void CreateDBInstanceRequest::setResourceGroupId(const std::string& resourceGroupId)
{
resourceGroupId_ = resourceGroupId;
setParameter("ResourceGroupId", resourceGroupId);
}
std::string CreateDBInstanceRequest::getRegionId()const
{
return regionId_;
}
void CreateDBInstanceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateDBInstanceRequest::getEngine()const
{
return engine_;
}
void CreateDBInstanceRequest::setEngine(const std::string& engine)
{
engine_ = engine;
setParameter("Engine", engine);
}
std::string CreateDBInstanceRequest::getDBInstanceDescription()const
{
return dBInstanceDescription_;
}
void CreateDBInstanceRequest::setDBInstanceDescription(const std::string& dBInstanceDescription)
{
dBInstanceDescription_ = dBInstanceDescription;
setParameter("DBInstanceDescription", dBInstanceDescription);
}
std::string CreateDBInstanceRequest::getDBInstanceNetType()const
{
return dBInstanceNetType_;
}
void CreateDBInstanceRequest::setDBInstanceNetType(const std::string& dBInstanceNetType)
{
dBInstanceNetType_ = dBInstanceNetType;
setParameter("DBInstanceNetType", dBInstanceNetType);
}
std::string CreateDBInstanceRequest::getPeriod()const
{
return period_;
}
void CreateDBInstanceRequest::setPeriod(const std::string& period)
{
period_ = period;
setParameter("Period", period);
}
std::string CreateDBInstanceRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateDBInstanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateDBInstanceRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateDBInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CreateDBInstanceRequest::getOwnerId()const
{
return ownerId_;
}
void CreateDBInstanceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateDBInstanceRequest::getUsedTime()const
{
return usedTime_;
}
void CreateDBInstanceRequest::setUsedTime(const std::string& usedTime)
{
usedTime_ = usedTime;
setParameter("UsedTime", usedTime);
}
std::string CreateDBInstanceRequest::getDBInstanceClass()const
{
return dBInstanceClass_;
}
void CreateDBInstanceRequest::setDBInstanceClass(const std::string& dBInstanceClass)
{
dBInstanceClass_ = dBInstanceClass;
setParameter("DBInstanceClass", dBInstanceClass);
}
std::string CreateDBInstanceRequest::getSecurityIPList()const
{
return securityIPList_;
}
void CreateDBInstanceRequest::setSecurityIPList(const std::string& securityIPList)
{
securityIPList_ = securityIPList;
setParameter("SecurityIPList", securityIPList);
}
std::string CreateDBInstanceRequest::getVSwitchId()const
{
return vSwitchId_;
}
void CreateDBInstanceRequest::setVSwitchId(const std::string& vSwitchId)
{
vSwitchId_ = vSwitchId;
setParameter("VSwitchId", vSwitchId);
}
std::string CreateDBInstanceRequest::getPrivateIpAddress()const
{
return privateIpAddress_;
}
void CreateDBInstanceRequest::setPrivateIpAddress(const std::string& privateIpAddress)
{
privateIpAddress_ = privateIpAddress;
setParameter("PrivateIpAddress", privateIpAddress);
}
std::string CreateDBInstanceRequest::getVPCId()const
{
return vPCId_;
}
void CreateDBInstanceRequest::setVPCId(const std::string& vPCId)
{
vPCId_ = vPCId;
setParameter("VPCId", vPCId);
}
std::string CreateDBInstanceRequest::getTunnelId()const
{
return tunnelId_;
}
void CreateDBInstanceRequest::setTunnelId(const std::string& tunnelId)
{
tunnelId_ = tunnelId;
setParameter("TunnelId", tunnelId);
}
std::string CreateDBInstanceRequest::getZoneId()const
{
return zoneId_;
}
void CreateDBInstanceRequest::setZoneId(const std::string& zoneId)
{
zoneId_ = zoneId;
setParameter("ZoneId", zoneId);
}
std::string CreateDBInstanceRequest::getPayType()const
{
return payType_;
}
void CreateDBInstanceRequest::setPayType(const std::string& payType)
{
payType_ = payType;
setParameter("PayType", payType);
}
std::string CreateDBInstanceRequest::getInstanceNetworkType()const
{
return instanceNetworkType_;
}
void CreateDBInstanceRequest::setInstanceNetworkType(const std::string& instanceNetworkType)
{
instanceNetworkType_ = instanceNetworkType;
setParameter("InstanceNetworkType", instanceNetworkType);
}

72
rds/src/model/CreateDBInstanceResult.cc
View File

@@ -40,50 +40,34 @@ void CreateDBInstanceResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
dBInstanceId_ = value["DBInstanceId"].asString();
orderId_ = value["OrderId"].asString();
connectionString_ = value["ConnectionString"].asString();
port_ = value["Port"].asString();
if(!value["DBInstanceId"].isNull())
dBInstanceId_ = value["DBInstanceId"].asString();
if(!value["OrderId"].isNull())
orderId_ = value["OrderId"].asString();
if(!value["ConnectionString"].isNull())
connectionString_ = value["ConnectionString"].asString();
if(!value["Port"].isNull())
port_ = value["Port"].asString();
}
std::string CreateDBInstanceResult::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateDBInstanceResult::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
}
std::string CreateDBInstanceResult::getPort()const
{
return port_;
}
void CreateDBInstanceResult::setPort(const std::string& port)
{
port_ = port;
}
std::string CreateDBInstanceResult::getOrderId()const
{
return orderId_;
}
void CreateDBInstanceResult::setOrderId(const std::string& orderId)
{
orderId_ = orderId;
}
std::string CreateDBInstanceResult::getConnectionString()const
{
return connectionString_;
}
void CreateDBInstanceResult::setConnectionString(const std::string& connectionString)
{
connectionString_ = connectionString;
}
std::string CreateDBInstanceResult::getDBInstanceId()const
{
return dBInstanceId_;
}
std::string CreateDBInstanceResult::getPort()const
{
return port_;
}
std::string CreateDBInstanceResult::getOrderId()const
{
return orderId_;
}
std::string CreateDBInstanceResult::getConnectionString()const
{
return connectionString_;
}

313
rds/src/model/CreateDampPolicyRequest.cc
View File

@@ -16,167 +16,166 @@
#include <alibabacloud/rds/model/CreateDampPolicyRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CreateDampPolicyRequest;
CreateDampPolicyRequest::CreateDampPolicyRequest() :
RdsRequest("CreateDampPolicy")
RpcServiceRequest("rds", "2014-08-15", "CreateDampPolicy")
{}
CreateDampPolicyRequest::~CreateDampPolicyRequest()
{}
long CreateDampPolicyRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateDampPolicyRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateDampPolicyRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateDampPolicyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateDampPolicyRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateDampPolicyRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CreateDampPolicyRequest::getOwnerId()const
{
return ownerId_;
}
void CreateDampPolicyRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
int CreateDampPolicyRequest::getPriority()const
{
return priority_;
}
void CreateDampPolicyRequest::setPriority(int priority)
{
priority_ = priority;
setParameter("Priority", std::to_string(priority));
}
std::string CreateDampPolicyRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateDampPolicyRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateDampPolicyRequest::getTimeRules()const
{
return timeRules_;
}
void CreateDampPolicyRequest::setTimeRules(const std::string& timeRules)
{
timeRules_ = timeRules;
setParameter("TimeRules", timeRules);
}
std::string CreateDampPolicyRequest::getActionRules()const
{
return actionRules_;
}
void CreateDampPolicyRequest::setActionRules(const std::string& actionRules)
{
actionRules_ = actionRules;
setParameter("ActionRules", actionRules);
}
std::string CreateDampPolicyRequest::getSecurityToken()const
{
return securityToken_;
}
void CreateDampPolicyRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setParameter("SecurityToken", securityToken);
}
std::string CreateDampPolicyRequest::getRegionId()const
{
return regionId_;
}
void CreateDampPolicyRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateDampPolicyRequest::getHandlers()const
{
return handlers_;
}
void CreateDampPolicyRequest::setHandlers(const std::string& handlers)
{
handlers_ = handlers;
setParameter("Handlers", handlers);
}
std::string CreateDampPolicyRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateDampPolicyRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string CreateDampPolicyRequest::getPolicyName()const
{
return policyName_;
}
void CreateDampPolicyRequest::setPolicyName(const std::string& policyName)
{
policyName_ = policyName;
setParameter("PolicyName", policyName);
}
std::string CreateDampPolicyRequest::getSourceRules()const
{
return sourceRules_;
}
void CreateDampPolicyRequest::setSourceRules(const std::string& sourceRules)
{
sourceRules_ = sourceRules;
setParameter("SourceRules", sourceRules);
}
long CreateDampPolicyRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateDampPolicyRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateDampPolicyRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateDampPolicyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateDampPolicyRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateDampPolicyRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CreateDampPolicyRequest::getOwnerId()const
{
return ownerId_;
}
void CreateDampPolicyRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
int CreateDampPolicyRequest::getPriority()const
{
return priority_;
}
void CreateDampPolicyRequest::setPriority(int priority)
{
priority_ = priority;
setParameter("Priority", std::to_string(priority));
}
std::string CreateDampPolicyRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateDampPolicyRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateDampPolicyRequest::getTimeRules()const
{
return timeRules_;
}
void CreateDampPolicyRequest::setTimeRules(const std::string& timeRules)
{
timeRules_ = timeRules;
setParameter("TimeRules", timeRules);
}
std::string CreateDampPolicyRequest::getActionRules()const
{
return actionRules_;
}
void CreateDampPolicyRequest::setActionRules(const std::string& actionRules)
{
actionRules_ = actionRules;
setParameter("ActionRules", actionRules);
}
std::string CreateDampPolicyRequest::getSecurityToken()const
{
return securityToken_;
}
void CreateDampPolicyRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setParameter("SecurityToken", securityToken);
}
std::string CreateDampPolicyRequest::getRegionId()const
{
return regionId_;
}
void CreateDampPolicyRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateDampPolicyRequest::getHandlers()const
{
return handlers_;
}
void CreateDampPolicyRequest::setHandlers(const std::string& handlers)
{
handlers_ = handlers;
setParameter("Handlers", handlers);
}
std::string CreateDampPolicyRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateDampPolicyRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string CreateDampPolicyRequest::getPolicyName()const
{
return policyName_;
}
void CreateDampPolicyRequest::setPolicyName(const std::string& policyName)
{
policyName_ = policyName;
setParameter("PolicyName", policyName);
}
std::string CreateDampPolicyRequest::getSourceRules()const
{
return sourceRules_;
}
void CreateDampPolicyRequest::setSourceRules(const std::string& sourceRules)
{
sourceRules_ = sourceRules;
setParameter("SourceRules", sourceRules);
}

36
rds/src/model/CreateDampPolicyResult.cc
View File

@@ -40,28 +40,20 @@ void CreateDampPolicyResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
policyId_ = value["PolicyId"].asString();
policyName_ = value["PolicyName"].asString();
if(!value["PolicyId"].isNull())
policyId_ = value["PolicyId"].asString();
if(!value["PolicyName"].isNull())
policyName_ = value["PolicyName"].asString();
}
std::string CreateDampPolicyResult::getPolicyName()const
{
return policyName_;
}
void CreateDampPolicyResult::setPolicyName(const std::string& policyName)
{
policyName_ = policyName;
}
std::string CreateDampPolicyResult::getPolicyId()const
{
return policyId_;
}
void CreateDampPolicyResult::setPolicyId(const std::string& policyId)
{
policyId_ = policyId;
}
std::string CreateDampPolicyResult::getPolicyName()const
{
return policyName_;
}
std::string CreateDampPolicyResult::getPolicyId()const
{
return policyId_;
}

203
rds/src/model/CreateDatabaseRequest.cc
View File

@@ -16,112 +16,111 @@
#include <alibabacloud/rds/model/CreateDatabaseRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CreateDatabaseRequest;
CreateDatabaseRequest::CreateDatabaseRequest() :
RdsRequest("CreateDatabase")
RpcServiceRequest("rds", "2014-08-15", "CreateDatabase")
{}
CreateDatabaseRequest::~CreateDatabaseRequest()
{}
long CreateDatabaseRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateDatabaseRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateDatabaseRequest::getDBName()const
{
return dBName_;
}
void CreateDatabaseRequest::setDBName(const std::string& dBName)
{
dBName_ = dBName;
setParameter("DBName", dBName);
}
std::string CreateDatabaseRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateDatabaseRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateDatabaseRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateDatabaseRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CreateDatabaseRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateDatabaseRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string CreateDatabaseRequest::getDBDescription()const
{
return dBDescription_;
}
void CreateDatabaseRequest::setDBDescription(const std::string& dBDescription)
{
dBDescription_ = dBDescription;
setParameter("DBDescription", dBDescription);
}
long CreateDatabaseRequest::getOwnerId()const
{
return ownerId_;
}
void CreateDatabaseRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateDatabaseRequest::getCharacterSetName()const
{
return characterSetName_;
}
void CreateDatabaseRequest::setCharacterSetName(const std::string& characterSetName)
{
characterSetName_ = characterSetName;
setParameter("CharacterSetName", characterSetName);
}
std::string CreateDatabaseRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateDatabaseRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long CreateDatabaseRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateDatabaseRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateDatabaseRequest::getDBName()const
{
return dBName_;
}
void CreateDatabaseRequest::setDBName(const std::string& dBName)
{
dBName_ = dBName;
setParameter("DBName", dBName);
}
std::string CreateDatabaseRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateDatabaseRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateDatabaseRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateDatabaseRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CreateDatabaseRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateDatabaseRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string CreateDatabaseRequest::getDBDescription()const
{
return dBDescription_;
}
void CreateDatabaseRequest::setDBDescription(const std::string& dBDescription)
{
dBDescription_ = dBDescription;
setParameter("DBDescription", dBDescription);
}
long CreateDatabaseRequest::getOwnerId()const
{
return ownerId_;
}
void CreateDatabaseRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateDatabaseRequest::getCharacterSetName()const
{
return characterSetName_;
}
void CreateDatabaseRequest::setCharacterSetName(const std::string& characterSetName)
{
characterSetName_ = characterSetName;
setParameter("CharacterSetName", characterSetName);
}
std::string CreateDatabaseRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateDatabaseRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

93
rds/src/model/CreateDiagnosticReportRequest.cc
View File

@@ -16,57 +16,56 @@
#include <alibabacloud/rds/model/CreateDiagnosticReportRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CreateDiagnosticReportRequest;
CreateDiagnosticReportRequest::CreateDiagnosticReportRequest() :
RdsRequest("CreateDiagnosticReport")
RpcServiceRequest("rds", "2014-08-15", "CreateDiagnosticReport")
{}
CreateDiagnosticReportRequest::~CreateDiagnosticReportRequest()
{}
std::string CreateDiagnosticReportRequest::getEndTime()const
{
return endTime_;
}
void CreateDiagnosticReportRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
std::string CreateDiagnosticReportRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateDiagnosticReportRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string CreateDiagnosticReportRequest::getStartTime()const
{
return startTime_;
}
void CreateDiagnosticReportRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
std::string CreateDiagnosticReportRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateDiagnosticReportRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateDiagnosticReportRequest::getEndTime()const
{
return endTime_;
}
void CreateDiagnosticReportRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
std::string CreateDiagnosticReportRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateDiagnosticReportRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string CreateDiagnosticReportRequest::getStartTime()const
{
return startTime_;
}
void CreateDiagnosticReportRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
std::string CreateDiagnosticReportRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateDiagnosticReportRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

18
rds/src/model/CreateDiagnosticReportResult.cc
View File

@@ -40,17 +40,13 @@ void CreateDiagnosticReportResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
reportId_ = value["ReportId"].asString();
if(!value["ReportId"].isNull())
reportId_ = value["ReportId"].asString();
}
std::string CreateDiagnosticReportResult::getReportId()const
{
return reportId_;
}
void CreateDiagnosticReportResult::setReportId(const std::string& reportId)
{
reportId_ = reportId;
}
std::string CreateDiagnosticReportResult::getReportId()const
{
return reportId_;
}

203
rds/src/model/CreateMigrateTaskForSQLServerRequest.cc
View File

@@ -16,112 +16,111 @@
#include <alibabacloud/rds/model/CreateMigrateTaskForSQLServerRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CreateMigrateTaskForSQLServerRequest;
CreateMigrateTaskForSQLServerRequest::CreateMigrateTaskForSQLServerRequest() :
RdsRequest("CreateMigrateTaskForSQLServer")
RpcServiceRequest("rds", "2014-08-15", "CreateMigrateTaskForSQLServer")
{}
CreateMigrateTaskForSQLServerRequest::~CreateMigrateTaskForSQLServerRequest()
{}
long CreateMigrateTaskForSQLServerRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateMigrateTaskForSQLServerRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateMigrateTaskForSQLServerRequest::getTaskType()const
{
return taskType_;
}
void CreateMigrateTaskForSQLServerRequest::setTaskType(const std::string& taskType)
{
taskType_ = taskType;
setParameter("TaskType", taskType);
}
std::string CreateMigrateTaskForSQLServerRequest::getDBName()const
{
return dBName_;
}
void CreateMigrateTaskForSQLServerRequest::setDBName(const std::string& dBName)
{
dBName_ = dBName;
setParameter("DBName", dBName);
}
std::string CreateMigrateTaskForSQLServerRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateMigrateTaskForSQLServerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateMigrateTaskForSQLServerRequest::getIsOnlineDB()const
{
return isOnlineDB_;
}
void CreateMigrateTaskForSQLServerRequest::setIsOnlineDB(const std::string& isOnlineDB)
{
isOnlineDB_ = isOnlineDB;
setParameter("IsOnlineDB", isOnlineDB);
}
std::string CreateMigrateTaskForSQLServerRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateMigrateTaskForSQLServerRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CreateMigrateTaskForSQLServerRequest::getOwnerId()const
{
return ownerId_;
}
void CreateMigrateTaskForSQLServerRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateMigrateTaskForSQLServerRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateMigrateTaskForSQLServerRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateMigrateTaskForSQLServerRequest::getOSSUrls()const
{
return oSSUrls_;
}
void CreateMigrateTaskForSQLServerRequest::setOSSUrls(const std::string& oSSUrls)
{
oSSUrls_ = oSSUrls;
setParameter("OSSUrls", oSSUrls);
}
long CreateMigrateTaskForSQLServerRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateMigrateTaskForSQLServerRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateMigrateTaskForSQLServerRequest::getTaskType()const
{
return taskType_;
}
void CreateMigrateTaskForSQLServerRequest::setTaskType(const std::string& taskType)
{
taskType_ = taskType;
setParameter("TaskType", taskType);
}
std::string CreateMigrateTaskForSQLServerRequest::getDBName()const
{
return dBName_;
}
void CreateMigrateTaskForSQLServerRequest::setDBName(const std::string& dBName)
{
dBName_ = dBName;
setParameter("DBName", dBName);
}
std::string CreateMigrateTaskForSQLServerRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateMigrateTaskForSQLServerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateMigrateTaskForSQLServerRequest::getIsOnlineDB()const
{
return isOnlineDB_;
}
void CreateMigrateTaskForSQLServerRequest::setIsOnlineDB(const std::string& isOnlineDB)
{
isOnlineDB_ = isOnlineDB;
setParameter("IsOnlineDB", isOnlineDB);
}
std::string CreateMigrateTaskForSQLServerRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateMigrateTaskForSQLServerRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CreateMigrateTaskForSQLServerRequest::getOwnerId()const
{
return ownerId_;
}
void CreateMigrateTaskForSQLServerRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateMigrateTaskForSQLServerRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateMigrateTaskForSQLServerRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateMigrateTaskForSQLServerRequest::getOSSUrls()const
{
return oSSUrls_;
}
void CreateMigrateTaskForSQLServerRequest::setOSSUrls(const std::string& oSSUrls)
{
oSSUrls_ = oSSUrls;
setParameter("OSSUrls", oSSUrls);
}

108
rds/src/model/CreateMigrateTaskForSQLServerResult.cc
View File

@@ -40,72 +40,48 @@ void CreateMigrateTaskForSQLServerResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
dBInstanceId_ = value["DBInstanceId"].asString();
dBInstanceName_ = value["DBInstanceName"].asString();
taskId_ = value["TaskId"].asString();
dBName_ = value["DBName"].asString();
migrateIaskId_ = value["MigrateIaskId"].asString();
taskType_ = value["TaskType"].asString();
if(!value["DBInstanceId"].isNull())
dBInstanceId_ = value["DBInstanceId"].asString();
if(!value["DBInstanceName"].isNull())
dBInstanceName_ = value["DBInstanceName"].asString();
if(!value["TaskId"].isNull())
taskId_ = value["TaskId"].asString();
if(!value["DBName"].isNull())
dBName_ = value["DBName"].asString();
if(!value["MigrateIaskId"].isNull())
migrateIaskId_ = value["MigrateIaskId"].asString();
if(!value["TaskType"].isNull())
taskType_ = value["TaskType"].asString();
}
std::string CreateMigrateTaskForSQLServerResult::getTaskId()const
{
return taskId_;
}
void CreateMigrateTaskForSQLServerResult::setTaskId(const std::string& taskId)
{
taskId_ = taskId;
}
std::string CreateMigrateTaskForSQLServerResult::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateMigrateTaskForSQLServerResult::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
}
std::string CreateMigrateTaskForSQLServerResult::getTaskType()const
{
return taskType_;
}
void CreateMigrateTaskForSQLServerResult::setTaskType(const std::string& taskType)
{
taskType_ = taskType;
}
std::string CreateMigrateTaskForSQLServerResult::getDBName()const
{
return dBName_;
}
void CreateMigrateTaskForSQLServerResult::setDBName(const std::string& dBName)
{
dBName_ = dBName;
}
std::string CreateMigrateTaskForSQLServerResult::getMigrateIaskId()const
{
return migrateIaskId_;
}
void CreateMigrateTaskForSQLServerResult::setMigrateIaskId(const std::string& migrateIaskId)
{
migrateIaskId_ = migrateIaskId;
}
std::string CreateMigrateTaskForSQLServerResult::getDBInstanceName()const
{
return dBInstanceName_;
}
void CreateMigrateTaskForSQLServerResult::setDBInstanceName(const std::string& dBInstanceName)
{
dBInstanceName_ = dBInstanceName;
}
std::string CreateMigrateTaskForSQLServerResult::getTaskId()const
{
return taskId_;
}
std::string CreateMigrateTaskForSQLServerResult::getDBInstanceId()const
{
return dBInstanceId_;
}
std::string CreateMigrateTaskForSQLServerResult::getTaskType()const
{
return taskType_;
}
std::string CreateMigrateTaskForSQLServerResult::getDBName()const
{
return dBName_;
}
std::string CreateMigrateTaskForSQLServerResult::getMigrateIaskId()const
{
return migrateIaskId_;
}
std::string CreateMigrateTaskForSQLServerResult::getDBInstanceName()const
{
return dBInstanceName_;
}

203
rds/src/model/CreateMigrateTaskRequest.cc
View File

@@ -16,112 +16,111 @@
#include <alibabacloud/rds/model/CreateMigrateTaskRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CreateMigrateTaskRequest;
CreateMigrateTaskRequest::CreateMigrateTaskRequest() :
RdsRequest("CreateMigrateTask")
RpcServiceRequest("rds", "2014-08-15", "CreateMigrateTask")
{}
CreateMigrateTaskRequest::~CreateMigrateTaskRequest()
{}
long CreateMigrateTaskRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateMigrateTaskRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateMigrateTaskRequest::getDBName()const
{
return dBName_;
}
void CreateMigrateTaskRequest::setDBName(const std::string& dBName)
{
dBName_ = dBName;
setParameter("DBName", dBName);
}
std::string CreateMigrateTaskRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateMigrateTaskRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateMigrateTaskRequest::getIsOnlineDB()const
{
return isOnlineDB_;
}
void CreateMigrateTaskRequest::setIsOnlineDB(const std::string& isOnlineDB)
{
isOnlineDB_ = isOnlineDB;
setParameter("IsOnlineDB", isOnlineDB);
}
std::string CreateMigrateTaskRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateMigrateTaskRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string CreateMigrateTaskRequest::getBackupMode()const
{
return backupMode_;
}
void CreateMigrateTaskRequest::setBackupMode(const std::string& backupMode)
{
backupMode_ = backupMode;
setParameter("BackupMode", backupMode);
}
long CreateMigrateTaskRequest::getOwnerId()const
{
return ownerId_;
}
void CreateMigrateTaskRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateMigrateTaskRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateMigrateTaskRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateMigrateTaskRequest::getOSSUrls()const
{
return oSSUrls_;
}
void CreateMigrateTaskRequest::setOSSUrls(const std::string& oSSUrls)
{
oSSUrls_ = oSSUrls;
setParameter("OSSUrls", oSSUrls);
}
long CreateMigrateTaskRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateMigrateTaskRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateMigrateTaskRequest::getDBName()const
{
return dBName_;
}
void CreateMigrateTaskRequest::setDBName(const std::string& dBName)
{
dBName_ = dBName;
setParameter("DBName", dBName);
}
std::string CreateMigrateTaskRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateMigrateTaskRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateMigrateTaskRequest::getIsOnlineDB()const
{
return isOnlineDB_;
}
void CreateMigrateTaskRequest::setIsOnlineDB(const std::string& isOnlineDB)
{
isOnlineDB_ = isOnlineDB;
setParameter("IsOnlineDB", isOnlineDB);
}
std::string CreateMigrateTaskRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateMigrateTaskRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string CreateMigrateTaskRequest::getBackupMode()const
{
return backupMode_;
}
void CreateMigrateTaskRequest::setBackupMode(const std::string& backupMode)
{
backupMode_ = backupMode;
setParameter("BackupMode", backupMode);
}
long CreateMigrateTaskRequest::getOwnerId()const
{
return ownerId_;
}
void CreateMigrateTaskRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateMigrateTaskRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateMigrateTaskRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateMigrateTaskRequest::getOSSUrls()const
{
return oSSUrls_;
}
void CreateMigrateTaskRequest::setOSSUrls(const std::string& oSSUrls)
{
oSSUrls_ = oSSUrls;
setParameter("OSSUrls", oSSUrls);
}

90
rds/src/model/CreateMigrateTaskResult.cc
View File

@@ -40,61 +40,41 @@ void CreateMigrateTaskResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
dBInstanceId_ = value["DBInstanceId"].asString();
taskId_ = value["TaskId"].asString();
dBName_ = value["DBName"].asString();
migrateIaskId_ = value["MigrateIaskId"].asString();
backupMode_ = value["BackupMode"].asString();
if(!value["DBInstanceId"].isNull())
dBInstanceId_ = value["DBInstanceId"].asString();
if(!value["TaskId"].isNull())
taskId_ = value["TaskId"].asString();
if(!value["DBName"].isNull())
dBName_ = value["DBName"].asString();
if(!value["MigrateIaskId"].isNull())
migrateIaskId_ = value["MigrateIaskId"].asString();
if(!value["BackupMode"].isNull())
backupMode_ = value["BackupMode"].asString();
}
std::string CreateMigrateTaskResult::getTaskId()const
{
return taskId_;
}
void CreateMigrateTaskResult::setTaskId(const std::string& taskId)
{
taskId_ = taskId;
}
std::string CreateMigrateTaskResult::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateMigrateTaskResult::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
}
std::string CreateMigrateTaskResult::getBackupMode()const
{
return backupMode_;
}
void CreateMigrateTaskResult::setBackupMode(const std::string& backupMode)
{
backupMode_ = backupMode;
}
std::string CreateMigrateTaskResult::getDBName()const
{
return dBName_;
}
void CreateMigrateTaskResult::setDBName(const std::string& dBName)
{
dBName_ = dBName;
}
std::string CreateMigrateTaskResult::getMigrateIaskId()const
{
return migrateIaskId_;
}
void CreateMigrateTaskResult::setMigrateIaskId(const std::string& migrateIaskId)
{
migrateIaskId_ = migrateIaskId;
}
std::string CreateMigrateTaskResult::getTaskId()const
{
return taskId_;
}
std::string CreateMigrateTaskResult::getDBInstanceId()const
{
return dBInstanceId_;
}
std::string CreateMigrateTaskResult::getBackupMode()const
{
return backupMode_;
}
std::string CreateMigrateTaskResult::getDBName()const
{
return dBName_;
}
std::string CreateMigrateTaskResult::getMigrateIaskId()const
{
return migrateIaskId_;
}

203
rds/src/model/CreatePolicyWithSpecifiedPolicyRequest.cc
View File

@@ -16,112 +16,111 @@
#include <alibabacloud/rds/model/CreatePolicyWithSpecifiedPolicyRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CreatePolicyWithSpecifiedPolicyRequest;
CreatePolicyWithSpecifiedPolicyRequest::CreatePolicyWithSpecifiedPolicyRequest() :
RdsRequest("CreatePolicyWithSpecifiedPolicy")
RpcServiceRequest("rds", "2014-08-15", "CreatePolicyWithSpecifiedPolicy")
{}
CreatePolicyWithSpecifiedPolicyRequest::~CreatePolicyWithSpecifiedPolicyRequest()
{}
long CreatePolicyWithSpecifiedPolicyRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreatePolicyWithSpecifiedPolicyRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreatePolicyWithSpecifiedPolicyRequest::getPolicyId()const
{
return policyId_;
}
void CreatePolicyWithSpecifiedPolicyRequest::setPolicyId(const std::string& policyId)
{
policyId_ = policyId;
setParameter("PolicyId", policyId);
}
std::string CreatePolicyWithSpecifiedPolicyRequest::getSecurityToken()const
{
return securityToken_;
}
void CreatePolicyWithSpecifiedPolicyRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setParameter("SecurityToken", securityToken);
}
std::string CreatePolicyWithSpecifiedPolicyRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreatePolicyWithSpecifiedPolicyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreatePolicyWithSpecifiedPolicyRequest::getRegionId()const
{
return regionId_;
}
void CreatePolicyWithSpecifiedPolicyRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreatePolicyWithSpecifiedPolicyRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreatePolicyWithSpecifiedPolicyRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CreatePolicyWithSpecifiedPolicyRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreatePolicyWithSpecifiedPolicyRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CreatePolicyWithSpecifiedPolicyRequest::getOwnerId()const
{
return ownerId_;
}
void CreatePolicyWithSpecifiedPolicyRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreatePolicyWithSpecifiedPolicyRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreatePolicyWithSpecifiedPolicyRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long CreatePolicyWithSpecifiedPolicyRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreatePolicyWithSpecifiedPolicyRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreatePolicyWithSpecifiedPolicyRequest::getPolicyId()const
{
return policyId_;
}
void CreatePolicyWithSpecifiedPolicyRequest::setPolicyId(const std::string& policyId)
{
policyId_ = policyId;
setParameter("PolicyId", policyId);
}
std::string CreatePolicyWithSpecifiedPolicyRequest::getSecurityToken()const
{
return securityToken_;
}
void CreatePolicyWithSpecifiedPolicyRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setParameter("SecurityToken", securityToken);
}
std::string CreatePolicyWithSpecifiedPolicyRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreatePolicyWithSpecifiedPolicyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreatePolicyWithSpecifiedPolicyRequest::getRegionId()const
{
return regionId_;
}
void CreatePolicyWithSpecifiedPolicyRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreatePolicyWithSpecifiedPolicyRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreatePolicyWithSpecifiedPolicyRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CreatePolicyWithSpecifiedPolicyRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreatePolicyWithSpecifiedPolicyRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CreatePolicyWithSpecifiedPolicyRequest::getOwnerId()const
{
return ownerId_;
}
void CreatePolicyWithSpecifiedPolicyRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreatePolicyWithSpecifiedPolicyRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreatePolicyWithSpecifiedPolicyRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

423
rds/src/model/CreateReadOnlyDBInstanceRequest.cc
View File

@@ -16,222 +16,221 @@
#include <alibabacloud/rds/model/CreateReadOnlyDBInstanceRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CreateReadOnlyDBInstanceRequest;
CreateReadOnlyDBInstanceRequest::CreateReadOnlyDBInstanceRequest() :
RdsRequest("CreateReadOnlyDBInstance")
RpcServiceRequest("rds", "2014-08-15", "CreateReadOnlyDBInstance")
{}
CreateReadOnlyDBInstanceRequest::~CreateReadOnlyDBInstanceRequest()
{}
long CreateReadOnlyDBInstanceRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateReadOnlyDBInstanceRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
int CreateReadOnlyDBInstanceRequest::getDBInstanceStorage()const
{
return dBInstanceStorage_;
}
void CreateReadOnlyDBInstanceRequest::setDBInstanceStorage(int dBInstanceStorage)
{
dBInstanceStorage_ = dBInstanceStorage;
setParameter("DBInstanceStorage", std::to_string(dBInstanceStorage));
}
std::string CreateReadOnlyDBInstanceRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateReadOnlyDBInstanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateReadOnlyDBInstanceRequest::getClientToken()const
{
return clientToken_;
}
void CreateReadOnlyDBInstanceRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CreateReadOnlyDBInstanceRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateReadOnlyDBInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CreateReadOnlyDBInstanceRequest::getEngineVersion()const
{
return engineVersion_;
}
void CreateReadOnlyDBInstanceRequest::setEngineVersion(const std::string& engineVersion)
{
engineVersion_ = engineVersion;
setParameter("EngineVersion", engineVersion);
}
long CreateReadOnlyDBInstanceRequest::getOwnerId()const
{
return ownerId_;
}
void CreateReadOnlyDBInstanceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateReadOnlyDBInstanceRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateReadOnlyDBInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateReadOnlyDBInstanceRequest::getDBInstanceClass()const
{
return dBInstanceClass_;
}
void CreateReadOnlyDBInstanceRequest::setDBInstanceClass(const std::string& dBInstanceClass)
{
dBInstanceClass_ = dBInstanceClass;
setParameter("DBInstanceClass", dBInstanceClass);
}
std::string CreateReadOnlyDBInstanceRequest::getVSwitchId()const
{
return vSwitchId_;
}
void CreateReadOnlyDBInstanceRequest::setVSwitchId(const std::string& vSwitchId)
{
vSwitchId_ = vSwitchId;
setParameter("VSwitchId", vSwitchId);
}
std::string CreateReadOnlyDBInstanceRequest::getPrivateIpAddress()const
{
return privateIpAddress_;
}
void CreateReadOnlyDBInstanceRequest::setPrivateIpAddress(const std::string& privateIpAddress)
{
privateIpAddress_ = privateIpAddress;
setParameter("PrivateIpAddress", privateIpAddress);
}
std::string CreateReadOnlyDBInstanceRequest::getResourceGroupId()const
{
return resourceGroupId_;
}
void CreateReadOnlyDBInstanceRequest::setResourceGroupId(const std::string& resourceGroupId)
{
resourceGroupId_ = resourceGroupId;
setParameter("ResourceGroupId", resourceGroupId);
}
std::string CreateReadOnlyDBInstanceRequest::getRegionId()const
{
return regionId_;
}
void CreateReadOnlyDBInstanceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateReadOnlyDBInstanceRequest::getVPCId()const
{
return vPCId_;
}
void CreateReadOnlyDBInstanceRequest::setVPCId(const std::string& vPCId)
{
vPCId_ = vPCId;
setParameter("VPCId", vPCId);
}
std::string CreateReadOnlyDBInstanceRequest::getZoneId()const
{
return zoneId_;
}
void CreateReadOnlyDBInstanceRequest::setZoneId(const std::string& zoneId)
{
zoneId_ = zoneId;
setParameter("ZoneId", zoneId);
}
std::string CreateReadOnlyDBInstanceRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateReadOnlyDBInstanceRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string CreateReadOnlyDBInstanceRequest::getDBInstanceDescription()const
{
return dBInstanceDescription_;
}
void CreateReadOnlyDBInstanceRequest::setDBInstanceDescription(const std::string& dBInstanceDescription)
{
dBInstanceDescription_ = dBInstanceDescription;
setParameter("DBInstanceDescription", dBInstanceDescription);
}
std::string CreateReadOnlyDBInstanceRequest::getPayType()const
{
return payType_;
}
void CreateReadOnlyDBInstanceRequest::setPayType(const std::string& payType)
{
payType_ = payType;
setParameter("PayType", payType);
}
std::string CreateReadOnlyDBInstanceRequest::getInstanceNetworkType()const
{
return instanceNetworkType_;
}
void CreateReadOnlyDBInstanceRequest::setInstanceNetworkType(const std::string& instanceNetworkType)
{
instanceNetworkType_ = instanceNetworkType;
setParameter("InstanceNetworkType", instanceNetworkType);
}
long CreateReadOnlyDBInstanceRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateReadOnlyDBInstanceRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
int CreateReadOnlyDBInstanceRequest::getDBInstanceStorage()const
{
return dBInstanceStorage_;
}
void CreateReadOnlyDBInstanceRequest::setDBInstanceStorage(int dBInstanceStorage)
{
dBInstanceStorage_ = dBInstanceStorage;
setParameter("DBInstanceStorage", std::to_string(dBInstanceStorage));
}
std::string CreateReadOnlyDBInstanceRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateReadOnlyDBInstanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateReadOnlyDBInstanceRequest::getClientToken()const
{
return clientToken_;
}
void CreateReadOnlyDBInstanceRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CreateReadOnlyDBInstanceRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateReadOnlyDBInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CreateReadOnlyDBInstanceRequest::getEngineVersion()const
{
return engineVersion_;
}
void CreateReadOnlyDBInstanceRequest::setEngineVersion(const std::string& engineVersion)
{
engineVersion_ = engineVersion;
setParameter("EngineVersion", engineVersion);
}
long CreateReadOnlyDBInstanceRequest::getOwnerId()const
{
return ownerId_;
}
void CreateReadOnlyDBInstanceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateReadOnlyDBInstanceRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateReadOnlyDBInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateReadOnlyDBInstanceRequest::getDBInstanceClass()const
{
return dBInstanceClass_;
}
void CreateReadOnlyDBInstanceRequest::setDBInstanceClass(const std::string& dBInstanceClass)
{
dBInstanceClass_ = dBInstanceClass;
setParameter("DBInstanceClass", dBInstanceClass);
}
std::string CreateReadOnlyDBInstanceRequest::getVSwitchId()const
{
return vSwitchId_;
}
void CreateReadOnlyDBInstanceRequest::setVSwitchId(const std::string& vSwitchId)
{
vSwitchId_ = vSwitchId;
setParameter("VSwitchId", vSwitchId);
}
std::string CreateReadOnlyDBInstanceRequest::getPrivateIpAddress()const
{
return privateIpAddress_;
}
void CreateReadOnlyDBInstanceRequest::setPrivateIpAddress(const std::string& privateIpAddress)
{
privateIpAddress_ = privateIpAddress;
setParameter("PrivateIpAddress", privateIpAddress);
}
std::string CreateReadOnlyDBInstanceRequest::getResourceGroupId()const
{
return resourceGroupId_;
}
void CreateReadOnlyDBInstanceRequest::setResourceGroupId(const std::string& resourceGroupId)
{
resourceGroupId_ = resourceGroupId;
setParameter("ResourceGroupId", resourceGroupId);
}
std::string CreateReadOnlyDBInstanceRequest::getRegionId()const
{
return regionId_;
}
void CreateReadOnlyDBInstanceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateReadOnlyDBInstanceRequest::getVPCId()const
{
return vPCId_;
}
void CreateReadOnlyDBInstanceRequest::setVPCId(const std::string& vPCId)
{
vPCId_ = vPCId;
setParameter("VPCId", vPCId);
}
std::string CreateReadOnlyDBInstanceRequest::getZoneId()const
{
return zoneId_;
}
void CreateReadOnlyDBInstanceRequest::setZoneId(const std::string& zoneId)
{
zoneId_ = zoneId;
setParameter("ZoneId", zoneId);
}
std::string CreateReadOnlyDBInstanceRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateReadOnlyDBInstanceRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string CreateReadOnlyDBInstanceRequest::getDBInstanceDescription()const
{
return dBInstanceDescription_;
}
void CreateReadOnlyDBInstanceRequest::setDBInstanceDescription(const std::string& dBInstanceDescription)
{
dBInstanceDescription_ = dBInstanceDescription;
setParameter("DBInstanceDescription", dBInstanceDescription);
}
std::string CreateReadOnlyDBInstanceRequest::getPayType()const
{
return payType_;
}
void CreateReadOnlyDBInstanceRequest::setPayType(const std::string& payType)
{
payType_ = payType;
setParameter("PayType", payType);
}
std::string CreateReadOnlyDBInstanceRequest::getInstanceNetworkType()const
{
return instanceNetworkType_;
}
void CreateReadOnlyDBInstanceRequest::setInstanceNetworkType(const std::string& instanceNetworkType)
{
instanceNetworkType_ = instanceNetworkType;
setParameter("InstanceNetworkType", instanceNetworkType);
}

72
rds/src/model/CreateReadOnlyDBInstanceResult.cc
View File

@@ -40,50 +40,34 @@ void CreateReadOnlyDBInstanceResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
dBInstanceId_ = value["DBInstanceId"].asString();
orderId_ = value["OrderId"].asString();
connectionString_ = value["ConnectionString"].asString();
port_ = value["Port"].asString();
if(!value["DBInstanceId"].isNull())
dBInstanceId_ = value["DBInstanceId"].asString();
if(!value["OrderId"].isNull())
orderId_ = value["OrderId"].asString();
if(!value["ConnectionString"].isNull())
connectionString_ = value["ConnectionString"].asString();
if(!value["Port"].isNull())
port_ = value["Port"].asString();
}
std::string CreateReadOnlyDBInstanceResult::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateReadOnlyDBInstanceResult::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
}
std::string CreateReadOnlyDBInstanceResult::getPort()const
{
return port_;
}
void CreateReadOnlyDBInstanceResult::setPort(const std::string& port)
{
port_ = port;
}
std::string CreateReadOnlyDBInstanceResult::getOrderId()const
{
return orderId_;
}
void CreateReadOnlyDBInstanceResult::setOrderId(const std::string& orderId)
{
orderId_ = orderId;
}
std::string CreateReadOnlyDBInstanceResult::getConnectionString()const
{
return connectionString_;
}
void CreateReadOnlyDBInstanceResult::setConnectionString(const std::string& connectionString)
{
connectionString_ = connectionString;
}
std::string CreateReadOnlyDBInstanceResult::getDBInstanceId()const
{
return dBInstanceId_;
}
std::string CreateReadOnlyDBInstanceResult::getPort()const
{
return port_;
}
std::string CreateReadOnlyDBInstanceResult::getOrderId()const
{
return orderId_;
}
std::string CreateReadOnlyDBInstanceResult::getConnectionString()const
{
return connectionString_;
}

93
rds/src/model/CreateSQLDiagnosisRequest.cc
View File

@@ -16,57 +16,56 @@
#include <alibabacloud/rds/model/CreateSQLDiagnosisRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CreateSQLDiagnosisRequest;
CreateSQLDiagnosisRequest::CreateSQLDiagnosisRequest() :
RdsRequest("CreateSQLDiagnosis")
RpcServiceRequest("rds", "2014-08-15", "CreateSQLDiagnosis")
{}
CreateSQLDiagnosisRequest::~CreateSQLDiagnosisRequest()
{}
std::string CreateSQLDiagnosisRequest::getEndTime()const
{
return endTime_;
}
void CreateSQLDiagnosisRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
std::string CreateSQLDiagnosisRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateSQLDiagnosisRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string CreateSQLDiagnosisRequest::getStartTime()const
{
return startTime_;
}
void CreateSQLDiagnosisRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
std::string CreateSQLDiagnosisRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateSQLDiagnosisRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateSQLDiagnosisRequest::getEndTime()const
{
return endTime_;
}
void CreateSQLDiagnosisRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
std::string CreateSQLDiagnosisRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateSQLDiagnosisRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string CreateSQLDiagnosisRequest::getStartTime()const
{
return startTime_;
}
void CreateSQLDiagnosisRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
std::string CreateSQLDiagnosisRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateSQLDiagnosisRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

18
rds/src/model/CreateSQLDiagnosisResult.cc
View File

@@ -40,17 +40,13 @@ void CreateSQLDiagnosisResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
sQLDiagId_ = value["SQLDiagId"].asString();
if(!value["SQLDiagId"].isNull())
sQLDiagId_ = value["SQLDiagId"].asString();
}
std::string CreateSQLDiagnosisResult::getSQLDiagId()const
{
return sQLDiagId_;
}
void CreateSQLDiagnosisResult::setSQLDiagId(const std::string& sQLDiagId)
{
sQLDiagId_ = sQLDiagId;
}
std::string CreateSQLDiagnosisResult::getSQLDiagId()const
{
return sQLDiagId_;
}

181
rds/src/model/CreateTempDBInstanceRequest.cc
View File

@@ -16,101 +16,100 @@
#include <alibabacloud/rds/model/CreateTempDBInstanceRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CreateTempDBInstanceRequest;
CreateTempDBInstanceRequest::CreateTempDBInstanceRequest() :
RdsRequest("CreateTempDBInstance")
RpcServiceRequest("rds", "2014-08-15", "CreateTempDBInstance")
{}
CreateTempDBInstanceRequest::~CreateTempDBInstanceRequest()
{}
long CreateTempDBInstanceRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateTempDBInstanceRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateTempDBInstanceRequest::getRestoreTime()const
{
return restoreTime_;
}
void CreateTempDBInstanceRequest::setRestoreTime(const std::string& restoreTime)
{
restoreTime_ = restoreTime;
setParameter("RestoreTime", restoreTime);
}
std::string CreateTempDBInstanceRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateTempDBInstanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
int CreateTempDBInstanceRequest::getBackupId()const
{
return backupId_;
}
void CreateTempDBInstanceRequest::setBackupId(int backupId)
{
backupId_ = backupId;
setParameter("BackupId", std::to_string(backupId));
}
std::string CreateTempDBInstanceRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateTempDBInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CreateTempDBInstanceRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateTempDBInstanceRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CreateTempDBInstanceRequest::getOwnerId()const
{
return ownerId_;
}
void CreateTempDBInstanceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateTempDBInstanceRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateTempDBInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long CreateTempDBInstanceRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateTempDBInstanceRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateTempDBInstanceRequest::getRestoreTime()const
{
return restoreTime_;
}
void CreateTempDBInstanceRequest::setRestoreTime(const std::string& restoreTime)
{
restoreTime_ = restoreTime;
setParameter("RestoreTime", restoreTime);
}
std::string CreateTempDBInstanceRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateTempDBInstanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
int CreateTempDBInstanceRequest::getBackupId()const
{
return backupId_;
}
void CreateTempDBInstanceRequest::setBackupId(int backupId)
{
backupId_ = backupId;
setParameter("BackupId", std::to_string(backupId));
}
std::string CreateTempDBInstanceRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateTempDBInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CreateTempDBInstanceRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateTempDBInstanceRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CreateTempDBInstanceRequest::getOwnerId()const
{
return ownerId_;
}
void CreateTempDBInstanceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateTempDBInstanceRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateTempDBInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

18
rds/src/model/CreateTempDBInstanceResult.cc
View File

@@ -40,17 +40,13 @@ void CreateTempDBInstanceResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
tempDBInstanceId_ = value["TempDBInstanceId"].asString();
if(!value["TempDBInstanceId"].isNull())
tempDBInstanceId_ = value["TempDBInstanceId"].asString();
}
std::string CreateTempDBInstanceResult::getTempDBInstanceId()const
{
return tempDBInstanceId_;
}
void CreateTempDBInstanceResult::setTempDBInstanceId(const std::string& tempDBInstanceId)
{
tempDBInstanceId_ = tempDBInstanceId;
}
std::string CreateTempDBInstanceResult::getTempDBInstanceId()const
{
return tempDBInstanceId_;
}

159
rds/src/model/CreateUploadPathForSQLServerRequest.cc
View File

@@ -16,90 +16,89 @@
#include <alibabacloud/rds/model/CreateUploadPathForSQLServerRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::CreateUploadPathForSQLServerRequest;
CreateUploadPathForSQLServerRequest::CreateUploadPathForSQLServerRequest() :
RdsRequest("CreateUploadPathForSQLServer")
RpcServiceRequest("rds", "2014-08-15", "CreateUploadPathForSQLServer")
{}
CreateUploadPathForSQLServerRequest::~CreateUploadPathForSQLServerRequest()
{}
long CreateUploadPathForSQLServerRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateUploadPathForSQLServerRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateUploadPathForSQLServerRequest::getDBName()const
{
return dBName_;
}
void CreateUploadPathForSQLServerRequest::setDBName(const std::string& dBName)
{
dBName_ = dBName;
setParameter("DBName", dBName);
}
std::string CreateUploadPathForSQLServerRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateUploadPathForSQLServerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateUploadPathForSQLServerRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateUploadPathForSQLServerRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CreateUploadPathForSQLServerRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateUploadPathForSQLServerRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CreateUploadPathForSQLServerRequest::getOwnerId()const
{
return ownerId_;
}
void CreateUploadPathForSQLServerRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateUploadPathForSQLServerRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateUploadPathForSQLServerRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long CreateUploadPathForSQLServerRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateUploadPathForSQLServerRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateUploadPathForSQLServerRequest::getDBName()const
{
return dBName_;
}
void CreateUploadPathForSQLServerRequest::setDBName(const std::string& dBName)
{
dBName_ = dBName;
setParameter("DBName", dBName);
}
std::string CreateUploadPathForSQLServerRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateUploadPathForSQLServerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateUploadPathForSQLServerRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateUploadPathForSQLServerRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CreateUploadPathForSQLServerRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void CreateUploadPathForSQLServerRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long CreateUploadPathForSQLServerRequest::getOwnerId()const
{
return ownerId_;
}
void CreateUploadPathForSQLServerRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateUploadPathForSQLServerRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateUploadPathForSQLServerRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

126
rds/src/model/CreateUploadPathForSQLServerResult.cc
View File

@@ -40,83 +40,55 @@ void CreateUploadPathForSQLServerResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
internetFtpServer_ = value["InternetFtpServer"].asString();
internetPort_ = std::stoi(value["InternetPort"].asString());
intranetFtpserver_ = value["IntranetFtpserver"].asString();
intranetport_ = std::stoi(value["Intranetport"].asString());
userName_ = value["UserName"].asString();
password_ = value["Password"].asString();
fileName_ = value["FileName"].asString();
if(!value["InternetFtpServer"].isNull())
internetFtpServer_ = value["InternetFtpServer"].asString();
if(!value["InternetPort"].isNull())
internetPort_ = std::stoi(value["InternetPort"].asString());
if(!value["IntranetFtpserver"].isNull())
intranetFtpserver_ = value["IntranetFtpserver"].asString();
if(!value["Intranetport"].isNull())
intranetport_ = std::stoi(value["Intranetport"].asString());
if(!value["UserName"].isNull())
userName_ = value["UserName"].asString();
if(!value["Password"].isNull())
password_ = value["Password"].asString();
if(!value["FileName"].isNull())
fileName_ = value["FileName"].asString();
}
std::string CreateUploadPathForSQLServerResult::getIntranetFtpserver()const
{
return intranetFtpserver_;
}
void CreateUploadPathForSQLServerResult::setIntranetFtpserver(const std::string& intranetFtpserver)
{
intranetFtpserver_ = intranetFtpserver;
}
std::string CreateUploadPathForSQLServerResult::getUserName()const
{
return userName_;
}
void CreateUploadPathForSQLServerResult::setUserName(const std::string& userName)
{
userName_ = userName;
}
std::string CreateUploadPathForSQLServerResult::getFileName()const
{
return fileName_;
}
void CreateUploadPathForSQLServerResult::setFileName(const std::string& fileName)
{
fileName_ = fileName;
}
int CreateUploadPathForSQLServerResult::getInternetPort()const
{
return internetPort_;
}
void CreateUploadPathForSQLServerResult::setInternetPort(int internetPort)
{
internetPort_ = internetPort;
}
std::string CreateUploadPathForSQLServerResult::getInternetFtpServer()const
{
return internetFtpServer_;
}
void CreateUploadPathForSQLServerResult::setInternetFtpServer(const std::string& internetFtpServer)
{
internetFtpServer_ = internetFtpServer;
}
int CreateUploadPathForSQLServerResult::getIntranetport()const
{
return intranetport_;
}
void CreateUploadPathForSQLServerResult::setIntranetport(int intranetport)
{
intranetport_ = intranetport;
}
std::string CreateUploadPathForSQLServerResult::getPassword()const
{
return password_;
}
void CreateUploadPathForSQLServerResult::setPassword(const std::string& password)
{
password_ = password;
}
std::string CreateUploadPathForSQLServerResult::getIntranetFtpserver()const
{
return intranetFtpserver_;
}
std::string CreateUploadPathForSQLServerResult::getUserName()const
{
return userName_;
}
std::string CreateUploadPathForSQLServerResult::getFileName()const
{
return fileName_;
}
int CreateUploadPathForSQLServerResult::getInternetPort()const
{
return internetPort_;
}
std::string CreateUploadPathForSQLServerResult::getInternetFtpServer()const
{
return internetFtpServer_;
}
int CreateUploadPathForSQLServerResult::getIntranetport()const
{
return intranetport_;
}
std::string CreateUploadPathForSQLServerResult::getPassword()const
{
return password_;
}

203
rds/src/model/DegradeDBInstanceSpecRequest.cc
View File

@@ -16,112 +16,111 @@
#include <alibabacloud/rds/model/DegradeDBInstanceSpecRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DegradeDBInstanceSpecRequest;
DegradeDBInstanceSpecRequest::DegradeDBInstanceSpecRequest() :
RdsRequest("DegradeDBInstanceSpec")
RpcServiceRequest("rds", "2014-08-15", "DegradeDBInstanceSpec")
{}
DegradeDBInstanceSpecRequest::~DegradeDBInstanceSpecRequest()
{}
long DegradeDBInstanceSpecRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DegradeDBInstanceSpecRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
int DegradeDBInstanceSpecRequest::getDBInstanceStorage()const
{
return dBInstanceStorage_;
}
void DegradeDBInstanceSpecRequest::setDBInstanceStorage(int dBInstanceStorage)
{
dBInstanceStorage_ = dBInstanceStorage;
setParameter("DBInstanceStorage", std::to_string(dBInstanceStorage));
}
std::string DegradeDBInstanceSpecRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DegradeDBInstanceSpecRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DegradeDBInstanceSpecRequest::getClientToken()const
{
return clientToken_;
}
void DegradeDBInstanceSpecRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string DegradeDBInstanceSpecRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DegradeDBInstanceSpecRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DegradeDBInstanceSpecRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DegradeDBInstanceSpecRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DegradeDBInstanceSpecRequest::getOwnerId()const
{
return ownerId_;
}
void DegradeDBInstanceSpecRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DegradeDBInstanceSpecRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DegradeDBInstanceSpecRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DegradeDBInstanceSpecRequest::getDBInstanceClass()const
{
return dBInstanceClass_;
}
void DegradeDBInstanceSpecRequest::setDBInstanceClass(const std::string& dBInstanceClass)
{
dBInstanceClass_ = dBInstanceClass;
setParameter("DBInstanceClass", dBInstanceClass);
}
long DegradeDBInstanceSpecRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DegradeDBInstanceSpecRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
int DegradeDBInstanceSpecRequest::getDBInstanceStorage()const
{
return dBInstanceStorage_;
}
void DegradeDBInstanceSpecRequest::setDBInstanceStorage(int dBInstanceStorage)
{
dBInstanceStorage_ = dBInstanceStorage;
setParameter("DBInstanceStorage", std::to_string(dBInstanceStorage));
}
std::string DegradeDBInstanceSpecRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DegradeDBInstanceSpecRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DegradeDBInstanceSpecRequest::getClientToken()const
{
return clientToken_;
}
void DegradeDBInstanceSpecRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string DegradeDBInstanceSpecRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DegradeDBInstanceSpecRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DegradeDBInstanceSpecRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DegradeDBInstanceSpecRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DegradeDBInstanceSpecRequest::getOwnerId()const
{
return ownerId_;
}
void DegradeDBInstanceSpecRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DegradeDBInstanceSpecRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DegradeDBInstanceSpecRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DegradeDBInstanceSpecRequest::getDBInstanceClass()const
{
return dBInstanceClass_;
}
void DegradeDBInstanceSpecRequest::setDBInstanceClass(const std::string& dBInstanceClass)
{
dBInstanceClass_ = dBInstanceClass;
setParameter("DBInstanceClass", dBInstanceClass);
}

159
rds/src/model/DeleteAccountRequest.cc
View File

@@ -16,90 +16,89 @@
#include <alibabacloud/rds/model/DeleteAccountRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DeleteAccountRequest;
DeleteAccountRequest::DeleteAccountRequest() :
RdsRequest("DeleteAccount")
RpcServiceRequest("rds", "2014-08-15", "DeleteAccount")
{}
DeleteAccountRequest::~DeleteAccountRequest()
{}
long DeleteAccountRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteAccountRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteAccountRequest::getAccountName()const
{
return accountName_;
}
void DeleteAccountRequest::setAccountName(const std::string& accountName)
{
accountName_ = accountName;
setParameter("AccountName", accountName);
}
std::string DeleteAccountRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteAccountRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteAccountRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteAccountRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DeleteAccountRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DeleteAccountRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DeleteAccountRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteAccountRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteAccountRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteAccountRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long DeleteAccountRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteAccountRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteAccountRequest::getAccountName()const
{
return accountName_;
}
void DeleteAccountRequest::setAccountName(const std::string& accountName)
{
accountName_ = accountName;
setParameter("AccountName", accountName);
}
std::string DeleteAccountRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteAccountRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteAccountRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteAccountRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DeleteAccountRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DeleteAccountRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DeleteAccountRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteAccountRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteAccountRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteAccountRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

159
rds/src/model/DeleteBackupRequest.cc
View File

@@ -16,90 +16,89 @@
#include <alibabacloud/rds/model/DeleteBackupRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DeleteBackupRequest;
DeleteBackupRequest::DeleteBackupRequest() :
RdsRequest("DeleteBackup")
RpcServiceRequest("rds", "2014-08-15", "DeleteBackup")
{}
DeleteBackupRequest::~DeleteBackupRequest()
{}
long DeleteBackupRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteBackupRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteBackupRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteBackupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteBackupRequest::getBackupId()const
{
return backupId_;
}
void DeleteBackupRequest::setBackupId(const std::string& backupId)
{
backupId_ = backupId;
setParameter("BackupId", backupId);
}
std::string DeleteBackupRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteBackupRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DeleteBackupRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DeleteBackupRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DeleteBackupRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteBackupRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteBackupRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteBackupRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long DeleteBackupRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteBackupRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteBackupRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteBackupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteBackupRequest::getBackupId()const
{
return backupId_;
}
void DeleteBackupRequest::setBackupId(const std::string& backupId)
{
backupId_ = backupId;
setParameter("BackupId", backupId);
}
std::string DeleteBackupRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteBackupRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DeleteBackupRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DeleteBackupRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DeleteBackupRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteBackupRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteBackupRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteBackupRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

159
rds/src/model/DeleteDBInstanceRequest.cc
View File

@@ -16,90 +16,89 @@
#include <alibabacloud/rds/model/DeleteDBInstanceRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DeleteDBInstanceRequest;
DeleteDBInstanceRequest::DeleteDBInstanceRequest() :
RdsRequest("DeleteDBInstance")
RpcServiceRequest("rds", "2014-08-15", "DeleteDBInstance")
{}
DeleteDBInstanceRequest::~DeleteDBInstanceRequest()
{}
long DeleteDBInstanceRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteDBInstanceRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteDBInstanceRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteDBInstanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteDBInstanceRequest::getClientToken()const
{
return clientToken_;
}
void DeleteDBInstanceRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string DeleteDBInstanceRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteDBInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DeleteDBInstanceRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DeleteDBInstanceRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DeleteDBInstanceRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteDBInstanceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteDBInstanceRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteDBInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long DeleteDBInstanceRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteDBInstanceRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteDBInstanceRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteDBInstanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteDBInstanceRequest::getClientToken()const
{
return clientToken_;
}
void DeleteDBInstanceRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string DeleteDBInstanceRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteDBInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DeleteDBInstanceRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DeleteDBInstanceRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DeleteDBInstanceRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteDBInstanceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteDBInstanceRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteDBInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

203
rds/src/model/DeleteDampPolicyRequest.cc
View File

@@ -16,112 +16,111 @@
#include <alibabacloud/rds/model/DeleteDampPolicyRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DeleteDampPolicyRequest;
DeleteDampPolicyRequest::DeleteDampPolicyRequest() :
RdsRequest("DeleteDampPolicy")
RpcServiceRequest("rds", "2014-08-15", "DeleteDampPolicy")
{}
DeleteDampPolicyRequest::~DeleteDampPolicyRequest()
{}
long DeleteDampPolicyRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteDampPolicyRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteDampPolicyRequest::getSecurityToken()const
{
return securityToken_;
}
void DeleteDampPolicyRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setParameter("SecurityToken", securityToken);
}
std::string DeleteDampPolicyRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteDampPolicyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteDampPolicyRequest::getRegionId()const
{
return regionId_;
}
void DeleteDampPolicyRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DeleteDampPolicyRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteDampPolicyRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DeleteDampPolicyRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DeleteDampPolicyRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string DeleteDampPolicyRequest::getPolicyName()const
{
return policyName_;
}
void DeleteDampPolicyRequest::setPolicyName(const std::string& policyName)
{
policyName_ = policyName;
setParameter("PolicyName", policyName);
}
long DeleteDampPolicyRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteDampPolicyRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteDampPolicyRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteDampPolicyRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long DeleteDampPolicyRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteDampPolicyRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteDampPolicyRequest::getSecurityToken()const
{
return securityToken_;
}
void DeleteDampPolicyRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setParameter("SecurityToken", securityToken);
}
std::string DeleteDampPolicyRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteDampPolicyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteDampPolicyRequest::getRegionId()const
{
return regionId_;
}
void DeleteDampPolicyRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DeleteDampPolicyRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteDampPolicyRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DeleteDampPolicyRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DeleteDampPolicyRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string DeleteDampPolicyRequest::getPolicyName()const
{
return policyName_;
}
void DeleteDampPolicyRequest::setPolicyName(const std::string& policyName)
{
policyName_ = policyName;
setParameter("PolicyName", policyName);
}
long DeleteDampPolicyRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteDampPolicyRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteDampPolicyRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteDampPolicyRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

159
rds/src/model/DeleteDatabaseRequest.cc
View File

@@ -16,90 +16,89 @@
#include <alibabacloud/rds/model/DeleteDatabaseRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DeleteDatabaseRequest;
DeleteDatabaseRequest::DeleteDatabaseRequest() :
RdsRequest("DeleteDatabase")
RpcServiceRequest("rds", "2014-08-15", "DeleteDatabase")
{}
DeleteDatabaseRequest::~DeleteDatabaseRequest()
{}
long DeleteDatabaseRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteDatabaseRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteDatabaseRequest::getDBName()const
{
return dBName_;
}
void DeleteDatabaseRequest::setDBName(const std::string& dBName)
{
dBName_ = dBName;
setParameter("DBName", dBName);
}
std::string DeleteDatabaseRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteDatabaseRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteDatabaseRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteDatabaseRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DeleteDatabaseRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DeleteDatabaseRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DeleteDatabaseRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteDatabaseRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteDatabaseRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteDatabaseRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long DeleteDatabaseRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteDatabaseRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteDatabaseRequest::getDBName()const
{
return dBName_;
}
void DeleteDatabaseRequest::setDBName(const std::string& dBName)
{
dBName_ = dBName;
setParameter("DBName", dBName);
}
std::string DeleteDatabaseRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteDatabaseRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteDatabaseRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteDatabaseRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DeleteDatabaseRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DeleteDatabaseRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DeleteDatabaseRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteDatabaseRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteDatabaseRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteDatabaseRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

291
rds/src/model/DescibeImportsFromDatabaseRequest.cc
View File

@@ -16,156 +16,155 @@
#include <alibabacloud/rds/model/DescibeImportsFromDatabaseRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescibeImportsFromDatabaseRequest;
DescibeImportsFromDatabaseRequest::DescibeImportsFromDatabaseRequest() :
RdsRequest("DescibeImportsFromDatabase")
RpcServiceRequest("rds", "2014-08-15", "DescibeImportsFromDatabase")
{}
DescibeImportsFromDatabaseRequest::~DescibeImportsFromDatabaseRequest()
{}
long DescibeImportsFromDatabaseRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescibeImportsFromDatabaseRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescibeImportsFromDatabaseRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescibeImportsFromDatabaseRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescibeImportsFromDatabaseRequest::getClientToken()const
{
return clientToken_;
}
void DescibeImportsFromDatabaseRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string DescibeImportsFromDatabaseRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescibeImportsFromDatabaseRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescibeImportsFromDatabaseRequest::getEndTime()const
{
return endTime_;
}
void DescibeImportsFromDatabaseRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
std::string DescibeImportsFromDatabaseRequest::getStartTime()const
{
return startTime_;
}
void DescibeImportsFromDatabaseRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
long DescibeImportsFromDatabaseRequest::getOwnerId()const
{
return ownerId_;
}
void DescibeImportsFromDatabaseRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
int DescibeImportsFromDatabaseRequest::getPageNumber()const
{
return pageNumber_;
}
void DescibeImportsFromDatabaseRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescibeImportsFromDatabaseRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescibeImportsFromDatabaseRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
int DescibeImportsFromDatabaseRequest::getImportId()const
{
return importId_;
}
void DescibeImportsFromDatabaseRequest::setImportId(int importId)
{
importId_ = importId;
setParameter("ImportId", std::to_string(importId));
}
std::string DescibeImportsFromDatabaseRequest::getEngine()const
{
return engine_;
}
void DescibeImportsFromDatabaseRequest::setEngine(const std::string& engine)
{
engine_ = engine;
setParameter("Engine", engine);
}
int DescibeImportsFromDatabaseRequest::getPageSize()const
{
return pageSize_;
}
void DescibeImportsFromDatabaseRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescibeImportsFromDatabaseRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescibeImportsFromDatabaseRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescibeImportsFromDatabaseRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescibeImportsFromDatabaseRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescibeImportsFromDatabaseRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescibeImportsFromDatabaseRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescibeImportsFromDatabaseRequest::getClientToken()const
{
return clientToken_;
}
void DescibeImportsFromDatabaseRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string DescibeImportsFromDatabaseRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescibeImportsFromDatabaseRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescibeImportsFromDatabaseRequest::getEndTime()const
{
return endTime_;
}
void DescibeImportsFromDatabaseRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
std::string DescibeImportsFromDatabaseRequest::getStartTime()const
{
return startTime_;
}
void DescibeImportsFromDatabaseRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
long DescibeImportsFromDatabaseRequest::getOwnerId()const
{
return ownerId_;
}
void DescibeImportsFromDatabaseRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
int DescibeImportsFromDatabaseRequest::getPageNumber()const
{
return pageNumber_;
}
void DescibeImportsFromDatabaseRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescibeImportsFromDatabaseRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescibeImportsFromDatabaseRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
int DescibeImportsFromDatabaseRequest::getImportId()const
{
return importId_;
}
void DescibeImportsFromDatabaseRequest::setImportId(int importId)
{
importId_ = importId;
setParameter("ImportId", std::to_string(importId));
}
std::string DescibeImportsFromDatabaseRequest::getEngine()const
{
return engine_;
}
void DescibeImportsFromDatabaseRequest::setEngine(const std::string& engine)
{
engine_ = engine;
setParameter("Engine", engine);
}
int DescibeImportsFromDatabaseRequest::getPageSize()const
{
return pageSize_;
}
void DescibeImportsFromDatabaseRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescibeImportsFromDatabaseRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescibeImportsFromDatabaseRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}

86
rds/src/model/DescibeImportsFromDatabaseResult.cc
View File

@@ -40,50 +40,48 @@ void DescibeImportsFromDatabaseResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["ImportResultFromDB"];
for (auto value : allItems)
{
ImportResultFromDB importResultFromDBObject;
importResultFromDBObject.importId = std::stoi(value["ImportId"].asString());
importResultFromDBObject.importDataType = value["ImportDataType"].asString();
importResultFromDBObject.importDataStatus = value["ImportDataStatus"].asString();
importResultFromDBObject.importDataStatusDescription = value["ImportDataStatusDescription"].asString();
importResultFromDBObject.incrementalImportingTime = value["IncrementalImportingTime"].asString();
items_.push_back(importResultFromDBObject);
}
totalRecordCount_ = std::stoi(value["TotalRecordCount"].asString());
pageNumber_ = std::stoi(value["PageNumber"].asString());
pageRecordCount_ = std::stoi(value["PageRecordCount"].asString());
auto allItems = value["Items"]["ImportResultFromDB"];
for (auto value : allItems)
{
ImportResultFromDB itemsObject;
if(!value["ImportId"].isNull())
itemsObject.importId = std::stoi(value["ImportId"].asString());
if(!value["ImportDataType"].isNull())
itemsObject.importDataType = value["ImportDataType"].asString();
if(!value["ImportDataStatus"].isNull())
itemsObject.importDataStatus = value["ImportDataStatus"].asString();
if(!value["ImportDataStatusDescription"].isNull())
itemsObject.importDataStatusDescription = value["ImportDataStatusDescription"].asString();
if(!value["IncrementalImportingTime"].isNull())
itemsObject.incrementalImportingTime = value["IncrementalImportingTime"].asString();
items_.push_back(itemsObject);
}
if(!value["TotalRecordCount"].isNull())
totalRecordCount_ = std::stoi(value["TotalRecordCount"].asString());
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageRecordCount"].isNull())
pageRecordCount_ = std::stoi(value["PageRecordCount"].asString());
}
int DescibeImportsFromDatabaseResult::getTotalRecordCount()const
{
return totalRecordCount_;
}
void DescibeImportsFromDatabaseResult::setTotalRecordCount(int totalRecordCount)
{
totalRecordCount_ = totalRecordCount;
}
int DescibeImportsFromDatabaseResult::getPageRecordCount()const
{
return pageRecordCount_;
}
void DescibeImportsFromDatabaseResult::setPageRecordCount(int pageRecordCount)
{
pageRecordCount_ = pageRecordCount;
}
int DescibeImportsFromDatabaseResult::getPageNumber()const
{
return pageNumber_;
}
void DescibeImportsFromDatabaseResult::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
}
int DescibeImportsFromDatabaseResult::getTotalRecordCount()const
{
return totalRecordCount_;
}
int DescibeImportsFromDatabaseResult::getPageRecordCount()const
{
return pageRecordCount_;
}
int DescibeImportsFromDatabaseResult::getPageNumber()const
{
return pageNumber_;
}
std::vector<DescibeImportsFromDatabaseResult::ImportResultFromDB> DescibeImportsFromDatabaseResult::getItems()const
{
return items_;
}

467
rds/src/model/DescribeAbnormalDBInstancesRequest.cc
View File

@@ -16,244 +16,243 @@
#include <alibabacloud/rds/model/DescribeAbnormalDBInstancesRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeAbnormalDBInstancesRequest;
DescribeAbnormalDBInstancesRequest::DescribeAbnormalDBInstancesRequest() :
RdsRequest("DescribeAbnormalDBInstances")
RpcServiceRequest("rds", "2014-08-15", "DescribeAbnormalDBInstances")
{}
DescribeAbnormalDBInstancesRequest::~DescribeAbnormalDBInstancesRequest()
{}
std::string DescribeAbnormalDBInstancesRequest::getTag4value()const
{
return tag4value_;
}
void DescribeAbnormalDBInstancesRequest::setTag4value(const std::string& tag4value)
{
tag4value_ = tag4value;
setParameter("Tag4value", tag4value);
}
long DescribeAbnormalDBInstancesRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeAbnormalDBInstancesRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeAbnormalDBInstancesRequest::getTag2key()const
{
return tag2key_;
}
void DescribeAbnormalDBInstancesRequest::setTag2key(const std::string& tag2key)
{
tag2key_ = tag2key;
setParameter("Tag2key", tag2key);
}
std::string DescribeAbnormalDBInstancesRequest::getTag5key()const
{
return tag5key_;
}
void DescribeAbnormalDBInstancesRequest::setTag5key(const std::string& tag5key)
{
tag5key_ = tag5key;
setParameter("Tag5key", tag5key);
}
std::string DescribeAbnormalDBInstancesRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeAbnormalDBInstancesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeAbnormalDBInstancesRequest::getClientToken()const
{
return clientToken_;
}
void DescribeAbnormalDBInstancesRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string DescribeAbnormalDBInstancesRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeAbnormalDBInstancesRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeAbnormalDBInstancesRequest::getTag3key()const
{
return tag3key_;
}
void DescribeAbnormalDBInstancesRequest::setTag3key(const std::string& tag3key)
{
tag3key_ = tag3key;
setParameter("Tag3key", tag3key);
}
long DescribeAbnormalDBInstancesRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeAbnormalDBInstancesRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeAbnormalDBInstancesRequest::getTag5value()const
{
return tag5value_;
}
void DescribeAbnormalDBInstancesRequest::setTag5value(const std::string& tag5value)
{
tag5value_ = tag5value;
setParameter("Tag5value", tag5value);
}
int DescribeAbnormalDBInstancesRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeAbnormalDBInstancesRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeAbnormalDBInstancesRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeAbnormalDBInstancesRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeAbnormalDBInstancesRequest::getTags()const
{
return tags_;
}
void DescribeAbnormalDBInstancesRequest::setTags(const std::string& tags)
{
tags_ = tags;
setParameter("Tags", tags);
}
std::string DescribeAbnormalDBInstancesRequest::getTag1key()const
{
return tag1key_;
}
void DescribeAbnormalDBInstancesRequest::setTag1key(const std::string& tag1key)
{
tag1key_ = tag1key;
setParameter("Tag1key", tag1key);
}
std::string DescribeAbnormalDBInstancesRequest::getTag1value()const
{
return tag1value_;
}
void DescribeAbnormalDBInstancesRequest::setTag1value(const std::string& tag1value)
{
tag1value_ = tag1value;
setParameter("Tag1value", tag1value);
}
std::string DescribeAbnormalDBInstancesRequest::getTag2value()const
{
return tag2value_;
}
void DescribeAbnormalDBInstancesRequest::setTag2value(const std::string& tag2value)
{
tag2value_ = tag2value;
setParameter("Tag2value", tag2value);
}
int DescribeAbnormalDBInstancesRequest::getPageSize()const
{
return pageSize_;
}
void DescribeAbnormalDBInstancesRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeAbnormalDBInstancesRequest::getTag4key()const
{
return tag4key_;
}
void DescribeAbnormalDBInstancesRequest::setTag4key(const std::string& tag4key)
{
tag4key_ = tag4key;
setParameter("Tag4key", tag4key);
}
std::string DescribeAbnormalDBInstancesRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeAbnormalDBInstancesRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string DescribeAbnormalDBInstancesRequest::getTag3value()const
{
return tag3value_;
}
void DescribeAbnormalDBInstancesRequest::setTag3value(const std::string& tag3value)
{
tag3value_ = tag3value;
setParameter("Tag3value", tag3value);
}
std::string DescribeAbnormalDBInstancesRequest::getProxyId()const
{
return proxyId_;
}
void DescribeAbnormalDBInstancesRequest::setProxyId(const std::string& proxyId)
{
proxyId_ = proxyId;
setParameter("ProxyId", proxyId);
}
std::string DescribeAbnormalDBInstancesRequest::getTag4value()const
{
return tag4value_;
}
void DescribeAbnormalDBInstancesRequest::setTag4value(const std::string& tag4value)
{
tag4value_ = tag4value;
setParameter("Tag4value", tag4value);
}
long DescribeAbnormalDBInstancesRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeAbnormalDBInstancesRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeAbnormalDBInstancesRequest::getTag2key()const
{
return tag2key_;
}
void DescribeAbnormalDBInstancesRequest::setTag2key(const std::string& tag2key)
{
tag2key_ = tag2key;
setParameter("Tag2key", tag2key);
}
std::string DescribeAbnormalDBInstancesRequest::getTag5key()const
{
return tag5key_;
}
void DescribeAbnormalDBInstancesRequest::setTag5key(const std::string& tag5key)
{
tag5key_ = tag5key;
setParameter("Tag5key", tag5key);
}
std::string DescribeAbnormalDBInstancesRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeAbnormalDBInstancesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeAbnormalDBInstancesRequest::getClientToken()const
{
return clientToken_;
}
void DescribeAbnormalDBInstancesRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string DescribeAbnormalDBInstancesRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeAbnormalDBInstancesRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeAbnormalDBInstancesRequest::getTag3key()const
{
return tag3key_;
}
void DescribeAbnormalDBInstancesRequest::setTag3key(const std::string& tag3key)
{
tag3key_ = tag3key;
setParameter("Tag3key", tag3key);
}
long DescribeAbnormalDBInstancesRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeAbnormalDBInstancesRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeAbnormalDBInstancesRequest::getTag5value()const
{
return tag5value_;
}
void DescribeAbnormalDBInstancesRequest::setTag5value(const std::string& tag5value)
{
tag5value_ = tag5value;
setParameter("Tag5value", tag5value);
}
int DescribeAbnormalDBInstancesRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeAbnormalDBInstancesRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeAbnormalDBInstancesRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeAbnormalDBInstancesRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeAbnormalDBInstancesRequest::getTags()const
{
return tags_;
}
void DescribeAbnormalDBInstancesRequest::setTags(const std::string& tags)
{
tags_ = tags;
setParameter("Tags", tags);
}
std::string DescribeAbnormalDBInstancesRequest::getTag1key()const
{
return tag1key_;
}
void DescribeAbnormalDBInstancesRequest::setTag1key(const std::string& tag1key)
{
tag1key_ = tag1key;
setParameter("Tag1key", tag1key);
}
std::string DescribeAbnormalDBInstancesRequest::getTag1value()const
{
return tag1value_;
}
void DescribeAbnormalDBInstancesRequest::setTag1value(const std::string& tag1value)
{
tag1value_ = tag1value;
setParameter("Tag1value", tag1value);
}
std::string DescribeAbnormalDBInstancesRequest::getTag2value()const
{
return tag2value_;
}
void DescribeAbnormalDBInstancesRequest::setTag2value(const std::string& tag2value)
{
tag2value_ = tag2value;
setParameter("Tag2value", tag2value);
}
int DescribeAbnormalDBInstancesRequest::getPageSize()const
{
return pageSize_;
}
void DescribeAbnormalDBInstancesRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeAbnormalDBInstancesRequest::getTag4key()const
{
return tag4key_;
}
void DescribeAbnormalDBInstancesRequest::setTag4key(const std::string& tag4key)
{
tag4key_ = tag4key;
setParameter("Tag4key", tag4key);
}
std::string DescribeAbnormalDBInstancesRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeAbnormalDBInstancesRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string DescribeAbnormalDBInstancesRequest::getTag3value()const
{
return tag3value_;
}
void DescribeAbnormalDBInstancesRequest::setTag3value(const std::string& tag3value)
{
tag3value_ = tag3value;
setParameter("Tag3value", tag3value);
}
std::string DescribeAbnormalDBInstancesRequest::getProxyId()const
{
return proxyId_;
}
void DescribeAbnormalDBInstancesRequest::setProxyId(const std::string& proxyId)
{
proxyId_ = proxyId;
setParameter("ProxyId", proxyId);
}

113
rds/src/model/DescribeAbnormalDBInstancesResult.cc
View File

@@ -40,62 +40,63 @@ void DescribeAbnormalDBInstancesResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["InstanceResult"];
for (auto value : allItems)
{
InstanceResult instanceResultObject;
instanceResultObject.dBInstanceDescription = value["DBInstanceDescription"].asString();
instanceResultObject.dBInstanceId = value["DBInstanceId"].asString();
auto allAbnormalItems = value["AbnormalItems"]["AbnormalItem"];
for (auto value : allAbnormalItems)
{
InstanceResult::AbnormalItem abnormalItemObject;
abnormalItemObject.checkTime = value["CheckTime"].asString();
abnormalItemObject.checkItem = value["CheckItem"].asString();
abnormalItemObject.abnormalReason = value["AbnormalReason"].asString();
abnormalItemObject.abnormalValue = value["AbnormalValue"].asString();
abnormalItemObject.abnormalDetail = value["AbnormalDetail"].asString();
abnormalItemObject.adviceKey = value["AdviceKey"].asString();
auto allAdviseValue = value["AdviseValue"]["String"];
for (auto value : allAdviseValue)
abnormalItemObject.adviseValue.push_back(value.asString());
instanceResultObject.abnormalItems.push_back(abnormalItemObject);
}
items_.push_back(instanceResultObject);
}
totalRecordCount_ = std::stoi(value["TotalRecordCount"].asString());
pageNumber_ = std::stoi(value["PageNumber"].asString());
pageRecordCount_ = std::stoi(value["PageRecordCount"].asString());
auto allItems = value["Items"]["InstanceResult"];
for (auto value : allItems)
{
InstanceResult itemsObject;
if(!value["DBInstanceDescription"].isNull())
itemsObject.dBInstanceDescription = value["DBInstanceDescription"].asString();
if(!value["DBInstanceId"].isNull())
itemsObject.dBInstanceId = value["DBInstanceId"].asString();
auto allAbnormalItems = value["AbnormalItems"]["AbnormalItem"];
for (auto value : allAbnormalItems)
{
InstanceResult::AbnormalItem abnormalItemsObject;
if(!value["CheckTime"].isNull())
abnormalItemsObject.checkTime = value["CheckTime"].asString();
if(!value["CheckItem"].isNull())
abnormalItemsObject.checkItem = value["CheckItem"].asString();
if(!value["AbnormalReason"].isNull())
abnormalItemsObject.abnormalReason = value["AbnormalReason"].asString();
if(!value["AbnormalValue"].isNull())
abnormalItemsObject.abnormalValue = value["AbnormalValue"].asString();
if(!value["AbnormalDetail"].isNull())
abnormalItemsObject.abnormalDetail = value["AbnormalDetail"].asString();
if(!value["AdviceKey"].isNull())
abnormalItemsObject.adviceKey = value["AdviceKey"].asString();
auto allAdviseValue = value["AdviseValue"]["String"];
for (auto value : allAdviseValue)
abnormalItemsObject.adviseValue.push_back(value.asString());
itemsObject.abnormalItems.push_back(abnormalItemsObject);
}
items_.push_back(itemsObject);
}
if(!value["TotalRecordCount"].isNull())
totalRecordCount_ = std::stoi(value["TotalRecordCount"].asString());
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageRecordCount"].isNull())
pageRecordCount_ = std::stoi(value["PageRecordCount"].asString());
}
int DescribeAbnormalDBInstancesResult::getTotalRecordCount()const
{
return totalRecordCount_;
}
void DescribeAbnormalDBInstancesResult::setTotalRecordCount(int totalRecordCount)
{
totalRecordCount_ = totalRecordCount;
}
int DescribeAbnormalDBInstancesResult::getPageRecordCount()const
{
return pageRecordCount_;
}
void DescribeAbnormalDBInstancesResult::setPageRecordCount(int pageRecordCount)
{
pageRecordCount_ = pageRecordCount;
}
int DescribeAbnormalDBInstancesResult::getPageNumber()const
{
return pageNumber_;
}
void DescribeAbnormalDBInstancesResult::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
}
int DescribeAbnormalDBInstancesResult::getTotalRecordCount()const
{
return totalRecordCount_;
}
int DescribeAbnormalDBInstancesResult::getPageRecordCount()const
{
return pageRecordCount_;
}
int DescribeAbnormalDBInstancesResult::getPageNumber()const
{
return pageNumber_;
}
std::vector<DescribeAbnormalDBInstancesResult::InstanceResult> DescribeAbnormalDBInstancesResult::getItems()const
{
return items_;
}

159
rds/src/model/DescribeAccountsRequest.cc
View File

@@ -16,90 +16,89 @@
#include <alibabacloud/rds/model/DescribeAccountsRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeAccountsRequest;
DescribeAccountsRequest::DescribeAccountsRequest() :
RdsRequest("DescribeAccounts")
RpcServiceRequest("rds", "2014-08-15", "DescribeAccounts")
{}
DescribeAccountsRequest::~DescribeAccountsRequest()
{}
long DescribeAccountsRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeAccountsRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeAccountsRequest::getAccountName()const
{
return accountName_;
}
void DescribeAccountsRequest::setAccountName(const std::string& accountName)
{
accountName_ = accountName;
setParameter("AccountName", accountName);
}
std::string DescribeAccountsRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeAccountsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeAccountsRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeAccountsRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeAccountsRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeAccountsRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeAccountsRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeAccountsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeAccountsRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeAccountsRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long DescribeAccountsRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeAccountsRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeAccountsRequest::getAccountName()const
{
return accountName_;
}
void DescribeAccountsRequest::setAccountName(const std::string& accountName)
{
accountName_ = accountName;
setParameter("AccountName", accountName);
}
std::string DescribeAccountsRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeAccountsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeAccountsRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeAccountsRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeAccountsRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeAccountsRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeAccountsRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeAccountsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeAccountsRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeAccountsRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

50
rds/src/model/DescribeAccountsResult.cc
View File

@@ -40,25 +40,37 @@ void DescribeAccountsResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allAccounts = value["Accounts"]["DBInstanceAccount"];
for (auto value : allAccounts)
{
DBInstanceAccount dBInstanceAccountObject;
dBInstanceAccountObject.dBInstanceId = value["DBInstanceId"].asString();
dBInstanceAccountObject.accountName = value["AccountName"].asString();
dBInstanceAccountObject.accountStatus = value["AccountStatus"].asString();
dBInstanceAccountObject.accountType = value["AccountType"].asString();
dBInstanceAccountObject.accountDescription = value["AccountDescription"].asString();
auto allDatabasePrivileges = value["DatabasePrivileges"]["DatabasePrivilege"];
for (auto value : allDatabasePrivileges)
{
DBInstanceAccount::DatabasePrivilege databasePrivilegeObject;
databasePrivilegeObject.dBName = value["DBName"].asString();
databasePrivilegeObject.accountPrivilege = value["AccountPrivilege"].asString();
dBInstanceAccountObject.databasePrivileges.push_back(databasePrivilegeObject);
}
accounts_.push_back(dBInstanceAccountObject);
}
auto allAccounts = value["Accounts"]["DBInstanceAccount"];
for (auto value : allAccounts)
{
DBInstanceAccount accountsObject;
if(!value["DBInstanceId"].isNull())
accountsObject.dBInstanceId = value["DBInstanceId"].asString();
if(!value["AccountName"].isNull())
accountsObject.accountName = value["AccountName"].asString();
if(!value["AccountStatus"].isNull())
accountsObject.accountStatus = value["AccountStatus"].asString();
if(!value["AccountType"].isNull())
accountsObject.accountType = value["AccountType"].asString();
if(!value["AccountDescription"].isNull())
accountsObject.accountDescription = value["AccountDescription"].asString();
auto allDatabasePrivileges = value["DatabasePrivileges"]["DatabasePrivilege"];
for (auto value : allDatabasePrivileges)
{
DBInstanceAccount::DatabasePrivilege databasePrivilegesObject;
if(!value["DBName"].isNull())
databasePrivilegesObject.dBName = value["DBName"].asString();
if(!value["AccountPrivilege"].isNull())
databasePrivilegesObject.accountPrivilege = value["AccountPrivilege"].asString();
accountsObject.databasePrivileges.push_back(databasePrivilegesObject);
}
accounts_.push_back(accountsObject);
}
}
std::vector<DescribeAccountsResult::DBInstanceAccount> DescribeAccountsResult::getAccounts()const
{
return accounts_;
}

137
rds/src/model/DescribeBackupPolicyRequest.cc
View File

@@ -16,79 +16,78 @@
#include <alibabacloud/rds/model/DescribeBackupPolicyRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeBackupPolicyRequest;
DescribeBackupPolicyRequest::DescribeBackupPolicyRequest() :
RdsRequest("DescribeBackupPolicy")
RpcServiceRequest("rds", "2014-08-15", "DescribeBackupPolicy")
{}
DescribeBackupPolicyRequest::~DescribeBackupPolicyRequest()
{}
long DescribeBackupPolicyRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeBackupPolicyRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeBackupPolicyRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeBackupPolicyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeBackupPolicyRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeBackupPolicyRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeBackupPolicyRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeBackupPolicyRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeBackupPolicyRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeBackupPolicyRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeBackupPolicyRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeBackupPolicyRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long DescribeBackupPolicyRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeBackupPolicyRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeBackupPolicyRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeBackupPolicyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeBackupPolicyRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeBackupPolicyRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeBackupPolicyRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeBackupPolicyRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeBackupPolicyRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeBackupPolicyRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeBackupPolicyRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeBackupPolicyRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

108
rds/src/model/DescribeBackupPolicyResult.cc
View File

@@ -40,72 +40,48 @@ void DescribeBackupPolicyResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
backupRetentionPeriod_ = std::stoi(value["BackupRetentionPeriod"].asString());
preferredNextBackupTime_ = value["PreferredNextBackupTime"].asString();
preferredBackupTime_ = value["PreferredBackupTime"].asString();
preferredBackupPeriod_ = value["PreferredBackupPeriod"].asString();
backupLog_ = value["BackupLog"].asString();
logBackupRetentionPeriod_ = std::stoi(value["LogBackupRetentionPeriod"].asString());
if(!value["BackupRetentionPeriod"].isNull())
backupRetentionPeriod_ = std::stoi(value["BackupRetentionPeriod"].asString());
if(!value["PreferredNextBackupTime"].isNull())
preferredNextBackupTime_ = value["PreferredNextBackupTime"].asString();
if(!value["PreferredBackupTime"].isNull())
preferredBackupTime_ = value["PreferredBackupTime"].asString();
if(!value["PreferredBackupPeriod"].isNull())
preferredBackupPeriod_ = value["PreferredBackupPeriod"].asString();
if(!value["BackupLog"].isNull())
backupLog_ = value["BackupLog"].asString();
if(!value["LogBackupRetentionPeriod"].isNull())
logBackupRetentionPeriod_ = std::stoi(value["LogBackupRetentionPeriod"].asString());
}
std::string DescribeBackupPolicyResult::getPreferredBackupPeriod()const
{
return preferredBackupPeriod_;
}
void DescribeBackupPolicyResult::setPreferredBackupPeriod(const std::string& preferredBackupPeriod)
{
preferredBackupPeriod_ = preferredBackupPeriod;
}
int DescribeBackupPolicyResult::getLogBackupRetentionPeriod()const
{
return logBackupRetentionPeriod_;
}
void DescribeBackupPolicyResult::setLogBackupRetentionPeriod(int logBackupRetentionPeriod)
{
logBackupRetentionPeriod_ = logBackupRetentionPeriod;
}
std::string DescribeBackupPolicyResult::getPreferredBackupTime()const
{
return preferredBackupTime_;
}
void DescribeBackupPolicyResult::setPreferredBackupTime(const std::string& preferredBackupTime)
{
preferredBackupTime_ = preferredBackupTime;
}
std::string DescribeBackupPolicyResult::getBackupLog()const
{
return backupLog_;
}
void DescribeBackupPolicyResult::setBackupLog(const std::string& backupLog)
{
backupLog_ = backupLog;
}
int DescribeBackupPolicyResult::getBackupRetentionPeriod()const
{
return backupRetentionPeriod_;
}
void DescribeBackupPolicyResult::setBackupRetentionPeriod(int backupRetentionPeriod)
{
backupRetentionPeriod_ = backupRetentionPeriod;
}
std::string DescribeBackupPolicyResult::getPreferredNextBackupTime()const
{
return preferredNextBackupTime_;
}
void DescribeBackupPolicyResult::setPreferredNextBackupTime(const std::string& preferredNextBackupTime)
{
preferredNextBackupTime_ = preferredNextBackupTime;
}
std::string DescribeBackupPolicyResult::getPreferredBackupPeriod()const
{
return preferredBackupPeriod_;
}
int DescribeBackupPolicyResult::getLogBackupRetentionPeriod()const
{
return logBackupRetentionPeriod_;
}
std::string DescribeBackupPolicyResult::getPreferredBackupTime()const
{
return preferredBackupTime_;
}
std::string DescribeBackupPolicyResult::getBackupLog()const
{
return backupLog_;
}
int DescribeBackupPolicyResult::getBackupRetentionPeriod()const
{
return backupRetentionPeriod_;
}
std::string DescribeBackupPolicyResult::getPreferredNextBackupTime()const
{
return preferredNextBackupTime_;
}

357
rds/src/model/DescribeBackupSetsForSecurityRequest.cc
View File

@@ -16,189 +16,188 @@
#include <alibabacloud/rds/model/DescribeBackupSetsForSecurityRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeBackupSetsForSecurityRequest;
DescribeBackupSetsForSecurityRequest::DescribeBackupSetsForSecurityRequest() :
RdsRequest("DescribeBackupSetsForSecurity")
RpcServiceRequest("rds", "2014-08-15", "DescribeBackupSetsForSecurity")
{}
DescribeBackupSetsForSecurityRequest::~DescribeBackupSetsForSecurityRequest()
{}
long DescribeBackupSetsForSecurityRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeBackupSetsForSecurityRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeBackupSetsForSecurityRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeBackupSetsForSecurityRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeBackupSetsForSecurityRequest::getTargetAliBid()const
{
return targetAliBid_;
}
void DescribeBackupSetsForSecurityRequest::setTargetAliBid(const std::string& targetAliBid)
{
targetAliBid_ = targetAliBid;
setParameter("TargetAliBid", targetAliBid);
}
std::string DescribeBackupSetsForSecurityRequest::getBackupId()const
{
return backupId_;
}
void DescribeBackupSetsForSecurityRequest::setBackupId(const std::string& backupId)
{
backupId_ = backupId;
setParameter("BackupId", backupId);
}
std::string DescribeBackupSetsForSecurityRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeBackupSetsForSecurityRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeBackupSetsForSecurityRequest::getEndTime()const
{
return endTime_;
}
void DescribeBackupSetsForSecurityRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
std::string DescribeBackupSetsForSecurityRequest::getStartTime()const
{
return startTime_;
}
void DescribeBackupSetsForSecurityRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
long DescribeBackupSetsForSecurityRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeBackupSetsForSecurityRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
int DescribeBackupSetsForSecurityRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeBackupSetsForSecurityRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeBackupSetsForSecurityRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeBackupSetsForSecurityRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeBackupSetsForSecurityRequest::getBackupStatus()const
{
return backupStatus_;
}
void DescribeBackupSetsForSecurityRequest::setBackupStatus(const std::string& backupStatus)
{
backupStatus_ = backupStatus;
setParameter("BackupStatus", backupStatus);
}
std::string DescribeBackupSetsForSecurityRequest::getBackupLocation()const
{
return backupLocation_;
}
void DescribeBackupSetsForSecurityRequest::setBackupLocation(const std::string& backupLocation)
{
backupLocation_ = backupLocation;
setParameter("BackupLocation", backupLocation);
}
std::string DescribeBackupSetsForSecurityRequest::getTargetAliUid()const
{
return targetAliUid_;
}
void DescribeBackupSetsForSecurityRequest::setTargetAliUid(const std::string& targetAliUid)
{
targetAliUid_ = targetAliUid;
setParameter("TargetAliUid", targetAliUid);
}
int DescribeBackupSetsForSecurityRequest::getPageSize()const
{
return pageSize_;
}
void DescribeBackupSetsForSecurityRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeBackupSetsForSecurityRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeBackupSetsForSecurityRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string DescribeBackupSetsForSecurityRequest::getBackupMode()const
{
return backupMode_;
}
void DescribeBackupSetsForSecurityRequest::setBackupMode(const std::string& backupMode)
{
backupMode_ = backupMode;
setParameter("BackupMode", backupMode);
}
long DescribeBackupSetsForSecurityRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeBackupSetsForSecurityRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeBackupSetsForSecurityRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeBackupSetsForSecurityRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeBackupSetsForSecurityRequest::getTargetAliBid()const
{
return targetAliBid_;
}
void DescribeBackupSetsForSecurityRequest::setTargetAliBid(const std::string& targetAliBid)
{
targetAliBid_ = targetAliBid;
setParameter("TargetAliBid", targetAliBid);
}
std::string DescribeBackupSetsForSecurityRequest::getBackupId()const
{
return backupId_;
}
void DescribeBackupSetsForSecurityRequest::setBackupId(const std::string& backupId)
{
backupId_ = backupId;
setParameter("BackupId", backupId);
}
std::string DescribeBackupSetsForSecurityRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeBackupSetsForSecurityRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeBackupSetsForSecurityRequest::getEndTime()const
{
return endTime_;
}
void DescribeBackupSetsForSecurityRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
std::string DescribeBackupSetsForSecurityRequest::getStartTime()const
{
return startTime_;
}
void DescribeBackupSetsForSecurityRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
long DescribeBackupSetsForSecurityRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeBackupSetsForSecurityRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
int DescribeBackupSetsForSecurityRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeBackupSetsForSecurityRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeBackupSetsForSecurityRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeBackupSetsForSecurityRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeBackupSetsForSecurityRequest::getBackupStatus()const
{
return backupStatus_;
}
void DescribeBackupSetsForSecurityRequest::setBackupStatus(const std::string& backupStatus)
{
backupStatus_ = backupStatus;
setParameter("BackupStatus", backupStatus);
}
std::string DescribeBackupSetsForSecurityRequest::getBackupLocation()const
{
return backupLocation_;
}
void DescribeBackupSetsForSecurityRequest::setBackupLocation(const std::string& backupLocation)
{
backupLocation_ = backupLocation;
setParameter("BackupLocation", backupLocation);
}
std::string DescribeBackupSetsForSecurityRequest::getTargetAliUid()const
{
return targetAliUid_;
}
void DescribeBackupSetsForSecurityRequest::setTargetAliUid(const std::string& targetAliUid)
{
targetAliUid_ = targetAliUid;
setParameter("TargetAliUid", targetAliUid);
}
int DescribeBackupSetsForSecurityRequest::getPageSize()const
{
return pageSize_;
}
void DescribeBackupSetsForSecurityRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeBackupSetsForSecurityRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeBackupSetsForSecurityRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string DescribeBackupSetsForSecurityRequest::getBackupMode()const
{
return backupMode_;
}
void DescribeBackupSetsForSecurityRequest::setBackupMode(const std::string& backupMode)
{
backupMode_ = backupMode;
setParameter("BackupMode", backupMode);
}

143
rds/src/model/DescribeBackupSetsForSecurityResult.cc
View File

@@ -40,74 +40,81 @@ void DescribeBackupSetsForSecurityResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["Backup"];
for (auto value : allItems)
{
Backup backupObject;
backupObject.backupId = value["BackupId"].asString();
backupObject.dBInstanceId = value["DBInstanceId"].asString();
backupObject.backupStatus = value["BackupStatus"].asString();
backupObject.backupStartTime = value["BackupStartTime"].asString();
backupObject.backupEndTime = value["BackupEndTime"].asString();
backupObject.backupType = value["BackupType"].asString();
backupObject.backupMode = value["BackupMode"].asString();
backupObject.backupMethod = value["BackupMethod"].asString();
backupObject.backupDownloadURL = value["BackupDownloadURL"].asString();
backupObject.backupIntranetDownloadURL = value["BackupIntranetDownloadURL"].asString();
backupObject.backupLocation = value["BackupLocation"].asString();
backupObject.backupExtractionStatus = value["BackupExtractionStatus"].asString();
backupObject.backupScale = value["BackupScale"].asString();
backupObject.backupDBNames = value["BackupDBNames"].asString();
backupObject.totalBackupSize = std::stol(value["TotalBackupSize"].asString());
backupObject.backupSize = std::stol(value["BackupSize"].asString());
backupObject.hostInstanceID = value["HostInstanceID"].asString();
backupObject.storeStatus = value["StoreStatus"].asString();
items_.push_back(backupObject);
}
totalRecordCount_ = value["TotalRecordCount"].asString();
pageNumber_ = value["PageNumber"].asString();
pageRecordCount_ = value["PageRecordCount"].asString();
totalBackupSize_ = std::stol(value["TotalBackupSize"].asString());
auto allItems = value["Items"]["Backup"];
for (auto value : allItems)
{
Backup itemsObject;
if(!value["BackupId"].isNull())
itemsObject.backupId = value["BackupId"].asString();
if(!value["DBInstanceId"].isNull())
itemsObject.dBInstanceId = value["DBInstanceId"].asString();
if(!value["BackupStatus"].isNull())
itemsObject.backupStatus = value["BackupStatus"].asString();
if(!value["BackupStartTime"].isNull())
itemsObject.backupStartTime = value["BackupStartTime"].asString();
if(!value["BackupEndTime"].isNull())
itemsObject.backupEndTime = value["BackupEndTime"].asString();
if(!value["BackupType"].isNull())
itemsObject.backupType = value["BackupType"].asString();
if(!value["BackupMode"].isNull())
itemsObject.backupMode = value["BackupMode"].asString();
if(!value["BackupMethod"].isNull())
itemsObject.backupMethod = value["BackupMethod"].asString();
if(!value["BackupDownloadURL"].isNull())
itemsObject.backupDownloadURL = value["BackupDownloadURL"].asString();
if(!value["BackupIntranetDownloadURL"].isNull())
itemsObject.backupIntranetDownloadURL = value["BackupIntranetDownloadURL"].asString();
if(!value["BackupLocation"].isNull())
itemsObject.backupLocation = value["BackupLocation"].asString();
if(!value["BackupExtractionStatus"].isNull())
itemsObject.backupExtractionStatus = value["BackupExtractionStatus"].asString();
if(!value["BackupScale"].isNull())
itemsObject.backupScale = value["BackupScale"].asString();
if(!value["BackupDBNames"].isNull())
itemsObject.backupDBNames = value["BackupDBNames"].asString();
if(!value["TotalBackupSize"].isNull())
itemsObject.totalBackupSize = std::stol(value["TotalBackupSize"].asString());
if(!value["BackupSize"].isNull())
itemsObject.backupSize = std::stol(value["BackupSize"].asString());
if(!value["HostInstanceID"].isNull())
itemsObject.hostInstanceID = value["HostInstanceID"].asString();
if(!value["StoreStatus"].isNull())
itemsObject.storeStatus = value["StoreStatus"].asString();
items_.push_back(itemsObject);
}
if(!value["TotalRecordCount"].isNull())
totalRecordCount_ = value["TotalRecordCount"].asString();
if(!value["PageNumber"].isNull())
pageNumber_ = value["PageNumber"].asString();
if(!value["PageRecordCount"].isNull())
pageRecordCount_ = value["PageRecordCount"].asString();
if(!value["TotalBackupSize"].isNull())
totalBackupSize_ = std::stol(value["TotalBackupSize"].asString());
}
std::string DescribeBackupSetsForSecurityResult::getTotalRecordCount()const
{
return totalRecordCount_;
}
void DescribeBackupSetsForSecurityResult::setTotalRecordCount(const std::string& totalRecordCount)
{
totalRecordCount_ = totalRecordCount;
}
std::string DescribeBackupSetsForSecurityResult::getPageRecordCount()const
{
return pageRecordCount_;
}
void DescribeBackupSetsForSecurityResult::setPageRecordCount(const std::string& pageRecordCount)
{
pageRecordCount_ = pageRecordCount;
}
std::string DescribeBackupSetsForSecurityResult::getPageNumber()const
{
return pageNumber_;
}
void DescribeBackupSetsForSecurityResult::setPageNumber(const std::string& pageNumber)
{
pageNumber_ = pageNumber;
}
long DescribeBackupSetsForSecurityResult::getTotalBackupSize()const
{
return totalBackupSize_;
}
void DescribeBackupSetsForSecurityResult::setTotalBackupSize(long totalBackupSize)
{
totalBackupSize_ = totalBackupSize;
}
std::string DescribeBackupSetsForSecurityResult::getTotalRecordCount()const
{
return totalRecordCount_;
}
std::string DescribeBackupSetsForSecurityResult::getPageRecordCount()const
{
return pageRecordCount_;
}
std::string DescribeBackupSetsForSecurityResult::getPageNumber()const
{
return pageNumber_;
}
std::vector<DescribeBackupSetsForSecurityResult::Backup> DescribeBackupSetsForSecurityResult::getItems()const
{
return items_;
}
long DescribeBackupSetsForSecurityResult::getTotalBackupSize()const
{
return totalBackupSize_;
}

247
rds/src/model/DescribeBackupTasksRequest.cc
View File

@@ -16,134 +16,133 @@
#include <alibabacloud/rds/model/DescribeBackupTasksRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeBackupTasksRequest;
DescribeBackupTasksRequest::DescribeBackupTasksRequest() :
RdsRequest("DescribeBackupTasks")
RpcServiceRequest("rds", "2014-08-15", "DescribeBackupTasks")
{}
DescribeBackupTasksRequest::~DescribeBackupTasksRequest()
{}
std::string DescribeBackupTasksRequest::getBackupJobId()const
{
return backupJobId_;
}
void DescribeBackupTasksRequest::setBackupJobId(const std::string& backupJobId)
{
backupJobId_ = backupJobId;
setParameter("BackupJobId", backupJobId);
}
long DescribeBackupTasksRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeBackupTasksRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeBackupTasksRequest::getFlag()const
{
return flag_;
}
void DescribeBackupTasksRequest::setFlag(const std::string& flag)
{
flag_ = flag;
setParameter("Flag", flag);
}
std::string DescribeBackupTasksRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeBackupTasksRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeBackupTasksRequest::getClientToken()const
{
return clientToken_;
}
void DescribeBackupTasksRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string DescribeBackupTasksRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeBackupTasksRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeBackupTasksRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeBackupTasksRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string DescribeBackupTasksRequest::getBackupMode()const
{
return backupMode_;
}
void DescribeBackupTasksRequest::setBackupMode(const std::string& backupMode)
{
backupMode_ = backupMode;
setParameter("BackupMode", backupMode);
}
long DescribeBackupTasksRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeBackupTasksRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeBackupTasksRequest::getBackupJobStatus()const
{
return backupJobStatus_;
}
void DescribeBackupTasksRequest::setBackupJobStatus(const std::string& backupJobStatus)
{
backupJobStatus_ = backupJobStatus;
setParameter("BackupJobStatus", backupJobStatus);
}
std::string DescribeBackupTasksRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeBackupTasksRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeBackupTasksRequest::getBackupJobId()const
{
return backupJobId_;
}
void DescribeBackupTasksRequest::setBackupJobId(const std::string& backupJobId)
{
backupJobId_ = backupJobId;
setParameter("BackupJobId", backupJobId);
}
long DescribeBackupTasksRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeBackupTasksRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeBackupTasksRequest::getFlag()const
{
return flag_;
}
void DescribeBackupTasksRequest::setFlag(const std::string& flag)
{
flag_ = flag;
setParameter("Flag", flag);
}
std::string DescribeBackupTasksRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeBackupTasksRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeBackupTasksRequest::getClientToken()const
{
return clientToken_;
}
void DescribeBackupTasksRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string DescribeBackupTasksRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeBackupTasksRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeBackupTasksRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeBackupTasksRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string DescribeBackupTasksRequest::getBackupMode()const
{
return backupMode_;
}
void DescribeBackupTasksRequest::setBackupMode(const std::string& backupMode)
{
backupMode_ = backupMode;
setParameter("BackupMode", backupMode);
}
long DescribeBackupTasksRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeBackupTasksRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeBackupTasksRequest::getBackupJobStatus()const
{
return backupJobStatus_;
}
void DescribeBackupTasksRequest::setBackupJobStatus(const std::string& backupJobStatus)
{
backupJobStatus_ = backupJobStatus;
setParameter("BackupJobStatus", backupJobStatus);
}
std::string DescribeBackupTasksRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeBackupTasksRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

32
rds/src/model/DescribeBackupTasksResult.cc
View File

@@ -40,17 +40,27 @@ void DescribeBackupTasksResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["BackupJob"];
for (auto value : allItems)
{
BackupJob backupJobObject;
backupJobObject.backupProgressStatus = value["BackupProgressStatus"].asString();
backupJobObject.jobMode = value["JobMode"].asString();
backupJobObject.process = value["Process"].asString();
backupJobObject.taskAction = value["TaskAction"].asString();
backupJobObject.backupjobId = value["BackupjobId"].asString();
items_.push_back(backupJobObject);
}
auto allItems = value["Items"]["BackupJob"];
for (auto value : allItems)
{
BackupJob itemsObject;
if(!value["BackupProgressStatus"].isNull())
itemsObject.backupProgressStatus = value["BackupProgressStatus"].asString();
if(!value["JobMode"].isNull())
itemsObject.jobMode = value["JobMode"].asString();
if(!value["Process"].isNull())
itemsObject.process = value["Process"].asString();
if(!value["TaskAction"].isNull())
itemsObject.taskAction = value["TaskAction"].asString();
if(!value["BackupjobId"].isNull())
itemsObject.backupjobId = value["BackupjobId"].asString();
items_.push_back(itemsObject);
}
}
std::vector<DescribeBackupTasksResult::BackupJob> DescribeBackupTasksResult::getItems()const
{
return items_;
}

357
rds/src/model/DescribeBackupsForSecurityRequest.cc
View File

@@ -16,189 +16,188 @@
#include <alibabacloud/rds/model/DescribeBackupsForSecurityRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeBackupsForSecurityRequest;
DescribeBackupsForSecurityRequest::DescribeBackupsForSecurityRequest() :
RdsRequest("DescribeBackupsForSecurity")
RpcServiceRequest("rds", "2014-08-15", "DescribeBackupsForSecurity")
{}
DescribeBackupsForSecurityRequest::~DescribeBackupsForSecurityRequest()
{}
long DescribeBackupsForSecurityRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeBackupsForSecurityRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeBackupsForSecurityRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeBackupsForSecurityRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeBackupsForSecurityRequest::getTargetAliBid()const
{
return targetAliBid_;
}
void DescribeBackupsForSecurityRequest::setTargetAliBid(const std::string& targetAliBid)
{
targetAliBid_ = targetAliBid;
setParameter("TargetAliBid", targetAliBid);
}
std::string DescribeBackupsForSecurityRequest::getBackupId()const
{
return backupId_;
}
void DescribeBackupsForSecurityRequest::setBackupId(const std::string& backupId)
{
backupId_ = backupId;
setParameter("BackupId", backupId);
}
std::string DescribeBackupsForSecurityRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeBackupsForSecurityRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeBackupsForSecurityRequest::getEndTime()const
{
return endTime_;
}
void DescribeBackupsForSecurityRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
std::string DescribeBackupsForSecurityRequest::getStartTime()const
{
return startTime_;
}
void DescribeBackupsForSecurityRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
long DescribeBackupsForSecurityRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeBackupsForSecurityRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
int DescribeBackupsForSecurityRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeBackupsForSecurityRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeBackupsForSecurityRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeBackupsForSecurityRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeBackupsForSecurityRequest::getBackupStatus()const
{
return backupStatus_;
}
void DescribeBackupsForSecurityRequest::setBackupStatus(const std::string& backupStatus)
{
backupStatus_ = backupStatus;
setParameter("BackupStatus", backupStatus);
}
std::string DescribeBackupsForSecurityRequest::getBackupLocation()const
{
return backupLocation_;
}
void DescribeBackupsForSecurityRequest::setBackupLocation(const std::string& backupLocation)
{
backupLocation_ = backupLocation;
setParameter("BackupLocation", backupLocation);
}
std::string DescribeBackupsForSecurityRequest::getTargetAliUid()const
{
return targetAliUid_;
}
void DescribeBackupsForSecurityRequest::setTargetAliUid(const std::string& targetAliUid)
{
targetAliUid_ = targetAliUid;
setParameter("TargetAliUid", targetAliUid);
}
int DescribeBackupsForSecurityRequest::getPageSize()const
{
return pageSize_;
}
void DescribeBackupsForSecurityRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeBackupsForSecurityRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeBackupsForSecurityRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string DescribeBackupsForSecurityRequest::getBackupMode()const
{
return backupMode_;
}
void DescribeBackupsForSecurityRequest::setBackupMode(const std::string& backupMode)
{
backupMode_ = backupMode;
setParameter("BackupMode", backupMode);
}
long DescribeBackupsForSecurityRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeBackupsForSecurityRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeBackupsForSecurityRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeBackupsForSecurityRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeBackupsForSecurityRequest::getTargetAliBid()const
{
return targetAliBid_;
}
void DescribeBackupsForSecurityRequest::setTargetAliBid(const std::string& targetAliBid)
{
targetAliBid_ = targetAliBid;
setParameter("TargetAliBid", targetAliBid);
}
std::string DescribeBackupsForSecurityRequest::getBackupId()const
{
return backupId_;
}
void DescribeBackupsForSecurityRequest::setBackupId(const std::string& backupId)
{
backupId_ = backupId;
setParameter("BackupId", backupId);
}
std::string DescribeBackupsForSecurityRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeBackupsForSecurityRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeBackupsForSecurityRequest::getEndTime()const
{
return endTime_;
}
void DescribeBackupsForSecurityRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
std::string DescribeBackupsForSecurityRequest::getStartTime()const
{
return startTime_;
}
void DescribeBackupsForSecurityRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
long DescribeBackupsForSecurityRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeBackupsForSecurityRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
int DescribeBackupsForSecurityRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeBackupsForSecurityRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeBackupsForSecurityRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeBackupsForSecurityRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeBackupsForSecurityRequest::getBackupStatus()const
{
return backupStatus_;
}
void DescribeBackupsForSecurityRequest::setBackupStatus(const std::string& backupStatus)
{
backupStatus_ = backupStatus;
setParameter("BackupStatus", backupStatus);
}
std::string DescribeBackupsForSecurityRequest::getBackupLocation()const
{
return backupLocation_;
}
void DescribeBackupsForSecurityRequest::setBackupLocation(const std::string& backupLocation)
{
backupLocation_ = backupLocation;
setParameter("BackupLocation", backupLocation);
}
std::string DescribeBackupsForSecurityRequest::getTargetAliUid()const
{
return targetAliUid_;
}
void DescribeBackupsForSecurityRequest::setTargetAliUid(const std::string& targetAliUid)
{
targetAliUid_ = targetAliUid;
setParameter("TargetAliUid", targetAliUid);
}
int DescribeBackupsForSecurityRequest::getPageSize()const
{
return pageSize_;
}
void DescribeBackupsForSecurityRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeBackupsForSecurityRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeBackupsForSecurityRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string DescribeBackupsForSecurityRequest::getBackupMode()const
{
return backupMode_;
}
void DescribeBackupsForSecurityRequest::setBackupMode(const std::string& backupMode)
{
backupMode_ = backupMode;
setParameter("BackupMode", backupMode);
}

143
rds/src/model/DescribeBackupsForSecurityResult.cc
View File

@@ -40,74 +40,81 @@ void DescribeBackupsForSecurityResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["Backup"];
for (auto value : allItems)
{
Backup backupObject;
backupObject.backupId = value["BackupId"].asString();
backupObject.dBInstanceId = value["DBInstanceId"].asString();
backupObject.backupStatus = value["BackupStatus"].asString();
backupObject.backupStartTime = value["BackupStartTime"].asString();
backupObject.backupEndTime = value["BackupEndTime"].asString();
backupObject.backupType = value["BackupType"].asString();
backupObject.backupMode = value["BackupMode"].asString();
backupObject.backupMethod = value["BackupMethod"].asString();
backupObject.backupDownloadURL = value["BackupDownloadURL"].asString();
backupObject.backupIntranetDownloadURL = value["BackupIntranetDownloadURL"].asString();
backupObject.backupLocation = value["BackupLocation"].asString();
backupObject.backupExtractionStatus = value["BackupExtractionStatus"].asString();
backupObject.backupScale = value["BackupScale"].asString();
backupObject.backupDBNames = value["BackupDBNames"].asString();
backupObject.totalBackupSize = std::stol(value["TotalBackupSize"].asString());
backupObject.backupSize = std::stol(value["BackupSize"].asString());
backupObject.hostInstanceID = value["HostInstanceID"].asString();
backupObject.storeStatus = value["StoreStatus"].asString();
items_.push_back(backupObject);
}
totalRecordCount_ = value["TotalRecordCount"].asString();
pageNumber_ = value["PageNumber"].asString();
pageRecordCount_ = value["PageRecordCount"].asString();
totalBackupSize_ = std::stol(value["TotalBackupSize"].asString());
auto allItems = value["Items"]["Backup"];
for (auto value : allItems)
{
Backup itemsObject;
if(!value["BackupId"].isNull())
itemsObject.backupId = value["BackupId"].asString();
if(!value["DBInstanceId"].isNull())
itemsObject.dBInstanceId = value["DBInstanceId"].asString();
if(!value["BackupStatus"].isNull())
itemsObject.backupStatus = value["BackupStatus"].asString();
if(!value["BackupStartTime"].isNull())
itemsObject.backupStartTime = value["BackupStartTime"].asString();
if(!value["BackupEndTime"].isNull())
itemsObject.backupEndTime = value["BackupEndTime"].asString();
if(!value["BackupType"].isNull())
itemsObject.backupType = value["BackupType"].asString();
if(!value["BackupMode"].isNull())
itemsObject.backupMode = value["BackupMode"].asString();
if(!value["BackupMethod"].isNull())
itemsObject.backupMethod = value["BackupMethod"].asString();
if(!value["BackupDownloadURL"].isNull())
itemsObject.backupDownloadURL = value["BackupDownloadURL"].asString();
if(!value["BackupIntranetDownloadURL"].isNull())
itemsObject.backupIntranetDownloadURL = value["BackupIntranetDownloadURL"].asString();
if(!value["BackupLocation"].isNull())
itemsObject.backupLocation = value["BackupLocation"].asString();
if(!value["BackupExtractionStatus"].isNull())
itemsObject.backupExtractionStatus = value["BackupExtractionStatus"].asString();
if(!value["BackupScale"].isNull())
itemsObject.backupScale = value["BackupScale"].asString();
if(!value["BackupDBNames"].isNull())
itemsObject.backupDBNames = value["BackupDBNames"].asString();
if(!value["TotalBackupSize"].isNull())
itemsObject.totalBackupSize = std::stol(value["TotalBackupSize"].asString());
if(!value["BackupSize"].isNull())
itemsObject.backupSize = std::stol(value["BackupSize"].asString());
if(!value["HostInstanceID"].isNull())
itemsObject.hostInstanceID = value["HostInstanceID"].asString();
if(!value["StoreStatus"].isNull())
itemsObject.storeStatus = value["StoreStatus"].asString();
items_.push_back(itemsObject);
}
if(!value["TotalRecordCount"].isNull())
totalRecordCount_ = value["TotalRecordCount"].asString();
if(!value["PageNumber"].isNull())
pageNumber_ = value["PageNumber"].asString();
if(!value["PageRecordCount"].isNull())
pageRecordCount_ = value["PageRecordCount"].asString();
if(!value["TotalBackupSize"].isNull())
totalBackupSize_ = std::stol(value["TotalBackupSize"].asString());
}
std::string DescribeBackupsForSecurityResult::getTotalRecordCount()const
{
return totalRecordCount_;
}
void DescribeBackupsForSecurityResult::setTotalRecordCount(const std::string& totalRecordCount)
{
totalRecordCount_ = totalRecordCount;
}
std::string DescribeBackupsForSecurityResult::getPageRecordCount()const
{
return pageRecordCount_;
}
void DescribeBackupsForSecurityResult::setPageRecordCount(const std::string& pageRecordCount)
{
pageRecordCount_ = pageRecordCount;
}
std::string DescribeBackupsForSecurityResult::getPageNumber()const
{
return pageNumber_;
}
void DescribeBackupsForSecurityResult::setPageNumber(const std::string& pageNumber)
{
pageNumber_ = pageNumber;
}
long DescribeBackupsForSecurityResult::getTotalBackupSize()const
{
return totalBackupSize_;
}
void DescribeBackupsForSecurityResult::setTotalBackupSize(long totalBackupSize)
{
totalBackupSize_ = totalBackupSize;
}
std::string DescribeBackupsForSecurityResult::getTotalRecordCount()const
{
return totalRecordCount_;
}
std::string DescribeBackupsForSecurityResult::getPageRecordCount()const
{
return pageRecordCount_;
}
std::string DescribeBackupsForSecurityResult::getPageNumber()const
{
return pageNumber_;
}
std::vector<DescribeBackupsForSecurityResult::Backup> DescribeBackupsForSecurityResult::getItems()const
{
return items_;
}
long DescribeBackupsForSecurityResult::getTotalBackupSize()const
{
return totalBackupSize_;
}

313
rds/src/model/DescribeBackupsRequest.cc
View File

@@ -16,167 +16,166 @@
#include <alibabacloud/rds/model/DescribeBackupsRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeBackupsRequest;
DescribeBackupsRequest::DescribeBackupsRequest() :
RdsRequest("DescribeBackups")
RpcServiceRequest("rds", "2014-08-15", "DescribeBackups")
{}
DescribeBackupsRequest::~DescribeBackupsRequest()
{}
long DescribeBackupsRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeBackupsRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeBackupsRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeBackupsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeBackupsRequest::getBackupId()const
{
return backupId_;
}
void DescribeBackupsRequest::setBackupId(const std::string& backupId)
{
backupId_ = backupId;
setParameter("BackupId", backupId);
}
std::string DescribeBackupsRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeBackupsRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeBackupsRequest::getEndTime()const
{
return endTime_;
}
void DescribeBackupsRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
std::string DescribeBackupsRequest::getStartTime()const
{
return startTime_;
}
void DescribeBackupsRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
long DescribeBackupsRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeBackupsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
int DescribeBackupsRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeBackupsRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeBackupsRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeBackupsRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeBackupsRequest::getBackupStatus()const
{
return backupStatus_;
}
void DescribeBackupsRequest::setBackupStatus(const std::string& backupStatus)
{
backupStatus_ = backupStatus;
setParameter("BackupStatus", backupStatus);
}
std::string DescribeBackupsRequest::getBackupLocation()const
{
return backupLocation_;
}
void DescribeBackupsRequest::setBackupLocation(const std::string& backupLocation)
{
backupLocation_ = backupLocation;
setParameter("BackupLocation", backupLocation);
}
int DescribeBackupsRequest::getPageSize()const
{
return pageSize_;
}
void DescribeBackupsRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeBackupsRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeBackupsRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string DescribeBackupsRequest::getBackupMode()const
{
return backupMode_;
}
void DescribeBackupsRequest::setBackupMode(const std::string& backupMode)
{
backupMode_ = backupMode;
setParameter("BackupMode", backupMode);
}
long DescribeBackupsRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeBackupsRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeBackupsRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeBackupsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeBackupsRequest::getBackupId()const
{
return backupId_;
}
void DescribeBackupsRequest::setBackupId(const std::string& backupId)
{
backupId_ = backupId;
setParameter("BackupId", backupId);
}
std::string DescribeBackupsRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeBackupsRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeBackupsRequest::getEndTime()const
{
return endTime_;
}
void DescribeBackupsRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
std::string DescribeBackupsRequest::getStartTime()const
{
return startTime_;
}
void DescribeBackupsRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
long DescribeBackupsRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeBackupsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
int DescribeBackupsRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeBackupsRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeBackupsRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeBackupsRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeBackupsRequest::getBackupStatus()const
{
return backupStatus_;
}
void DescribeBackupsRequest::setBackupStatus(const std::string& backupStatus)
{
backupStatus_ = backupStatus;
setParameter("BackupStatus", backupStatus);
}
std::string DescribeBackupsRequest::getBackupLocation()const
{
return backupLocation_;
}
void DescribeBackupsRequest::setBackupLocation(const std::string& backupLocation)
{
backupLocation_ = backupLocation;
setParameter("BackupLocation", backupLocation);
}
int DescribeBackupsRequest::getPageSize()const
{
return pageSize_;
}
void DescribeBackupsRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeBackupsRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeBackupsRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string DescribeBackupsRequest::getBackupMode()const
{
return backupMode_;
}
void DescribeBackupsRequest::setBackupMode(const std::string& backupMode)
{
backupMode_ = backupMode;
setParameter("BackupMode", backupMode);
}

143
rds/src/model/DescribeBackupsResult.cc
View File

@@ -40,74 +40,81 @@ void DescribeBackupsResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["Backup"];
for (auto value : allItems)
{
Backup backupObject;
backupObject.backupId = value["BackupId"].asString();
backupObject.dBInstanceId = value["DBInstanceId"].asString();
backupObject.backupStatus = value["BackupStatus"].asString();
backupObject.backupStartTime = value["BackupStartTime"].asString();
backupObject.backupEndTime = value["BackupEndTime"].asString();
backupObject.backupType = value["BackupType"].asString();
backupObject.backupMode = value["BackupMode"].asString();
backupObject.backupMethod = value["BackupMethod"].asString();
backupObject.backupDownloadURL = value["BackupDownloadURL"].asString();
backupObject.backupIntranetDownloadURL = value["BackupIntranetDownloadURL"].asString();
backupObject.backupLocation = value["BackupLocation"].asString();
backupObject.backupExtractionStatus = value["BackupExtractionStatus"].asString();
backupObject.backupScale = value["BackupScale"].asString();
backupObject.backupDBNames = value["BackupDBNames"].asString();
backupObject.totalBackupSize = std::stol(value["TotalBackupSize"].asString());
backupObject.backupSize = std::stol(value["BackupSize"].asString());
backupObject.hostInstanceID = value["HostInstanceID"].asString();
backupObject.storeStatus = value["StoreStatus"].asString();
items_.push_back(backupObject);
}
totalRecordCount_ = value["TotalRecordCount"].asString();
pageNumber_ = value["PageNumber"].asString();
pageRecordCount_ = value["PageRecordCount"].asString();
totalBackupSize_ = std::stol(value["TotalBackupSize"].asString());
auto allItems = value["Items"]["Backup"];
for (auto value : allItems)
{
Backup itemsObject;
if(!value["BackupId"].isNull())
itemsObject.backupId = value["BackupId"].asString();
if(!value["DBInstanceId"].isNull())
itemsObject.dBInstanceId = value["DBInstanceId"].asString();
if(!value["BackupStatus"].isNull())
itemsObject.backupStatus = value["BackupStatus"].asString();
if(!value["BackupStartTime"].isNull())
itemsObject.backupStartTime = value["BackupStartTime"].asString();
if(!value["BackupEndTime"].isNull())
itemsObject.backupEndTime = value["BackupEndTime"].asString();
if(!value["BackupType"].isNull())
itemsObject.backupType = value["BackupType"].asString();
if(!value["BackupMode"].isNull())
itemsObject.backupMode = value["BackupMode"].asString();
if(!value["BackupMethod"].isNull())
itemsObject.backupMethod = value["BackupMethod"].asString();
if(!value["BackupDownloadURL"].isNull())
itemsObject.backupDownloadURL = value["BackupDownloadURL"].asString();
if(!value["BackupIntranetDownloadURL"].isNull())
itemsObject.backupIntranetDownloadURL = value["BackupIntranetDownloadURL"].asString();
if(!value["BackupLocation"].isNull())
itemsObject.backupLocation = value["BackupLocation"].asString();
if(!value["BackupExtractionStatus"].isNull())
itemsObject.backupExtractionStatus = value["BackupExtractionStatus"].asString();
if(!value["BackupScale"].isNull())
itemsObject.backupScale = value["BackupScale"].asString();
if(!value["BackupDBNames"].isNull())
itemsObject.backupDBNames = value["BackupDBNames"].asString();
if(!value["TotalBackupSize"].isNull())
itemsObject.totalBackupSize = std::stol(value["TotalBackupSize"].asString());
if(!value["BackupSize"].isNull())
itemsObject.backupSize = std::stol(value["BackupSize"].asString());
if(!value["HostInstanceID"].isNull())
itemsObject.hostInstanceID = value["HostInstanceID"].asString();
if(!value["StoreStatus"].isNull())
itemsObject.storeStatus = value["StoreStatus"].asString();
items_.push_back(itemsObject);
}
if(!value["TotalRecordCount"].isNull())
totalRecordCount_ = value["TotalRecordCount"].asString();
if(!value["PageNumber"].isNull())
pageNumber_ = value["PageNumber"].asString();
if(!value["PageRecordCount"].isNull())
pageRecordCount_ = value["PageRecordCount"].asString();
if(!value["TotalBackupSize"].isNull())
totalBackupSize_ = std::stol(value["TotalBackupSize"].asString());
}
std::string DescribeBackupsResult::getTotalRecordCount()const
{
return totalRecordCount_;
}
void DescribeBackupsResult::setTotalRecordCount(const std::string& totalRecordCount)
{
totalRecordCount_ = totalRecordCount;
}
std::string DescribeBackupsResult::getPageRecordCount()const
{
return pageRecordCount_;
}
void DescribeBackupsResult::setPageRecordCount(const std::string& pageRecordCount)
{
pageRecordCount_ = pageRecordCount;
}
std::string DescribeBackupsResult::getPageNumber()const
{
return pageNumber_;
}
void DescribeBackupsResult::setPageNumber(const std::string& pageNumber)
{
pageNumber_ = pageNumber;
}
long DescribeBackupsResult::getTotalBackupSize()const
{
return totalBackupSize_;
}
void DescribeBackupsResult::setTotalBackupSize(long totalBackupSize)
{
totalBackupSize_ = totalBackupSize;
}
std::string DescribeBackupsResult::getTotalRecordCount()const
{
return totalRecordCount_;
}
std::string DescribeBackupsResult::getPageRecordCount()const
{
return pageRecordCount_;
}
std::string DescribeBackupsResult::getPageNumber()const
{
return pageNumber_;
}
std::vector<DescribeBackupsResult::Backup> DescribeBackupsResult::getItems()const
{
return items_;
}
long DescribeBackupsResult::getTotalBackupSize()const
{
return totalBackupSize_;
}

225
rds/src/model/DescribeBinlogFilesRequest.cc
View File

@@ -16,123 +16,122 @@
#include <alibabacloud/rds/model/DescribeBinlogFilesRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeBinlogFilesRequest;
DescribeBinlogFilesRequest::DescribeBinlogFilesRequest() :
RdsRequest("DescribeBinlogFiles")
RpcServiceRequest("rds", "2014-08-15", "DescribeBinlogFiles")
{}
DescribeBinlogFilesRequest::~DescribeBinlogFilesRequest()
{}
long DescribeBinlogFilesRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeBinlogFilesRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeBinlogFilesRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeBinlogFilesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeBinlogFilesRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeBinlogFilesRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
int DescribeBinlogFilesRequest::getPageSize()const
{
return pageSize_;
}
void DescribeBinlogFilesRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeBinlogFilesRequest::getEndTime()const
{
return endTime_;
}
void DescribeBinlogFilesRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
std::string DescribeBinlogFilesRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeBinlogFilesRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string DescribeBinlogFilesRequest::getStartTime()const
{
return startTime_;
}
void DescribeBinlogFilesRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
long DescribeBinlogFilesRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeBinlogFilesRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
int DescribeBinlogFilesRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeBinlogFilesRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeBinlogFilesRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeBinlogFilesRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long DescribeBinlogFilesRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeBinlogFilesRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeBinlogFilesRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeBinlogFilesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeBinlogFilesRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeBinlogFilesRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
int DescribeBinlogFilesRequest::getPageSize()const
{
return pageSize_;
}
void DescribeBinlogFilesRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeBinlogFilesRequest::getEndTime()const
{
return endTime_;
}
void DescribeBinlogFilesRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
std::string DescribeBinlogFilesRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeBinlogFilesRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string DescribeBinlogFilesRequest::getStartTime()const
{
return startTime_;
}
void DescribeBinlogFilesRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
long DescribeBinlogFilesRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeBinlogFilesRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
int DescribeBinlogFilesRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeBinlogFilesRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeBinlogFilesRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeBinlogFilesRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

113
rds/src/model/DescribeBinlogFilesResult.cc
View File

@@ -40,64 +40,61 @@ void DescribeBinlogFilesResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["BinLogFile"];
for (auto value : allItems)
{
BinLogFile binLogFileObject;
binLogFileObject.fileSize = std::stol(value["FileSize"].asString());
binLogFileObject.logBeginTime = value["LogBeginTime"].asString();
binLogFileObject.logEndTime = value["LogEndTime"].asString();
binLogFileObject.downloadLink = value["DownloadLink"].asString();
binLogFileObject.intranetDownloadLink = value["IntranetDownloadLink"].asString();
binLogFileObject.linkExpiredTime = value["LinkExpiredTime"].asString();
binLogFileObject.checksum = value["Checksum"].asString();
binLogFileObject.hostInstanceID = value["HostInstanceID"].asString();
items_.push_back(binLogFileObject);
}
totalRecordCount_ = std::stoi(value["TotalRecordCount"].asString());
pageNumber_ = std::stoi(value["PageNumber"].asString());
pageRecordCount_ = std::stoi(value["PageRecordCount"].asString());
totalFileSize_ = std::stol(value["TotalFileSize"].asString());
auto allItems = value["Items"]["BinLogFile"];
for (auto value : allItems)
{
BinLogFile itemsObject;
if(!value["FileSize"].isNull())
itemsObject.fileSize = std::stol(value["FileSize"].asString());
if(!value["LogBeginTime"].isNull())
itemsObject.logBeginTime = value["LogBeginTime"].asString();
if(!value["LogEndTime"].isNull())
itemsObject.logEndTime = value["LogEndTime"].asString();
if(!value["DownloadLink"].isNull())
itemsObject.downloadLink = value["DownloadLink"].asString();
if(!value["IntranetDownloadLink"].isNull())
itemsObject.intranetDownloadLink = value["IntranetDownloadLink"].asString();
if(!value["LinkExpiredTime"].isNull())
itemsObject.linkExpiredTime = value["LinkExpiredTime"].asString();
if(!value["Checksum"].isNull())
itemsObject.checksum = value["Checksum"].asString();
if(!value["HostInstanceID"].isNull())
itemsObject.hostInstanceID = value["HostInstanceID"].asString();
items_.push_back(itemsObject);
}
if(!value["TotalRecordCount"].isNull())
totalRecordCount_ = std::stoi(value["TotalRecordCount"].asString());
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageRecordCount"].isNull())
pageRecordCount_ = std::stoi(value["PageRecordCount"].asString());
if(!value["TotalFileSize"].isNull())
totalFileSize_ = std::stol(value["TotalFileSize"].asString());
}
int DescribeBinlogFilesResult::getTotalRecordCount()const
{
return totalRecordCount_;
}
void DescribeBinlogFilesResult::setTotalRecordCount(int totalRecordCount)
{
totalRecordCount_ = totalRecordCount;
}
int DescribeBinlogFilesResult::getPageRecordCount()const
{
return pageRecordCount_;
}
void DescribeBinlogFilesResult::setPageRecordCount(int pageRecordCount)
{
pageRecordCount_ = pageRecordCount;
}
int DescribeBinlogFilesResult::getPageNumber()const
{
return pageNumber_;
}
void DescribeBinlogFilesResult::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
}
long DescribeBinlogFilesResult::getTotalFileSize()const
{
return totalFileSize_;
}
void DescribeBinlogFilesResult::setTotalFileSize(long totalFileSize)
{
totalFileSize_ = totalFileSize;
}
int DescribeBinlogFilesResult::getTotalRecordCount()const
{
return totalRecordCount_;
}
int DescribeBinlogFilesResult::getPageRecordCount()const
{
return pageRecordCount_;
}
int DescribeBinlogFilesResult::getPageNumber()const
{
return pageNumber_;
}
std::vector<DescribeBinlogFilesResult::BinLogFile> DescribeBinlogFilesResult::getItems()const
{
return items_;
}
long DescribeBinlogFilesResult::getTotalFileSize()const
{
return totalFileSize_;
}

159
rds/src/model/DescribeCharacterSetNameRequest.cc
View File

@@ -16,90 +16,89 @@
#include <alibabacloud/rds/model/DescribeCharacterSetNameRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeCharacterSetNameRequest;
DescribeCharacterSetNameRequest::DescribeCharacterSetNameRequest() :
RdsRequest("DescribeCharacterSetName")
RpcServiceRequest("rds", "2014-08-15", "DescribeCharacterSetName")
{}
DescribeCharacterSetNameRequest::~DescribeCharacterSetNameRequest()
{}
long DescribeCharacterSetNameRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeCharacterSetNameRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeCharacterSetNameRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeCharacterSetNameRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeCharacterSetNameRequest::getEngine()const
{
return engine_;
}
void DescribeCharacterSetNameRequest::setEngine(const std::string& engine)
{
engine_ = engine;
setParameter("Engine", engine);
}
std::string DescribeCharacterSetNameRequest::getRegionId()const
{
return regionId_;
}
void DescribeCharacterSetNameRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribeCharacterSetNameRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeCharacterSetNameRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DescribeCharacterSetNameRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeCharacterSetNameRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeCharacterSetNameRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeCharacterSetNameRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long DescribeCharacterSetNameRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeCharacterSetNameRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeCharacterSetNameRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeCharacterSetNameRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeCharacterSetNameRequest::getEngine()const
{
return engine_;
}
void DescribeCharacterSetNameRequest::setEngine(const std::string& engine)
{
engine_ = engine;
setParameter("Engine", engine);
}
std::string DescribeCharacterSetNameRequest::getRegionId()const
{
return regionId_;
}
void DescribeCharacterSetNameRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribeCharacterSetNameRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeCharacterSetNameRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DescribeCharacterSetNameRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeCharacterSetNameRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeCharacterSetNameRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeCharacterSetNameRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

39
rds/src/model/DescribeCharacterSetNameResult.cc
View File

@@ -40,30 +40,21 @@ void DescribeCharacterSetNameResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allCharacterSetNameItems = value["CharacterSetNameItems"]["CharacterSetName"];
for (const auto &item : allCharacterSetNameItems)
characterSetNameItems_.push_back(item.asString());
engine_ = value["Engine"].asString();
auto allCharacterSetNameItems = value["CharacterSetNameItems"]["CharacterSetName"];
for (const auto &item : allCharacterSetNameItems)
characterSetNameItems_.push_back(item.asString());
if(!value["Engine"].isNull())
engine_ = value["Engine"].asString();
}
std::vector<std::string> DescribeCharacterSetNameResult::getCharacterSetNameItems()const
{
return characterSetNameItems_;
}
void DescribeCharacterSetNameResult::setCharacterSetNameItems(const std::vector<std::string>& characterSetNameItems)
{
characterSetNameItems_ = characterSetNameItems;
}
std::string DescribeCharacterSetNameResult::getEngine()const
{
return engine_;
}
void DescribeCharacterSetNameResult::setEngine(const std::string& engine)
{
engine_ = engine;
}
std::vector<std::string> DescribeCharacterSetNameResult::getCharacterSetNameItems()const
{
return characterSetNameItems_;
}
std::string DescribeCharacterSetNameResult::getEngine()const
{
return engine_;
}

159
rds/src/model/DescribeDBInstanceAttributeRequest.cc
View File

@@ -16,90 +16,89 @@
#include <alibabacloud/rds/model/DescribeDBInstanceAttributeRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeDBInstanceAttributeRequest;
DescribeDBInstanceAttributeRequest::DescribeDBInstanceAttributeRequest() :
RdsRequest("DescribeDBInstanceAttribute")
RpcServiceRequest("rds", "2014-08-15", "DescribeDBInstanceAttribute")
{}
DescribeDBInstanceAttributeRequest::~DescribeDBInstanceAttributeRequest()
{}
std::string DescribeDBInstanceAttributeRequest::getResourceGroupId()const
{
return resourceGroupId_;
}
void DescribeDBInstanceAttributeRequest::setResourceGroupId(const std::string& resourceGroupId)
{
resourceGroupId_ = resourceGroupId;
setParameter("ResourceGroupId", resourceGroupId);
}
long DescribeDBInstanceAttributeRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstanceAttributeRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstanceAttributeRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstanceAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstanceAttributeRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDBInstanceAttributeRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeDBInstanceAttributeRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceAttributeRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstanceAttributeRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstanceAttributeRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstanceAttributeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeDBInstanceAttributeRequest::getResourceGroupId()const
{
return resourceGroupId_;
}
void DescribeDBInstanceAttributeRequest::setResourceGroupId(const std::string& resourceGroupId)
{
resourceGroupId_ = resourceGroupId;
setParameter("ResourceGroupId", resourceGroupId);
}
long DescribeDBInstanceAttributeRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstanceAttributeRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstanceAttributeRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstanceAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstanceAttributeRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDBInstanceAttributeRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeDBInstanceAttributeRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceAttributeRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstanceAttributeRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstanceAttributeRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstanceAttributeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

196
rds/src/model/DescribeDBInstanceAttributeResult.cc
View File

@@ -40,73 +40,135 @@ void DescribeDBInstanceAttributeResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["DBInstanceAttribute"];
for (auto value : allItems)
{
DBInstanceAttribute dBInstanceAttributeObject;
dBInstanceAttributeObject.dBInstanceDiskUsed = value["DBInstanceDiskUsed"].asString();
dBInstanceAttributeObject.guardDBInstanceName = value["GuardDBInstanceName"].asString();
dBInstanceAttributeObject.canTempUpgrade = std::stoi(value["CanTempUpgrade"].asString());
dBInstanceAttributeObject.tempUpgradeTimeStart = value["TempUpgradeTimeStart"].asString();
dBInstanceAttributeObject.tempUpgradeTimeEnd = value["TempUpgradeTimeEnd"].asString();
dBInstanceAttributeObject.tempUpgradeRecoveryTime = value["TempUpgradeRecoveryTime"].asString();
dBInstanceAttributeObject.tempUpgradeRecoveryClass = value["TempUpgradeRecoveryClass"].asString();
dBInstanceAttributeObject.tempUpgradeRecoveryCpu = std::stoi(value["TempUpgradeRecoveryCpu"].asString());
dBInstanceAttributeObject.tempUpgradeRecoveryMemory = std::stoi(value["TempUpgradeRecoveryMemory"].asString());
dBInstanceAttributeObject.tempUpgradeRecoveryMaxIOPS = value["TempUpgradeRecoveryMaxIOPS"].asString();
dBInstanceAttributeObject.tempUpgradeRecoveryMaxConnections = value["TempUpgradeRecoveryMaxConnections"].asString();
dBInstanceAttributeObject.insId = std::stoi(value["InsId"].asString());
dBInstanceAttributeObject.dBInstanceId = value["DBInstanceId"].asString();
dBInstanceAttributeObject.payType = value["PayType"].asString();
dBInstanceAttributeObject.dBInstanceClassType = value["DBInstanceClassType"].asString();
dBInstanceAttributeObject.dBInstanceType = value["DBInstanceType"].asString();
dBInstanceAttributeObject.regionId = value["RegionId"].asString();
dBInstanceAttributeObject.connectionString = value["ConnectionString"].asString();
dBInstanceAttributeObject.port = value["Port"].asString();
dBInstanceAttributeObject.engine = value["Engine"].asString();
dBInstanceAttributeObject.engineVersion = value["EngineVersion"].asString();
dBInstanceAttributeObject.dBInstanceClass = value["DBInstanceClass"].asString();
dBInstanceAttributeObject.dBInstanceMemory = std::stol(value["DBInstanceMemory"].asString());
dBInstanceAttributeObject.dBInstanceStorage = std::stoi(value["DBInstanceStorage"].asString());
dBInstanceAttributeObject.dBInstanceNetType = value["DBInstanceNetType"].asString();
dBInstanceAttributeObject.dBInstanceStatus = value["DBInstanceStatus"].asString();
dBInstanceAttributeObject.dBInstanceDescription = value["DBInstanceDescription"].asString();
dBInstanceAttributeObject.lockMode = value["LockMode"].asString();
dBInstanceAttributeObject.lockReason = value["LockReason"].asString();
dBInstanceAttributeObject.readDelayTime = value["ReadDelayTime"].asString();
dBInstanceAttributeObject.dBMaxQuantity = std::stoi(value["DBMaxQuantity"].asString());
dBInstanceAttributeObject.accountMaxQuantity = std::stoi(value["AccountMaxQuantity"].asString());
dBInstanceAttributeObject.creationTime = value["CreationTime"].asString();
dBInstanceAttributeObject.expireTime = value["ExpireTime"].asString();
dBInstanceAttributeObject.maintainTime = value["MaintainTime"].asString();
dBInstanceAttributeObject.availabilityValue = value["AvailabilityValue"].asString();
dBInstanceAttributeObject.maxIOPS = std::stoi(value["MaxIOPS"].asString());
dBInstanceAttributeObject.maxConnections = std::stoi(value["MaxConnections"].asString());
dBInstanceAttributeObject.masterInstanceId = value["MasterInstanceId"].asString();
dBInstanceAttributeObject.dBInstanceCPU = value["DBInstanceCPU"].asString();
dBInstanceAttributeObject.incrementSourceDBInstanceId = value["IncrementSourceDBInstanceId"].asString();
dBInstanceAttributeObject.guardDBInstanceId = value["GuardDBInstanceId"].asString();
dBInstanceAttributeObject.replicateId = value["ReplicateId"].asString();
dBInstanceAttributeObject.tempDBInstanceId = value["TempDBInstanceId"].asString();
dBInstanceAttributeObject.securityIPList = value["SecurityIPList"].asString();
dBInstanceAttributeObject.zoneId = value["ZoneId"].asString();
dBInstanceAttributeObject.instanceNetworkType = value["InstanceNetworkType"].asString();
dBInstanceAttributeObject.category = value["Category"].asString();
dBInstanceAttributeObject.accountType = value["AccountType"].asString();
dBInstanceAttributeObject.supportUpgradeAccountType = value["SupportUpgradeAccountType"].asString();
dBInstanceAttributeObject.vpcId = value["VpcId"].asString();
dBInstanceAttributeObject.vSwitchId = value["VSwitchId"].asString();
dBInstanceAttributeObject.connectionMode = value["ConnectionMode"].asString();
dBInstanceAttributeObject.resourceGroupId = value["ResourceGroupId"].asString();
auto allReadOnlyDBInstanceIds = value["ReadOnlyDBInstanceIds"]["ReadOnlyDBInstanceId"];
for (auto value : allReadOnlyDBInstanceIds)
{
DBInstanceAttribute::ReadOnlyDBInstanceId readOnlyDBInstanceIdObject;
readOnlyDBInstanceIdObject.dBInstanceId = value["DBInstanceId"].asString();
dBInstanceAttributeObject.readOnlyDBInstanceIds.push_back(readOnlyDBInstanceIdObject);
}
items_.push_back(dBInstanceAttributeObject);
}
auto allItems = value["Items"]["DBInstanceAttribute"];
for (auto value : allItems)
{
DBInstanceAttribute itemsObject;
if(!value["DBInstanceDiskUsed"].isNull())
itemsObject.dBInstanceDiskUsed = value["DBInstanceDiskUsed"].asString();
if(!value["GuardDBInstanceName"].isNull())
itemsObject.guardDBInstanceName = value["GuardDBInstanceName"].asString();
if(!value["CanTempUpgrade"].isNull())
itemsObject.canTempUpgrade = value["CanTempUpgrade"].asString() == "true";
if(!value["TempUpgradeTimeStart"].isNull())
itemsObject.tempUpgradeTimeStart = value["TempUpgradeTimeStart"].asString();
if(!value["TempUpgradeTimeEnd"].isNull())
itemsObject.tempUpgradeTimeEnd = value["TempUpgradeTimeEnd"].asString();
if(!value["TempUpgradeRecoveryTime"].isNull())
itemsObject.tempUpgradeRecoveryTime = value["TempUpgradeRecoveryTime"].asString();
if(!value["TempUpgradeRecoveryClass"].isNull())
itemsObject.tempUpgradeRecoveryClass = value["TempUpgradeRecoveryClass"].asString();
if(!value["TempUpgradeRecoveryCpu"].isNull())
itemsObject.tempUpgradeRecoveryCpu = std::stoi(value["TempUpgradeRecoveryCpu"].asString());
if(!value["TempUpgradeRecoveryMemory"].isNull())
itemsObject.tempUpgradeRecoveryMemory = std::stoi(value["TempUpgradeRecoveryMemory"].asString());
if(!value["TempUpgradeRecoveryMaxIOPS"].isNull())
itemsObject.tempUpgradeRecoveryMaxIOPS = value["TempUpgradeRecoveryMaxIOPS"].asString();
if(!value["TempUpgradeRecoveryMaxConnections"].isNull())
itemsObject.tempUpgradeRecoveryMaxConnections = value["TempUpgradeRecoveryMaxConnections"].asString();
if(!value["InsId"].isNull())
itemsObject.insId = std::stoi(value["InsId"].asString());
if(!value["DBInstanceId"].isNull())
itemsObject.dBInstanceId = value["DBInstanceId"].asString();
if(!value["PayType"].isNull())
itemsObject.payType = value["PayType"].asString();
if(!value["DBInstanceClassType"].isNull())
itemsObject.dBInstanceClassType = value["DBInstanceClassType"].asString();
if(!value["DBInstanceType"].isNull())
itemsObject.dBInstanceType = value["DBInstanceType"].asString();
if(!value["RegionId"].isNull())
itemsObject.regionId = value["RegionId"].asString();
if(!value["ConnectionString"].isNull())
itemsObject.connectionString = value["ConnectionString"].asString();
if(!value["Port"].isNull())
itemsObject.port = value["Port"].asString();
if(!value["Engine"].isNull())
itemsObject.engine = value["Engine"].asString();
if(!value["EngineVersion"].isNull())
itemsObject.engineVersion = value["EngineVersion"].asString();
if(!value["DBInstanceClass"].isNull())
itemsObject.dBInstanceClass = value["DBInstanceClass"].asString();
if(!value["DBInstanceMemory"].isNull())
itemsObject.dBInstanceMemory = std::stol(value["DBInstanceMemory"].asString());
if(!value["DBInstanceStorage"].isNull())
itemsObject.dBInstanceStorage = std::stoi(value["DBInstanceStorage"].asString());
if(!value["DBInstanceNetType"].isNull())
itemsObject.dBInstanceNetType = value["DBInstanceNetType"].asString();
if(!value["DBInstanceStatus"].isNull())
itemsObject.dBInstanceStatus = value["DBInstanceStatus"].asString();
if(!value["DBInstanceDescription"].isNull())
itemsObject.dBInstanceDescription = value["DBInstanceDescription"].asString();
if(!value["LockMode"].isNull())
itemsObject.lockMode = value["LockMode"].asString();
if(!value["LockReason"].isNull())
itemsObject.lockReason = value["LockReason"].asString();
if(!value["ReadDelayTime"].isNull())
itemsObject.readDelayTime = value["ReadDelayTime"].asString();
if(!value["DBMaxQuantity"].isNull())
itemsObject.dBMaxQuantity = std::stoi(value["DBMaxQuantity"].asString());
if(!value["AccountMaxQuantity"].isNull())
itemsObject.accountMaxQuantity = std::stoi(value["AccountMaxQuantity"].asString());
if(!value["CreationTime"].isNull())
itemsObject.creationTime = value["CreationTime"].asString();
if(!value["ExpireTime"].isNull())
itemsObject.expireTime = value["ExpireTime"].asString();
if(!value["MaintainTime"].isNull())
itemsObject.maintainTime = value["MaintainTime"].asString();
if(!value["AvailabilityValue"].isNull())
itemsObject.availabilityValue = value["AvailabilityValue"].asString();
if(!value["MaxIOPS"].isNull())
itemsObject.maxIOPS = std::stoi(value["MaxIOPS"].asString());
if(!value["MaxConnections"].isNull())
itemsObject.maxConnections = std::stoi(value["MaxConnections"].asString());
if(!value["MasterInstanceId"].isNull())
itemsObject.masterInstanceId = value["MasterInstanceId"].asString();
if(!value["DBInstanceCPU"].isNull())
itemsObject.dBInstanceCPU = value["DBInstanceCPU"].asString();
if(!value["IncrementSourceDBInstanceId"].isNull())
itemsObject.incrementSourceDBInstanceId = value["IncrementSourceDBInstanceId"].asString();
if(!value["GuardDBInstanceId"].isNull())
itemsObject.guardDBInstanceId = value["GuardDBInstanceId"].asString();
if(!value["ReplicateId"].isNull())
itemsObject.replicateId = value["ReplicateId"].asString();
if(!value["TempDBInstanceId"].isNull())
itemsObject.tempDBInstanceId = value["TempDBInstanceId"].asString();
if(!value["SecurityIPList"].isNull())
itemsObject.securityIPList = value["SecurityIPList"].asString();
if(!value["ZoneId"].isNull())
itemsObject.zoneId = value["ZoneId"].asString();
if(!value["InstanceNetworkType"].isNull())
itemsObject.instanceNetworkType = value["InstanceNetworkType"].asString();
if(!value["Category"].isNull())
itemsObject.category = value["Category"].asString();
if(!value["AccountType"].isNull())
itemsObject.accountType = value["AccountType"].asString();
if(!value["SupportUpgradeAccountType"].isNull())
itemsObject.supportUpgradeAccountType = value["SupportUpgradeAccountType"].asString();
if(!value["VpcId"].isNull())
itemsObject.vpcId = value["VpcId"].asString();
if(!value["VSwitchId"].isNull())
itemsObject.vSwitchId = value["VSwitchId"].asString();
if(!value["ConnectionMode"].isNull())
itemsObject.connectionMode = value["ConnectionMode"].asString();
if(!value["ResourceGroupId"].isNull())
itemsObject.resourceGroupId = value["ResourceGroupId"].asString();
if(!value["AdvancedFeatures"].isNull())
itemsObject.advancedFeatures = value["AdvancedFeatures"].asString();
auto allReadOnlyDBInstanceIds = value["ReadOnlyDBInstanceIds"]["ReadOnlyDBInstanceId"];
for (auto value : allReadOnlyDBInstanceIds)
{
DBInstanceAttribute::ReadOnlyDBInstanceId readOnlyDBInstanceIdsObject;
if(!value["DBInstanceId"].isNull())
readOnlyDBInstanceIdsObject.dBInstanceId = value["DBInstanceId"].asString();
itemsObject.readOnlyDBInstanceIds.push_back(readOnlyDBInstanceIdsObject);
}
items_.push_back(itemsObject);
}
}
std::vector<DescribeDBInstanceAttributeResult::DBInstanceAttribute> DescribeDBInstanceAttributeResult::getItems()const
{
return items_;
}

247
rds/src/model/DescribeDBInstanceByTagsRequest.cc
View File

@@ -16,134 +16,133 @@
#include <alibabacloud/rds/model/DescribeDBInstanceByTagsRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeDBInstanceByTagsRequest;
DescribeDBInstanceByTagsRequest::DescribeDBInstanceByTagsRequest() :
RdsRequest("DescribeDBInstanceByTags")
RpcServiceRequest("rds", "2014-08-15", "DescribeDBInstanceByTags")
{}
DescribeDBInstanceByTagsRequest::~DescribeDBInstanceByTagsRequest()
{}
long DescribeDBInstanceByTagsRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstanceByTagsRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstanceByTagsRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstanceByTagsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstanceByTagsRequest::getClientToken()const
{
return clientToken_;
}
void DescribeDBInstanceByTagsRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string DescribeDBInstanceByTagsRequest::getRegionId()const
{
return regionId_;
}
void DescribeDBInstanceByTagsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribeDBInstanceByTagsRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDBInstanceByTagsRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
int DescribeDBInstanceByTagsRequest::getPageSize()const
{
return pageSize_;
}
void DescribeDBInstanceByTagsRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeDBInstanceByTagsRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceByTagsRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstanceByTagsRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstanceByTagsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
int DescribeDBInstanceByTagsRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeDBInstanceByTagsRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeDBInstanceByTagsRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceByTagsRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeDBInstanceByTagsRequest::getProxyId()const
{
return proxyId_;
}
void DescribeDBInstanceByTagsRequest::setProxyId(const std::string& proxyId)
{
proxyId_ = proxyId;
setParameter("ProxyId", proxyId);
}
long DescribeDBInstanceByTagsRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstanceByTagsRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstanceByTagsRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstanceByTagsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstanceByTagsRequest::getClientToken()const
{
return clientToken_;
}
void DescribeDBInstanceByTagsRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string DescribeDBInstanceByTagsRequest::getRegionId()const
{
return regionId_;
}
void DescribeDBInstanceByTagsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribeDBInstanceByTagsRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDBInstanceByTagsRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
int DescribeDBInstanceByTagsRequest::getPageSize()const
{
return pageSize_;
}
void DescribeDBInstanceByTagsRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeDBInstanceByTagsRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceByTagsRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstanceByTagsRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstanceByTagsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
int DescribeDBInstanceByTagsRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeDBInstanceByTagsRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeDBInstanceByTagsRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceByTagsRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeDBInstanceByTagsRequest::getProxyId()const
{
return proxyId_;
}
void DescribeDBInstanceByTagsRequest::setProxyId(const std::string& proxyId)
{
proxyId_ = proxyId;
setParameter("ProxyId", proxyId);
}

92
rds/src/model/DescribeDBInstanceByTagsResult.cc
View File

@@ -40,54 +40,50 @@ void DescribeDBInstanceByTagsResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["DBInstanceTag"];
for (auto value : allItems)
{
DBInstanceTag dBInstanceTagObject;
dBInstanceTagObject.dBInstanceId = value["DBInstanceId"].asString();
auto allTags = value["Tags"]["Tag"];
for (auto value : allTags)
{
DBInstanceTag::Tag tagObject;
tagObject.tagKey = value["TagKey"].asString();
tagObject.tagValue = value["TagValue"].asString();
dBInstanceTagObject.tags.push_back(tagObject);
}
items_.push_back(dBInstanceTagObject);
}
pageNumber_ = std::stoi(value["PageNumber"].asString());
pageRecordCount_ = std::stoi(value["PageRecordCount"].asString());
totalRecordCount_ = std::stoi(value["TotalRecordCount"].asString());
auto allItems = value["Items"]["DBInstanceTag"];
for (auto value : allItems)
{
DBInstanceTag itemsObject;
if(!value["DBInstanceId"].isNull())
itemsObject.dBInstanceId = value["DBInstanceId"].asString();
auto allTags = value["Tags"]["Tag"];
for (auto value : allTags)
{
DBInstanceTag::Tag tagsObject;
if(!value["TagKey"].isNull())
tagsObject.tagKey = value["TagKey"].asString();
if(!value["TagValue"].isNull())
tagsObject.tagValue = value["TagValue"].asString();
itemsObject.tags.push_back(tagsObject);
}
items_.push_back(itemsObject);
}
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageRecordCount"].isNull())
pageRecordCount_ = std::stoi(value["PageRecordCount"].asString());
if(!value["TotalRecordCount"].isNull())
totalRecordCount_ = std::stoi(value["TotalRecordCount"].asString());
}
int DescribeDBInstanceByTagsResult::getTotalRecordCount()const
{
return totalRecordCount_;
}
void DescribeDBInstanceByTagsResult::setTotalRecordCount(int totalRecordCount)
{
totalRecordCount_ = totalRecordCount;
}
int DescribeDBInstanceByTagsResult::getPageRecordCount()const
{
return pageRecordCount_;
}
void DescribeDBInstanceByTagsResult::setPageRecordCount(int pageRecordCount)
{
pageRecordCount_ = pageRecordCount;
}
int DescribeDBInstanceByTagsResult::getPageNumber()const
{
return pageNumber_;
}
void DescribeDBInstanceByTagsResult::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
}
int DescribeDBInstanceByTagsResult::getTotalRecordCount()const
{
return totalRecordCount_;
}
int DescribeDBInstanceByTagsResult::getPageRecordCount()const
{
return pageRecordCount_;
}
int DescribeDBInstanceByTagsResult::getPageNumber()const
{
return pageNumber_;
}
std::vector<DescribeDBInstanceByTagsResult::DBInstanceTag> DescribeDBInstanceByTagsResult::getItems()const
{
return items_;
}

83
rds/src/model/DescribeDBInstanceECSSGRelationRequest.cc
View File

@@ -1,83 +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/DescribeDBInstanceECSSGRelationRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
DescribeDBInstanceECSSGRelationRequest::DescribeDBInstanceECSSGRelationRequest() :
RdsRequest("DescribeDBInstanceECSSGRelation")
{}
DescribeDBInstanceECSSGRelationRequest::~DescribeDBInstanceECSSGRelationRequest()
{}
long DescribeDBInstanceECSSGRelationRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstanceECSSGRelationRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstanceECSSGRelationRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstanceECSSGRelationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstanceECSSGRelationRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceECSSGRelationRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstanceECSSGRelationRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstanceECSSGRelationRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstanceECSSGRelationRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceECSSGRelationRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

65
rds/src/model/DescribeDBInstanceECSSGRelationResult.cc
View File

@@ -1,65 +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/DescribeDBInstanceECSSGRelationResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
DescribeDBInstanceECSSGRelationResult::DescribeDBInstanceECSSGRelationResult() :
ServiceResult()
{}
DescribeDBInstanceECSSGRelationResult::DescribeDBInstanceECSSGRelationResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeDBInstanceECSSGRelationResult::~DescribeDBInstanceECSSGRelationResult()
{}
void DescribeDBInstanceECSSGRelationResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["RdsEcsSecurityGroupRel"];
for (auto value : allItems)
{
RdsEcsSecurityGroupRel rdsEcsSecurityGroupRelObject;
rdsEcsSecurityGroupRelObject.regionId = value["RegionId"].asString();
rdsEcsSecurityGroupRelObject.securityGroupId = value["SecurityGroupId"].asString();
rdsEcsSecurityGroupRelObject.netType = value["NetType"].asString();
items_.push_back(rdsEcsSecurityGroupRelObject);
}
dBInstanceName_ = value["DBInstanceName"].asString();
}
std::string DescribeDBInstanceECSSGRelationResult::getDBInstanceName()const
{
return dBInstanceName_;
}
void DescribeDBInstanceECSSGRelationResult::setDBInstanceName(const std::string& dBInstanceName)
{
dBInstanceName_ = dBInstanceName;
}

115
rds/src/model/DescribeDBInstanceExtendAttributeRequest.cc
View File

@@ -16,68 +16,67 @@
#include <alibabacloud/rds/model/DescribeDBInstanceExtendAttributeRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeDBInstanceExtendAttributeRequest;
DescribeDBInstanceExtendAttributeRequest::DescribeDBInstanceExtendAttributeRequest() :
RdsRequest("DescribeDBInstanceExtendAttribute")
RpcServiceRequest("rds", "2014-08-15", "DescribeDBInstanceExtendAttribute")
{}
DescribeDBInstanceExtendAttributeRequest::~DescribeDBInstanceExtendAttributeRequest()
{}
long DescribeDBInstanceExtendAttributeRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstanceExtendAttributeRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstanceExtendAttributeRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstanceExtendAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstanceExtendAttributeRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceExtendAttributeRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstanceExtendAttributeRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstanceExtendAttributeRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstanceExtendAttributeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceExtendAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long DescribeDBInstanceExtendAttributeRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstanceExtendAttributeRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstanceExtendAttributeRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstanceExtendAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstanceExtendAttributeRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceExtendAttributeRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstanceExtendAttributeRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstanceExtendAttributeRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstanceExtendAttributeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceExtendAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

162
rds/src/model/DescribeDBInstanceExtendAttributeResult.cc
View File

@@ -40,105 +40,69 @@ void DescribeDBInstanceExtendAttributeResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
canTempUpgrade_ = std::stoi(value["CanTempUpgrade"].asString());
tempUpgradeTimeStart_ = value["TempUpgradeTimeStart"].asString();
tempUpgradeTimeEnd_ = value["TempUpgradeTimeEnd"].asString();
tempUpgradeRecoveryTime_ = value["TempUpgradeRecoveryTime"].asString();
tempUpgradeRecoveryClass_ = value["TempUpgradeRecoveryClass"].asString();
tempUpgradeRecoveryCpu_ = std::stoi(value["TempUpgradeRecoveryCpu"].asString());
tempUpgradeRecoveryMemory_ = std::stoi(value["TempUpgradeRecoveryMemory"].asString());
tempUpgradeRecoveryMaxIOPS_ = value["TempUpgradeRecoveryMaxIOPS"].asString();
tempUpgradeRecoveryMaxConnections_ = value["TempUpgradeRecoveryMaxConnections"].asString();
if(!value["CanTempUpgrade"].isNull())
canTempUpgrade_ = value["CanTempUpgrade"].asString() == "true";
if(!value["TempUpgradeTimeStart"].isNull())
tempUpgradeTimeStart_ = value["TempUpgradeTimeStart"].asString();
if(!value["TempUpgradeTimeEnd"].isNull())
tempUpgradeTimeEnd_ = value["TempUpgradeTimeEnd"].asString();
if(!value["TempUpgradeRecoveryTime"].isNull())
tempUpgradeRecoveryTime_ = value["TempUpgradeRecoveryTime"].asString();
if(!value["TempUpgradeRecoveryClass"].isNull())
tempUpgradeRecoveryClass_ = value["TempUpgradeRecoveryClass"].asString();
if(!value["TempUpgradeRecoveryCpu"].isNull())
tempUpgradeRecoveryCpu_ = std::stoi(value["TempUpgradeRecoveryCpu"].asString());
if(!value["TempUpgradeRecoveryMemory"].isNull())
tempUpgradeRecoveryMemory_ = std::stoi(value["TempUpgradeRecoveryMemory"].asString());
if(!value["TempUpgradeRecoveryMaxIOPS"].isNull())
tempUpgradeRecoveryMaxIOPS_ = value["TempUpgradeRecoveryMaxIOPS"].asString();
if(!value["TempUpgradeRecoveryMaxConnections"].isNull())
tempUpgradeRecoveryMaxConnections_ = value["TempUpgradeRecoveryMaxConnections"].asString();
}
std::string DescribeDBInstanceExtendAttributeResult::getTempUpgradeRecoveryMaxIOPS()const
{
return tempUpgradeRecoveryMaxIOPS_;
}
void DescribeDBInstanceExtendAttributeResult::setTempUpgradeRecoveryMaxIOPS(const std::string& tempUpgradeRecoveryMaxIOPS)
{
tempUpgradeRecoveryMaxIOPS_ = tempUpgradeRecoveryMaxIOPS;
}
int DescribeDBInstanceExtendAttributeResult::getTempUpgradeRecoveryMemory()const
{
return tempUpgradeRecoveryMemory_;
}
void DescribeDBInstanceExtendAttributeResult::setTempUpgradeRecoveryMemory(int tempUpgradeRecoveryMemory)
{
tempUpgradeRecoveryMemory_ = tempUpgradeRecoveryMemory;
}
std::string DescribeDBInstanceExtendAttributeResult::getTempUpgradeRecoveryTime()const
{
return tempUpgradeRecoveryTime_;
}
void DescribeDBInstanceExtendAttributeResult::setTempUpgradeRecoveryTime(const std::string& tempUpgradeRecoveryTime)
{
tempUpgradeRecoveryTime_ = tempUpgradeRecoveryTime;
}
std::string DescribeDBInstanceExtendAttributeResult::getTempUpgradeRecoveryMaxConnections()const
{
return tempUpgradeRecoveryMaxConnections_;
}
void DescribeDBInstanceExtendAttributeResult::setTempUpgradeRecoveryMaxConnections(const std::string& tempUpgradeRecoveryMaxConnections)
{
tempUpgradeRecoveryMaxConnections_ = tempUpgradeRecoveryMaxConnections;
}
int DescribeDBInstanceExtendAttributeResult::getTempUpgradeRecoveryCpu()const
{
return tempUpgradeRecoveryCpu_;
}
void DescribeDBInstanceExtendAttributeResult::setTempUpgradeRecoveryCpu(int tempUpgradeRecoveryCpu)
{
tempUpgradeRecoveryCpu_ = tempUpgradeRecoveryCpu;
}
std::string DescribeDBInstanceExtendAttributeResult::getTempUpgradeTimeStart()const
{
return tempUpgradeTimeStart_;
}
void DescribeDBInstanceExtendAttributeResult::setTempUpgradeTimeStart(const std::string& tempUpgradeTimeStart)
{
tempUpgradeTimeStart_ = tempUpgradeTimeStart;
}
std::string DescribeDBInstanceExtendAttributeResult::getTempUpgradeTimeEnd()const
{
return tempUpgradeTimeEnd_;
}
void DescribeDBInstanceExtendAttributeResult::setTempUpgradeTimeEnd(const std::string& tempUpgradeTimeEnd)
{
tempUpgradeTimeEnd_ = tempUpgradeTimeEnd;
}
bool DescribeDBInstanceExtendAttributeResult::getCanTempUpgrade()const
{
return canTempUpgrade_;
}
void DescribeDBInstanceExtendAttributeResult::setCanTempUpgrade(bool canTempUpgrade)
{
canTempUpgrade_ = canTempUpgrade;
}
std::string DescribeDBInstanceExtendAttributeResult::getTempUpgradeRecoveryClass()const
{
return tempUpgradeRecoveryClass_;
}
void DescribeDBInstanceExtendAttributeResult::setTempUpgradeRecoveryClass(const std::string& tempUpgradeRecoveryClass)
{
tempUpgradeRecoveryClass_ = tempUpgradeRecoveryClass;
}
std::string DescribeDBInstanceExtendAttributeResult::getTempUpgradeRecoveryMaxIOPS()const
{
return tempUpgradeRecoveryMaxIOPS_;
}
int DescribeDBInstanceExtendAttributeResult::getTempUpgradeRecoveryMemory()const
{
return tempUpgradeRecoveryMemory_;
}
std::string DescribeDBInstanceExtendAttributeResult::getTempUpgradeRecoveryTime()const
{
return tempUpgradeRecoveryTime_;
}
std::string DescribeDBInstanceExtendAttributeResult::getTempUpgradeRecoveryMaxConnections()const
{
return tempUpgradeRecoveryMaxConnections_;
}
int DescribeDBInstanceExtendAttributeResult::getTempUpgradeRecoveryCpu()const
{
return tempUpgradeRecoveryCpu_;
}
std::string DescribeDBInstanceExtendAttributeResult::getTempUpgradeTimeStart()const
{
return tempUpgradeTimeStart_;
}
std::string DescribeDBInstanceExtendAttributeResult::getTempUpgradeTimeEnd()const
{
return tempUpgradeTimeEnd_;
}
bool DescribeDBInstanceExtendAttributeResult::getCanTempUpgrade()const
{
return canTempUpgrade_;
}
std::string DescribeDBInstanceExtendAttributeResult::getTempUpgradeRecoveryClass()const
{
return tempUpgradeRecoveryClass_;
}

137
rds/src/model/DescribeDBInstanceHAConfigRequest.cc
View File

@@ -16,79 +16,78 @@
#include <alibabacloud/rds/model/DescribeDBInstanceHAConfigRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeDBInstanceHAConfigRequest;
DescribeDBInstanceHAConfigRequest::DescribeDBInstanceHAConfigRequest() :
RdsRequest("DescribeDBInstanceHAConfig")
RpcServiceRequest("rds", "2014-08-15", "DescribeDBInstanceHAConfig")
{}
DescribeDBInstanceHAConfigRequest::~DescribeDBInstanceHAConfigRequest()
{}
long DescribeDBInstanceHAConfigRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstanceHAConfigRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstanceHAConfigRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstanceHAConfigRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstanceHAConfigRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDBInstanceHAConfigRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeDBInstanceHAConfigRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceHAConfigRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstanceHAConfigRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstanceHAConfigRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstanceHAConfigRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceHAConfigRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long DescribeDBInstanceHAConfigRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstanceHAConfigRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstanceHAConfigRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstanceHAConfigRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstanceHAConfigRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDBInstanceHAConfigRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeDBInstanceHAConfigRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceHAConfigRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstanceHAConfigRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstanceHAConfigRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstanceHAConfigRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceHAConfigRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

92
rds/src/model/DescribeDBInstanceHAConfigResult.cc
View File

@@ -40,52 +40,52 @@ void DescribeDBInstanceHAConfigResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allHostInstanceInfos = value["HostInstanceInfos"]["NodeInfo"];
for (auto value : allHostInstanceInfos)
{
NodeInfo nodeInfoObject;
nodeInfoObject.nodeId = value["NodeId"].asString();
nodeInfoObject.regionId = value["RegionId"].asString();
nodeInfoObject.logSyncTime = value["LogSyncTime"].asString();
nodeInfoObject.dataSyncTime = value["DataSyncTime"].asString();
nodeInfoObject.nodeType = value["NodeType"].asString();
nodeInfoObject.zoneId = value["ZoneId"].asString();
nodeInfoObject.syncStatus = value["SyncStatus"].asString();
hostInstanceInfos_.push_back(nodeInfoObject);
}
dBInstanceId_ = value["DBInstanceId"].asString();
syncMode_ = value["SyncMode"].asString();
hAMode_ = value["HAMode"].asString();
auto allHostInstanceInfos = value["HostInstanceInfos"]["NodeInfo"];
for (auto value : allHostInstanceInfos)
{
NodeInfo hostInstanceInfosObject;
if(!value["NodeId"].isNull())
hostInstanceInfosObject.nodeId = value["NodeId"].asString();
if(!value["RegionId"].isNull())
hostInstanceInfosObject.regionId = value["RegionId"].asString();
if(!value["LogSyncTime"].isNull())
hostInstanceInfosObject.logSyncTime = value["LogSyncTime"].asString();
if(!value["DataSyncTime"].isNull())
hostInstanceInfosObject.dataSyncTime = value["DataSyncTime"].asString();
if(!value["NodeType"].isNull())
hostInstanceInfosObject.nodeType = value["NodeType"].asString();
if(!value["ZoneId"].isNull())
hostInstanceInfosObject.zoneId = value["ZoneId"].asString();
if(!value["SyncStatus"].isNull())
hostInstanceInfosObject.syncStatus = value["SyncStatus"].asString();
hostInstanceInfos_.push_back(hostInstanceInfosObject);
}
if(!value["DBInstanceId"].isNull())
dBInstanceId_ = value["DBInstanceId"].asString();
if(!value["SyncMode"].isNull())
syncMode_ = value["SyncMode"].asString();
if(!value["HAMode"].isNull())
hAMode_ = value["HAMode"].asString();
}
std::string DescribeDBInstanceHAConfigResult::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceHAConfigResult::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
}
std::string DescribeDBInstanceHAConfigResult::getHAMode()const
{
return hAMode_;
}
void DescribeDBInstanceHAConfigResult::setHAMode(const std::string& hAMode)
{
hAMode_ = hAMode;
}
std::string DescribeDBInstanceHAConfigResult::getSyncMode()const
{
return syncMode_;
}
void DescribeDBInstanceHAConfigResult::setSyncMode(const std::string& syncMode)
{
syncMode_ = syncMode;
}
std::string DescribeDBInstanceHAConfigResult::getDBInstanceId()const
{
return dBInstanceId_;
}
std::string DescribeDBInstanceHAConfigResult::getHAMode()const
{
return hAMode_;
}
std::vector<DescribeDBInstanceHAConfigResult::NodeInfo> DescribeDBInstanceHAConfigResult::getHostInstanceInfos()const
{
return hostInstanceInfos_;
}
std::string DescribeDBInstanceHAConfigResult::getSyncMode()const
{
return syncMode_;
}

159
rds/src/model/DescribeDBInstanceIPArrayListRequest.cc
View File

@@ -16,90 +16,89 @@
#include <alibabacloud/rds/model/DescribeDBInstanceIPArrayListRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeDBInstanceIPArrayListRequest;
DescribeDBInstanceIPArrayListRequest::DescribeDBInstanceIPArrayListRequest() :
RdsRequest("DescribeDBInstanceIPArrayList")
RpcServiceRequest("rds", "2014-08-15", "DescribeDBInstanceIPArrayList")
{}
DescribeDBInstanceIPArrayListRequest::~DescribeDBInstanceIPArrayListRequest()
{}
long DescribeDBInstanceIPArrayListRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstanceIPArrayListRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstanceIPArrayListRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstanceIPArrayListRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstanceIPArrayListRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDBInstanceIPArrayListRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeDBInstanceIPArrayListRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceIPArrayListRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstanceIPArrayListRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstanceIPArrayListRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstanceIPArrayListRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceIPArrayListRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeDBInstanceIPArrayListRequest::getWhitelistNetType()const
{
return whitelistNetType_;
}
void DescribeDBInstanceIPArrayListRequest::setWhitelistNetType(const std::string& whitelistNetType)
{
whitelistNetType_ = whitelistNetType;
setParameter("WhitelistNetType", whitelistNetType);
}
long DescribeDBInstanceIPArrayListRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstanceIPArrayListRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstanceIPArrayListRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstanceIPArrayListRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstanceIPArrayListRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDBInstanceIPArrayListRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeDBInstanceIPArrayListRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceIPArrayListRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstanceIPArrayListRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstanceIPArrayListRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstanceIPArrayListRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceIPArrayListRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeDBInstanceIPArrayListRequest::getWhitelistNetType()const
{
return whitelistNetType_;
}
void DescribeDBInstanceIPArrayListRequest::setWhitelistNetType(const std::string& whitelistNetType)
{
whitelistNetType_ = whitelistNetType;
setParameter("WhitelistNetType", whitelistNetType);
}

29
rds/src/model/DescribeDBInstanceIPArrayListResult.cc
View File

@@ -40,16 +40,25 @@ void DescribeDBInstanceIPArrayListResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["DBInstanceIPArray"];
for (auto value : allItems)
{
DBInstanceIPArray dBInstanceIPArrayObject;
dBInstanceIPArrayObject.dBInstanceIPArrayName = value["DBInstanceIPArrayName"].asString();
dBInstanceIPArrayObject.dBInstanceIPArrayAttribute = value["DBInstanceIPArrayAttribute"].asString();
dBInstanceIPArrayObject.securityIPList = value["SecurityIPList"].asString();
dBInstanceIPArrayObject.whitelistNetType = value["WhitelistNetType"].asString();
items_.push_back(dBInstanceIPArrayObject);
}
auto allItems = value["Items"]["DBInstanceIPArray"];
for (auto value : allItems)
{
DBInstanceIPArray itemsObject;
if(!value["DBInstanceIPArrayName"].isNull())
itemsObject.dBInstanceIPArrayName = value["DBInstanceIPArrayName"].asString();
if(!value["DBInstanceIPArrayAttribute"].isNull())
itemsObject.dBInstanceIPArrayAttribute = value["DBInstanceIPArrayAttribute"].asString();
if(!value["SecurityIPList"].isNull())
itemsObject.securityIPList = value["SecurityIPList"].asString();
if(!value["WhitelistNetType"].isNull())
itemsObject.whitelistNetType = value["WhitelistNetType"].asString();
items_.push_back(itemsObject);
}
}
std::vector<DescribeDBInstanceIPArrayListResult::DBInstanceIPArray> DescribeDBInstanceIPArrayListResult::getItems()const
{
return items_;
}

159
rds/src/model/DescribeDBInstanceMonitorRequest.cc
View File

@@ -16,90 +16,89 @@
#include <alibabacloud/rds/model/DescribeDBInstanceMonitorRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeDBInstanceMonitorRequest;
DescribeDBInstanceMonitorRequest::DescribeDBInstanceMonitorRequest() :
RdsRequest("DescribeDBInstanceMonitor")
RpcServiceRequest("rds", "2014-08-15", "DescribeDBInstanceMonitor")
{}
DescribeDBInstanceMonitorRequest::~DescribeDBInstanceMonitorRequest()
{}
long DescribeDBInstanceMonitorRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstanceMonitorRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstanceMonitorRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstanceMonitorRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstanceMonitorRequest::getClientToken()const
{
return clientToken_;
}
void DescribeDBInstanceMonitorRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string DescribeDBInstanceMonitorRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDBInstanceMonitorRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeDBInstanceMonitorRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceMonitorRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstanceMonitorRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstanceMonitorRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstanceMonitorRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceMonitorRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long DescribeDBInstanceMonitorRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstanceMonitorRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstanceMonitorRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstanceMonitorRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstanceMonitorRequest::getClientToken()const
{
return clientToken_;
}
void DescribeDBInstanceMonitorRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string DescribeDBInstanceMonitorRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDBInstanceMonitorRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeDBInstanceMonitorRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceMonitorRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstanceMonitorRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstanceMonitorRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstanceMonitorRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceMonitorRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

18
rds/src/model/DescribeDBInstanceMonitorResult.cc
View File

@@ -40,17 +40,13 @@ void DescribeDBInstanceMonitorResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
period_ = value["Period"].asString();
if(!value["Period"].isNull())
period_ = value["Period"].asString();
}
std::string DescribeDBInstanceMonitorResult::getPeriod()const
{
return period_;
}
void DescribeDBInstanceMonitorResult::setPeriod(const std::string& period)
{
period_ = period;
}
std::string DescribeDBInstanceMonitorResult::getPeriod()const
{
return period_;
}

203
rds/src/model/DescribeDBInstanceNetInfoRequest.cc
View File

@@ -16,112 +16,111 @@
#include <alibabacloud/rds/model/DescribeDBInstanceNetInfoRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeDBInstanceNetInfoRequest;
DescribeDBInstanceNetInfoRequest::DescribeDBInstanceNetInfoRequest() :
RdsRequest("DescribeDBInstanceNetInfo")
RpcServiceRequest("rds", "2014-08-15", "DescribeDBInstanceNetInfo")
{}
DescribeDBInstanceNetInfoRequest::~DescribeDBInstanceNetInfoRequest()
{}
long DescribeDBInstanceNetInfoRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstanceNetInfoRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstanceNetInfoRequest::getFlag()const
{
return flag_;
}
void DescribeDBInstanceNetInfoRequest::setFlag(const std::string& flag)
{
flag_ = flag;
setParameter("Flag", flag);
}
std::string DescribeDBInstanceNetInfoRequest::getDBInstanceNetRWSplitType()const
{
return dBInstanceNetRWSplitType_;
}
void DescribeDBInstanceNetInfoRequest::setDBInstanceNetRWSplitType(const std::string& dBInstanceNetRWSplitType)
{
dBInstanceNetRWSplitType_ = dBInstanceNetRWSplitType;
setParameter("DBInstanceNetRWSplitType", dBInstanceNetRWSplitType);
}
std::string DescribeDBInstanceNetInfoRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstanceNetInfoRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstanceNetInfoRequest::getClientToken()const
{
return clientToken_;
}
void DescribeDBInstanceNetInfoRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string DescribeDBInstanceNetInfoRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDBInstanceNetInfoRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeDBInstanceNetInfoRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceNetInfoRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstanceNetInfoRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstanceNetInfoRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstanceNetInfoRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceNetInfoRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long DescribeDBInstanceNetInfoRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstanceNetInfoRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstanceNetInfoRequest::getFlag()const
{
return flag_;
}
void DescribeDBInstanceNetInfoRequest::setFlag(const std::string& flag)
{
flag_ = flag;
setParameter("Flag", flag);
}
std::string DescribeDBInstanceNetInfoRequest::getDBInstanceNetRWSplitType()const
{
return dBInstanceNetRWSplitType_;
}
void DescribeDBInstanceNetInfoRequest::setDBInstanceNetRWSplitType(const std::string& dBInstanceNetRWSplitType)
{
dBInstanceNetRWSplitType_ = dBInstanceNetRWSplitType;
setParameter("DBInstanceNetRWSplitType", dBInstanceNetRWSplitType);
}
std::string DescribeDBInstanceNetInfoRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstanceNetInfoRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstanceNetInfoRequest::getClientToken()const
{
return clientToken_;
}
void DescribeDBInstanceNetInfoRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string DescribeDBInstanceNetInfoRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDBInstanceNetInfoRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeDBInstanceNetInfoRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceNetInfoRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstanceNetInfoRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstanceNetInfoRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstanceNetInfoRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceNetInfoRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

110
rds/src/model/DescribeDBInstanceNetInfoResult.cc
View File

@@ -40,52 +40,70 @@ void DescribeDBInstanceNetInfoResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDBInstanceNetInfos = value["DBInstanceNetInfos"]["DBInstanceNetInfo"];
for (auto value : allDBInstanceNetInfos)
{
DBInstanceNetInfo dBInstanceNetInfoObject;
dBInstanceNetInfoObject.upgradeable = value["Upgradeable"].asString();
dBInstanceNetInfoObject.expiredTime = value["ExpiredTime"].asString();
dBInstanceNetInfoObject.connectionString = value["ConnectionString"].asString();
dBInstanceNetInfoObject.iPAddress = value["IPAddress"].asString();
dBInstanceNetInfoObject.iPType = value["IPType"].asString();
dBInstanceNetInfoObject.port = value["Port"].asString();
dBInstanceNetInfoObject.vPCId = value["VPCId"].asString();
dBInstanceNetInfoObject.vSwitchId = value["VSwitchId"].asString();
dBInstanceNetInfoObject.connectionStringType = value["ConnectionStringType"].asString();
dBInstanceNetInfoObject.maxDelayTime = value["MaxDelayTime"].asString();
dBInstanceNetInfoObject.distributionType = value["DistributionType"].asString();
auto allSecurityIPGroups = value["SecurityIPGroups"]["securityIPGroup"];
for (auto value : allSecurityIPGroups)
{
DBInstanceNetInfo::securityIPGroup securityIPGroupObject;
securityIPGroupObject.securityIPGroupName = value["SecurityIPGroupName"].asString();
securityIPGroupObject.securityIPs = value["SecurityIPs"].asString();
dBInstanceNetInfoObject.securityIPGroups.push_back(securityIPGroupObject);
}
auto allDBInstanceWeights = value["DBInstanceWeights"]["DBInstanceWeight"];
for (auto value : allDBInstanceWeights)
{
DBInstanceNetInfo::DBInstanceWeight dBInstanceWeightObject;
dBInstanceWeightObject.dBInstanceId = value["DBInstanceId"].asString();
dBInstanceWeightObject.dBInstanceType = value["DBInstanceType"].asString();
dBInstanceWeightObject.availability = value["Availability"].asString();
dBInstanceWeightObject.weight = value["Weight"].asString();
dBInstanceNetInfoObject.dBInstanceWeights.push_back(dBInstanceWeightObject);
}
dBInstanceNetInfos_.push_back(dBInstanceNetInfoObject);
}
instanceNetworkType_ = value["InstanceNetworkType"].asString();
auto allDBInstanceNetInfos = value["DBInstanceNetInfos"]["DBInstanceNetInfo"];
for (auto value : allDBInstanceNetInfos)
{
DBInstanceNetInfo dBInstanceNetInfosObject;
if(!value["Upgradeable"].isNull())
dBInstanceNetInfosObject.upgradeable = value["Upgradeable"].asString();
if(!value["ExpiredTime"].isNull())
dBInstanceNetInfosObject.expiredTime = value["ExpiredTime"].asString();
if(!value["ConnectionString"].isNull())
dBInstanceNetInfosObject.connectionString = value["ConnectionString"].asString();
if(!value["IPAddress"].isNull())
dBInstanceNetInfosObject.iPAddress = value["IPAddress"].asString();
if(!value["IPType"].isNull())
dBInstanceNetInfosObject.iPType = value["IPType"].asString();
if(!value["Port"].isNull())
dBInstanceNetInfosObject.port = value["Port"].asString();
if(!value["VPCId"].isNull())
dBInstanceNetInfosObject.vPCId = value["VPCId"].asString();
if(!value["VSwitchId"].isNull())
dBInstanceNetInfosObject.vSwitchId = value["VSwitchId"].asString();
if(!value["ConnectionStringType"].isNull())
dBInstanceNetInfosObject.connectionStringType = value["ConnectionStringType"].asString();
if(!value["MaxDelayTime"].isNull())
dBInstanceNetInfosObject.maxDelayTime = value["MaxDelayTime"].asString();
if(!value["DistributionType"].isNull())
dBInstanceNetInfosObject.distributionType = value["DistributionType"].asString();
auto allSecurityIPGroups = value["SecurityIPGroups"]["securityIPGroup"];
for (auto value : allSecurityIPGroups)
{
DBInstanceNetInfo::SecurityIPGroup securityIPGroupsObject;
if(!value["SecurityIPGroupName"].isNull())
securityIPGroupsObject.securityIPGroupName = value["SecurityIPGroupName"].asString();
if(!value["SecurityIPs"].isNull())
securityIPGroupsObject.securityIPs = value["SecurityIPs"].asString();
dBInstanceNetInfosObject.securityIPGroups.push_back(securityIPGroupsObject);
}
auto allDBInstanceWeights = value["DBInstanceWeights"]["DBInstanceWeight"];
for (auto value : allDBInstanceWeights)
{
DBInstanceNetInfo::DBInstanceWeight dBInstanceWeightsObject;
if(!value["DBInstanceId"].isNull())
dBInstanceWeightsObject.dBInstanceId = value["DBInstanceId"].asString();
if(!value["DBInstanceType"].isNull())
dBInstanceWeightsObject.dBInstanceType = value["DBInstanceType"].asString();
if(!value["Availability"].isNull())
dBInstanceWeightsObject.availability = value["Availability"].asString();
if(!value["Weight"].isNull())
dBInstanceWeightsObject.weight = value["Weight"].asString();
dBInstanceNetInfosObject.dBInstanceWeights.push_back(dBInstanceWeightsObject);
}
dBInstanceNetInfos_.push_back(dBInstanceNetInfosObject);
}
if(!value["InstanceNetworkType"].isNull())
instanceNetworkType_ = value["InstanceNetworkType"].asString();
}
std::string DescribeDBInstanceNetInfoResult::getInstanceNetworkType()const
{
return instanceNetworkType_;
}
void DescribeDBInstanceNetInfoResult::setInstanceNetworkType(const std::string& instanceNetworkType)
{
instanceNetworkType_ = instanceNetworkType;
}
std::vector<DescribeDBInstanceNetInfoResult::DBInstanceNetInfo> DescribeDBInstanceNetInfoResult::getDBInstanceNetInfos()const
{
return dBInstanceNetInfos_;
}
std::string DescribeDBInstanceNetInfoResult::getInstanceNetworkType()const
{
return instanceNetworkType_;
}

137
rds/src/model/DescribeDBInstanceNetworkDetailRequest.cc
View File

@@ -16,79 +16,78 @@
#include <alibabacloud/rds/model/DescribeDBInstanceNetworkDetailRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeDBInstanceNetworkDetailRequest;
DescribeDBInstanceNetworkDetailRequest::DescribeDBInstanceNetworkDetailRequest() :
RdsRequest("DescribeDBInstanceNetworkDetail")
RpcServiceRequest("rds", "2014-08-15", "DescribeDBInstanceNetworkDetail")
{}
DescribeDBInstanceNetworkDetailRequest::~DescribeDBInstanceNetworkDetailRequest()
{}
std::string DescribeDBInstanceNetworkDetailRequest::getEndPoint()const
{
return endPoint_;
}
void DescribeDBInstanceNetworkDetailRequest::setEndPoint(const std::string& endPoint)
{
endPoint_ = endPoint;
setParameter("EndPoint", endPoint);
}
std::string DescribeDBInstanceNetworkDetailRequest::getStartPoint()const
{
return startPoint_;
}
void DescribeDBInstanceNetworkDetailRequest::setStartPoint(const std::string& startPoint)
{
startPoint_ = startPoint;
setParameter("StartPoint", startPoint);
}
std::string DescribeDBInstanceNetworkDetailRequest::getEndTime()const
{
return endTime_;
}
void DescribeDBInstanceNetworkDetailRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
std::string DescribeDBInstanceNetworkDetailRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceNetworkDetailRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string DescribeDBInstanceNetworkDetailRequest::getStartTime()const
{
return startTime_;
}
void DescribeDBInstanceNetworkDetailRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
std::string DescribeDBInstanceNetworkDetailRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceNetworkDetailRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeDBInstanceNetworkDetailRequest::getEndPoint()const
{
return endPoint_;
}
void DescribeDBInstanceNetworkDetailRequest::setEndPoint(const std::string& endPoint)
{
endPoint_ = endPoint;
setParameter("EndPoint", endPoint);
}
std::string DescribeDBInstanceNetworkDetailRequest::getStartPoint()const
{
return startPoint_;
}
void DescribeDBInstanceNetworkDetailRequest::setStartPoint(const std::string& startPoint)
{
startPoint_ = startPoint;
setParameter("StartPoint", startPoint);
}
std::string DescribeDBInstanceNetworkDetailRequest::getEndTime()const
{
return endTime_;
}
void DescribeDBInstanceNetworkDetailRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
std::string DescribeDBInstanceNetworkDetailRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceNetworkDetailRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string DescribeDBInstanceNetworkDetailRequest::getStartTime()const
{
return startTime_;
}
void DescribeDBInstanceNetworkDetailRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
std::string DescribeDBInstanceNetworkDetailRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceNetworkDetailRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

257
rds/src/model/DescribeDBInstanceNetworkDetailResult.cc
View File

@@ -40,154 +40,115 @@ void DescribeDBInstanceNetworkDetailResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allNetworkDetail = value["NetworkDetail"]["NetworkKey"];
for (auto value : allNetworkDetail)
{
NetworkKey networkKeyObject;
networkKeyObject.key = value["Key"].asString();
networkKeyObject.unit = value["Unit"].asString();
auto allValues = value["Values"]["NetworkValue"];
for (auto value : allValues)
{
NetworkKey::NetworkValue networkValueObject;
networkValueObject.value = value["Value"].asString();
networkValueObject.dateTime = value["DateTime"].asString();
networkKeyObject.values.push_back(networkValueObject);
}
networkDetail_.push_back(networkKeyObject);
}
dBInstanceId_ = value["DBInstanceId"].asString();
startTime_ = value["StartTime"].asString();
endTime_ = value["EndTime"].asString();
newConnection_ = value["NewConnection"].asString();
activeConnection_ = value["ActiveConnection"].asString();
abortedConnection_ = value["AbortedConnection"].asString();
networkRequest_ = value["NetworkRequest"].asString();
networkTrafficIn_ = value["NetworkTrafficIn"].asString();
networkTrafficOut_ = value["NetworkTrafficOut"].asString();
networkLatency_ = value["NetworkLatency"].asString();
backendLatency_ = value["BackendLatency"].asString();
networkErrors_ = value["NetworkErrors"].asString();
auto allNetworkDetail = value["NetworkDetail"]["NetworkKey"];
for (auto value : allNetworkDetail)
{
NetworkKey networkDetailObject;
if(!value["Key"].isNull())
networkDetailObject.key = value["Key"].asString();
if(!value["Unit"].isNull())
networkDetailObject.unit = value["Unit"].asString();
auto allValues = value["Values"]["NetworkValue"];
for (auto value : allValues)
{
NetworkKey::NetworkValue valuesObject;
if(!value["Value"].isNull())
valuesObject.value = value["Value"].asString();
if(!value["DateTime"].isNull())
valuesObject.dateTime = value["DateTime"].asString();
networkDetailObject.values.push_back(valuesObject);
}
networkDetail_.push_back(networkDetailObject);
}
if(!value["DBInstanceId"].isNull())
dBInstanceId_ = value["DBInstanceId"].asString();
if(!value["StartTime"].isNull())
startTime_ = value["StartTime"].asString();
if(!value["EndTime"].isNull())
endTime_ = value["EndTime"].asString();
if(!value["NewConnection"].isNull())
newConnection_ = value["NewConnection"].asString();
if(!value["ActiveConnection"].isNull())
activeConnection_ = value["ActiveConnection"].asString();
if(!value["AbortedConnection"].isNull())
abortedConnection_ = value["AbortedConnection"].asString();
if(!value["NetworkRequest"].isNull())
networkRequest_ = value["NetworkRequest"].asString();
if(!value["NetworkTrafficIn"].isNull())
networkTrafficIn_ = value["NetworkTrafficIn"].asString();
if(!value["NetworkTrafficOut"].isNull())
networkTrafficOut_ = value["NetworkTrafficOut"].asString();
if(!value["NetworkLatency"].isNull())
networkLatency_ = value["NetworkLatency"].asString();
if(!value["BackendLatency"].isNull())
backendLatency_ = value["BackendLatency"].asString();
if(!value["NetworkErrors"].isNull())
networkErrors_ = value["NetworkErrors"].asString();
}
std::string DescribeDBInstanceNetworkDetailResult::getEndTime()const
{
return endTime_;
}
void DescribeDBInstanceNetworkDetailResult::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
}
std::string DescribeDBInstanceNetworkDetailResult::getNetworkLatency()const
{
return networkLatency_;
}
void DescribeDBInstanceNetworkDetailResult::setNetworkLatency(const std::string& networkLatency)
{
networkLatency_ = networkLatency;
}
std::string DescribeDBInstanceNetworkDetailResult::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceNetworkDetailResult::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
}
std::string DescribeDBInstanceNetworkDetailResult::getNetworkTrafficOut()const
{
return networkTrafficOut_;
}
void DescribeDBInstanceNetworkDetailResult::setNetworkTrafficOut(const std::string& networkTrafficOut)
{
networkTrafficOut_ = networkTrafficOut;
}
std::string DescribeDBInstanceNetworkDetailResult::getActiveConnection()const
{
return activeConnection_;
}
void DescribeDBInstanceNetworkDetailResult::setActiveConnection(const std::string& activeConnection)
{
activeConnection_ = activeConnection;
}
std::string DescribeDBInstanceNetworkDetailResult::getNetworkErrors()const
{
return networkErrors_;
}
void DescribeDBInstanceNetworkDetailResult::setNetworkErrors(const std::string& networkErrors)
{
networkErrors_ = networkErrors;
}
std::string DescribeDBInstanceNetworkDetailResult::getStartTime()const
{
return startTime_;
}
void DescribeDBInstanceNetworkDetailResult::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
}
std::string DescribeDBInstanceNetworkDetailResult::getNetworkRequest()const
{
return networkRequest_;
}
void DescribeDBInstanceNetworkDetailResult::setNetworkRequest(const std::string& networkRequest)
{
networkRequest_ = networkRequest;
}
std::string DescribeDBInstanceNetworkDetailResult::getNewConnection()const
{
return newConnection_;
}
void DescribeDBInstanceNetworkDetailResult::setNewConnection(const std::string& newConnection)
{
newConnection_ = newConnection;
}
std::string DescribeDBInstanceNetworkDetailResult::getNetworkTrafficIn()const
{
return networkTrafficIn_;
}
void DescribeDBInstanceNetworkDetailResult::setNetworkTrafficIn(const std::string& networkTrafficIn)
{
networkTrafficIn_ = networkTrafficIn;
}
std::string DescribeDBInstanceNetworkDetailResult::getAbortedConnection()const
{
return abortedConnection_;
}
void DescribeDBInstanceNetworkDetailResult::setAbortedConnection(const std::string& abortedConnection)
{
abortedConnection_ = abortedConnection;
}
std::string DescribeDBInstanceNetworkDetailResult::getBackendLatency()const
{
return backendLatency_;
}
void DescribeDBInstanceNetworkDetailResult::setBackendLatency(const std::string& backendLatency)
{
backendLatency_ = backendLatency;
}
std::string DescribeDBInstanceNetworkDetailResult::getEndTime()const
{
return endTime_;
}
std::string DescribeDBInstanceNetworkDetailResult::getNetworkLatency()const
{
return networkLatency_;
}
std::string DescribeDBInstanceNetworkDetailResult::getNetworkTrafficOut()const
{
return networkTrafficOut_;
}
std::string DescribeDBInstanceNetworkDetailResult::getStartTime()const
{
return startTime_;
}
std::string DescribeDBInstanceNetworkDetailResult::getNetworkRequest()const
{
return networkRequest_;
}
std::string DescribeDBInstanceNetworkDetailResult::getAbortedConnection()const
{
return abortedConnection_;
}
std::string DescribeDBInstanceNetworkDetailResult::getBackendLatency()const
{
return backendLatency_;
}
std::string DescribeDBInstanceNetworkDetailResult::getDBInstanceId()const
{
return dBInstanceId_;
}
std::string DescribeDBInstanceNetworkDetailResult::getActiveConnection()const
{
return activeConnection_;
}
std::string DescribeDBInstanceNetworkDetailResult::getNetworkErrors()const
{
return networkErrors_;
}
std::string DescribeDBInstanceNetworkDetailResult::getNewConnection()const
{
return newConnection_;
}
std::string DescribeDBInstanceNetworkDetailResult::getNetworkTrafficIn()const
{
return networkTrafficIn_;
}
std::vector<DescribeDBInstanceNetworkDetailResult::NetworkKey> DescribeDBInstanceNetworkDetailResult::getNetworkDetail()const
{
return networkDetail_;
}

93
rds/src/model/DescribeDBInstanceNetworkRequest.cc
View File

@@ -16,57 +16,56 @@
#include <alibabacloud/rds/model/DescribeDBInstanceNetworkRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeDBInstanceNetworkRequest;
DescribeDBInstanceNetworkRequest::DescribeDBInstanceNetworkRequest() :
RdsRequest("DescribeDBInstanceNetwork")
RpcServiceRequest("rds", "2014-08-15", "DescribeDBInstanceNetwork")
{}
DescribeDBInstanceNetworkRequest::~DescribeDBInstanceNetworkRequest()
{}
std::string DescribeDBInstanceNetworkRequest::getEndTime()const
{
return endTime_;
}
void DescribeDBInstanceNetworkRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
std::string DescribeDBInstanceNetworkRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceNetworkRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string DescribeDBInstanceNetworkRequest::getStartTime()const
{
return startTime_;
}
void DescribeDBInstanceNetworkRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
std::string DescribeDBInstanceNetworkRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceNetworkRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeDBInstanceNetworkRequest::getEndTime()const
{
return endTime_;
}
void DescribeDBInstanceNetworkRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
std::string DescribeDBInstanceNetworkRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceNetworkRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string DescribeDBInstanceNetworkRequest::getStartTime()const
{
return startTime_;
}
void DescribeDBInstanceNetworkRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
std::string DescribeDBInstanceNetworkRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceNetworkRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

92
rds/src/model/DescribeDBInstanceNetworkResult.cc
View File

@@ -40,52 +40,52 @@ void DescribeDBInstanceNetworkResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allTopology = value["Topology"]["TopologyItem"];
for (auto value : allTopology)
{
TopologyItem topologyItemObject;
topologyItemObject.startPoint = value["StartPoint"].asString();
topologyItemObject.endPoint = value["EndPoint"].asString();
topologyItemObject.networkTrafficIn = value["NetworkTrafficIn"].asString();
topologyItemObject.networkTrafficOut = value["NetworkTrafficOut"].asString();
topologyItemObject.networkLatency = value["NetworkLatency"].asString();
topologyItemObject.backendLatency = value["BackendLatency"].asString();
topologyItemObject.networkErrors = value["NetworkErrors"].asString();
topology_.push_back(topologyItemObject);
}
dBInstanceId_ = value["DBInstanceId"].asString();
startTime_ = value["StartTime"].asString();
endTime_ = value["EndTime"].asString();
auto allTopology = value["Topology"]["TopologyItem"];
for (auto value : allTopology)
{
TopologyItem topologyObject;
if(!value["StartPoint"].isNull())
topologyObject.startPoint = value["StartPoint"].asString();
if(!value["EndPoint"].isNull())
topologyObject.endPoint = value["EndPoint"].asString();
if(!value["NetworkTrafficIn"].isNull())
topologyObject.networkTrafficIn = value["NetworkTrafficIn"].asString();
if(!value["NetworkTrafficOut"].isNull())
topologyObject.networkTrafficOut = value["NetworkTrafficOut"].asString();
if(!value["NetworkLatency"].isNull())
topologyObject.networkLatency = value["NetworkLatency"].asString();
if(!value["BackendLatency"].isNull())
topologyObject.backendLatency = value["BackendLatency"].asString();
if(!value["NetworkErrors"].isNull())
topologyObject.networkErrors = value["NetworkErrors"].asString();
topology_.push_back(topologyObject);
}
if(!value["DBInstanceId"].isNull())
dBInstanceId_ = value["DBInstanceId"].asString();
if(!value["StartTime"].isNull())
startTime_ = value["StartTime"].asString();
if(!value["EndTime"].isNull())
endTime_ = value["EndTime"].asString();
}
std::string DescribeDBInstanceNetworkResult::getEndTime()const
{
return endTime_;
}
void DescribeDBInstanceNetworkResult::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
}
std::string DescribeDBInstanceNetworkResult::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceNetworkResult::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
}
std::string DescribeDBInstanceNetworkResult::getStartTime()const
{
return startTime_;
}
void DescribeDBInstanceNetworkResult::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
}
std::string DescribeDBInstanceNetworkResult::getEndTime()const
{
return endTime_;
}
std::string DescribeDBInstanceNetworkResult::getDBInstanceId()const
{
return dBInstanceId_;
}
std::string DescribeDBInstanceNetworkResult::getStartTime()const
{
return startTime_;
}
std::vector<DescribeDBInstanceNetworkResult::TopologyItem> DescribeDBInstanceNetworkResult::getTopology()const
{
return topology_;
}

203
rds/src/model/DescribeDBInstancePerformanceRequest.cc
View File

@@ -16,112 +16,111 @@
#include <alibabacloud/rds/model/DescribeDBInstancePerformanceRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeDBInstancePerformanceRequest;
DescribeDBInstancePerformanceRequest::DescribeDBInstancePerformanceRequest() :
RdsRequest("DescribeDBInstancePerformance")
RpcServiceRequest("rds", "2014-08-15", "DescribeDBInstancePerformance")
{}
DescribeDBInstancePerformanceRequest::~DescribeDBInstancePerformanceRequest()
{}
long DescribeDBInstancePerformanceRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstancePerformanceRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstancePerformanceRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstancePerformanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstancePerformanceRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDBInstancePerformanceRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeDBInstancePerformanceRequest::getEndTime()const
{
return endTime_;
}
void DescribeDBInstancePerformanceRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
std::string DescribeDBInstancePerformanceRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstancePerformanceRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string DescribeDBInstancePerformanceRequest::getStartTime()const
{
return startTime_;
}
void DescribeDBInstancePerformanceRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
long DescribeDBInstancePerformanceRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstancePerformanceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstancePerformanceRequest::getKey()const
{
return key_;
}
void DescribeDBInstancePerformanceRequest::setKey(const std::string& key)
{
key_ = key;
setParameter("Key", key);
}
std::string DescribeDBInstancePerformanceRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstancePerformanceRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long DescribeDBInstancePerformanceRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstancePerformanceRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstancePerformanceRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstancePerformanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstancePerformanceRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDBInstancePerformanceRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeDBInstancePerformanceRequest::getEndTime()const
{
return endTime_;
}
void DescribeDBInstancePerformanceRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
std::string DescribeDBInstancePerformanceRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstancePerformanceRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
std::string DescribeDBInstancePerformanceRequest::getStartTime()const
{
return startTime_;
}
void DescribeDBInstancePerformanceRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
long DescribeDBInstancePerformanceRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstancePerformanceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstancePerformanceRequest::getKey()const
{
return key_;
}
void DescribeDBInstancePerformanceRequest::setKey(const std::string& key)
{
key_ = key;
setParameter("Key", key);
}
std::string DescribeDBInstancePerformanceRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstancePerformanceRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

116
rds/src/model/DescribeDBInstancePerformanceResult.cc
View File

@@ -40,67 +40,61 @@ void DescribeDBInstancePerformanceResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allPerformanceKeys = value["PerformanceKeys"]["PerformanceKey"];
for (auto value : allPerformanceKeys)
{
PerformanceKey performanceKeyObject;
performanceKeyObject.key = value["Key"].asString();
performanceKeyObject.unit = value["Unit"].asString();
performanceKeyObject.valueFormat = value["ValueFormat"].asString();
auto allValues = value["Values"]["PerformanceValue"];
for (auto value : allValues)
{
PerformanceKey::PerformanceValue performanceValueObject;
performanceValueObject.value = value["Value"].asString();
performanceValueObject.date = value["Date"].asString();
performanceKeyObject.values.push_back(performanceValueObject);
}
performanceKeys_.push_back(performanceKeyObject);
}
dBInstanceId_ = value["DBInstanceId"].asString();
engine_ = value["Engine"].asString();
startTime_ = value["StartTime"].asString();
endTime_ = value["EndTime"].asString();
auto allPerformanceKeys = value["PerformanceKeys"]["PerformanceKey"];
for (auto value : allPerformanceKeys)
{
PerformanceKey performanceKeysObject;
if(!value["Key"].isNull())
performanceKeysObject.key = value["Key"].asString();
if(!value["Unit"].isNull())
performanceKeysObject.unit = value["Unit"].asString();
if(!value["ValueFormat"].isNull())
performanceKeysObject.valueFormat = value["ValueFormat"].asString();
auto allValues = value["Values"]["PerformanceValue"];
for (auto value : allValues)
{
PerformanceKey::PerformanceValue valuesObject;
if(!value["Value"].isNull())
valuesObject.value = value["Value"].asString();
if(!value["Date"].isNull())
valuesObject.date = value["Date"].asString();
performanceKeysObject.values.push_back(valuesObject);
}
performanceKeys_.push_back(performanceKeysObject);
}
if(!value["DBInstanceId"].isNull())
dBInstanceId_ = value["DBInstanceId"].asString();
if(!value["Engine"].isNull())
engine_ = value["Engine"].asString();
if(!value["StartTime"].isNull())
startTime_ = value["StartTime"].asString();
if(!value["EndTime"].isNull())
endTime_ = value["EndTime"].asString();
}
std::string DescribeDBInstancePerformanceResult::getEndTime()const
{
return endTime_;
}
void DescribeDBInstancePerformanceResult::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
}
std::string DescribeDBInstancePerformanceResult::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstancePerformanceResult::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
}
std::string DescribeDBInstancePerformanceResult::getStartTime()const
{
return startTime_;
}
void DescribeDBInstancePerformanceResult::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
}
std::string DescribeDBInstancePerformanceResult::getEngine()const
{
return engine_;
}
void DescribeDBInstancePerformanceResult::setEngine(const std::string& engine)
{
engine_ = engine;
}
std::vector<DescribeDBInstancePerformanceResult::PerformanceKey> DescribeDBInstancePerformanceResult::getPerformanceKeys()const
{
return performanceKeys_;
}
std::string DescribeDBInstancePerformanceResult::getEndTime()const
{
return endTime_;
}
std::string DescribeDBInstancePerformanceResult::getDBInstanceId()const
{
return dBInstanceId_;
}
std::string DescribeDBInstancePerformanceResult::getStartTime()const
{
return startTime_;
}
std::string DescribeDBInstancePerformanceResult::getEngine()const
{
return engine_;
}

137
rds/src/model/DescribeDBInstanceSSLRequest.cc
View File

@@ -16,79 +16,78 @@
#include <alibabacloud/rds/model/DescribeDBInstanceSSLRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeDBInstanceSSLRequest;
DescribeDBInstanceSSLRequest::DescribeDBInstanceSSLRequest() :
RdsRequest("DescribeDBInstanceSSL")
RpcServiceRequest("rds", "2014-08-15", "DescribeDBInstanceSSL")
{}
DescribeDBInstanceSSLRequest::~DescribeDBInstanceSSLRequest()
{}
long DescribeDBInstanceSSLRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstanceSSLRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstanceSSLRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstanceSSLRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstanceSSLRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDBInstanceSSLRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeDBInstanceSSLRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceSSLRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstanceSSLRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstanceSSLRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstanceSSLRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceSSLRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long DescribeDBInstanceSSLRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstanceSSLRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstanceSSLRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstanceSSLRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstanceSSLRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDBInstanceSSLRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeDBInstanceSSLRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceSSLRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstanceSSLRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstanceSSLRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstanceSSLRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceSSLRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

72
rds/src/model/DescribeDBInstanceSSLResult.cc
View File

@@ -40,50 +40,34 @@ void DescribeDBInstanceSSLResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
connectionString_ = value["ConnectionString"].asString();
sSLExpireTime_ = value["SSLExpireTime"].asString();
requireUpdate_ = value["RequireUpdate"].asString();
requireUpdateReason_ = value["RequireUpdateReason"].asString();
if(!value["ConnectionString"].isNull())
connectionString_ = value["ConnectionString"].asString();
if(!value["SSLExpireTime"].isNull())
sSLExpireTime_ = value["SSLExpireTime"].asString();
if(!value["RequireUpdate"].isNull())
requireUpdate_ = value["RequireUpdate"].asString();
if(!value["RequireUpdateReason"].isNull())
requireUpdateReason_ = value["RequireUpdateReason"].asString();
}
std::string DescribeDBInstanceSSLResult::getSSLExpireTime()const
{
return sSLExpireTime_;
}
void DescribeDBInstanceSSLResult::setSSLExpireTime(const std::string& sSLExpireTime)
{
sSLExpireTime_ = sSLExpireTime;
}
std::string DescribeDBInstanceSSLResult::getRequireUpdateReason()const
{
return requireUpdateReason_;
}
void DescribeDBInstanceSSLResult::setRequireUpdateReason(const std::string& requireUpdateReason)
{
requireUpdateReason_ = requireUpdateReason;
}
std::string DescribeDBInstanceSSLResult::getConnectionString()const
{
return connectionString_;
}
void DescribeDBInstanceSSLResult::setConnectionString(const std::string& connectionString)
{
connectionString_ = connectionString;
}
std::string DescribeDBInstanceSSLResult::getRequireUpdate()const
{
return requireUpdate_;
}
void DescribeDBInstanceSSLResult::setRequireUpdate(const std::string& requireUpdate)
{
requireUpdate_ = requireUpdate;
}
std::string DescribeDBInstanceSSLResult::getSSLExpireTime()const
{
return sSLExpireTime_;
}
std::string DescribeDBInstanceSSLResult::getRequireUpdateReason()const
{
return requireUpdateReason_;
}
std::string DescribeDBInstanceSSLResult::getConnectionString()const
{
return connectionString_;
}
std::string DescribeDBInstanceSSLResult::getRequireUpdate()const
{
return requireUpdate_;
}

137
rds/src/model/DescribeDBInstanceTDERequest.cc
View File

@@ -16,79 +16,78 @@
#include <alibabacloud/rds/model/DescribeDBInstanceTDERequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeDBInstanceTDERequest;
DescribeDBInstanceTDERequest::DescribeDBInstanceTDERequest() :
RdsRequest("DescribeDBInstanceTDE")
RpcServiceRequest("rds", "2014-08-15", "DescribeDBInstanceTDE")
{}
DescribeDBInstanceTDERequest::~DescribeDBInstanceTDERequest()
{}
long DescribeDBInstanceTDERequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstanceTDERequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstanceTDERequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstanceTDERequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstanceTDERequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDBInstanceTDERequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeDBInstanceTDERequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceTDERequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstanceTDERequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstanceTDERequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstanceTDERequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceTDERequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long DescribeDBInstanceTDERequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstanceTDERequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstanceTDERequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstanceTDERequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstanceTDERequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDBInstanceTDERequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeDBInstanceTDERequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceTDERequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstanceTDERequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstanceTDERequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstanceTDERequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceTDERequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

41
rds/src/model/DescribeDBInstanceTDEResult.cc
View File

@@ -40,25 +40,28 @@ void DescribeDBInstanceTDEResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDatabases = value["Databases"]["Database"];
for (auto value : allDatabases)
{
Database databaseObject;
databaseObject.dBName = value["DBName"].asString();
databaseObject.tDEStatus = value["TDEStatus"].asString();
databases_.push_back(databaseObject);
}
tDEStatus_ = value["TDEStatus"].asString();
auto allDatabases = value["Databases"]["Database"];
for (auto value : allDatabases)
{
Database databasesObject;
if(!value["DBName"].isNull())
databasesObject.dBName = value["DBName"].asString();
if(!value["TDEStatus"].isNull())
databasesObject.tDEStatus = value["TDEStatus"].asString();
databases_.push_back(databasesObject);
}
if(!value["TDEStatus"].isNull())
tDEStatus_ = value["TDEStatus"].asString();
}
std::string DescribeDBInstanceTDEResult::getTDEStatus()const
{
return tDEStatus_;
}
void DescribeDBInstanceTDEResult::setTDEStatus(const std::string& tDEStatus)
{
tDEStatus_ = tDEStatus;
}
std::string DescribeDBInstanceTDEResult::getTDEStatus()const
{
return tDEStatus_;
}
std::vector<DescribeDBInstanceTDEResult::Database> DescribeDBInstanceTDEResult::getDatabases()const
{
return databases_;
}

137
rds/src/model/DescribeDBInstanceUserRequest.cc
View File

@@ -16,79 +16,78 @@
#include <alibabacloud/rds/model/DescribeDBInstanceUserRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeDBInstanceUserRequest;
DescribeDBInstanceUserRequest::DescribeDBInstanceUserRequest() :
RdsRequest("DescribeDBInstanceUser")
RpcServiceRequest("rds", "2014-08-15", "DescribeDBInstanceUser")
{}
DescribeDBInstanceUserRequest::~DescribeDBInstanceUserRequest()
{}
long DescribeDBInstanceUserRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstanceUserRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstanceUserRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstanceUserRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstanceUserRequest::getConnectionString()const
{
return connectionString_;
}
void DescribeDBInstanceUserRequest::setConnectionString(const std::string& connectionString)
{
connectionString_ = connectionString;
setParameter("ConnectionString", connectionString);
}
std::string DescribeDBInstanceUserRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceUserRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstanceUserRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstanceUserRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstanceUserRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceUserRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long DescribeDBInstanceUserRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstanceUserRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstanceUserRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstanceUserRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstanceUserRequest::getConnectionString()const
{
return connectionString_;
}
void DescribeDBInstanceUserRequest::setConnectionString(const std::string& connectionString)
{
connectionString_ = connectionString;
setParameter("ConnectionString", connectionString);
}
std::string DescribeDBInstanceUserRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstanceUserRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstanceUserRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstanceUserRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstanceUserRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstanceUserRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

36
rds/src/model/DescribeDBInstanceUserResult.cc
View File

@@ -40,28 +40,20 @@ void DescribeDBInstanceUserResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
dBInstanceName_ = value["DBInstanceName"].asString();
internalDBFlag_ = value["InternalDBFlag"].asString();
if(!value["DBInstanceName"].isNull())
dBInstanceName_ = value["DBInstanceName"].asString();
if(!value["InternalDBFlag"].isNull())
internalDBFlag_ = value["InternalDBFlag"].asString();
}
std::string DescribeDBInstanceUserResult::getInternalDBFlag()const
{
return internalDBFlag_;
}
void DescribeDBInstanceUserResult::setInternalDBFlag(const std::string& internalDBFlag)
{
internalDBFlag_ = internalDBFlag;
}
std::string DescribeDBInstanceUserResult::getDBInstanceName()const
{
return dBInstanceName_;
}
void DescribeDBInstanceUserResult::setDBInstanceName(const std::string& dBInstanceName)
{
dBInstanceName_ = dBInstanceName;
}
std::string DescribeDBInstanceUserResult::getInternalDBFlag()const
{
return internalDBFlag_;
}
std::string DescribeDBInstanceUserResult::getDBInstanceName()const
{
return dBInstanceName_;
}

137
rds/src/model/DescribeDBInstancesAsCsvRequest.cc
View File

@@ -16,79 +16,78 @@
#include <alibabacloud/rds/model/DescribeDBInstancesAsCsvRequest.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
using AlibabaCloud::Rds::Model::DescribeDBInstancesAsCsvRequest;
DescribeDBInstancesAsCsvRequest::DescribeDBInstancesAsCsvRequest() :
RdsRequest("DescribeDBInstancesAsCsv")
RpcServiceRequest("rds", "2014-08-15", "DescribeDBInstancesAsCsv")
{}
DescribeDBInstancesAsCsvRequest::~DescribeDBInstancesAsCsvRequest()
{}
long DescribeDBInstancesAsCsvRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstancesAsCsvRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstancesAsCsvRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstancesAsCsvRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstancesAsCsvRequest::getRegionId()const
{
return regionId_;
}
void DescribeDBInstancesAsCsvRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribeDBInstancesAsCsvRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstancesAsCsvRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstancesAsCsvRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstancesAsCsvRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstancesAsCsvRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstancesAsCsvRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
long DescribeDBInstancesAsCsvRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInstancesAsCsvRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInstancesAsCsvRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInstancesAsCsvRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInstancesAsCsvRequest::getRegionId()const
{
return regionId_;
}
void DescribeDBInstancesAsCsvRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribeDBInstancesAsCsvRequest::getDBInstanceId()const
{
return dBInstanceId_;
}
void DescribeDBInstancesAsCsvRequest::setDBInstanceId(const std::string& dBInstanceId)
{
dBInstanceId_ = dBInstanceId;
setParameter("DBInstanceId", dBInstanceId);
}
long DescribeDBInstancesAsCsvRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInstancesAsCsvRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDBInstancesAsCsvRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInstancesAsCsvRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

Some files were not shown because too many files have changed in this diff Show More