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

update Slb module

Browse Source
This commit is contained in:
fenglc
2018-02-05 15:16:14 +08:00
parent eaaa575e1d
commit c078095dfe
237 changed files with 3242 additions and 3729 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
slb/src/model/AddBackendServersRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/AddBackendServersRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::AddBackendServersRequest;
AddBackendServersRequest::AddBackendServersRequest() :
SlbRequest("AddBackendServers")
RpcServiceRequest("slb", "2014-05-15", "AddBackendServers")
{}
AddBackendServersRequest::~AddBackendServersRequest()
@@ -114,17 +113,6 @@ void AddBackendServersRequest::setBackendServers(const std::string& backendServe
setParameter("BackendServers", backendServers);
}
std::string AddBackendServersRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void AddBackendServersRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string AddBackendServersRequest::getTags()const
{
return tags_;

17
slb/src/model/AddBackendServersResult.cc
View File

@@ -43,12 +43,15 @@ void AddBackendServersResult::parse(const std::string &payload)
auto allBackendServers = value["BackendServers"]["BackendServer"];
for (auto value : allBackendServers)
{
BackendServer backendServerObject;
backendServerObject.serverId = value["ServerId"].asString();
backendServerObject.weight = value["Weight"].asString();
backendServers_.push_back(backendServerObject);
BackendServer backendServersObject;
if(!value["ServerId"].isNull())
backendServersObject.serverId = value["ServerId"].asString();
if(!value["Weight"].isNull())
backendServersObject.weight = value["Weight"].asString();
backendServers_.push_back(backendServersObject);
}
loadBalancerId_ = value["LoadBalancerId"].asString();
if(!value["LoadBalancerId"].isNull())
loadBalancerId_ = value["LoadBalancerId"].asString();
}
@@ -57,8 +60,8 @@ std::string AddBackendServersResult::getLoadBalancerId()const
return loadBalancerId_;
}
void AddBackendServersResult::setLoadBalancerId(const std::string& loadBalancerId)
std::vector<AddBackendServersResult::BackendServer> AddBackendServersResult::getBackendServers()const
{
loadBalancerId_ = loadBalancerId;
return backendServers_;
}

16
slb/src/model/AddListenerWhiteListItemRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/AddListenerWhiteListItemRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::AddListenerWhiteListItemRequest;
AddListenerWhiteListItemRequest::AddListenerWhiteListItemRequest() :
SlbRequest("AddListenerWhiteListItem")
RpcServiceRequest("slb", "2014-05-15", "AddListenerWhiteListItem")
{}
AddListenerWhiteListItemRequest::~AddListenerWhiteListItemRequest()
@@ -125,17 +124,6 @@ void AddListenerWhiteListItemRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string AddListenerWhiteListItemRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void AddListenerWhiteListItemRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string AddListenerWhiteListItemRequest::getTags()const
{
return tags_;

16
slb/src/model/AddTagsRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/AddTagsRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::AddTagsRequest;
AddTagsRequest::AddTagsRequest() :
SlbRequest("AddTags")
RpcServiceRequest("slb", "2014-05-15", "AddTags")
{}
AddTagsRequest::~AddTagsRequest()
@@ -103,17 +102,6 @@ void AddTagsRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string AddTagsRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void AddTagsRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string AddTagsRequest::getTags()const
{
return tags_;

16
slb/src/model/AddVServerGroupBackendServersRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/AddVServerGroupBackendServersRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::AddVServerGroupBackendServersRequest;
AddVServerGroupBackendServersRequest::AddVServerGroupBackendServersRequest() :
SlbRequest("AddVServerGroupBackendServers")
RpcServiceRequest("slb", "2014-05-15", "AddVServerGroupBackendServers")
{}
AddVServerGroupBackendServersRequest::~AddVServerGroupBackendServersRequest()
@@ -114,17 +113,6 @@ void AddVServerGroupBackendServersRequest::setBackendServers(const std::string&
setParameter("BackendServers", backendServers);
}
std::string AddVServerGroupBackendServersRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void AddVServerGroupBackendServersRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string AddVServerGroupBackendServersRequest::getTags()const
{
return tags_;

20
slb/src/model/AddVServerGroupBackendServersResult.cc
View File

@@ -43,13 +43,17 @@ void AddVServerGroupBackendServersResult::parse(const std::string &payload)
auto allBackendServers = value["BackendServers"]["BackendServer"];
for (auto value : allBackendServers)
{
BackendServer backendServerObject;
backendServerObject.serverId = value["ServerId"].asString();
backendServerObject.port = std::stoi(value["Port"].asString());
backendServerObject.weight = std::stoi(value["Weight"].asString());
backendServers_.push_back(backendServerObject);
BackendServer backendServersObject;
if(!value["ServerId"].isNull())
backendServersObject.serverId = value["ServerId"].asString();
if(!value["Port"].isNull())
backendServersObject.port = std::stoi(value["Port"].asString());
if(!value["Weight"].isNull())
backendServersObject.weight = std::stoi(value["Weight"].asString());
backendServers_.push_back(backendServersObject);
}
vServerGroupId_ = value["VServerGroupId"].asString();
if(!value["VServerGroupId"].isNull())
vServerGroupId_ = value["VServerGroupId"].asString();
}
@@ -58,8 +62,8 @@ std::string AddVServerGroupBackendServersResult::getVServerGroupId()const
return vServerGroupId_;
}
void AddVServerGroupBackendServersResult::setVServerGroupId(const std::string& vServerGroupId)
std::vector<AddVServerGroupBackendServersResult::BackendServer> AddVServerGroupBackendServersResult::getBackendServers()const
{
vServerGroupId_ = vServerGroupId;
return backendServers_;
}

16
slb/src/model/CreateLoadBalancerHTTPListenerRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/CreateLoadBalancerHTTPListenerRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::CreateLoadBalancerHTTPListenerRequest;
CreateLoadBalancerHTTPListenerRequest::CreateLoadBalancerHTTPListenerRequest() :
SlbRequest("CreateLoadBalancerHTTPListener")
RpcServiceRequest("slb", "2014-05-15", "CreateLoadBalancerHTTPListener")
{}
CreateLoadBalancerHTTPListenerRequest::~CreateLoadBalancerHTTPListenerRequest()
@@ -103,17 +102,6 @@ void CreateLoadBalancerHTTPListenerRequest::setHealthyThreshold(int healthyThres
setParameter("HealthyThreshold", std::to_string(healthyThreshold));
}
std::string CreateLoadBalancerHTTPListenerRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateLoadBalancerHTTPListenerRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateLoadBalancerHTTPListenerRequest::getScheduler()const
{
return scheduler_;

16
slb/src/model/CreateLoadBalancerHTTPSListenerRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/CreateLoadBalancerHTTPSListenerRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::CreateLoadBalancerHTTPSListenerRequest;
CreateLoadBalancerHTTPSListenerRequest::CreateLoadBalancerHTTPSListenerRequest() :
SlbRequest("CreateLoadBalancerHTTPSListener")
RpcServiceRequest("slb", "2014-05-15", "CreateLoadBalancerHTTPSListener")
{}
CreateLoadBalancerHTTPSListenerRequest::~CreateLoadBalancerHTTPSListenerRequest()
@@ -103,17 +102,6 @@ void CreateLoadBalancerHTTPSListenerRequest::setHealthyThreshold(int healthyThre
setParameter("HealthyThreshold", std::to_string(healthyThreshold));
}
std::string CreateLoadBalancerHTTPSListenerRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateLoadBalancerHTTPSListenerRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateLoadBalancerHTTPSListenerRequest::getScheduler()const
{
return scheduler_;

214
slb/src/model/CreateLoadBalancerRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/CreateLoadBalancerRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::CreateLoadBalancerRequest;
CreateLoadBalancerRequest::CreateLoadBalancerRequest() :
SlbRequest("CreateLoadBalancer")
RpcServiceRequest("slb", "2014-05-15", "CreateLoadBalancer")
{}
CreateLoadBalancerRequest::~CreateLoadBalancerRequest()
@@ -37,116 +36,6 @@ void CreateLoadBalancerRequest::setAccess_key_id(const std::string& access_key_i
setParameter("Access_key_id", access_key_id);
}
long CreateLoadBalancerRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateLoadBalancerRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateLoadBalancerRequest::getClientToken()const
{
return clientToken_;
}
void CreateLoadBalancerRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CreateLoadBalancerRequest::getMasterZoneId()const
{
return masterZoneId_;
}
void CreateLoadBalancerRequest::setMasterZoneId(const std::string& masterZoneId)
{
masterZoneId_ = masterZoneId;
setParameter("MasterZoneId", masterZoneId);
}
std::string CreateLoadBalancerRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateLoadBalancerRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
int CreateLoadBalancerRequest::getDuration()const
{
return duration_;
}
void CreateLoadBalancerRequest::setDuration(int duration)
{
duration_ = duration;
setParameter("Duration", std::to_string(duration));
}
std::string CreateLoadBalancerRequest::getResourceGroupId()const
{
return resourceGroupId_;
}
void CreateLoadBalancerRequest::setResourceGroupId(const std::string& resourceGroupId)
{
resourceGroupId_ = resourceGroupId;
setParameter("ResourceGroupId", resourceGroupId);
}
std::string CreateLoadBalancerRequest::getLoadBalancerName()const
{
return loadBalancerName_;
}
void CreateLoadBalancerRequest::setLoadBalancerName(const std::string& loadBalancerName)
{
loadBalancerName_ = loadBalancerName;
setParameter("LoadBalancerName", loadBalancerName);
}
std::string CreateLoadBalancerRequest::getRegionId()const
{
return regionId_;
}
void CreateLoadBalancerRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateLoadBalancerRequest::getAddressType()const
{
return addressType_;
}
void CreateLoadBalancerRequest::setAddressType(const std::string& addressType)
{
addressType_ = addressType;
setParameter("AddressType", addressType);
}
std::string CreateLoadBalancerRequest::getSlaveZoneId()const
{
return slaveZoneId_;
}
void CreateLoadBalancerRequest::setSlaveZoneId(const std::string& slaveZoneId)
{
slaveZoneId_ = slaveZoneId;
setParameter("SlaveZoneId", slaveZoneId);
}
std::string CreateLoadBalancerRequest::getLoadBalancerSpec()const
{
return loadBalancerSpec_;
@@ -158,6 +47,17 @@ void CreateLoadBalancerRequest::setLoadBalancerSpec(const std::string& loadBalan
setParameter("LoadBalancerSpec", loadBalancerSpec);
}
long CreateLoadBalancerRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateLoadBalancerRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
bool CreateLoadBalancerRequest::getAutoPay()const
{
return autoPay_;
@@ -191,6 +91,17 @@ void CreateLoadBalancerRequest::setBandwidth(int bandwidth)
setParameter("Bandwidth", std::to_string(bandwidth));
}
std::string CreateLoadBalancerRequest::getClientToken()const
{
return clientToken_;
}
void CreateLoadBalancerRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CreateLoadBalancerRequest::getOwnerAccount()const
{
return ownerAccount_;
@@ -213,6 +124,17 @@ void CreateLoadBalancerRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateLoadBalancerRequest::getMasterZoneId()const
{
return masterZoneId_;
}
void CreateLoadBalancerRequest::setMasterZoneId(const std::string& masterZoneId)
{
masterZoneId_ = masterZoneId;
setParameter("MasterZoneId", masterZoneId);
}
std::string CreateLoadBalancerRequest::getTags()const
{
return tags_;
@@ -235,6 +157,39 @@ void CreateLoadBalancerRequest::setVSwitchId(const std::string& vSwitchId)
setParameter("VSwitchId", vSwitchId);
}
int CreateLoadBalancerRequest::getDuration()const
{
return duration_;
}
void CreateLoadBalancerRequest::setDuration(int duration)
{
duration_ = duration;
setParameter("Duration", std::to_string(duration));
}
std::string CreateLoadBalancerRequest::getResourceGroupId()const
{
return resourceGroupId_;
}
void CreateLoadBalancerRequest::setResourceGroupId(const std::string& resourceGroupId)
{
resourceGroupId_ = resourceGroupId;
setParameter("ResourceGroupId", resourceGroupId);
}
std::string CreateLoadBalancerRequest::getLoadBalancerName()const
{
return loadBalancerName_;
}
void CreateLoadBalancerRequest::setLoadBalancerName(const std::string& loadBalancerName)
{
loadBalancerName_ = loadBalancerName;
setParameter("LoadBalancerName", loadBalancerName);
}
std::string CreateLoadBalancerRequest::getEnableVpcVipFlow()const
{
return enableVpcVipFlow_;
@@ -246,6 +201,17 @@ void CreateLoadBalancerRequest::setEnableVpcVipFlow(const std::string& enableVpc
setParameter("EnableVpcVipFlow", enableVpcVipFlow);
}
std::string CreateLoadBalancerRequest::getRegionId()const
{
return regionId_;
}
void CreateLoadBalancerRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateLoadBalancerRequest::getInternetChargeType()const
{
return internetChargeType_;
@@ -268,6 +234,28 @@ void CreateLoadBalancerRequest::setVpcId(const std::string& vpcId)
setParameter("VpcId", vpcId);
}
std::string CreateLoadBalancerRequest::getAddressType()const
{
return addressType_;
}
void CreateLoadBalancerRequest::setAddressType(const std::string& addressType)
{
addressType_ = addressType;
setParameter("AddressType", addressType);
}
std::string CreateLoadBalancerRequest::getSlaveZoneId()const
{
return slaveZoneId_;
}
void CreateLoadBalancerRequest::setSlaveZoneId(const std::string& slaveZoneId)
{
slaveZoneId_ = slaveZoneId;
setParameter("SlaveZoneId", slaveZoneId);
}
std::string CreateLoadBalancerRequest::getPayType()const
{
return payType_;

64
slb/src/model/CreateLoadBalancerResult.cc
View File

@@ -40,14 +40,22 @@ void CreateLoadBalancerResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
loadBalancerId_ = value["LoadBalancerId"].asString();
resourceGroupId_ = value["ResourceGroupId"].asString();
address_ = value["Address"].asString();
loadBalancerName_ = value["LoadBalancerName"].asString();
vpcId_ = value["VpcId"].asString();
vSwitchId_ = value["VSwitchId"].asString();
networkType_ = value["NetworkType"].asString();
orderId_ = std::stol(value["OrderId"].asString());
if(!value["LoadBalancerId"].isNull())
loadBalancerId_ = value["LoadBalancerId"].asString();
if(!value["ResourceGroupId"].isNull())
resourceGroupId_ = value["ResourceGroupId"].asString();
if(!value["Address"].isNull())
address_ = value["Address"].asString();
if(!value["LoadBalancerName"].isNull())
loadBalancerName_ = value["LoadBalancerName"].asString();
if(!value["VpcId"].isNull())
vpcId_ = value["VpcId"].asString();
if(!value["VSwitchId"].isNull())
vSwitchId_ = value["VSwitchId"].asString();
if(!value["NetworkType"].isNull())
networkType_ = value["NetworkType"].asString();
if(!value["OrderId"].isNull())
orderId_ = std::stol(value["OrderId"].asString());
}
@@ -56,78 +64,38 @@ std::string CreateLoadBalancerResult::getLoadBalancerName()const
return loadBalancerName_;
}
void CreateLoadBalancerResult::setLoadBalancerName(const std::string& loadBalancerName)
{
loadBalancerName_ = loadBalancerName;
}
std::string CreateLoadBalancerResult::getResourceGroupId()const
{
return resourceGroupId_;
}
void CreateLoadBalancerResult::setResourceGroupId(const std::string& resourceGroupId)
{
resourceGroupId_ = resourceGroupId;
}
std::string CreateLoadBalancerResult::getAddress()const
{
return address_;
}
void CreateLoadBalancerResult::setAddress(const std::string& address)
{
address_ = address;
}
std::string CreateLoadBalancerResult::getVpcId()const
{
return vpcId_;
}
void CreateLoadBalancerResult::setVpcId(const std::string& vpcId)
{
vpcId_ = vpcId;
}
std::string CreateLoadBalancerResult::getNetworkType()const
{
return networkType_;
}
void CreateLoadBalancerResult::setNetworkType(const std::string& networkType)
{
networkType_ = networkType;
}
std::string CreateLoadBalancerResult::getVSwitchId()const
{
return vSwitchId_;
}
void CreateLoadBalancerResult::setVSwitchId(const std::string& vSwitchId)
{
vSwitchId_ = vSwitchId;
}
std::string CreateLoadBalancerResult::getLoadBalancerId()const
{
return loadBalancerId_;
}
void CreateLoadBalancerResult::setLoadBalancerId(const std::string& loadBalancerId)
{
loadBalancerId_ = loadBalancerId;
}
long CreateLoadBalancerResult::getOrderId()const
{
return orderId_;
}
void CreateLoadBalancerResult::setOrderId(long orderId)
{
orderId_ = orderId;
}

16
slb/src/model/CreateLoadBalancerTCPListenerRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/CreateLoadBalancerTCPListenerRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::CreateLoadBalancerTCPListenerRequest;
CreateLoadBalancerTCPListenerRequest::CreateLoadBalancerTCPListenerRequest() :
SlbRequest("CreateLoadBalancerTCPListener")
RpcServiceRequest("slb", "2014-05-15", "CreateLoadBalancerTCPListener")
{}
CreateLoadBalancerTCPListenerRequest::~CreateLoadBalancerTCPListenerRequest()
@@ -92,17 +91,6 @@ void CreateLoadBalancerTCPListenerRequest::setHealthyThreshold(int healthyThresh
setParameter("HealthyThreshold", std::to_string(healthyThreshold));
}
std::string CreateLoadBalancerTCPListenerRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateLoadBalancerTCPListenerRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateLoadBalancerTCPListenerRequest::getScheduler()const
{
return scheduler_;

170
slb/src/model/CreateLoadBalancerUDPListenerRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/CreateLoadBalancerUDPListenerRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::CreateLoadBalancerUDPListenerRequest;
CreateLoadBalancerUDPListenerRequest::CreateLoadBalancerUDPListenerRequest() :
SlbRequest("CreateLoadBalancerUDPListener")
RpcServiceRequest("slb", "2014-05-15", "CreateLoadBalancerUDPListener")
{}
CreateLoadBalancerUDPListenerRequest::~CreateLoadBalancerUDPListenerRequest()
@@ -37,6 +36,17 @@ void CreateLoadBalancerUDPListenerRequest::setAccess_key_id(const std::string& a
setParameter("Access_key_id", access_key_id);
}
std::string CreateLoadBalancerUDPListenerRequest::getVServerGroupId()const
{
return vServerGroupId_;
}
void CreateLoadBalancerUDPListenerRequest::setVServerGroupId(const std::string& vServerGroupId)
{
vServerGroupId_ = vServerGroupId;
setParameter("VServerGroupId", vServerGroupId);
}
int CreateLoadBalancerUDPListenerRequest::getHealthCheckConnectTimeout()const
{
return healthCheckConnectTimeout_;
@@ -59,94 +69,6 @@ void CreateLoadBalancerUDPListenerRequest::setResourceOwnerId(long resourceOwner
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
int CreateLoadBalancerUDPListenerRequest::getUnhealthyThreshold()const
{
return unhealthyThreshold_;
}
void CreateLoadBalancerUDPListenerRequest::setUnhealthyThreshold(int unhealthyThreshold)
{
unhealthyThreshold_ = unhealthyThreshold;
setParameter("UnhealthyThreshold", std::to_string(unhealthyThreshold));
}
int CreateLoadBalancerUDPListenerRequest::getHealthyThreshold()const
{
return healthyThreshold_;
}
void CreateLoadBalancerUDPListenerRequest::setHealthyThreshold(int healthyThreshold)
{
healthyThreshold_ = healthyThreshold;
setParameter("HealthyThreshold", std::to_string(healthyThreshold));
}
std::string CreateLoadBalancerUDPListenerRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateLoadBalancerUDPListenerRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateLoadBalancerUDPListenerRequest::getScheduler()const
{
return scheduler_;
}
void CreateLoadBalancerUDPListenerRequest::setScheduler(const std::string& scheduler)
{
scheduler_ = scheduler;
setParameter("Scheduler", scheduler);
}
int CreateLoadBalancerUDPListenerRequest::getMaxConnection()const
{
return maxConnection_;
}
void CreateLoadBalancerUDPListenerRequest::setMaxConnection(int maxConnection)
{
maxConnection_ = maxConnection;
setParameter("MaxConnection", std::to_string(maxConnection));
}
std::string CreateLoadBalancerUDPListenerRequest::getRegionId()const
{
return regionId_;
}
void CreateLoadBalancerUDPListenerRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
int CreateLoadBalancerUDPListenerRequest::getPersistenceTimeout()const
{
return persistenceTimeout_;
}
void CreateLoadBalancerUDPListenerRequest::setPersistenceTimeout(int persistenceTimeout)
{
persistenceTimeout_ = persistenceTimeout;
setParameter("PersistenceTimeout", std::to_string(persistenceTimeout));
}
std::string CreateLoadBalancerUDPListenerRequest::getVServerGroupId()const
{
return vServerGroupId_;
}
void CreateLoadBalancerUDPListenerRequest::setVServerGroupId(const std::string& vServerGroupId)
{
vServerGroupId_ = vServerGroupId;
setParameter("VServerGroupId", vServerGroupId);
}
int CreateLoadBalancerUDPListenerRequest::getListenerPort()const
{
return listenerPort_;
@@ -191,6 +113,17 @@ void CreateLoadBalancerUDPListenerRequest::setOwnerAccount(const std::string& ow
setParameter("OwnerAccount", ownerAccount);
}
int CreateLoadBalancerUDPListenerRequest::getUnhealthyThreshold()const
{
return unhealthyThreshold_;
}
void CreateLoadBalancerUDPListenerRequest::setUnhealthyThreshold(int unhealthyThreshold)
{
unhealthyThreshold_ = unhealthyThreshold;
setParameter("UnhealthyThreshold", std::to_string(unhealthyThreshold));
}
long CreateLoadBalancerUDPListenerRequest::getOwnerId()const
{
return ownerId_;
@@ -202,6 +135,17 @@ void CreateLoadBalancerUDPListenerRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
int CreateLoadBalancerUDPListenerRequest::getHealthyThreshold()const
{
return healthyThreshold_;
}
void CreateLoadBalancerUDPListenerRequest::setHealthyThreshold(int healthyThreshold)
{
healthyThreshold_ = healthyThreshold;
setParameter("HealthyThreshold", std::to_string(healthyThreshold));
}
std::string CreateLoadBalancerUDPListenerRequest::getTags()const
{
return tags_;
@@ -213,6 +157,17 @@ void CreateLoadBalancerUDPListenerRequest::setTags(const std::string& tags)
setParameter("Tags", tags);
}
std::string CreateLoadBalancerUDPListenerRequest::getScheduler()const
{
return scheduler_;
}
void CreateLoadBalancerUDPListenerRequest::setScheduler(const std::string& scheduler)
{
scheduler_ = scheduler;
setParameter("Scheduler", scheduler);
}
std::string CreateLoadBalancerUDPListenerRequest::getLoadBalancerId()const
{
return loadBalancerId_;
@@ -224,6 +179,17 @@ void CreateLoadBalancerUDPListenerRequest::setLoadBalancerId(const std::string&
setParameter("LoadBalancerId", loadBalancerId);
}
int CreateLoadBalancerUDPListenerRequest::getMaxConnection()const
{
return maxConnection_;
}
void CreateLoadBalancerUDPListenerRequest::setMaxConnection(int maxConnection)
{
maxConnection_ = maxConnection;
setParameter("MaxConnection", std::to_string(maxConnection));
}
std::string CreateLoadBalancerUDPListenerRequest::getMasterSlaveServerGroupId()const
{
return masterSlaveServerGroupId_;
@@ -246,6 +212,17 @@ void CreateLoadBalancerUDPListenerRequest::setHealthCheckReq(const std::string&
setParameter("HealthCheckReq", healthCheckReq);
}
std::string CreateLoadBalancerUDPListenerRequest::getRegionId()const
{
return regionId_;
}
void CreateLoadBalancerUDPListenerRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
int CreateLoadBalancerUDPListenerRequest::getBackendServerPort()const
{
return backendServerPort_;
@@ -268,6 +245,17 @@ void CreateLoadBalancerUDPListenerRequest::setHealthCheckInterval(int healthChec
setParameter("HealthCheckInterval", std::to_string(healthCheckInterval));
}
int CreateLoadBalancerUDPListenerRequest::getPersistenceTimeout()const
{
return persistenceTimeout_;
}
void CreateLoadBalancerUDPListenerRequest::setPersistenceTimeout(int persistenceTimeout)
{
persistenceTimeout_ = persistenceTimeout;
setParameter("PersistenceTimeout", std::to_string(persistenceTimeout));
}
std::string CreateLoadBalancerUDPListenerRequest::getHealthCheckExp()const
{
return healthCheckExp_;

16
slb/src/model/CreateMasterSlaveServerGroupRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/CreateMasterSlaveServerGroupRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::CreateMasterSlaveServerGroupRequest;
CreateMasterSlaveServerGroupRequest::CreateMasterSlaveServerGroupRequest() :
SlbRequest("CreateMasterSlaveServerGroup")
RpcServiceRequest("slb", "2014-05-15", "CreateMasterSlaveServerGroup")
{}
CreateMasterSlaveServerGroupRequest::~CreateMasterSlaveServerGroupRequest()
@@ -125,17 +124,6 @@ void CreateMasterSlaveServerGroupRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateMasterSlaveServerGroupRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateMasterSlaveServerGroupRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateMasterSlaveServerGroupRequest::getTags()const
{
return tags_;

23
slb/src/model/CreateMasterSlaveServerGroupResult.cc
View File

@@ -43,14 +43,19 @@ void CreateMasterSlaveServerGroupResult::parse(const std::string &payload)
auto allMasterSlaveBackendServers = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
for (auto value : allMasterSlaveBackendServers)
{
MasterSlaveBackendServer masterSlaveBackendServerObject;
masterSlaveBackendServerObject.serverId = value["ServerId"].asString();
masterSlaveBackendServerObject.port = std::stoi(value["Port"].asString());
masterSlaveBackendServerObject.weight = std::stoi(value["Weight"].asString());
masterSlaveBackendServerObject.serverType = value["ServerType"].asString();
masterSlaveBackendServers_.push_back(masterSlaveBackendServerObject);
MasterSlaveBackendServer masterSlaveBackendServersObject;
if(!value["ServerId"].isNull())
masterSlaveBackendServersObject.serverId = value["ServerId"].asString();
if(!value["Port"].isNull())
masterSlaveBackendServersObject.port = std::stoi(value["Port"].asString());
if(!value["Weight"].isNull())
masterSlaveBackendServersObject.weight = std::stoi(value["Weight"].asString());
if(!value["ServerType"].isNull())
masterSlaveBackendServersObject.serverType = value["ServerType"].asString();
masterSlaveBackendServers_.push_back(masterSlaveBackendServersObject);
}
masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
if(!value["MasterSlaveServerGroupId"].isNull())
masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
}
@@ -59,8 +64,8 @@ std::string CreateMasterSlaveServerGroupResult::getMasterSlaveServerGroupId()con
return masterSlaveServerGroupId_;
}
void CreateMasterSlaveServerGroupResult::setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId)
std::vector<CreateMasterSlaveServerGroupResult::MasterSlaveBackendServer> CreateMasterSlaveServerGroupResult::getMasterSlaveBackendServers()const
{
masterSlaveServerGroupId_ = masterSlaveServerGroupId;
return masterSlaveBackendServers_;
}

5
slb/src/model/CreateMasterSlaveVServerGroupRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/CreateMasterSlaveVServerGroupRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::CreateMasterSlaveVServerGroupRequest;
CreateMasterSlaveVServerGroupRequest::CreateMasterSlaveVServerGroupRequest() :
SlbRequest("CreateMasterSlaveVServerGroup")
RpcServiceRequest("slb", "2014-05-15", "CreateMasterSlaveVServerGroup")
{}
CreateMasterSlaveVServerGroupRequest::~CreateMasterSlaveVServerGroupRequest()

23
slb/src/model/CreateMasterSlaveVServerGroupResult.cc
View File

@@ -43,14 +43,19 @@ void CreateMasterSlaveVServerGroupResult::parse(const std::string &payload)
auto allMasterSlaveBackendServers = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
for (auto value : allMasterSlaveBackendServers)
{
MasterSlaveBackendServer masterSlaveBackendServerObject;
masterSlaveBackendServerObject.serverId = value["ServerId"].asString();
masterSlaveBackendServerObject.port = std::stoi(value["Port"].asString());
masterSlaveBackendServerObject.weight = std::stoi(value["Weight"].asString());
masterSlaveBackendServerObject.isBackup = std::stoi(value["IsBackup"].asString());
masterSlaveBackendServers_.push_back(masterSlaveBackendServerObject);
MasterSlaveBackendServer masterSlaveBackendServersObject;
if(!value["ServerId"].isNull())
masterSlaveBackendServersObject.serverId = value["ServerId"].asString();
if(!value["Port"].isNull())
masterSlaveBackendServersObject.port = std::stoi(value["Port"].asString());
if(!value["Weight"].isNull())
masterSlaveBackendServersObject.weight = std::stoi(value["Weight"].asString());
if(!value["IsBackup"].isNull())
masterSlaveBackendServersObject.isBackup = std::stoi(value["IsBackup"].asString());
masterSlaveBackendServers_.push_back(masterSlaveBackendServersObject);
}
masterSlaveVServerGroupId_ = value["MasterSlaveVServerGroupId"].asString();
if(!value["MasterSlaveVServerGroupId"].isNull())
masterSlaveVServerGroupId_ = value["MasterSlaveVServerGroupId"].asString();
}
@@ -59,8 +64,8 @@ std::string CreateMasterSlaveVServerGroupResult::getMasterSlaveVServerGroupId()c
return masterSlaveVServerGroupId_;
}
void CreateMasterSlaveVServerGroupResult::setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId)
std::vector<CreateMasterSlaveVServerGroupResult::MasterSlaveBackendServer> CreateMasterSlaveVServerGroupResult::getMasterSlaveBackendServers()const
{
masterSlaveVServerGroupId_ = masterSlaveVServerGroupId;
return masterSlaveBackendServers_;
}

16
slb/src/model/CreateRulesRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/CreateRulesRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::CreateRulesRequest;
CreateRulesRequest::CreateRulesRequest() :
SlbRequest("CreateRules")
RpcServiceRequest("slb", "2014-05-15", "CreateRules")
{}
CreateRulesRequest::~CreateRulesRequest()
@@ -125,17 +124,6 @@ void CreateRulesRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateRulesRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateRulesRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateRulesRequest::getTags()const
{
return tags_;

15
slb/src/model/CreateRulesResult.cc
View File

@@ -43,11 +43,18 @@ void CreateRulesResult::parse(const std::string &payload)
auto allRules = value["Rules"]["Rule"];
for (auto value : allRules)
{
Rule ruleObject;
ruleObject.ruleId = value["RuleId"].asString();
ruleObject.ruleName = value["RuleName"].asString();
rules_.push_back(ruleObject);
Rule rulesObject;
if(!value["RuleId"].isNull())
rulesObject.ruleId = value["RuleId"].asString();
if(!value["RuleName"].isNull())
rulesObject.ruleName = value["RuleName"].asString();
rules_.push_back(rulesObject);
}
}
std::vector<CreateRulesResult::Rule> CreateRulesResult::getRules()const
{
return rules_;
}

16
slb/src/model/CreateVServerGroupRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/CreateVServerGroupRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::CreateVServerGroupRequest;
CreateVServerGroupRequest::CreateVServerGroupRequest() :
SlbRequest("CreateVServerGroup")
RpcServiceRequest("slb", "2014-05-15", "CreateVServerGroup")
{}
CreateVServerGroupRequest::~CreateVServerGroupRequest()
@@ -114,17 +113,6 @@ void CreateVServerGroupRequest::setBackendServers(const std::string& backendServ
setParameter("BackendServers", backendServers);
}
std::string CreateVServerGroupRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateVServerGroupRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateVServerGroupRequest::getTags()const
{
return tags_;

20
slb/src/model/CreateVServerGroupResult.cc
View File

@@ -43,13 +43,17 @@ void CreateVServerGroupResult::parse(const std::string &payload)
auto allBackendServers = value["BackendServers"]["BackendServer"];
for (auto value : allBackendServers)
{
BackendServer backendServerObject;
backendServerObject.serverId = value["ServerId"].asString();
backendServerObject.port = std::stoi(value["Port"].asString());
backendServerObject.weight = std::stoi(value["Weight"].asString());
backendServers_.push_back(backendServerObject);
BackendServer backendServersObject;
if(!value["ServerId"].isNull())
backendServersObject.serverId = value["ServerId"].asString();
if(!value["Port"].isNull())
backendServersObject.port = std::stoi(value["Port"].asString());
if(!value["Weight"].isNull())
backendServersObject.weight = std::stoi(value["Weight"].asString());
backendServers_.push_back(backendServersObject);
}
vServerGroupId_ = value["VServerGroupId"].asString();
if(!value["VServerGroupId"].isNull())
vServerGroupId_ = value["VServerGroupId"].asString();
}
@@ -58,8 +62,8 @@ std::string CreateVServerGroupResult::getVServerGroupId()const
return vServerGroupId_;
}
void CreateVServerGroupResult::setVServerGroupId(const std::string& vServerGroupId)
std::vector<CreateVServerGroupResult::BackendServer> CreateVServerGroupResult::getBackendServers()const
{
vServerGroupId_ = vServerGroupId;
return backendServers_;
}

126
slb/src/model/DeleteAccessLogsDownloadAttributeRequest.cc Normal file
View File

@@ -0,0 +1,126 @@
/*
* 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/slb/model/DeleteAccessLogsDownloadAttributeRequest.h>
using AlibabaCloud::Slb::Model::DeleteAccessLogsDownloadAttributeRequest;
DeleteAccessLogsDownloadAttributeRequest::DeleteAccessLogsDownloadAttributeRequest() :
RpcServiceRequest("slb", "2014-05-15", "DeleteAccessLogsDownloadAttribute")
{}
DeleteAccessLogsDownloadAttributeRequest::~DeleteAccessLogsDownloadAttributeRequest()
{}
std::string DeleteAccessLogsDownloadAttributeRequest::getAccess_key_id()const
{
return access_key_id_;
}
void DeleteAccessLogsDownloadAttributeRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
long DeleteAccessLogsDownloadAttributeRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteAccessLogsDownloadAttributeRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteAccessLogsDownloadAttributeRequest::getLoadBalancerId()const
{
return loadBalancerId_;
}
void DeleteAccessLogsDownloadAttributeRequest::setLoadBalancerId(const std::string& loadBalancerId)
{
loadBalancerId_ = loadBalancerId;
setParameter("LoadBalancerId", loadBalancerId);
}
std::string DeleteAccessLogsDownloadAttributeRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteAccessLogsDownloadAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteAccessLogsDownloadAttributeRequest::getRegionId()const
{
return regionId_;
}
void DeleteAccessLogsDownloadAttributeRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DeleteAccessLogsDownloadAttributeRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteAccessLogsDownloadAttributeRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DeleteAccessLogsDownloadAttributeRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteAccessLogsDownloadAttributeRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteAccessLogsDownloadAttributeRequest::getTags()const
{
return tags_;
}
void DeleteAccessLogsDownloadAttributeRequest::setTags(const std::string& tags)
{
tags_ = tags;
setParameter("Tags", tags);
}
std::string DeleteAccessLogsDownloadAttributeRequest::getLogsDownloadAttributes()const
{
return logsDownloadAttributes_;
}
void DeleteAccessLogsDownloadAttributeRequest::setLogsDownloadAttributes(const std::string& logsDownloadAttributes)
{
logsDownloadAttributes_ = logsDownloadAttributes;
setParameter("LogsDownloadAttributes", logsDownloadAttributes);
}

45
slb/src/model/DeleteAccessLogsDownloadAttributeResult.cc Normal file
View File

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

16
slb/src/model/DeleteCACertificateRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DeleteCACertificateRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DeleteCACertificateRequest;
DeleteCACertificateRequest::DeleteCACertificateRequest() :
SlbRequest("DeleteCACertificate")
RpcServiceRequest("slb", "2014-05-15", "DeleteCACertificate")
{}
DeleteCACertificateRequest::~DeleteCACertificateRequest()
@@ -103,14 +102,3 @@ void DeleteCACertificateRequest::setCACertificateId(const std::string& cACertifi
setParameter("CACertificateId", cACertificateId);
}
std::string DeleteCACertificateRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteCACertificateRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

16
slb/src/model/DeleteLoadBalancerListenerRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DeleteLoadBalancerListenerRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DeleteLoadBalancerListenerRequest;
DeleteLoadBalancerListenerRequest::DeleteLoadBalancerListenerRequest() :
SlbRequest("DeleteLoadBalancerListener")
RpcServiceRequest("slb", "2014-05-15", "DeleteLoadBalancerListener")
{}
DeleteLoadBalancerListenerRequest::~DeleteLoadBalancerListenerRequest()
@@ -114,17 +113,6 @@ void DeleteLoadBalancerListenerRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteLoadBalancerListenerRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteLoadBalancerListenerRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DeleteLoadBalancerListenerRequest::getTags()const
{
return tags_;

16
slb/src/model/DeleteLoadBalancerRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DeleteLoadBalancerRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DeleteLoadBalancerRequest;
DeleteLoadBalancerRequest::DeleteLoadBalancerRequest() :
SlbRequest("DeleteLoadBalancer")
RpcServiceRequest("slb", "2014-05-15", "DeleteLoadBalancer")
{}
DeleteLoadBalancerRequest::~DeleteLoadBalancerRequest()
@@ -103,17 +102,6 @@ void DeleteLoadBalancerRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteLoadBalancerRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteLoadBalancerRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DeleteLoadBalancerRequest::getTags()const
{
return tags_;

16
slb/src/model/DeleteMasterSlaveServerGroupRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DeleteMasterSlaveServerGroupRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DeleteMasterSlaveServerGroupRequest;
DeleteMasterSlaveServerGroupRequest::DeleteMasterSlaveServerGroupRequest() :
SlbRequest("DeleteMasterSlaveServerGroup")
RpcServiceRequest("slb", "2014-05-15", "DeleteMasterSlaveServerGroup")
{}
DeleteMasterSlaveServerGroupRequest::~DeleteMasterSlaveServerGroupRequest()
@@ -103,17 +102,6 @@ void DeleteMasterSlaveServerGroupRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteMasterSlaveServerGroupRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteMasterSlaveServerGroupRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DeleteMasterSlaveServerGroupRequest::getTags()const
{
return tags_;

5
slb/src/model/DeleteMasterSlaveVServerGroupRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DeleteMasterSlaveVServerGroupRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DeleteMasterSlaveVServerGroupRequest;
DeleteMasterSlaveVServerGroupRequest::DeleteMasterSlaveVServerGroupRequest() :
SlbRequest("DeleteMasterSlaveVServerGroup")
RpcServiceRequest("slb", "2014-05-15", "DeleteMasterSlaveVServerGroup")
{}
DeleteMasterSlaveVServerGroupRequest::~DeleteMasterSlaveVServerGroupRequest()

16
slb/src/model/DeleteRulesRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DeleteRulesRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DeleteRulesRequest;
DeleteRulesRequest::DeleteRulesRequest() :
SlbRequest("DeleteRules")
RpcServiceRequest("slb", "2014-05-15", "DeleteRules")
{}
DeleteRulesRequest::~DeleteRulesRequest()
@@ -103,17 +102,6 @@ void DeleteRulesRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteRulesRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteRulesRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DeleteRulesRequest::getTags()const
{
return tags_;

16
slb/src/model/DeleteServerCertificateRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DeleteServerCertificateRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DeleteServerCertificateRequest;
DeleteServerCertificateRequest::DeleteServerCertificateRequest() :
SlbRequest("DeleteServerCertificate")
RpcServiceRequest("slb", "2014-05-15", "DeleteServerCertificate")
{}
DeleteServerCertificateRequest::~DeleteServerCertificateRequest()
@@ -103,17 +102,6 @@ void DeleteServerCertificateRequest::setServerCertificateId(const std::string& s
setParameter("ServerCertificateId", serverCertificateId);
}
std::string DeleteServerCertificateRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteServerCertificateRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DeleteServerCertificateRequest::getTags()const
{
return tags_;

16
slb/src/model/DeleteVServerGroupRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DeleteVServerGroupRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DeleteVServerGroupRequest;
DeleteVServerGroupRequest::DeleteVServerGroupRequest() :
SlbRequest("DeleteVServerGroup")
RpcServiceRequest("slb", "2014-05-15", "DeleteVServerGroup")
{}
DeleteVServerGroupRequest::~DeleteVServerGroupRequest()
@@ -103,17 +102,6 @@ void DeleteVServerGroupRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteVServerGroupRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteVServerGroupRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DeleteVServerGroupRequest::getTags()const
{
return tags_;

148
slb/src/model/DescribeAccessLogsDownloadAttributeRequest.cc Normal file
View File

@@ -0,0 +1,148 @@
/*
* 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/slb/model/DescribeAccessLogsDownloadAttributeRequest.h>
using AlibabaCloud::Slb::Model::DescribeAccessLogsDownloadAttributeRequest;
DescribeAccessLogsDownloadAttributeRequest::DescribeAccessLogsDownloadAttributeRequest() :
RpcServiceRequest("slb", "2014-05-15", "DescribeAccessLogsDownloadAttribute")
{}
DescribeAccessLogsDownloadAttributeRequest::~DescribeAccessLogsDownloadAttributeRequest()
{}
std::string DescribeAccessLogsDownloadAttributeRequest::getAccess_key_id()const
{
return access_key_id_;
}
void DescribeAccessLogsDownloadAttributeRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
long DescribeAccessLogsDownloadAttributeRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeAccessLogsDownloadAttributeRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeAccessLogsDownloadAttributeRequest::getLogType()const
{
return logType_;
}
void DescribeAccessLogsDownloadAttributeRequest::setLogType(const std::string& logType)
{
logType_ = logType;
setParameter("LogType", logType);
}
std::string DescribeAccessLogsDownloadAttributeRequest::getLoadBalancerId()const
{
return loadBalancerId_;
}
void DescribeAccessLogsDownloadAttributeRequest::setLoadBalancerId(const std::string& loadBalancerId)
{
loadBalancerId_ = loadBalancerId;
setParameter("LoadBalancerId", loadBalancerId);
}
std::string DescribeAccessLogsDownloadAttributeRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeAccessLogsDownloadAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeAccessLogsDownloadAttributeRequest::getRegionId()const
{
return regionId_;
}
void DescribeAccessLogsDownloadAttributeRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribeAccessLogsDownloadAttributeRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeAccessLogsDownloadAttributeRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
int DescribeAccessLogsDownloadAttributeRequest::getPageSize()const
{
return pageSize_;
}
void DescribeAccessLogsDownloadAttributeRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
long DescribeAccessLogsDownloadAttributeRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeAccessLogsDownloadAttributeRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
int DescribeAccessLogsDownloadAttributeRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeAccessLogsDownloadAttributeRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeAccessLogsDownloadAttributeRequest::getTags()const
{
return tags_;
}
void DescribeAccessLogsDownloadAttributeRequest::setTags(const std::string& tags)
{
tags_ = tags;
setParameter("Tags", tags);
}

96
slb/src/model/DescribeAccessLogsDownloadAttributeResult.cc Normal file
View File

@@ -0,0 +1,96 @@
/*
* 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/slb/model/DescribeAccessLogsDownloadAttributeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
DescribeAccessLogsDownloadAttributeResult::DescribeAccessLogsDownloadAttributeResult() :
ServiceResult()
{}
DescribeAccessLogsDownloadAttributeResult::DescribeAccessLogsDownloadAttributeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeAccessLogsDownloadAttributeResult::~DescribeAccessLogsDownloadAttributeResult()
{}
void DescribeAccessLogsDownloadAttributeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allLogsDownloadAttributes = value["LogsDownloadAttributes"]["LogsDownloadAttribute"];
for (auto value : allLogsDownloadAttributes)
{
LogsDownloadAttribute logsDownloadAttributesObject;
if(!value["LogProject"].isNull())
logsDownloadAttributesObject.logProject = value["LogProject"].asString();
if(!value["LogStore"].isNull())
logsDownloadAttributesObject.logStore = value["LogStore"].asString();
if(!value["LoadBalancerId"].isNull())
logsDownloadAttributesObject.loadBalancerId = value["LoadBalancerId"].asString();
if(!value["LogType"].isNull())
logsDownloadAttributesObject.logType = value["LogType"].asString();
if(!value["RoleArn"].isNull())
logsDownloadAttributesObject.roleArn = value["RoleArn"].asString();
if(!value["Region"].isNull())
logsDownloadAttributesObject.region = value["Region"].asString();
logsDownloadAttributes_.push_back(logsDownloadAttributesObject);
}
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
if(!value["Count"].isNull())
count_ = std::stoi(value["Count"].asString());
}
int DescribeAccessLogsDownloadAttributeResult::getTotalCount()const
{
return totalCount_;
}
int DescribeAccessLogsDownloadAttributeResult::getPageSize()const
{
return pageSize_;
}
int DescribeAccessLogsDownloadAttributeResult::getPageNumber()const
{
return pageNumber_;
}
int DescribeAccessLogsDownloadAttributeResult::getCount()const
{
return count_;
}
std::vector<DescribeAccessLogsDownloadAttributeResult::LogsDownloadAttribute> DescribeAccessLogsDownloadAttributeResult::getLogsDownloadAttributes()const
{
return logsDownloadAttributes_;
}

16
slb/src/model/DescribeCACertificatesRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeCACertificatesRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeCACertificatesRequest;
DescribeCACertificatesRequest::DescribeCACertificatesRequest() :
SlbRequest("DescribeCACertificates")
RpcServiceRequest("slb", "2014-05-15", "DescribeCACertificates")
{}
DescribeCACertificatesRequest::~DescribeCACertificatesRequest()
@@ -114,14 +113,3 @@ void DescribeCACertificatesRequest::setCACertificateId(const std::string& cACert
setParameter("CACertificateId", cACertificateId);
}
std::string DescribeCACertificatesRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeCACertificatesRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

30
slb/src/model/DescribeCACertificatesResult.cc
View File

@@ -43,16 +43,28 @@ void DescribeCACertificatesResult::parse(const std::string &payload)
auto allCACertificates = value["CACertificates"]["CACertificate"];
for (auto value : allCACertificates)
{
CACertificate cACertificateObject;
cACertificateObject.regionId = value["RegionId"].asString();
cACertificateObject.cACertificateId = value["CACertificateId"].asString();
cACertificateObject.cACertificateName = value["CACertificateName"].asString();
cACertificateObject.fingerprint = value["Fingerprint"].asString();
cACertificateObject.resourceGroupId = value["ResourceGroupId"].asString();
cACertificateObject.createTime = value["CreateTime"].asString();
cACertificateObject.createTimeStamp = std::stol(value["CreateTimeStamp"].asString());
cACertificates_.push_back(cACertificateObject);
CACertificate cACertificatesObject;
if(!value["RegionId"].isNull())
cACertificatesObject.regionId = value["RegionId"].asString();
if(!value["CACertificateId"].isNull())
cACertificatesObject.cACertificateId = value["CACertificateId"].asString();
if(!value["CACertificateName"].isNull())
cACertificatesObject.cACertificateName = value["CACertificateName"].asString();
if(!value["Fingerprint"].isNull())
cACertificatesObject.fingerprint = value["Fingerprint"].asString();
if(!value["ResourceGroupId"].isNull())
cACertificatesObject.resourceGroupId = value["ResourceGroupId"].asString();
if(!value["CreateTime"].isNull())
cACertificatesObject.createTime = value["CreateTime"].asString();
if(!value["CreateTimeStamp"].isNull())
cACertificatesObject.createTimeStamp = std::stol(value["CreateTimeStamp"].asString());
cACertificates_.push_back(cACertificatesObject);
}
}
std::vector<DescribeCACertificatesResult::CACertificate> DescribeCACertificatesResult::getCACertificates()const
{
return cACertificates_;
}

16
slb/src/model/DescribeHealthStatusRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeHealthStatusRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeHealthStatusRequest;
DescribeHealthStatusRequest::DescribeHealthStatusRequest() :
SlbRequest("DescribeHealthStatus")
RpcServiceRequest("slb", "2014-05-15", "DescribeHealthStatus")
{}
DescribeHealthStatusRequest::~DescribeHealthStatusRequest()
@@ -114,17 +113,6 @@ void DescribeHealthStatusRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeHealthStatusRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeHealthStatusRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeHealthStatusRequest::getTags()const
{
return tags_;

21
slb/src/model/DescribeHealthStatusResult.cc
View File

@@ -43,13 +43,22 @@ void DescribeHealthStatusResult::parse(const std::string &payload)
auto allBackendServers = value["BackendServers"]["BackendServer"];
for (auto value : allBackendServers)
{
BackendServer backendServerObject;
backendServerObject.listenerPort = std::stoi(value["ListenerPort"].asString());
backendServerObject.serverId = value["ServerId"].asString();
backendServerObject.port = std::stoi(value["Port"].asString());
backendServerObject.serverHealthStatus = value["ServerHealthStatus"].asString();
backendServers_.push_back(backendServerObject);
BackendServer backendServersObject;
if(!value["ListenerPort"].isNull())
backendServersObject.listenerPort = std::stoi(value["ListenerPort"].asString());
if(!value["ServerId"].isNull())
backendServersObject.serverId = value["ServerId"].asString();
if(!value["Port"].isNull())
backendServersObject.port = std::stoi(value["Port"].asString());
if(!value["ServerHealthStatus"].isNull())
backendServersObject.serverHealthStatus = value["ServerHealthStatus"].asString();
backendServers_.push_back(backendServersObject);
}
}
std::vector<DescribeHealthStatusResult::BackendServer> DescribeHealthStatusResult::getBackendServers()const
{
return backendServers_;
}

16
slb/src/model/DescribeListenerAccessControlAttributeRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeListenerAccessControlAttributeRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeListenerAccessControlAttributeRequest;
DescribeListenerAccessControlAttributeRequest::DescribeListenerAccessControlAttributeRequest() :
SlbRequest("DescribeListenerAccessControlAttribute")
RpcServiceRequest("slb", "2014-05-15", "DescribeListenerAccessControlAttribute")
{}
DescribeListenerAccessControlAttributeRequest::~DescribeListenerAccessControlAttributeRequest()
@@ -114,17 +113,6 @@ void DescribeListenerAccessControlAttributeRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeListenerAccessControlAttributeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeListenerAccessControlAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeListenerAccessControlAttributeRequest::getTags()const
{
return tags_;

16
slb/src/model/DescribeListenerAccessControlAttributeResult.cc
View File

@@ -40,8 +40,10 @@ void DescribeListenerAccessControlAttributeResult::parse(const std::string &payl
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
accessControlStatus_ = value["AccessControlStatus"].asString();
sourceItems_ = value["SourceItems"].asString();
if(!value["AccessControlStatus"].isNull())
accessControlStatus_ = value["AccessControlStatus"].asString();
if(!value["SourceItems"].isNull())
sourceItems_ = value["SourceItems"].asString();
}
@@ -50,18 +52,8 @@ std::string DescribeListenerAccessControlAttributeResult::getAccessControlStatus
return accessControlStatus_;
}
void DescribeListenerAccessControlAttributeResult::setAccessControlStatus(const std::string& accessControlStatus)
{
accessControlStatus_ = accessControlStatus;
}
std::string DescribeListenerAccessControlAttributeResult::getSourceItems()const
{
return sourceItems_;
}
void DescribeListenerAccessControlAttributeResult::setSourceItems(const std::string& sourceItems)
{
sourceItems_ = sourceItems;
}

16
slb/src/model/DescribeLoadBalancerAttributeRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeLoadBalancerAttributeRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeLoadBalancerAttributeRequest;
DescribeLoadBalancerAttributeRequest::DescribeLoadBalancerAttributeRequest() :
SlbRequest("DescribeLoadBalancerAttribute")
RpcServiceRequest("slb", "2014-05-15", "DescribeLoadBalancerAttribute")
{}
DescribeLoadBalancerAttributeRequest::~DescribeLoadBalancerAttributeRequest()
@@ -103,17 +102,6 @@ void DescribeLoadBalancerAttributeRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeLoadBalancerAttributeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeLoadBalancerAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeLoadBalancerAttributeRequest::getTags()const
{
return tags_;

338
slb/src/model/DescribeLoadBalancerAttributeResult.cc
View File

@@ -43,103 +43,106 @@ void DescribeLoadBalancerAttributeResult::parse(const std::string &payload)
auto allListenerPortsAndProtocal = value["ListenerPortsAndProtocal"]["ListenerPortAndProtocal"];
for (auto value : allListenerPortsAndProtocal)
{
ListenerPortAndProtocal listenerPortAndProtocalObject;
listenerPortAndProtocalObject.listenerPort = std::stoi(value["ListenerPort"].asString());
listenerPortAndProtocalObject.listenerProtocal = value["ListenerProtocal"].asString();
listenerPortsAndProtocal_.push_back(listenerPortAndProtocalObject);
ListenerPortAndProtocal listenerPortsAndProtocalObject;
if(!value["ListenerPort"].isNull())
listenerPortsAndProtocalObject.listenerPort = std::stoi(value["ListenerPort"].asString());
if(!value["ListenerProtocal"].isNull())
listenerPortsAndProtocalObject.listenerProtocal = value["ListenerProtocal"].asString();
listenerPortsAndProtocal_.push_back(listenerPortsAndProtocalObject);
}
auto allListenerPortsAndProtocol = value["ListenerPortsAndProtocol"]["ListenerPortAndProtocol"];
for (auto value : allListenerPortsAndProtocol)
{
ListenerPortAndProtocol listenerPortAndProtocolObject;
listenerPortAndProtocolObject.listenerPort = std::stoi(value["ListenerPort"].asString());
listenerPortAndProtocolObject.listenerProtocol = value["ListenerProtocol"].asString();
listenerPortsAndProtocol_.push_back(listenerPortAndProtocolObject);
ListenerPortAndProtocol listenerPortsAndProtocolObject;
if(!value["ListenerPort"].isNull())
listenerPortsAndProtocolObject.listenerPort = std::stoi(value["ListenerPort"].asString());
if(!value["ListenerProtocol"].isNull())
listenerPortsAndProtocolObject.listenerProtocol = value["ListenerProtocol"].asString();
listenerPortsAndProtocol_.push_back(listenerPortsAndProtocolObject);
}
auto allBackendServers = value["BackendServers"]["BackendServer"];
for (auto value : allBackendServers)
{
BackendServer backendServerObject;
backendServerObject.serverId = value["ServerId"].asString();
backendServerObject.weight = std::stoi(value["Weight"].asString());
backendServers_.push_back(backendServerObject);
BackendServer backendServersObject;
if(!value["ServerId"].isNull())
backendServersObject.serverId = value["ServerId"].asString();
if(!value["Weight"].isNull())
backendServersObject.weight = std::stoi(value["Weight"].asString());
backendServers_.push_back(backendServersObject);
}
auto allListenerPorts = value["ListenerPorts"]["ListenerPort"];
for (const auto &item : allListenerPorts)
listenerPorts_.push_back(item.asString());
loadBalancerId_ = value["LoadBalancerId"].asString();
resourceGroupId_ = value["ResourceGroupId"].asString();
loadBalancerName_ = value["LoadBalancerName"].asString();
loadBalancerStatus_ = value["LoadBalancerStatus"].asString();
regionId_ = value["RegionId"].asString();
regionIdAlias_ = value["RegionIdAlias"].asString();
address_ = value["Address"].asString();
addressType_ = value["AddressType"].asString();
vpcId_ = value["VpcId"].asString();
vSwitchId_ = value["VSwitchId"].asString();
networkType_ = value["NetworkType"].asString();
internetChargeType_ = value["InternetChargeType"].asString();
autoReleaseTime_ = std::stol(value["AutoReleaseTime"].asString());
bandwidth_ = std::stoi(value["Bandwidth"].asString());
loadBalancerSpec_ = value["LoadBalancerSpec"].asString();
createTime_ = value["CreateTime"].asString();
createTimeStamp_ = std::stol(value["CreateTimeStamp"].asString());
endTime_ = value["EndTime"].asString();
endTimeStamp_ = std::stol(value["EndTimeStamp"].asString());
payType_ = value["PayType"].asString();
masterZoneId_ = value["MasterZoneId"].asString();
slaveZoneId_ = value["SlaveZoneId"].asString();
if(!value["LoadBalancerId"].isNull())
loadBalancerId_ = value["LoadBalancerId"].asString();
if(!value["ResourceGroupId"].isNull())
resourceGroupId_ = value["ResourceGroupId"].asString();
if(!value["LoadBalancerName"].isNull())
loadBalancerName_ = value["LoadBalancerName"].asString();
if(!value["LoadBalancerStatus"].isNull())
loadBalancerStatus_ = value["LoadBalancerStatus"].asString();
if(!value["RegionId"].isNull())
regionId_ = value["RegionId"].asString();
if(!value["RegionIdAlias"].isNull())
regionIdAlias_ = value["RegionIdAlias"].asString();
if(!value["Address"].isNull())
address_ = value["Address"].asString();
if(!value["AddressType"].isNull())
addressType_ = value["AddressType"].asString();
if(!value["VpcId"].isNull())
vpcId_ = value["VpcId"].asString();
if(!value["VSwitchId"].isNull())
vSwitchId_ = value["VSwitchId"].asString();
if(!value["NetworkType"].isNull())
networkType_ = value["NetworkType"].asString();
if(!value["InternetChargeType"].isNull())
internetChargeType_ = value["InternetChargeType"].asString();
if(!value["AutoReleaseTime"].isNull())
autoReleaseTime_ = std::stol(value["AutoReleaseTime"].asString());
if(!value["Bandwidth"].isNull())
bandwidth_ = std::stoi(value["Bandwidth"].asString());
if(!value["LoadBalancerSpec"].isNull())
loadBalancerSpec_ = value["LoadBalancerSpec"].asString();
if(!value["CreateTime"].isNull())
createTime_ = value["CreateTime"].asString();
if(!value["CreateTimeStamp"].isNull())
createTimeStamp_ = std::stol(value["CreateTimeStamp"].asString());
if(!value["EndTime"].isNull())
endTime_ = value["EndTime"].asString();
if(!value["EndTimeStamp"].isNull())
endTimeStamp_ = std::stol(value["EndTimeStamp"].asString());
if(!value["PayType"].isNull())
payType_ = value["PayType"].asString();
if(!value["MasterZoneId"].isNull())
masterZoneId_ = value["MasterZoneId"].asString();
if(!value["SlaveZoneId"].isNull())
slaveZoneId_ = value["SlaveZoneId"].asString();
}
std::vector<DescribeLoadBalancerAttributeResult::ListenerPortAndProtocal> DescribeLoadBalancerAttributeResult::getListenerPortsAndProtocal()const
{
return listenerPortsAndProtocal_;
}
std::string DescribeLoadBalancerAttributeResult::getResourceGroupId()const
{
return resourceGroupId_;
}
void DescribeLoadBalancerAttributeResult::setResourceGroupId(const std::string& resourceGroupId)
{
resourceGroupId_ = resourceGroupId;
}
std::string DescribeLoadBalancerAttributeResult::getAddress()const
{
return address_;
}
void DescribeLoadBalancerAttributeResult::setAddress(const std::string& address)
{
address_ = address;
}
std::string DescribeLoadBalancerAttributeResult::getEndTime()const
{
return endTime_;
}
void DescribeLoadBalancerAttributeResult::setEndTime(const std::string& endTime)
std::vector<DescribeLoadBalancerAttributeResult::ListenerPortAndProtocol> DescribeLoadBalancerAttributeResult::getListenerPortsAndProtocol()const
{
endTime_ = endTime;
}
std::string DescribeLoadBalancerAttributeResult::getVSwitchId()const
{
return vSwitchId_;
}
void DescribeLoadBalancerAttributeResult::setVSwitchId(const std::string& vSwitchId)
{
vSwitchId_ = vSwitchId;
}
std::string DescribeLoadBalancerAttributeResult::getCreateTime()const
{
return createTime_;
}
void DescribeLoadBalancerAttributeResult::setCreateTime(const std::string& createTime)
{
createTime_ = createTime;
return listenerPortsAndProtocol_;
}
std::string DescribeLoadBalancerAttributeResult::getLoadBalancerId()const
@@ -147,39 +150,9 @@ std::string DescribeLoadBalancerAttributeResult::getLoadBalancerId()const
return loadBalancerId_;
}
void DescribeLoadBalancerAttributeResult::setLoadBalancerId(const std::string& loadBalancerId)
std::vector<DescribeLoadBalancerAttributeResult::BackendServer> DescribeLoadBalancerAttributeResult::getBackendServers()const
{
loadBalancerId_ = loadBalancerId;
}
std::string DescribeLoadBalancerAttributeResult::getPayType()const
{
return payType_;
}
void DescribeLoadBalancerAttributeResult::setPayType(const std::string& payType)
{
payType_ = payType;
}
std::string DescribeLoadBalancerAttributeResult::getSlaveZoneId()const
{
return slaveZoneId_;
}
void DescribeLoadBalancerAttributeResult::setSlaveZoneId(const std::string& slaveZoneId)
{
slaveZoneId_ = slaveZoneId;
}
std::string DescribeLoadBalancerAttributeResult::getInternetChargeType()const
{
return internetChargeType_;
}
void DescribeLoadBalancerAttributeResult::setInternetChargeType(const std::string& internetChargeType)
{
internetChargeType_ = internetChargeType;
return backendServers_;
}
std::string DescribeLoadBalancerAttributeResult::getLoadBalancerSpec()const
@@ -187,129 +160,89 @@ std::string DescribeLoadBalancerAttributeResult::getLoadBalancerSpec()const
return loadBalancerSpec_;
}
void DescribeLoadBalancerAttributeResult::setLoadBalancerSpec(const std::string& loadBalancerSpec)
{
loadBalancerSpec_ = loadBalancerSpec;
}
std::string DescribeLoadBalancerAttributeResult::getRegionIdAlias()const
{
return regionIdAlias_;
}
void DescribeLoadBalancerAttributeResult::setRegionIdAlias(const std::string& regionIdAlias)
{
regionIdAlias_ = regionIdAlias;
}
std::string DescribeLoadBalancerAttributeResult::getLoadBalancerName()const
{
return loadBalancerName_;
}
void DescribeLoadBalancerAttributeResult::setLoadBalancerName(const std::string& loadBalancerName)
{
loadBalancerName_ = loadBalancerName;
}
std::string DescribeLoadBalancerAttributeResult::getVpcId()const
{
return vpcId_;
}
void DescribeLoadBalancerAttributeResult::setVpcId(const std::string& vpcId)
{
vpcId_ = vpcId;
}
long DescribeLoadBalancerAttributeResult::getEndTimeStamp()const
{
return endTimeStamp_;
}
void DescribeLoadBalancerAttributeResult::setEndTimeStamp(long endTimeStamp)
{
endTimeStamp_ = endTimeStamp;
}
std::string DescribeLoadBalancerAttributeResult::getNetworkType()const
{
return networkType_;
}
void DescribeLoadBalancerAttributeResult::setNetworkType(const std::string& networkType)
{
networkType_ = networkType;
}
int DescribeLoadBalancerAttributeResult::getBandwidth()const
{
return bandwidth_;
}
void DescribeLoadBalancerAttributeResult::setBandwidth(int bandwidth)
{
bandwidth_ = bandwidth;
}
std::string DescribeLoadBalancerAttributeResult::getRegionId()const
{
return regionId_;
}
void DescribeLoadBalancerAttributeResult::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
}
std::string DescribeLoadBalancerAttributeResult::getAddressType()const
{
return addressType_;
}
void DescribeLoadBalancerAttributeResult::setAddressType(const std::string& addressType)
{
addressType_ = addressType;
}
std::string DescribeLoadBalancerAttributeResult::getLoadBalancerStatus()const
{
return loadBalancerStatus_;
}
void DescribeLoadBalancerAttributeResult::setLoadBalancerStatus(const std::string& loadBalancerStatus)
{
loadBalancerStatus_ = loadBalancerStatus;
}
std::vector<std::string> DescribeLoadBalancerAttributeResult::getListenerPorts()const
{
return listenerPorts_;
}
void DescribeLoadBalancerAttributeResult::setListenerPorts(const std::vector<std::string>& listenerPorts)
{
listenerPorts_ = listenerPorts;
}
long DescribeLoadBalancerAttributeResult::getCreateTimeStamp()const
{
return createTimeStamp_;
}
void DescribeLoadBalancerAttributeResult::setCreateTimeStamp(long createTimeStamp)
{
createTimeStamp_ = createTimeStamp;
}
std::string DescribeLoadBalancerAttributeResult::getMasterZoneId()const
{
return masterZoneId_;
}
void DescribeLoadBalancerAttributeResult::setMasterZoneId(const std::string& masterZoneId)
std::string DescribeLoadBalancerAttributeResult::getVSwitchId()const
{
masterZoneId_ = masterZoneId;
return vSwitchId_;
}
std::string DescribeLoadBalancerAttributeResult::getCreateTime()const
{
return createTime_;
}
std::string DescribeLoadBalancerAttributeResult::getPayType()const
{
return payType_;
}
std::string DescribeLoadBalancerAttributeResult::getSlaveZoneId()const
{
return slaveZoneId_;
}
std::string DescribeLoadBalancerAttributeResult::getInternetChargeType()const
{
return internetChargeType_;
}
std::string DescribeLoadBalancerAttributeResult::getRegionIdAlias()const
{
return regionIdAlias_;
}
std::string DescribeLoadBalancerAttributeResult::getLoadBalancerName()const
{
return loadBalancerName_;
}
std::string DescribeLoadBalancerAttributeResult::getVpcId()const
{
return vpcId_;
}
long DescribeLoadBalancerAttributeResult::getEndTimeStamp()const
{
return endTimeStamp_;
}
std::string DescribeLoadBalancerAttributeResult::getRegionId()const
{
return regionId_;
}
std::string DescribeLoadBalancerAttributeResult::getAddressType()const
{
return addressType_;
}
std::string DescribeLoadBalancerAttributeResult::getLoadBalancerStatus()const
{
return loadBalancerStatus_;
}
long DescribeLoadBalancerAttributeResult::getCreateTimeStamp()const
{
return createTimeStamp_;
}
long DescribeLoadBalancerAttributeResult::getAutoReleaseTime()const
@@ -317,8 +250,3 @@ long DescribeLoadBalancerAttributeResult::getAutoReleaseTime()const
return autoReleaseTime_;
}
void DescribeLoadBalancerAttributeResult::setAutoReleaseTime(long autoReleaseTime)
{
autoReleaseTime_ = autoReleaseTime;
}

16
slb/src/model/DescribeLoadBalancerAutoReleaseTimeRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeLoadBalancerAutoReleaseTimeRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeLoadBalancerAutoReleaseTimeRequest;
DescribeLoadBalancerAutoReleaseTimeRequest::DescribeLoadBalancerAutoReleaseTimeRequest() :
SlbRequest("DescribeLoadBalancerAutoReleaseTime")
RpcServiceRequest("slb", "2014-05-15", "DescribeLoadBalancerAutoReleaseTime")
{}
DescribeLoadBalancerAutoReleaseTimeRequest::~DescribeLoadBalancerAutoReleaseTimeRequest()
@@ -103,17 +102,6 @@ void DescribeLoadBalancerAutoReleaseTimeRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeLoadBalancerAutoReleaseTimeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeLoadBalancerAutoReleaseTimeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeLoadBalancerAutoReleaseTimeRequest::getTags()const
{
return tags_;

8
slb/src/model/DescribeLoadBalancerAutoReleaseTimeResult.cc
View File

@@ -40,7 +40,8 @@ void DescribeLoadBalancerAutoReleaseTimeResult::parse(const std::string &payload
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
autoReleaseTime_ = std::stol(value["AutoReleaseTime"].asString());
if(!value["AutoReleaseTime"].isNull())
autoReleaseTime_ = std::stol(value["AutoReleaseTime"].asString());
}
@@ -49,8 +50,3 @@ long DescribeLoadBalancerAutoReleaseTimeResult::getAutoReleaseTime()const
return autoReleaseTime_;
}
void DescribeLoadBalancerAutoReleaseTimeResult::setAutoReleaseTime(long autoReleaseTime)
{
autoReleaseTime_ = autoReleaseTime;
}

16
slb/src/model/DescribeLoadBalancerHTTPListenerAttributeRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeLoadBalancerHTTPListenerAttributeRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeLoadBalancerHTTPListenerAttributeRequest;
DescribeLoadBalancerHTTPListenerAttributeRequest::DescribeLoadBalancerHTTPListenerAttributeRequest() :
SlbRequest("DescribeLoadBalancerHTTPListenerAttribute")
RpcServiceRequest("slb", "2014-05-15", "DescribeLoadBalancerHTTPListenerAttribute")
{}
DescribeLoadBalancerHTTPListenerAttributeRequest::~DescribeLoadBalancerHTTPListenerAttributeRequest()
@@ -114,17 +113,6 @@ void DescribeLoadBalancerHTTPListenerAttributeRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeLoadBalancerHTTPListenerAttributeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeLoadBalancerHTTPListenerAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeLoadBalancerHTTPListenerAttributeRequest::getTags()const
{
return tags_;

208
slb/src/model/DescribeLoadBalancerHTTPListenerAttributeResult.cc
View File

@@ -40,32 +40,58 @@ void DescribeLoadBalancerHTTPListenerAttributeResult::parse(const std::string &p
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
listenerPort_ = std::stoi(value["ListenerPort"].asString());
backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
bandwidth_ = std::stoi(value["Bandwidth"].asString());
status_ = value["Status"].asString();
securityStatus_ = value["SecurityStatus"].asString();
xForwardedFor_ = value["XForwardedFor"].asString();
scheduler_ = value["Scheduler"].asString();
stickySession_ = value["StickySession"].asString();
stickySessionType_ = value["StickySessionType"].asString();
cookieTimeout_ = std::stoi(value["CookieTimeout"].asString());
cookie_ = value["Cookie"].asString();
healthCheck_ = value["HealthCheck"].asString();
healthCheckDomain_ = value["HealthCheckDomain"].asString();
healthCheckURI_ = value["HealthCheckURI"].asString();
healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
healthCheckTimeout_ = std::stoi(value["HealthCheckTimeout"].asString());
healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
maxConnection_ = std::stoi(value["MaxConnection"].asString());
vServerGroupId_ = value["VServerGroupId"].asString();
gzip_ = value["Gzip"].asString();
xForwardedFor_SLBIP_ = value["XForwardedFor_SLBIP"].asString();
xForwardedFor_SLBID_ = value["XForwardedFor_SLBID"].asString();
xForwardedFor_proto_ = value["XForwardedFor_proto"].asString();
if(!value["ListenerPort"].isNull())
listenerPort_ = std::stoi(value["ListenerPort"].asString());
if(!value["BackendServerPort"].isNull())
backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
if(!value["Bandwidth"].isNull())
bandwidth_ = std::stoi(value["Bandwidth"].asString());
if(!value["Status"].isNull())
status_ = value["Status"].asString();
if(!value["SecurityStatus"].isNull())
securityStatus_ = value["SecurityStatus"].asString();
if(!value["XForwardedFor"].isNull())
xForwardedFor_ = value["XForwardedFor"].asString();
if(!value["Scheduler"].isNull())
scheduler_ = value["Scheduler"].asString();
if(!value["StickySession"].isNull())
stickySession_ = value["StickySession"].asString();
if(!value["StickySessionType"].isNull())
stickySessionType_ = value["StickySessionType"].asString();
if(!value["CookieTimeout"].isNull())
cookieTimeout_ = std::stoi(value["CookieTimeout"].asString());
if(!value["Cookie"].isNull())
cookie_ = value["Cookie"].asString();
if(!value["HealthCheck"].isNull())
healthCheck_ = value["HealthCheck"].asString();
if(!value["HealthCheckDomain"].isNull())
healthCheckDomain_ = value["HealthCheckDomain"].asString();
if(!value["HealthCheckURI"].isNull())
healthCheckURI_ = value["HealthCheckURI"].asString();
if(!value["HealthyThreshold"].isNull())
healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
if(!value["UnhealthyThreshold"].isNull())
unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
if(!value["HealthCheckTimeout"].isNull())
healthCheckTimeout_ = std::stoi(value["HealthCheckTimeout"].asString());
if(!value["HealthCheckInterval"].isNull())
healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
if(!value["HealthCheckConnectPort"].isNull())
healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
if(!value["HealthCheckHttpCode"].isNull())
healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
if(!value["MaxConnection"].isNull())
maxConnection_ = std::stoi(value["MaxConnection"].asString());
if(!value["VServerGroupId"].isNull())
vServerGroupId_ = value["VServerGroupId"].asString();
if(!value["Gzip"].isNull())
gzip_ = value["Gzip"].asString();
if(!value["XForwardedFor_SLBIP"].isNull())
xForwardedFor_SLBIP_ = value["XForwardedFor_SLBIP"].asString();
if(!value["XForwardedFor_SLBID"].isNull())
xForwardedFor_SLBID_ = value["XForwardedFor_SLBID"].asString();
if(!value["XForwardedFor_proto"].isNull())
xForwardedFor_proto_ = value["XForwardedFor_proto"].asString();
}
@@ -74,258 +100,128 @@ int DescribeLoadBalancerHTTPListenerAttributeResult::getCookieTimeout()const
return cookieTimeout_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setCookieTimeout(int cookieTimeout)
{
cookieTimeout_ = cookieTimeout;
}
int DescribeLoadBalancerHTTPListenerAttributeResult::getMaxConnection()const
{
return maxConnection_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setMaxConnection(int maxConnection)
{
maxConnection_ = maxConnection;
}
std::string DescribeLoadBalancerHTTPListenerAttributeResult::getVServerGroupId()const
{
return vServerGroupId_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setVServerGroupId(const std::string& vServerGroupId)
{
vServerGroupId_ = vServerGroupId;
}
int DescribeLoadBalancerHTTPListenerAttributeResult::getUnhealthyThreshold()const
{
return unhealthyThreshold_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setUnhealthyThreshold(int unhealthyThreshold)
{
unhealthyThreshold_ = unhealthyThreshold;
}
std::string DescribeLoadBalancerHTTPListenerAttributeResult::getScheduler()const
{
return scheduler_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setScheduler(const std::string& scheduler)
{
scheduler_ = scheduler;
}
std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckURI()const
{
return healthCheckURI_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setHealthCheckURI(const std::string& healthCheckURI)
{
healthCheckURI_ = healthCheckURI;
}
std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheck()const
{
return healthCheck_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setHealthCheck(const std::string& healthCheck)
{
healthCheck_ = healthCheck;
}
int DescribeLoadBalancerHTTPListenerAttributeResult::getBackendServerPort()const
{
return backendServerPort_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setBackendServerPort(int backendServerPort)
{
backendServerPort_ = backendServerPort;
}
std::string DescribeLoadBalancerHTTPListenerAttributeResult::getXForwardedFor_SLBID()const
{
return xForwardedFor_SLBID_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setXForwardedFor_SLBID(const std::string& xForwardedFor_SLBID)
{
xForwardedFor_SLBID_ = xForwardedFor_SLBID;
}
int DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckConnectPort()const
{
return healthCheckConnectPort_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setHealthCheckConnectPort(int healthCheckConnectPort)
{
healthCheckConnectPort_ = healthCheckConnectPort;
}
int DescribeLoadBalancerHTTPListenerAttributeResult::getBandwidth()const
{
return bandwidth_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setBandwidth(int bandwidth)
{
bandwidth_ = bandwidth;
}
std::string DescribeLoadBalancerHTTPListenerAttributeResult::getSecurityStatus()const
{
return securityStatus_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setSecurityStatus(const std::string& securityStatus)
{
securityStatus_ = securityStatus;
}
std::string DescribeLoadBalancerHTTPListenerAttributeResult::getGzip()const
{
return gzip_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setGzip(const std::string& gzip)
{
gzip_ = gzip;
}
std::string DescribeLoadBalancerHTTPListenerAttributeResult::getStickySessionType()const
{
return stickySessionType_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setStickySessionType(const std::string& stickySessionType)
{
stickySessionType_ = stickySessionType;
}
std::string DescribeLoadBalancerHTTPListenerAttributeResult::getXForwardedFor_SLBIP()const
{
return xForwardedFor_SLBIP_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setXForwardedFor_SLBIP(const std::string& xForwardedFor_SLBIP)
{
xForwardedFor_SLBIP_ = xForwardedFor_SLBIP;
}
std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckHttpCode()const
{
return healthCheckHttpCode_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setHealthCheckHttpCode(const std::string& healthCheckHttpCode)
{
healthCheckHttpCode_ = healthCheckHttpCode;
}
std::string DescribeLoadBalancerHTTPListenerAttributeResult::getStatus()const
{
return status_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setStatus(const std::string& status)
{
status_ = status;
}
std::string DescribeLoadBalancerHTTPListenerAttributeResult::getCookie()const
{
return cookie_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setCookie(const std::string& cookie)
{
cookie_ = cookie;
}
int DescribeLoadBalancerHTTPListenerAttributeResult::getListenerPort()const
{
return listenerPort_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setListenerPort(int listenerPort)
{
listenerPort_ = listenerPort;
}
int DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckInterval()const
{
return healthCheckInterval_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setHealthCheckInterval(int healthCheckInterval)
{
healthCheckInterval_ = healthCheckInterval;
}
int DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckTimeout()const
{
return healthCheckTimeout_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setHealthCheckTimeout(int healthCheckTimeout)
{
healthCheckTimeout_ = healthCheckTimeout;
}
std::string DescribeLoadBalancerHTTPListenerAttributeResult::getStickySession()const
{
return stickySession_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setStickySession(const std::string& stickySession)
{
stickySession_ = stickySession;
}
int DescribeLoadBalancerHTTPListenerAttributeResult::getHealthyThreshold()const
{
return healthyThreshold_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setHealthyThreshold(int healthyThreshold)
{
healthyThreshold_ = healthyThreshold;
}
std::string DescribeLoadBalancerHTTPListenerAttributeResult::getXForwardedFor()const
{
return xForwardedFor_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setXForwardedFor(const std::string& xForwardedFor)
{
xForwardedFor_ = xForwardedFor;
}
std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckDomain()const
{
return healthCheckDomain_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setHealthCheckDomain(const std::string& healthCheckDomain)
{
healthCheckDomain_ = healthCheckDomain;
}
std::string DescribeLoadBalancerHTTPListenerAttributeResult::getXForwardedFor_proto()const
{
return xForwardedFor_proto_;
}
void DescribeLoadBalancerHTTPListenerAttributeResult::setXForwardedFor_proto(const std::string& xForwardedFor_proto)
{
xForwardedFor_proto_ = xForwardedFor_proto;
}

16
slb/src/model/DescribeLoadBalancerHTTPSListenerAttributeRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeLoadBalancerHTTPSListenerAttributeRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeLoadBalancerHTTPSListenerAttributeRequest;
DescribeLoadBalancerHTTPSListenerAttributeRequest::DescribeLoadBalancerHTTPSListenerAttributeRequest() :
SlbRequest("DescribeLoadBalancerHTTPSListenerAttribute")
RpcServiceRequest("slb", "2014-05-15", "DescribeLoadBalancerHTTPSListenerAttribute")
{}
DescribeLoadBalancerHTTPSListenerAttributeRequest::~DescribeLoadBalancerHTTPSListenerAttributeRequest()
@@ -114,17 +113,6 @@ void DescribeLoadBalancerHTTPSListenerAttributeRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeLoadBalancerHTTPSListenerAttributeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeLoadBalancerHTTPSListenerAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeLoadBalancerHTTPSListenerAttributeRequest::getTags()const
{
return tags_;

224
slb/src/model/DescribeLoadBalancerHTTPSListenerAttributeResult.cc
View File

@@ -40,34 +40,62 @@ void DescribeLoadBalancerHTTPSListenerAttributeResult::parse(const std::string &
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
listenerPort_ = std::stoi(value["ListenerPort"].asString());
backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
bandwidth_ = std::stoi(value["Bandwidth"].asString());
status_ = value["Status"].asString();
securityStatus_ = value["SecurityStatus"].asString();
xForwardedFor_ = value["XForwardedFor"].asString();
scheduler_ = value["Scheduler"].asString();
stickySession_ = value["StickySession"].asString();
stickySessionType_ = value["StickySessionType"].asString();
cookieTimeout_ = std::stoi(value["CookieTimeout"].asString());
cookie_ = value["Cookie"].asString();
healthCheck_ = value["HealthCheck"].asString();
healthCheckDomain_ = value["HealthCheckDomain"].asString();
healthCheckURI_ = value["HealthCheckURI"].asString();
healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
healthCheckTimeout_ = std::stoi(value["HealthCheckTimeout"].asString());
healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
serverCertificateId_ = value["ServerCertificateId"].asString();
cACertificateId_ = value["CACertificateId"].asString();
maxConnection_ = std::stoi(value["MaxConnection"].asString());
vServerGroupId_ = value["VServerGroupId"].asString();
gzip_ = value["Gzip"].asString();
xForwardedFor_SLBIP_ = value["XForwardedFor_SLBIP"].asString();
xForwardedFor_SLBID_ = value["XForwardedFor_SLBID"].asString();
xForwardedFor_proto_ = value["XForwardedFor_proto"].asString();
if(!value["ListenerPort"].isNull())
listenerPort_ = std::stoi(value["ListenerPort"].asString());
if(!value["BackendServerPort"].isNull())
backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
if(!value["Bandwidth"].isNull())
bandwidth_ = std::stoi(value["Bandwidth"].asString());
if(!value["Status"].isNull())
status_ = value["Status"].asString();
if(!value["SecurityStatus"].isNull())
securityStatus_ = value["SecurityStatus"].asString();
if(!value["XForwardedFor"].isNull())
xForwardedFor_ = value["XForwardedFor"].asString();
if(!value["Scheduler"].isNull())
scheduler_ = value["Scheduler"].asString();
if(!value["StickySession"].isNull())
stickySession_ = value["StickySession"].asString();
if(!value["StickySessionType"].isNull())
stickySessionType_ = value["StickySessionType"].asString();
if(!value["CookieTimeout"].isNull())
cookieTimeout_ = std::stoi(value["CookieTimeout"].asString());
if(!value["Cookie"].isNull())
cookie_ = value["Cookie"].asString();
if(!value["HealthCheck"].isNull())
healthCheck_ = value["HealthCheck"].asString();
if(!value["HealthCheckDomain"].isNull())
healthCheckDomain_ = value["HealthCheckDomain"].asString();
if(!value["HealthCheckURI"].isNull())
healthCheckURI_ = value["HealthCheckURI"].asString();
if(!value["HealthyThreshold"].isNull())
healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
if(!value["UnhealthyThreshold"].isNull())
unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
if(!value["HealthCheckTimeout"].isNull())
healthCheckTimeout_ = std::stoi(value["HealthCheckTimeout"].asString());
if(!value["HealthCheckInterval"].isNull())
healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
if(!value["HealthCheckConnectPort"].isNull())
healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
if(!value["HealthCheckHttpCode"].isNull())
healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
if(!value["ServerCertificateId"].isNull())
serverCertificateId_ = value["ServerCertificateId"].asString();
if(!value["CACertificateId"].isNull())
cACertificateId_ = value["CACertificateId"].asString();
if(!value["MaxConnection"].isNull())
maxConnection_ = std::stoi(value["MaxConnection"].asString());
if(!value["VServerGroupId"].isNull())
vServerGroupId_ = value["VServerGroupId"].asString();
if(!value["Gzip"].isNull())
gzip_ = value["Gzip"].asString();
if(!value["XForwardedFor_SLBIP"].isNull())
xForwardedFor_SLBIP_ = value["XForwardedFor_SLBIP"].asString();
if(!value["XForwardedFor_SLBID"].isNull())
xForwardedFor_SLBID_ = value["XForwardedFor_SLBID"].asString();
if(!value["XForwardedFor_proto"].isNull())
xForwardedFor_proto_ = value["XForwardedFor_proto"].asString();
}
@@ -76,278 +104,138 @@ int DescribeLoadBalancerHTTPSListenerAttributeResult::getCookieTimeout()const
return cookieTimeout_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setCookieTimeout(int cookieTimeout)
{
cookieTimeout_ = cookieTimeout;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getMaxConnection()const
{
return maxConnection_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setMaxConnection(int maxConnection)
{
maxConnection_ = maxConnection;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getVServerGroupId()const
{
return vServerGroupId_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setVServerGroupId(const std::string& vServerGroupId)
{
vServerGroupId_ = vServerGroupId;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getUnhealthyThreshold()const
{
return unhealthyThreshold_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setUnhealthyThreshold(int unhealthyThreshold)
{
unhealthyThreshold_ = unhealthyThreshold;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getScheduler()const
{
return scheduler_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setScheduler(const std::string& scheduler)
{
scheduler_ = scheduler;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckURI()const
{
return healthCheckURI_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setHealthCheckURI(const std::string& healthCheckURI)
{
healthCheckURI_ = healthCheckURI;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheck()const
{
return healthCheck_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setHealthCheck(const std::string& healthCheck)
{
healthCheck_ = healthCheck;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getBackendServerPort()const
{
return backendServerPort_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setBackendServerPort(int backendServerPort)
{
backendServerPort_ = backendServerPort;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_SLBID()const
{
return xForwardedFor_SLBID_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setXForwardedFor_SLBID(const std::string& xForwardedFor_SLBID)
{
xForwardedFor_SLBID_ = xForwardedFor_SLBID;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckConnectPort()const
{
return healthCheckConnectPort_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setHealthCheckConnectPort(int healthCheckConnectPort)
{
healthCheckConnectPort_ = healthCheckConnectPort;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getBandwidth()const
{
return bandwidth_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setBandwidth(int bandwidth)
{
bandwidth_ = bandwidth;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getSecurityStatus()const
{
return securityStatus_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setSecurityStatus(const std::string& securityStatus)
{
securityStatus_ = securityStatus;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getGzip()const
{
return gzip_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setGzip(const std::string& gzip)
{
gzip_ = gzip;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getServerCertificateId()const
{
return serverCertificateId_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setServerCertificateId(const std::string& serverCertificateId)
{
serverCertificateId_ = serverCertificateId;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStickySessionType()const
{
return stickySessionType_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setStickySessionType(const std::string& stickySessionType)
{
stickySessionType_ = stickySessionType;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_SLBIP()const
{
return xForwardedFor_SLBIP_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setXForwardedFor_SLBIP(const std::string& xForwardedFor_SLBIP)
{
xForwardedFor_SLBIP_ = xForwardedFor_SLBIP;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckHttpCode()const
{
return healthCheckHttpCode_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setHealthCheckHttpCode(const std::string& healthCheckHttpCode)
{
healthCheckHttpCode_ = healthCheckHttpCode;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStatus()const
{
return status_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setStatus(const std::string& status)
{
status_ = status;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getCookie()const
{
return cookie_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setCookie(const std::string& cookie)
{
cookie_ = cookie;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getListenerPort()const
{
return listenerPort_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setListenerPort(int listenerPort)
{
listenerPort_ = listenerPort;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckInterval()const
{
return healthCheckInterval_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setHealthCheckInterval(int healthCheckInterval)
{
healthCheckInterval_ = healthCheckInterval;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getCACertificateId()const
{
return cACertificateId_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setCACertificateId(const std::string& cACertificateId)
{
cACertificateId_ = cACertificateId;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckTimeout()const
{
return healthCheckTimeout_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setHealthCheckTimeout(int healthCheckTimeout)
{
healthCheckTimeout_ = healthCheckTimeout;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStickySession()const
{
return stickySession_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setStickySession(const std::string& stickySession)
{
stickySession_ = stickySession;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthyThreshold()const
{
return healthyThreshold_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setHealthyThreshold(int healthyThreshold)
{
healthyThreshold_ = healthyThreshold;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor()const
{
return xForwardedFor_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setXForwardedFor(const std::string& xForwardedFor)
{
xForwardedFor_ = xForwardedFor;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckDomain()const
{
return healthCheckDomain_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setHealthCheckDomain(const std::string& healthCheckDomain)
{
healthCheckDomain_ = healthCheckDomain;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_proto()const
{
return xForwardedFor_proto_;
}
void DescribeLoadBalancerHTTPSListenerAttributeResult::setXForwardedFor_proto(const std::string& xForwardedFor_proto)
{
xForwardedFor_proto_ = xForwardedFor_proto;
}

16
slb/src/model/DescribeLoadBalancerTCPListenerAttributeRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeLoadBalancerTCPListenerAttributeRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeLoadBalancerTCPListenerAttributeRequest;
DescribeLoadBalancerTCPListenerAttributeRequest::DescribeLoadBalancerTCPListenerAttributeRequest() :
SlbRequest("DescribeLoadBalancerTCPListenerAttribute")
RpcServiceRequest("slb", "2014-05-15", "DescribeLoadBalancerTCPListenerAttribute")
{}
DescribeLoadBalancerTCPListenerAttributeRequest::~DescribeLoadBalancerTCPListenerAttributeRequest()
@@ -114,17 +113,6 @@ void DescribeLoadBalancerTCPListenerAttributeRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeLoadBalancerTCPListenerAttributeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeLoadBalancerTCPListenerAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeLoadBalancerTCPListenerAttributeRequest::getTags()const
{
return tags_;

168
slb/src/model/DescribeLoadBalancerTCPListenerAttributeResult.cc
View File

@@ -40,27 +40,48 @@ void DescribeLoadBalancerTCPListenerAttributeResult::parse(const std::string &pa
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
listenerPort_ = std::stoi(value["ListenerPort"].asString());
backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
status_ = value["Status"].asString();
bandwidth_ = std::stoi(value["Bandwidth"].asString());
scheduler_ = value["Scheduler"].asString();
synProxy_ = value["SynProxy"].asString();
persistenceTimeout_ = std::stoi(value["PersistenceTimeout"].asString());
establishedTimeout_ = std::stoi(value["EstablishedTimeout"].asString());
healthCheck_ = value["HealthCheck"].asString();
healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
healthCheckConnectTimeout_ = std::stoi(value["HealthCheckConnectTimeout"].asString());
healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
healthCheckDomain_ = value["HealthCheckDomain"].asString();
healthCheckURI_ = value["HealthCheckURI"].asString();
healthCheckType_ = value["HealthCheckType"].asString();
maxConnection_ = std::stoi(value["MaxConnection"].asString());
vServerGroupId_ = value["VServerGroupId"].asString();
masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
if(!value["ListenerPort"].isNull())
listenerPort_ = std::stoi(value["ListenerPort"].asString());
if(!value["BackendServerPort"].isNull())
backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
if(!value["Status"].isNull())
status_ = value["Status"].asString();
if(!value["Bandwidth"].isNull())
bandwidth_ = std::stoi(value["Bandwidth"].asString());
if(!value["Scheduler"].isNull())
scheduler_ = value["Scheduler"].asString();
if(!value["SynProxy"].isNull())
synProxy_ = value["SynProxy"].asString();
if(!value["PersistenceTimeout"].isNull())
persistenceTimeout_ = std::stoi(value["PersistenceTimeout"].asString());
if(!value["EstablishedTimeout"].isNull())
establishedTimeout_ = std::stoi(value["EstablishedTimeout"].asString());
if(!value["HealthCheck"].isNull())
healthCheck_ = value["HealthCheck"].asString();
if(!value["HealthyThreshold"].isNull())
healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
if(!value["UnhealthyThreshold"].isNull())
unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
if(!value["HealthCheckConnectTimeout"].isNull())
healthCheckConnectTimeout_ = std::stoi(value["HealthCheckConnectTimeout"].asString());
if(!value["HealthCheckConnectPort"].isNull())
healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
if(!value["HealthCheckInterval"].isNull())
healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
if(!value["HealthCheckHttpCode"].isNull())
healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
if(!value["HealthCheckDomain"].isNull())
healthCheckDomain_ = value["HealthCheckDomain"].asString();
if(!value["HealthCheckURI"].isNull())
healthCheckURI_ = value["HealthCheckURI"].asString();
if(!value["HealthCheckType"].isNull())
healthCheckType_ = value["HealthCheckType"].asString();
if(!value["MaxConnection"].isNull())
maxConnection_ = std::stoi(value["MaxConnection"].asString());
if(!value["VServerGroupId"].isNull())
vServerGroupId_ = value["VServerGroupId"].asString();
if(!value["MasterSlaveServerGroupId"].isNull())
masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
}
@@ -69,208 +90,103 @@ std::string DescribeLoadBalancerTCPListenerAttributeResult::getStatus()const
return status_;
}
void DescribeLoadBalancerTCPListenerAttributeResult::setStatus(const std::string& status)
{
status_ = status;
}
int DescribeLoadBalancerTCPListenerAttributeResult::getMaxConnection()const
{
return maxConnection_;
}
void DescribeLoadBalancerTCPListenerAttributeResult::setMaxConnection(int maxConnection)
{
maxConnection_ = maxConnection;
}
int DescribeLoadBalancerTCPListenerAttributeResult::getListenerPort()const
{
return listenerPort_;
}
void DescribeLoadBalancerTCPListenerAttributeResult::setListenerPort(int listenerPort)
{
listenerPort_ = listenerPort;
}
std::string DescribeLoadBalancerTCPListenerAttributeResult::getVServerGroupId()const
{
return vServerGroupId_;
}
void DescribeLoadBalancerTCPListenerAttributeResult::setVServerGroupId(const std::string& vServerGroupId)
{
vServerGroupId_ = vServerGroupId;
}
std::string DescribeLoadBalancerTCPListenerAttributeResult::getSynProxy()const
{
return synProxy_;
}
void DescribeLoadBalancerTCPListenerAttributeResult::setSynProxy(const std::string& synProxy)
{
synProxy_ = synProxy;
}
int DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckInterval()const
{
return healthCheckInterval_;
}
void DescribeLoadBalancerTCPListenerAttributeResult::setHealthCheckInterval(int healthCheckInterval)
{
healthCheckInterval_ = healthCheckInterval;
}
int DescribeLoadBalancerTCPListenerAttributeResult::getUnhealthyThreshold()const
{
return unhealthyThreshold_;
}
void DescribeLoadBalancerTCPListenerAttributeResult::setUnhealthyThreshold(int unhealthyThreshold)
{
unhealthyThreshold_ = unhealthyThreshold;
}
std::string DescribeLoadBalancerTCPListenerAttributeResult::getScheduler()const
{
return scheduler_;
}
void DescribeLoadBalancerTCPListenerAttributeResult::setScheduler(const std::string& scheduler)
{
scheduler_ = scheduler;
}
std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckURI()const
{
return healthCheckURI_;
}
void DescribeLoadBalancerTCPListenerAttributeResult::setHealthCheckURI(const std::string& healthCheckURI)
{
healthCheckURI_ = healthCheckURI;
}
std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheck()const
{
return healthCheck_;
}
void DescribeLoadBalancerTCPListenerAttributeResult::setHealthCheck(const std::string& healthCheck)
{
healthCheck_ = healthCheck;
}
int DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckConnectTimeout()const
{
return healthCheckConnectTimeout_;
}
void DescribeLoadBalancerTCPListenerAttributeResult::setHealthCheckConnectTimeout(int healthCheckConnectTimeout)
{
healthCheckConnectTimeout_ = healthCheckConnectTimeout;
}
int DescribeLoadBalancerTCPListenerAttributeResult::getBackendServerPort()const
{
return backendServerPort_;
}
void DescribeLoadBalancerTCPListenerAttributeResult::setBackendServerPort(int backendServerPort)
{
backendServerPort_ = backendServerPort;
}
int DescribeLoadBalancerTCPListenerAttributeResult::getPersistenceTimeout()const
{
return persistenceTimeout_;
}
void DescribeLoadBalancerTCPListenerAttributeResult::setPersistenceTimeout(int persistenceTimeout)
{
persistenceTimeout_ = persistenceTimeout;
}
int DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckConnectPort()const
{
return healthCheckConnectPort_;
}
void DescribeLoadBalancerTCPListenerAttributeResult::setHealthCheckConnectPort(int healthCheckConnectPort)
{
healthCheckConnectPort_ = healthCheckConnectPort;
}
int DescribeLoadBalancerTCPListenerAttributeResult::getBandwidth()const
{
return bandwidth_;
}
void DescribeLoadBalancerTCPListenerAttributeResult::setBandwidth(int bandwidth)
{
bandwidth_ = bandwidth;
}
int DescribeLoadBalancerTCPListenerAttributeResult::getHealthyThreshold()const
{
return healthyThreshold_;
}
void DescribeLoadBalancerTCPListenerAttributeResult::setHealthyThreshold(int healthyThreshold)
{
healthyThreshold_ = healthyThreshold;
}
std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckDomain()const
{
return healthCheckDomain_;
}
void DescribeLoadBalancerTCPListenerAttributeResult::setHealthCheckDomain(const std::string& healthCheckDomain)
{
healthCheckDomain_ = healthCheckDomain;
}
std::string DescribeLoadBalancerTCPListenerAttributeResult::getMasterSlaveServerGroupId()const
{
return masterSlaveServerGroupId_;
}
void DescribeLoadBalancerTCPListenerAttributeResult::setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId)
{
masterSlaveServerGroupId_ = masterSlaveServerGroupId;
}
std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckHttpCode()const
{
return healthCheckHttpCode_;
}
void DescribeLoadBalancerTCPListenerAttributeResult::setHealthCheckHttpCode(const std::string& healthCheckHttpCode)
{
healthCheckHttpCode_ = healthCheckHttpCode;
}
std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckType()const
{
return healthCheckType_;
}
void DescribeLoadBalancerTCPListenerAttributeResult::setHealthCheckType(const std::string& healthCheckType)
{
healthCheckType_ = healthCheckType;
}
int DescribeLoadBalancerTCPListenerAttributeResult::getEstablishedTimeout()const
{
return establishedTimeout_;
}
void DescribeLoadBalancerTCPListenerAttributeResult::setEstablishedTimeout(int establishedTimeout)
{
establishedTimeout_ = establishedTimeout;
}

16
slb/src/model/DescribeLoadBalancerUDPListenerAttributeRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeLoadBalancerUDPListenerAttributeRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeLoadBalancerUDPListenerAttributeRequest;
DescribeLoadBalancerUDPListenerAttributeRequest::DescribeLoadBalancerUDPListenerAttributeRequest() :
SlbRequest("DescribeLoadBalancerUDPListenerAttribute")
RpcServiceRequest("slb", "2014-05-15", "DescribeLoadBalancerUDPListenerAttribute")
{}
DescribeLoadBalancerUDPListenerAttributeRequest::~DescribeLoadBalancerUDPListenerAttributeRequest()
@@ -114,17 +113,6 @@ void DescribeLoadBalancerUDPListenerAttributeRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeLoadBalancerUDPListenerAttributeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeLoadBalancerUDPListenerAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeLoadBalancerUDPListenerAttributeRequest::getTags()const
{
return tags_;

136
slb/src/model/DescribeLoadBalancerUDPListenerAttributeResult.cc
View File

@@ -40,23 +40,40 @@ void DescribeLoadBalancerUDPListenerAttributeResult::parse(const std::string &pa
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
listenerPort_ = std::stoi(value["ListenerPort"].asString());
backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
status_ = value["Status"].asString();
bandwidth_ = std::stoi(value["Bandwidth"].asString());
scheduler_ = value["Scheduler"].asString();
persistenceTimeout_ = std::stoi(value["PersistenceTimeout"].asString());
healthCheck_ = value["HealthCheck"].asString();
healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
healthCheckConnectTimeout_ = std::stoi(value["HealthCheckConnectTimeout"].asString());
healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
healthCheckReq_ = value["HealthCheckReq"].asString();
healthCheckExp_ = value["HealthCheckExp"].asString();
maxConnection_ = std::stoi(value["MaxConnection"].asString());
vServerGroupId_ = value["VServerGroupId"].asString();
masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
if(!value["ListenerPort"].isNull())
listenerPort_ = std::stoi(value["ListenerPort"].asString());
if(!value["BackendServerPort"].isNull())
backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
if(!value["Status"].isNull())
status_ = value["Status"].asString();
if(!value["Bandwidth"].isNull())
bandwidth_ = std::stoi(value["Bandwidth"].asString());
if(!value["Scheduler"].isNull())
scheduler_ = value["Scheduler"].asString();
if(!value["PersistenceTimeout"].isNull())
persistenceTimeout_ = std::stoi(value["PersistenceTimeout"].asString());
if(!value["HealthCheck"].isNull())
healthCheck_ = value["HealthCheck"].asString();
if(!value["HealthyThreshold"].isNull())
healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
if(!value["UnhealthyThreshold"].isNull())
unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
if(!value["HealthCheckConnectTimeout"].isNull())
healthCheckConnectTimeout_ = std::stoi(value["HealthCheckConnectTimeout"].asString());
if(!value["HealthCheckConnectPort"].isNull())
healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
if(!value["HealthCheckInterval"].isNull())
healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
if(!value["HealthCheckReq"].isNull())
healthCheckReq_ = value["HealthCheckReq"].asString();
if(!value["HealthCheckExp"].isNull())
healthCheckExp_ = value["HealthCheckExp"].asString();
if(!value["MaxConnection"].isNull())
maxConnection_ = std::stoi(value["MaxConnection"].asString());
if(!value["VServerGroupId"].isNull())
vServerGroupId_ = value["VServerGroupId"].asString();
if(!value["MasterSlaveServerGroupId"].isNull())
masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
}
@@ -65,168 +82,83 @@ std::string DescribeLoadBalancerUDPListenerAttributeResult::getStatus()const
return status_;
}
void DescribeLoadBalancerUDPListenerAttributeResult::setStatus(const std::string& status)
{
status_ = status;
}
int DescribeLoadBalancerUDPListenerAttributeResult::getMaxConnection()const
{
return maxConnection_;
}
void DescribeLoadBalancerUDPListenerAttributeResult::setMaxConnection(int maxConnection)
{
maxConnection_ = maxConnection;
}
int DescribeLoadBalancerUDPListenerAttributeResult::getListenerPort()const
{
return listenerPort_;
}
void DescribeLoadBalancerUDPListenerAttributeResult::setListenerPort(int listenerPort)
{
listenerPort_ = listenerPort;
}
std::string DescribeLoadBalancerUDPListenerAttributeResult::getVServerGroupId()const
{
return vServerGroupId_;
}
void DescribeLoadBalancerUDPListenerAttributeResult::setVServerGroupId(const std::string& vServerGroupId)
{
vServerGroupId_ = vServerGroupId;
}
int DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckInterval()const
{
return healthCheckInterval_;
}
void DescribeLoadBalancerUDPListenerAttributeResult::setHealthCheckInterval(int healthCheckInterval)
{
healthCheckInterval_ = healthCheckInterval;
}
int DescribeLoadBalancerUDPListenerAttributeResult::getUnhealthyThreshold()const
{
return unhealthyThreshold_;
}
void DescribeLoadBalancerUDPListenerAttributeResult::setUnhealthyThreshold(int unhealthyThreshold)
{
unhealthyThreshold_ = unhealthyThreshold;
}
std::string DescribeLoadBalancerUDPListenerAttributeResult::getScheduler()const
{
return scheduler_;
}
void DescribeLoadBalancerUDPListenerAttributeResult::setScheduler(const std::string& scheduler)
{
scheduler_ = scheduler;
}
std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheck()const
{
return healthCheck_;
}
void DescribeLoadBalancerUDPListenerAttributeResult::setHealthCheck(const std::string& healthCheck)
{
healthCheck_ = healthCheck;
}
int DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckConnectTimeout()const
{
return healthCheckConnectTimeout_;
}
void DescribeLoadBalancerUDPListenerAttributeResult::setHealthCheckConnectTimeout(int healthCheckConnectTimeout)
{
healthCheckConnectTimeout_ = healthCheckConnectTimeout;
}
int DescribeLoadBalancerUDPListenerAttributeResult::getBackendServerPort()const
{
return backendServerPort_;
}
void DescribeLoadBalancerUDPListenerAttributeResult::setBackendServerPort(int backendServerPort)
{
backendServerPort_ = backendServerPort;
}
int DescribeLoadBalancerUDPListenerAttributeResult::getPersistenceTimeout()const
{
return persistenceTimeout_;
}
void DescribeLoadBalancerUDPListenerAttributeResult::setPersistenceTimeout(int persistenceTimeout)
{
persistenceTimeout_ = persistenceTimeout;
}
int DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckConnectPort()const
{
return healthCheckConnectPort_;
}
void DescribeLoadBalancerUDPListenerAttributeResult::setHealthCheckConnectPort(int healthCheckConnectPort)
{
healthCheckConnectPort_ = healthCheckConnectPort;
}
std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckReq()const
{
return healthCheckReq_;
}
void DescribeLoadBalancerUDPListenerAttributeResult::setHealthCheckReq(const std::string& healthCheckReq)
{
healthCheckReq_ = healthCheckReq;
}
int DescribeLoadBalancerUDPListenerAttributeResult::getBandwidth()const
{
return bandwidth_;
}
void DescribeLoadBalancerUDPListenerAttributeResult::setBandwidth(int bandwidth)
{
bandwidth_ = bandwidth;
}
int DescribeLoadBalancerUDPListenerAttributeResult::getHealthyThreshold()const
{
return healthyThreshold_;
}
void DescribeLoadBalancerUDPListenerAttributeResult::setHealthyThreshold(int healthyThreshold)
{
healthyThreshold_ = healthyThreshold;
}
std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckExp()const
{
return healthCheckExp_;
}
void DescribeLoadBalancerUDPListenerAttributeResult::setHealthCheckExp(const std::string& healthCheckExp)
{
healthCheckExp_ = healthCheckExp;
}
std::string DescribeLoadBalancerUDPListenerAttributeResult::getMasterSlaveServerGroupId()const
{
return masterSlaveServerGroupId_;
}
void DescribeLoadBalancerUDPListenerAttributeResult::setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId)
{
masterSlaveServerGroupId_ = masterSlaveServerGroupId;
}

5
slb/src/model/DescribeLoadBalancersRelatedEcsRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeLoadBalancersRelatedEcsRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeLoadBalancersRelatedEcsRequest;
DescribeLoadBalancersRelatedEcsRequest::DescribeLoadBalancersRelatedEcsRequest() :
SlbRequest("DescribeLoadBalancersRelatedEcs")
RpcServiceRequest("slb", "2014-05-15", "DescribeLoadBalancersRelatedEcs")
{}
DescribeLoadBalancersRelatedEcsRequest::~DescribeLoadBalancersRelatedEcsRequest()

101
slb/src/model/DescribeLoadBalancersRelatedEcsResult.cc
View File

@@ -43,59 +43,79 @@ void DescribeLoadBalancersRelatedEcsResult::parse(const std::string &payload)
auto allLoadBalancers = value["LoadBalancers"]["LoadBalancer"];
for (auto value : allLoadBalancers)
{
LoadBalancer loadBalancerObject;
loadBalancerObject.loadBalancerId = value["LoadBalancerId"].asString();
loadBalancerObject.count = std::stoi(value["Count"].asString());
LoadBalancer loadBalancersObject;
if(!value["LoadBalancerId"].isNull())
loadBalancersObject.loadBalancerId = value["LoadBalancerId"].asString();
if(!value["Count"].isNull())
loadBalancersObject.count = std::stoi(value["Count"].asString());
auto allMasterSlaveVServerGroups = value["MasterSlaveVServerGroups"]["MasterSlaveVServerGroup"];
for (auto value : allMasterSlaveVServerGroups)
{
LoadBalancer::MasterSlaveVServerGroup masterSlaveVServerGroupObject;
masterSlaveVServerGroupObject.groupId = value["GroupId"].asString();
masterSlaveVServerGroupObject.groupName = value["GroupName"].asString();
auto allBackendServers = value["BackendServers"]["BackendServer"];
for (auto value : allBackendServers)
LoadBalancer::MasterSlaveVServerGroup masterSlaveVServerGroupsObject;
if(!value["GroupId"].isNull())
masterSlaveVServerGroupsObject.groupId = value["GroupId"].asString();
if(!value["GroupName"].isNull())
masterSlaveVServerGroupsObject.groupName = value["GroupName"].asString();
auto allBackendServers1 = value["BackendServers"]["BackendServer"];
for (auto value : allBackendServers1)
{
LoadBalancer::MasterSlaveVServerGroup::BackendServer backendServerObject;
backendServerObject.vmName = value["VmName"].asString();
backendServerObject.weight = std::stoi(value["Weight"].asString());
backendServerObject.port = std::stoi(value["Port"].asString());
backendServerObject.networkType = value["NetworkType"].asString();
masterSlaveVServerGroupObject.backendServers1.push_back(backendServerObject);
LoadBalancer::MasterSlaveVServerGroup::BackendServer backendServers1Object;
if(!value["VmName"].isNull())
backendServers1Object.vmName = value["VmName"].asString();
if(!value["Weight"].isNull())
backendServers1Object.weight = std::stoi(value["Weight"].asString());
if(!value["Port"].isNull())
backendServers1Object.port = std::stoi(value["Port"].asString());
if(!value["NetworkType"].isNull())
backendServers1Object.networkType = value["NetworkType"].asString();
masterSlaveVServerGroupsObject.backendServers1.push_back(backendServers1Object);
}
loadBalancerObject.masterSlaveVServerGroups.push_back(masterSlaveVServerGroupObject);
loadBalancersObject.masterSlaveVServerGroups.push_back(masterSlaveVServerGroupsObject);
}
auto allVServerGroups = value["VServerGroups"]["VServerGroup"];
for (auto value : allVServerGroups)
{
LoadBalancer::VServerGroup vServerGroupObject;
vServerGroupObject.groupId = value["GroupId"].asString();
vServerGroupObject.groupName = value["GroupName"].asString();
auto allBackendServers = value["BackendServers"]["BackendServer"];
for (auto value : allBackendServers)
LoadBalancer::VServerGroup vServerGroupsObject;
if(!value["GroupId"].isNull())
vServerGroupsObject.groupId = value["GroupId"].asString();
if(!value["GroupName"].isNull())
vServerGroupsObject.groupName = value["GroupName"].asString();
auto allBackendServers2 = value["BackendServers"]["BackendServer"];
for (auto value : allBackendServers2)
{
LoadBalancer::VServerGroup::BackendServer backendServerObject;
backendServerObject.vmName = value["VmName"].asString();
backendServerObject.weight = std::stoi(value["Weight"].asString());
backendServerObject.port = std::stoi(value["Port"].asString());
backendServerObject.networkType = value["NetworkType"].asString();
vServerGroupObject.backendServers2.push_back(backendServerObject);
LoadBalancer::VServerGroup::BackendServer3 backendServers2Object;
if(!value["VmName"].isNull())
backendServers2Object.vmName = value["VmName"].asString();
if(!value["Weight"].isNull())
backendServers2Object.weight = std::stoi(value["Weight"].asString());
if(!value["Port"].isNull())
backendServers2Object.port = std::stoi(value["Port"].asString());
if(!value["NetworkType"].isNull())
backendServers2Object.networkType = value["NetworkType"].asString();
vServerGroupsObject.backendServers2.push_back(backendServers2Object);
}
loadBalancerObject.vServerGroups.push_back(vServerGroupObject);
loadBalancersObject.vServerGroups.push_back(vServerGroupsObject);
}
auto allBackendServers = value["BackendServers"]["BackendServer"];
for (auto value : allBackendServers)
{
LoadBalancer::BackendServer backendServerObject;
backendServerObject.vmName = value["VmName"].asString();
backendServerObject.weight = std::stoi(value["Weight"].asString());
backendServerObject.port = std::stoi(value["Port"].asString());
backendServerObject.networkType = value["NetworkType"].asString();
loadBalancerObject.backendServers.push_back(backendServerObject);
LoadBalancer::BackendServer4 backendServersObject;
if(!value["VmName"].isNull())
backendServersObject.vmName = value["VmName"].asString();
if(!value["Weight"].isNull())
backendServersObject.weight = std::stoi(value["Weight"].asString());
if(!value["Port"].isNull())
backendServersObject.port = std::stoi(value["Port"].asString());
if(!value["NetworkType"].isNull())
backendServersObject.networkType = value["NetworkType"].asString();
loadBalancersObject.backendServers.push_back(backendServersObject);
}
loadBalancers_.push_back(loadBalancerObject);
loadBalancers_.push_back(loadBalancersObject);
}
message_ = value["Message"].asString();
success_ = std::stoi(value["Success"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
@@ -104,9 +124,9 @@ std::string DescribeLoadBalancersRelatedEcsResult::getMessage()const
return message_;
}
void DescribeLoadBalancersRelatedEcsResult::setMessage(const std::string& message)
std::vector<DescribeLoadBalancersRelatedEcsResult::LoadBalancer> DescribeLoadBalancersRelatedEcsResult::getLoadBalancers()const
{
message_ = message;
return loadBalancers_;
}
bool DescribeLoadBalancersRelatedEcsResult::getSuccess()const
@@ -114,8 +134,3 @@ bool DescribeLoadBalancersRelatedEcsResult::getSuccess()const
return success_;
}
void DescribeLoadBalancersRelatedEcsResult::setSuccess(bool success)
{
success_ = success;
}

214
slb/src/model/DescribeLoadBalancersRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeLoadBalancersRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeLoadBalancersRequest;
DescribeLoadBalancersRequest::DescribeLoadBalancersRequest() :
SlbRequest("DescribeLoadBalancers")
RpcServiceRequest("slb", "2014-05-15", "DescribeLoadBalancers")
{}
DescribeLoadBalancersRequest::~DescribeLoadBalancersRequest()
@@ -48,116 +47,6 @@ void DescribeLoadBalancersRequest::setResourceOwnerId(long resourceOwnerId)
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeLoadBalancersRequest::getNetworkType()const
{
return networkType_;
}
void DescribeLoadBalancersRequest::setNetworkType(const std::string& networkType)
{
networkType_ = networkType;
setParameter("NetworkType", networkType);
}
std::string DescribeLoadBalancersRequest::getMasterZoneId()const
{
return masterZoneId_;
}
void DescribeLoadBalancersRequest::setMasterZoneId(const std::string& masterZoneId)
{
masterZoneId_ = masterZoneId;
setParameter("MasterZoneId", masterZoneId);
}
int DescribeLoadBalancersRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeLoadBalancersRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeLoadBalancersRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeLoadBalancersRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeLoadBalancersRequest::getResourceGroupId()const
{
return resourceGroupId_;
}
void DescribeLoadBalancersRequest::setResourceGroupId(const std::string& resourceGroupId)
{
resourceGroupId_ = resourceGroupId;
setParameter("ResourceGroupId", resourceGroupId);
}
std::string DescribeLoadBalancersRequest::getLoadBalancerName()const
{
return loadBalancerName_;
}
void DescribeLoadBalancersRequest::setLoadBalancerName(const std::string& loadBalancerName)
{
loadBalancerName_ = loadBalancerName;
setParameter("LoadBalancerName", loadBalancerName);
}
std::string DescribeLoadBalancersRequest::getRegionId()const
{
return regionId_;
}
void DescribeLoadBalancersRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
int DescribeLoadBalancersRequest::getPageSize()const
{
return pageSize_;
}
void DescribeLoadBalancersRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeLoadBalancersRequest::getAddressType()const
{
return addressType_;
}
void DescribeLoadBalancersRequest::setAddressType(const std::string& addressType)
{
addressType_ = addressType;
setParameter("AddressType", addressType);
}
std::string DescribeLoadBalancersRequest::getSlaveZoneId()const
{
return slaveZoneId_;
}
void DescribeLoadBalancersRequest::setSlaveZoneId(const std::string& slaveZoneId)
{
slaveZoneId_ = slaveZoneId;
setParameter("SlaveZoneId", slaveZoneId);
}
std::string DescribeLoadBalancersRequest::getAddress()const
{
return address_;
@@ -191,6 +80,17 @@ void DescribeLoadBalancersRequest::setOwnerAccount(const std::string& ownerAccou
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeLoadBalancersRequest::getNetworkType()const
{
return networkType_;
}
void DescribeLoadBalancersRequest::setNetworkType(const std::string& networkType)
{
networkType_ = networkType;
setParameter("NetworkType", networkType);
}
long DescribeLoadBalancersRequest::getOwnerId()const
{
return ownerId_;
@@ -213,6 +113,28 @@ void DescribeLoadBalancersRequest::setServerId(const std::string& serverId)
setParameter("ServerId", serverId);
}
std::string DescribeLoadBalancersRequest::getMasterZoneId()const
{
return masterZoneId_;
}
void DescribeLoadBalancersRequest::setMasterZoneId(const std::string& masterZoneId)
{
masterZoneId_ = masterZoneId;
setParameter("MasterZoneId", masterZoneId);
}
int DescribeLoadBalancersRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeLoadBalancersRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeLoadBalancersRequest::getTags()const
{
return tags_;
@@ -246,6 +168,28 @@ void DescribeLoadBalancersRequest::setVSwitchId(const std::string& vSwitchId)
setParameter("VSwitchId", vSwitchId);
}
std::string DescribeLoadBalancersRequest::getResourceGroupId()const
{
return resourceGroupId_;
}
void DescribeLoadBalancersRequest::setResourceGroupId(const std::string& resourceGroupId)
{
resourceGroupId_ = resourceGroupId;
setParameter("ResourceGroupId", resourceGroupId);
}
std::string DescribeLoadBalancersRequest::getLoadBalancerName()const
{
return loadBalancerName_;
}
void DescribeLoadBalancersRequest::setLoadBalancerName(const std::string& loadBalancerName)
{
loadBalancerName_ = loadBalancerName;
setParameter("LoadBalancerName", loadBalancerName);
}
std::string DescribeLoadBalancersRequest::getLoadBalancerId()const
{
return loadBalancerId_;
@@ -257,6 +201,17 @@ void DescribeLoadBalancersRequest::setLoadBalancerId(const std::string& loadBala
setParameter("LoadBalancerId", loadBalancerId);
}
std::string DescribeLoadBalancersRequest::getRegionId()const
{
return regionId_;
}
void DescribeLoadBalancersRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribeLoadBalancersRequest::getInternetChargeType()const
{
return internetChargeType_;
@@ -279,6 +234,39 @@ void DescribeLoadBalancersRequest::setVpcId(const std::string& vpcId)
setParameter("VpcId", vpcId);
}
int DescribeLoadBalancersRequest::getPageSize()const
{
return pageSize_;
}
void DescribeLoadBalancersRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeLoadBalancersRequest::getAddressType()const
{
return addressType_;
}
void DescribeLoadBalancersRequest::setAddressType(const std::string& addressType)
{
addressType_ = addressType;
setParameter("AddressType", addressType);
}
std::string DescribeLoadBalancersRequest::getSlaveZoneId()const
{
return slaveZoneId_;
}
void DescribeLoadBalancersRequest::setSlaveZoneId(const std::string& slaveZoneId)
{
slaveZoneId_ = slaveZoneId;
setParameter("SlaveZoneId", slaveZoneId);
}
std::string DescribeLoadBalancersRequest::getPayType()const
{
return payType_;

78
slb/src/model/DescribeLoadBalancersResult.cc
View File

@@ -43,29 +43,49 @@ void DescribeLoadBalancersResult::parse(const std::string &payload)
auto allLoadBalancers = value["LoadBalancers"]["LoadBalancer"];
for (auto value : allLoadBalancers)
{
LoadBalancer loadBalancerObject;
loadBalancerObject.loadBalancerId = value["LoadBalancerId"].asString();
loadBalancerObject.loadBalancerName = value["LoadBalancerName"].asString();
loadBalancerObject.loadBalancerStatus = value["LoadBalancerStatus"].asString();
loadBalancerObject.address = value["Address"].asString();
loadBalancerObject.addressType = value["AddressType"].asString();
loadBalancerObject.regionId = value["RegionId"].asString();
loadBalancerObject.regionIdAlias = value["RegionIdAlias"].asString();
loadBalancerObject.vSwitchId = value["VSwitchId"].asString();
loadBalancerObject.vpcId = value["VpcId"].asString();
loadBalancerObject.networkType = value["NetworkType"].asString();
loadBalancerObject.masterZoneId = value["MasterZoneId"].asString();
loadBalancerObject.slaveZoneId = value["SlaveZoneId"].asString();
loadBalancerObject.internetChargeType = value["InternetChargeType"].asString();
loadBalancerObject.createTime = value["CreateTime"].asString();
loadBalancerObject.createTimeStamp = std::stol(value["CreateTimeStamp"].asString());
loadBalancerObject.payType = value["PayType"].asString();
loadBalancerObject.resourceGroupId = value["ResourceGroupId"].asString();
loadBalancers_.push_back(loadBalancerObject);
LoadBalancer loadBalancersObject;
if(!value["LoadBalancerId"].isNull())
loadBalancersObject.loadBalancerId = value["LoadBalancerId"].asString();
if(!value["LoadBalancerName"].isNull())
loadBalancersObject.loadBalancerName = value["LoadBalancerName"].asString();
if(!value["LoadBalancerStatus"].isNull())
loadBalancersObject.loadBalancerStatus = value["LoadBalancerStatus"].asString();
if(!value["Address"].isNull())
loadBalancersObject.address = value["Address"].asString();
if(!value["AddressType"].isNull())
loadBalancersObject.addressType = value["AddressType"].asString();
if(!value["RegionId"].isNull())
loadBalancersObject.regionId = value["RegionId"].asString();
if(!value["RegionIdAlias"].isNull())
loadBalancersObject.regionIdAlias = value["RegionIdAlias"].asString();
if(!value["VSwitchId"].isNull())
loadBalancersObject.vSwitchId = value["VSwitchId"].asString();
if(!value["VpcId"].isNull())
loadBalancersObject.vpcId = value["VpcId"].asString();
if(!value["NetworkType"].isNull())
loadBalancersObject.networkType = value["NetworkType"].asString();
if(!value["MasterZoneId"].isNull())
loadBalancersObject.masterZoneId = value["MasterZoneId"].asString();
if(!value["SlaveZoneId"].isNull())
loadBalancersObject.slaveZoneId = value["SlaveZoneId"].asString();
if(!value["InternetChargeType"].isNull())
loadBalancersObject.internetChargeType = value["InternetChargeType"].asString();
if(!value["CreateTime"].isNull())
loadBalancersObject.createTime = value["CreateTime"].asString();
if(!value["CreateTimeStamp"].isNull())
loadBalancersObject.createTimeStamp = std::stol(value["CreateTimeStamp"].asString());
if(!value["PayType"].isNull())
loadBalancersObject.payType = value["PayType"].asString();
if(!value["ResourceGroupId"].isNull())
loadBalancersObject.resourceGroupId = value["ResourceGroupId"].asString();
loadBalancers_.push_back(loadBalancersObject);
}
pageNumber_ = std::stoi(value["PageNumber"].asString());
pageSize_ = std::stoi(value["PageSize"].asString());
totalCount_ = std::stoi(value["TotalCount"].asString());
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
}
@@ -74,28 +94,18 @@ int DescribeLoadBalancersResult::getTotalCount()const
return totalCount_;
}
void DescribeLoadBalancersResult::setTotalCount(int totalCount)
{
totalCount_ = totalCount;
}
int DescribeLoadBalancersResult::getPageSize()const
{
return pageSize_;
}
void DescribeLoadBalancersResult::setPageSize(int pageSize)
{
pageSize_ = pageSize;
}
int DescribeLoadBalancersResult::getPageNumber()const
{
return pageNumber_;
}
void DescribeLoadBalancersResult::setPageNumber(int pageNumber)
std::vector<DescribeLoadBalancersResult::LoadBalancer> DescribeLoadBalancersResult::getLoadBalancers()const
{
pageNumber_ = pageNumber;
return loadBalancers_;
}

16
slb/src/model/DescribeMasterSlaveServerGroupAttributeRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeMasterSlaveServerGroupAttributeRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeMasterSlaveServerGroupAttributeRequest;
DescribeMasterSlaveServerGroupAttributeRequest::DescribeMasterSlaveServerGroupAttributeRequest() :
SlbRequest("DescribeMasterSlaveServerGroupAttribute")
RpcServiceRequest("slb", "2014-05-15", "DescribeMasterSlaveServerGroupAttribute")
{}
DescribeMasterSlaveServerGroupAttributeRequest::~DescribeMasterSlaveServerGroupAttributeRequest()
@@ -103,17 +102,6 @@ void DescribeMasterSlaveServerGroupAttributeRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeMasterSlaveServerGroupAttributeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeMasterSlaveServerGroupAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeMasterSlaveServerGroupAttributeRequest::getTags()const
{
return tags_;

31
slb/src/model/DescribeMasterSlaveServerGroupAttributeResult.cc
View File

@@ -43,15 +43,21 @@ void DescribeMasterSlaveServerGroupAttributeResult::parse(const std::string &pay
auto allMasterSlaveBackendServers = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
for (auto value : allMasterSlaveBackendServers)
{
MasterSlaveBackendServer masterSlaveBackendServerObject;
masterSlaveBackendServerObject.serverId = value["ServerId"].asString();
masterSlaveBackendServerObject.port = std::stoi(value["Port"].asString());
masterSlaveBackendServerObject.weight = std::stoi(value["Weight"].asString());
masterSlaveBackendServerObject.serverType = value["ServerType"].asString();
masterSlaveBackendServers_.push_back(masterSlaveBackendServerObject);
MasterSlaveBackendServer masterSlaveBackendServersObject;
if(!value["ServerId"].isNull())
masterSlaveBackendServersObject.serverId = value["ServerId"].asString();
if(!value["Port"].isNull())
masterSlaveBackendServersObject.port = std::stoi(value["Port"].asString());
if(!value["Weight"].isNull())
masterSlaveBackendServersObject.weight = std::stoi(value["Weight"].asString());
if(!value["ServerType"].isNull())
masterSlaveBackendServersObject.serverType = value["ServerType"].asString();
masterSlaveBackendServers_.push_back(masterSlaveBackendServersObject);
}
masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
masterSlaveServerGroupName_ = value["MasterSlaveServerGroupName"].asString();
if(!value["MasterSlaveServerGroupId"].isNull())
masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
if(!value["MasterSlaveServerGroupName"].isNull())
masterSlaveServerGroupName_ = value["MasterSlaveServerGroupName"].asString();
}
@@ -60,18 +66,13 @@ std::string DescribeMasterSlaveServerGroupAttributeResult::getMasterSlaveServerG
return masterSlaveServerGroupId_;
}
void DescribeMasterSlaveServerGroupAttributeResult::setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId)
{
masterSlaveServerGroupId_ = masterSlaveServerGroupId;
}
std::string DescribeMasterSlaveServerGroupAttributeResult::getMasterSlaveServerGroupName()const
{
return masterSlaveServerGroupName_;
}
void DescribeMasterSlaveServerGroupAttributeResult::setMasterSlaveServerGroupName(const std::string& masterSlaveServerGroupName)
std::vector<DescribeMasterSlaveServerGroupAttributeResult::MasterSlaveBackendServer> DescribeMasterSlaveServerGroupAttributeResult::getMasterSlaveBackendServers()const
{
masterSlaveServerGroupName_ = masterSlaveServerGroupName;
return masterSlaveBackendServers_;
}

16
slb/src/model/DescribeMasterSlaveServerGroupsRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeMasterSlaveServerGroupsRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeMasterSlaveServerGroupsRequest;
DescribeMasterSlaveServerGroupsRequest::DescribeMasterSlaveServerGroupsRequest() :
SlbRequest("DescribeMasterSlaveServerGroups")
RpcServiceRequest("slb", "2014-05-15", "DescribeMasterSlaveServerGroups")
{}
DescribeMasterSlaveServerGroupsRequest::~DescribeMasterSlaveServerGroupsRequest()
@@ -103,17 +102,6 @@ void DescribeMasterSlaveServerGroupsRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeMasterSlaveServerGroupsRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeMasterSlaveServerGroupsRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeMasterSlaveServerGroupsRequest::getTags()const
{
return tags_;

15
slb/src/model/DescribeMasterSlaveServerGroupsResult.cc
View File

@@ -43,11 +43,18 @@ void DescribeMasterSlaveServerGroupsResult::parse(const std::string &payload)
auto allMasterSlaveServerGroups = value["MasterSlaveServerGroups"]["MasterSlaveServerGroup"];
for (auto value : allMasterSlaveServerGroups)
{
MasterSlaveServerGroup masterSlaveServerGroupObject;
masterSlaveServerGroupObject.masterSlaveServerGroupId = value["MasterSlaveServerGroupId"].asString();
masterSlaveServerGroupObject.masterSlaveServerGroupName = value["MasterSlaveServerGroupName"].asString();
masterSlaveServerGroups_.push_back(masterSlaveServerGroupObject);
MasterSlaveServerGroup masterSlaveServerGroupsObject;
if(!value["MasterSlaveServerGroupId"].isNull())
masterSlaveServerGroupsObject.masterSlaveServerGroupId = value["MasterSlaveServerGroupId"].asString();
if(!value["MasterSlaveServerGroupName"].isNull())
masterSlaveServerGroupsObject.masterSlaveServerGroupName = value["MasterSlaveServerGroupName"].asString();
masterSlaveServerGroups_.push_back(masterSlaveServerGroupsObject);
}
}
std::vector<DescribeMasterSlaveServerGroupsResult::MasterSlaveServerGroup> DescribeMasterSlaveServerGroupsResult::getMasterSlaveServerGroups()const
{
return masterSlaveServerGroups_;
}

5
slb/src/model/DescribeMasterSlaveVServerGroupAttributeRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeMasterSlaveVServerGroupAttributeRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeMasterSlaveVServerGroupAttributeRequest;
DescribeMasterSlaveVServerGroupAttributeRequest::DescribeMasterSlaveVServerGroupAttributeRequest() :
SlbRequest("DescribeMasterSlaveVServerGroupAttribute")
RpcServiceRequest("slb", "2014-05-15", "DescribeMasterSlaveVServerGroupAttribute")
{}
DescribeMasterSlaveVServerGroupAttributeRequest::~DescribeMasterSlaveVServerGroupAttributeRequest()

31
slb/src/model/DescribeMasterSlaveVServerGroupAttributeResult.cc
View File

@@ -43,15 +43,21 @@ void DescribeMasterSlaveVServerGroupAttributeResult::parse(const std::string &pa
auto allMasterSlaveBackendServers = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
for (auto value : allMasterSlaveBackendServers)
{
MasterSlaveBackendServer masterSlaveBackendServerObject;
masterSlaveBackendServerObject.serverId = value["ServerId"].asString();
masterSlaveBackendServerObject.port = std::stoi(value["Port"].asString());
masterSlaveBackendServerObject.weight = std::stoi(value["Weight"].asString());
masterSlaveBackendServerObject.isBackup = std::stoi(value["IsBackup"].asString());
masterSlaveBackendServers_.push_back(masterSlaveBackendServerObject);
MasterSlaveBackendServer masterSlaveBackendServersObject;
if(!value["ServerId"].isNull())
masterSlaveBackendServersObject.serverId = value["ServerId"].asString();
if(!value["Port"].isNull())
masterSlaveBackendServersObject.port = std::stoi(value["Port"].asString());
if(!value["Weight"].isNull())
masterSlaveBackendServersObject.weight = std::stoi(value["Weight"].asString());
if(!value["IsBackup"].isNull())
masterSlaveBackendServersObject.isBackup = std::stoi(value["IsBackup"].asString());
masterSlaveBackendServers_.push_back(masterSlaveBackendServersObject);
}
masterSlaveVServerGroupId_ = value["MasterSlaveVServerGroupId"].asString();
masterSlaveVServerGroupName_ = value["MasterSlaveVServerGroupName"].asString();
if(!value["MasterSlaveVServerGroupId"].isNull())
masterSlaveVServerGroupId_ = value["MasterSlaveVServerGroupId"].asString();
if(!value["MasterSlaveVServerGroupName"].isNull())
masterSlaveVServerGroupName_ = value["MasterSlaveVServerGroupName"].asString();
}
@@ -60,9 +66,9 @@ std::string DescribeMasterSlaveVServerGroupAttributeResult::getMasterSlaveVServe
return masterSlaveVServerGroupId_;
}
void DescribeMasterSlaveVServerGroupAttributeResult::setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId)
std::vector<DescribeMasterSlaveVServerGroupAttributeResult::MasterSlaveBackendServer> DescribeMasterSlaveVServerGroupAttributeResult::getMasterSlaveBackendServers()const
{
masterSlaveVServerGroupId_ = masterSlaveVServerGroupId;
return masterSlaveBackendServers_;
}
std::string DescribeMasterSlaveVServerGroupAttributeResult::getMasterSlaveVServerGroupName()const
@@ -70,8 +76,3 @@ std::string DescribeMasterSlaveVServerGroupAttributeResult::getMasterSlaveVServe
return masterSlaveVServerGroupName_;
}
void DescribeMasterSlaveVServerGroupAttributeResult::setMasterSlaveVServerGroupName(const std::string& masterSlaveVServerGroupName)
{
masterSlaveVServerGroupName_ = masterSlaveVServerGroupName;
}

5
slb/src/model/DescribeMasterSlaveVServerGroupsRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeMasterSlaveVServerGroupsRequest;
DescribeMasterSlaveVServerGroupsRequest::DescribeMasterSlaveVServerGroupsRequest() :
SlbRequest("DescribeMasterSlaveVServerGroups")
RpcServiceRequest("slb", "2014-05-15", "DescribeMasterSlaveVServerGroups")
{}
DescribeMasterSlaveVServerGroupsRequest::~DescribeMasterSlaveVServerGroupsRequest()

15
slb/src/model/DescribeMasterSlaveVServerGroupsResult.cc
View File

@@ -43,11 +43,18 @@ void DescribeMasterSlaveVServerGroupsResult::parse(const std::string &payload)
auto allMasterSlaveVServerGroups = value["MasterSlaveVServerGroups"]["MasterSlaveVServerGroup"];
for (auto value : allMasterSlaveVServerGroups)
{
MasterSlaveVServerGroup masterSlaveVServerGroupObject;
masterSlaveVServerGroupObject.masterSlaveVServerGroupId = value["MasterSlaveVServerGroupId"].asString();
masterSlaveVServerGroupObject.masterSlaveVServerGroupName = value["MasterSlaveVServerGroupName"].asString();
masterSlaveVServerGroups_.push_back(masterSlaveVServerGroupObject);
MasterSlaveVServerGroup masterSlaveVServerGroupsObject;
if(!value["MasterSlaveVServerGroupId"].isNull())
masterSlaveVServerGroupsObject.masterSlaveVServerGroupId = value["MasterSlaveVServerGroupId"].asString();
if(!value["MasterSlaveVServerGroupName"].isNull())
masterSlaveVServerGroupsObject.masterSlaveVServerGroupName = value["MasterSlaveVServerGroupName"].asString();
masterSlaveVServerGroups_.push_back(masterSlaveVServerGroupsObject);
}
}
std::vector<DescribeMasterSlaveVServerGroupsResult::MasterSlaveVServerGroup> DescribeMasterSlaveVServerGroupsResult::getMasterSlaveVServerGroups()const
{
return masterSlaveVServerGroups_;
}

16
slb/src/model/DescribeRegionsRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeRegionsRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeRegionsRequest;
DescribeRegionsRequest::DescribeRegionsRequest() :
SlbRequest("DescribeRegions")
RpcServiceRequest("slb", "2014-05-15", "DescribeRegions")
{}
DescribeRegionsRequest::~DescribeRegionsRequest()
@@ -92,17 +91,6 @@ void DescribeRegionsRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeRegionsRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeRegionsRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeRegionsRequest::getTags()const
{
return tags_;

15
slb/src/model/DescribeRegionsResult.cc
View File

@@ -43,11 +43,18 @@ void DescribeRegionsResult::parse(const std::string &payload)
auto allRegions = value["Regions"]["Region"];
for (auto value : allRegions)
{
Region regionObject;
regionObject.regionId = value["RegionId"].asString();
regionObject.localName = value["LocalName"].asString();
regions_.push_back(regionObject);
Region regionsObject;
if(!value["RegionId"].isNull())
regionsObject.regionId = value["RegionId"].asString();
if(!value["LocalName"].isNull())
regionsObject.localName = value["LocalName"].asString();
regions_.push_back(regionsObject);
}
}
std::vector<DescribeRegionsResult::Region> DescribeRegionsResult::getRegions()const
{
return regions_;
}

16
slb/src/model/DescribeRuleAttributeRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeRuleAttributeRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeRuleAttributeRequest;
DescribeRuleAttributeRequest::DescribeRuleAttributeRequest() :
SlbRequest("DescribeRuleAttribute")
RpcServiceRequest("slb", "2014-05-15", "DescribeRuleAttribute")
{}
DescribeRuleAttributeRequest::~DescribeRuleAttributeRequest()
@@ -103,17 +102,6 @@ void DescribeRuleAttributeRequest::setRuleId(const std::string& ruleId)
setParameter("RuleId", ruleId);
}
std::string DescribeRuleAttributeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeRuleAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeRuleAttributeRequest::getTags()const
{
return tags_;

48
slb/src/model/DescribeRuleAttributeResult.cc
View File

@@ -40,12 +40,18 @@ void DescribeRuleAttributeResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
ruleName_ = value["RuleName"].asString();
loadBalancerId_ = value["LoadBalancerId"].asString();
listenerPort_ = value["ListenerPort"].asString();
domain_ = value["Domain"].asString();
url_ = value["Url"].asString();
vServerGroupId_ = value["VServerGroupId"].asString();
if(!value["RuleName"].isNull())
ruleName_ = value["RuleName"].asString();
if(!value["LoadBalancerId"].isNull())
loadBalancerId_ = value["LoadBalancerId"].asString();
if(!value["ListenerPort"].isNull())
listenerPort_ = value["ListenerPort"].asString();
if(!value["Domain"].isNull())
domain_ = value["Domain"].asString();
if(!value["Url"].isNull())
url_ = value["Url"].asString();
if(!value["VServerGroupId"].isNull())
vServerGroupId_ = value["VServerGroupId"].asString();
}
@@ -54,58 +60,28 @@ std::string DescribeRuleAttributeResult::getListenerPort()const
return listenerPort_;
}
void DescribeRuleAttributeResult::setListenerPort(const std::string& listenerPort)
{
listenerPort_ = listenerPort;
}
std::string DescribeRuleAttributeResult::getVServerGroupId()const
{
return vServerGroupId_;
}
void DescribeRuleAttributeResult::setVServerGroupId(const std::string& vServerGroupId)
{
vServerGroupId_ = vServerGroupId;
}
std::string DescribeRuleAttributeResult::getLoadBalancerId()const
{
return loadBalancerId_;
}
void DescribeRuleAttributeResult::setLoadBalancerId(const std::string& loadBalancerId)
{
loadBalancerId_ = loadBalancerId;
}
std::string DescribeRuleAttributeResult::getDomain()const
{
return domain_;
}
void DescribeRuleAttributeResult::setDomain(const std::string& domain)
{
domain_ = domain;
}
std::string DescribeRuleAttributeResult::getRuleName()const
{
return ruleName_;
}
void DescribeRuleAttributeResult::setRuleName(const std::string& ruleName)
{
ruleName_ = ruleName;
}
std::string DescribeRuleAttributeResult::getUrl()const
{
return url_;
}
void DescribeRuleAttributeResult::setUrl(const std::string& url)
{
url_ = url;
}

16
slb/src/model/DescribeRulesRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeRulesRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeRulesRequest;
DescribeRulesRequest::DescribeRulesRequest() :
SlbRequest("DescribeRules")
RpcServiceRequest("slb", "2014-05-15", "DescribeRules")
{}
DescribeRulesRequest::~DescribeRulesRequest()
@@ -114,17 +113,6 @@ void DescribeRulesRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeRulesRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeRulesRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeRulesRequest::getTags()const
{
return tags_;

24
slb/src/model/DescribeRulesResult.cc
View File

@@ -43,14 +43,24 @@ void DescribeRulesResult::parse(const std::string &payload)
auto allRules = value["Rules"]["Rule"];
for (auto value : allRules)
{
Rule ruleObject;
ruleObject.ruleId = value["RuleId"].asString();
ruleObject.ruleName = value["RuleName"].asString();
ruleObject.domain = value["Domain"].asString();
ruleObject.url = value["Url"].asString();
ruleObject.vServerGroupId = value["VServerGroupId"].asString();
rules_.push_back(ruleObject);
Rule rulesObject;
if(!value["RuleId"].isNull())
rulesObject.ruleId = value["RuleId"].asString();
if(!value["RuleName"].isNull())
rulesObject.ruleName = value["RuleName"].asString();
if(!value["Domain"].isNull())
rulesObject.domain = value["Domain"].asString();
if(!value["Url"].isNull())
rulesObject.url = value["Url"].asString();
if(!value["VServerGroupId"].isNull())
rulesObject.vServerGroupId = value["VServerGroupId"].asString();
rules_.push_back(rulesObject);
}
}
std::vector<DescribeRulesResult::Rule> DescribeRulesResult::getRules()const
{
return rules_;
}

16
slb/src/model/DescribeServerCertificatesRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeServerCertificatesRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeServerCertificatesRequest;
DescribeServerCertificatesRequest::DescribeServerCertificatesRequest() :
SlbRequest("DescribeServerCertificates")
RpcServiceRequest("slb", "2014-05-15", "DescribeServerCertificates")
{}
DescribeServerCertificatesRequest::~DescribeServerCertificatesRequest()
@@ -114,17 +113,6 @@ void DescribeServerCertificatesRequest::setServerCertificateId(const std::string
setParameter("ServerCertificateId", serverCertificateId);
}
std::string DescribeServerCertificatesRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeServerCertificatesRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeServerCertificatesRequest::getTags()const
{
return tags_;

42
slb/src/model/DescribeServerCertificatesResult.cc
View File

@@ -43,20 +43,36 @@ void DescribeServerCertificatesResult::parse(const std::string &payload)
auto allServerCertificates = value["ServerCertificates"]["ServerCertificate"];
for (auto value : allServerCertificates)
{
ServerCertificate serverCertificateObject;
serverCertificateObject.serverCertificateId = value["ServerCertificateId"].asString();
serverCertificateObject.fingerprint = value["Fingerprint"].asString();
serverCertificateObject.serverCertificateName = value["ServerCertificateName"].asString();
serverCertificateObject.regionId = value["RegionId"].asString();
serverCertificateObject.regionIdAlias = value["RegionIdAlias"].asString();
serverCertificateObject.aliCloudCertificateId = value["AliCloudCertificateId"].asString();
serverCertificateObject.aliCloudCertificateName = value["AliCloudCertificateName"].asString();
serverCertificateObject.isAliCloudCertificate = std::stoi(value["IsAliCloudCertificate"].asString());
serverCertificateObject.resourceGroupId = value["ResourceGroupId"].asString();
serverCertificateObject.createTime = value["CreateTime"].asString();
serverCertificateObject.createTimeStamp = std::stol(value["CreateTimeStamp"].asString());
serverCertificates_.push_back(serverCertificateObject);
ServerCertificate serverCertificatesObject;
if(!value["ServerCertificateId"].isNull())
serverCertificatesObject.serverCertificateId = value["ServerCertificateId"].asString();
if(!value["Fingerprint"].isNull())
serverCertificatesObject.fingerprint = value["Fingerprint"].asString();
if(!value["ServerCertificateName"].isNull())
serverCertificatesObject.serverCertificateName = value["ServerCertificateName"].asString();
if(!value["RegionId"].isNull())
serverCertificatesObject.regionId = value["RegionId"].asString();
if(!value["RegionIdAlias"].isNull())
serverCertificatesObject.regionIdAlias = value["RegionIdAlias"].asString();
if(!value["AliCloudCertificateId"].isNull())
serverCertificatesObject.aliCloudCertificateId = value["AliCloudCertificateId"].asString();
if(!value["AliCloudCertificateName"].isNull())
serverCertificatesObject.aliCloudCertificateName = value["AliCloudCertificateName"].asString();
if(!value["IsAliCloudCertificate"].isNull())
serverCertificatesObject.isAliCloudCertificate = std::stoi(value["IsAliCloudCertificate"].asString());
if(!value["ResourceGroupId"].isNull())
serverCertificatesObject.resourceGroupId = value["ResourceGroupId"].asString();
if(!value["CreateTime"].isNull())
serverCertificatesObject.createTime = value["CreateTime"].asString();
if(!value["CreateTimeStamp"].isNull())
serverCertificatesObject.createTimeStamp = std::stol(value["CreateTimeStamp"].asString());
serverCertificates_.push_back(serverCertificatesObject);
}
}
std::vector<DescribeServerCertificatesResult::ServerCertificate> DescribeServerCertificatesResult::getServerCertificates()const
{
return serverCertificates_;
}

82
slb/src/model/DescribeTagsRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeTagsRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeTagsRequest;
DescribeTagsRequest::DescribeTagsRequest() :
SlbRequest("DescribeTags")
RpcServiceRequest("slb", "2014-05-15", "DescribeTags")
{}
DescribeTagsRequest::~DescribeTagsRequest()
@@ -48,6 +47,17 @@ void DescribeTagsRequest::setResourceOwnerId(long resourceOwnerId)
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeTagsRequest::getLoadBalancerId()const
{
return loadBalancerId_;
}
void DescribeTagsRequest::setLoadBalancerId(const std::string& loadBalancerId)
{
loadBalancerId_ = loadBalancerId;
setParameter("LoadBalancerId", loadBalancerId);
}
std::string DescribeTagsRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
@@ -59,6 +69,17 @@ void DescribeTagsRequest::setResourceOwnerAccount(const std::string& resourceOwn
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeTagsRequest::getRegionId()const
{
return regionId_;
}
void DescribeTagsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribeTagsRequest::getOwnerAccount()const
{
return ownerAccount_;
@@ -70,6 +91,17 @@ void DescribeTagsRequest::setOwnerAccount(const std::string& ownerAccount)
setParameter("OwnerAccount", ownerAccount);
}
int DescribeTagsRequest::getPageSize()const
{
return pageSize_;
}
void DescribeTagsRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
bool DescribeTagsRequest::getDistinctKey()const
{
return distinctKey_;
@@ -103,17 +135,6 @@ void DescribeTagsRequest::setPageNumber(int pageNumber)
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeTagsRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeTagsRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeTagsRequest::getTags()const
{
return tags_;
@@ -125,36 +146,3 @@ void DescribeTagsRequest::setTags(const std::string& tags)
setParameter("Tags", tags);
}
std::string DescribeTagsRequest::getLoadBalancerId()const
{
return loadBalancerId_;
}
void DescribeTagsRequest::setLoadBalancerId(const std::string& loadBalancerId)
{
loadBalancerId_ = loadBalancerId;
setParameter("LoadBalancerId", loadBalancerId);
}
std::string DescribeTagsRequest::getRegionId()const
{
return regionId_;
}
void DescribeTagsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
int DescribeTagsRequest::getPageSize()const
{
return pageSize_;
}
void DescribeTagsRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}

36
slb/src/model/DescribeTagsResult.cc
View File

@@ -43,15 +43,21 @@ void DescribeTagsResult::parse(const std::string &payload)
auto allTagSets = value["TagSets"]["TagSet"];
for (auto value : allTagSets)
{
TagSet tagSetObject;
tagSetObject.tagKey = value["TagKey"].asString();
tagSetObject.tagValue = value["TagValue"].asString();
tagSetObject.instanceCount = std::stoi(value["InstanceCount"].asString());
tagSets_.push_back(tagSetObject);
TagSet tagSetsObject;
if(!value["TagKey"].isNull())
tagSetsObject.tagKey = value["TagKey"].asString();
if(!value["TagValue"].isNull())
tagSetsObject.tagValue = value["TagValue"].asString();
if(!value["InstanceCount"].isNull())
tagSetsObject.instanceCount = std::stoi(value["InstanceCount"].asString());
tagSets_.push_back(tagSetsObject);
}
pageSize_ = std::stoi(value["PageSize"].asString());
pageNumber_ = std::stoi(value["PageNumber"].asString());
totalCount_ = std::stoi(value["TotalCount"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
}
@@ -60,28 +66,18 @@ int DescribeTagsResult::getTotalCount()const
return totalCount_;
}
void DescribeTagsResult::setTotalCount(int totalCount)
{
totalCount_ = totalCount;
}
int DescribeTagsResult::getPageSize()const
{
return pageSize_;
}
void DescribeTagsResult::setPageSize(int pageSize)
{
pageSize_ = pageSize;
}
int DescribeTagsResult::getPageNumber()const
{
return pageNumber_;
}
void DescribeTagsResult::setPageNumber(int pageNumber)
std::vector<DescribeTagsResult::TagSet> DescribeTagsResult::getTagSets()const
{
pageNumber_ = pageNumber;
return tagSets_;
}

16
slb/src/model/DescribeVServerGroupAttributeRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeVServerGroupAttributeRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeVServerGroupAttributeRequest;
DescribeVServerGroupAttributeRequest::DescribeVServerGroupAttributeRequest() :
SlbRequest("DescribeVServerGroupAttribute")
RpcServiceRequest("slb", "2014-05-15", "DescribeVServerGroupAttribute")
{}
DescribeVServerGroupAttributeRequest::~DescribeVServerGroupAttributeRequest()
@@ -103,17 +102,6 @@ void DescribeVServerGroupAttributeRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeVServerGroupAttributeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeVServerGroupAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeVServerGroupAttributeRequest::getTags()const
{
return tags_;

28
slb/src/model/DescribeVServerGroupAttributeResult.cc
View File

@@ -43,14 +43,19 @@ void DescribeVServerGroupAttributeResult::parse(const std::string &payload)
auto allBackendServers = value["BackendServers"]["BackendServer"];
for (auto value : allBackendServers)
{
BackendServer backendServerObject;
backendServerObject.serverId = value["ServerId"].asString();
backendServerObject.port = std::stoi(value["Port"].asString());
backendServerObject.weight = std::stoi(value["Weight"].asString());
backendServers_.push_back(backendServerObject);
BackendServer backendServersObject;
if(!value["ServerId"].isNull())
backendServersObject.serverId = value["ServerId"].asString();
if(!value["Port"].isNull())
backendServersObject.port = std::stoi(value["Port"].asString());
if(!value["Weight"].isNull())
backendServersObject.weight = std::stoi(value["Weight"].asString());
backendServers_.push_back(backendServersObject);
}
vServerGroupId_ = value["VServerGroupId"].asString();
vServerGroupName_ = value["VServerGroupName"].asString();
if(!value["VServerGroupId"].isNull())
vServerGroupId_ = value["VServerGroupId"].asString();
if(!value["VServerGroupName"].isNull())
vServerGroupName_ = value["VServerGroupName"].asString();
}
@@ -59,18 +64,13 @@ std::string DescribeVServerGroupAttributeResult::getVServerGroupId()const
return vServerGroupId_;
}
void DescribeVServerGroupAttributeResult::setVServerGroupId(const std::string& vServerGroupId)
{
vServerGroupId_ = vServerGroupId;
}
std::string DescribeVServerGroupAttributeResult::getVServerGroupName()const
{
return vServerGroupName_;
}
void DescribeVServerGroupAttributeResult::setVServerGroupName(const std::string& vServerGroupName)
std::vector<DescribeVServerGroupAttributeResult::BackendServer> DescribeVServerGroupAttributeResult::getBackendServers()const
{
vServerGroupName_ = vServerGroupName;
return backendServers_;
}

16
slb/src/model/DescribeVServerGroupsRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeVServerGroupsRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeVServerGroupsRequest;
DescribeVServerGroupsRequest::DescribeVServerGroupsRequest() :
SlbRequest("DescribeVServerGroups")
RpcServiceRequest("slb", "2014-05-15", "DescribeVServerGroups")
{}
DescribeVServerGroupsRequest::~DescribeVServerGroupsRequest()
@@ -103,17 +102,6 @@ void DescribeVServerGroupsRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeVServerGroupsRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeVServerGroupsRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeVServerGroupsRequest::getTags()const
{
return tags_;

15
slb/src/model/DescribeVServerGroupsResult.cc
View File

@@ -43,11 +43,18 @@ void DescribeVServerGroupsResult::parse(const std::string &payload)
auto allVServerGroups = value["VServerGroups"]["VServerGroup"];
for (auto value : allVServerGroups)
{
VServerGroup vServerGroupObject;
vServerGroupObject.vServerGroupId = value["VServerGroupId"].asString();
vServerGroupObject.vServerGroupName = value["VServerGroupName"].asString();
vServerGroups_.push_back(vServerGroupObject);
VServerGroup vServerGroupsObject;
if(!value["VServerGroupId"].isNull())
vServerGroupsObject.vServerGroupId = value["VServerGroupId"].asString();
if(!value["VServerGroupName"].isNull())
vServerGroupsObject.vServerGroupName = value["VServerGroupName"].asString();
vServerGroups_.push_back(vServerGroupsObject);
}
}
std::vector<DescribeVServerGroupsResult::VServerGroup> DescribeVServerGroupsResult::getVServerGroups()const
{
return vServerGroups_;
}

16
slb/src/model/DescribeZonesRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/DescribeZonesRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::DescribeZonesRequest;
DescribeZonesRequest::DescribeZonesRequest() :
SlbRequest("DescribeZones")
RpcServiceRequest("slb", "2014-05-15", "DescribeZones")
{}
DescribeZonesRequest::~DescribeZonesRequest()
@@ -92,17 +91,6 @@ void DescribeZonesRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeZonesRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeZonesRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeZonesRequest::getTags()const
{
return tags_;

25
slb/src/model/DescribeZonesResult.cc
View File

@@ -43,19 +43,28 @@ void DescribeZonesResult::parse(const std::string &payload)
auto allZones = value["Zones"]["Zone"];
for (auto value : allZones)
{
Zone zoneObject;
zoneObject.zoneId = value["ZoneId"].asString();
zoneObject.localName = value["LocalName"].asString();
Zone zonesObject;
if(!value["ZoneId"].isNull())
zonesObject.zoneId = value["ZoneId"].asString();
if(!value["LocalName"].isNull())
zonesObject.localName = value["LocalName"].asString();
auto allSlaveZones = value["SlaveZones"]["SlaveZone"];
for (auto value : allSlaveZones)
{
Zone::SlaveZone slaveZoneObject;
slaveZoneObject.zoneId = value["ZoneId"].asString();
slaveZoneObject.localName = value["LocalName"].asString();
zoneObject.slaveZones.push_back(slaveZoneObject);
Zone::SlaveZone slaveZonesObject;
if(!value["ZoneId"].isNull())
slaveZonesObject.zoneId = value["ZoneId"].asString();
if(!value["LocalName"].isNull())
slaveZonesObject.localName = value["LocalName"].asString();
zonesObject.slaveZones.push_back(slaveZonesObject);
}
zones_.push_back(zoneObject);
zones_.push_back(zonesObject);
}
}
std::vector<DescribeZonesResult::Zone> DescribeZonesResult::getZones()const
{
return zones_;
}

16
slb/src/model/ModifyLoadBalancerInstanceSpecRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/ModifyLoadBalancerInstanceSpecRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::ModifyLoadBalancerInstanceSpecRequest;
ModifyLoadBalancerInstanceSpecRequest::ModifyLoadBalancerInstanceSpecRequest() :
SlbRequest("ModifyLoadBalancerInstanceSpec")
RpcServiceRequest("slb", "2014-05-15", "ModifyLoadBalancerInstanceSpec")
{}
ModifyLoadBalancerInstanceSpecRequest::~ModifyLoadBalancerInstanceSpecRequest()
@@ -125,17 +124,6 @@ void ModifyLoadBalancerInstanceSpecRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string ModifyLoadBalancerInstanceSpecRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void ModifyLoadBalancerInstanceSpecRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string ModifyLoadBalancerInstanceSpecRequest::getTags()const
{
return tags_;

8
slb/src/model/ModifyLoadBalancerInstanceSpecResult.cc
View File

@@ -40,7 +40,8 @@ void ModifyLoadBalancerInstanceSpecResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
orderId_ = std::stol(value["OrderId"].asString());
if(!value["OrderId"].isNull())
orderId_ = std::stol(value["OrderId"].asString());
}
@@ -49,8 +50,3 @@ long ModifyLoadBalancerInstanceSpecResult::getOrderId()const
return orderId_;
}
void ModifyLoadBalancerInstanceSpecResult::setOrderId(long orderId)
{
orderId_ = orderId;
}

82
slb/src/model/ModifyLoadBalancerInternetSpecRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/ModifyLoadBalancerInternetSpecRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::ModifyLoadBalancerInternetSpecRequest;
ModifyLoadBalancerInternetSpecRequest::ModifyLoadBalancerInternetSpecRequest() :
SlbRequest("ModifyLoadBalancerInternetSpec")
RpcServiceRequest("slb", "2014-05-15", "ModifyLoadBalancerInternetSpec")
{}
ModifyLoadBalancerInternetSpecRequest::~ModifyLoadBalancerInternetSpecRequest()
@@ -48,6 +47,17 @@ void ModifyLoadBalancerInternetSpecRequest::setResourceOwnerId(long resourceOwne
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string ModifyLoadBalancerInternetSpecRequest::getLoadBalancerId()const
{
return loadBalancerId_;
}
void ModifyLoadBalancerInternetSpecRequest::setLoadBalancerId(const std::string& loadBalancerId)
{
loadBalancerId_ = loadBalancerId;
setParameter("LoadBalancerId", loadBalancerId);
}
bool ModifyLoadBalancerInternetSpecRequest::getAutoPay()const
{
return autoPay_;
@@ -59,6 +69,17 @@ void ModifyLoadBalancerInternetSpecRequest::setAutoPay(bool autoPay)
setParameter("AutoPay", std::to_string(autoPay));
}
std::string ModifyLoadBalancerInternetSpecRequest::getRegionId()const
{
return regionId_;
}
void ModifyLoadBalancerInternetSpecRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string ModifyLoadBalancerInternetSpecRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
@@ -81,6 +102,17 @@ void ModifyLoadBalancerInternetSpecRequest::setBandwidth(int bandwidth)
setParameter("Bandwidth", std::to_string(bandwidth));
}
std::string ModifyLoadBalancerInternetSpecRequest::getInternetChargeType()const
{
return internetChargeType_;
}
void ModifyLoadBalancerInternetSpecRequest::setInternetChargeType(const std::string& internetChargeType)
{
internetChargeType_ = internetChargeType;
setParameter("InternetChargeType", internetChargeType);
}
std::string ModifyLoadBalancerInternetSpecRequest::getOwnerAccount()const
{
return ownerAccount_;
@@ -103,17 +135,6 @@ void ModifyLoadBalancerInternetSpecRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string ModifyLoadBalancerInternetSpecRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void ModifyLoadBalancerInternetSpecRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string ModifyLoadBalancerInternetSpecRequest::getTags()const
{
return tags_;
@@ -125,36 +146,3 @@ void ModifyLoadBalancerInternetSpecRequest::setTags(const std::string& tags)
setParameter("Tags", tags);
}
std::string ModifyLoadBalancerInternetSpecRequest::getLoadBalancerId()const
{
return loadBalancerId_;
}
void ModifyLoadBalancerInternetSpecRequest::setLoadBalancerId(const std::string& loadBalancerId)
{
loadBalancerId_ = loadBalancerId;
setParameter("LoadBalancerId", loadBalancerId);
}
std::string ModifyLoadBalancerInternetSpecRequest::getRegionId()const
{
return regionId_;
}
void ModifyLoadBalancerInternetSpecRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string ModifyLoadBalancerInternetSpecRequest::getInternetChargeType()const
{
return internetChargeType_;
}
void ModifyLoadBalancerInternetSpecRequest::setInternetChargeType(const std::string& internetChargeType)
{
internetChargeType_ = internetChargeType;
setParameter("InternetChargeType", internetChargeType);
}

8
slb/src/model/ModifyLoadBalancerInternetSpecResult.cc
View File

@@ -40,7 +40,8 @@ void ModifyLoadBalancerInternetSpecResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
orderId_ = std::stol(value["OrderId"].asString());
if(!value["OrderId"].isNull())
orderId_ = std::stol(value["OrderId"].asString());
}
@@ -49,8 +50,3 @@ long ModifyLoadBalancerInternetSpecResult::getOrderId()const
return orderId_;
}
void ModifyLoadBalancerInternetSpecResult::setOrderId(long orderId)
{
orderId_ = orderId;
}

16
slb/src/model/ModifyLoadBalancerPayTypeRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/ModifyLoadBalancerPayTypeRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::ModifyLoadBalancerPayTypeRequest;
ModifyLoadBalancerPayTypeRequest::ModifyLoadBalancerPayTypeRequest() :
SlbRequest("ModifyLoadBalancerPayType")
RpcServiceRequest("slb", "2014-05-15", "ModifyLoadBalancerPayType")
{}
ModifyLoadBalancerPayTypeRequest::~ModifyLoadBalancerPayTypeRequest()
@@ -92,17 +91,6 @@ void ModifyLoadBalancerPayTypeRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string ModifyLoadBalancerPayTypeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void ModifyLoadBalancerPayTypeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string ModifyLoadBalancerPayTypeRequest::getTags()const
{
return tags_;

8
slb/src/model/ModifyLoadBalancerPayTypeResult.cc
View File

@@ -40,7 +40,8 @@ void ModifyLoadBalancerPayTypeResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
orderId_ = std::stol(value["OrderId"].asString());
if(!value["OrderId"].isNull())
orderId_ = std::stol(value["OrderId"].asString());
}
@@ -49,8 +50,3 @@ long ModifyLoadBalancerPayTypeResult::getOrderId()const
return orderId_;
}
void ModifyLoadBalancerPayTypeResult::setOrderId(long orderId)
{
orderId_ = orderId;
}

16
slb/src/model/ModifyVServerGroupBackendServersRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/ModifyVServerGroupBackendServersRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::ModifyVServerGroupBackendServersRequest;
ModifyVServerGroupBackendServersRequest::ModifyVServerGroupBackendServersRequest() :
SlbRequest("ModifyVServerGroupBackendServers")
RpcServiceRequest("slb", "2014-05-15", "ModifyVServerGroupBackendServers")
{}
ModifyVServerGroupBackendServersRequest::~ModifyVServerGroupBackendServersRequest()
@@ -125,17 +124,6 @@ void ModifyVServerGroupBackendServersRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string ModifyVServerGroupBackendServersRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void ModifyVServerGroupBackendServersRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string ModifyVServerGroupBackendServersRequest::getTags()const
{
return tags_;

20
slb/src/model/ModifyVServerGroupBackendServersResult.cc
View File

@@ -43,13 +43,17 @@ void ModifyVServerGroupBackendServersResult::parse(const std::string &payload)
auto allBackendServers = value["BackendServers"]["BackendServer"];
for (auto value : allBackendServers)
{
BackendServer backendServerObject;
backendServerObject.serverId = value["ServerId"].asString();
backendServerObject.port = std::stoi(value["Port"].asString());
backendServerObject.weight = std::stoi(value["Weight"].asString());
backendServers_.push_back(backendServerObject);
BackendServer backendServersObject;
if(!value["ServerId"].isNull())
backendServersObject.serverId = value["ServerId"].asString();
if(!value["Port"].isNull())
backendServersObject.port = std::stoi(value["Port"].asString());
if(!value["Weight"].isNull())
backendServersObject.weight = std::stoi(value["Weight"].asString());
backendServers_.push_back(backendServersObject);
}
vServerGroupId_ = value["VServerGroupId"].asString();
if(!value["VServerGroupId"].isNull())
vServerGroupId_ = value["VServerGroupId"].asString();
}
@@ -58,8 +62,8 @@ std::string ModifyVServerGroupBackendServersResult::getVServerGroupId()const
return vServerGroupId_;
}
void ModifyVServerGroupBackendServersResult::setVServerGroupId(const std::string& vServerGroupId)
std::vector<ModifyVServerGroupBackendServersResult::BackendServer> ModifyVServerGroupBackendServersResult::getBackendServers()const
{
vServerGroupId_ = vServerGroupId;
return backendServers_;
}

5
slb/src/model/MoveResourceGroupRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/MoveResourceGroupRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::MoveResourceGroupRequest;
MoveResourceGroupRequest::MoveResourceGroupRequest() :
SlbRequest("MoveResourceGroup")
RpcServiceRequest("slb", "2014-05-15", "MoveResourceGroup")
{}
MoveResourceGroupRequest::~MoveResourceGroupRequest()

16
slb/src/model/RemoveBackendServersRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/RemoveBackendServersRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::RemoveBackendServersRequest;
RemoveBackendServersRequest::RemoveBackendServersRequest() :
SlbRequest("RemoveBackendServers")
RpcServiceRequest("slb", "2014-05-15", "RemoveBackendServers")
{}
RemoveBackendServersRequest::~RemoveBackendServersRequest()
@@ -114,17 +113,6 @@ void RemoveBackendServersRequest::setBackendServers(const std::string& backendSe
setParameter("BackendServers", backendServers);
}
std::string RemoveBackendServersRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void RemoveBackendServersRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string RemoveBackendServersRequest::getTags()const
{
return tags_;

17
slb/src/model/RemoveBackendServersResult.cc
View File

@@ -43,12 +43,15 @@ void RemoveBackendServersResult::parse(const std::string &payload)
auto allBackendServers = value["BackendServers"]["BackendServer"];
for (auto value : allBackendServers)
{
BackendServer backendServerObject;
backendServerObject.serverId = value["ServerId"].asString();
backendServerObject.weight = std::stoi(value["Weight"].asString());
backendServers_.push_back(backendServerObject);
BackendServer backendServersObject;
if(!value["ServerId"].isNull())
backendServersObject.serverId = value["ServerId"].asString();
if(!value["Weight"].isNull())
backendServersObject.weight = std::stoi(value["Weight"].asString());
backendServers_.push_back(backendServersObject);
}
loadBalancerId_ = value["LoadBalancerId"].asString();
if(!value["LoadBalancerId"].isNull())
loadBalancerId_ = value["LoadBalancerId"].asString();
}
@@ -57,8 +60,8 @@ std::string RemoveBackendServersResult::getLoadBalancerId()const
return loadBalancerId_;
}
void RemoveBackendServersResult::setLoadBalancerId(const std::string& loadBalancerId)
std::vector<RemoveBackendServersResult::BackendServer> RemoveBackendServersResult::getBackendServers()const
{
loadBalancerId_ = loadBalancerId;
return backendServers_;
}

16
slb/src/model/RemoveListenerWhiteListItemRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/RemoveListenerWhiteListItemRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::RemoveListenerWhiteListItemRequest;
RemoveListenerWhiteListItemRequest::RemoveListenerWhiteListItemRequest() :
SlbRequest("RemoveListenerWhiteListItem")
RpcServiceRequest("slb", "2014-05-15", "RemoveListenerWhiteListItem")
{}
RemoveListenerWhiteListItemRequest::~RemoveListenerWhiteListItemRequest()
@@ -125,17 +124,6 @@ void RemoveListenerWhiteListItemRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string RemoveListenerWhiteListItemRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void RemoveListenerWhiteListItemRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string RemoveListenerWhiteListItemRequest::getTags()const
{
return tags_;

16
slb/src/model/RemoveTagsRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/RemoveTagsRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::RemoveTagsRequest;
RemoveTagsRequest::RemoveTagsRequest() :
SlbRequest("RemoveTags")
RpcServiceRequest("slb", "2014-05-15", "RemoveTags")
{}
RemoveTagsRequest::~RemoveTagsRequest()
@@ -103,17 +102,6 @@ void RemoveTagsRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string RemoveTagsRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void RemoveTagsRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string RemoveTagsRequest::getTags()const
{
return tags_;

16
slb/src/model/RemoveVServerGroupBackendServersRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/RemoveVServerGroupBackendServersRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::RemoveVServerGroupBackendServersRequest;
RemoveVServerGroupBackendServersRequest::RemoveVServerGroupBackendServersRequest() :
SlbRequest("RemoveVServerGroupBackendServers")
RpcServiceRequest("slb", "2014-05-15", "RemoveVServerGroupBackendServers")
{}
RemoveVServerGroupBackendServersRequest::~RemoveVServerGroupBackendServersRequest()
@@ -114,17 +113,6 @@ void RemoveVServerGroupBackendServersRequest::setBackendServers(const std::strin
setParameter("BackendServers", backendServers);
}
std::string RemoveVServerGroupBackendServersRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void RemoveVServerGroupBackendServersRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string RemoveVServerGroupBackendServersRequest::getTags()const
{
return tags_;

20
slb/src/model/RemoveVServerGroupBackendServersResult.cc
View File

@@ -43,13 +43,17 @@ void RemoveVServerGroupBackendServersResult::parse(const std::string &payload)
auto allBackendServers = value["BackendServers"]["BackendServer"];
for (auto value : allBackendServers)
{
BackendServer backendServerObject;
backendServerObject.serverId = value["ServerId"].asString();
backendServerObject.port = std::stoi(value["Port"].asString());
backendServerObject.weight = std::stoi(value["Weight"].asString());
backendServers_.push_back(backendServerObject);
BackendServer backendServersObject;
if(!value["ServerId"].isNull())
backendServersObject.serverId = value["ServerId"].asString();
if(!value["Port"].isNull())
backendServersObject.port = std::stoi(value["Port"].asString());
if(!value["Weight"].isNull())
backendServersObject.weight = std::stoi(value["Weight"].asString());
backendServers_.push_back(backendServersObject);
}
vServerGroupId_ = value["VServerGroupId"].asString();
if(!value["VServerGroupId"].isNull())
vServerGroupId_ = value["VServerGroupId"].asString();
}
@@ -58,8 +62,8 @@ std::string RemoveVServerGroupBackendServersResult::getVServerGroupId()const
return vServerGroupId_;
}
void RemoveVServerGroupBackendServersResult::setVServerGroupId(const std::string& vServerGroupId)
std::vector<RemoveVServerGroupBackendServersResult::BackendServer> RemoveVServerGroupBackendServersResult::getBackendServers()const
{
vServerGroupId_ = vServerGroupId;
return backendServers_;
}

126
slb/src/model/SetAccessLogsDownloadAttributeRequest.cc Normal file
View File

@@ -0,0 +1,126 @@
/*
* 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/slb/model/SetAccessLogsDownloadAttributeRequest.h>
using AlibabaCloud::Slb::Model::SetAccessLogsDownloadAttributeRequest;
SetAccessLogsDownloadAttributeRequest::SetAccessLogsDownloadAttributeRequest() :
RpcServiceRequest("slb", "2014-05-15", "SetAccessLogsDownloadAttribute")
{}
SetAccessLogsDownloadAttributeRequest::~SetAccessLogsDownloadAttributeRequest()
{}
std::string SetAccessLogsDownloadAttributeRequest::getAccess_key_id()const
{
return access_key_id_;
}
void SetAccessLogsDownloadAttributeRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
long SetAccessLogsDownloadAttributeRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void SetAccessLogsDownloadAttributeRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string SetAccessLogsDownloadAttributeRequest::getLoadBalancerId()const
{
return loadBalancerId_;
}
void SetAccessLogsDownloadAttributeRequest::setLoadBalancerId(const std::string& loadBalancerId)
{
loadBalancerId_ = loadBalancerId;
setParameter("LoadBalancerId", loadBalancerId);
}
std::string SetAccessLogsDownloadAttributeRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void SetAccessLogsDownloadAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string SetAccessLogsDownloadAttributeRequest::getRegionId()const
{
return regionId_;
}
void SetAccessLogsDownloadAttributeRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string SetAccessLogsDownloadAttributeRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void SetAccessLogsDownloadAttributeRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long SetAccessLogsDownloadAttributeRequest::getOwnerId()const
{
return ownerId_;
}
void SetAccessLogsDownloadAttributeRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string SetAccessLogsDownloadAttributeRequest::getTags()const
{
return tags_;
}
void SetAccessLogsDownloadAttributeRequest::setTags(const std::string& tags)
{
tags_ = tags;
setParameter("Tags", tags);
}
std::string SetAccessLogsDownloadAttributeRequest::getLogsDownloadAttributes()const
{
return logsDownloadAttributes_;
}
void SetAccessLogsDownloadAttributeRequest::setLogsDownloadAttributes(const std::string& logsDownloadAttributes)
{
logsDownloadAttributes_ = logsDownloadAttributes;
setParameter("LogsDownloadAttributes", logsDownloadAttributes);
}

45
slb/src/model/SetAccessLogsDownloadAttributeResult.cc Normal file
View File

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

16
slb/src/model/SetBackendServersRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/SetBackendServersRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::SetBackendServersRequest;
SetBackendServersRequest::SetBackendServersRequest() :
SlbRequest("SetBackendServers")
RpcServiceRequest("slb", "2014-05-15", "SetBackendServers")
{}
SetBackendServersRequest::~SetBackendServersRequest()
@@ -114,17 +113,6 @@ void SetBackendServersRequest::setBackendServers(const std::string& backendServe
setParameter("BackendServers", backendServers);
}
std::string SetBackendServersRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void SetBackendServersRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string SetBackendServersRequest::getTags()const
{
return tags_;

17
slb/src/model/SetBackendServersResult.cc
View File

@@ -43,12 +43,15 @@ void SetBackendServersResult::parse(const std::string &payload)
auto allBackendServers = value["BackendServers"]["BackendServer"];
for (auto value : allBackendServers)
{
BackendServer backendServerObject;
backendServerObject.serverId = value["ServerId"].asString();
backendServerObject.weight = value["Weight"].asString();
backendServers_.push_back(backendServerObject);
BackendServer backendServersObject;
if(!value["ServerId"].isNull())
backendServersObject.serverId = value["ServerId"].asString();
if(!value["Weight"].isNull())
backendServersObject.weight = value["Weight"].asString();
backendServers_.push_back(backendServersObject);
}
loadBalancerId_ = value["LoadBalancerId"].asString();
if(!value["LoadBalancerId"].isNull())
loadBalancerId_ = value["LoadBalancerId"].asString();
}
@@ -57,8 +60,8 @@ std::string SetBackendServersResult::getLoadBalancerId()const
return loadBalancerId_;
}
void SetBackendServersResult::setLoadBalancerId(const std::string& loadBalancerId)
std::vector<SetBackendServersResult::BackendServer> SetBackendServersResult::getBackendServers()const
{
loadBalancerId_ = loadBalancerId;
return backendServers_;
}

16
slb/src/model/SetCACertificateNameRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/SetCACertificateNameRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::SetCACertificateNameRequest;
SetCACertificateNameRequest::SetCACertificateNameRequest() :
SlbRequest("SetCACertificateName")
RpcServiceRequest("slb", "2014-05-15", "SetCACertificateName")
{}
SetCACertificateNameRequest::~SetCACertificateNameRequest()
@@ -114,14 +113,3 @@ void SetCACertificateNameRequest::setCACertificateId(const std::string& cACertif
setParameter("CACertificateId", cACertificateId);
}
std::string SetCACertificateNameRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void SetCACertificateNameRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

16
slb/src/model/SetListenerAccessControlStatusRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/SetListenerAccessControlStatusRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::SetListenerAccessControlStatusRequest;
SetListenerAccessControlStatusRequest::SetListenerAccessControlStatusRequest() :
SlbRequest("SetListenerAccessControlStatus")
RpcServiceRequest("slb", "2014-05-15", "SetListenerAccessControlStatus")
{}
SetListenerAccessControlStatusRequest::~SetListenerAccessControlStatusRequest()
@@ -125,17 +124,6 @@ void SetListenerAccessControlStatusRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string SetListenerAccessControlStatusRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void SetListenerAccessControlStatusRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string SetListenerAccessControlStatusRequest::getTags()const
{
return tags_;

16
slb/src/model/SetLoadBalancerAutoReleaseTimeRequest.cc
View File

@@ -16,11 +16,10 @@
#include <alibabacloud/slb/model/SetLoadBalancerAutoReleaseTimeRequest.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
using AlibabaCloud::Slb::Model::SetLoadBalancerAutoReleaseTimeRequest;
SetLoadBalancerAutoReleaseTimeRequest::SetLoadBalancerAutoReleaseTimeRequest() :
SlbRequest("SetLoadBalancerAutoReleaseTime")
RpcServiceRequest("slb", "2014-05-15", "SetLoadBalancerAutoReleaseTime")
{}
SetLoadBalancerAutoReleaseTimeRequest::~SetLoadBalancerAutoReleaseTimeRequest()
@@ -114,17 +113,6 @@ void SetLoadBalancerAutoReleaseTimeRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string SetLoadBalancerAutoReleaseTimeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void SetLoadBalancerAutoReleaseTimeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string SetLoadBalancerAutoReleaseTimeRequest::getTags()const
{
return tags_;

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