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

AcceptInquiredSystemEvent adds Choice parameter.

Browse Source
This commit is contained in:
sdk-team
2021-04-22 07:36:19 +00:00
parent bfee7629d7
commit 863129ac92
61 changed files with 2761 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

252
ecs/src/EcsClient.cc
View File

@@ -1275,6 +1275,42 @@ 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();
@@ -1419,6 +1455,42 @@ EcsClient::CreateDiskOutcomeCallable EcsClient::createDiskCallable(const CreateD
return task->get_future();
}
EcsClient::CreateDiskReplicaPairOutcome EcsClient::createDiskReplicaPair(const CreateDiskReplicaPairRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateDiskReplicaPairOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateDiskReplicaPairOutcome(CreateDiskReplicaPairResult(outcome.result()));
else
return CreateDiskReplicaPairOutcome(outcome.error());
}
void EcsClient::createDiskReplicaPairAsync(const CreateDiskReplicaPairRequest& request, const CreateDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createDiskReplicaPair(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::CreateDiskReplicaPairOutcomeCallable EcsClient::createDiskReplicaPairCallable(const CreateDiskReplicaPairRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateDiskReplicaPairOutcome()>>(
[this, request]()
{
return this->createDiskReplicaPair(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::CreateElasticityAssuranceOutcome EcsClient::createElasticityAssurance(const CreateElasticityAssuranceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2679,6 +2751,42 @@ EcsClient::DeleteDiskOutcomeCallable EcsClient::deleteDiskCallable(const DeleteD
return task->get_future();
}
EcsClient::DeleteDiskReplicaPairOutcome EcsClient::deleteDiskReplicaPair(const DeleteDiskReplicaPairRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteDiskReplicaPairOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteDiskReplicaPairOutcome(DeleteDiskReplicaPairResult(outcome.result()));
else
return DeleteDiskReplicaPairOutcome(outcome.error());
}
void EcsClient::deleteDiskReplicaPairAsync(const DeleteDiskReplicaPairRequest& request, const DeleteDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteDiskReplicaPair(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::DeleteDiskReplicaPairOutcomeCallable EcsClient::deleteDiskReplicaPairCallable(const DeleteDiskReplicaPairRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteDiskReplicaPairOutcome()>>(
[this, request]()
{
return this->deleteDiskReplicaPair(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::DeleteForwardEntryOutcome EcsClient::deleteForwardEntry(const DeleteForwardEntryRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4155,6 +4263,42 @@ 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();
@@ -4443,6 +4587,42 @@ EcsClient::DescribeDiskMonitorDataOutcomeCallable EcsClient::describeDiskMonitor
return task->get_future();
}
EcsClient::DescribeDiskReplicaPairsOutcome EcsClient::describeDiskReplicaPairs(const DescribeDiskReplicaPairsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeDiskReplicaPairsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeDiskReplicaPairsOutcome(DescribeDiskReplicaPairsResult(outcome.result()));
else
return DescribeDiskReplicaPairsOutcome(outcome.error());
}
void EcsClient::describeDiskReplicaPairsAsync(const DescribeDiskReplicaPairsRequest& request, const DescribeDiskReplicaPairsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeDiskReplicaPairs(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::DescribeDiskReplicaPairsOutcomeCallable EcsClient::describeDiskReplicaPairsCallable(const DescribeDiskReplicaPairsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeDiskReplicaPairsOutcome()>>(
[this, request]()
{
return this->describeDiskReplicaPairs(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::DescribeDisksOutcome EcsClient::describeDisks(const DescribeDisksRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -11247,6 +11427,42 @@ EcsClient::SendFileOutcomeCallable EcsClient::sendFileCallable(const SendFileReq
return task->get_future();
}
EcsClient::StartDiskReplicaPairOutcome EcsClient::startDiskReplicaPair(const StartDiskReplicaPairRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StartDiskReplicaPairOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StartDiskReplicaPairOutcome(StartDiskReplicaPairResult(outcome.result()));
else
return StartDiskReplicaPairOutcome(outcome.error());
}
void EcsClient::startDiskReplicaPairAsync(const StartDiskReplicaPairRequest& request, const StartDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, startDiskReplicaPair(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::StartDiskReplicaPairOutcomeCallable EcsClient::startDiskReplicaPairCallable(const StartDiskReplicaPairRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StartDiskReplicaPairOutcome()>>(
[this, request]()
{
return this->startDiskReplicaPair(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::StartElasticityAssuranceOutcome EcsClient::startElasticityAssurance(const StartElasticityAssuranceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -11391,6 +11607,42 @@ EcsClient::StartInstancesOutcomeCallable EcsClient::startInstancesCallable(const
return task->get_future();
}
EcsClient::StopDiskReplicaPairOutcome EcsClient::stopDiskReplicaPair(const StopDiskReplicaPairRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StopDiskReplicaPairOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StopDiskReplicaPairOutcome(StopDiskReplicaPairResult(outcome.result()));
else
return StopDiskReplicaPairOutcome(outcome.error());
}
void EcsClient::stopDiskReplicaPairAsync(const StopDiskReplicaPairRequest& request, const StopDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, stopDiskReplicaPair(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::StopDiskReplicaPairOutcomeCallable EcsClient::stopDiskReplicaPairCallable(const StopDiskReplicaPairRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StopDiskReplicaPairOutcome()>>(
[this, request]()
{
return this->stopDiskReplicaPair(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::StopInstanceOutcome EcsClient::stopInstance(const StopInstanceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

11
ecs/src/model/AcceptInquiredSystemEventRequest.cc
View File

@@ -93,3 +93,14 @@ void AcceptInquiredSystemEventRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string AcceptInquiredSystemEventRequest::getChoice()const
{
return choice_;
}
void AcceptInquiredSystemEventRequest::setChoice(const std::string& choice)
{
choice_ = choice;
setParameter("Choice", choice);
}

194
ecs/src/model/CreateDedicatedBlockStorageClusterRequest.cc Normal file
View File

@@ -0,0 +1,194 @@
/*
* 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("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateDedicatedBlockStorageClusterRequest::getDedicatedBlockStorageClusterName()const
{
return dedicatedBlockStorageClusterName_;
}
void CreateDedicatedBlockStorageClusterRequest::setDedicatedBlockStorageClusterName(const std::string& dedicatedBlockStorageClusterName)
{
dedicatedBlockStorageClusterName_ = dedicatedBlockStorageClusterName;
setParameter("DedicatedBlockStorageClusterName", dedicatedBlockStorageClusterName);
}
std::string CreateDedicatedBlockStorageClusterRequest::getClientToken()const
{
return clientToken_;
}
void CreateDedicatedBlockStorageClusterRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CreateDedicatedBlockStorageClusterRequest::getDescription()const
{
return description_;
}
void CreateDedicatedBlockStorageClusterRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
int CreateDedicatedBlockStorageClusterRequest::getCapacity()const
{
return capacity_;
}
void CreateDedicatedBlockStorageClusterRequest::setCapacity(int capacity)
{
capacity_ = capacity;
setParameter("Capacity", std::to_string(capacity));
}
std::string CreateDedicatedBlockStorageClusterRequest::getRegionId()const
{
return regionId_;
}
void CreateDedicatedBlockStorageClusterRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
int CreateDedicatedBlockStorageClusterRequest::getPeriod()const
{
return period_;
}
void CreateDedicatedBlockStorageClusterRequest::setPeriod(int period)
{
period_ = period;
setParameter("Period", std::to_string(period));
}
std::string CreateDedicatedBlockStorageClusterRequest::getFromApp()const
{
return fromApp_;
}
void CreateDedicatedBlockStorageClusterRequest::setFromApp(const std::string& fromApp)
{
fromApp_ = fromApp;
setParameter("FromApp", fromApp);
}
std::string CreateDedicatedBlockStorageClusterRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateDedicatedBlockStorageClusterRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateDedicatedBlockStorageClusterRequest::getPerformanceLevel()const
{
return performanceLevel_;
}
void CreateDedicatedBlockStorageClusterRequest::setPerformanceLevel(const std::string& performanceLevel)
{
performanceLevel_ = performanceLevel;
setParameter("PerformanceLevel", performanceLevel);
}
std::string CreateDedicatedBlockStorageClusterRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateDedicatedBlockStorageClusterRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CreateDedicatedBlockStorageClusterRequest::getOwnerId()const
{
return ownerId_;
}
void CreateDedicatedBlockStorageClusterRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateDedicatedBlockStorageClusterRequest::getPeriodUnit()const
{
return periodUnit_;
}
void CreateDedicatedBlockStorageClusterRequest::setPeriodUnit(const std::string& periodUnit)
{
periodUnit_ = periodUnit;
setParameter("PeriodUnit", periodUnit);
}
std::string CreateDedicatedBlockStorageClusterRequest::getZoneId()const
{
return zoneId_;
}
void CreateDedicatedBlockStorageClusterRequest::setZoneId(const std::string& zoneId)
{
zoneId_ = zoneId;
setParameter("ZoneId", zoneId);
}
std::string CreateDedicatedBlockStorageClusterRequest::getCategory()const
{
return category_;
}
void CreateDedicatedBlockStorageClusterRequest::setCategory(const std::string& category)
{
category_ = category;
setParameter("Category", category);
}

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

@@ -0,0 +1,58 @@
/*
* 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_;
}

150
ecs/src/model/CreateDiskReplicaPairRequest.cc Normal file
View File

@@ -0,0 +1,150 @@
/*
* 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/CreateDiskReplicaPairRequest.h>
using AlibabaCloud::Ecs::Model::CreateDiskReplicaPairRequest;
CreateDiskReplicaPairRequest::CreateDiskReplicaPairRequest() :
RpcServiceRequest("ecs", "2014-05-26", "CreateDiskReplicaPair")
{
setMethod(HttpRequest::Method::Post);
}
CreateDiskReplicaPairRequest::~CreateDiskReplicaPairRequest()
{}
long CreateDiskReplicaPairRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateDiskReplicaPairRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateDiskReplicaPairRequest::getPairName()const
{
return pairName_;
}
void CreateDiskReplicaPairRequest::setPairName(const std::string& pairName)
{
pairName_ = pairName;
setParameter("PairName", pairName);
}
std::string CreateDiskReplicaPairRequest::getDestinationRegionId()const
{
return destinationRegionId_;
}
void CreateDiskReplicaPairRequest::setDestinationRegionId(const std::string& destinationRegionId)
{
destinationRegionId_ = destinationRegionId;
setParameter("DestinationRegionId", destinationRegionId);
}
std::string CreateDiskReplicaPairRequest::getDescription()const
{
return description_;
}
void CreateDiskReplicaPairRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
std::string CreateDiskReplicaPairRequest::getRegionId()const
{
return regionId_;
}
void CreateDiskReplicaPairRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateDiskReplicaPairRequest::getDiskId()const
{
return diskId_;
}
void CreateDiskReplicaPairRequest::setDiskId(const std::string& diskId)
{
diskId_ = diskId;
setParameter("DiskId", diskId);
}
int CreateDiskReplicaPairRequest::getAsyncCycle()const
{
return asyncCycle_;
}
void CreateDiskReplicaPairRequest::setAsyncCycle(int asyncCycle)
{
asyncCycle_ = asyncCycle;
setParameter("AsyncCycle", std::to_string(asyncCycle));
}
std::string CreateDiskReplicaPairRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateDiskReplicaPairRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateDiskReplicaPairRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateDiskReplicaPairRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CreateDiskReplicaPairRequest::getOwnerId()const
{
return ownerId_;
}
void CreateDiskReplicaPairRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateDiskReplicaPairRequest::getDestinationDiskId()const
{
return destinationDiskId_;
}
void CreateDiskReplicaPairRequest::setDestinationDiskId(const std::string& destinationDiskId)
{
destinationDiskId_ = destinationDiskId;
setParameter("DestinationDiskId", destinationDiskId);
}

51
ecs/src/model/CreateDiskReplicaPairResult.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/ecs/model/CreateDiskReplicaPairResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
CreateDiskReplicaPairResult::CreateDiskReplicaPairResult() :
ServiceResult()
{}
CreateDiskReplicaPairResult::CreateDiskReplicaPairResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateDiskReplicaPairResult::~CreateDiskReplicaPairResult()
{}
void CreateDiskReplicaPairResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["PairId"].isNull())
pairId_ = value["PairId"].asString();
}
std::string CreateDiskReplicaPairResult::getPairId()const
{
return pairId_;
}

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

@@ -181,6 +181,17 @@ void CreateDiskRequest::setAdvancedFeatures(const std::string& advancedFeatures)
setParameter("AdvancedFeatures", advancedFeatures);
}
std::string CreateDiskRequest::getDedicatedBlockStorageClusterId()const
{
return dedicatedBlockStorageClusterId_;
}
void CreateDiskRequest::setDedicatedBlockStorageClusterId(const std::string& dedicatedBlockStorageClusterId)
{
dedicatedBlockStorageClusterId_ = dedicatedBlockStorageClusterId;
setParameter("DedicatedBlockStorageClusterId", dedicatedBlockStorageClusterId);
}
std::string CreateDiskRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;

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

@@ -197,6 +197,17 @@ void CreateNetworkInterfaceRequest::setOwnerAccount(const std::string& ownerAcco
setParameter("OwnerAccount", ownerAccount);
}
int CreateNetworkInterfaceRequest::getQueuePairNumber()const
{
return queuePairNumber_;
}
void CreateNetworkInterfaceRequest::setQueuePairNumber(int queuePairNumber)
{
queuePairNumber_ = queuePairNumber;
setParameter("QueuePairNumber", std::to_string(queuePairNumber));
}
long CreateNetworkInterfaceRequest::getOwnerId()const
{
return ownerId_;
@@ -221,6 +232,17 @@ void CreateNetworkInterfaceRequest::setSecurityGroupIds(const std::vector<std::s
}
}
std::string CreateNetworkInterfaceRequest::getNetworkInterfaceTrafficMode()const
{
return networkInterfaceTrafficMode_;
}
void CreateNetworkInterfaceRequest::setNetworkInterfaceTrafficMode(const std::string& networkInterfaceTrafficMode)
{
networkInterfaceTrafficMode_ = networkInterfaceTrafficMode;
setParameter("NetworkInterfaceTrafficMode", networkInterfaceTrafficMode);
}
std::string CreateNetworkInterfaceRequest::getVSwitchId()const
{
return vSwitchId_;

95
ecs/src/model/DeleteDiskReplicaPairRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* 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/DeleteDiskReplicaPairRequest.h>
using AlibabaCloud::Ecs::Model::DeleteDiskReplicaPairRequest;
DeleteDiskReplicaPairRequest::DeleteDiskReplicaPairRequest() :
RpcServiceRequest("ecs", "2014-05-26", "DeleteDiskReplicaPair")
{
setMethod(HttpRequest::Method::Post);
}
DeleteDiskReplicaPairRequest::~DeleteDiskReplicaPairRequest()
{}
long DeleteDiskReplicaPairRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteDiskReplicaPairRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteDiskReplicaPairRequest::getRegionId()const
{
return regionId_;
}
void DeleteDiskReplicaPairRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DeleteDiskReplicaPairRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteDiskReplicaPairRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteDiskReplicaPairRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteDiskReplicaPairRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DeleteDiskReplicaPairRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteDiskReplicaPairRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteDiskReplicaPairRequest::getReplicaPairId()const
{
return replicaPairId_;
}
void DeleteDiskReplicaPairRequest::setReplicaPairId(const std::string& replicaPairId)
{
replicaPairId_ = replicaPairId;
setParameter("ReplicaPairId", replicaPairId);
}

44
ecs/src/model/DeleteDiskReplicaPairResult.cc Normal file
View File

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

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

@@ -57,6 +57,8 @@ void DescribeCloudAssistantStatusResult::parse(const std::string &payload)
instanceCloudAssistantStatusSetObject.activeTaskCount = std::stol(valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["ActiveTaskCount"].asString());
if(!valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["LastInvokedTime"].isNull())
instanceCloudAssistantStatusSetObject.lastInvokedTime = valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["LastInvokedTime"].asString();
if(!valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["LastHeartbeatTime"].isNull())
instanceCloudAssistantStatusSetObject.lastHeartbeatTime = valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["LastHeartbeatTime"].asString();
instanceCloudAssistantStatusSet_.push_back(instanceCloudAssistantStatusSetObject);
}
if(!value["TotalCount"].isNull())

154
ecs/src/model/DescribeDedicatedBlockStorageClustersRequest.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/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("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDedicatedBlockStorageClustersRequest::getRegionId()const
{
return regionId_;
}
void DescribeDedicatedBlockStorageClustersRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribeDedicatedBlockStorageClustersRequest::getNextToken()const
{
return nextToken_;
}
void DescribeDedicatedBlockStorageClustersRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
}
std::vector<std::string> DescribeDedicatedBlockStorageClustersRequest::getDedicatedBlockStorageClusterId()const
{
return dedicatedBlockStorageClusterId_;
}
void DescribeDedicatedBlockStorageClustersRequest::setDedicatedBlockStorageClusterId(const std::vector<std::string>& dedicatedBlockStorageClusterId)
{
dedicatedBlockStorageClusterId_ = dedicatedBlockStorageClusterId;
for(int dep1 = 0; dep1!= dedicatedBlockStorageClusterId.size(); dep1++) {
setParameter("DedicatedBlockStorageClusterId."+ std::to_string(dep1), dedicatedBlockStorageClusterId.at(dep1));
}
}
std::string DescribeDedicatedBlockStorageClustersRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDedicatedBlockStorageClustersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDedicatedBlockStorageClustersRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDedicatedBlockStorageClustersRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DescribeDedicatedBlockStorageClustersRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDedicatedBlockStorageClustersRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDedicatedBlockStorageClustersRequest::getZoneId()const
{
return zoneId_;
}
void DescribeDedicatedBlockStorageClustersRequest::setZoneId(const std::string& zoneId)
{
zoneId_ = zoneId;
setParameter("ZoneId", zoneId);
}
int DescribeDedicatedBlockStorageClustersRequest::getMaxResults()const
{
return maxResults_;
}
void DescribeDedicatedBlockStorageClustersRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
}
std::string DescribeDedicatedBlockStorageClustersRequest::getCategory()const
{
return category_;
}
void DescribeDedicatedBlockStorageClustersRequest::setCategory(const std::string& category)
{
category_ = category;
setParameter("Category", category);
}
std::vector<std::string> DescribeDedicatedBlockStorageClustersRequest::getStatus()const
{
return status_;
}
void DescribeDedicatedBlockStorageClustersRequest::setStatus(const std::vector<std::string>& status)
{
status_ = status;
for(int dep1 = 0; dep1!= status.size(); dep1++) {
setParameter("Status."+ std::to_string(dep1), status.at(dep1));
}
}

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

@@ -0,0 +1,85 @@
/*
* 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["DedicatedBlockStorageClusterId"].isNull())
dedicatedBlockStorageClustersObject.dedicatedBlockStorageClusterId = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["DedicatedBlockStorageClusterId"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["DedicatedBlockStorageClusterName"].isNull())
dedicatedBlockStorageClustersObject.dedicatedBlockStorageClusterName = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["DedicatedBlockStorageClusterName"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Description"].isNull())
dedicatedBlockStorageClustersObject.description = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Description"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["ZoneId"].isNull())
dedicatedBlockStorageClustersObject.zoneId = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["ZoneId"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Status"].isNull())
dedicatedBlockStorageClustersObject.status = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Status"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Category"].isNull())
dedicatedBlockStorageClustersObject.category = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Category"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["PerformanceLevel"].isNull())
dedicatedBlockStorageClustersObject.performanceLevel = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["PerformanceLevel"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["ExpiredTime"].isNull())
dedicatedBlockStorageClustersObject.expiredTime = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["ExpiredTime"].asString();
if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["CreateTime"].isNull())
dedicatedBlockStorageClustersObject.createTime = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["CreateTime"].asString();
auto dedicatedBlockStorageClusterCapacityNode = value["DedicatedBlockStorageClusterCapacity"];
if(!dedicatedBlockStorageClusterCapacityNode["AvailableCapacity"].isNull())
dedicatedBlockStorageClustersObject.dedicatedBlockStorageClusterCapacity.availableCapacity = std::stol(dedicatedBlockStorageClusterCapacityNode["AvailableCapacity"].asString());
if(!dedicatedBlockStorageClusterCapacityNode["TotalCapacity"].isNull())
dedicatedBlockStorageClustersObject.dedicatedBlockStorageClusterCapacity.totalCapacity = std::stol(dedicatedBlockStorageClusterCapacityNode["TotalCapacity"].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_;
}

106
ecs/src/model/DescribeDiskReplicaPairsRequest.cc Normal file
View File

@@ -0,0 +1,106 @@
/*
* 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/DescribeDiskReplicaPairsRequest.h>
using AlibabaCloud::Ecs::Model::DescribeDiskReplicaPairsRequest;
DescribeDiskReplicaPairsRequest::DescribeDiskReplicaPairsRequest() :
RpcServiceRequest("ecs", "2014-05-26", "DescribeDiskReplicaPairs")
{
setMethod(HttpRequest::Method::Post);
}
DescribeDiskReplicaPairsRequest::~DescribeDiskReplicaPairsRequest()
{}
long DescribeDiskReplicaPairsRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDiskReplicaPairsRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDiskReplicaPairsRequest::getRegionId()const
{
return regionId_;
}
void DescribeDiskReplicaPairsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribeDiskReplicaPairsRequest::getNextToken()const
{
return nextToken_;
}
void DescribeDiskReplicaPairsRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
}
std::string DescribeDiskReplicaPairsRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDiskReplicaPairsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDiskReplicaPairsRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDiskReplicaPairsRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DescribeDiskReplicaPairsRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDiskReplicaPairsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
int DescribeDiskReplicaPairsRequest::getMaxResults()const
{
return maxResults_;
}
void DescribeDiskReplicaPairsRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
}

78
ecs/src/model/DescribeDiskReplicaPairsResult.cc Normal file
View File

@@ -0,0 +1,78 @@
/*
* 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/DescribeDiskReplicaPairsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
DescribeDiskReplicaPairsResult::DescribeDiskReplicaPairsResult() :
ServiceResult()
{}
DescribeDiskReplicaPairsResult::DescribeDiskReplicaPairsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeDiskReplicaPairsResult::~DescribeDiskReplicaPairsResult()
{}
void DescribeDiskReplicaPairsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDiskReplicaPairsNode = value["DiskReplicaPairs"]["DiskReplicaPair"];
for (auto valueDiskReplicaPairsDiskReplicaPair : allDiskReplicaPairsNode)
{
DiskReplicaPair diskReplicaPairsObject;
if(!valueDiskReplicaPairsDiskReplicaPair["ReplicaPairId"].isNull())
diskReplicaPairsObject.replicaPairId = valueDiskReplicaPairsDiskReplicaPair["ReplicaPairId"].asString();
if(!valueDiskReplicaPairsDiskReplicaPair["SourceRegion"].isNull())
diskReplicaPairsObject.sourceRegion = valueDiskReplicaPairsDiskReplicaPair["SourceRegion"].asString();
if(!valueDiskReplicaPairsDiskReplicaPair["SourceDiskId"].isNull())
diskReplicaPairsObject.sourceDiskId = valueDiskReplicaPairsDiskReplicaPair["SourceDiskId"].asString();
if(!valueDiskReplicaPairsDiskReplicaPair["DestinationRegion"].isNull())
diskReplicaPairsObject.destinationRegion = valueDiskReplicaPairsDiskReplicaPair["DestinationRegion"].asString();
if(!valueDiskReplicaPairsDiskReplicaPair["DestinationDiskId"].isNull())
diskReplicaPairsObject.destinationDiskId = valueDiskReplicaPairsDiskReplicaPair["DestinationDiskId"].asString();
if(!valueDiskReplicaPairsDiskReplicaPair["PairName"].isNull())
diskReplicaPairsObject.pairName = valueDiskReplicaPairsDiskReplicaPair["PairName"].asString();
if(!valueDiskReplicaPairsDiskReplicaPair["Description"].isNull())
diskReplicaPairsObject.description = valueDiskReplicaPairsDiskReplicaPair["Description"].asString();
if(!valueDiskReplicaPairsDiskReplicaPair["Status"].isNull())
diskReplicaPairsObject.status = valueDiskReplicaPairsDiskReplicaPair["Status"].asString();
diskReplicaPairs_.push_back(diskReplicaPairsObject);
}
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
}
std::string DescribeDiskReplicaPairsResult::getNextToken()const
{
return nextToken_;
}
std::vector<DescribeDiskReplicaPairsResult::DiskReplicaPair> DescribeDiskReplicaPairsResult::getDiskReplicaPairs()const
{
return diskReplicaPairs_;
}

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

@@ -117,6 +117,8 @@ void DescribeDisksResult::parse(const std::string &payload)
disksObject.bdfId = valueDisksDisk["BdfId"].asString();
if(!valueDisksDisk["SerialNumber"].isNull())
disksObject.serialNumber = valueDisksDisk["SerialNumber"].asString();
if(!valueDisksDisk["DedicatedBlockStorageClusterId"].isNull())
disksObject.dedicatedBlockStorageClusterId = valueDisksDisk["DedicatedBlockStorageClusterId"].asString();
auto allOperationLocksNode = valueDisksDisk["OperationLocks"]["OperationLock"];
for (auto valueDisksDiskOperationLocksOperationLock : allOperationLocksNode)
{

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

@@ -130,6 +130,19 @@ void DescribeInstanceHistoryEventsRequest::setEventPublishTimeEnd(const std::str
setParameter("EventPublishTimeEnd", eventPublishTimeEnd);
}
std::vector<std::string> DescribeInstanceHistoryEventsRequest::getResourceId()const
{
return resourceId_;
}
void DescribeInstanceHistoryEventsRequest::setResourceId(const std::vector<std::string>& resourceId)
{
resourceId_ = resourceId;
for(int dep1 = 0; dep1!= resourceId.size(); dep1++) {
setParameter("ResourceId."+ std::to_string(dep1), resourceId.at(dep1));
}
}
std::vector<std::string> DescribeInstanceHistoryEventsRequest::getInstanceEventType()const
{
return instanceEventType_;
@@ -187,6 +200,17 @@ void DescribeInstanceHistoryEventsRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeInstanceHistoryEventsRequest::getResourceType()const
{
return resourceType_;
}
void DescribeInstanceHistoryEventsRequest::setResourceType(const std::string& resourceType)
{
resourceType_ = resourceType;
setParameter("ResourceType", resourceType);
}
std::string DescribeInstanceHistoryEventsRequest::getEventPublishTimeStart()const
{
return eventPublishTimeStart_;

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

@@ -57,6 +57,8 @@ void DescribeInstanceHistoryEventsResult::parse(const std::string &payload)
instanceSystemEventSetObject.reason = valueInstanceSystemEventSetInstanceSystemEventType["Reason"].asString();
if(!valueInstanceSystemEventSetInstanceSystemEventType["ImpactLevel"].isNull())
instanceSystemEventSetObject.impactLevel = valueInstanceSystemEventSetInstanceSystemEventType["ImpactLevel"].asString();
if(!valueInstanceSystemEventSetInstanceSystemEventType["ResourceType"].isNull())
instanceSystemEventSetObject.resourceType = valueInstanceSystemEventSetInstanceSystemEventType["ResourceType"].asString();
auto eventTypeNode = value["EventType"];
if(!eventTypeNode["Code"].isNull())
instanceSystemEventSetObject.eventType.code = std::stoi(eventTypeNode["Code"].asString());

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

@@ -95,6 +95,12 @@ void DescribeInstanceTypesResult::parse(const std::string &payload)
instanceTypesObject.secondaryEniQueueNumber = std::stoi(valueInstanceTypesInstanceType["SecondaryEniQueueNumber"].asString());
if(!valueInstanceTypesInstanceType["DiskQuantity"].isNull())
instanceTypesObject.diskQuantity = std::stoi(valueInstanceTypesInstanceType["DiskQuantity"].asString());
if(!valueInstanceTypesInstanceType["EriQuantity"].isNull())
instanceTypesObject.eriQuantity = std::stoi(valueInstanceTypesInstanceType["EriQuantity"].asString());
if(!valueInstanceTypesInstanceType["QueuePairNumber"].isNull())
instanceTypesObject.queuePairNumber = std::stoi(valueInstanceTypesInstanceType["QueuePairNumber"].asString());
if(!valueInstanceTypesInstanceType["NvmeSupport"].isNull())
instanceTypesObject.nvmeSupport = valueInstanceTypesInstanceType["NvmeSupport"].asString();
instanceTypes_.push_back(instanceTypesObject);
}

4
ecs/src/model/DescribeInvocationsResult.cc
View File

@@ -59,6 +59,8 @@ void DescribeInvocationsResult::parse(const std::string &payload)
invocationsObject.frequency = valueInvocationsInvocation["Frequency"].asString();
if(!valueInvocationsInvocation["Timed"].isNull())
invocationsObject.timed = valueInvocationsInvocation["Timed"].asString() == "true";
if(!valueInvocationsInvocation["RepeatMode"].isNull())
invocationsObject.repeatMode = valueInvocationsInvocation["RepeatMode"].asString();
if(!valueInvocationsInvocation["InvokeStatus"].isNull())
invocationsObject.invokeStatus = valueInvocationsInvocation["InvokeStatus"].asString();
if(!valueInvocationsInvocation["InvocationStatus"].isNull())
@@ -75,6 +77,8 @@ void DescribeInvocationsResult::parse(const std::string &payload)
invokeInstancesObject.instanceId = valueInvocationsInvocationInvokeInstancesInvokeInstance["InstanceId"].asString();
if(!valueInvocationsInvocationInvokeInstancesInvokeInstance["Repeats"].isNull())
invokeInstancesObject.repeats = std::stoi(valueInvocationsInvocationInvokeInstancesInvokeInstance["Repeats"].asString());
if(!valueInvocationsInvocationInvokeInstancesInvokeInstance["Timed"].isNull())
invokeInstancesObject.timed = valueInvocationsInvocationInvokeInstancesInvokeInstance["Timed"].asString() == "true";
if(!valueInvocationsInvocationInvokeInstancesInvokeInstance["InstanceInvokeStatus"].isNull())
invokeInstancesObject.instanceInvokeStatus = valueInvocationsInvocationInvokeInstancesInvokeInstance["InstanceInvokeStatus"].asString();
if(!valueInvocationsInvocationInvokeInstancesInvokeInstance["InvocationStatus"].isNull())

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

@@ -124,14 +124,13 @@ void DescribeNetworkInterfaceAttributeResult::parse(const std::string &payload)
queueNumber_ = std::stoi(value["QueueNumber"].asString());
if(!value["OwnerId"].isNull())
ownerId_ = value["OwnerId"].asString();
if(!value["NetworkInterfaceTrafficMode"].isNull())
networkInterfaceTrafficMode_ = value["NetworkInterfaceTrafficMode"].asString();
if(!value["QueuePairNumber"].isNull())
queuePairNumber_ = std::stoi(value["QueuePairNumber"].asString());
}
std::string DescribeNetworkInterfaceAttributeResult::getStatus()const
{
return status_;
}
std::string DescribeNetworkInterfaceAttributeResult::getPrivateIpAddress()const
{
return privateIpAddress_;
@@ -142,11 +141,6 @@ std::string DescribeNetworkInterfaceAttributeResult::getDescription()const
return description_;
}
std::string DescribeNetworkInterfaceAttributeResult::getZoneId()const
{
return zoneId_;
}
std::string DescribeNetworkInterfaceAttributeResult::getResourceGroupId()const
{
return resourceGroupId_;
@@ -157,6 +151,51 @@ bool DescribeNetworkInterfaceAttributeResult::getServiceManaged()const
return serviceManaged_;
}
DescribeNetworkInterfaceAttributeResult::Attachment DescribeNetworkInterfaceAttributeResult::getAttachment()const
{
return attachment_;
}
std::string DescribeNetworkInterfaceAttributeResult::getNetworkInterfaceId()const
{
return networkInterfaceId_;
}
std::vector<DescribeNetworkInterfaceAttributeResult::Ipv6Set> DescribeNetworkInterfaceAttributeResult::getIpv6Sets()const
{
return ipv6Sets_;
}
std::string DescribeNetworkInterfaceAttributeResult::getOwnerId()const
{
return ownerId_;
}
DescribeNetworkInterfaceAttributeResult::AssociatedPublicIp DescribeNetworkInterfaceAttributeResult::getAssociatedPublicIp()const
{
return associatedPublicIp_;
}
std::vector<DescribeNetworkInterfaceAttributeResult::Tag> DescribeNetworkInterfaceAttributeResult::getTags()const
{
return tags_;
}
std::string DescribeNetworkInterfaceAttributeResult::getStatus()const
{
return status_;
}
std::string DescribeNetworkInterfaceAttributeResult::getNetworkInterfaceTrafficMode()const
{
return networkInterfaceTrafficMode_;
}
std::string DescribeNetworkInterfaceAttributeResult::getZoneId()const
{
return zoneId_;
}
std::string DescribeNetworkInterfaceAttributeResult::getInstanceId()const
{
return instanceId_;
@@ -172,16 +211,6 @@ std::string DescribeNetworkInterfaceAttributeResult::getNetworkInterfaceName()co
return networkInterfaceName_;
}
DescribeNetworkInterfaceAttributeResult::Attachment DescribeNetworkInterfaceAttributeResult::getAttachment()const
{
return attachment_;
}
std::string DescribeNetworkInterfaceAttributeResult::getNetworkInterfaceId()const
{
return networkInterfaceId_;
}
std::string DescribeNetworkInterfaceAttributeResult::getMacAddress()const
{
return macAddress_;
@@ -202,41 +231,26 @@ std::string DescribeNetworkInterfaceAttributeResult::getType()const
return type_;
}
std::vector<DescribeNetworkInterfaceAttributeResult::Ipv6Set> DescribeNetworkInterfaceAttributeResult::getIpv6Sets()const
{
return ipv6Sets_;
}
int DescribeNetworkInterfaceAttributeResult::getQueueNumber()const
{
return queueNumber_;
}
int DescribeNetworkInterfaceAttributeResult::getQueuePairNumber()const
{
return queuePairNumber_;
}
std::string DescribeNetworkInterfaceAttributeResult::getVpcId()const
{
return vpcId_;
}
std::string DescribeNetworkInterfaceAttributeResult::getOwnerId()const
{
return ownerId_;
}
DescribeNetworkInterfaceAttributeResult::AssociatedPublicIp DescribeNetworkInterfaceAttributeResult::getAssociatedPublicIp()const
{
return associatedPublicIp_;
}
std::string DescribeNetworkInterfaceAttributeResult::getCreationTime()const
{
return creationTime_;
}
std::vector<DescribeNetworkInterfaceAttributeResult::Tag> DescribeNetworkInterfaceAttributeResult::getTags()const
{
return tags_;
}
std::vector<DescribeNetworkInterfaceAttributeResult::PrivateIpSet> DescribeNetworkInterfaceAttributeResult::getPrivateIpSets()const
{
return privateIpSets_;

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

@@ -77,6 +77,10 @@ void DescribeNetworkInterfacesResult::parse(const std::string &payload)
networkInterfaceSetsObject.queueNumber = std::stoi(valueNetworkInterfaceSetsNetworkInterfaceSet["QueueNumber"].asString());
if(!valueNetworkInterfaceSetsNetworkInterfaceSet["OwnerId"].isNull())
networkInterfaceSetsObject.ownerId = valueNetworkInterfaceSetsNetworkInterfaceSet["OwnerId"].asString();
if(!valueNetworkInterfaceSetsNetworkInterfaceSet["NetworkInterfaceTrafficMode"].isNull())
networkInterfaceSetsObject.networkInterfaceTrafficMode = valueNetworkInterfaceSetsNetworkInterfaceSet["NetworkInterfaceTrafficMode"].asString();
if(!valueNetworkInterfaceSetsNetworkInterfaceSet["QueuePairNumber"].isNull())
networkInterfaceSetsObject.queuePairNumber = std::stoi(valueNetworkInterfaceSetsNetworkInterfaceSet["QueuePairNumber"].asString());
auto allPrivateIpSetsNode = valueNetworkInterfaceSetsNetworkInterfaceSet["PrivateIpSets"]["PrivateIpSet"];
for (auto valueNetworkInterfaceSetsNetworkInterfaceSetPrivateIpSetsPrivateIpSet : allPrivateIpSetsNode)
{

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

@@ -71,6 +71,17 @@ void InvokeCommandRequest::setRegionId(const std::string& regionId)
setParameter("RegionId", regionId);
}
std::string InvokeCommandRequest::getRepeatMode()const
{
return repeatMode_;
}
void InvokeCommandRequest::setRepeatMode(const std::string& repeatMode)
{
repeatMode_ = repeatMode;
setParameter("RepeatMode", repeatMode);
}
std::string InvokeCommandRequest::getWindowsPasswordName()const
{
return windowsPasswordName_;

11
ecs/src/model/ModifyDiskAttributeRequest.cc
View File

@@ -71,6 +71,17 @@ void ModifyDiskAttributeRequest::setDeleteAutoSnapshot(bool deleteAutoSnapshot)
setParameter("DeleteAutoSnapshot", deleteAutoSnapshot ? "true" : "false");
}
std::string ModifyDiskAttributeRequest::getRegionId()const
{
return regionId_;
}
void ModifyDiskAttributeRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::vector<std::string> ModifyDiskAttributeRequest::getDiskIds()const
{
return diskIds_;

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

@@ -126,6 +126,17 @@ void RunCommandRequest::setContentEncoding(const std::string& contentEncoding)
setParameter("ContentEncoding", contentEncoding);
}
std::string RunCommandRequest::getRepeatMode()const
{
return repeatMode_;
}
void RunCommandRequest::setRepeatMode(const std::string& repeatMode)
{
repeatMode_ = repeatMode;
setParameter("RepeatMode", repeatMode);
}
std::string RunCommandRequest::getWindowsPasswordName()const
{
return windowsPasswordName_;

95
ecs/src/model/StartDiskReplicaPairRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* 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/StartDiskReplicaPairRequest.h>
using AlibabaCloud::Ecs::Model::StartDiskReplicaPairRequest;
StartDiskReplicaPairRequest::StartDiskReplicaPairRequest() :
RpcServiceRequest("ecs", "2014-05-26", "StartDiskReplicaPair")
{
setMethod(HttpRequest::Method::Post);
}
StartDiskReplicaPairRequest::~StartDiskReplicaPairRequest()
{}
long StartDiskReplicaPairRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void StartDiskReplicaPairRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string StartDiskReplicaPairRequest::getRegionId()const
{
return regionId_;
}
void StartDiskReplicaPairRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string StartDiskReplicaPairRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void StartDiskReplicaPairRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string StartDiskReplicaPairRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void StartDiskReplicaPairRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long StartDiskReplicaPairRequest::getOwnerId()const
{
return ownerId_;
}
void StartDiskReplicaPairRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string StartDiskReplicaPairRequest::getReplicaPairId()const
{
return replicaPairId_;
}
void StartDiskReplicaPairRequest::setReplicaPairId(const std::string& replicaPairId)
{
replicaPairId_ = replicaPairId;
setParameter("ReplicaPairId", replicaPairId);
}

44
ecs/src/model/StartDiskReplicaPairResult.cc Normal file
View File

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

95
ecs/src/model/StopDiskReplicaPairRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* 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/StopDiskReplicaPairRequest.h>
using AlibabaCloud::Ecs::Model::StopDiskReplicaPairRequest;
StopDiskReplicaPairRequest::StopDiskReplicaPairRequest() :
RpcServiceRequest("ecs", "2014-05-26", "StopDiskReplicaPair")
{
setMethod(HttpRequest::Method::Post);
}
StopDiskReplicaPairRequest::~StopDiskReplicaPairRequest()
{}
long StopDiskReplicaPairRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void StopDiskReplicaPairRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string StopDiskReplicaPairRequest::getRegionId()const
{
return regionId_;
}
void StopDiskReplicaPairRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string StopDiskReplicaPairRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void StopDiskReplicaPairRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string StopDiskReplicaPairRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void StopDiskReplicaPairRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long StopDiskReplicaPairRequest::getOwnerId()const
{
return ownerId_;
}
void StopDiskReplicaPairRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string StopDiskReplicaPairRequest::getReplicaPairId()const
{
return replicaPairId_;
}
void StopDiskReplicaPairRequest::setReplicaPairId(const std::string& replicaPairId)
{
replicaPairId_ = replicaPairId;
setParameter("ReplicaPairId", replicaPairId);
}

44
ecs/src/model/StopDiskReplicaPairResult.cc Normal file
View File

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