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

Add error code for ModifyInstanceNetworkSpec.

Browse Source
This commit is contained in:
sdk-team
2023-01-06 03:07:52 +00:00
parent 35aa024193
commit ac4c81dcb5
104 changed files with 1520 additions and 1099 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
ecs/src/EcsClient.cc
View File

@@ -31,21 +31,21 @@ EcsClient::EcsClient(const Credentials &credentials, const ClientConfiguration &
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "ecs");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
EcsClient::EcsClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "ecs");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
EcsClient::EcsClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "ecs");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
EcsClient::~EcsClient()
@@ -1275,42 +1275,6 @@ EcsClient::CreateCommandOutcomeCallable EcsClient::createCommandCallable(const C
return task->get_future();
}
EcsClient::CreateDedicatedBlockStorageClusterOutcome EcsClient::createDedicatedBlockStorageCluster(const CreateDedicatedBlockStorageClusterRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateDedicatedBlockStorageClusterOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateDedicatedBlockStorageClusterOutcome(CreateDedicatedBlockStorageClusterResult(outcome.result()));
else
return CreateDedicatedBlockStorageClusterOutcome(outcome.error());
}
void EcsClient::createDedicatedBlockStorageClusterAsync(const CreateDedicatedBlockStorageClusterRequest& request, const CreateDedicatedBlockStorageClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createDedicatedBlockStorageCluster(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::CreateDedicatedBlockStorageClusterOutcomeCallable EcsClient::createDedicatedBlockStorageClusterCallable(const CreateDedicatedBlockStorageClusterRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateDedicatedBlockStorageClusterOutcome()>>(
[this, request]()
{
return this->createDedicatedBlockStorageCluster(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::CreateDedicatedHostClusterOutcome EcsClient::createDedicatedHostCluster(const CreateDedicatedHostClusterRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4407,42 +4371,6 @@ EcsClient::DescribeCommandsOutcomeCallable EcsClient::describeCommandsCallable(c
return task->get_future();
}
EcsClient::DescribeDedicatedBlockStorageClustersOutcome EcsClient::describeDedicatedBlockStorageClusters(const DescribeDedicatedBlockStorageClustersRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeDedicatedBlockStorageClustersOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeDedicatedBlockStorageClustersOutcome(DescribeDedicatedBlockStorageClustersResult(outcome.result()));
else
return DescribeDedicatedBlockStorageClustersOutcome(outcome.error());
}
void EcsClient::describeDedicatedBlockStorageClustersAsync(const DescribeDedicatedBlockStorageClustersRequest& request, const DescribeDedicatedBlockStorageClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeDedicatedBlockStorageClusters(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::DescribeDedicatedBlockStorageClustersOutcomeCallable EcsClient::describeDedicatedBlockStorageClustersCallable(const DescribeDedicatedBlockStorageClustersRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeDedicatedBlockStorageClustersOutcome()>>(
[this, request]()
{
return this->describeDedicatedBlockStorageClusters(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::DescribeDedicatedHostAutoRenewOutcome EcsClient::describeDedicatedHostAutoRenew(const DescribeDedicatedHostAutoRenewRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4767,6 +4695,42 @@ EcsClient::DescribeDiagnosticMetricsOutcomeCallable EcsClient::describeDiagnosti
return task->get_future();
}
EcsClient::DescribeDiagnosticReportAttributesOutcome EcsClient::describeDiagnosticReportAttributes(const DescribeDiagnosticReportAttributesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeDiagnosticReportAttributesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeDiagnosticReportAttributesOutcome(DescribeDiagnosticReportAttributesResult(outcome.result()));
else
return DescribeDiagnosticReportAttributesOutcome(outcome.error());
}
void EcsClient::describeDiagnosticReportAttributesAsync(const DescribeDiagnosticReportAttributesRequest& request, const DescribeDiagnosticReportAttributesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeDiagnosticReportAttributes(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::DescribeDiagnosticReportAttributesOutcomeCallable EcsClient::describeDiagnosticReportAttributesCallable(const DescribeDiagnosticReportAttributesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeDiagnosticReportAttributesOutcome()>>(
[this, request]()
{
return this->describeDiagnosticReportAttributes(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::DescribeDiagnosticReportsOutcome EcsClient::describeDiagnosticReports(const DescribeDiagnosticReportsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

17
ecs/src/model/AssignIpv6AddressesRequest.cc
View File

@@ -34,6 +34,23 @@ void AssignIpv6AddressesRequest::setResourceOwnerId(long resourceOwnerId) {
setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
}
std::vector<std::string> AssignIpv6AddressesRequest::getIpv6Prefix() const {
return ipv6Prefix_;
}
void AssignIpv6AddressesRequest::setIpv6Prefix(const std::vector<std::string> &ipv6Prefix) {
ipv6Prefix_ = ipv6Prefix;
}
int AssignIpv6AddressesRequest::getIpv6PrefixCount() const {
return ipv6PrefixCount_;
}
void AssignIpv6AddressesRequest::setIpv6PrefixCount(int ipv6PrefixCount) {
ipv6PrefixCount_ = ipv6PrefixCount;
setParameter(std::string("Ipv6PrefixCount"), std::to_string(ipv6PrefixCount));
}
std::string AssignIpv6AddressesRequest::getRegionId() const {
return regionId_;
}

8
ecs/src/model/AssignIpv6AddressesResult.cc
View File

@@ -42,6 +42,9 @@ void AssignIpv6AddressesResult::parse(const std::string &payload)
auto allIpv6Sets = value["Ipv6Sets"]["Ipv6Address"];
for (const auto &item : allIpv6Sets)
ipv6Sets_.push_back(item.asString());
auto allIpv6PrefixSets = value["Ipv6PrefixSets"]["Ipv6Prefix"];
for (const auto &item : allIpv6PrefixSets)
ipv6PrefixSets_.push_back(item.asString());
if(!value["NetworkInterfaceId"].isNull())
networkInterfaceId_ = value["NetworkInterfaceId"].asString();
@@ -52,6 +55,11 @@ std::vector<std::string> AssignIpv6AddressesResult::getIpv6Sets()const
return ipv6Sets_;
}
std::vector<std::string> AssignIpv6AddressesResult::getIpv6PrefixSets()const
{
return ipv6PrefixSets_;
}
std::string AssignIpv6AddressesResult::getNetworkInterfaceId()const
{
return networkInterfaceId_;

17
ecs/src/model/AssignPrivateIpAddressesRequest.cc
View File

@@ -34,6 +34,14 @@ void AssignPrivateIpAddressesRequest::setResourceOwnerId(long resourceOwnerId) {
setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
}
std::vector<std::string> AssignPrivateIpAddressesRequest::getIpv4Prefix() const {
return ipv4Prefix_;
}
void AssignPrivateIpAddressesRequest::setIpv4Prefix(const std::vector<std::string> &ipv4Prefix) {
ipv4Prefix_ = ipv4Prefix;
}
std::string AssignPrivateIpAddressesRequest::getClientToken() const {
return clientToken_;
}
@@ -88,6 +96,15 @@ void AssignPrivateIpAddressesRequest::setOwnerId(long ownerId) {
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
int AssignPrivateIpAddressesRequest::getIpv4PrefixCount() const {
return ipv4PrefixCount_;
}
void AssignPrivateIpAddressesRequest::setIpv4PrefixCount(int ipv4PrefixCount) {
ipv4PrefixCount_ = ipv4PrefixCount;
setParameter(std::string("Ipv4PrefixCount"), std::to_string(ipv4PrefixCount));
}
std::vector<std::string> AssignPrivateIpAddressesRequest::getPrivateIpAddress() const {
return privateIpAddress_;
}

3
ecs/src/model/AssignPrivateIpAddressesResult.cc
View File

@@ -45,6 +45,9 @@ void AssignPrivateIpAddressesResult::parse(const std::string &payload)
auto allPrivateIpSet = assignedPrivateIpAddressesSetNode["PrivateIpSet"]["PrivateIpAddress"];
for (auto value : allPrivateIpSet)
assignedPrivateIpAddressesSet_.privateIpSet.push_back(value.asString());
auto allIpv4PrefixSet = assignedPrivateIpAddressesSetNode["Ipv4PrefixSet"]["Ipv4Prefixes"];
for (auto value : allIpv4PrefixSet)
assignedPrivateIpAddressesSet_.ipv4PrefixSet.push_back(value.asString());
}

9
ecs/src/model/AttachNetworkInterfaceRequest.cc
View File

@@ -88,6 +88,15 @@ void AttachNetworkInterfaceRequest::setOwnerId(long ownerId) {
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
int AttachNetworkInterfaceRequest::getNetworkCardIndex() const {
return networkCardIndex_;
}
void AttachNetworkInterfaceRequest::setNetworkCardIndex(int networkCardIndex) {
networkCardIndex_ = networkCardIndex;
setParameter(std::string("NetworkCardIndex"), std::to_string(networkCardIndex));
}
std::string AttachNetworkInterfaceRequest::getInstanceId() const {
return instanceId_;
}

33
ecs/src/model/CopySnapshotRequest.cc
View File

@@ -84,6 +84,21 @@ void CopySnapshotRequest::setTag(const std::vector<CopySnapshotRequest::Tag> &ta
}
}
std::vector<CopySnapshotRequest::Arn> CopySnapshotRequest::getArn() const {
return arn_;
}
void CopySnapshotRequest::setArn(const std::vector<CopySnapshotRequest::Arn> &arn) {
arn_ = arn;
for(int dep1 = 0; dep1 != arn.size(); dep1++) {
auto arnObj = arn.at(dep1);
std::string arnObjStr = std::string("Arn") + "." + std::to_string(dep1 + 1);
setParameter(arnObjStr + ".RoleType", arnObj.roleType);
setParameter(arnObjStr + ".Rolearn", arnObj.rolearn);
setParameter(arnObjStr + ".AssumeRoleFor", std::to_string(arnObj.assumeRoleFor));
}
}
std::string CopySnapshotRequest::getResourceOwnerAccount() const {
return resourceOwnerAccount_;
}
@@ -120,6 +135,15 @@ void CopySnapshotRequest::setDestinationSnapshotDescription(const std::string &d
setParameter(std::string("DestinationSnapshotDescription"), destinationSnapshotDescription);
}
bool CopySnapshotRequest::getEncrypted() const {
return encrypted_;
}
void CopySnapshotRequest::setEncrypted(bool encrypted) {
encrypted_ = encrypted;
setParameter(std::string("Encrypted"), encrypted ? "true" : "false");
}
int CopySnapshotRequest::getRetentionDays() const {
return retentionDays_;
}
@@ -129,3 +153,12 @@ void CopySnapshotRequest::setRetentionDays(int retentionDays) {
setParameter(std::string("RetentionDays"), std::to_string(retentionDays));
}
std::string CopySnapshotRequest::getKMSKeyId() const {
return kMSKeyId_;
}
void CopySnapshotRequest::setKMSKeyId(const std::string &kMSKeyId) {
kMSKeyId_ = kMSKeyId;
setParameter(std::string("KMSKeyId"), kMSKeyId);
}

9
ecs/src/model/CreateAutoSnapshotPolicyRequest.cc
View File

@@ -79,6 +79,15 @@ void CreateAutoSnapshotPolicyRequest::setRegionId(const std::string &regionId) {
setParameter(std::string("regionId"), regionId);
}
std::string CreateAutoSnapshotPolicyRequest::getStorageLocationArn() const {
return storageLocationArn_;
}
void CreateAutoSnapshotPolicyRequest::setStorageLocationArn(const std::string &storageLocationArn) {
storageLocationArn_ = storageLocationArn;
setParameter(std::string("StorageLocationArn"), storageLocationArn);
}
std::vector<CreateAutoSnapshotPolicyRequest::Tag> CreateAutoSnapshotPolicyRequest::getTag() const {
return tag_;
}

29
ecs/src/model/CreateCommandRequest.cc
View File

@@ -34,6 +34,21 @@ void CreateCommandRequest::setResourceOwnerId(long resourceOwnerId) {
setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
}
std::vector<CreateCommandRequest::SystemTag> CreateCommandRequest::getSystemTag() const {
return systemTag_;
}
void CreateCommandRequest::setSystemTag(const std::vector<CreateCommandRequest::SystemTag> &systemTag) {
systemTag_ = systemTag;
for(int dep1 = 0; dep1 != systemTag.size(); dep1++) {
auto systemTagObj = systemTag.at(dep1);
std::string systemTagObjStr = std::string("SystemTag") + "." + std::to_string(dep1 + 1);
setParameter(systemTagObjStr + ".Key", systemTagObj.key);
setParameter(systemTagObjStr + ".Value", systemTagObj.value);
setParameter(systemTagObjStr + ".Scope", systemTagObj.scope);
}
}
std::string CreateCommandRequest::getWorkingDir() const {
return workingDir_;
}
@@ -97,6 +112,20 @@ void CreateCommandRequest::setContentEncoding(const std::string &contentEncoding
setParameter(std::string("ContentEncoding"), contentEncoding);
}
std::vector<CreateCommandRequest::Tag> CreateCommandRequest::getTag() const {
return tag_;
}
void CreateCommandRequest::setTag(const std::vector<CreateCommandRequest::Tag> &tag) {
tag_ = tag;
for(int dep1 = 0; dep1 != tag.size(); dep1++) {
auto tagObj = tag.at(dep1);
std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
setParameter(tagObjStr + ".Key", tagObj.key);
setParameter(tagObjStr + ".Value", tagObj.value);
}
}
std::string CreateCommandRequest::getResourceOwnerAccount() const {
return resourceOwnerAccount_;
}

162
ecs/src/model/CreateDedicatedBlockStorageClusterRequest.cc
View File

@@ -1,162 +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/ecs/model/CreateDedicatedBlockStorageClusterRequest.h>
using AlibabaCloud::Ecs::Model::CreateDedicatedBlockStorageClusterRequest;
CreateDedicatedBlockStorageClusterRequest::CreateDedicatedBlockStorageClusterRequest()
: RpcServiceRequest("ecs", "2014-05-26", "CreateDedicatedBlockStorageCluster") {
setMethod(HttpRequest::Method::Post);
}
CreateDedicatedBlockStorageClusterRequest::~CreateDedicatedBlockStorageClusterRequest() {}
long CreateDedicatedBlockStorageClusterRequest::getResourceOwnerId() const {
return resourceOwnerId_;
}
void CreateDedicatedBlockStorageClusterRequest::setResourceOwnerId(long resourceOwnerId) {
resourceOwnerId_ = resourceOwnerId;
setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
}
std::string CreateDedicatedBlockStorageClusterRequest::getDedicatedBlockStorageClusterName() const {
return dedicatedBlockStorageClusterName_;
}
void CreateDedicatedBlockStorageClusterRequest::setDedicatedBlockStorageClusterName(const std::string &dedicatedBlockStorageClusterName) {
dedicatedBlockStorageClusterName_ = dedicatedBlockStorageClusterName;
setParameter(std::string("DedicatedBlockStorageClusterName"), dedicatedBlockStorageClusterName);
}
std::string CreateDedicatedBlockStorageClusterRequest::getClientToken() const {
return clientToken_;
}
void CreateDedicatedBlockStorageClusterRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
std::string CreateDedicatedBlockStorageClusterRequest::getDescription() const {
return description_;
}
void CreateDedicatedBlockStorageClusterRequest::setDescription(const std::string &description) {
description_ = description;
setParameter(std::string("Description"), description);
}
std::string CreateDedicatedBlockStorageClusterRequest::getType() const {
return type_;
}
void CreateDedicatedBlockStorageClusterRequest::setType(const std::string &type) {
type_ = type;
setParameter(std::string("Type"), type);
}
int CreateDedicatedBlockStorageClusterRequest::getCapacity() const {
return capacity_;
}
void CreateDedicatedBlockStorageClusterRequest::setCapacity(int capacity) {
capacity_ = capacity;
setParameter(std::string("Capacity"), std::to_string(capacity));
}
std::string CreateDedicatedBlockStorageClusterRequest::getRegionId() const {
return regionId_;
}
void CreateDedicatedBlockStorageClusterRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
int CreateDedicatedBlockStorageClusterRequest::getPeriod() const {
return period_;
}
void CreateDedicatedBlockStorageClusterRequest::setPeriod(int period) {
period_ = period;
setParameter(std::string("Period"), std::to_string(period));
}
std::string CreateDedicatedBlockStorageClusterRequest::getFromApp() const {
return fromApp_;
}
void CreateDedicatedBlockStorageClusterRequest::setFromApp(const std::string &fromApp) {
fromApp_ = fromApp;
setParameter(std::string("FromApp"), fromApp);
}
std::string CreateDedicatedBlockStorageClusterRequest::getResourceOwnerAccount() const {
return resourceOwnerAccount_;
}
void CreateDedicatedBlockStorageClusterRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
}
std::string CreateDedicatedBlockStorageClusterRequest::getOwnerAccount() const {
return ownerAccount_;
}
void CreateDedicatedBlockStorageClusterRequest::setOwnerAccount(const std::string &ownerAccount) {
ownerAccount_ = ownerAccount;
setParameter(std::string("OwnerAccount"), ownerAccount);
}
long CreateDedicatedBlockStorageClusterRequest::getOwnerId() const {
return ownerId_;
}
void CreateDedicatedBlockStorageClusterRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::string CreateDedicatedBlockStorageClusterRequest::getPeriodUnit() const {
return periodUnit_;
}
void CreateDedicatedBlockStorageClusterRequest::setPeriodUnit(const std::string &periodUnit) {
periodUnit_ = periodUnit;
setParameter(std::string("PeriodUnit"), periodUnit);
}
std::string CreateDedicatedBlockStorageClusterRequest::getZoneId() const {
return zoneId_;
}
void CreateDedicatedBlockStorageClusterRequest::setZoneId(const std::string &zoneId) {
zoneId_ = zoneId;
setParameter(std::string("ZoneId"), zoneId);
}
std::string CreateDedicatedBlockStorageClusterRequest::getCategory() const {
return category_;
}
void CreateDedicatedBlockStorageClusterRequest::setCategory(const std::string &category) {
category_ = category;
setParameter(std::string("Category"), category);
}

58
ecs/src/model/CreateDedicatedBlockStorageClusterResult.cc
View File

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

223
ecs/src/model/CreateDiskRequest.cc
View File

@@ -34,24 +34,6 @@ void CreateDiskRequest::setResourceOwnerId(long resourceOwnerId) {
setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
}
std::string CreateDiskRequest::getSnapshotId() const {
return snapshotId_;
}
void CreateDiskRequest::setSnapshotId(const std::string &snapshotId) {
snapshotId_ = snapshotId;
setParameter(std::string("SnapshotId"), snapshotId);
}
std::string CreateDiskRequest::getClientToken() const {
return clientToken_;
}
void CreateDiskRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
std::string CreateDiskRequest::getEncryptAlgorithm() const {
return encryptAlgorithm_;
}
@@ -61,15 +43,6 @@ void CreateDiskRequest::setEncryptAlgorithm(const std::string &encryptAlgorithm)
setParameter(std::string("EncryptAlgorithm"), encryptAlgorithm);
}
std::string CreateDiskRequest::getDescription() const {
return description_;
}
void CreateDiskRequest::setDescription(const std::string &description) {
description_ = description;
setParameter(std::string("Description"), description);
}
std::string CreateDiskRequest::getDiskName() const {
return diskName_;
}
@@ -88,6 +61,125 @@ void CreateDiskRequest::setResourceGroupId(const std::string &resourceGroupId) {
setParameter(std::string("ResourceGroupId"), resourceGroupId);
}
int CreateDiskRequest::getStorageSetPartitionNumber() const {
return storageSetPartitionNumber_;
}
void CreateDiskRequest::setStorageSetPartitionNumber(int storageSetPartitionNumber) {
storageSetPartitionNumber_ = storageSetPartitionNumber;
setParameter(std::string("StorageSetPartitionNumber"), std::to_string(storageSetPartitionNumber));
}
std::vector<CreateDiskRequest::Tag> CreateDiskRequest::getTag() const {
return tag_;
}
void CreateDiskRequest::setTag(const std::vector<CreateDiskRequest::Tag> &tag) {
tag_ = tag;
for(int dep1 = 0; dep1 != tag.size(); dep1++) {
auto tagObj = tag.at(dep1);
std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
setParameter(tagObjStr + ".Value", tagObj.value);
setParameter(tagObjStr + ".Key", tagObj.key);
}
}
long CreateDiskRequest::getOwnerId() const {
return ownerId_;
}
void CreateDiskRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
long CreateDiskRequest::getProvisionedIops() const {
return provisionedIops_;
}
void CreateDiskRequest::setProvisionedIops(long provisionedIops) {
provisionedIops_ = provisionedIops;
setParameter(std::string("ProvisionedIops"), std::to_string(provisionedIops));
}
std::string CreateDiskRequest::getInstanceId() const {
return instanceId_;
}
void CreateDiskRequest::setInstanceId(const std::string &instanceId) {
instanceId_ = instanceId;
setParameter(std::string("InstanceId"), instanceId);
}
int CreateDiskRequest::getSize() const {
return size_;
}
void CreateDiskRequest::setSize(int size) {
size_ = size;
setParameter(std::string("Size"), std::to_string(size));
}
std::string CreateDiskRequest::getZoneId() const {
return zoneId_;
}
void CreateDiskRequest::setZoneId(const std::string &zoneId) {
zoneId_ = zoneId;
setParameter(std::string("ZoneId"), zoneId);
}
std::string CreateDiskRequest::getStorageClusterId() const {
return storageClusterId_;
}
void CreateDiskRequest::setStorageClusterId(const std::string &storageClusterId) {
storageClusterId_ = storageClusterId;
setParameter(std::string("StorageClusterId"), storageClusterId);
}
std::string CreateDiskRequest::getSnapshotId() const {
return snapshotId_;
}
void CreateDiskRequest::setSnapshotId(const std::string &snapshotId) {
snapshotId_ = snapshotId;
setParameter(std::string("SnapshotId"), snapshotId);
}
std::string CreateDiskRequest::getClientToken() const {
return clientToken_;
}
void CreateDiskRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
std::vector<CreateDiskRequest::SystemTag> CreateDiskRequest::getSystemTag() const {
return systemTag_;
}
void CreateDiskRequest::setSystemTag(const std::vector<CreateDiskRequest::SystemTag> &systemTag) {
systemTag_ = systemTag;
for(int dep1 = 0; dep1 != systemTag.size(); dep1++) {
auto systemTagObj = systemTag.at(dep1);
std::string systemTagObjStr = std::string("SystemTag") + "." + std::to_string(dep1 + 1);
setParameter(systemTagObjStr + ".Scope", systemTagObj.scope);
setParameter(systemTagObjStr + ".Value", systemTagObj.value);
setParameter(systemTagObjStr + ".Key", systemTagObj.key);
}
}
std::string CreateDiskRequest::getDescription() const {
return description_;
}
void CreateDiskRequest::setDescription(const std::string &description) {
description_ = description;
setParameter(std::string("Description"), description);
}
std::string CreateDiskRequest::getRegionId() const {
return regionId_;
}
@@ -106,15 +198,6 @@ void CreateDiskRequest::setDiskCategory(const std::string &diskCategory) {
setParameter(std::string("DiskCategory"), diskCategory);
}
int CreateDiskRequest::getStorageSetPartitionNumber() const {
return storageSetPartitionNumber_;
}
void CreateDiskRequest::setStorageSetPartitionNumber(int storageSetPartitionNumber) {
storageSetPartitionNumber_ = storageSetPartitionNumber;
setParameter(std::string("StorageSetPartitionNumber"), std::to_string(storageSetPartitionNumber));
}
std::string CreateDiskRequest::getMultiAttach() const {
return multiAttach_;
}
@@ -124,20 +207,6 @@ void CreateDiskRequest::setMultiAttach(const std::string &multiAttach) {
setParameter(std::string("MultiAttach"), multiAttach);
}
std::vector<CreateDiskRequest::Tag> CreateDiskRequest::getTag() const {
return tag_;
}
void CreateDiskRequest::setTag(const std::vector<CreateDiskRequest::Tag> &tag) {
tag_ = tag;
for(int dep1 = 0; dep1 != tag.size(); dep1++) {
auto tagObj = tag.at(dep1);
std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
setParameter(tagObjStr + ".Value", tagObj.value);
setParameter(tagObjStr + ".Key", tagObj.key);
}
}
std::string CreateDiskRequest::getAdvancedFeatures() const {
return advancedFeatures_;
}
@@ -189,15 +258,6 @@ void CreateDiskRequest::setOwnerAccount(const std::string &ownerAccount) {
setParameter(std::string("OwnerAccount"), ownerAccount);
}
long CreateDiskRequest::getOwnerId() const {
return ownerId_;
}
void CreateDiskRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
bool CreateDiskRequest::getBurstingEnabled() const {
return burstingEnabled_;
}
@@ -207,24 +267,6 @@ void CreateDiskRequest::setBurstingEnabled(bool burstingEnabled) {
setParameter(std::string("BurstingEnabled"), burstingEnabled ? "true" : "false");
}
long CreateDiskRequest::getProvisionedIops() const {
return provisionedIops_;
}
void CreateDiskRequest::setProvisionedIops(long provisionedIops) {
provisionedIops_ = provisionedIops;
setParameter(std::string("ProvisionedIops"), std::to_string(provisionedIops));
}
std::string CreateDiskRequest::getInstanceId() const {
return instanceId_;
}
void CreateDiskRequest::setInstanceId(const std::string &instanceId) {
instanceId_ = instanceId;
setParameter(std::string("InstanceId"), instanceId);
}
std::string CreateDiskRequest::getStorageSetId() const {
return storageSetId_;
}
@@ -234,15 +276,6 @@ void CreateDiskRequest::setStorageSetId(const std::string &storageSetId) {
setParameter(std::string("StorageSetId"), storageSetId);
}
int CreateDiskRequest::getSize() const {
return size_;
}
void CreateDiskRequest::setSize(int size) {
size_ = size;
setParameter(std::string("Size"), std::to_string(size));
}
bool CreateDiskRequest::getEncrypted() const {
return encrypted_;
}
@@ -252,24 +285,6 @@ void CreateDiskRequest::setEncrypted(bool encrypted) {
setParameter(std::string("Encrypted"), encrypted ? "true" : "false");
}
std::string CreateDiskRequest::getZoneId() const {
return zoneId_;
}
void CreateDiskRequest::setZoneId(const std::string &zoneId) {
zoneId_ = zoneId;
setParameter(std::string("ZoneId"), zoneId);
}
std::string CreateDiskRequest::getStorageClusterId() const {
return storageClusterId_;
}
void CreateDiskRequest::setStorageClusterId(const std::string &storageClusterId) {
storageClusterId_ = storageClusterId;
setParameter(std::string("StorageClusterId"), storageClusterId);
}
std::string CreateDiskRequest::getKMSKeyId() const {
return kMSKeyId_;
}

33
ecs/src/model/CreateImageRequest.cc
View File

@@ -68,6 +68,21 @@ void CreateImageRequest::setClientToken(const std::string &clientToken) {
setParameter(std::string("ClientToken"), clientToken);
}
std::vector<CreateImageRequest::SystemTag> CreateImageRequest::getSystemTag() const {
return systemTag_;
}
void CreateImageRequest::setSystemTag(const std::vector<CreateImageRequest::SystemTag> &systemTag) {
systemTag_ = systemTag;
for(int dep1 = 0; dep1 != systemTag.size(); dep1++) {
auto systemTagObj = systemTag.at(dep1);
std::string systemTagObjStr = std::string("SystemTag") + "." + std::to_string(dep1 + 1);
setParameter(systemTagObjStr + ".Scope", systemTagObj.scope);
setParameter(systemTagObjStr + ".Value", systemTagObj.value);
setParameter(systemTagObjStr + ".Key", systemTagObj.key);
}
}
std::string CreateImageRequest::getDescription() const {
return description_;
}
@@ -122,6 +137,15 @@ void CreateImageRequest::setImageName(const std::string &imageName) {
setParameter(std::string("ImageName"), imageName);
}
std::string CreateImageRequest::getStorageLocationArn() const {
return storageLocationArn_;
}
void CreateImageRequest::setStorageLocationArn(const std::string &storageLocationArn) {
storageLocationArn_ = storageLocationArn;
setParameter(std::string("StorageLocationArn"), storageLocationArn);
}
std::vector<CreateImageRequest::Tag> CreateImageRequest::getTag() const {
return tag_;
}
@@ -145,6 +169,15 @@ void CreateImageRequest::setArchitecture(const std::string &architecture) {
setParameter(std::string("Architecture"), architecture);
}
std::string CreateImageRequest::getDetectionStrategy() const {
return detectionStrategy_;
}
void CreateImageRequest::setDetectionStrategy(const std::string &detectionStrategy) {
detectionStrategy_ = detectionStrategy;
setParameter(std::string("DetectionStrategy"), detectionStrategy);
}
std::string CreateImageRequest::getResourceOwnerAccount() const {
return resourceOwnerAccount_;
}

9
ecs/src/model/CreateLaunchTemplateRequest.cc
View File

@@ -545,3 +545,12 @@ void CreateLaunchTemplateRequest::setSystemDiskDescription(const std::string &sy
setParameter(std::string("SystemDisk.Description"), systemDiskDescription);
}
std::string CreateLaunchTemplateRequest::getSystemDiskEncrypted() const {
return systemDiskEncrypted_;
}
void CreateLaunchTemplateRequest::setSystemDiskEncrypted(const std::string &systemDiskEncrypted) {
systemDiskEncrypted_ = systemDiskEncrypted;
setParameter(std::string("SystemDisk.Encrypted"), systemDiskEncrypted);
}

9
ecs/src/model/CreateLaunchTemplateVersionRequest.cc
View File

@@ -531,3 +531,12 @@ void CreateLaunchTemplateVersionRequest::setSystemDiskDescription(const std::str
setParameter(std::string("SystemDisk.Description"), systemDiskDescription);
}
std::string CreateLaunchTemplateVersionRequest::getSystemDiskEncrypted() const {
return systemDiskEncrypted_;
}
void CreateLaunchTemplateVersionRequest::setSystemDiskEncrypted(const std::string &systemDiskEncrypted) {
systemDiskEncrypted_ = systemDiskEncrypted;
setParameter(std::string("SystemDisk.Encrypted"), systemDiskEncrypted);
}

194
ecs/src/model/CreateNetworkInterfaceRequest.cc
View File

@@ -43,31 +43,12 @@ void CreateNetworkInterfaceRequest::setResourceOwnerId(long resourceOwnerId) {
setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
}
std::string CreateNetworkInterfaceRequest::getClientToken() const {
return clientToken_;
std::vector<std::string> CreateNetworkInterfaceRequest::getIpv4Prefix() const {
return ipv4Prefix_;
}
void CreateNetworkInterfaceRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
std::string CreateNetworkInterfaceRequest::getSecurityGroupId() const {
return securityGroupId_;
}
void CreateNetworkInterfaceRequest::setSecurityGroupId(const std::string &securityGroupId) {
securityGroupId_ = securityGroupId;
setParameter(std::string("SecurityGroupId"), securityGroupId);
}
std::string CreateNetworkInterfaceRequest::getDescription() const {
return description_;
}
void CreateNetworkInterfaceRequest::setDescription(const std::string &description) {
description_ = description;
setParameter(std::string("Description"), description);
void CreateNetworkInterfaceRequest::setIpv4Prefix(const std::vector<std::string> &ipv4Prefix) {
ipv4Prefix_ = ipv4Prefix;
}
int CreateNetworkInterfaceRequest::getSecondaryPrivateIpAddressCount() const {
@@ -97,24 +78,6 @@ void CreateNetworkInterfaceRequest::setResourceGroupId(const std::string &resour
setParameter(std::string("ResourceGroupId"), resourceGroupId);
}
std::string CreateNetworkInterfaceRequest::getRegionId() const {
return regionId_;
}
void CreateNetworkInterfaceRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
std::string CreateNetworkInterfaceRequest::getInstanceType() const {
return instanceType_;
}
void CreateNetworkInterfaceRequest::setInstanceType(const std::string &instanceType) {
instanceType_ = instanceType;
setParameter(std::string("InstanceType"), instanceType);
}
std::vector<CreateNetworkInterfaceRequest::Tag> CreateNetworkInterfaceRequest::getTag() const {
return tag_;
}
@@ -147,15 +110,6 @@ void CreateNetworkInterfaceRequest::setVisible(bool visible) {
setParameter(std::string("Visible"), visible ? "true" : "false");
}
std::string CreateNetworkInterfaceRequest::getResourceOwnerAccount() const {
return resourceOwnerAccount_;
}
void CreateNetworkInterfaceRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
}
int CreateNetworkInterfaceRequest::getIpv6AddressCount() const {
return ipv6AddressCount_;
}
@@ -165,6 +119,111 @@ void CreateNetworkInterfaceRequest::setIpv6AddressCount(int ipv6AddressCount) {
setParameter(std::string("Ipv6AddressCount"), std::to_string(ipv6AddressCount));
}
long CreateNetworkInterfaceRequest::getOwnerId() const {
return ownerId_;
}
void CreateNetworkInterfaceRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::string CreateNetworkInterfaceRequest::getVSwitchId() const {
return vSwitchId_;
}
void CreateNetworkInterfaceRequest::setVSwitchId(const std::string &vSwitchId) {
vSwitchId_ = vSwitchId;
setParameter(std::string("VSwitchId"), vSwitchId);
}
std::vector<std::string> CreateNetworkInterfaceRequest::getPrivateIpAddress() const {
return privateIpAddress_;
}
void CreateNetworkInterfaceRequest::setPrivateIpAddress(const std::vector<std::string> &privateIpAddress) {
privateIpAddress_ = privateIpAddress;
}
std::vector<std::string> CreateNetworkInterfaceRequest::getIpv6Address() const {
return ipv6Address_;
}
void CreateNetworkInterfaceRequest::setIpv6Address(const std::vector<std::string> &ipv6Address) {
ipv6Address_ = ipv6Address;
}
std::string CreateNetworkInterfaceRequest::getClientToken() const {
return clientToken_;
}
void CreateNetworkInterfaceRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
std::vector<std::string> CreateNetworkInterfaceRequest::getIpv6Prefix() const {
return ipv6Prefix_;
}
void CreateNetworkInterfaceRequest::setIpv6Prefix(const std::vector<std::string> &ipv6Prefix) {
ipv6Prefix_ = ipv6Prefix;
}
std::string CreateNetworkInterfaceRequest::getSecurityGroupId() const {
return securityGroupId_;
}
void CreateNetworkInterfaceRequest::setSecurityGroupId(const std::string &securityGroupId) {
securityGroupId_ = securityGroupId;
setParameter(std::string("SecurityGroupId"), securityGroupId);
}
std::string CreateNetworkInterfaceRequest::getDescription() const {
return description_;
}
void CreateNetworkInterfaceRequest::setDescription(const std::string &description) {
description_ = description;
setParameter(std::string("Description"), description);
}
int CreateNetworkInterfaceRequest::getIpv6PrefixCount() const {
return ipv6PrefixCount_;
}
void CreateNetworkInterfaceRequest::setIpv6PrefixCount(int ipv6PrefixCount) {
ipv6PrefixCount_ = ipv6PrefixCount;
setParameter(std::string("Ipv6PrefixCount"), std::to_string(ipv6PrefixCount));
}
std::string CreateNetworkInterfaceRequest::getRegionId() const {
return regionId_;
}
void CreateNetworkInterfaceRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
std::string CreateNetworkInterfaceRequest::getInstanceType() const {
return instanceType_;
}
void CreateNetworkInterfaceRequest::setInstanceType(const std::string &instanceType) {
instanceType_ = instanceType;
setParameter(std::string("InstanceType"), instanceType);
}
std::string CreateNetworkInterfaceRequest::getResourceOwnerAccount() const {
return resourceOwnerAccount_;
}
void CreateNetworkInterfaceRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
}
std::string CreateNetworkInterfaceRequest::getOwnerAccount() const {
return ownerAccount_;
}
@@ -183,15 +242,6 @@ void CreateNetworkInterfaceRequest::setQueuePairNumber(int queuePairNumber) {
setParameter(std::string("QueuePairNumber"), std::to_string(queuePairNumber));
}
long CreateNetworkInterfaceRequest::getOwnerId() const {
return ownerId_;
}
void CreateNetworkInterfaceRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::vector<std::string> CreateNetworkInterfaceRequest::getSecurityGroupIds() const {
return securityGroupIds_;
}
@@ -209,21 +259,13 @@ void CreateNetworkInterfaceRequest::setNetworkInterfaceTrafficMode(const std::st
setParameter(std::string("NetworkInterfaceTrafficMode"), networkInterfaceTrafficMode);
}
std::string CreateNetworkInterfaceRequest::getVSwitchId() const {
return vSwitchId_;
int CreateNetworkInterfaceRequest::getIpv4PrefixCount() const {
return ipv4PrefixCount_;
}
void CreateNetworkInterfaceRequest::setVSwitchId(const std::string &vSwitchId) {
vSwitchId_ = vSwitchId;
setParameter(std::string("VSwitchId"), vSwitchId);
}
std::vector<std::string> CreateNetworkInterfaceRequest::getPrivateIpAddress() const {
return privateIpAddress_;
}
void CreateNetworkInterfaceRequest::setPrivateIpAddress(const std::vector<std::string> &privateIpAddress) {
privateIpAddress_ = privateIpAddress;
void CreateNetworkInterfaceRequest::setIpv4PrefixCount(int ipv4PrefixCount) {
ipv4PrefixCount_ = ipv4PrefixCount;
setParameter(std::string("Ipv4PrefixCount"), std::to_string(ipv4PrefixCount));
}
std::string CreateNetworkInterfaceRequest::getPrimaryIpAddress() const {
@@ -235,11 +277,3 @@ void CreateNetworkInterfaceRequest::setPrimaryIpAddress(const std::string &prima
setParameter(std::string("PrimaryIpAddress"), primaryIpAddress);
}
std::vector<std::string> CreateNetworkInterfaceRequest::getIpv6Address() const {
return ipv6Address_;
}
void CreateNetworkInterfaceRequest::setIpv6Address(const std::vector<std::string> &ipv6Address) {
ipv6Address_ = ipv6Address;
}

26
ecs/src/model/CreateNetworkInterfaceResult.cc
View File

@@ -67,6 +67,22 @@ void CreateNetworkInterfaceResult::parse(const std::string &payload)
ipv6SetsObject.ipv6Address = valueIpv6SetsIpv6Set["Ipv6Address"].asString();
ipv6Sets_.push_back(ipv6SetsObject);
}
auto allIpv4PrefixSetsNode = value["Ipv4PrefixSets"]["Ipv4PrefixSet"];
for (auto valueIpv4PrefixSetsIpv4PrefixSet : allIpv4PrefixSetsNode)
{
Ipv4PrefixSet ipv4PrefixSetsObject;
if(!valueIpv4PrefixSetsIpv4PrefixSet["Ipv4Prefix"].isNull())
ipv4PrefixSetsObject.ipv4Prefix = valueIpv4PrefixSetsIpv4PrefixSet["Ipv4Prefix"].asString();
ipv4PrefixSets_.push_back(ipv4PrefixSetsObject);
}
auto allIpv6PrefixSetsNode = value["Ipv6PrefixSets"]["Ipv6PrefixSet"];
for (auto valueIpv6PrefixSetsIpv6PrefixSet : allIpv6PrefixSetsNode)
{
Ipv6PrefixSet ipv6PrefixSetsObject;
if(!valueIpv6PrefixSetsIpv6PrefixSet["Ipv6Prefix"].isNull())
ipv6PrefixSetsObject.ipv6Prefix = valueIpv6PrefixSetsIpv6PrefixSet["Ipv6Prefix"].asString();
ipv6PrefixSets_.push_back(ipv6PrefixSetsObject);
}
auto allSecurityGroupIds = value["SecurityGroupIds"]["SecurityGroupId"];
for (const auto &item : allSecurityGroupIds)
securityGroupIds_.push_back(item.asString());
@@ -181,11 +197,21 @@ std::string CreateNetworkInterfaceResult::getOwnerId()const
return ownerId_;
}
std::vector<CreateNetworkInterfaceResult::Ipv6PrefixSet> CreateNetworkInterfaceResult::getIpv6PrefixSets()const
{
return ipv6PrefixSets_;
}
std::vector<CreateNetworkInterfaceResult::Tag> CreateNetworkInterfaceResult::getTags()const
{
return tags_;
}
std::vector<CreateNetworkInterfaceResult::Ipv4PrefixSet> CreateNetworkInterfaceResult::getIpv4PrefixSets()const
{
return ipv4PrefixSets_;
}
std::vector<CreateNetworkInterfaceResult::PrivateIpSet> CreateNetworkInterfaceResult::getPrivateIpSets()const
{
return privateIpSets_;

9
ecs/src/model/CreateSnapshotGroupRequest.cc
View File

@@ -87,6 +87,15 @@ void CreateSnapshotGroupRequest::setRegionId(const std::string &regionId) {
setParameter(std::string("RegionId"), regionId);
}
std::string CreateSnapshotGroupRequest::getStorageLocationArn() const {
return storageLocationArn_;
}
void CreateSnapshotGroupRequest::setStorageLocationArn(const std::string &storageLocationArn) {
storageLocationArn_ = storageLocationArn;
setParameter(std::string("StorageLocationArn"), storageLocationArn);
}
std::vector<std::string> CreateSnapshotGroupRequest::getDiskId() const {
return diskId_;
}

24
ecs/src/model/CreateSnapshotRequest.cc
View File

@@ -52,6 +52,21 @@ void CreateSnapshotRequest::setInstantAccess(bool instantAccess) {
setParameter(std::string("InstantAccess"), instantAccess ? "true" : "false");
}
std::vector<CreateSnapshotRequest::SystemTag> CreateSnapshotRequest::getSystemTag() const {
return systemTag_;
}
void CreateSnapshotRequest::setSystemTag(const std::vector<CreateSnapshotRequest::SystemTag> &systemTag) {
systemTag_ = systemTag;
for(int dep1 = 0; dep1 != systemTag.size(); dep1++) {
auto systemTagObj = systemTag.at(dep1);
std::string systemTagObjStr = std::string("SystemTag") + "." + std::to_string(dep1 + 1);
setParameter(systemTagObjStr + ".Scope", systemTagObj.scope);
setParameter(systemTagObjStr + ".Value", systemTagObj.value);
setParameter(systemTagObjStr + ".Key", systemTagObj.key);
}
}
std::string CreateSnapshotRequest::getDescription() const {
return description_;
}
@@ -88,6 +103,15 @@ void CreateSnapshotRequest::setInstantAccessRetentionDays(int instantAccessReten
setParameter(std::string("InstantAccessRetentionDays"), std::to_string(instantAccessRetentionDays));
}
std::string CreateSnapshotRequest::getStorageLocationArn() const {
return storageLocationArn_;
}
void CreateSnapshotRequest::setStorageLocationArn(const std::string &storageLocationArn) {
storageLocationArn_ = storageLocationArn;
setParameter(std::string("StorageLocationArn"), storageLocationArn);
}
std::string CreateSnapshotRequest::getDiskId() const {
return diskId_;
}

124
ecs/src/model/DescribeDedicatedBlockStorageClustersRequest.cc
View File

@@ -1,124 +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/ecs/model/DescribeDedicatedBlockStorageClustersRequest.h>
using AlibabaCloud::Ecs::Model::DescribeDedicatedBlockStorageClustersRequest;
DescribeDedicatedBlockStorageClustersRequest::DescribeDedicatedBlockStorageClustersRequest()
: RpcServiceRequest("ecs", "2014-05-26", "DescribeDedicatedBlockStorageClusters") {
setMethod(HttpRequest::Method::Post);
}
DescribeDedicatedBlockStorageClustersRequest::~DescribeDedicatedBlockStorageClustersRequest() {}
long DescribeDedicatedBlockStorageClustersRequest::getResourceOwnerId() const {
return resourceOwnerId_;
}
void DescribeDedicatedBlockStorageClustersRequest::setResourceOwnerId(long resourceOwnerId) {
resourceOwnerId_ = resourceOwnerId;
setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
}
std::string DescribeDedicatedBlockStorageClustersRequest::getRegionId() const {
return regionId_;
}
void DescribeDedicatedBlockStorageClustersRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
std::string DescribeDedicatedBlockStorageClustersRequest::getNextToken() const {
return nextToken_;
}
void DescribeDedicatedBlockStorageClustersRequest::setNextToken(const std::string &nextToken) {
nextToken_ = nextToken;
setParameter(std::string("NextToken"), nextToken);
}
std::vector<std::string> DescribeDedicatedBlockStorageClustersRequest::getDedicatedBlockStorageClusterId() const {
return dedicatedBlockStorageClusterId_;
}
void DescribeDedicatedBlockStorageClustersRequest::setDedicatedBlockStorageClusterId(const std::vector<std::string> &dedicatedBlockStorageClusterId) {
dedicatedBlockStorageClusterId_ = dedicatedBlockStorageClusterId;
}
std::string DescribeDedicatedBlockStorageClustersRequest::getResourceOwnerAccount() const {
return resourceOwnerAccount_;
}
void DescribeDedicatedBlockStorageClustersRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
}
std::string DescribeDedicatedBlockStorageClustersRequest::getOwnerAccount() const {
return ownerAccount_;
}
void DescribeDedicatedBlockStorageClustersRequest::setOwnerAccount(const std::string &ownerAccount) {
ownerAccount_ = ownerAccount;
setParameter(std::string("OwnerAccount"), ownerAccount);
}
long DescribeDedicatedBlockStorageClustersRequest::getOwnerId() const {
return ownerId_;
}
void DescribeDedicatedBlockStorageClustersRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::string DescribeDedicatedBlockStorageClustersRequest::getZoneId() const {
return zoneId_;
}
void DescribeDedicatedBlockStorageClustersRequest::setZoneId(const std::string &zoneId) {
zoneId_ = zoneId;
setParameter(std::string("ZoneId"), zoneId);
}
int DescribeDedicatedBlockStorageClustersRequest::getMaxResults() const {
return maxResults_;
}
void DescribeDedicatedBlockStorageClustersRequest::setMaxResults(int maxResults) {
maxResults_ = maxResults;
setParameter(std::string("MaxResults"), std::to_string(maxResults));
}
std::string DescribeDedicatedBlockStorageClustersRequest::getCategory() const {
return category_;
}
void DescribeDedicatedBlockStorageClustersRequest::setCategory(const std::string &category) {
category_ = category;
setParameter(std::string("Category"), category);
}
std::vector<std::string> DescribeDedicatedBlockStorageClustersRequest::getStatus() const {
return status_;
}
void DescribeDedicatedBlockStorageClustersRequest::setStatus(const std::vector<std::string> &status) {
status_ = status;
}

85
ecs/src/model/DescribeDedicatedBlockStorageClustersResult.cc
View File

@@ -1,85 +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/ecs/model/DescribeDedicatedBlockStorageClustersResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
DescribeDedicatedBlockStorageClustersResult::DescribeDedicatedBlockStorageClustersResult() :
ServiceResult()
{}
DescribeDedicatedBlockStorageClustersResult::DescribeDedicatedBlockStorageClustersResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeDedicatedBlockStorageClustersResult::~DescribeDedicatedBlockStorageClustersResult()
{}
void DescribeDedicatedBlockStorageClustersResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDedicatedBlockStorageClustersNode = value["DedicatedBlockStorageClusters"]["DedicatedBlockStorageCluster"];
for (auto valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster : allDedicatedBlockStorageClustersNode)
{
DedicatedBlockStorageCluster dedicatedBlockStorageClustersObject;
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Status"].isNull())
dedicatedBlockStorageClustersObject.status = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Status"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Type"].isNull())
dedicatedBlockStorageClustersObject.type = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Type"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Description"].isNull())
dedicatedBlockStorageClustersObject.description = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Description"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["ExpiredTime"].isNull())
dedicatedBlockStorageClustersObject.expiredTime = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["ExpiredTime"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["CreateTime"].isNull())
dedicatedBlockStorageClustersObject.createTime = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["CreateTime"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["ZoneId"].isNull())
dedicatedBlockStorageClustersObject.zoneId = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["ZoneId"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Category"].isNull())
dedicatedBlockStorageClustersObject.category = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Category"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["DedicatedBlockStorageClusterName"].isNull())
dedicatedBlockStorageClustersObject.dedicatedBlockStorageClusterName = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["DedicatedBlockStorageClusterName"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["DedicatedBlockStorageClusterId"].isNull())
dedicatedBlockStorageClustersObject.dedicatedBlockStorageClusterId = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["DedicatedBlockStorageClusterId"].asString();
auto dedicatedBlockStorageClusterCapacityNode = value["DedicatedBlockStorageClusterCapacity"];
if(!dedicatedBlockStorageClusterCapacityNode["TotalCapacity"].isNull())
dedicatedBlockStorageClustersObject.dedicatedBlockStorageClusterCapacity.totalCapacity = std::stol(dedicatedBlockStorageClusterCapacityNode["TotalCapacity"].asString());
if(!dedicatedBlockStorageClusterCapacityNode["AvailableCapacity"].isNull())
dedicatedBlockStorageClustersObject.dedicatedBlockStorageClusterCapacity.availableCapacity = std::stol(dedicatedBlockStorageClusterCapacityNode["AvailableCapacity"].asString());
dedicatedBlockStorageClusters_.push_back(dedicatedBlockStorageClustersObject);
}
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
}
std::vector<DescribeDedicatedBlockStorageClustersResult::DedicatedBlockStorageCluster> DescribeDedicatedBlockStorageClustersResult::getDedicatedBlockStorageClusters()const
{
return dedicatedBlockStorageClusters_;
}
std::string DescribeDedicatedBlockStorageClustersResult::getNextToken()const
{
return nextToken_;
}

45
ecs/src/model/DescribeDiagnosticReportAttributesRequest.cc Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ecs/model/DescribeDiagnosticReportAttributesRequest.h>
using AlibabaCloud::Ecs::Model::DescribeDiagnosticReportAttributesRequest;
DescribeDiagnosticReportAttributesRequest::DescribeDiagnosticReportAttributesRequest()
: RpcServiceRequest("ecs", "2014-05-26", "DescribeDiagnosticReportAttributes") {
setMethod(HttpRequest::Method::Post);
}
DescribeDiagnosticReportAttributesRequest::~DescribeDiagnosticReportAttributesRequest() {}
std::string DescribeDiagnosticReportAttributesRequest::getReportId() const {
return reportId_;
}
void DescribeDiagnosticReportAttributesRequest::setReportId(const std::string &reportId) {
reportId_ = reportId;
setParameter(std::string("ReportId"), reportId);
}
std::string DescribeDiagnosticReportAttributesRequest::getRegionId() const {
return regionId_;
}
void DescribeDiagnosticReportAttributesRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}

154
ecs/src/model/DescribeDiagnosticReportAttributesResult.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/ecs/model/DescribeDiagnosticReportAttributesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
DescribeDiagnosticReportAttributesResult::DescribeDiagnosticReportAttributesResult() :
ServiceResult()
{}
DescribeDiagnosticReportAttributesResult::DescribeDiagnosticReportAttributesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeDiagnosticReportAttributesResult::~DescribeDiagnosticReportAttributesResult()
{}
void DescribeDiagnosticReportAttributesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allMetricResultsNode = value["MetricResults"]["MetricResult"];
for (auto valueMetricResultsMetricResult : allMetricResultsNode)
{
MetricResult metricResultsObject;
if(!valueMetricResultsMetricResult["MetricId"].isNull())
metricResultsObject.metricId = valueMetricResultsMetricResult["MetricId"].asString();
if(!valueMetricResultsMetricResult["MetricCategory"].isNull())
metricResultsObject.metricCategory = valueMetricResultsMetricResult["MetricCategory"].asString();
if(!valueMetricResultsMetricResult["Severity"].isNull())
metricResultsObject.severity = valueMetricResultsMetricResult["Severity"].asString();
if(!valueMetricResultsMetricResult["Status"].isNull())
metricResultsObject.status = valueMetricResultsMetricResult["Status"].asString();
auto allIssuesNode = valueMetricResultsMetricResult["Issues"]["Issue"];
for (auto valueMetricResultsMetricResultIssuesIssue : allIssuesNode)
{
MetricResult::Issue issuesObject;
if(!valueMetricResultsMetricResultIssuesIssue["IssueId"].isNull())
issuesObject.issueId = valueMetricResultsMetricResultIssuesIssue["IssueId"].asString();
if(!valueMetricResultsMetricResultIssuesIssue["Severity"].isNull())
issuesObject.severity = valueMetricResultsMetricResultIssuesIssue["Severity"].asString();
if(!valueMetricResultsMetricResultIssuesIssue["Additional"].isNull())
issuesObject.additional = valueMetricResultsMetricResultIssuesIssue["Additional"].asString();
if(!valueMetricResultsMetricResultIssuesIssue["OccurrenceTime"].isNull())
issuesObject.occurrenceTime = valueMetricResultsMetricResultIssuesIssue["OccurrenceTime"].asString();
metricResultsObject.issues.push_back(issuesObject);
}
metricResults_.push_back(metricResultsObject);
}
if(!value["ResourceId"].isNull())
resourceId_ = value["ResourceId"].asString();
if(!value["ResourceType"].isNull())
resourceType_ = value["ResourceType"].asString();
if(!value["ReportId"].isNull())
reportId_ = value["ReportId"].asString();
if(!value["Status"].isNull())
status_ = value["Status"].asString();
if(!value["CreationTime"].isNull())
creationTime_ = value["CreationTime"].asString();
if(!value["FinishedTime"].isNull())
finishedTime_ = value["FinishedTime"].asString();
if(!value["StartTime"].isNull())
startTime_ = value["StartTime"].asString();
if(!value["EndTime"].isNull())
endTime_ = value["EndTime"].asString();
if(!value["Severity"].isNull())
severity_ = value["Severity"].asString();
if(!value["MetricSetId"].isNull())
metricSetId_ = value["MetricSetId"].asString();
if(!value["Attributes"].isNull())
attributes_ = value["Attributes"].asString();
}
std::string DescribeDiagnosticReportAttributesResult::getStatus()const
{
return status_;
}
std::string DescribeDiagnosticReportAttributesResult::getEndTime()const
{
return endTime_;
}
std::string DescribeDiagnosticReportAttributesResult::getResourceId()const
{
return resourceId_;
}
std::string DescribeDiagnosticReportAttributesResult::getMetricSetId()const
{
return metricSetId_;
}
std::vector<DescribeDiagnosticReportAttributesResult::MetricResult> DescribeDiagnosticReportAttributesResult::getMetricResults()const
{
return metricResults_;
}
std::string DescribeDiagnosticReportAttributesResult::getCreationTime()const
{
return creationTime_;
}
std::string DescribeDiagnosticReportAttributesResult::getStartTime()const
{
return startTime_;
}
std::string DescribeDiagnosticReportAttributesResult::getAttributes()const
{
return attributes_;
}
std::string DescribeDiagnosticReportAttributesResult::getReportId()const
{
return reportId_;
}
std::string DescribeDiagnosticReportAttributesResult::getResourceType()const
{
return resourceType_;
}
std::string DescribeDiagnosticReportAttributesResult::getSeverity()const
{
return severity_;
}
std::string DescribeDiagnosticReportAttributesResult::getFinishedTime()const
{
return finishedTime_;
}

10
ecs/src/model/DescribeInstanceTypesResult.cc
View File

@@ -115,6 +115,16 @@ void DescribeInstanceTypesResult::parse(const std::string &payload)
instanceTypesObject.cpuArchitecture = valueInstanceTypesInstanceType["CpuArchitecture"].asString();
if(!valueInstanceTypesInstanceType["GPUMemorySize"].isNull())
instanceTypesObject.gPUMemorySize = std::stof(valueInstanceTypesInstanceType["GPUMemorySize"].asString());
if(!valueInstanceTypesInstanceType["NetworkCardQuantity"].isNull())
instanceTypesObject.networkCardQuantity = std::stoi(valueInstanceTypesInstanceType["NetworkCardQuantity"].asString());
auto allNetworkCardsNode = valueInstanceTypesInstanceType["NetworkCards"]["NetworkCardInfo"];
for (auto valueInstanceTypesInstanceTypeNetworkCardsNetworkCardInfo : allNetworkCardsNode)
{
InstanceType::NetworkCardInfo networkCardsObject;
if(!valueInstanceTypesInstanceTypeNetworkCardsNetworkCardInfo["NetworkCardIndex"].isNull())
networkCardsObject.networkCardIndex = std::stoi(valueInstanceTypesInstanceTypeNetworkCardsNetworkCardInfo["NetworkCardIndex"].asString());
instanceTypesObject.networkCards.push_back(networkCardsObject);
}
instanceTypes_.push_back(instanceTypesObject);
}
if(!value["NextToken"].isNull())

16
ecs/src/model/DescribeInstancesResult.cc
View File

@@ -167,6 +167,22 @@ void DescribeInstancesResult::parse(const std::string &payload)
ipv6SetsObject.ipv6Address = valueInstancesInstanceNetworkInterfacesNetworkInterfaceIpv6SetsIpv6Set["Ipv6Address"].asString();
networkInterfacesObject.ipv6Sets.push_back(ipv6SetsObject);
}
auto allIpv4PrefixSetsNode = valueInstancesInstanceNetworkInterfacesNetworkInterface["Ipv4PrefixSets"]["Ipv4PrefixSet"];
for (auto valueInstancesInstanceNetworkInterfacesNetworkInterfaceIpv4PrefixSetsIpv4PrefixSet : allIpv4PrefixSetsNode)
{
Instance::NetworkInterface::Ipv4PrefixSet ipv4PrefixSetsObject;
if(!valueInstancesInstanceNetworkInterfacesNetworkInterfaceIpv4PrefixSetsIpv4PrefixSet["Ipv4Prefix"].isNull())
ipv4PrefixSetsObject.ipv4Prefix = valueInstancesInstanceNetworkInterfacesNetworkInterfaceIpv4PrefixSetsIpv4PrefixSet["Ipv4Prefix"].asString();
networkInterfacesObject.ipv4PrefixSets.push_back(ipv4PrefixSetsObject);
}
auto allIpv6PrefixSetsNode = valueInstancesInstanceNetworkInterfacesNetworkInterface["Ipv6PrefixSets"]["Ipv6PrefixSet"];
for (auto valueInstancesInstanceNetworkInterfacesNetworkInterfaceIpv6PrefixSetsIpv6PrefixSet : allIpv6PrefixSetsNode)
{
Instance::NetworkInterface::Ipv6PrefixSet ipv6PrefixSetsObject;
if(!valueInstancesInstanceNetworkInterfacesNetworkInterfaceIpv6PrefixSetsIpv6PrefixSet["Ipv6Prefix"].isNull())
ipv6PrefixSetsObject.ipv6Prefix = valueInstancesInstanceNetworkInterfacesNetworkInterfaceIpv6PrefixSetsIpv6PrefixSet["Ipv6Prefix"].asString();
networkInterfacesObject.ipv6PrefixSets.push_back(ipv6PrefixSetsObject);
}
instancesObject.networkInterfaces.push_back(networkInterfacesObject);
}
auto allOperationLocksNode = valueInstancesInstance["OperationLocks"]["LockReason"];

9
ecs/src/model/DescribeInvocationResultsRequest.cc
View File

@@ -52,6 +52,15 @@ void DescribeInvocationResultsRequest::setPageNumber(long pageNumber) {
setParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
std::string DescribeInvocationResultsRequest::getResourceGroupId() const {
return resourceGroupId_;
}
void DescribeInvocationResultsRequest::setResourceGroupId(const std::string &resourceGroupId) {
resourceGroupId_ = resourceGroupId;
setParameter(std::string("ResourceGroupId"), resourceGroupId);
}
std::string DescribeInvocationResultsRequest::getRegionId() const {
return regionId_;
}

9
ecs/src/model/DescribeInvocationsRequest.cc
View File

@@ -70,6 +70,15 @@ void DescribeInvocationsRequest::setPageNumber(long pageNumber) {
setParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
std::string DescribeInvocationsRequest::getResourceGroupId() const {
return resourceGroupId_;
}
void DescribeInvocationsRequest::setResourceGroupId(const std::string &resourceGroupId) {
resourceGroupId_ = resourceGroupId;
setParameter(std::string("ResourceGroupId"), resourceGroupId);
}
std::string DescribeInvocationsRequest::getRegionId() const {
return regionId_;
}

2
ecs/src/model/DescribeLaunchTemplateVersionsResult.cc
View File

@@ -142,6 +142,8 @@ void DescribeLaunchTemplateVersionsResult::parse(const std::string &payload)
launchTemplateVersionSetsObject.launchTemplateData.systemDiskProvisionedIops = std::stol(launchTemplateDataNode["SystemDisk.ProvisionedIops"].asString());
if(!launchTemplateDataNode["SystemDisk.BurstingEnabled"].isNull())
launchTemplateVersionSetsObject.launchTemplateData.systemDiskBurstingEnabled = launchTemplateDataNode["SystemDisk.BurstingEnabled"].asString() == "true";
if(!launchTemplateDataNode["SystemDisk.Encrypted"].isNull())
launchTemplateVersionSetsObject.launchTemplateData.systemDiskEncrypted = launchTemplateDataNode["SystemDisk.Encrypted"].asString();
auto allDataDisksNode = launchTemplateDataNode["DataDisks"]["DataDisk"];
for (auto launchTemplateDataNodeDataDisksDataDisk : allDataDisksNode)
{

28
ecs/src/model/DescribeNetworkInterfaceAttributeResult.cc
View File

@@ -62,6 +62,22 @@ void DescribeNetworkInterfaceAttributeResult::parse(const std::string &payload)
ipv6SetsObject.ipv6Address = valueIpv6SetsIpv6Set["Ipv6Address"].asString();
ipv6Sets_.push_back(ipv6SetsObject);
}
auto allIpv4PrefixSetsNode = value["Ipv4PrefixSets"]["Ipv4PrefixSet"];
for (auto valueIpv4PrefixSetsIpv4PrefixSet : allIpv4PrefixSetsNode)
{
Ipv4PrefixSet ipv4PrefixSetsObject;
if(!valueIpv4PrefixSetsIpv4PrefixSet["Ipv4Prefix"].isNull())
ipv4PrefixSetsObject.ipv4Prefix = valueIpv4PrefixSetsIpv4PrefixSet["Ipv4Prefix"].asString();
ipv4PrefixSets_.push_back(ipv4PrefixSetsObject);
}
auto allIpv6PrefixSetsNode = value["Ipv6PrefixSets"]["Ipv6PrefixSet"];
for (auto valueIpv6PrefixSetsIpv6PrefixSet : allIpv6PrefixSetsNode)
{
Ipv6PrefixSet ipv6PrefixSetsObject;
if(!valueIpv6PrefixSetsIpv6PrefixSet["Ipv6Prefix"].isNull())
ipv6PrefixSetsObject.ipv6Prefix = valueIpv6PrefixSetsIpv6PrefixSet["Ipv6Prefix"].asString();
ipv6PrefixSets_.push_back(ipv6PrefixSetsObject);
}
auto allTagsNode = value["Tags"]["Tag"];
for (auto valueTagsTag : allTagsNode)
{
@@ -84,6 +100,8 @@ void DescribeNetworkInterfaceAttributeResult::parse(const std::string &payload)
attachment_.instanceId = attachmentNode["InstanceId"].asString();
if(!attachmentNode["TrunkNetworkInterfaceId"].isNull())
attachment_.trunkNetworkInterfaceId = attachmentNode["TrunkNetworkInterfaceId"].asString();
if(!attachmentNode["NetworkCardIndex"].isNull())
attachment_.networkCardIndex = std::stoi(attachmentNode["NetworkCardIndex"].asString());
auto allMemberNetworkInterfaceIds = attachmentNode["MemberNetworkInterfaceIds"]["MemberNetworkInterfaceId"];
for (auto value : allMemberNetworkInterfaceIds)
attachment_.memberNetworkInterfaceIds.push_back(value.asString());
@@ -273,6 +291,11 @@ std::string DescribeNetworkInterfaceAttributeResult::getVpcId()const
return vpcId_;
}
std::vector<DescribeNetworkInterfaceAttributeResult::Ipv6PrefixSet> DescribeNetworkInterfaceAttributeResult::getIpv6PrefixSets()const
{
return ipv6PrefixSets_;
}
DescribeNetworkInterfaceAttributeResult::BondInterfaceSpecification DescribeNetworkInterfaceAttributeResult::getBondInterfaceSpecification()const
{
return bondInterfaceSpecification_;
@@ -283,6 +306,11 @@ std::string DescribeNetworkInterfaceAttributeResult::getCreationTime()const
return creationTime_;
}
std::vector<DescribeNetworkInterfaceAttributeResult::Ipv4PrefixSet> DescribeNetworkInterfaceAttributeResult::getIpv4PrefixSets()const
{
return ipv4PrefixSets_;
}
std::vector<DescribeNetworkInterfaceAttributeResult::PrivateIpSet> DescribeNetworkInterfaceAttributeResult::getPrivateIpSets()const
{
return privateIpSets_;

18
ecs/src/model/DescribeNetworkInterfacesResult.cc
View File

@@ -104,6 +104,22 @@ void DescribeNetworkInterfacesResult::parse(const std::string &payload)
ipv6SetsObject.ipv6Address = valueNetworkInterfaceSetsNetworkInterfaceSetIpv6SetsIpv6Set["Ipv6Address"].asString();
networkInterfaceSetsObject.ipv6Sets.push_back(ipv6SetsObject);
}
auto allIpv4PrefixSetsNode = valueNetworkInterfaceSetsNetworkInterfaceSet["Ipv4PrefixSets"]["Ipv4PrefixSet"];
for (auto valueNetworkInterfaceSetsNetworkInterfaceSetIpv4PrefixSetsIpv4PrefixSet : allIpv4PrefixSetsNode)
{
NetworkInterfaceSet::Ipv4PrefixSet ipv4PrefixSetsObject;
if(!valueNetworkInterfaceSetsNetworkInterfaceSetIpv4PrefixSetsIpv4PrefixSet["Ipv4Prefix"].isNull())
ipv4PrefixSetsObject.ipv4Prefix = valueNetworkInterfaceSetsNetworkInterfaceSetIpv4PrefixSetsIpv4PrefixSet["Ipv4Prefix"].asString();
networkInterfaceSetsObject.ipv4PrefixSets.push_back(ipv4PrefixSetsObject);
}
auto allIpv6PrefixSetsNode = valueNetworkInterfaceSetsNetworkInterfaceSet["Ipv6PrefixSets"]["Ipv6PrefixSet"];
for (auto valueNetworkInterfaceSetsNetworkInterfaceSetIpv6PrefixSetsIpv6PrefixSet : allIpv6PrefixSetsNode)
{
NetworkInterfaceSet::Ipv6PrefixSet ipv6PrefixSetsObject;
if(!valueNetworkInterfaceSetsNetworkInterfaceSetIpv6PrefixSetsIpv6PrefixSet["Ipv6Prefix"].isNull())
ipv6PrefixSetsObject.ipv6Prefix = valueNetworkInterfaceSetsNetworkInterfaceSetIpv6PrefixSetsIpv6PrefixSet["Ipv6Prefix"].asString();
networkInterfaceSetsObject.ipv6PrefixSets.push_back(ipv6PrefixSetsObject);
}
auto allTagsNode = valueNetworkInterfaceSetsNetworkInterfaceSet["Tags"]["Tag"];
for (auto valueNetworkInterfaceSetsNetworkInterfaceSetTagsTag : allTagsNode)
{
@@ -126,6 +142,8 @@ void DescribeNetworkInterfacesResult::parse(const std::string &payload)
networkInterfaceSetsObject.attachment.instanceId = attachmentNode["InstanceId"].asString();
if(!attachmentNode["TrunkNetworkInterfaceId"].isNull())
networkInterfaceSetsObject.attachment.trunkNetworkInterfaceId = attachmentNode["TrunkNetworkInterfaceId"].asString();
if(!attachmentNode["NetworkCardIndex"].isNull())
networkInterfaceSetsObject.attachment.networkCardIndex = std::stoi(attachmentNode["NetworkCardIndex"].asString());
auto allSecurityGroupIds = value["SecurityGroupIds"]["SecurityGroupId"];
for (auto value : allSecurityGroupIds)
networkInterfaceSetsObject.securityGroupIds.push_back(value.asString());

2
ecs/src/model/DescribeSecurityGroupAttributeResult.cc
View File

@@ -43,6 +43,8 @@ void DescribeSecurityGroupAttributeResult::parse(const std::string &payload)
for (auto valuePermissionsPermission : allPermissionsNode)
{
Permission permissionsObject;
if(!valuePermissionsPermission["SecurityGroupRuleId"].isNull())
permissionsObject.securityGroupRuleId = valuePermissionsPermission["SecurityGroupRuleId"].asString();
if(!valuePermissionsPermission["Direction"].isNull())
permissionsObject.direction = valuePermissionsPermission["Direction"].asString();
if(!valuePermissionsPermission["SourceGroupId"].isNull())

9
ecs/src/model/DescribeSendFileResultsRequest.cc
View File

@@ -43,6 +43,15 @@ void DescribeSendFileResultsRequest::setPageNumber(long pageNumber) {
setParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
std::string DescribeSendFileResultsRequest::getResourceGroupId() const {
return resourceGroupId_;
}
void DescribeSendFileResultsRequest::setResourceGroupId(const std::string &resourceGroupId) {
resourceGroupId_ = resourceGroupId;
setParameter(std::string("ResourceGroupId"), resourceGroupId);
}
std::string DescribeSendFileResultsRequest::getRegionId() const {
return regionId_;
}

8
ecs/src/model/DescribeTasksRequest.cc
View File

@@ -133,3 +133,11 @@ void DescribeTasksRequest::setTaskAction(const std::string &taskAction) {
setParameter(std::string("TaskAction"), taskAction);
}
std::vector<std::string> DescribeTasksRequest::getResourceIds() const {
return resourceIds_;
}
void DescribeTasksRequest::setResourceIds(const std::vector<std::string> &resourceIds) {
resourceIds_ = resourceIds;
}

2
ecs/src/model/DescribeTasksResult.cc
View File

@@ -55,6 +55,8 @@ void DescribeTasksResult::parse(const std::string &payload)
taskSetObject.taskId = valueTaskSetTask["TaskId"].asString();
if(!valueTaskSetTask["TaskAction"].isNull())
taskSetObject.taskAction = valueTaskSetTask["TaskAction"].asString();
if(!valueTaskSetTask["ResourceId"].isNull())
taskSetObject.resourceId = valueTaskSetTask["ResourceId"].asString();
taskSet_.push_back(taskSetObject);
}
if(!value["PageSize"].isNull())

47
ecs/src/model/InvokeCommandRequest.cc
View File

@@ -43,6 +43,21 @@ void InvokeCommandRequest::setContainerName(const std::string &containerName) {
setParameter(std::string("ContainerName"), containerName);
}
std::vector<InvokeCommandRequest::SystemTag> InvokeCommandRequest::getSystemTag() const {
return systemTag_;
}
void InvokeCommandRequest::setSystemTag(const std::vector<InvokeCommandRequest::SystemTag> &systemTag) {
systemTag_ = systemTag;
for(int dep1 = 0; dep1 != systemTag.size(); dep1++) {
auto systemTagObj = systemTag.at(dep1);
std::string systemTagObjStr = std::string("SystemTag") + "." + std::to_string(dep1 + 1);
setParameter(systemTagObjStr + ".Key", systemTagObj.key);
setParameter(systemTagObjStr + ".Value", systemTagObj.value);
setParameter(systemTagObjStr + ".Scope", systemTagObj.scope);
}
}
std::string InvokeCommandRequest::getCommandId() const {
return commandId_;
}
@@ -52,6 +67,15 @@ void InvokeCommandRequest::setCommandId(const std::string &commandId) {
setParameter(std::string("CommandId"), commandId);
}
long InvokeCommandRequest::getTimeout() const {
return timeout_;
}
void InvokeCommandRequest::setTimeout(long timeout) {
timeout_ = timeout;
setParameter(std::string("Timeout"), std::to_string(timeout));
}
std::string InvokeCommandRequest::getFrequency() const {
return frequency_;
}
@@ -61,6 +85,15 @@ void InvokeCommandRequest::setFrequency(const std::string &frequency) {
setParameter(std::string("Frequency"), frequency);
}
std::string InvokeCommandRequest::getResourceGroupId() const {
return resourceGroupId_;
}
void InvokeCommandRequest::setResourceGroupId(const std::string &resourceGroupId) {
resourceGroupId_ = resourceGroupId;
setParameter(std::string("ResourceGroupId"), resourceGroupId);
}
std::string InvokeCommandRequest::getRegionId() const {
return regionId_;
}
@@ -88,6 +121,20 @@ void InvokeCommandRequest::setWindowsPasswordName(const std::string &windowsPass
setParameter(std::string("WindowsPasswordName"), windowsPasswordName);
}
std::vector<InvokeCommandRequest::Tag> InvokeCommandRequest::getTag() const {
return tag_;
}
void InvokeCommandRequest::setTag(const std::vector<InvokeCommandRequest::Tag> &tag) {
tag_ = tag;
for(int dep1 = 0; dep1 != tag.size(); dep1++) {
auto tagObj = tag.at(dep1);
std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
setParameter(tagObjStr + ".Key", tagObj.key);
setParameter(tagObjStr + ".Value", tagObj.value);
}
}
bool InvokeCommandRequest::getTimed() const {
return timed_;
}

9
ecs/src/model/ModifyInstanceMetadataOptionsRequest.cc
View File

@@ -34,6 +34,15 @@ void ModifyInstanceMetadataOptionsRequest::setResourceOwnerId(long resourceOwner
setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
}
std::string ModifyInstanceMetadataOptionsRequest::getInstanceMetadataTags() const {
return instanceMetadataTags_;
}
void ModifyInstanceMetadataOptionsRequest::setInstanceMetadataTags(const std::string &instanceMetadataTags) {
instanceMetadataTags_ = instanceMetadataTags;
setParameter(std::string("InstanceMetadataTags"), instanceMetadataTags);
}
int ModifyInstanceMetadataOptionsRequest::getHttpPutResponseHopLimit() const {
return httpPutResponseHopLimit_;
}

9
ecs/src/model/ModifyPrepayInstanceSpecRequest.cc
View File

@@ -43,6 +43,15 @@ void ModifyPrepayInstanceSpecRequest::setClientToken(const std::string &clientTo
setParameter(std::string("ClientToken"), clientToken);
}
std::string ModifyPrepayInstanceSpecRequest::getCouponNo() const {
return couponNo_;
}
void ModifyPrepayInstanceSpecRequest::setCouponNo(const std::string &couponNo) {
couponNo_ = couponNo;
setParameter(std::string("CouponNo"), couponNo);
}
std::string ModifyPrepayInstanceSpecRequest::getOperatorType() const {
return operatorType_;
}

9
ecs/src/model/ModifySecurityGroupEgressRuleRequest.cc
View File

@@ -223,3 +223,12 @@ void ModifySecurityGroupEgressRuleRequest::setDestGroupOwnerId(long destGroupOwn
setParameter(std::string("DestGroupOwnerId"), std::to_string(destGroupOwnerId));
}
std::string ModifySecurityGroupEgressRuleRequest::getSecurityGroupRuleId() const {
return securityGroupRuleId_;
}
void ModifySecurityGroupEgressRuleRequest::setSecurityGroupRuleId(const std::string &securityGroupRuleId) {
securityGroupRuleId_ = securityGroupRuleId;
setParameter(std::string("SecurityGroupRuleId"), securityGroupRuleId);
}

9
ecs/src/model/ModifySecurityGroupRuleRequest.cc
View File

@@ -223,3 +223,12 @@ void ModifySecurityGroupRuleRequest::setSourceGroupId(const std::string &sourceG
setParameter(std::string("SourceGroupId"), sourceGroupId);
}
std::string ModifySecurityGroupRuleRequest::getSecurityGroupRuleId() const {
return securityGroupRuleId_;
}
void ModifySecurityGroupRuleRequest::setSecurityGroupRuleId(const std::string &securityGroupRuleId) {
securityGroupRuleId_ = securityGroupRuleId;
setParameter(std::string("SecurityGroupRuleId"), securityGroupRuleId);
}

18
ecs/src/model/PurchaseReservedInstancesOfferingRequest.cc
View File

@@ -111,6 +111,15 @@ void PurchaseReservedInstancesOfferingRequest::setTag(const std::vector<Purchase
}
}
int PurchaseReservedInstancesOfferingRequest::getAutoRenewPeriod() const {
return autoRenewPeriod_;
}
void PurchaseReservedInstancesOfferingRequest::setAutoRenewPeriod(int autoRenewPeriod) {
autoRenewPeriod_ = autoRenewPeriod;
setParameter(std::string("AutoRenewPeriod"), std::to_string(autoRenewPeriod));
}
int PurchaseReservedInstancesOfferingRequest::getPeriod() const {
return period_;
}
@@ -165,6 +174,15 @@ void PurchaseReservedInstancesOfferingRequest::setOfferingType(const std::string
setParameter(std::string("OfferingType"), offeringType);
}
bool PurchaseReservedInstancesOfferingRequest::getAutoRenew() const {
return autoRenew_;
}
void PurchaseReservedInstancesOfferingRequest::setAutoRenew(bool autoRenew) {
autoRenew_ = autoRenew;
setParameter(std::string("AutoRenew"), autoRenew ? "true" : "false");
}
std::string PurchaseReservedInstancesOfferingRequest::getZoneId() const {
return zoneId_;
}

38
ecs/src/model/ReleasePublicIpAddressRequest.cc
View File

@@ -25,40 +25,22 @@ ReleasePublicIpAddressRequest::ReleasePublicIpAddressRequest()
ReleasePublicIpAddressRequest::~ReleasePublicIpAddressRequest() {}
long ReleasePublicIpAddressRequest::getResourceOwnerId() const {
return resourceOwnerId_;
std::string ReleasePublicIpAddressRequest::getRegionId() const {
return regionId_;
}
void ReleasePublicIpAddressRequest::setResourceOwnerId(long resourceOwnerId) {
resourceOwnerId_ = resourceOwnerId;
setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
void ReleasePublicIpAddressRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
std::string ReleasePublicIpAddressRequest::getResourceOwnerAccount() const {
return resourceOwnerAccount_;
bool ReleasePublicIpAddressRequest::getDryRun() const {
return dryRun_;
}
void ReleasePublicIpAddressRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
}
std::string ReleasePublicIpAddressRequest::getOwnerAccount() const {
return ownerAccount_;
}
void ReleasePublicIpAddressRequest::setOwnerAccount(const std::string &ownerAccount) {
ownerAccount_ = ownerAccount;
setParameter(std::string("OwnerAccount"), ownerAccount);
}
long ReleasePublicIpAddressRequest::getOwnerId() const {
return ownerId_;
}
void ReleasePublicIpAddressRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
void ReleasePublicIpAddressRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}
std::string ReleasePublicIpAddressRequest::getPublicIpAddress() const {

7
ecs/src/model/ReleasePublicIpAddressResult.cc
View File

@@ -39,6 +39,13 @@ void ReleasePublicIpAddressResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["RemainTimes"].isNull())
remainTimes_ = value["RemainTimes"].asString();
}
std::string ReleasePublicIpAddressResult::getRemainTimes()const
{
return remainTimes_;
}

18
ecs/src/model/RenewReservedInstancesRequest.cc
View File

@@ -52,6 +52,15 @@ void RenewReservedInstancesRequest::setRegionId(const std::string &regionId) {
setParameter(std::string("RegionId"), regionId);
}
int RenewReservedInstancesRequest::getAutoRenewPeriod() const {
return autoRenewPeriod_;
}
void RenewReservedInstancesRequest::setAutoRenewPeriod(int autoRenewPeriod) {
autoRenewPeriod_ = autoRenewPeriod;
setParameter(std::string("AutoRenewPeriod"), std::to_string(autoRenewPeriod));
}
int RenewReservedInstancesRequest::getPeriod() const {
return period_;
}
@@ -105,3 +114,12 @@ void RenewReservedInstancesRequest::setReservedInstanceId(const std::vector<std:
reservedInstanceId_ = reservedInstanceId;
}
bool RenewReservedInstancesRequest::getAutoRenew() const {
return autoRenew_;
}
void RenewReservedInstancesRequest::setAutoRenew(bool autoRenew) {
autoRenew_ = autoRenew;
setParameter(std::string("AutoRenew"), autoRenew ? "true" : "false");
}

42
ecs/src/model/ReplaceSystemDiskRequest.cc
View File

@@ -52,6 +52,15 @@ void ReplaceSystemDiskRequest::setClientToken(const std::string &clientToken) {
setParameter(std::string("ClientToken"), clientToken);
}
std::string ReplaceSystemDiskRequest::getEncryptAlgorithm() const {
return encryptAlgorithm_;
}
void ReplaceSystemDiskRequest::setEncryptAlgorithm(const std::string &encryptAlgorithm) {
encryptAlgorithm_ = encryptAlgorithm;
setParameter(std::string("EncryptAlgorithm"), encryptAlgorithm);
}
std::string ReplaceSystemDiskRequest::getSecurityEnhancementStrategy() const {
return securityEnhancementStrategy_;
}
@@ -115,6 +124,21 @@ void ReplaceSystemDiskRequest::setDiskId(const std::string &diskId) {
setParameter(std::string("DiskId"), diskId);
}
std::vector<ReplaceSystemDiskRequest::Arn> ReplaceSystemDiskRequest::getArn() const {
return arn_;
}
void ReplaceSystemDiskRequest::setArn(const std::vector<ReplaceSystemDiskRequest::Arn> &arn) {
arn_ = arn;
for(int dep1 = 0; dep1 != arn.size(); dep1++) {
auto arnObj = arn.at(dep1);
std::string arnObjStr = std::string("Arn") + "." + std::to_string(dep1 + 1);
setParameter(arnObjStr + ".Rolearn", arnObj.rolearn);
setParameter(arnObjStr + ".RoleType", arnObj.roleType);
setParameter(arnObjStr + ".AssumeRoleFor", std::to_string(arnObj.assumeRoleFor));
}
}
std::string ReplaceSystemDiskRequest::getArchitecture() const {
return architecture_;
}
@@ -169,6 +193,24 @@ void ReplaceSystemDiskRequest::setSystemDiskSize(int systemDiskSize) {
setParameter(std::string("SystemDisk.Size"), std::to_string(systemDiskSize));
}
bool ReplaceSystemDiskRequest::getEncrypted() const {
return encrypted_;
}
void ReplaceSystemDiskRequest::setEncrypted(bool encrypted) {
encrypted_ = encrypted;
setParameter(std::string("Encrypted"), encrypted ? "true" : "false");
}
std::string ReplaceSystemDiskRequest::getKMSKeyId() const {
return kMSKeyId_;
}
void ReplaceSystemDiskRequest::setKMSKeyId(const std::string &kMSKeyId) {
kMSKeyId_ = kMSKeyId;
setParameter(std::string("KMSKeyId"), kMSKeyId);
}
bool ReplaceSystemDiskRequest::getUseAdditionalService() const {
return useAdditionalService_;
}

8
ecs/src/model/RevokeSecurityGroupEgressRequest.cc
View File

@@ -248,3 +248,11 @@ void RevokeSecurityGroupEgressRequest::setDestGroupOwnerId(long destGroupOwnerId
setParameter(std::string("DestGroupOwnerId"), std::to_string(destGroupOwnerId));
}
std::vector<std::string> RevokeSecurityGroupEgressRequest::getSecurityGroupRuleId() const {
return securityGroupRuleId_;
}
void RevokeSecurityGroupEgressRequest::setSecurityGroupRuleId(const std::vector<std::string> &securityGroupRuleId) {
securityGroupRuleId_ = securityGroupRuleId;
}

8
ecs/src/model/RevokeSecurityGroupRequest.cc
View File

@@ -248,3 +248,11 @@ void RevokeSecurityGroupRequest::setSourceGroupId(const std::string &sourceGroup
setParameter(std::string("SourceGroupId"), sourceGroupId);
}
std::vector<std::string> RevokeSecurityGroupRequest::getSecurityGroupRuleId() const {
return securityGroupRuleId_;
}
void RevokeSecurityGroupRequest::setSecurityGroupRuleId(const std::vector<std::string> &securityGroupRuleId) {
securityGroupRuleId_ = securityGroupRuleId;
}

9
ecs/src/model/RunCommandRequest.cc
View File

@@ -97,6 +97,15 @@ void RunCommandRequest::setFrequency(const std::string &frequency) {
setParameter(std::string("Frequency"), frequency);
}
std::string RunCommandRequest::getResourceGroupId() const {
return resourceGroupId_;
}
void RunCommandRequest::setResourceGroupId(const std::string &resourceGroupId) {
resourceGroupId_ = resourceGroupId;
setParameter(std::string("ResourceGroupId"), resourceGroupId);
}
std::string RunCommandRequest::getRegionId() const {
return regionId_;
}

1
ecs/src/model/RunInstancesRequest.cc
View File

@@ -723,6 +723,7 @@ void RunInstancesRequest::setNetworkInterface(const std::vector<RunInstancesRequ
setParameter(networkInterfaceObjStr + ".QueuePairNumber", std::to_string(networkInterfaceObj.queuePairNumber));
setParameter(networkInterfaceObjStr + ".InstanceType", networkInterfaceObj.instanceType);
setParameter(networkInterfaceObjStr + ".Ipv6AddressCount", std::to_string(networkInterfaceObj.ipv6AddressCount));
setParameter(networkInterfaceObjStr + ".NetworkCardIndex", std::to_string(networkInterfaceObj.networkCardIndex));
}
}

9
ecs/src/model/SendFileRequest.cc
View File

@@ -61,6 +61,15 @@ void SendFileRequest::setContent(const std::string &content) {
setParameter(std::string("Content"), content);
}
std::string SendFileRequest::getResourceGroupId() const {
return resourceGroupId_;
}
void SendFileRequest::setResourceGroupId(const std::string &resourceGroupId) {
resourceGroupId_ = resourceGroupId;
setParameter(std::string("ResourceGroupId"), resourceGroupId);
}
std::string SendFileRequest::getRegionId() const {
return regionId_;
}

8
ecs/src/model/UnassignIpv6AddressesRequest.cc
View File

@@ -34,6 +34,14 @@ void UnassignIpv6AddressesRequest::setResourceOwnerId(long resourceOwnerId) {
setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
}
std::vector<std::string> UnassignIpv6AddressesRequest::getIpv6Prefix() const {
return ipv6Prefix_;
}
void UnassignIpv6AddressesRequest::setIpv6Prefix(const std::vector<std::string> &ipv6Prefix) {
ipv6Prefix_ = ipv6Prefix;
}
std::string UnassignIpv6AddressesRequest::getRegionId() const {
return regionId_;
}

8
ecs/src/model/UnassignPrivateIpAddressesRequest.cc
View File

@@ -34,6 +34,14 @@ void UnassignPrivateIpAddressesRequest::setResourceOwnerId(long resourceOwnerId)
setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
}
std::vector<std::string> UnassignPrivateIpAddressesRequest::getIpv4Prefix() const {
return ipv4Prefix_;
}
void UnassignPrivateIpAddressesRequest::setIpv4Prefix(const std::vector<std::string> &ipv4Prefix) {
ipv4Prefix_ = ipv4Prefix;
}
std::string UnassignPrivateIpAddressesRequest::getRegionId() const {
return regionId_;
}