From dcb1633973999e8f24c739c9655143043dfd9b7c Mon Sep 17 00:00:00 2001 From: sdk-team Date: Mon, 26 Oct 2020 14:44:03 +0000 Subject: [PATCH] Generated 2014-05-26 for Ecs. --- CHANGELOG | 3 + ecs/CMakeLists.txt | 16 + ecs/include/alibabacloud/ecs/EcsClient.h | 32 ++ .../model/CreateCapacityReservationRequest.h | 114 +++++++ .../model/CreateCapacityReservationResult.h | 51 ++++ ...cribeCapacityReservationInstancesRequest.h | 72 +++++ ...scribeCapacityReservationInstancesResult.h | 61 ++++ .../DescribeCapacityReservationsRequest.h | 84 ++++++ .../DescribeCapacityReservationsResult.h | 79 +++++ .../DescribeElasticityAssurancesRequest.h | 12 + .../model/ReleaseCapacityReservationRequest.h | 66 ++++ .../model/ReleaseCapacityReservationResult.h | 49 +++ .../ecs/model/RunInstancesRequest.h | 3 + ecs/src/EcsClient.cc | 144 +++++++++ .../model/CreateCapacityReservationRequest.cc | 284 ++++++++++++++++++ .../model/CreateCapacityReservationResult.cc | 51 ++++ ...ribeCapacityReservationInstancesRequest.cc | 128 ++++++++ ...cribeCapacityReservationInstancesResult.cc | 78 +++++ .../DescribeCapacityReservationsRequest.cc | 172 +++++++++++ .../DescribeCapacityReservationsResult.cc | 112 +++++++ .../DescribeElasticityAssurancesRequest.cc | 44 +++ .../ReleaseCapacityReservationRequest.cc | 106 +++++++ .../model/ReleaseCapacityReservationResult.cc | 44 +++ ecs/src/model/RunInstancesRequest.cc | 11 + 24 files changed, 1816 insertions(+) create mode 100644 ecs/include/alibabacloud/ecs/model/CreateCapacityReservationRequest.h create mode 100644 ecs/include/alibabacloud/ecs/model/CreateCapacityReservationResult.h create mode 100644 ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationInstancesRequest.h create mode 100644 ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationInstancesResult.h create mode 100644 ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationsRequest.h create mode 100644 ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationsResult.h create mode 100644 ecs/include/alibabacloud/ecs/model/ReleaseCapacityReservationRequest.h create mode 100644 ecs/include/alibabacloud/ecs/model/ReleaseCapacityReservationResult.h create mode 100644 ecs/src/model/CreateCapacityReservationRequest.cc create mode 100644 ecs/src/model/CreateCapacityReservationResult.cc create mode 100644 ecs/src/model/DescribeCapacityReservationInstancesRequest.cc create mode 100644 ecs/src/model/DescribeCapacityReservationInstancesResult.cc create mode 100644 ecs/src/model/DescribeCapacityReservationsRequest.cc create mode 100644 ecs/src/model/DescribeCapacityReservationsResult.cc create mode 100644 ecs/src/model/ReleaseCapacityReservationRequest.cc create mode 100644 ecs/src/model/ReleaseCapacityReservationResult.cc diff --git a/CHANGELOG b/CHANGELOG index 3284d2d89..2bbbabd95 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,6 @@ +2020-10-26 Version: patch +- Generated 2014-05-26 for `Ecs`. + 2020-10-26 Version: patch - Generated 2016-11-01 for `live`. diff --git a/ecs/CMakeLists.txt b/ecs/CMakeLists.txt index 8a8679d11..72457dd66 100644 --- a/ecs/CMakeLists.txt +++ b/ecs/CMakeLists.txt @@ -81,6 +81,8 @@ set(ecs_public_header_model include/alibabacloud/ecs/model/CreateAutoProvisioningGroupResult.h include/alibabacloud/ecs/model/CreateAutoSnapshotPolicyRequest.h include/alibabacloud/ecs/model/CreateAutoSnapshotPolicyResult.h + include/alibabacloud/ecs/model/CreateCapacityReservationRequest.h + include/alibabacloud/ecs/model/CreateCapacityReservationResult.h include/alibabacloud/ecs/model/CreateCommandRequest.h include/alibabacloud/ecs/model/CreateCommandResult.h include/alibabacloud/ecs/model/CreateDedicatedHostClusterRequest.h @@ -213,6 +215,10 @@ set(ecs_public_header_model include/alibabacloud/ecs/model/DescribeBandwidthLimitationResult.h include/alibabacloud/ecs/model/DescribeBandwidthPackagesRequest.h include/alibabacloud/ecs/model/DescribeBandwidthPackagesResult.h + include/alibabacloud/ecs/model/DescribeCapacityReservationInstancesRequest.h + include/alibabacloud/ecs/model/DescribeCapacityReservationInstancesResult.h + include/alibabacloud/ecs/model/DescribeCapacityReservationsRequest.h + include/alibabacloud/ecs/model/DescribeCapacityReservationsResult.h include/alibabacloud/ecs/model/DescribeClassicLinkInstancesRequest.h include/alibabacloud/ecs/model/DescribeClassicLinkInstancesResult.h include/alibabacloud/ecs/model/DescribeCloudAssistantStatusRequest.h @@ -555,6 +561,8 @@ set(ecs_public_header_model include/alibabacloud/ecs/model/RedeployDedicatedHostResult.h include/alibabacloud/ecs/model/RedeployInstanceRequest.h include/alibabacloud/ecs/model/RedeployInstanceResult.h + include/alibabacloud/ecs/model/ReleaseCapacityReservationRequest.h + include/alibabacloud/ecs/model/ReleaseCapacityReservationResult.h include/alibabacloud/ecs/model/ReleaseDedicatedHostRequest.h include/alibabacloud/ecs/model/ReleaseDedicatedHostResult.h include/alibabacloud/ecs/model/ReleaseEipAddressRequest.h @@ -678,6 +686,8 @@ set(ecs_src src/model/CreateAutoProvisioningGroupResult.cc src/model/CreateAutoSnapshotPolicyRequest.cc src/model/CreateAutoSnapshotPolicyResult.cc + src/model/CreateCapacityReservationRequest.cc + src/model/CreateCapacityReservationResult.cc src/model/CreateCommandRequest.cc src/model/CreateCommandResult.cc src/model/CreateDedicatedHostClusterRequest.cc @@ -810,6 +820,10 @@ set(ecs_src src/model/DescribeBandwidthLimitationResult.cc src/model/DescribeBandwidthPackagesRequest.cc src/model/DescribeBandwidthPackagesResult.cc + src/model/DescribeCapacityReservationInstancesRequest.cc + src/model/DescribeCapacityReservationInstancesResult.cc + src/model/DescribeCapacityReservationsRequest.cc + src/model/DescribeCapacityReservationsResult.cc src/model/DescribeClassicLinkInstancesRequest.cc src/model/DescribeClassicLinkInstancesResult.cc src/model/DescribeCloudAssistantStatusRequest.cc @@ -1152,6 +1166,8 @@ set(ecs_src src/model/RedeployDedicatedHostResult.cc src/model/RedeployInstanceRequest.cc src/model/RedeployInstanceResult.cc + src/model/ReleaseCapacityReservationRequest.cc + src/model/ReleaseCapacityReservationResult.cc src/model/ReleaseDedicatedHostRequest.cc src/model/ReleaseDedicatedHostResult.cc src/model/ReleaseEipAddressRequest.cc diff --git a/ecs/include/alibabacloud/ecs/EcsClient.h b/ecs/include/alibabacloud/ecs/EcsClient.h index 31dc7869c..9c3194463 100644 --- a/ecs/include/alibabacloud/ecs/EcsClient.h +++ b/ecs/include/alibabacloud/ecs/EcsClient.h @@ -82,6 +82,8 @@ #include "model/CreateAutoProvisioningGroupResult.h" #include "model/CreateAutoSnapshotPolicyRequest.h" #include "model/CreateAutoSnapshotPolicyResult.h" +#include "model/CreateCapacityReservationRequest.h" +#include "model/CreateCapacityReservationResult.h" #include "model/CreateCommandRequest.h" #include "model/CreateCommandResult.h" #include "model/CreateDedicatedHostClusterRequest.h" @@ -214,6 +216,10 @@ #include "model/DescribeBandwidthLimitationResult.h" #include "model/DescribeBandwidthPackagesRequest.h" #include "model/DescribeBandwidthPackagesResult.h" +#include "model/DescribeCapacityReservationInstancesRequest.h" +#include "model/DescribeCapacityReservationInstancesResult.h" +#include "model/DescribeCapacityReservationsRequest.h" +#include "model/DescribeCapacityReservationsResult.h" #include "model/DescribeClassicLinkInstancesRequest.h" #include "model/DescribeClassicLinkInstancesResult.h" #include "model/DescribeCloudAssistantStatusRequest.h" @@ -556,6 +562,8 @@ #include "model/RedeployDedicatedHostResult.h" #include "model/RedeployInstanceRequest.h" #include "model/RedeployInstanceResult.h" +#include "model/ReleaseCapacityReservationRequest.h" +#include "model/ReleaseCapacityReservationResult.h" #include "model/ReleaseDedicatedHostRequest.h" #include "model/ReleaseDedicatedHostResult.h" #include "model/ReleaseEipAddressRequest.h" @@ -715,6 +723,9 @@ namespace AlibabaCloud typedef Outcome CreateAutoSnapshotPolicyOutcome; typedef std::future CreateAutoSnapshotPolicyOutcomeCallable; typedef std::function&)> CreateAutoSnapshotPolicyAsyncHandler; + typedef Outcome CreateCapacityReservationOutcome; + typedef std::future CreateCapacityReservationOutcomeCallable; + typedef std::function&)> CreateCapacityReservationAsyncHandler; typedef Outcome CreateCommandOutcome; typedef std::future CreateCommandOutcomeCallable; typedef std::function&)> CreateCommandAsyncHandler; @@ -913,6 +924,12 @@ namespace AlibabaCloud typedef Outcome DescribeBandwidthPackagesOutcome; typedef std::future DescribeBandwidthPackagesOutcomeCallable; typedef std::function&)> DescribeBandwidthPackagesAsyncHandler; + typedef Outcome DescribeCapacityReservationInstancesOutcome; + typedef std::future DescribeCapacityReservationInstancesOutcomeCallable; + typedef std::function&)> DescribeCapacityReservationInstancesAsyncHandler; + typedef Outcome DescribeCapacityReservationsOutcome; + typedef std::future DescribeCapacityReservationsOutcomeCallable; + typedef std::function&)> DescribeCapacityReservationsAsyncHandler; typedef Outcome DescribeClassicLinkInstancesOutcome; typedef std::future DescribeClassicLinkInstancesOutcomeCallable; typedef std::function&)> DescribeClassicLinkInstancesAsyncHandler; @@ -1426,6 +1443,9 @@ namespace AlibabaCloud typedef Outcome RedeployInstanceOutcome; typedef std::future RedeployInstanceOutcomeCallable; typedef std::function&)> RedeployInstanceAsyncHandler; + typedef Outcome ReleaseCapacityReservationOutcome; + typedef std::future ReleaseCapacityReservationOutcomeCallable; + typedef std::function&)> ReleaseCapacityReservationAsyncHandler; typedef Outcome ReleaseDedicatedHostOutcome; typedef std::future ReleaseDedicatedHostOutcomeCallable; typedef std::function&)> ReleaseDedicatedHostAsyncHandler; @@ -1611,6 +1631,9 @@ namespace AlibabaCloud CreateAutoSnapshotPolicyOutcome createAutoSnapshotPolicy(const Model::CreateAutoSnapshotPolicyRequest &request)const; void createAutoSnapshotPolicyAsync(const Model::CreateAutoSnapshotPolicyRequest& request, const CreateAutoSnapshotPolicyAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; CreateAutoSnapshotPolicyOutcomeCallable createAutoSnapshotPolicyCallable(const Model::CreateAutoSnapshotPolicyRequest& request) const; + CreateCapacityReservationOutcome createCapacityReservation(const Model::CreateCapacityReservationRequest &request)const; + void createCapacityReservationAsync(const Model::CreateCapacityReservationRequest& request, const CreateCapacityReservationAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateCapacityReservationOutcomeCallable createCapacityReservationCallable(const Model::CreateCapacityReservationRequest& request) const; CreateCommandOutcome createCommand(const Model::CreateCommandRequest &request)const; void createCommandAsync(const Model::CreateCommandRequest& request, const CreateCommandAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; CreateCommandOutcomeCallable createCommandCallable(const Model::CreateCommandRequest& request) const; @@ -1809,6 +1832,12 @@ namespace AlibabaCloud DescribeBandwidthPackagesOutcome describeBandwidthPackages(const Model::DescribeBandwidthPackagesRequest &request)const; void describeBandwidthPackagesAsync(const Model::DescribeBandwidthPackagesRequest& request, const DescribeBandwidthPackagesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeBandwidthPackagesOutcomeCallable describeBandwidthPackagesCallable(const Model::DescribeBandwidthPackagesRequest& request) const; + DescribeCapacityReservationInstancesOutcome describeCapacityReservationInstances(const Model::DescribeCapacityReservationInstancesRequest &request)const; + void describeCapacityReservationInstancesAsync(const Model::DescribeCapacityReservationInstancesRequest& request, const DescribeCapacityReservationInstancesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeCapacityReservationInstancesOutcomeCallable describeCapacityReservationInstancesCallable(const Model::DescribeCapacityReservationInstancesRequest& request) const; + DescribeCapacityReservationsOutcome describeCapacityReservations(const Model::DescribeCapacityReservationsRequest &request)const; + void describeCapacityReservationsAsync(const Model::DescribeCapacityReservationsRequest& request, const DescribeCapacityReservationsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeCapacityReservationsOutcomeCallable describeCapacityReservationsCallable(const Model::DescribeCapacityReservationsRequest& request) const; DescribeClassicLinkInstancesOutcome describeClassicLinkInstances(const Model::DescribeClassicLinkInstancesRequest &request)const; void describeClassicLinkInstancesAsync(const Model::DescribeClassicLinkInstancesRequest& request, const DescribeClassicLinkInstancesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeClassicLinkInstancesOutcomeCallable describeClassicLinkInstancesCallable(const Model::DescribeClassicLinkInstancesRequest& request) const; @@ -2322,6 +2351,9 @@ namespace AlibabaCloud RedeployInstanceOutcome redeployInstance(const Model::RedeployInstanceRequest &request)const; void redeployInstanceAsync(const Model::RedeployInstanceRequest& request, const RedeployInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; RedeployInstanceOutcomeCallable redeployInstanceCallable(const Model::RedeployInstanceRequest& request) const; + ReleaseCapacityReservationOutcome releaseCapacityReservation(const Model::ReleaseCapacityReservationRequest &request)const; + void releaseCapacityReservationAsync(const Model::ReleaseCapacityReservationRequest& request, const ReleaseCapacityReservationAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ReleaseCapacityReservationOutcomeCallable releaseCapacityReservationCallable(const Model::ReleaseCapacityReservationRequest& request) const; ReleaseDedicatedHostOutcome releaseDedicatedHost(const Model::ReleaseDedicatedHostRequest &request)const; void releaseDedicatedHostAsync(const Model::ReleaseDedicatedHostRequest& request, const ReleaseDedicatedHostAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ReleaseDedicatedHostOutcomeCallable releaseDedicatedHostCallable(const Model::ReleaseDedicatedHostRequest& request) const; diff --git a/ecs/include/alibabacloud/ecs/model/CreateCapacityReservationRequest.h b/ecs/include/alibabacloud/ecs/model/CreateCapacityReservationRequest.h new file mode 100644 index 000000000..3af946fb7 --- /dev/null +++ b/ecs/include/alibabacloud/ecs/model/CreateCapacityReservationRequest.h @@ -0,0 +1,114 @@ +/* + * 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. + */ + +#ifndef ALIBABACLOUD_ECS_MODEL_CREATECAPACITYRESERVATIONREQUEST_H_ +#define ALIBABACLOUD_ECS_MODEL_CREATECAPACITYRESERVATIONREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Ecs + { + namespace Model + { + class ALIBABACLOUD_ECS_EXPORT CreateCapacityReservationRequest : public RpcServiceRequest + { + + public: + CreateCapacityReservationRequest(); + ~CreateCapacityReservationRequest(); + + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getClientToken()const; + void setClientToken(const std::string& clientToken); + std::string getDescription()const; + void setDescription(const std::string& description); + std::string getStartTime()const; + void setStartTime(const std::string& startTime); + std::string getPlatform()const; + void setPlatform(const std::string& platform); + std::string getPrivatePoolOptionsMatchCriteria()const; + void setPrivatePoolOptionsMatchCriteria(const std::string& privatePoolOptionsMatchCriteria); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getInstanceType()const; + void setInstanceType(const std::string& instanceType); + std::string getInstanceChargeType()const; + void setInstanceChargeType(const std::string& instanceChargeType); + int getEfficientStatus()const; + void setEfficientStatus(int efficientStatus); + int getPeriod()const; + void setPeriod(int period); + std::string getEndTimeType()const; + void setEndTimeType(const std::string& endTimeType); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getPrivatePoolOptionsName()const; + void setPrivatePoolOptionsName(const std::string& privatePoolOptionsName); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + std::string getEndTime()const; + void setEndTime(const std::string& endTime); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getResourceType()const; + void setResourceType(const std::string& resourceType); + std::string getPeriodUnit()const; + void setPeriodUnit(const std::string& periodUnit); + std::vector getZoneId()const; + void setZoneId(const std::vector& zoneId); + std::string getChargeType()const; + void setChargeType(const std::string& chargeType); + std::string getPackageType()const; + void setPackageType(const std::string& packageType); + int getInstanceAmount()const; + void setInstanceAmount(int instanceAmount); + + private: + long resourceOwnerId_; + std::string clientToken_; + std::string description_; + std::string startTime_; + std::string platform_; + std::string privatePoolOptionsMatchCriteria_; + std::string regionId_; + std::string instanceType_; + std::string instanceChargeType_; + int efficientStatus_; + int period_; + std::string endTimeType_; + std::string resourceOwnerAccount_; + std::string privatePoolOptionsName_; + std::string ownerAccount_; + std::string endTime_; + long ownerId_; + std::string resourceType_; + std::string periodUnit_; + std::vector zoneId_; + std::string chargeType_; + std::string packageType_; + int instanceAmount_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ECS_MODEL_CREATECAPACITYRESERVATIONREQUEST_H_ \ No newline at end of file diff --git a/ecs/include/alibabacloud/ecs/model/CreateCapacityReservationResult.h b/ecs/include/alibabacloud/ecs/model/CreateCapacityReservationResult.h new file mode 100644 index 000000000..1874b0e2f --- /dev/null +++ b/ecs/include/alibabacloud/ecs/model/CreateCapacityReservationResult.h @@ -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. + */ + +#ifndef ALIBABACLOUD_ECS_MODEL_CREATECAPACITYRESERVATIONRESULT_H_ +#define ALIBABACLOUD_ECS_MODEL_CREATECAPACITYRESERVATIONRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Ecs + { + namespace Model + { + class ALIBABACLOUD_ECS_EXPORT CreateCapacityReservationResult : public ServiceResult + { + public: + + + CreateCapacityReservationResult(); + explicit CreateCapacityReservationResult(const std::string &payload); + ~CreateCapacityReservationResult(); + std::string getPrivatePoolOptionsId()const; + + protected: + void parse(const std::string &payload); + private: + std::string privatePoolOptionsId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ECS_MODEL_CREATECAPACITYRESERVATIONRESULT_H_ \ No newline at end of file diff --git a/ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationInstancesRequest.h b/ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationInstancesRequest.h new file mode 100644 index 000000000..3687f45ad --- /dev/null +++ b/ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationInstancesRequest.h @@ -0,0 +1,72 @@ +/* + * 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. + */ + +#ifndef ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONINSTANCESREQUEST_H_ +#define ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONINSTANCESREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Ecs + { + namespace Model + { + class ALIBABACLOUD_ECS_EXPORT DescribeCapacityReservationInstancesRequest : public RpcServiceRequest + { + + public: + DescribeCapacityReservationInstancesRequest(); + ~DescribeCapacityReservationInstancesRequest(); + + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getNextToken()const; + void setNextToken(const std::string& nextToken); + std::string getPrivatePoolOptionsId()const; + void setPrivatePoolOptionsId(const std::string& privatePoolOptionsId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + int getMaxResults()const; + void setMaxResults(int maxResults); + std::string getPackageType()const; + void setPackageType(const std::string& packageType); + + private: + long resourceOwnerId_; + std::string regionId_; + std::string nextToken_; + std::string privatePoolOptionsId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + int maxResults_; + std::string packageType_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONINSTANCESREQUEST_H_ \ No newline at end of file diff --git a/ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationInstancesResult.h b/ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationInstancesResult.h new file mode 100644 index 000000000..abbc5a1ab --- /dev/null +++ b/ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationInstancesResult.h @@ -0,0 +1,61 @@ +/* + * 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. + */ + +#ifndef ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONINSTANCESRESULT_H_ +#define ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONINSTANCESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Ecs + { + namespace Model + { + class ALIBABACLOUD_ECS_EXPORT DescribeCapacityReservationInstancesResult : public ServiceResult + { + public: + struct InstanceIdSet + { + std::string instanceId; + }; + + + DescribeCapacityReservationInstancesResult(); + explicit DescribeCapacityReservationInstancesResult(const std::string &payload); + ~DescribeCapacityReservationInstancesResult(); + std::vector getCapacityReservationItem()const; + int getTotalCount()const; + std::string getNextToken()const; + int getMaxResults()const; + + protected: + void parse(const std::string &payload); + private: + std::vector capacityReservationItem_; + int totalCount_; + std::string nextToken_; + int maxResults_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONINSTANCESRESULT_H_ \ No newline at end of file diff --git a/ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationsRequest.h b/ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationsRequest.h new file mode 100644 index 000000000..9304450c2 --- /dev/null +++ b/ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationsRequest.h @@ -0,0 +1,84 @@ +/* + * 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. + */ + +#ifndef ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONSREQUEST_H_ +#define ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Ecs + { + namespace Model + { + class ALIBABACLOUD_ECS_EXPORT DescribeCapacityReservationsRequest : public RpcServiceRequest + { + + public: + DescribeCapacityReservationsRequest(); + ~DescribeCapacityReservationsRequest(); + + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getPlatform()const; + void setPlatform(const std::string& platform); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getNextToken()const; + void setNextToken(const std::string& nextToken); + std::string getInstanceType()const; + void setInstanceType(const std::string& instanceType); + std::string getInstanceChargeType()const; + void setInstanceChargeType(const std::string& instanceChargeType); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getPrivatePoolOptionsIds()const; + void setPrivatePoolOptionsIds(const std::string& privatePoolOptionsIds); + int getMaxResults()const; + void setMaxResults(int maxResults); + std::string getZoneId()const; + void setZoneId(const std::string& zoneId); + std::string getPackageType()const; + void setPackageType(const std::string& packageType); + + private: + long resourceOwnerId_; + std::string platform_; + std::string regionId_; + std::string nextToken_; + std::string instanceType_; + std::string instanceChargeType_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string privatePoolOptionsIds_; + int maxResults_; + std::string zoneId_; + std::string packageType_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONSREQUEST_H_ \ No newline at end of file diff --git a/ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationsResult.h b/ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationsResult.h new file mode 100644 index 000000000..3a6bf37e6 --- /dev/null +++ b/ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationsResult.h @@ -0,0 +1,79 @@ +/* + * 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. + */ + +#ifndef ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONSRESULT_H_ +#define ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Ecs + { + namespace Model + { + class ALIBABACLOUD_ECS_EXPORT DescribeCapacityReservationsResult : public ServiceResult + { + public: + struct CapacityReservationItem + { + struct AllocatedResource + { + int usedAmount; + std::string zoneId; + int totalAmount; + std::string instanceType; + }; + std::string status; + std::string description; + std::string endTime; + std::string endTimeType; + std::string platform; + std::string privatePoolOptionsName; + std::string instanceChargeType; + std::string startTime; + std::string regionId; + std::string privatePoolOptionsMatchCriteria; + std::vector allocatedResources; + std::string privatePoolOptionsId; + }; + + + DescribeCapacityReservationsResult(); + explicit DescribeCapacityReservationsResult(const std::string &payload); + ~DescribeCapacityReservationsResult(); + int getTotalCount()const; + std::string getNextToken()const; + int getMaxResults()const; + std::vector getCapacityReservationSet()const; + + protected: + void parse(const std::string &payload); + private: + int totalCount_; + std::string nextToken_; + int maxResults_; + std::vector capacityReservationSet_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONSRESULT_H_ \ No newline at end of file diff --git a/ecs/include/alibabacloud/ecs/model/DescribeElasticityAssurancesRequest.h b/ecs/include/alibabacloud/ecs/model/DescribeElasticityAssurancesRequest.h index bc796e5ff..50522a0b2 100644 --- a/ecs/include/alibabacloud/ecs/model/DescribeElasticityAssurancesRequest.h +++ b/ecs/include/alibabacloud/ecs/model/DescribeElasticityAssurancesRequest.h @@ -37,10 +37,16 @@ namespace AlibabaCloud long getResourceOwnerId()const; void setResourceOwnerId(long resourceOwnerId); + std::string getPlatform()const; + void setPlatform(const std::string& platform); std::string getRegionId()const; void setRegionId(const std::string& regionId); std::string getNextToken()const; void setNextToken(const std::string& nextToken); + std::string getInstanceType()const; + void setInstanceType(const std::string& instanceType); + std::string getInstanceChargeType()const; + void setInstanceChargeType(const std::string& instanceChargeType); std::string getResourceOwnerAccount()const; void setResourceOwnerAccount(const std::string& resourceOwnerAccount); std::string getOwnerAccount()const; @@ -51,18 +57,24 @@ namespace AlibabaCloud void setPrivatePoolOptionsIds(const std::string& privatePoolOptionsIds); int getMaxResults()const; void setMaxResults(int maxResults); + std::string getZoneId()const; + void setZoneId(const std::string& zoneId); std::string getPackageType()const; void setPackageType(const std::string& packageType); private: long resourceOwnerId_; + std::string platform_; std::string regionId_; std::string nextToken_; + std::string instanceType_; + std::string instanceChargeType_; std::string resourceOwnerAccount_; std::string ownerAccount_; long ownerId_; std::string privatePoolOptionsIds_; int maxResults_; + std::string zoneId_; std::string packageType_; }; diff --git a/ecs/include/alibabacloud/ecs/model/ReleaseCapacityReservationRequest.h b/ecs/include/alibabacloud/ecs/model/ReleaseCapacityReservationRequest.h new file mode 100644 index 000000000..c5d16a82c --- /dev/null +++ b/ecs/include/alibabacloud/ecs/model/ReleaseCapacityReservationRequest.h @@ -0,0 +1,66 @@ +/* + * 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. + */ + +#ifndef ALIBABACLOUD_ECS_MODEL_RELEASECAPACITYRESERVATIONREQUEST_H_ +#define ALIBABACLOUD_ECS_MODEL_RELEASECAPACITYRESERVATIONREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Ecs + { + namespace Model + { + class ALIBABACLOUD_ECS_EXPORT ReleaseCapacityReservationRequest : public RpcServiceRequest + { + + public: + ReleaseCapacityReservationRequest(); + ~ReleaseCapacityReservationRequest(); + + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getPrivatePoolOptionsId()const; + void setPrivatePoolOptionsId(const std::string& privatePoolOptionsId); + bool getDryRun()const; + void setDryRun(bool dryRun); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + + private: + long resourceOwnerId_; + std::string regionId_; + std::string privatePoolOptionsId_; + bool dryRun_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ECS_MODEL_RELEASECAPACITYRESERVATIONREQUEST_H_ \ No newline at end of file diff --git a/ecs/include/alibabacloud/ecs/model/ReleaseCapacityReservationResult.h b/ecs/include/alibabacloud/ecs/model/ReleaseCapacityReservationResult.h new file mode 100644 index 000000000..4dc588c44 --- /dev/null +++ b/ecs/include/alibabacloud/ecs/model/ReleaseCapacityReservationResult.h @@ -0,0 +1,49 @@ +/* + * 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. + */ + +#ifndef ALIBABACLOUD_ECS_MODEL_RELEASECAPACITYRESERVATIONRESULT_H_ +#define ALIBABACLOUD_ECS_MODEL_RELEASECAPACITYRESERVATIONRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Ecs + { + namespace Model + { + class ALIBABACLOUD_ECS_EXPORT ReleaseCapacityReservationResult : public ServiceResult + { + public: + + + ReleaseCapacityReservationResult(); + explicit ReleaseCapacityReservationResult(const std::string &payload); + ~ReleaseCapacityReservationResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_ECS_MODEL_RELEASECAPACITYRESERVATIONRESULT_H_ \ No newline at end of file diff --git a/ecs/include/alibabacloud/ecs/model/RunInstancesRequest.h b/ecs/include/alibabacloud/ecs/model/RunInstancesRequest.h index 3e1bf8b9f..755663618 100644 --- a/ecs/include/alibabacloud/ecs/model/RunInstancesRequest.h +++ b/ecs/include/alibabacloud/ecs/model/RunInstancesRequest.h @@ -226,6 +226,8 @@ namespace AlibabaCloud void setDataDisk(const std::vector& dataDisk); long getLaunchTemplateVersion()const; void setLaunchTemplateVersion(long launchTemplateVersion); + std::string getSchedulerOptionsManagedPrivateSpaceId()const; + void setSchedulerOptionsManagedPrivateSpaceId(const std::string& schedulerOptionsManagedPrivateSpaceId); std::string getStorageSetId()const; void setStorageSetId(const std::string& storageSetId); std::string getHttpTokens()const; @@ -311,6 +313,7 @@ namespace AlibabaCloud std::string creditSpecification_; std::vector dataDisk_; long launchTemplateVersion_; + std::string schedulerOptionsManagedPrivateSpaceId_; std::string storageSetId_; std::string httpTokens_; std::string systemDiskDescription_; diff --git a/ecs/src/EcsClient.cc b/ecs/src/EcsClient.cc index ec4f1605c..e64210bdf 100644 --- a/ecs/src/EcsClient.cc +++ b/ecs/src/EcsClient.cc @@ -1131,6 +1131,42 @@ EcsClient::CreateAutoSnapshotPolicyOutcomeCallable EcsClient::createAutoSnapshot return task->get_future(); } +EcsClient::CreateCapacityReservationOutcome EcsClient::createCapacityReservation(const CreateCapacityReservationRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CreateCapacityReservationOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateCapacityReservationOutcome(CreateCapacityReservationResult(outcome.result())); + else + return CreateCapacityReservationOutcome(outcome.error()); +} + +void EcsClient::createCapacityReservationAsync(const CreateCapacityReservationRequest& request, const CreateCapacityReservationAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createCapacityReservation(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EcsClient::CreateCapacityReservationOutcomeCallable EcsClient::createCapacityReservationCallable(const CreateCapacityReservationRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createCapacityReservation(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + EcsClient::CreateCommandOutcome EcsClient::createCommand(const CreateCommandRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -3507,6 +3543,78 @@ EcsClient::DescribeBandwidthPackagesOutcomeCallable EcsClient::describeBandwidth return task->get_future(); } +EcsClient::DescribeCapacityReservationInstancesOutcome EcsClient::describeCapacityReservationInstances(const DescribeCapacityReservationInstancesRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeCapacityReservationInstancesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeCapacityReservationInstancesOutcome(DescribeCapacityReservationInstancesResult(outcome.result())); + else + return DescribeCapacityReservationInstancesOutcome(outcome.error()); +} + +void EcsClient::describeCapacityReservationInstancesAsync(const DescribeCapacityReservationInstancesRequest& request, const DescribeCapacityReservationInstancesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeCapacityReservationInstances(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EcsClient::DescribeCapacityReservationInstancesOutcomeCallable EcsClient::describeCapacityReservationInstancesCallable(const DescribeCapacityReservationInstancesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeCapacityReservationInstances(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +EcsClient::DescribeCapacityReservationsOutcome EcsClient::describeCapacityReservations(const DescribeCapacityReservationsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeCapacityReservationsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeCapacityReservationsOutcome(DescribeCapacityReservationsResult(outcome.result())); + else + return DescribeCapacityReservationsOutcome(outcome.error()); +} + +void EcsClient::describeCapacityReservationsAsync(const DescribeCapacityReservationsRequest& request, const DescribeCapacityReservationsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeCapacityReservations(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EcsClient::DescribeCapacityReservationsOutcomeCallable EcsClient::describeCapacityReservationsCallable(const DescribeCapacityReservationsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeCapacityReservations(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + EcsClient::DescribeClassicLinkInstancesOutcome EcsClient::describeClassicLinkInstances(const DescribeClassicLinkInstancesRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -9663,6 +9771,42 @@ EcsClient::RedeployInstanceOutcomeCallable EcsClient::redeployInstanceCallable(c return task->get_future(); } +EcsClient::ReleaseCapacityReservationOutcome EcsClient::releaseCapacityReservation(const ReleaseCapacityReservationRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ReleaseCapacityReservationOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ReleaseCapacityReservationOutcome(ReleaseCapacityReservationResult(outcome.result())); + else + return ReleaseCapacityReservationOutcome(outcome.error()); +} + +void EcsClient::releaseCapacityReservationAsync(const ReleaseCapacityReservationRequest& request, const ReleaseCapacityReservationAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, releaseCapacityReservation(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EcsClient::ReleaseCapacityReservationOutcomeCallable EcsClient::releaseCapacityReservationCallable(const ReleaseCapacityReservationRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->releaseCapacityReservation(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + EcsClient::ReleaseDedicatedHostOutcome EcsClient::releaseDedicatedHost(const ReleaseDedicatedHostRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); diff --git a/ecs/src/model/CreateCapacityReservationRequest.cc b/ecs/src/model/CreateCapacityReservationRequest.cc new file mode 100644 index 000000000..ef4ffb1ee --- /dev/null +++ b/ecs/src/model/CreateCapacityReservationRequest.cc @@ -0,0 +1,284 @@ +/* + * 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 + +using AlibabaCloud::Ecs::Model::CreateCapacityReservationRequest; + +CreateCapacityReservationRequest::CreateCapacityReservationRequest() : + RpcServiceRequest("ecs", "2014-05-26", "CreateCapacityReservation") +{ + setMethod(HttpRequest::Method::Post); +} + +CreateCapacityReservationRequest::~CreateCapacityReservationRequest() +{} + +long CreateCapacityReservationRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void CreateCapacityReservationRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string CreateCapacityReservationRequest::getClientToken()const +{ + return clientToken_; +} + +void CreateCapacityReservationRequest::setClientToken(const std::string& clientToken) +{ + clientToken_ = clientToken; + setParameter("ClientToken", clientToken); +} + +std::string CreateCapacityReservationRequest::getDescription()const +{ + return description_; +} + +void CreateCapacityReservationRequest::setDescription(const std::string& description) +{ + description_ = description; + setParameter("Description", description); +} + +std::string CreateCapacityReservationRequest::getStartTime()const +{ + return startTime_; +} + +void CreateCapacityReservationRequest::setStartTime(const std::string& startTime) +{ + startTime_ = startTime; + setParameter("StartTime", startTime); +} + +std::string CreateCapacityReservationRequest::getPlatform()const +{ + return platform_; +} + +void CreateCapacityReservationRequest::setPlatform(const std::string& platform) +{ + platform_ = platform; + setParameter("Platform", platform); +} + +std::string CreateCapacityReservationRequest::getPrivatePoolOptionsMatchCriteria()const +{ + return privatePoolOptionsMatchCriteria_; +} + +void CreateCapacityReservationRequest::setPrivatePoolOptionsMatchCriteria(const std::string& privatePoolOptionsMatchCriteria) +{ + privatePoolOptionsMatchCriteria_ = privatePoolOptionsMatchCriteria; + setParameter("PrivatePoolOptionsMatchCriteria", privatePoolOptionsMatchCriteria); +} + +std::string CreateCapacityReservationRequest::getRegionId()const +{ + return regionId_; +} + +void CreateCapacityReservationRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string CreateCapacityReservationRequest::getInstanceType()const +{ + return instanceType_; +} + +void CreateCapacityReservationRequest::setInstanceType(const std::string& instanceType) +{ + instanceType_ = instanceType; + setParameter("InstanceType", instanceType); +} + +std::string CreateCapacityReservationRequest::getInstanceChargeType()const +{ + return instanceChargeType_; +} + +void CreateCapacityReservationRequest::setInstanceChargeType(const std::string& instanceChargeType) +{ + instanceChargeType_ = instanceChargeType; + setParameter("InstanceChargeType", instanceChargeType); +} + +int CreateCapacityReservationRequest::getEfficientStatus()const +{ + return efficientStatus_; +} + +void CreateCapacityReservationRequest::setEfficientStatus(int efficientStatus) +{ + efficientStatus_ = efficientStatus; + setParameter("EfficientStatus", std::to_string(efficientStatus)); +} + +int CreateCapacityReservationRequest::getPeriod()const +{ + return period_; +} + +void CreateCapacityReservationRequest::setPeriod(int period) +{ + period_ = period; + setParameter("Period", std::to_string(period)); +} + +std::string CreateCapacityReservationRequest::getEndTimeType()const +{ + return endTimeType_; +} + +void CreateCapacityReservationRequest::setEndTimeType(const std::string& endTimeType) +{ + endTimeType_ = endTimeType; + setParameter("EndTimeType", endTimeType); +} + +std::string CreateCapacityReservationRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void CreateCapacityReservationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string CreateCapacityReservationRequest::getPrivatePoolOptionsName()const +{ + return privatePoolOptionsName_; +} + +void CreateCapacityReservationRequest::setPrivatePoolOptionsName(const std::string& privatePoolOptionsName) +{ + privatePoolOptionsName_ = privatePoolOptionsName; + setParameter("PrivatePoolOptionsName", privatePoolOptionsName); +} + +std::string CreateCapacityReservationRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void CreateCapacityReservationRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +std::string CreateCapacityReservationRequest::getEndTime()const +{ + return endTime_; +} + +void CreateCapacityReservationRequest::setEndTime(const std::string& endTime) +{ + endTime_ = endTime; + setParameter("EndTime", endTime); +} + +long CreateCapacityReservationRequest::getOwnerId()const +{ + return ownerId_; +} + +void CreateCapacityReservationRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string CreateCapacityReservationRequest::getResourceType()const +{ + return resourceType_; +} + +void CreateCapacityReservationRequest::setResourceType(const std::string& resourceType) +{ + resourceType_ = resourceType; + setParameter("ResourceType", resourceType); +} + +std::string CreateCapacityReservationRequest::getPeriodUnit()const +{ + return periodUnit_; +} + +void CreateCapacityReservationRequest::setPeriodUnit(const std::string& periodUnit) +{ + periodUnit_ = periodUnit; + setParameter("PeriodUnit", periodUnit); +} + +std::vector CreateCapacityReservationRequest::getZoneId()const +{ + return zoneId_; +} + +void CreateCapacityReservationRequest::setZoneId(const std::vector& zoneId) +{ + zoneId_ = zoneId; + for(int dep1 = 0; dep1!= zoneId.size(); dep1++) { + setParameter("ZoneId."+ std::to_string(dep1), zoneId.at(dep1)); + } +} + +std::string CreateCapacityReservationRequest::getChargeType()const +{ + return chargeType_; +} + +void CreateCapacityReservationRequest::setChargeType(const std::string& chargeType) +{ + chargeType_ = chargeType; + setParameter("ChargeType", chargeType); +} + +std::string CreateCapacityReservationRequest::getPackageType()const +{ + return packageType_; +} + +void CreateCapacityReservationRequest::setPackageType(const std::string& packageType) +{ + packageType_ = packageType; + setParameter("PackageType", packageType); +} + +int CreateCapacityReservationRequest::getInstanceAmount()const +{ + return instanceAmount_; +} + +void CreateCapacityReservationRequest::setInstanceAmount(int instanceAmount) +{ + instanceAmount_ = instanceAmount; + setParameter("InstanceAmount", std::to_string(instanceAmount)); +} + diff --git a/ecs/src/model/CreateCapacityReservationResult.cc b/ecs/src/model/CreateCapacityReservationResult.cc new file mode 100644 index 000000000..8fb417a38 --- /dev/null +++ b/ecs/src/model/CreateCapacityReservationResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Ecs; +using namespace AlibabaCloud::Ecs::Model; + +CreateCapacityReservationResult::CreateCapacityReservationResult() : + ServiceResult() +{} + +CreateCapacityReservationResult::CreateCapacityReservationResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateCapacityReservationResult::~CreateCapacityReservationResult() +{} + +void CreateCapacityReservationResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["PrivatePoolOptionsId"].isNull()) + privatePoolOptionsId_ = value["PrivatePoolOptionsId"].asString(); + +} + +std::string CreateCapacityReservationResult::getPrivatePoolOptionsId()const +{ + return privatePoolOptionsId_; +} + diff --git a/ecs/src/model/DescribeCapacityReservationInstancesRequest.cc b/ecs/src/model/DescribeCapacityReservationInstancesRequest.cc new file mode 100644 index 000000000..93491050e --- /dev/null +++ b/ecs/src/model/DescribeCapacityReservationInstancesRequest.cc @@ -0,0 +1,128 @@ +/* + * 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 + +using AlibabaCloud::Ecs::Model::DescribeCapacityReservationInstancesRequest; + +DescribeCapacityReservationInstancesRequest::DescribeCapacityReservationInstancesRequest() : + RpcServiceRequest("ecs", "2014-05-26", "DescribeCapacityReservationInstances") +{ + setMethod(HttpRequest::Method::Post); +} + +DescribeCapacityReservationInstancesRequest::~DescribeCapacityReservationInstancesRequest() +{} + +long DescribeCapacityReservationInstancesRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeCapacityReservationInstancesRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DescribeCapacityReservationInstancesRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeCapacityReservationInstancesRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeCapacityReservationInstancesRequest::getNextToken()const +{ + return nextToken_; +} + +void DescribeCapacityReservationInstancesRequest::setNextToken(const std::string& nextToken) +{ + nextToken_ = nextToken; + setParameter("NextToken", nextToken); +} + +std::string DescribeCapacityReservationInstancesRequest::getPrivatePoolOptionsId()const +{ + return privatePoolOptionsId_; +} + +void DescribeCapacityReservationInstancesRequest::setPrivatePoolOptionsId(const std::string& privatePoolOptionsId) +{ + privatePoolOptionsId_ = privatePoolOptionsId; + setParameter("PrivatePoolOptionsId", privatePoolOptionsId); +} + +std::string DescribeCapacityReservationInstancesRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeCapacityReservationInstancesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeCapacityReservationInstancesRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeCapacityReservationInstancesRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeCapacityReservationInstancesRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeCapacityReservationInstancesRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +int DescribeCapacityReservationInstancesRequest::getMaxResults()const +{ + return maxResults_; +} + +void DescribeCapacityReservationInstancesRequest::setMaxResults(int maxResults) +{ + maxResults_ = maxResults; + setParameter("MaxResults", std::to_string(maxResults)); +} + +std::string DescribeCapacityReservationInstancesRequest::getPackageType()const +{ + return packageType_; +} + +void DescribeCapacityReservationInstancesRequest::setPackageType(const std::string& packageType) +{ + packageType_ = packageType; + setParameter("PackageType", packageType); +} + diff --git a/ecs/src/model/DescribeCapacityReservationInstancesResult.cc b/ecs/src/model/DescribeCapacityReservationInstancesResult.cc new file mode 100644 index 000000000..b3d4a5f17 --- /dev/null +++ b/ecs/src/model/DescribeCapacityReservationInstancesResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Ecs; +using namespace AlibabaCloud::Ecs::Model; + +DescribeCapacityReservationInstancesResult::DescribeCapacityReservationInstancesResult() : + ServiceResult() +{} + +DescribeCapacityReservationInstancesResult::DescribeCapacityReservationInstancesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeCapacityReservationInstancesResult::~DescribeCapacityReservationInstancesResult() +{} + +void DescribeCapacityReservationInstancesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allCapacityReservationItemNode = value["CapacityReservationItem"]["InstanceIdSet"]; + for (auto valueCapacityReservationItemInstanceIdSet : allCapacityReservationItemNode) + { + InstanceIdSet capacityReservationItemObject; + if(!valueCapacityReservationItemInstanceIdSet["InstanceId"].isNull()) + capacityReservationItemObject.instanceId = valueCapacityReservationItemInstanceIdSet["InstanceId"].asString(); + capacityReservationItem_.push_back(capacityReservationItemObject); + } + if(!value["NextToken"].isNull()) + nextToken_ = value["NextToken"].asString(); + if(!value["MaxResults"].isNull()) + maxResults_ = std::stoi(value["MaxResults"].asString()); + if(!value["TotalCount"].isNull()) + totalCount_ = std::stoi(value["TotalCount"].asString()); + +} + +std::vector DescribeCapacityReservationInstancesResult::getCapacityReservationItem()const +{ + return capacityReservationItem_; +} + +int DescribeCapacityReservationInstancesResult::getTotalCount()const +{ + return totalCount_; +} + +std::string DescribeCapacityReservationInstancesResult::getNextToken()const +{ + return nextToken_; +} + +int DescribeCapacityReservationInstancesResult::getMaxResults()const +{ + return maxResults_; +} + diff --git a/ecs/src/model/DescribeCapacityReservationsRequest.cc b/ecs/src/model/DescribeCapacityReservationsRequest.cc new file mode 100644 index 000000000..4857fa219 --- /dev/null +++ b/ecs/src/model/DescribeCapacityReservationsRequest.cc @@ -0,0 +1,172 @@ +/* + * 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 + +using AlibabaCloud::Ecs::Model::DescribeCapacityReservationsRequest; + +DescribeCapacityReservationsRequest::DescribeCapacityReservationsRequest() : + RpcServiceRequest("ecs", "2014-05-26", "DescribeCapacityReservations") +{ + setMethod(HttpRequest::Method::Post); +} + +DescribeCapacityReservationsRequest::~DescribeCapacityReservationsRequest() +{} + +long DescribeCapacityReservationsRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeCapacityReservationsRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DescribeCapacityReservationsRequest::getPlatform()const +{ + return platform_; +} + +void DescribeCapacityReservationsRequest::setPlatform(const std::string& platform) +{ + platform_ = platform; + setParameter("Platform", platform); +} + +std::string DescribeCapacityReservationsRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeCapacityReservationsRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeCapacityReservationsRequest::getNextToken()const +{ + return nextToken_; +} + +void DescribeCapacityReservationsRequest::setNextToken(const std::string& nextToken) +{ + nextToken_ = nextToken; + setParameter("NextToken", nextToken); +} + +std::string DescribeCapacityReservationsRequest::getInstanceType()const +{ + return instanceType_; +} + +void DescribeCapacityReservationsRequest::setInstanceType(const std::string& instanceType) +{ + instanceType_ = instanceType; + setParameter("InstanceType", instanceType); +} + +std::string DescribeCapacityReservationsRequest::getInstanceChargeType()const +{ + return instanceChargeType_; +} + +void DescribeCapacityReservationsRequest::setInstanceChargeType(const std::string& instanceChargeType) +{ + instanceChargeType_ = instanceChargeType; + setParameter("InstanceChargeType", instanceChargeType); +} + +std::string DescribeCapacityReservationsRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeCapacityReservationsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeCapacityReservationsRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeCapacityReservationsRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeCapacityReservationsRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeCapacityReservationsRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeCapacityReservationsRequest::getPrivatePoolOptionsIds()const +{ + return privatePoolOptionsIds_; +} + +void DescribeCapacityReservationsRequest::setPrivatePoolOptionsIds(const std::string& privatePoolOptionsIds) +{ + privatePoolOptionsIds_ = privatePoolOptionsIds; + setParameter("PrivatePoolOptionsIds", privatePoolOptionsIds); +} + +int DescribeCapacityReservationsRequest::getMaxResults()const +{ + return maxResults_; +} + +void DescribeCapacityReservationsRequest::setMaxResults(int maxResults) +{ + maxResults_ = maxResults; + setParameter("MaxResults", std::to_string(maxResults)); +} + +std::string DescribeCapacityReservationsRequest::getZoneId()const +{ + return zoneId_; +} + +void DescribeCapacityReservationsRequest::setZoneId(const std::string& zoneId) +{ + zoneId_ = zoneId; + setParameter("ZoneId", zoneId); +} + +std::string DescribeCapacityReservationsRequest::getPackageType()const +{ + return packageType_; +} + +void DescribeCapacityReservationsRequest::setPackageType(const std::string& packageType) +{ + packageType_ = packageType; + setParameter("PackageType", packageType); +} + diff --git a/ecs/src/model/DescribeCapacityReservationsResult.cc b/ecs/src/model/DescribeCapacityReservationsResult.cc new file mode 100644 index 000000000..b564fc128 --- /dev/null +++ b/ecs/src/model/DescribeCapacityReservationsResult.cc @@ -0,0 +1,112 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Ecs; +using namespace AlibabaCloud::Ecs::Model; + +DescribeCapacityReservationsResult::DescribeCapacityReservationsResult() : + ServiceResult() +{} + +DescribeCapacityReservationsResult::DescribeCapacityReservationsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeCapacityReservationsResult::~DescribeCapacityReservationsResult() +{} + +void DescribeCapacityReservationsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allCapacityReservationSetNode = value["CapacityReservationSet"]["CapacityReservationItem"]; + for (auto valueCapacityReservationSetCapacityReservationItem : allCapacityReservationSetNode) + { + CapacityReservationItem capacityReservationSetObject; + if(!valueCapacityReservationSetCapacityReservationItem["PrivatePoolOptionsId"].isNull()) + capacityReservationSetObject.privatePoolOptionsId = valueCapacityReservationSetCapacityReservationItem["PrivatePoolOptionsId"].asString(); + if(!valueCapacityReservationSetCapacityReservationItem["PrivatePoolOptionsName"].isNull()) + capacityReservationSetObject.privatePoolOptionsName = valueCapacityReservationSetCapacityReservationItem["PrivatePoolOptionsName"].asString(); + if(!valueCapacityReservationSetCapacityReservationItem["Description"].isNull()) + capacityReservationSetObject.description = valueCapacityReservationSetCapacityReservationItem["Description"].asString(); + if(!valueCapacityReservationSetCapacityReservationItem["RegionId"].isNull()) + capacityReservationSetObject.regionId = valueCapacityReservationSetCapacityReservationItem["RegionId"].asString(); + if(!valueCapacityReservationSetCapacityReservationItem["PrivatePoolOptionsMatchCriteria"].isNull()) + capacityReservationSetObject.privatePoolOptionsMatchCriteria = valueCapacityReservationSetCapacityReservationItem["PrivatePoolOptionsMatchCriteria"].asString(); + if(!valueCapacityReservationSetCapacityReservationItem["Status"].isNull()) + capacityReservationSetObject.status = valueCapacityReservationSetCapacityReservationItem["Status"].asString(); + if(!valueCapacityReservationSetCapacityReservationItem["StartTime"].isNull()) + capacityReservationSetObject.startTime = valueCapacityReservationSetCapacityReservationItem["StartTime"].asString(); + if(!valueCapacityReservationSetCapacityReservationItem["EndTime"].isNull()) + capacityReservationSetObject.endTime = valueCapacityReservationSetCapacityReservationItem["EndTime"].asString(); + if(!valueCapacityReservationSetCapacityReservationItem["EndTimeType"].isNull()) + capacityReservationSetObject.endTimeType = valueCapacityReservationSetCapacityReservationItem["EndTimeType"].asString(); + if(!valueCapacityReservationSetCapacityReservationItem["InstanceChargeType"].isNull()) + capacityReservationSetObject.instanceChargeType = valueCapacityReservationSetCapacityReservationItem["InstanceChargeType"].asString(); + if(!valueCapacityReservationSetCapacityReservationItem["Platform"].isNull()) + capacityReservationSetObject.platform = valueCapacityReservationSetCapacityReservationItem["Platform"].asString(); + auto allAllocatedResourcesNode = allCapacityReservationSetNode["AllocatedResources"]["AllocatedResource"]; + for (auto allCapacityReservationSetNodeAllocatedResourcesAllocatedResource : allAllocatedResourcesNode) + { + CapacityReservationItem::AllocatedResource allocatedResourcesObject; + if(!allCapacityReservationSetNodeAllocatedResourcesAllocatedResource["zoneId"].isNull()) + allocatedResourcesObject.zoneId = allCapacityReservationSetNodeAllocatedResourcesAllocatedResource["zoneId"].asString(); + if(!allCapacityReservationSetNodeAllocatedResourcesAllocatedResource["InstanceType"].isNull()) + allocatedResourcesObject.instanceType = allCapacityReservationSetNodeAllocatedResourcesAllocatedResource["InstanceType"].asString(); + if(!allCapacityReservationSetNodeAllocatedResourcesAllocatedResource["TotalAmount"].isNull()) + allocatedResourcesObject.totalAmount = std::stoi(allCapacityReservationSetNodeAllocatedResourcesAllocatedResource["TotalAmount"].asString()); + if(!allCapacityReservationSetNodeAllocatedResourcesAllocatedResource["UsedAmount"].isNull()) + allocatedResourcesObject.usedAmount = std::stoi(allCapacityReservationSetNodeAllocatedResourcesAllocatedResource["UsedAmount"].asString()); + capacityReservationSetObject.allocatedResources.push_back(allocatedResourcesObject); + } + capacityReservationSet_.push_back(capacityReservationSetObject); + } + if(!value["NextToken"].isNull()) + nextToken_ = value["NextToken"].asString(); + if(!value["MaxResults"].isNull()) + maxResults_ = std::stoi(value["MaxResults"].asString()); + if(!value["TotalCount"].isNull()) + totalCount_ = std::stoi(value["TotalCount"].asString()); + +} + +int DescribeCapacityReservationsResult::getTotalCount()const +{ + return totalCount_; +} + +std::string DescribeCapacityReservationsResult::getNextToken()const +{ + return nextToken_; +} + +int DescribeCapacityReservationsResult::getMaxResults()const +{ + return maxResults_; +} + +std::vector DescribeCapacityReservationsResult::getCapacityReservationSet()const +{ + return capacityReservationSet_; +} + diff --git a/ecs/src/model/DescribeElasticityAssurancesRequest.cc b/ecs/src/model/DescribeElasticityAssurancesRequest.cc index 55d5b0d31..7ceb58d7c 100644 --- a/ecs/src/model/DescribeElasticityAssurancesRequest.cc +++ b/ecs/src/model/DescribeElasticityAssurancesRequest.cc @@ -38,6 +38,17 @@ void DescribeElasticityAssurancesRequest::setResourceOwnerId(long resourceOwnerI setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); } +std::string DescribeElasticityAssurancesRequest::getPlatform()const +{ + return platform_; +} + +void DescribeElasticityAssurancesRequest::setPlatform(const std::string& platform) +{ + platform_ = platform; + setParameter("Platform", platform); +} + std::string DescribeElasticityAssurancesRequest::getRegionId()const { return regionId_; @@ -60,6 +71,28 @@ void DescribeElasticityAssurancesRequest::setNextToken(const std::string& nextTo setParameter("NextToken", nextToken); } +std::string DescribeElasticityAssurancesRequest::getInstanceType()const +{ + return instanceType_; +} + +void DescribeElasticityAssurancesRequest::setInstanceType(const std::string& instanceType) +{ + instanceType_ = instanceType; + setParameter("InstanceType", instanceType); +} + +std::string DescribeElasticityAssurancesRequest::getInstanceChargeType()const +{ + return instanceChargeType_; +} + +void DescribeElasticityAssurancesRequest::setInstanceChargeType(const std::string& instanceChargeType) +{ + instanceChargeType_ = instanceChargeType; + setParameter("InstanceChargeType", instanceChargeType); +} + std::string DescribeElasticityAssurancesRequest::getResourceOwnerAccount()const { return resourceOwnerAccount_; @@ -115,6 +148,17 @@ void DescribeElasticityAssurancesRequest::setMaxResults(int maxResults) setParameter("MaxResults", std::to_string(maxResults)); } +std::string DescribeElasticityAssurancesRequest::getZoneId()const +{ + return zoneId_; +} + +void DescribeElasticityAssurancesRequest::setZoneId(const std::string& zoneId) +{ + zoneId_ = zoneId; + setParameter("ZoneId", zoneId); +} + std::string DescribeElasticityAssurancesRequest::getPackageType()const { return packageType_; diff --git a/ecs/src/model/ReleaseCapacityReservationRequest.cc b/ecs/src/model/ReleaseCapacityReservationRequest.cc new file mode 100644 index 000000000..cab289d5c --- /dev/null +++ b/ecs/src/model/ReleaseCapacityReservationRequest.cc @@ -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 + +using AlibabaCloud::Ecs::Model::ReleaseCapacityReservationRequest; + +ReleaseCapacityReservationRequest::ReleaseCapacityReservationRequest() : + RpcServiceRequest("ecs", "2014-05-26", "ReleaseCapacityReservation") +{ + setMethod(HttpRequest::Method::Post); +} + +ReleaseCapacityReservationRequest::~ReleaseCapacityReservationRequest() +{} + +long ReleaseCapacityReservationRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void ReleaseCapacityReservationRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string ReleaseCapacityReservationRequest::getRegionId()const +{ + return regionId_; +} + +void ReleaseCapacityReservationRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string ReleaseCapacityReservationRequest::getPrivatePoolOptionsId()const +{ + return privatePoolOptionsId_; +} + +void ReleaseCapacityReservationRequest::setPrivatePoolOptionsId(const std::string& privatePoolOptionsId) +{ + privatePoolOptionsId_ = privatePoolOptionsId; + setParameter("PrivatePoolOptionsId", privatePoolOptionsId); +} + +bool ReleaseCapacityReservationRequest::getDryRun()const +{ + return dryRun_; +} + +void ReleaseCapacityReservationRequest::setDryRun(bool dryRun) +{ + dryRun_ = dryRun; + setParameter("DryRun", dryRun ? "true" : "false"); +} + +std::string ReleaseCapacityReservationRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void ReleaseCapacityReservationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string ReleaseCapacityReservationRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void ReleaseCapacityReservationRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long ReleaseCapacityReservationRequest::getOwnerId()const +{ + return ownerId_; +} + +void ReleaseCapacityReservationRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + diff --git a/ecs/src/model/ReleaseCapacityReservationResult.cc b/ecs/src/model/ReleaseCapacityReservationResult.cc new file mode 100644 index 000000000..36af53369 --- /dev/null +++ b/ecs/src/model/ReleaseCapacityReservationResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Ecs; +using namespace AlibabaCloud::Ecs::Model; + +ReleaseCapacityReservationResult::ReleaseCapacityReservationResult() : + ServiceResult() +{} + +ReleaseCapacityReservationResult::ReleaseCapacityReservationResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ReleaseCapacityReservationResult::~ReleaseCapacityReservationResult() +{} + +void ReleaseCapacityReservationResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/ecs/src/model/RunInstancesRequest.cc b/ecs/src/model/RunInstancesRequest.cc index f30660f26..a09a0d9a8 100644 --- a/ecs/src/model/RunInstancesRequest.cc +++ b/ecs/src/model/RunInstancesRequest.cc @@ -916,6 +916,17 @@ void RunInstancesRequest::setLaunchTemplateVersion(long launchTemplateVersion) setParameter("LaunchTemplateVersion", std::to_string(launchTemplateVersion)); } +std::string RunInstancesRequest::getSchedulerOptionsManagedPrivateSpaceId()const +{ + return schedulerOptionsManagedPrivateSpaceId_; +} + +void RunInstancesRequest::setSchedulerOptionsManagedPrivateSpaceId(const std::string& schedulerOptionsManagedPrivateSpaceId) +{ + schedulerOptionsManagedPrivateSpaceId_ = schedulerOptionsManagedPrivateSpaceId; + setParameter("SchedulerOptionsManagedPrivateSpaceId", schedulerOptionsManagedPrivateSpaceId); +} + std::string RunInstancesRequest::getStorageSetId()const { return storageSetId_;