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

Support SLB latest OpenAPIs.

Browse Source
This commit is contained in:
sdk-team
2020-12-22 09:00:08 +00:00
parent 55c2e91e9f
commit 505b8e2062
71 changed files with 2163 additions and 1993 deletions
Download Patch File Download Diff File Expand all files Collapse all files

342
slb/src/SlbClient.cc
View File

@@ -519,42 +519,6 @@ SlbClient::CreateMasterSlaveServerGroupOutcomeCallable SlbClient::createMasterSl
return task->get_future();
}
SlbClient::CreateMasterSlaveVServerGroupOutcome SlbClient::createMasterSlaveVServerGroup(const CreateMasterSlaveVServerGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateMasterSlaveVServerGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateMasterSlaveVServerGroupOutcome(CreateMasterSlaveVServerGroupResult(outcome.result()));
else
return CreateMasterSlaveVServerGroupOutcome(outcome.error());
}
void SlbClient::createMasterSlaveVServerGroupAsync(const CreateMasterSlaveVServerGroupRequest& request, const CreateMasterSlaveVServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createMasterSlaveVServerGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::CreateMasterSlaveVServerGroupOutcomeCallable SlbClient::createMasterSlaveVServerGroupCallable(const CreateMasterSlaveVServerGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateMasterSlaveVServerGroupOutcome()>>(
[this, request]()
{
return this->createMasterSlaveVServerGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::CreateRulesOutcome SlbClient::createRules(const CreateRulesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -591,6 +555,42 @@ SlbClient::CreateRulesOutcomeCallable SlbClient::createRulesCallable(const Creat
return task->get_future();
}
SlbClient::CreateTLSCipherPolicyOutcome SlbClient::createTLSCipherPolicy(const CreateTLSCipherPolicyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateTLSCipherPolicyOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateTLSCipherPolicyOutcome(CreateTLSCipherPolicyResult(outcome.result()));
else
return CreateTLSCipherPolicyOutcome(outcome.error());
}
void SlbClient::createTLSCipherPolicyAsync(const CreateTLSCipherPolicyRequest& request, const CreateTLSCipherPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createTLSCipherPolicy(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::CreateTLSCipherPolicyOutcomeCallable SlbClient::createTLSCipherPolicyCallable(const CreateTLSCipherPolicyRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateTLSCipherPolicyOutcome()>>(
[this, request]()
{
return this->createTLSCipherPolicy(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::CreateVServerGroupOutcome SlbClient::createVServerGroup(const CreateVServerGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -843,42 +843,6 @@ SlbClient::DeleteMasterSlaveServerGroupOutcomeCallable SlbClient::deleteMasterSl
return task->get_future();
}
SlbClient::DeleteMasterSlaveVServerGroupOutcome SlbClient::deleteMasterSlaveVServerGroup(const DeleteMasterSlaveVServerGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteMasterSlaveVServerGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteMasterSlaveVServerGroupOutcome(DeleteMasterSlaveVServerGroupResult(outcome.result()));
else
return DeleteMasterSlaveVServerGroupOutcome(outcome.error());
}
void SlbClient::deleteMasterSlaveVServerGroupAsync(const DeleteMasterSlaveVServerGroupRequest& request, const DeleteMasterSlaveVServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteMasterSlaveVServerGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::DeleteMasterSlaveVServerGroupOutcomeCallable SlbClient::deleteMasterSlaveVServerGroupCallable(const DeleteMasterSlaveVServerGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteMasterSlaveVServerGroupOutcome()>>(
[this, request]()
{
return this->deleteMasterSlaveVServerGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::DeleteRulesOutcome SlbClient::deleteRules(const DeleteRulesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -951,6 +915,42 @@ SlbClient::DeleteServerCertificateOutcomeCallable SlbClient::deleteServerCertifi
return task->get_future();
}
SlbClient::DeleteTLSCipherPolicyOutcome SlbClient::deleteTLSCipherPolicy(const DeleteTLSCipherPolicyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteTLSCipherPolicyOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteTLSCipherPolicyOutcome(DeleteTLSCipherPolicyResult(outcome.result()));
else
return DeleteTLSCipherPolicyOutcome(outcome.error());
}
void SlbClient::deleteTLSCipherPolicyAsync(const DeleteTLSCipherPolicyRequest& request, const DeleteTLSCipherPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteTLSCipherPolicy(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::DeleteTLSCipherPolicyOutcomeCallable SlbClient::deleteTLSCipherPolicyCallable(const DeleteTLSCipherPolicyRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteTLSCipherPolicyOutcome()>>(
[this, request]()
{
return this->deleteTLSCipherPolicy(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::DeleteVServerGroupOutcome SlbClient::deleteVServerGroup(const DeleteVServerGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1383,42 +1383,6 @@ SlbClient::DescribeLoadBalancerHTTPSListenerAttributeOutcomeCallable SlbClient::
return task->get_future();
}
SlbClient::DescribeLoadBalancerListenersExOutcome SlbClient::describeLoadBalancerListenersEx(const DescribeLoadBalancerListenersExRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeLoadBalancerListenersExOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeLoadBalancerListenersExOutcome(DescribeLoadBalancerListenersExResult(outcome.result()));
else
return DescribeLoadBalancerListenersExOutcome(outcome.error());
}
void SlbClient::describeLoadBalancerListenersExAsync(const DescribeLoadBalancerListenersExRequest& request, const DescribeLoadBalancerListenersExAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeLoadBalancerListenersEx(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::DescribeLoadBalancerListenersExOutcomeCallable SlbClient::describeLoadBalancerListenersExCallable(const DescribeLoadBalancerListenersExRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeLoadBalancerListenersExOutcome()>>(
[this, request]()
{
return this->describeLoadBalancerListenersEx(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::DescribeLoadBalancerTCPListenerAttributeOutcome SlbClient::describeLoadBalancerTCPListenerAttribute(const DescribeLoadBalancerTCPListenerAttributeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1599,78 +1563,6 @@ SlbClient::DescribeMasterSlaveServerGroupsOutcomeCallable SlbClient::describeMas
return task->get_future();
}
SlbClient::DescribeMasterSlaveVServerGroupAttributeOutcome SlbClient::describeMasterSlaveVServerGroupAttribute(const DescribeMasterSlaveVServerGroupAttributeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeMasterSlaveVServerGroupAttributeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeMasterSlaveVServerGroupAttributeOutcome(DescribeMasterSlaveVServerGroupAttributeResult(outcome.result()));
else
return DescribeMasterSlaveVServerGroupAttributeOutcome(outcome.error());
}
void SlbClient::describeMasterSlaveVServerGroupAttributeAsync(const DescribeMasterSlaveVServerGroupAttributeRequest& request, const DescribeMasterSlaveVServerGroupAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeMasterSlaveVServerGroupAttribute(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::DescribeMasterSlaveVServerGroupAttributeOutcomeCallable SlbClient::describeMasterSlaveVServerGroupAttributeCallable(const DescribeMasterSlaveVServerGroupAttributeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeMasterSlaveVServerGroupAttributeOutcome()>>(
[this, request]()
{
return this->describeMasterSlaveVServerGroupAttribute(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::DescribeMasterSlaveVServerGroupsOutcome SlbClient::describeMasterSlaveVServerGroups(const DescribeMasterSlaveVServerGroupsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeMasterSlaveVServerGroupsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeMasterSlaveVServerGroupsOutcome(DescribeMasterSlaveVServerGroupsResult(outcome.result()));
else
return DescribeMasterSlaveVServerGroupsOutcome(outcome.error());
}
void SlbClient::describeMasterSlaveVServerGroupsAsync(const DescribeMasterSlaveVServerGroupsRequest& request, const DescribeMasterSlaveVServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeMasterSlaveVServerGroups(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::DescribeMasterSlaveVServerGroupsOutcomeCallable SlbClient::describeMasterSlaveVServerGroupsCallable(const DescribeMasterSlaveVServerGroupsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeMasterSlaveVServerGroupsOutcome()>>(
[this, request]()
{
return this->describeMasterSlaveVServerGroups(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::DescribeRegionsOutcome SlbClient::describeRegions(const DescribeRegionsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1959,6 +1851,42 @@ SlbClient::DescribeZonesOutcomeCallable SlbClient::describeZonesCallable(const D
return task->get_future();
}
SlbClient::ListTLSCipherPoliciesOutcome SlbClient::listTLSCipherPolicies(const ListTLSCipherPoliciesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListTLSCipherPoliciesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListTLSCipherPoliciesOutcome(ListTLSCipherPoliciesResult(outcome.result()));
else
return ListTLSCipherPoliciesOutcome(outcome.error());
}
void SlbClient::listTLSCipherPoliciesAsync(const ListTLSCipherPoliciesRequest& request, const ListTLSCipherPoliciesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listTLSCipherPolicies(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::ListTLSCipherPoliciesOutcomeCallable SlbClient::listTLSCipherPoliciesCallable(const ListTLSCipherPoliciesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListTLSCipherPoliciesOutcome()>>(
[this, request]()
{
return this->listTLSCipherPolicies(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::ListTagResourcesOutcome SlbClient::listTagResources(const ListTagResourcesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2607,36 +2535,36 @@ SlbClient::SetLoadBalancerHTTPSListenerAttributeOutcomeCallable SlbClient::setLo
return task->get_future();
}
SlbClient::SetLoadBalancerListenerAttributeExOutcome SlbClient::setLoadBalancerListenerAttributeEx(const SetLoadBalancerListenerAttributeExRequest &request) const
SlbClient::SetLoadBalancerModificationProtectionOutcome SlbClient::setLoadBalancerModificationProtection(const SetLoadBalancerModificationProtectionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SetLoadBalancerListenerAttributeExOutcome(endpointOutcome.error());
return SetLoadBalancerModificationProtectionOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SetLoadBalancerListenerAttributeExOutcome(SetLoadBalancerListenerAttributeExResult(outcome.result()));
return SetLoadBalancerModificationProtectionOutcome(SetLoadBalancerModificationProtectionResult(outcome.result()));
else
return SetLoadBalancerListenerAttributeExOutcome(outcome.error());
return SetLoadBalancerModificationProtectionOutcome(outcome.error());
}
void SlbClient::setLoadBalancerListenerAttributeExAsync(const SetLoadBalancerListenerAttributeExRequest& request, const SetLoadBalancerListenerAttributeExAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void SlbClient::setLoadBalancerModificationProtectionAsync(const SetLoadBalancerModificationProtectionRequest& request, const SetLoadBalancerModificationProtectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, setLoadBalancerListenerAttributeEx(request), context);
handler(this, request, setLoadBalancerModificationProtection(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::SetLoadBalancerListenerAttributeExOutcomeCallable SlbClient::setLoadBalancerListenerAttributeExCallable(const SetLoadBalancerListenerAttributeExRequest &request) const
SlbClient::SetLoadBalancerModificationProtectionOutcomeCallable SlbClient::setLoadBalancerModificationProtectionCallable(const SetLoadBalancerModificationProtectionRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SetLoadBalancerListenerAttributeExOutcome()>>(
auto task = std::make_shared<std::packaged_task<SetLoadBalancerModificationProtectionOutcome()>>(
[this, request]()
{
return this->setLoadBalancerListenerAttributeEx(request);
return this->setLoadBalancerModificationProtection(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -2859,6 +2787,42 @@ SlbClient::SetServerCertificateNameOutcomeCallable SlbClient::setServerCertifica
return task->get_future();
}
SlbClient::SetTLSCipherPolicyAttributeOutcome SlbClient::setTLSCipherPolicyAttribute(const SetTLSCipherPolicyAttributeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SetTLSCipherPolicyAttributeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SetTLSCipherPolicyAttributeOutcome(SetTLSCipherPolicyAttributeResult(outcome.result()));
else
return SetTLSCipherPolicyAttributeOutcome(outcome.error());
}
void SlbClient::setTLSCipherPolicyAttributeAsync(const SetTLSCipherPolicyAttributeRequest& request, const SetTLSCipherPolicyAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, setTLSCipherPolicyAttribute(request), context);
};
asyncExecute(new Runnable(fn));
}
SlbClient::SetTLSCipherPolicyAttributeOutcomeCallable SlbClient::setTLSCipherPolicyAttributeCallable(const SetTLSCipherPolicyAttributeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SetTLSCipherPolicyAttributeOutcome()>>(
[this, request]()
{
return this->setTLSCipherPolicyAttribute(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
SlbClient::SetVServerGroupAttributeOutcome SlbClient::setVServerGroupAttribute(const SetVServerGroupAttributeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

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

@@ -49,6 +49,23 @@ void CreateDomainExtensionRequest::setResourceOwnerId(long resourceOwnerId)
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::vector<CreateDomainExtensionRequest::ServerCertificate> CreateDomainExtensionRequest::getServerCertificate()const
{
return serverCertificate_;
}
void CreateDomainExtensionRequest::setServerCertificate(const std::vector<ServerCertificate>& serverCertificate)
{
serverCertificate_ = serverCertificate;
for(int dep1 = 0; dep1!= serverCertificate.size(); dep1++) {
auto serverCertificateObj = serverCertificate.at(dep1);
std::string serverCertificateObjStr = "ServerCertificate." + std::to_string(dep1 + 1);
setParameter(serverCertificateObjStr + ".BindingType", serverCertificateObj.bindingType);
setParameter(serverCertificateObjStr + ".CertificateId", serverCertificateObj.certificateId);
setParameter(serverCertificateObjStr + ".StandardType", serverCertificateObj.standardType);
}
}
std::string CreateDomainExtensionRequest::getRegionId()const
{
return regionId_;
@@ -93,6 +110,19 @@ void CreateDomainExtensionRequest::setOwnerAccount(const std::string& ownerAccou
setParameter("OwnerAccount", ownerAccount);
}
std::vector<std::string> CreateDomainExtensionRequest::getCertificateId()const
{
return certificateId_;
}
void CreateDomainExtensionRequest::setCertificateId(const std::vector<std::string>& certificateId)
{
certificateId_ = certificateId;
for(int dep1 = 0; dep1!= certificateId.size(); dep1++) {
setParameter("CertificateId."+ std::to_string(dep1), certificateId.at(dep1));
}
}
long CreateDomainExtensionRequest::getOwnerId()const
{
return ownerId_;

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

@@ -38,6 +38,23 @@ void CreateLoadBalancerHTTPSListenerRequest::setResourceOwnerId(long resourceOwn
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::vector<CreateLoadBalancerHTTPSListenerRequest::ServerCertificate> CreateLoadBalancerHTTPSListenerRequest::getServerCertificate()const
{
return serverCertificate_;
}
void CreateLoadBalancerHTTPSListenerRequest::setServerCertificate(const std::vector<ServerCertificate>& serverCertificate)
{
serverCertificate_ = serverCertificate;
for(int dep1 = 0; dep1!= serverCertificate.size(); dep1++) {
auto serverCertificateObj = serverCertificate.at(dep1);
std::string serverCertificateObjStr = "ServerCertificate." + std::to_string(dep1 + 1);
setParameter(serverCertificateObjStr + ".BindingType", serverCertificateObj.bindingType);
setParameter(serverCertificateObjStr + ".CertificateId", serverCertificateObj.certificateId);
setParameter(serverCertificateObjStr + ".StandardType", serverCertificateObj.standardType);
}
}
int CreateLoadBalancerHTTPSListenerRequest::getHealthCheckTimeout()const
{
return healthCheckTimeout_;

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

@@ -27,17 +27,6 @@ CreateLoadBalancerRequest::CreateLoadBalancerRequest() :
CreateLoadBalancerRequest::~CreateLoadBalancerRequest()
{}
std::string CreateLoadBalancerRequest::getAccess_key_id()const
{
return access_key_id_;
}
void CreateLoadBalancerRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
long CreateLoadBalancerRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
@@ -49,39 +38,6 @@ void CreateLoadBalancerRequest::setResourceOwnerId(long resourceOwnerId)
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
bool CreateLoadBalancerRequest::getSupportPrivateLink()const
{
return supportPrivateLink_;
}
void CreateLoadBalancerRequest::setSupportPrivateLink(bool supportPrivateLink)
{
supportPrivateLink_ = supportPrivateLink;
setParameter("SupportPrivateLink", supportPrivateLink ? "true" : "false");
}
std::string CreateLoadBalancerRequest::getClientToken()const
{
return clientToken_;
}
void CreateLoadBalancerRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CreateLoadBalancerRequest::getCloudType()const
{
return cloudType_;
}
void CreateLoadBalancerRequest::setCloudType(const std::string& cloudType)
{
cloudType_ = cloudType;
setParameter("CloudType", cloudType);
}
std::string CreateLoadBalancerRequest::getAddressIPVersion()const
{
return addressIPVersion_;
@@ -104,17 +60,6 @@ void CreateLoadBalancerRequest::setMasterZoneId(const std::string& masterZoneId)
setParameter("MasterZoneId", masterZoneId);
}
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_;
@@ -137,28 +82,6 @@ void CreateLoadBalancerRequest::setLoadBalancerName(const std::string& loadBalan
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_;
@@ -170,17 +93,6 @@ void CreateLoadBalancerRequest::setSlaveZoneId(const std::string& slaveZoneId)
setParameter("SlaveZoneId", slaveZoneId);
}
std::string CreateLoadBalancerRequest::getDeleteProtection()const
{
return deleteProtection_;
}
void CreateLoadBalancerRequest::setDeleteProtection(const std::string& deleteProtection)
{
deleteProtection_ = deleteProtection;
setParameter("DeleteProtection", deleteProtection);
}
std::string CreateLoadBalancerRequest::getLoadBalancerSpec()const
{
return loadBalancerSpec_;
@@ -192,61 +104,6 @@ void CreateLoadBalancerRequest::setLoadBalancerSpec(const std::string& loadBalan
setParameter("LoadBalancerSpec", loadBalancerSpec);
}
bool CreateLoadBalancerRequest::getAutoPay()const
{
return autoPay_;
}
void CreateLoadBalancerRequest::setAutoPay(bool autoPay)
{
autoPay_ = autoPay;
setParameter("AutoPay", autoPay ? "true" : "false");
}
std::string CreateLoadBalancerRequest::getAddress()const
{
return address_;
}
void CreateLoadBalancerRequest::setAddress(const std::string& address)
{
address_ = address;
setParameter("Address", address);
}
std::string CreateLoadBalancerRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateLoadBalancerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
int CreateLoadBalancerRequest::getBandwidth()const
{
return bandwidth_;
}
void CreateLoadBalancerRequest::setBandwidth(int bandwidth)
{
bandwidth_ = bandwidth;
setParameter("Bandwidth", std::to_string(bandwidth));
}
std::string CreateLoadBalancerRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateLoadBalancerRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CreateLoadBalancerRequest::getOwnerId()const
{
return ownerId_;
@@ -302,6 +159,182 @@ void CreateLoadBalancerRequest::setInternetChargeType(const std::string& interne
setParameter("InternetChargeType", internetChargeType);
}
std::string CreateLoadBalancerRequest::getPricingCycle()const
{
return pricingCycle_;
}
void CreateLoadBalancerRequest::setPricingCycle(const std::string& pricingCycle)
{
pricingCycle_ = pricingCycle;
setParameter("PricingCycle", pricingCycle);
}
std::string CreateLoadBalancerRequest::getAccess_key_id()const
{
return access_key_id_;
}
void CreateLoadBalancerRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
std::string CreateLoadBalancerRequest::getModificationProtectionReason()const
{
return modificationProtectionReason_;
}
void CreateLoadBalancerRequest::setModificationProtectionReason(const std::string& modificationProtectionReason)
{
modificationProtectionReason_ = modificationProtectionReason;
setParameter("ModificationProtectionReason", modificationProtectionReason);
}
bool CreateLoadBalancerRequest::getSupportPrivateLink()const
{
return supportPrivateLink_;
}
void CreateLoadBalancerRequest::setSupportPrivateLink(bool supportPrivateLink)
{
supportPrivateLink_ = supportPrivateLink;
setParameter("SupportPrivateLink", supportPrivateLink ? "true" : "false");
}
std::string CreateLoadBalancerRequest::getClientToken()const
{
return clientToken_;
}
void CreateLoadBalancerRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CreateLoadBalancerRequest::getCloudType()const
{
return cloudType_;
}
void CreateLoadBalancerRequest::setCloudType(const std::string& cloudType)
{
cloudType_ = cloudType;
setParameter("CloudType", cloudType);
}
int CreateLoadBalancerRequest::getDuration()const
{
return duration_;
}
void CreateLoadBalancerRequest::setDuration(int duration)
{
duration_ = duration;
setParameter("Duration", std::to_string(duration));
}
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::getDeleteProtection()const
{
return deleteProtection_;
}
void CreateLoadBalancerRequest::setDeleteProtection(const std::string& deleteProtection)
{
deleteProtection_ = deleteProtection;
setParameter("DeleteProtection", deleteProtection);
}
bool CreateLoadBalancerRequest::getAutoPay()const
{
return autoPay_;
}
void CreateLoadBalancerRequest::setAutoPay(bool autoPay)
{
autoPay_ = autoPay;
setParameter("AutoPay", autoPay ? "true" : "false");
}
std::string CreateLoadBalancerRequest::getAddress()const
{
return address_;
}
void CreateLoadBalancerRequest::setAddress(const std::string& address)
{
address_ = address;
setParameter("Address", address);
}
std::string CreateLoadBalancerRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateLoadBalancerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
int CreateLoadBalancerRequest::getBandwidth()const
{
return bandwidth_;
}
void CreateLoadBalancerRequest::setBandwidth(int bandwidth)
{
bandwidth_ = bandwidth;
setParameter("Bandwidth", std::to_string(bandwidth));
}
std::string CreateLoadBalancerRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateLoadBalancerRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CreateLoadBalancerRequest::getModificationProtectionStatus()const
{
return modificationProtectionStatus_;
}
void CreateLoadBalancerRequest::setModificationProtectionStatus(const std::string& modificationProtectionStatus)
{
modificationProtectionStatus_ = modificationProtectionStatus;
setParameter("ModificationProtectionStatus", modificationProtectionStatus);
}
std::string CreateLoadBalancerRequest::getVpcId()const
{
return vpcId_;
@@ -324,17 +357,6 @@ void CreateLoadBalancerRequest::setPayType(const std::string& payType)
setParameter("PayType", payType);
}
std::string CreateLoadBalancerRequest::getPricingCycle()const
{
return pricingCycle_;
}
void CreateLoadBalancerRequest::setPricingCycle(const std::string& pricingCycle)
{
pricingCycle_ = pricingCycle;
setParameter("PricingCycle", pricingCycle);
}
int CreateLoadBalancerRequest::getRatio()const
{
return ratio_;

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

@@ -1,148 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/slb/model/CreateMasterSlaveVServerGroupRequest.h>
using AlibabaCloud::Slb::Model::CreateMasterSlaveVServerGroupRequest;
CreateMasterSlaveVServerGroupRequest::CreateMasterSlaveVServerGroupRequest() :
RpcServiceRequest("slb", "2014-05-15", "CreateMasterSlaveVServerGroup")
{}
CreateMasterSlaveVServerGroupRequest::~CreateMasterSlaveVServerGroupRequest()
{}
std::string CreateMasterSlaveVServerGroupRequest::getAccess_key_id()const
{
return access_key_id_;
}
void CreateMasterSlaveVServerGroupRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setCoreParameter("Access_key_id", access_key_id);
}
long CreateMasterSlaveVServerGroupRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateMasterSlaveVServerGroupRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateMasterSlaveVServerGroupRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateMasterSlaveVServerGroupRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
std::string CreateMasterSlaveVServerGroupRequest::getMasterSlaveBackendServers()const
{
return masterSlaveBackendServers_;
}
void CreateMasterSlaveVServerGroupRequest::setMasterSlaveBackendServers(const std::string& masterSlaveBackendServers)
{
masterSlaveBackendServers_ = masterSlaveBackendServers;
setCoreParameter("MasterSlaveBackendServers", masterSlaveBackendServers);
}
std::string CreateMasterSlaveVServerGroupRequest::getRegionId()const
{
return regionId_;
}
void CreateMasterSlaveVServerGroupRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string CreateMasterSlaveVServerGroupRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateMasterSlaveVServerGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateMasterSlaveVServerGroupRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateMasterSlaveVServerGroupRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setCoreParameter("OwnerAccount", ownerAccount);
}
std::string CreateMasterSlaveVServerGroupRequest::getMasterSlaveVServerGroupName()const
{
return masterSlaveVServerGroupName_;
}
void CreateMasterSlaveVServerGroupRequest::setMasterSlaveVServerGroupName(const std::string& masterSlaveVServerGroupName)
{
masterSlaveVServerGroupName_ = masterSlaveVServerGroupName;
setCoreParameter("MasterSlaveVServerGroupName", masterSlaveVServerGroupName);
}
long CreateMasterSlaveVServerGroupRequest::getOwnerId()const
{
return ownerId_;
}
void CreateMasterSlaveVServerGroupRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateMasterSlaveVServerGroupRequest::getTags()const
{
return tags_;
}
void CreateMasterSlaveVServerGroupRequest::setTags(const std::string& tags)
{
tags_ = tags;
setCoreParameter("Tags", tags);
}
std::string CreateMasterSlaveVServerGroupRequest::getLoadBalancerId()const
{
return loadBalancerId_;
}
void CreateMasterSlaveVServerGroupRequest::setLoadBalancerId(const std::string& loadBalancerId)
{
loadBalancerId_ = loadBalancerId;
setCoreParameter("LoadBalancerId", loadBalancerId);
}

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

@@ -1,80 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/slb/model/CreateMasterSlaveVServerGroupResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
CreateMasterSlaveVServerGroupResult::CreateMasterSlaveVServerGroupResult() :
ServiceResult()
{}
CreateMasterSlaveVServerGroupResult::CreateMasterSlaveVServerGroupResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateMasterSlaveVServerGroupResult::~CreateMasterSlaveVServerGroupResult()
{}
void CreateMasterSlaveVServerGroupResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allMasterSlaveBackendServersNode = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
for (auto valueMasterSlaveBackendServersMasterSlaveBackendServer : allMasterSlaveBackendServersNode)
{
MasterSlaveBackendServer masterSlaveBackendServersObject;
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerId"].isNull())
masterSlaveBackendServersObject.serverId = valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerId"].asString();
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Port"].isNull())
masterSlaveBackendServersObject.port = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["Port"].asString());
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Weight"].isNull())
masterSlaveBackendServersObject.weight = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["Weight"].asString());
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["IsBackup"].isNull())
masterSlaveBackendServersObject.isBackup = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["IsBackup"].asString());
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Type"].isNull())
masterSlaveBackendServersObject.type = valueMasterSlaveBackendServersMasterSlaveBackendServer["Type"].asString();
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerIp"].isNull())
masterSlaveBackendServersObject.serverIp = valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerIp"].asString();
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["EniHost"].isNull())
masterSlaveBackendServersObject.eniHost = valueMasterSlaveBackendServersMasterSlaveBackendServer["EniHost"].asString();
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["VpcId"].isNull())
masterSlaveBackendServersObject.vpcId = valueMasterSlaveBackendServersMasterSlaveBackendServer["VpcId"].asString();
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Description"].isNull())
masterSlaveBackendServersObject.description = valueMasterSlaveBackendServersMasterSlaveBackendServer["Description"].asString();
masterSlaveBackendServers_.push_back(masterSlaveBackendServersObject);
}
if(!value["MasterSlaveVServerGroupId"].isNull())
masterSlaveVServerGroupId_ = value["MasterSlaveVServerGroupId"].asString();
}
std::string CreateMasterSlaveVServerGroupResult::getMasterSlaveVServerGroupId()const
{
return masterSlaveVServerGroupId_;
}
std::vector<CreateMasterSlaveVServerGroupResult::MasterSlaveBackendServer> CreateMasterSlaveVServerGroupResult::getMasterSlaveBackendServers()const
{
return masterSlaveBackendServers_;
}

143
slb/src/model/CreateTLSCipherPolicyRequest.cc Normal file
View File

@@ -0,0 +1,143 @@
/*
* 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/CreateTLSCipherPolicyRequest.h>
using AlibabaCloud::Slb::Model::CreateTLSCipherPolicyRequest;
CreateTLSCipherPolicyRequest::CreateTLSCipherPolicyRequest() :
RpcServiceRequest("slb", "2014-05-15", "CreateTLSCipherPolicy")
{
setMethod(HttpRequest::Method::Post);
}
CreateTLSCipherPolicyRequest::~CreateTLSCipherPolicyRequest()
{}
std::string CreateTLSCipherPolicyRequest::getAccess_key_id()const
{
return access_key_id_;
}
void CreateTLSCipherPolicyRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
long CreateTLSCipherPolicyRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateTLSCipherPolicyRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateTLSCipherPolicyRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateTLSCipherPolicyRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateTLSCipherPolicyRequest::getRegionId()const
{
return regionId_;
}
void CreateTLSCipherPolicyRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::vector<std::string> CreateTLSCipherPolicyRequest::getCiphers()const
{
return ciphers_;
}
void CreateTLSCipherPolicyRequest::setCiphers(const std::vector<std::string>& ciphers)
{
ciphers_ = ciphers;
for(int dep1 = 0; dep1!= ciphers.size(); dep1++) {
setParameter("Ciphers."+ std::to_string(dep1), ciphers.at(dep1));
}
}
std::vector<std::string> CreateTLSCipherPolicyRequest::getTLSVersions()const
{
return tLSVersions_;
}
void CreateTLSCipherPolicyRequest::setTLSVersions(const std::vector<std::string>& tLSVersions)
{
tLSVersions_ = tLSVersions;
for(int dep1 = 0; dep1!= tLSVersions.size(); dep1++) {
setParameter("TLSVersions."+ std::to_string(dep1), tLSVersions.at(dep1));
}
}
std::string CreateTLSCipherPolicyRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateTLSCipherPolicyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateTLSCipherPolicyRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateTLSCipherPolicyRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CreateTLSCipherPolicyRequest::getOwnerId()const
{
return ownerId_;
}
void CreateTLSCipherPolicyRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateTLSCipherPolicyRequest::getName()const
{
return name_;
}
void CreateTLSCipherPolicyRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}

51
slb/src/model/CreateTLSCipherPolicyResult.cc Normal file
View File

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

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

@@ -1,126 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/slb/model/DeleteMasterSlaveVServerGroupRequest.h>
using AlibabaCloud::Slb::Model::DeleteMasterSlaveVServerGroupRequest;
DeleteMasterSlaveVServerGroupRequest::DeleteMasterSlaveVServerGroupRequest() :
RpcServiceRequest("slb", "2014-05-15", "DeleteMasterSlaveVServerGroup")
{}
DeleteMasterSlaveVServerGroupRequest::~DeleteMasterSlaveVServerGroupRequest()
{}
std::string DeleteMasterSlaveVServerGroupRequest::getAccess_key_id()const
{
return access_key_id_;
}
void DeleteMasterSlaveVServerGroupRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setCoreParameter("Access_key_id", access_key_id);
}
long DeleteMasterSlaveVServerGroupRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteMasterSlaveVServerGroupRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteMasterSlaveVServerGroupRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteMasterSlaveVServerGroupRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
std::string DeleteMasterSlaveVServerGroupRequest::getRegionId()const
{
return regionId_;
}
void DeleteMasterSlaveVServerGroupRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DeleteMasterSlaveVServerGroupRequest::getMasterSlaveVServerGroupId()const
{
return masterSlaveVServerGroupId_;
}
void DeleteMasterSlaveVServerGroupRequest::setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId)
{
masterSlaveVServerGroupId_ = masterSlaveVServerGroupId;
setCoreParameter("MasterSlaveVServerGroupId", masterSlaveVServerGroupId);
}
std::string DeleteMasterSlaveVServerGroupRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteMasterSlaveVServerGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteMasterSlaveVServerGroupRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteMasterSlaveVServerGroupRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setCoreParameter("OwnerAccount", ownerAccount);
}
long DeleteMasterSlaveVServerGroupRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteMasterSlaveVServerGroupRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteMasterSlaveVServerGroupRequest::getTags()const
{
return tags_;
}
void DeleteMasterSlaveVServerGroupRequest::setTags(const std::string& tags)
{
tags_ = tags;
setCoreParameter("Tags", tags);
}

117
slb/src/model/DeleteTLSCipherPolicyRequest.cc Normal file
View File

@@ -0,0 +1,117 @@
/*
* 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/DeleteTLSCipherPolicyRequest.h>
using AlibabaCloud::Slb::Model::DeleteTLSCipherPolicyRequest;
DeleteTLSCipherPolicyRequest::DeleteTLSCipherPolicyRequest() :
RpcServiceRequest("slb", "2014-05-15", "DeleteTLSCipherPolicy")
{
setMethod(HttpRequest::Method::Post);
}
DeleteTLSCipherPolicyRequest::~DeleteTLSCipherPolicyRequest()
{}
std::string DeleteTLSCipherPolicyRequest::getAccess_key_id()const
{
return access_key_id_;
}
void DeleteTLSCipherPolicyRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
long DeleteTLSCipherPolicyRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteTLSCipherPolicyRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteTLSCipherPolicyRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteTLSCipherPolicyRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DeleteTLSCipherPolicyRequest::getTLSCipherPolicyId()const
{
return tLSCipherPolicyId_;
}
void DeleteTLSCipherPolicyRequest::setTLSCipherPolicyId(const std::string& tLSCipherPolicyId)
{
tLSCipherPolicyId_ = tLSCipherPolicyId;
setParameter("TLSCipherPolicyId", tLSCipherPolicyId);
}
std::string DeleteTLSCipherPolicyRequest::getRegionId()const
{
return regionId_;
}
void DeleteTLSCipherPolicyRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DeleteTLSCipherPolicyRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteTLSCipherPolicyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteTLSCipherPolicyRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteTLSCipherPolicyRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DeleteTLSCipherPolicyRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteTLSCipherPolicyRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

10
slb/src/model/DeleteMasterSlaveVServerGroupResult.cc → slb/src/model/DeleteTLSCipherPolicyResult.cc
View File

@@ -14,26 +14,26 @@
* limitations under the License.
*/
#include <alibabacloud/slb/model/DeleteMasterSlaveVServerGroupResult.h>
#include <alibabacloud/slb/model/DeleteTLSCipherPolicyResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
DeleteMasterSlaveVServerGroupResult::DeleteMasterSlaveVServerGroupResult() :
DeleteTLSCipherPolicyResult::DeleteTLSCipherPolicyResult() :
ServiceResult()
{}
DeleteMasterSlaveVServerGroupResult::DeleteMasterSlaveVServerGroupResult(const std::string &payload) :
DeleteTLSCipherPolicyResult::DeleteTLSCipherPolicyResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteMasterSlaveVServerGroupResult::~DeleteMasterSlaveVServerGroupResult()
DeleteTLSCipherPolicyResult::~DeleteTLSCipherPolicyResult()
{}
void DeleteMasterSlaveVServerGroupResult::parse(const std::string &payload)
void DeleteTLSCipherPolicyResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;

12
slb/src/model/DescribeAccessControlListsResult.cc
View File

@@ -51,14 +51,14 @@ void DescribeAccessControlListsResult::parse(const std::string &payload)
aclsObject.addressIPVersion = valueAclsAcl["AddressIPVersion"].asString();
if(!valueAclsAcl["ResourceGroupId"].isNull())
aclsObject.resourceGroupId = valueAclsAcl["ResourceGroupId"].asString();
auto allTagsNode = allAclsNode["Tags"]["Tag"];
for (auto allAclsNodeTagsTag : allTagsNode)
auto allTagsNode = valueAclsAcl["Tags"]["Tag"];
for (auto valueAclsAclTagsTag : allTagsNode)
{
Acl::Tag tagsObject;
if(!allAclsNodeTagsTag["TagKey"].isNull())
tagsObject.tagKey = allAclsNodeTagsTag["TagKey"].asString();
if(!allAclsNodeTagsTag["TagValue"].isNull())
tagsObject.tagValue = allAclsNodeTagsTag["TagValue"].asString();
if(!valueAclsAclTagsTag["TagKey"].isNull())
tagsObject.tagKey = valueAclsAclTagsTag["TagKey"].asString();
if(!valueAclsAclTagsTag["TagValue"].isNull())
tagsObject.tagValue = valueAclsAclTagsTag["TagValue"].asString();
aclsObject.tags.push_back(tagsObject);
}
acls_.push_back(aclsObject);

12
slb/src/model/DescribeAvailableResourceResult.cc
View File

@@ -47,14 +47,14 @@ void DescribeAvailableResourceResult::parse(const std::string &payload)
availableResourcesObject.masterZoneId = valueAvailableResourcesAvailableResource["MasterZoneId"].asString();
if(!valueAvailableResourcesAvailableResource["SlaveZoneId"].isNull())
availableResourcesObject.slaveZoneId = valueAvailableResourcesAvailableResource["SlaveZoneId"].asString();
auto allSupportResourcesNode = allAvailableResourcesNode["SupportResources"]["SupportResource"];
for (auto allAvailableResourcesNodeSupportResourcesSupportResource : allSupportResourcesNode)
auto allSupportResourcesNode = valueAvailableResourcesAvailableResource["SupportResources"]["SupportResource"];
for (auto valueAvailableResourcesAvailableResourceSupportResourcesSupportResource : allSupportResourcesNode)
{
AvailableResource::SupportResource supportResourcesObject;
if(!allAvailableResourcesNodeSupportResourcesSupportResource["AddressType"].isNull())
supportResourcesObject.addressType = allAvailableResourcesNodeSupportResourcesSupportResource["AddressType"].asString();
if(!allAvailableResourcesNodeSupportResourcesSupportResource["AddressIPVersion"].isNull())
supportResourcesObject.addressIPVersion = allAvailableResourcesNodeSupportResourcesSupportResource["AddressIPVersion"].asString();
if(!valueAvailableResourcesAvailableResourceSupportResourcesSupportResource["AddressType"].isNull())
supportResourcesObject.addressType = valueAvailableResourcesAvailableResourceSupportResourcesSupportResource["AddressType"].asString();
if(!valueAvailableResourcesAvailableResourceSupportResourcesSupportResource["AddressIPVersion"].isNull())
supportResourcesObject.addressIPVersion = valueAvailableResourcesAvailableResourceSupportResourcesSupportResource["AddressIPVersion"].asString();
availableResourcesObject.supportResources.push_back(supportResourcesObject);
}
availableResources_.push_back(availableResourcesObject);

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

@@ -63,14 +63,20 @@ void DescribeCACertificatesResult::parse(const std::string &payload)
cACertificatesObject.expireTimeStamp = std::stol(valueCACertificatesCACertificate["ExpireTimeStamp"].asString());
if(!valueCACertificatesCACertificate["CommonName"].isNull())
cACertificatesObject.commonName = valueCACertificatesCACertificate["CommonName"].asString();
auto allTagsNode = allCACertificatesNode["Tags"]["Tag"];
for (auto allCACertificatesNodeTagsTag : allTagsNode)
if(!valueCACertificatesCACertificate["EncryptionAlgorithm"].isNull())
cACertificatesObject.encryptionAlgorithm = valueCACertificatesCACertificate["EncryptionAlgorithm"].asString();
if(!valueCACertificatesCACertificate["EncryptionKeyLength"].isNull())
cACertificatesObject.encryptionKeyLength = std::stoi(valueCACertificatesCACertificate["EncryptionKeyLength"].asString());
if(!valueCACertificatesCACertificate["StandardType"].isNull())
cACertificatesObject.standardType = valueCACertificatesCACertificate["StandardType"].asString();
auto allTagsNode = valueCACertificatesCACertificate["Tags"]["Tag"];
for (auto valueCACertificatesCACertificateTagsTag : allTagsNode)
{
CACertificate::Tag tagsObject;
if(!allCACertificatesNodeTagsTag["TagKey"].isNull())
tagsObject.tagKey = allCACertificatesNodeTagsTag["TagKey"].asString();
if(!allCACertificatesNodeTagsTag["TagValue"].isNull())
tagsObject.tagValue = allCACertificatesNodeTagsTag["TagValue"].asString();
if(!valueCACertificatesCACertificateTagsTag["TagKey"].isNull())
tagsObject.tagKey = valueCACertificatesCACertificateTagsTag["TagKey"].asString();
if(!valueCACertificatesCACertificateTagsTag["TagValue"].isNull())
tagsObject.tagValue = valueCACertificatesCACertificateTagsTag["TagValue"].asString();
cACertificatesObject.tags.push_back(tagsObject);
}
cACertificates_.push_back(cACertificatesObject);

34
slb/src/model/DescribeDomainExtensionAttributeResult.cc
View File

@@ -39,6 +39,30 @@ void DescribeDomainExtensionAttributeResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allCertificatesNode = value["Certificates"]["Certificate"];
for (auto valueCertificatesCertificate : allCertificatesNode)
{
Certificate certificatesObject;
if(!valueCertificatesCertificate["CertificateId"].isNull())
certificatesObject.certificateId = valueCertificatesCertificate["CertificateId"].asString();
if(!valueCertificatesCertificate["EncryptionAlgorithm"].isNull())
certificatesObject.encryptionAlgorithm = valueCertificatesCertificate["EncryptionAlgorithm"].asString();
certificates_.push_back(certificatesObject);
}
auto allServerCertificatesNode = value["ServerCertificates"]["ServerCertificate"];
for (auto valueServerCertificatesServerCertificate : allServerCertificatesNode)
{
ServerCertificate serverCertificatesObject;
if(!valueServerCertificatesServerCertificate["CertificateId"].isNull())
serverCertificatesObject.certificateId = valueServerCertificatesServerCertificate["CertificateId"].asString();
if(!valueServerCertificatesServerCertificate["EncryptionAlgorithm"].isNull())
serverCertificatesObject.encryptionAlgorithm = valueServerCertificatesServerCertificate["EncryptionAlgorithm"].asString();
if(!valueServerCertificatesServerCertificate["StandardType"].isNull())
serverCertificatesObject.standardType = valueServerCertificatesServerCertificate["StandardType"].asString();
if(!valueServerCertificatesServerCertificate["BindingType"].isNull())
serverCertificatesObject.bindingType = valueServerCertificatesServerCertificate["BindingType"].asString();
serverCertificates_.push_back(serverCertificatesObject);
}
if(!value["DomainExtensionId"].isNull())
domainExtensionId_ = value["DomainExtensionId"].asString();
if(!value["Domain"].isNull())
@@ -62,6 +86,16 @@ int DescribeDomainExtensionAttributeResult::getListenerPort()const
return listenerPort_;
}
std::vector<DescribeDomainExtensionAttributeResult::Certificate> DescribeDomainExtensionAttributeResult::getCertificates()const
{
return certificates_;
}
std::vector<DescribeDomainExtensionAttributeResult::ServerCertificate> DescribeDomainExtensionAttributeResult::getServerCertificates()const
{
return serverCertificates_;
}
std::string DescribeDomainExtensionAttributeResult::getServerCertificateId()const
{
return serverCertificateId_;

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

@@ -49,6 +49,30 @@ void DescribeDomainExtensionsResult::parse(const std::string &payload)
domainExtensionsObject.domain = valueDomainExtensionsDomainExtension["Domain"].asString();
if(!valueDomainExtensionsDomainExtension["ServerCertificateId"].isNull())
domainExtensionsObject.serverCertificateId = valueDomainExtensionsDomainExtension["ServerCertificateId"].asString();
auto allCertificatesNode = valueDomainExtensionsDomainExtension["Certificates"]["Certificate"];
for (auto valueDomainExtensionsDomainExtensionCertificatesCertificate : allCertificatesNode)
{
DomainExtension::Certificate certificatesObject;
if(!valueDomainExtensionsDomainExtensionCertificatesCertificate["CertificateId"].isNull())
certificatesObject.certificateId = valueDomainExtensionsDomainExtensionCertificatesCertificate["CertificateId"].asString();
if(!valueDomainExtensionsDomainExtensionCertificatesCertificate["EncryptionAlgorithm"].isNull())
certificatesObject.encryptionAlgorithm = valueDomainExtensionsDomainExtensionCertificatesCertificate["EncryptionAlgorithm"].asString();
domainExtensionsObject.certificates.push_back(certificatesObject);
}
auto allServerCertificatesNode = valueDomainExtensionsDomainExtension["ServerCertificates"]["ServerCertificate"];
for (auto valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate : allServerCertificatesNode)
{
DomainExtension::ServerCertificate serverCertificatesObject;
if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["CertificateId"].isNull())
serverCertificatesObject.certificateId = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["CertificateId"].asString();
if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["EncryptionAlgorithm"].isNull())
serverCertificatesObject.encryptionAlgorithm = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["EncryptionAlgorithm"].asString();
if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["BindingType"].isNull())
serverCertificatesObject.bindingType = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["BindingType"].asString();
if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["StandardType"].isNull())
serverCertificatesObject.standardType = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["StandardType"].asString();
domainExtensionsObject.serverCertificates.push_back(serverCertificatesObject);
}
domainExtensions_.push_back(domainExtensionsObject);
}

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

@@ -169,6 +169,12 @@ void DescribeLoadBalancerAttributeResult::parse(const std::string &payload)
cloudInstanceUid_ = std::stol(value["CloudInstanceUid"].asString());
if(!value["SupportPrivateLink"].isNull())
supportPrivateLink_ = value["SupportPrivateLink"].asString() == "true";
if(!value["BusinessStatus"].isNull())
businessStatus_ = value["BusinessStatus"].asString();
if(!value["ModificationProtectionStatus"].isNull())
modificationProtectionStatus_ = value["ModificationProtectionStatus"].asString();
if(!value["ModificationProtectionReason"].isNull())
modificationProtectionReason_ = value["ModificationProtectionReason"].asString();
}
@@ -232,11 +238,21 @@ std::string DescribeLoadBalancerAttributeResult::getHasReservedInfo()const
return hasReservedInfo_;
}
std::string DescribeLoadBalancerAttributeResult::getBusinessStatus()const
{
return businessStatus_;
}
std::string DescribeLoadBalancerAttributeResult::getReservedInfoBandwidth()const
{
return reservedInfoBandwidth_;
}
std::string DescribeLoadBalancerAttributeResult::getModificationProtectionStatus()const
{
return modificationProtectionStatus_;
}
std::string DescribeLoadBalancerAttributeResult::getLoadBalancerSpec()const
{
return loadBalancerSpec_;
@@ -252,6 +268,11 @@ int DescribeLoadBalancerAttributeResult::getBandwidth()const
return bandwidth_;
}
std::string DescribeLoadBalancerAttributeResult::getModificationProtectionReason()const
{
return modificationProtectionReason_;
}
std::string DescribeLoadBalancerAttributeResult::getAssociatedCenId()const
{
return associatedCenId_;

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

@@ -65,8 +65,46 @@ void DescribeLoadBalancerHTTPSListenerAttributeResult::parse(const std::string &
domainExtensionsObject.domain = valueDomainExtensionsDomainExtension["Domain"].asString();
if(!valueDomainExtensionsDomainExtension["ServerCertificateId"].isNull())
domainExtensionsObject.serverCertificateId = valueDomainExtensionsDomainExtension["ServerCertificateId"].asString();
auto allCertificatesNode = valueDomainExtensionsDomainExtension["Certificates"]["Certificate"];
for (auto valueDomainExtensionsDomainExtensionCertificatesCertificate : allCertificatesNode)
{
DomainExtension::Certificate certificatesObject;
if(!valueDomainExtensionsDomainExtensionCertificatesCertificate["CertificateId"].isNull())
certificatesObject.certificateId = valueDomainExtensionsDomainExtensionCertificatesCertificate["CertificateId"].asString();
if(!valueDomainExtensionsDomainExtensionCertificatesCertificate["EncryptionAlgorithm"].isNull())
certificatesObject.encryptionAlgorithm = valueDomainExtensionsDomainExtensionCertificatesCertificate["EncryptionAlgorithm"].asString();
domainExtensionsObject.certificates.push_back(certificatesObject);
}
auto allServerCertificates1Node = valueDomainExtensionsDomainExtension["ServerCertificates"]["ServerCertificate"];
for (auto valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate : allServerCertificates1Node)
{
DomainExtension::ServerCertificate serverCertificates1Object;
if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["CertificateId"].isNull())
serverCertificates1Object.certificateId = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["CertificateId"].asString();
if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["EncryptionAlgorithm"].isNull())
serverCertificates1Object.encryptionAlgorithm = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["EncryptionAlgorithm"].asString();
if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["StandardType"].isNull())
serverCertificates1Object.standardType = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["StandardType"].asString();
if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["BindingType"].isNull())
serverCertificates1Object.bindingType = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["BindingType"].asString();
domainExtensionsObject.serverCertificates1.push_back(serverCertificates1Object);
}
domainExtensions_.push_back(domainExtensionsObject);
}
auto allServerCertificatesNode = value["ServerCertificates"]["ServerCertificate"];
for (auto valueServerCertificatesServerCertificate : allServerCertificatesNode)
{
ServerCertificate2 serverCertificatesObject;
if(!valueServerCertificatesServerCertificate["CertificateId"].isNull())
serverCertificatesObject.certificateId = valueServerCertificatesServerCertificate["CertificateId"].asString();
if(!valueServerCertificatesServerCertificate["EncryptionAlgorithm"].isNull())
serverCertificatesObject.encryptionAlgorithm = valueServerCertificatesServerCertificate["EncryptionAlgorithm"].asString();
if(!valueServerCertificatesServerCertificate["StandardType"].isNull())
serverCertificatesObject.standardType = valueServerCertificatesServerCertificate["StandardType"].asString();
if(!valueServerCertificatesServerCertificate["BindingType"].isNull())
serverCertificatesObject.bindingType = valueServerCertificatesServerCertificate["BindingType"].asString();
serverCertificates_.push_back(serverCertificatesObject);
}
auto allAclIds = value["AclIds"]["AclId"];
for (const auto &item : allAclIds)
aclIds_.push_back(item.asString());
@@ -250,6 +288,11 @@ std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getCACertificateId
return cACertificateId_;
}
std::vector<DescribeLoadBalancerHTTPSListenerAttributeResult::ServerCertificate2> DescribeLoadBalancerHTTPSListenerAttributeResult::getServerCertificates()const
{
return serverCertificates_;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_ClientCertFingerprintAlias()const
{
return xForwardedFor_ClientCertFingerprintAlias_;

73
slb/src/model/DescribeLoadBalancerListenersExRequest.cc
View File

@@ -1,73 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/slb/model/DescribeLoadBalancerListenersExRequest.h>
using AlibabaCloud::Slb::Model::DescribeLoadBalancerListenersExRequest;
DescribeLoadBalancerListenersExRequest::DescribeLoadBalancerListenersExRequest() :
RpcServiceRequest("slb", "2014-05-15", "DescribeLoadBalancerListenersEx")
{
setMethod(HttpRequest::Method::Post);
}
DescribeLoadBalancerListenersExRequest::~DescribeLoadBalancerListenersExRequest()
{}
int DescribeLoadBalancerListenersExRequest::getListenerPort()const
{
return listenerPort_;
}
void DescribeLoadBalancerListenersExRequest::setListenerPort(int listenerPort)
{
listenerPort_ = listenerPort;
setParameter("ListenerPort", std::to_string(listenerPort));
}
std::string DescribeLoadBalancerListenersExRequest::getProtocol()const
{
return protocol_;
}
void DescribeLoadBalancerListenersExRequest::setProtocol(const std::string& protocol)
{
protocol_ = protocol;
setParameter("Protocol", protocol);
}
std::string DescribeLoadBalancerListenersExRequest::getLoadBalancerId()const
{
return loadBalancerId_;
}
void DescribeLoadBalancerListenersExRequest::setLoadBalancerId(const std::string& loadBalancerId)
{
loadBalancerId_ = loadBalancerId;
setParameter("LoadBalancerId", loadBalancerId);
}
std::string DescribeLoadBalancerListenersExRequest::getRegionId()const
{
return regionId_;
}
void DescribeLoadBalancerListenersExRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}

68
slb/src/model/DescribeLoadBalancerListenersExResult.cc
View File

@@ -1,68 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/slb/model/DescribeLoadBalancerListenersExResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
DescribeLoadBalancerListenersExResult::DescribeLoadBalancerListenersExResult() :
ServiceResult()
{}
DescribeLoadBalancerListenersExResult::DescribeLoadBalancerListenersExResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeLoadBalancerListenersExResult::~DescribeLoadBalancerListenersExResult()
{}
void DescribeLoadBalancerListenersExResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allListenerExtendedAttributesNode = value["ListenerExtendedAttributes"]["ListenerAttributeExResponseModel"];
for (auto valueListenerExtendedAttributesListenerAttributeExResponseModel : allListenerExtendedAttributesNode)
{
ListenerAttributeExResponseModel listenerExtendedAttributesObject;
if(!valueListenerExtendedAttributesListenerAttributeExResponseModel["ListenerPort"].isNull())
listenerExtendedAttributesObject.listenerPort = std::stoi(valueListenerExtendedAttributesListenerAttributeExResponseModel["ListenerPort"].asString());
if(!valueListenerExtendedAttributesListenerAttributeExResponseModel["Protocol"].isNull())
listenerExtendedAttributesObject.protocol = valueListenerExtendedAttributesListenerAttributeExResponseModel["Protocol"].asString();
if(!valueListenerExtendedAttributesListenerAttributeExResponseModel["RecordCustomizedHeaders"].isNull())
listenerExtendedAttributesObject.recordCustomizedHeaders = valueListenerExtendedAttributesListenerAttributeExResponseModel["RecordCustomizedHeaders"].asString();
listenerExtendedAttributes_.push_back(listenerExtendedAttributesObject);
}
if(!value["LoadBalancerId"].isNull())
loadBalancerId_ = value["LoadBalancerId"].asString();
}
std::string DescribeLoadBalancerListenersExResult::getLoadBalancerId()const
{
return loadBalancerId_;
}
std::vector<DescribeLoadBalancerListenersExResult::ListenerAttributeExResponseModel> DescribeLoadBalancerListenersExResult::getListenerExtendedAttributes()const
{
return listenerExtendedAttributes_;
}

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

@@ -27,17 +27,6 @@ DescribeLoadBalancersRequest::DescribeLoadBalancersRequest() :
DescribeLoadBalancersRequest::~DescribeLoadBalancersRequest()
{}
std::string DescribeLoadBalancersRequest::getAccess_key_id()const
{
return access_key_id_;
}
void DescribeLoadBalancersRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
long DescribeLoadBalancersRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
@@ -49,17 +38,6 @@ void DescribeLoadBalancersRequest::setResourceOwnerId(long resourceOwnerId)
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
bool DescribeLoadBalancersRequest::getSupportPrivateLink()const
{
return supportPrivateLink_;
}
void DescribeLoadBalancersRequest::setSupportPrivateLink(bool supportPrivateLink)
{
supportPrivateLink_ = supportPrivateLink;
setParameter("SupportPrivateLink", supportPrivateLink ? "true" : "false");
}
std::string DescribeLoadBalancersRequest::getNetworkType()const
{
return networkType_;
@@ -93,17 +71,6 @@ void DescribeLoadBalancersRequest::setMasterZoneId(const std::string& masterZone
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::getResourceGroupId()const
{
return resourceGroupId_;
@@ -126,39 +93,6 @@ void DescribeLoadBalancersRequest::setLoadBalancerName(const std::string& loadBa
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_;
@@ -186,50 +120,6 @@ void DescribeLoadBalancersRequest::setTag(const std::vector<Tag>& tag)
}
}
std::string DescribeLoadBalancersRequest::getFuzzy()const
{
return fuzzy_;
}
void DescribeLoadBalancersRequest::setFuzzy(const std::string& fuzzy)
{
fuzzy_ = fuzzy;
setParameter("Fuzzy", fuzzy);
}
std::string DescribeLoadBalancersRequest::getAddress()const
{
return address_;
}
void DescribeLoadBalancersRequest::setAddress(const std::string& address)
{
address_ = address;
setParameter("Address", address);
}
std::string DescribeLoadBalancersRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeLoadBalancersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeLoadBalancersRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeLoadBalancersRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DescribeLoadBalancersRequest::getOwnerId()const
{
return ownerId_;
@@ -252,17 +142,6 @@ void DescribeLoadBalancersRequest::setServerId(const std::string& serverId)
setParameter("ServerId", serverId);
}
std::string DescribeLoadBalancersRequest::getLoadBalancerStatus()const
{
return loadBalancerStatus_;
}
void DescribeLoadBalancersRequest::setLoadBalancerStatus(const std::string& loadBalancerStatus)
{
loadBalancerStatus_ = loadBalancerStatus;
setParameter("LoadBalancerStatus", loadBalancerStatus);
}
std::string DescribeLoadBalancersRequest::getTags()const
{
return tags_;
@@ -318,6 +197,138 @@ void DescribeLoadBalancersRequest::setInternetChargeType(const std::string& inte
setParameter("InternetChargeType", internetChargeType);
}
std::string DescribeLoadBalancersRequest::getAccess_key_id()const
{
return access_key_id_;
}
void DescribeLoadBalancersRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
bool DescribeLoadBalancersRequest::getSupportPrivateLink()const
{
return supportPrivateLink_;
}
void DescribeLoadBalancersRequest::setSupportPrivateLink(bool supportPrivateLink)
{
supportPrivateLink_ = supportPrivateLink;
setParameter("SupportPrivateLink", supportPrivateLink ? "true" : "false");
}
int DescribeLoadBalancersRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeLoadBalancersRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
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::getFuzzy()const
{
return fuzzy_;
}
void DescribeLoadBalancersRequest::setFuzzy(const std::string& fuzzy)
{
fuzzy_ = fuzzy;
setParameter("Fuzzy", fuzzy);
}
std::string DescribeLoadBalancersRequest::getBusinessStatus()const
{
return businessStatus_;
}
void DescribeLoadBalancersRequest::setBusinessStatus(const std::string& businessStatus)
{
businessStatus_ = businessStatus;
setParameter("BusinessStatus", businessStatus);
}
std::string DescribeLoadBalancersRequest::getAddress()const
{
return address_;
}
void DescribeLoadBalancersRequest::setAddress(const std::string& address)
{
address_ = address;
setParameter("Address", address);
}
std::string DescribeLoadBalancersRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeLoadBalancersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeLoadBalancersRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeLoadBalancersRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeLoadBalancersRequest::getLoadBalancerStatus()const
{
return loadBalancerStatus_;
}
void DescribeLoadBalancersRequest::setLoadBalancerStatus(const std::string& loadBalancerStatus)
{
loadBalancerStatus_ = loadBalancerStatus;
setParameter("LoadBalancerStatus", loadBalancerStatus);
}
std::string DescribeLoadBalancersRequest::getVpcId()const
{
return vpcId_;

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

@@ -79,14 +79,20 @@ void DescribeLoadBalancersResult::parse(const std::string &payload)
loadBalancersObject.resourceGroupId = valueLoadBalancersLoadBalancer["ResourceGroupId"].asString();
if(!valueLoadBalancersLoadBalancer["AddressIPVersion"].isNull())
loadBalancersObject.addressIPVersion = valueLoadBalancersLoadBalancer["AddressIPVersion"].asString();
auto allTagsNode = allLoadBalancersNode["Tags"]["Tag"];
for (auto allLoadBalancersNodeTagsTag : allTagsNode)
if(!valueLoadBalancersLoadBalancer["BusinessStatus"].isNull())
loadBalancersObject.businessStatus = valueLoadBalancersLoadBalancer["BusinessStatus"].asString();
if(!valueLoadBalancersLoadBalancer["ModificationProtectionStatus"].isNull())
loadBalancersObject.modificationProtectionStatus = valueLoadBalancersLoadBalancer["ModificationProtectionStatus"].asString();
if(!valueLoadBalancersLoadBalancer["ModificationProtectionReason"].isNull())
loadBalancersObject.modificationProtectionReason = valueLoadBalancersLoadBalancer["ModificationProtectionReason"].asString();
auto allTagsNode = valueLoadBalancersLoadBalancer["Tags"]["Tag"];
for (auto valueLoadBalancersLoadBalancerTagsTag : allTagsNode)
{
LoadBalancer::Tag tagsObject;
if(!allLoadBalancersNodeTagsTag["TagKey"].isNull())
tagsObject.tagKey = allLoadBalancersNodeTagsTag["TagKey"].asString();
if(!allLoadBalancersNodeTagsTag["TagValue"].isNull())
tagsObject.tagValue = allLoadBalancersNodeTagsTag["TagValue"].asString();
if(!valueLoadBalancersLoadBalancerTagsTag["TagKey"].isNull())
tagsObject.tagKey = valueLoadBalancersLoadBalancerTagsTag["TagKey"].asString();
if(!valueLoadBalancersLoadBalancerTagsTag["TagValue"].isNull())
tagsObject.tagValue = valueLoadBalancersLoadBalancerTagsTag["TagValue"].asString();
loadBalancersObject.tags.push_back(tagsObject);
}
loadBalancers_.push_back(loadBalancersObject);

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

@@ -1,126 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/slb/model/DescribeMasterSlaveVServerGroupAttributeRequest.h>
using AlibabaCloud::Slb::Model::DescribeMasterSlaveVServerGroupAttributeRequest;
DescribeMasterSlaveVServerGroupAttributeRequest::DescribeMasterSlaveVServerGroupAttributeRequest() :
RpcServiceRequest("slb", "2014-05-15", "DescribeMasterSlaveVServerGroupAttribute")
{}
DescribeMasterSlaveVServerGroupAttributeRequest::~DescribeMasterSlaveVServerGroupAttributeRequest()
{}
std::string DescribeMasterSlaveVServerGroupAttributeRequest::getAccess_key_id()const
{
return access_key_id_;
}
void DescribeMasterSlaveVServerGroupAttributeRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setCoreParameter("Access_key_id", access_key_id);
}
long DescribeMasterSlaveVServerGroupAttributeRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeMasterSlaveVServerGroupAttributeRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeMasterSlaveVServerGroupAttributeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeMasterSlaveVServerGroupAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
std::string DescribeMasterSlaveVServerGroupAttributeRequest::getRegionId()const
{
return regionId_;
}
void DescribeMasterSlaveVServerGroupAttributeRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DescribeMasterSlaveVServerGroupAttributeRequest::getMasterSlaveVServerGroupId()const
{
return masterSlaveVServerGroupId_;
}
void DescribeMasterSlaveVServerGroupAttributeRequest::setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId)
{
masterSlaveVServerGroupId_ = masterSlaveVServerGroupId;
setCoreParameter("MasterSlaveVServerGroupId", masterSlaveVServerGroupId);
}
std::string DescribeMasterSlaveVServerGroupAttributeRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeMasterSlaveVServerGroupAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeMasterSlaveVServerGroupAttributeRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeMasterSlaveVServerGroupAttributeRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setCoreParameter("OwnerAccount", ownerAccount);
}
long DescribeMasterSlaveVServerGroupAttributeRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeMasterSlaveVServerGroupAttributeRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeMasterSlaveVServerGroupAttributeRequest::getTags()const
{
return tags_;
}
void DescribeMasterSlaveVServerGroupAttributeRequest::setTags(const std::string& tags)
{
tags_ = tags;
setCoreParameter("Tags", tags);
}

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

@@ -1,87 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/slb/model/DescribeMasterSlaveVServerGroupAttributeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
DescribeMasterSlaveVServerGroupAttributeResult::DescribeMasterSlaveVServerGroupAttributeResult() :
ServiceResult()
{}
DescribeMasterSlaveVServerGroupAttributeResult::DescribeMasterSlaveVServerGroupAttributeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeMasterSlaveVServerGroupAttributeResult::~DescribeMasterSlaveVServerGroupAttributeResult()
{}
void DescribeMasterSlaveVServerGroupAttributeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allMasterSlaveBackendServersNode = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
for (auto valueMasterSlaveBackendServersMasterSlaveBackendServer : allMasterSlaveBackendServersNode)
{
MasterSlaveBackendServer masterSlaveBackendServersObject;
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerId"].isNull())
masterSlaveBackendServersObject.serverId = valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerId"].asString();
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Port"].isNull())
masterSlaveBackendServersObject.port = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["Port"].asString());
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Weight"].isNull())
masterSlaveBackendServersObject.weight = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["Weight"].asString());
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["IsBackup"].isNull())
masterSlaveBackendServersObject.isBackup = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["IsBackup"].asString());
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Type"].isNull())
masterSlaveBackendServersObject.type = valueMasterSlaveBackendServersMasterSlaveBackendServer["Type"].asString();
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerIp"].isNull())
masterSlaveBackendServersObject.serverIp = valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerIp"].asString();
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["EniHost"].isNull())
masterSlaveBackendServersObject.eniHost = valueMasterSlaveBackendServersMasterSlaveBackendServer["EniHost"].asString();
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["VpcId"].isNull())
masterSlaveBackendServersObject.vpcId = valueMasterSlaveBackendServersMasterSlaveBackendServer["VpcId"].asString();
if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Description"].isNull())
masterSlaveBackendServersObject.description = valueMasterSlaveBackendServersMasterSlaveBackendServer["Description"].asString();
masterSlaveBackendServers_.push_back(masterSlaveBackendServersObject);
}
if(!value["MasterSlaveVServerGroupId"].isNull())
masterSlaveVServerGroupId_ = value["MasterSlaveVServerGroupId"].asString();
if(!value["MasterSlaveVServerGroupName"].isNull())
masterSlaveVServerGroupName_ = value["MasterSlaveVServerGroupName"].asString();
}
std::string DescribeMasterSlaveVServerGroupAttributeResult::getMasterSlaveVServerGroupId()const
{
return masterSlaveVServerGroupId_;
}
std::vector<DescribeMasterSlaveVServerGroupAttributeResult::MasterSlaveBackendServer> DescribeMasterSlaveVServerGroupAttributeResult::getMasterSlaveBackendServers()const
{
return masterSlaveBackendServers_;
}
std::string DescribeMasterSlaveVServerGroupAttributeResult::getMasterSlaveVServerGroupName()const
{
return masterSlaveVServerGroupName_;
}

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

@@ -1,126 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsRequest.h>
using AlibabaCloud::Slb::Model::DescribeMasterSlaveVServerGroupsRequest;
DescribeMasterSlaveVServerGroupsRequest::DescribeMasterSlaveVServerGroupsRequest() :
RpcServiceRequest("slb", "2014-05-15", "DescribeMasterSlaveVServerGroups")
{}
DescribeMasterSlaveVServerGroupsRequest::~DescribeMasterSlaveVServerGroupsRequest()
{}
std::string DescribeMasterSlaveVServerGroupsRequest::getAccess_key_id()const
{
return access_key_id_;
}
void DescribeMasterSlaveVServerGroupsRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setCoreParameter("Access_key_id", access_key_id);
}
long DescribeMasterSlaveVServerGroupsRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeMasterSlaveVServerGroupsRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeMasterSlaveVServerGroupsRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeMasterSlaveVServerGroupsRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}
std::string DescribeMasterSlaveVServerGroupsRequest::getRegionId()const
{
return regionId_;
}
void DescribeMasterSlaveVServerGroupsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DescribeMasterSlaveVServerGroupsRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeMasterSlaveVServerGroupsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeMasterSlaveVServerGroupsRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeMasterSlaveVServerGroupsRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setCoreParameter("OwnerAccount", ownerAccount);
}
long DescribeMasterSlaveVServerGroupsRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeMasterSlaveVServerGroupsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeMasterSlaveVServerGroupsRequest::getTags()const
{
return tags_;
}
void DescribeMasterSlaveVServerGroupsRequest::setTags(const std::string& tags)
{
tags_ = tags;
setCoreParameter("Tags", tags);
}
std::string DescribeMasterSlaveVServerGroupsRequest::getLoadBalancerId()const
{
return loadBalancerId_;
}
void DescribeMasterSlaveVServerGroupsRequest::setLoadBalancerId(const std::string& loadBalancerId)
{
loadBalancerId_ = loadBalancerId;
setCoreParameter("LoadBalancerId", loadBalancerId);
}

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

@@ -1,59 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
DescribeMasterSlaveVServerGroupsResult::DescribeMasterSlaveVServerGroupsResult() :
ServiceResult()
{}
DescribeMasterSlaveVServerGroupsResult::DescribeMasterSlaveVServerGroupsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeMasterSlaveVServerGroupsResult::~DescribeMasterSlaveVServerGroupsResult()
{}
void DescribeMasterSlaveVServerGroupsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allMasterSlaveVServerGroupsNode = value["MasterSlaveVServerGroups"]["MasterSlaveVServerGroup"];
for (auto valueMasterSlaveVServerGroupsMasterSlaveVServerGroup : allMasterSlaveVServerGroupsNode)
{
MasterSlaveVServerGroup masterSlaveVServerGroupsObject;
if(!valueMasterSlaveVServerGroupsMasterSlaveVServerGroup["MasterSlaveVServerGroupId"].isNull())
masterSlaveVServerGroupsObject.masterSlaveVServerGroupId = valueMasterSlaveVServerGroupsMasterSlaveVServerGroup["MasterSlaveVServerGroupId"].asString();
if(!valueMasterSlaveVServerGroupsMasterSlaveVServerGroup["MasterSlaveVServerGroupName"].isNull())
masterSlaveVServerGroupsObject.masterSlaveVServerGroupName = valueMasterSlaveVServerGroupsMasterSlaveVServerGroup["MasterSlaveVServerGroupName"].asString();
masterSlaveVServerGroups_.push_back(masterSlaveVServerGroupsObject);
}
}
std::vector<DescribeMasterSlaveVServerGroupsResult::MasterSlaveVServerGroup> DescribeMasterSlaveVServerGroupsResult::getMasterSlaveVServerGroups()const
{
return masterSlaveVServerGroups_;
}

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

@@ -71,14 +71,20 @@ void DescribeServerCertificatesResult::parse(const std::string &payload)
serverCertificatesObject.expireTimeStamp = std::stol(valueServerCertificatesServerCertificate["ExpireTimeStamp"].asString());
if(!valueServerCertificatesServerCertificate["CommonName"].isNull())
serverCertificatesObject.commonName = valueServerCertificatesServerCertificate["CommonName"].asString();
auto allTagsNode = allServerCertificatesNode["Tags"]["Tag"];
for (auto allServerCertificatesNodeTagsTag : allTagsNode)
if(!valueServerCertificatesServerCertificate["EncryptionAlgorithm"].isNull())
serverCertificatesObject.encryptionAlgorithm = valueServerCertificatesServerCertificate["EncryptionAlgorithm"].asString();
if(!valueServerCertificatesServerCertificate["EncryptionKeyLength"].isNull())
serverCertificatesObject.encryptionKeyLength = std::stoi(valueServerCertificatesServerCertificate["EncryptionKeyLength"].asString());
if(!valueServerCertificatesServerCertificate["StandardType"].isNull())
serverCertificatesObject.standardType = valueServerCertificatesServerCertificate["StandardType"].asString();
auto allTagsNode = valueServerCertificatesServerCertificate["Tags"]["Tag"];
for (auto valueServerCertificatesServerCertificateTagsTag : allTagsNode)
{
ServerCertificate::Tag tagsObject;
if(!allServerCertificatesNodeTagsTag["TagKey"].isNull())
tagsObject.tagKey = allServerCertificatesNodeTagsTag["TagKey"].asString();
if(!allServerCertificatesNodeTagsTag["TagValue"].isNull())
tagsObject.tagValue = allServerCertificatesNodeTagsTag["TagValue"].asString();
if(!valueServerCertificatesServerCertificateTagsTag["TagKey"].isNull())
tagsObject.tagKey = valueServerCertificatesServerCertificateTagsTag["TagKey"].asString();
if(!valueServerCertificatesServerCertificateTagsTag["TagValue"].isNull())
tagsObject.tagValue = valueServerCertificatesServerCertificateTagsTag["TagValue"].asString();
serverCertificatesObject.tags.push_back(tagsObject);
}
auto allSubjectAlternativeNames = value["SubjectAlternativeNames"]["SubjectAlternativeName"];

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

@@ -47,14 +47,14 @@ void DescribeZonesResult::parse(const std::string &payload)
zonesObject.zoneId = valueZonesZone["ZoneId"].asString();
if(!valueZonesZone["LocalName"].isNull())
zonesObject.localName = valueZonesZone["LocalName"].asString();
auto allSlaveZonesNode = allZonesNode["SlaveZones"]["SlaveZone"];
for (auto allZonesNodeSlaveZonesSlaveZone : allSlaveZonesNode)
auto allSlaveZonesNode = valueZonesZone["SlaveZones"]["SlaveZone"];
for (auto valueZonesZoneSlaveZonesSlaveZone : allSlaveZonesNode)
{
Zone::SlaveZone slaveZonesObject;
if(!allZonesNodeSlaveZonesSlaveZone["ZoneId"].isNull())
slaveZonesObject.zoneId = allZonesNodeSlaveZonesSlaveZone["ZoneId"].asString();
if(!allZonesNodeSlaveZonesSlaveZone["LocalName"].isNull())
slaveZonesObject.localName = allZonesNodeSlaveZonesSlaveZone["LocalName"].asString();
if(!valueZonesZoneSlaveZonesSlaveZone["ZoneId"].isNull())
slaveZonesObject.zoneId = valueZonesZoneSlaveZonesSlaveZone["ZoneId"].asString();
if(!valueZonesZoneSlaveZonesSlaveZone["LocalName"].isNull())
slaveZonesObject.localName = valueZonesZoneSlaveZonesSlaveZone["LocalName"].asString();
zonesObject.slaveZones.push_back(slaveZonesObject);
}
zones_.push_back(zonesObject);

161
slb/src/model/ListTLSCipherPoliciesRequest.cc Normal file
View File

@@ -0,0 +1,161 @@
/*
* 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/ListTLSCipherPoliciesRequest.h>
using AlibabaCloud::Slb::Model::ListTLSCipherPoliciesRequest;
ListTLSCipherPoliciesRequest::ListTLSCipherPoliciesRequest() :
RpcServiceRequest("slb", "2014-05-15", "ListTLSCipherPolicies")
{
setMethod(HttpRequest::Method::Post);
}
ListTLSCipherPoliciesRequest::~ListTLSCipherPoliciesRequest()
{}
std::string ListTLSCipherPoliciesRequest::getAccess_key_id()const
{
return access_key_id_;
}
void ListTLSCipherPoliciesRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
long ListTLSCipherPoliciesRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void ListTLSCipherPoliciesRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
bool ListTLSCipherPoliciesRequest::getIncludeListener()const
{
return includeListener_;
}
void ListTLSCipherPoliciesRequest::setIncludeListener(bool includeListener)
{
includeListener_ = includeListener;
setParameter("IncludeListener", includeListener ? "true" : "false");
}
std::string ListTLSCipherPoliciesRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void ListTLSCipherPoliciesRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string ListTLSCipherPoliciesRequest::getTLSCipherPolicyId()const
{
return tLSCipherPolicyId_;
}
void ListTLSCipherPoliciesRequest::setTLSCipherPolicyId(const std::string& tLSCipherPolicyId)
{
tLSCipherPolicyId_ = tLSCipherPolicyId;
setParameter("TLSCipherPolicyId", tLSCipherPolicyId);
}
std::string ListTLSCipherPoliciesRequest::getRegionId()const
{
return regionId_;
}
void ListTLSCipherPoliciesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string ListTLSCipherPoliciesRequest::getNextToken()const
{
return nextToken_;
}
void ListTLSCipherPoliciesRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
}
std::string ListTLSCipherPoliciesRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void ListTLSCipherPoliciesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string ListTLSCipherPoliciesRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void ListTLSCipherPoliciesRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long ListTLSCipherPoliciesRequest::getOwnerId()const
{
return ownerId_;
}
void ListTLSCipherPoliciesRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string ListTLSCipherPoliciesRequest::getName()const
{
return name_;
}
void ListTLSCipherPoliciesRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}
int ListTLSCipherPoliciesRequest::getMaxItems()const
{
return maxItems_;
}
void ListTLSCipherPoliciesRequest::setMaxItems(int maxItems)
{
maxItems_ = maxItems;
setParameter("MaxItems", std::to_string(maxItems));
}

102
slb/src/model/ListTLSCipherPoliciesResult.cc Normal file
View File

@@ -0,0 +1,102 @@
/*
* 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/ListTLSCipherPoliciesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
ListTLSCipherPoliciesResult::ListTLSCipherPoliciesResult() :
ServiceResult()
{}
ListTLSCipherPoliciesResult::ListTLSCipherPoliciesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListTLSCipherPoliciesResult::~ListTLSCipherPoliciesResult()
{}
void ListTLSCipherPoliciesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allTLSCipherPoliciesNode = value["TLSCipherPolicies"]["TLSCipherPolicy"];
for (auto valueTLSCipherPoliciesTLSCipherPolicy : allTLSCipherPoliciesNode)
{
TLSCipherPolicy tLSCipherPoliciesObject;
if(!valueTLSCipherPoliciesTLSCipherPolicy["CreateTime"].isNull())
tLSCipherPoliciesObject.createTime = std::stol(valueTLSCipherPoliciesTLSCipherPolicy["CreateTime"].asString());
if(!valueTLSCipherPoliciesTLSCipherPolicy["InstanceId"].isNull())
tLSCipherPoliciesObject.instanceId = valueTLSCipherPoliciesTLSCipherPolicy["InstanceId"].asString();
if(!valueTLSCipherPoliciesTLSCipherPolicy["Name"].isNull())
tLSCipherPoliciesObject.name = valueTLSCipherPoliciesTLSCipherPolicy["Name"].asString();
if(!valueTLSCipherPoliciesTLSCipherPolicy["Status"].isNull())
tLSCipherPoliciesObject.status = valueTLSCipherPoliciesTLSCipherPolicy["Status"].asString();
auto allRelateListenersNode = valueTLSCipherPoliciesTLSCipherPolicy["RelateListeners"]["RelateListener"];
for (auto valueTLSCipherPoliciesTLSCipherPolicyRelateListenersRelateListener : allRelateListenersNode)
{
TLSCipherPolicy::RelateListener relateListenersObject;
if(!valueTLSCipherPoliciesTLSCipherPolicyRelateListenersRelateListener["LoadBalancerId"].isNull())
relateListenersObject.loadBalancerId = valueTLSCipherPoliciesTLSCipherPolicyRelateListenersRelateListener["LoadBalancerId"].asString();
if(!valueTLSCipherPoliciesTLSCipherPolicyRelateListenersRelateListener["Port"].isNull())
relateListenersObject.port = std::stoi(valueTLSCipherPoliciesTLSCipherPolicyRelateListenersRelateListener["Port"].asString());
if(!valueTLSCipherPoliciesTLSCipherPolicyRelateListenersRelateListener["Protocol"].isNull())
relateListenersObject.protocol = valueTLSCipherPoliciesTLSCipherPolicyRelateListenersRelateListener["Protocol"].asString();
tLSCipherPoliciesObject.relateListeners.push_back(relateListenersObject);
}
auto allTLSVersions = value["TLSVersions"]["TLSVersion"];
for (auto value : allTLSVersions)
tLSCipherPoliciesObject.tLSVersions.push_back(value.asString());
auto allCiphers = value["Ciphers"]["Cipher"];
for (auto value : allCiphers)
tLSCipherPoliciesObject.ciphers.push_back(value.asString());
tLSCipherPolicies_.push_back(tLSCipherPoliciesObject);
}
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
if(!value["IsTruncated"].isNull())
isTruncated_ = value["IsTruncated"].asString() == "true";
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
}
int ListTLSCipherPoliciesResult::getTotalCount()const
{
return totalCount_;
}
std::string ListTLSCipherPoliciesResult::getNextToken()const
{
return nextToken_;
}
std::vector<ListTLSCipherPoliciesResult::TLSCipherPolicy> ListTLSCipherPoliciesResult::getTLSCipherPolicies()const
{
return tLSCipherPolicies_;
}
bool ListTLSCipherPoliciesResult::getIsTruncated()const
{
return isTruncated_;
}

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

@@ -49,6 +49,23 @@ void SetDomainExtensionAttributeRequest::setResourceOwnerId(long resourceOwnerId
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::vector<SetDomainExtensionAttributeRequest::ServerCertificate> SetDomainExtensionAttributeRequest::getServerCertificate()const
{
return serverCertificate_;
}
void SetDomainExtensionAttributeRequest::setServerCertificate(const std::vector<ServerCertificate>& serverCertificate)
{
serverCertificate_ = serverCertificate;
for(int dep1 = 0; dep1!= serverCertificate.size(); dep1++) {
auto serverCertificateObj = serverCertificate.at(dep1);
std::string serverCertificateObjStr = "ServerCertificate." + std::to_string(dep1 + 1);
setParameter(serverCertificateObjStr + ".BindingType", serverCertificateObj.bindingType);
setParameter(serverCertificateObjStr + ".CertificateId", serverCertificateObj.certificateId);
setParameter(serverCertificateObjStr + ".StandardType", serverCertificateObj.standardType);
}
}
std::string SetDomainExtensionAttributeRequest::getRegionId()const
{
return regionId_;
@@ -93,6 +110,19 @@ void SetDomainExtensionAttributeRequest::setOwnerAccount(const std::string& owne
setParameter("OwnerAccount", ownerAccount);
}
std::vector<std::string> SetDomainExtensionAttributeRequest::getCertificateId()const
{
return certificateId_;
}
void SetDomainExtensionAttributeRequest::setCertificateId(const std::vector<std::string>& certificateId)
{
certificateId_ = certificateId;
for(int dep1 = 0; dep1!= certificateId.size(); dep1++) {
setParameter("CertificateId."+ std::to_string(dep1), certificateId.at(dep1));
}
}
long SetDomainExtensionAttributeRequest::getOwnerId()const
{
return ownerId_;

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

@@ -38,6 +38,23 @@ void SetLoadBalancerHTTPSListenerAttributeRequest::setResourceOwnerId(long resou
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::vector<SetLoadBalancerHTTPSListenerAttributeRequest::ServerCertificate> SetLoadBalancerHTTPSListenerAttributeRequest::getServerCertificate()const
{
return serverCertificate_;
}
void SetLoadBalancerHTTPSListenerAttributeRequest::setServerCertificate(const std::vector<ServerCertificate>& serverCertificate)
{
serverCertificate_ = serverCertificate;
for(int dep1 = 0; dep1!= serverCertificate.size(); dep1++) {
auto serverCertificateObj = serverCertificate.at(dep1);
std::string serverCertificateObjStr = "ServerCertificate." + std::to_string(dep1 + 1);
setParameter(serverCertificateObjStr + ".BindingType", serverCertificateObj.bindingType);
setParameter(serverCertificateObjStr + ".CertificateId", serverCertificateObj.certificateId);
setParameter(serverCertificateObjStr + ".StandardType", serverCertificateObj.standardType);
}
}
int SetLoadBalancerHTTPSListenerAttributeRequest::getHealthCheckTimeout()const
{
return healthCheckTimeout_;

89
slb/src/model/SetLoadBalancerListenerAttributeExRequest.cc
View File

@@ -1,89 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/slb/model/SetLoadBalancerListenerAttributeExRequest.h>
using AlibabaCloud::Slb::Model::SetLoadBalancerListenerAttributeExRequest;
SetLoadBalancerListenerAttributeExRequest::SetLoadBalancerListenerAttributeExRequest() :
RpcServiceRequest("slb", "2014-05-15", "SetLoadBalancerListenerAttributeEx")
{
setMethod(HttpRequest::Method::Post);
}
SetLoadBalancerListenerAttributeExRequest::~SetLoadBalancerListenerAttributeExRequest()
{}
int SetLoadBalancerListenerAttributeExRequest::getListenerPort()const
{
return listenerPort_;
}
void SetLoadBalancerListenerAttributeExRequest::setListenerPort(int listenerPort)
{
listenerPort_ = listenerPort;
setParameter("ListenerPort", std::to_string(listenerPort));
}
std::vector<SetLoadBalancerListenerAttributeExRequest::KvAttribute> SetLoadBalancerListenerAttributeExRequest::getKvAttribute()const
{
return kvAttribute_;
}
void SetLoadBalancerListenerAttributeExRequest::setKvAttribute(const std::vector<KvAttribute>& kvAttribute)
{
kvAttribute_ = kvAttribute;
for(int dep1 = 0; dep1!= kvAttribute.size(); dep1++) {
auto kvAttributeObj = kvAttribute.at(dep1);
std::string kvAttributeObjStr = "KvAttribute." + std::to_string(dep1 + 1);
setParameter(kvAttributeObjStr + ".Value", kvAttributeObj.value);
setParameter(kvAttributeObjStr + ".Key", kvAttributeObj.key);
}
}
std::string SetLoadBalancerListenerAttributeExRequest::getProtocol()const
{
return protocol_;
}
void SetLoadBalancerListenerAttributeExRequest::setProtocol(const std::string& protocol)
{
protocol_ = protocol;
setParameter("Protocol", protocol);
}
std::string SetLoadBalancerListenerAttributeExRequest::getLoadBalancerId()const
{
return loadBalancerId_;
}
void SetLoadBalancerListenerAttributeExRequest::setLoadBalancerId(const std::string& loadBalancerId)
{
loadBalancerId_ = loadBalancerId;
setParameter("LoadBalancerId", loadBalancerId);
}
std::string SetLoadBalancerListenerAttributeExRequest::getRegionId()const
{
return regionId_;
}
void SetLoadBalancerListenerAttributeExRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}

117
slb/src/model/SetLoadBalancerModificationProtectionRequest.cc Normal file
View File

@@ -0,0 +1,117 @@
/*
* 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/SetLoadBalancerModificationProtectionRequest.h>
using AlibabaCloud::Slb::Model::SetLoadBalancerModificationProtectionRequest;
SetLoadBalancerModificationProtectionRequest::SetLoadBalancerModificationProtectionRequest() :
RpcServiceRequest("slb", "2014-05-15", "SetLoadBalancerModificationProtection")
{
setMethod(HttpRequest::Method::Post);
}
SetLoadBalancerModificationProtectionRequest::~SetLoadBalancerModificationProtectionRequest()
{}
std::string SetLoadBalancerModificationProtectionRequest::getModificationProtectionReason()const
{
return modificationProtectionReason_;
}
void SetLoadBalancerModificationProtectionRequest::setModificationProtectionReason(const std::string& modificationProtectionReason)
{
modificationProtectionReason_ = modificationProtectionReason;
setParameter("ModificationProtectionReason", modificationProtectionReason);
}
long SetLoadBalancerModificationProtectionRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void SetLoadBalancerModificationProtectionRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string SetLoadBalancerModificationProtectionRequest::getRegionId()const
{
return regionId_;
}
void SetLoadBalancerModificationProtectionRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string SetLoadBalancerModificationProtectionRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void SetLoadBalancerModificationProtectionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string SetLoadBalancerModificationProtectionRequest::getModificationProtectionStatus()const
{
return modificationProtectionStatus_;
}
void SetLoadBalancerModificationProtectionRequest::setModificationProtectionStatus(const std::string& modificationProtectionStatus)
{
modificationProtectionStatus_ = modificationProtectionStatus;
setParameter("ModificationProtectionStatus", modificationProtectionStatus);
}
std::string SetLoadBalancerModificationProtectionRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void SetLoadBalancerModificationProtectionRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long SetLoadBalancerModificationProtectionRequest::getOwnerId()const
{
return ownerId_;
}
void SetLoadBalancerModificationProtectionRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string SetLoadBalancerModificationProtectionRequest::getLoadBalancerId()const
{
return loadBalancerId_;
}
void SetLoadBalancerModificationProtectionRequest::setLoadBalancerId(const std::string& loadBalancerId)
{
loadBalancerId_ = loadBalancerId;
setParameter("LoadBalancerId", loadBalancerId);
}

10
slb/src/model/SetLoadBalancerListenerAttributeExResult.cc → slb/src/model/SetLoadBalancerModificationProtectionResult.cc
View File

@@ -14,26 +14,26 @@
* limitations under the License.
*/
#include <alibabacloud/slb/model/SetLoadBalancerListenerAttributeExResult.h>
#include <alibabacloud/slb/model/SetLoadBalancerModificationProtectionResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Slb;
using namespace AlibabaCloud::Slb::Model;
SetLoadBalancerListenerAttributeExResult::SetLoadBalancerListenerAttributeExResult() :
SetLoadBalancerModificationProtectionResult::SetLoadBalancerModificationProtectionResult() :
ServiceResult()
{}
SetLoadBalancerListenerAttributeExResult::SetLoadBalancerListenerAttributeExResult(const std::string &payload) :
SetLoadBalancerModificationProtectionResult::SetLoadBalancerModificationProtectionResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SetLoadBalancerListenerAttributeExResult::~SetLoadBalancerListenerAttributeExResult()
SetLoadBalancerModificationProtectionResult::~SetLoadBalancerModificationProtectionResult()
{}
void SetLoadBalancerListenerAttributeExResult::parse(const std::string &payload)
void SetLoadBalancerModificationProtectionResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;

154
slb/src/model/SetTLSCipherPolicyAttributeRequest.cc Normal file
View File

@@ -0,0 +1,154 @@
/*
* 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/SetTLSCipherPolicyAttributeRequest.h>
using AlibabaCloud::Slb::Model::SetTLSCipherPolicyAttributeRequest;
SetTLSCipherPolicyAttributeRequest::SetTLSCipherPolicyAttributeRequest() :
RpcServiceRequest("slb", "2014-05-15", "SetTLSCipherPolicyAttribute")
{
setMethod(HttpRequest::Method::Post);
}
SetTLSCipherPolicyAttributeRequest::~SetTLSCipherPolicyAttributeRequest()
{}
std::string SetTLSCipherPolicyAttributeRequest::getAccess_key_id()const
{
return access_key_id_;
}
void SetTLSCipherPolicyAttributeRequest::setAccess_key_id(const std::string& access_key_id)
{
access_key_id_ = access_key_id;
setParameter("Access_key_id", access_key_id);
}
long SetTLSCipherPolicyAttributeRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void SetTLSCipherPolicyAttributeRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string SetTLSCipherPolicyAttributeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void SetTLSCipherPolicyAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string SetTLSCipherPolicyAttributeRequest::getTLSCipherPolicyId()const
{
return tLSCipherPolicyId_;
}
void SetTLSCipherPolicyAttributeRequest::setTLSCipherPolicyId(const std::string& tLSCipherPolicyId)
{
tLSCipherPolicyId_ = tLSCipherPolicyId;
setParameter("TLSCipherPolicyId", tLSCipherPolicyId);
}
std::string SetTLSCipherPolicyAttributeRequest::getRegionId()const
{
return regionId_;
}
void SetTLSCipherPolicyAttributeRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::vector<std::string> SetTLSCipherPolicyAttributeRequest::getCiphers()const
{
return ciphers_;
}
void SetTLSCipherPolicyAttributeRequest::setCiphers(const std::vector<std::string>& ciphers)
{
ciphers_ = ciphers;
for(int dep1 = 0; dep1!= ciphers.size(); dep1++) {
setParameter("Ciphers."+ std::to_string(dep1), ciphers.at(dep1));
}
}
std::vector<std::string> SetTLSCipherPolicyAttributeRequest::getTLSVersions()const
{
return tLSVersions_;
}
void SetTLSCipherPolicyAttributeRequest::setTLSVersions(const std::vector<std::string>& tLSVersions)
{
tLSVersions_ = tLSVersions;
for(int dep1 = 0; dep1!= tLSVersions.size(); dep1++) {
setParameter("TLSVersions."+ std::to_string(dep1), tLSVersions.at(dep1));
}
}
std::string SetTLSCipherPolicyAttributeRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void SetTLSCipherPolicyAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string SetTLSCipherPolicyAttributeRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void SetTLSCipherPolicyAttributeRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long SetTLSCipherPolicyAttributeRequest::getOwnerId()const
{
return ownerId_;
}
void SetTLSCipherPolicyAttributeRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string SetTLSCipherPolicyAttributeRequest::getName()const
{
return name_;
}
void SetTLSCipherPolicyAttributeRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}

51
slb/src/model/SetTLSCipherPolicyAttributeResult.cc Normal file
View File

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

11
slb/src/model/UploadCACertificateRequest.cc
View File

@@ -115,6 +115,17 @@ void UploadCACertificateRequest::setOwnerAccount(const std::string& ownerAccount
setParameter("OwnerAccount", ownerAccount);
}
std::string UploadCACertificateRequest::getStandardType()const
{
return standardType_;
}
void UploadCACertificateRequest::setStandardType(const std::string& standardType)
{
standardType_ = standardType;
setParameter("StandardType", standardType);
}
long UploadCACertificateRequest::getOwnerId()const
{
return ownerId_;

11
slb/src/model/UploadServerCertificateRequest.cc
View File

@@ -137,6 +137,17 @@ void UploadServerCertificateRequest::setOwnerAccount(const std::string& ownerAcc
setParameter("OwnerAccount", ownerAccount);
}
std::string UploadServerCertificateRequest::getStandardType()const
{
return standardType_;
}
void UploadServerCertificateRequest::setStandardType(const std::string& standardType)
{
standardType_ = standardType;
setParameter("StandardType", standardType);
}
long UploadServerCertificateRequest::getOwnerId()const
{
return ownerId_;