From db913af39df10ac53f59e3e003572ef64759fc8e Mon Sep 17 00:00:00 2001 From: sdk-team Date: Wed, 7 Sep 2022 07:20:50 +0000 Subject: [PATCH] Support attribute filtering for DescribeInstanceTypes. --- VERSION | 2 +- .../ecs/model/DescribeInstanceTypesRequest.h | 111 +++++- .../ecs/model/DescribeInstanceTypesResult.h | 6 + ecs/src/model/DescribeInstanceTypesRequest.cc | 317 +++++++++++++++++- ecs/src/model/DescribeInstanceTypesResult.cc | 12 + 5 files changed, 431 insertions(+), 17 deletions(-) diff --git a/VERSION b/VERSION index d7f1f2a21..df55ef51b 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.1249 \ No newline at end of file +1.36.1250 \ No newline at end of file diff --git a/ecs/include/alibabacloud/ecs/model/DescribeInstanceTypesRequest.h b/ecs/include/alibabacloud/ecs/model/DescribeInstanceTypesRequest.h index 0739a900d..9c21f4c05 100644 --- a/ecs/include/alibabacloud/ecs/model/DescribeInstanceTypesRequest.h +++ b/ecs/include/alibabacloud/ecs/model/DescribeInstanceTypesRequest.h @@ -30,32 +30,131 @@ class ALIBABACLOUD_ECS_EXPORT DescribeInstanceTypesRequest : public RpcServiceRe public: DescribeInstanceTypesRequest(); ~DescribeInstanceTypesRequest(); + std::string getGPUSpec() const; + void setGPUSpec(const std::string &gPUSpec); long getResourceOwnerId() const; void setResourceOwnerId(long resourceOwnerId); + int getMaximumCpuCoreCount() const; + void setMaximumCpuCoreCount(int maximumCpuCoreCount); + int getMaximumGPUAmount() const; + void setMaximumGPUAmount(int maximumGPUAmount); + std::string getLocalStorageCategory() const; + void setLocalStorageCategory(const std::string &localStorageCategory); + float getMaximumMemorySize() const; + void setMaximumMemorySize(float maximumMemorySize); + std::string getInstanceCategory() const; + void setInstanceCategory(const std::string &instanceCategory); + long getMinimumInstancePpsTx() const; + void setMinimumInstancePpsTx(long minimumInstancePpsTx); + int getMinimumCpuCoreCount() const; + void setMinimumCpuCoreCount(int minimumCpuCoreCount); + int getMinimumPrimaryEniQueueNumber() const; + void setMinimumPrimaryEniQueueNumber(int minimumPrimaryEniQueueNumber); + int getMinimumBaselineCredit() const; + void setMinimumBaselineCredit(int minimumBaselineCredit); + int getMinimumSecondaryEniQueueNumber() const; + void setMinimumSecondaryEniQueueNumber(int minimumSecondaryEniQueueNumber); + int getMinimumInstanceBandwidthTx() const; + void setMinimumInstanceBandwidthTx(int minimumInstanceBandwidthTx); + int getMinimumGPUAmount() const; + void setMinimumGPUAmount(int minimumGPUAmount); + float getMaximumCpuSpeedFrequency() const; + void setMaximumCpuSpeedFrequency(float maximumCpuSpeedFrequency); + std::string getCpuArchitecture() const; + void setCpuArchitecture(const std::string &cpuArchitecture); + long getOwnerId() const; + void setOwnerId(long ownerId); + float getMinimumMemorySize() const; + void setMinimumMemorySize(float minimumMemorySize); + int getMinimumEniQuantity() const; + void setMinimumEniQuantity(int minimumEniQuantity); + std::string getInstanceFamilyLevel() const; + void setInstanceFamilyLevel(const std::string &instanceFamilyLevel); + int getMinimumQueuePairNumber() const; + void setMinimumQueuePairNumber(int minimumQueuePairNumber); + int getMinimumLocalStorageAmount() const; + void setMinimumLocalStorageAmount(int minimumLocalStorageAmount); + long getMaxResults() const; + void setMaxResults(long maxResults); + std::string getPhysicalProcessorModel() const; + void setPhysicalProcessorModel(const std::string &physicalProcessorModel); + float getMaximumCpuTurboFrequency() const; + void setMaximumCpuTurboFrequency(float maximumCpuTurboFrequency); std::vector getInstanceTypes() const; void setInstanceTypes(const std::vector &instanceTypes); + long getMinimumInstancePpsRx() const; + void setMinimumInstancePpsRx(long minimumInstancePpsRx); + int getMinimumEniIpv6AddressQuantity() const; + void setMinimumEniIpv6AddressQuantity(int minimumEniIpv6AddressQuantity); + int getMinimumEriQuantity() const; + void setMinimumEriQuantity(int minimumEriQuantity); + int getMinimumDiskQuantity() const; + void setMinimumDiskQuantity(int minimumDiskQuantity); + float getMinimumCpuTurboFrequency() const; + void setMinimumCpuTurboFrequency(float minimumCpuTurboFrequency); std::string getNextToken() const; void setNextToken(const std::string &nextToken); + int getMinimumInstanceBandwidthRx() const; + void setMinimumInstanceBandwidthRx(int minimumInstanceBandwidthRx); + float getMinimumCpuSpeedFrequency() const; + void setMinimumCpuSpeedFrequency(float minimumCpuSpeedFrequency); + std::string getNvmeSupport() const; + void setNvmeSupport(const std::string &nvmeSupport); std::string getResourceOwnerAccount() const; void setResourceOwnerAccount(const std::string &resourceOwnerAccount); std::string getOwnerAccount() const; void setOwnerAccount(const std::string &ownerAccount); + int getMinimumInitialCredit() const; + void setMinimumInitialCredit(int minimumInitialCredit); std::string getInstanceTypeFamily() const; void setInstanceTypeFamily(const std::string &instanceTypeFamily); - long getOwnerId() const; - void setOwnerId(long ownerId); - long getMaxResults() const; - void setMaxResults(long maxResults); + int getMinimumEniPrivateIpAddressQuantity() const; + void setMinimumEniPrivateIpAddressQuantity(int minimumEniPrivateIpAddressQuantity); + long getMinimumLocalStorageCapacity() const; + void setMinimumLocalStorageCapacity(long minimumLocalStorageCapacity); private: + std::string gPUSpec_; long resourceOwnerId_; + int maximumCpuCoreCount_; + int maximumGPUAmount_; + std::string localStorageCategory_; + float maximumMemorySize_; + std::string instanceCategory_; + long minimumInstancePpsTx_; + int minimumCpuCoreCount_; + int minimumPrimaryEniQueueNumber_; + int minimumBaselineCredit_; + int minimumSecondaryEniQueueNumber_; + int minimumInstanceBandwidthTx_; + int minimumGPUAmount_; + float maximumCpuSpeedFrequency_; + std::string cpuArchitecture_; + long ownerId_; + float minimumMemorySize_; + int minimumEniQuantity_; + std::string instanceFamilyLevel_; + int minimumQueuePairNumber_; + int minimumLocalStorageAmount_; + long maxResults_; + std::string physicalProcessorModel_; + float maximumCpuTurboFrequency_; std::vector instanceTypes_; + long minimumInstancePpsRx_; + int minimumEniIpv6AddressQuantity_; + int minimumEriQuantity_; + int minimumDiskQuantity_; + float minimumCpuTurboFrequency_; std::string nextToken_; + int minimumInstanceBandwidthRx_; + float minimumCpuSpeedFrequency_; + std::string nvmeSupport_; std::string resourceOwnerAccount_; std::string ownerAccount_; + int minimumInitialCredit_; std::string instanceTypeFamily_; - long ownerId_; - long maxResults_; + int minimumEniPrivateIpAddressQuantity_; + long minimumLocalStorageCapacity_; }; } // namespace Model } // namespace Ecs diff --git a/ecs/include/alibabacloud/ecs/model/DescribeInstanceTypesResult.h b/ecs/include/alibabacloud/ecs/model/DescribeInstanceTypesResult.h index 7bf4d06df..92c465b93 100644 --- a/ecs/include/alibabacloud/ecs/model/DescribeInstanceTypesResult.h +++ b/ecs/include/alibabacloud/ecs/model/DescribeInstanceTypesResult.h @@ -42,13 +42,16 @@ namespace AlibabaCloud bool eniTrunkSupported; std::string instanceTypeFamily; long instancePpsRx; + bool networkEncryptionSupport; int eriQuantity; int instanceBandwidthRx; int instanceBandwidthTx; int localStorageAmount; int secondaryEniQueueNumber; + std::string physicalProcessorModel; std::string localStorageCategory; std::string gPUSpec; + std::string cpuArchitecture; std::string instanceTypeId; float memorySize; int maximumQueueNumberPerEni; @@ -56,12 +59,15 @@ namespace AlibabaCloud int eniTotalQuantity; int cpuCoreCount; int initialCredit; + std::string instanceCategory; int eniQuantity; int gPUAmount; int diskQuantity; + float cpuSpeedFrequency; int queuePairNumber; int baselineCredit; std::string instanceFamilyLevel; + float cpuTurboFrequency; int eniPrivateIpAddressQuantity; }; diff --git a/ecs/src/model/DescribeInstanceTypesRequest.cc b/ecs/src/model/DescribeInstanceTypesRequest.cc index dbe544cc6..9f21f8313 100644 --- a/ecs/src/model/DescribeInstanceTypesRequest.cc +++ b/ecs/src/model/DescribeInstanceTypesRequest.cc @@ -25,6 +25,15 @@ DescribeInstanceTypesRequest::DescribeInstanceTypesRequest() DescribeInstanceTypesRequest::~DescribeInstanceTypesRequest() {} +std::string DescribeInstanceTypesRequest::getGPUSpec() const { + return gPUSpec_; +} + +void DescribeInstanceTypesRequest::setGPUSpec(const std::string &gPUSpec) { + gPUSpec_ = gPUSpec; + setParameter(std::string("GPUSpec"), gPUSpec); +} + long DescribeInstanceTypesRequest::getResourceOwnerId() const { return resourceOwnerId_; } @@ -34,6 +43,213 @@ void DescribeInstanceTypesRequest::setResourceOwnerId(long resourceOwnerId) { setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId)); } +int DescribeInstanceTypesRequest::getMaximumCpuCoreCount() const { + return maximumCpuCoreCount_; +} + +void DescribeInstanceTypesRequest::setMaximumCpuCoreCount(int maximumCpuCoreCount) { + maximumCpuCoreCount_ = maximumCpuCoreCount; + setParameter(std::string("MaximumCpuCoreCount"), std::to_string(maximumCpuCoreCount)); +} + +int DescribeInstanceTypesRequest::getMaximumGPUAmount() const { + return maximumGPUAmount_; +} + +void DescribeInstanceTypesRequest::setMaximumGPUAmount(int maximumGPUAmount) { + maximumGPUAmount_ = maximumGPUAmount; + setParameter(std::string("MaximumGPUAmount"), std::to_string(maximumGPUAmount)); +} + +std::string DescribeInstanceTypesRequest::getLocalStorageCategory() const { + return localStorageCategory_; +} + +void DescribeInstanceTypesRequest::setLocalStorageCategory(const std::string &localStorageCategory) { + localStorageCategory_ = localStorageCategory; + setParameter(std::string("LocalStorageCategory"), localStorageCategory); +} + +float DescribeInstanceTypesRequest::getMaximumMemorySize() const { + return maximumMemorySize_; +} + +void DescribeInstanceTypesRequest::setMaximumMemorySize(float maximumMemorySize) { + maximumMemorySize_ = maximumMemorySize; + setParameter(std::string("MaximumMemorySize"), std::to_string(maximumMemorySize)); +} + +std::string DescribeInstanceTypesRequest::getInstanceCategory() const { + return instanceCategory_; +} + +void DescribeInstanceTypesRequest::setInstanceCategory(const std::string &instanceCategory) { + instanceCategory_ = instanceCategory; + setParameter(std::string("InstanceCategory"), instanceCategory); +} + +long DescribeInstanceTypesRequest::getMinimumInstancePpsTx() const { + return minimumInstancePpsTx_; +} + +void DescribeInstanceTypesRequest::setMinimumInstancePpsTx(long minimumInstancePpsTx) { + minimumInstancePpsTx_ = minimumInstancePpsTx; + setParameter(std::string("MinimumInstancePpsTx"), std::to_string(minimumInstancePpsTx)); +} + +int DescribeInstanceTypesRequest::getMinimumCpuCoreCount() const { + return minimumCpuCoreCount_; +} + +void DescribeInstanceTypesRequest::setMinimumCpuCoreCount(int minimumCpuCoreCount) { + minimumCpuCoreCount_ = minimumCpuCoreCount; + setParameter(std::string("MinimumCpuCoreCount"), std::to_string(minimumCpuCoreCount)); +} + +int DescribeInstanceTypesRequest::getMinimumPrimaryEniQueueNumber() const { + return minimumPrimaryEniQueueNumber_; +} + +void DescribeInstanceTypesRequest::setMinimumPrimaryEniQueueNumber(int minimumPrimaryEniQueueNumber) { + minimumPrimaryEniQueueNumber_ = minimumPrimaryEniQueueNumber; + setParameter(std::string("MinimumPrimaryEniQueueNumber"), std::to_string(minimumPrimaryEniQueueNumber)); +} + +int DescribeInstanceTypesRequest::getMinimumBaselineCredit() const { + return minimumBaselineCredit_; +} + +void DescribeInstanceTypesRequest::setMinimumBaselineCredit(int minimumBaselineCredit) { + minimumBaselineCredit_ = minimumBaselineCredit; + setParameter(std::string("MinimumBaselineCredit"), std::to_string(minimumBaselineCredit)); +} + +int DescribeInstanceTypesRequest::getMinimumSecondaryEniQueueNumber() const { + return minimumSecondaryEniQueueNumber_; +} + +void DescribeInstanceTypesRequest::setMinimumSecondaryEniQueueNumber(int minimumSecondaryEniQueueNumber) { + minimumSecondaryEniQueueNumber_ = minimumSecondaryEniQueueNumber; + setParameter(std::string("MinimumSecondaryEniQueueNumber"), std::to_string(minimumSecondaryEniQueueNumber)); +} + +int DescribeInstanceTypesRequest::getMinimumInstanceBandwidthTx() const { + return minimumInstanceBandwidthTx_; +} + +void DescribeInstanceTypesRequest::setMinimumInstanceBandwidthTx(int minimumInstanceBandwidthTx) { + minimumInstanceBandwidthTx_ = minimumInstanceBandwidthTx; + setParameter(std::string("MinimumInstanceBandwidthTx"), std::to_string(minimumInstanceBandwidthTx)); +} + +int DescribeInstanceTypesRequest::getMinimumGPUAmount() const { + return minimumGPUAmount_; +} + +void DescribeInstanceTypesRequest::setMinimumGPUAmount(int minimumGPUAmount) { + minimumGPUAmount_ = minimumGPUAmount; + setParameter(std::string("MinimumGPUAmount"), std::to_string(minimumGPUAmount)); +} + +float DescribeInstanceTypesRequest::getMaximumCpuSpeedFrequency() const { + return maximumCpuSpeedFrequency_; +} + +void DescribeInstanceTypesRequest::setMaximumCpuSpeedFrequency(float maximumCpuSpeedFrequency) { + maximumCpuSpeedFrequency_ = maximumCpuSpeedFrequency; + setParameter(std::string("MaximumCpuSpeedFrequency"), std::to_string(maximumCpuSpeedFrequency)); +} + +std::string DescribeInstanceTypesRequest::getCpuArchitecture() const { + return cpuArchitecture_; +} + +void DescribeInstanceTypesRequest::setCpuArchitecture(const std::string &cpuArchitecture) { + cpuArchitecture_ = cpuArchitecture; + setParameter(std::string("CpuArchitecture"), cpuArchitecture); +} + +long DescribeInstanceTypesRequest::getOwnerId() const { + return ownerId_; +} + +void DescribeInstanceTypesRequest::setOwnerId(long ownerId) { + ownerId_ = ownerId; + setParameter(std::string("OwnerId"), std::to_string(ownerId)); +} + +float DescribeInstanceTypesRequest::getMinimumMemorySize() const { + return minimumMemorySize_; +} + +void DescribeInstanceTypesRequest::setMinimumMemorySize(float minimumMemorySize) { + minimumMemorySize_ = minimumMemorySize; + setParameter(std::string("MinimumMemorySize"), std::to_string(minimumMemorySize)); +} + +int DescribeInstanceTypesRequest::getMinimumEniQuantity() const { + return minimumEniQuantity_; +} + +void DescribeInstanceTypesRequest::setMinimumEniQuantity(int minimumEniQuantity) { + minimumEniQuantity_ = minimumEniQuantity; + setParameter(std::string("MinimumEniQuantity"), std::to_string(minimumEniQuantity)); +} + +std::string DescribeInstanceTypesRequest::getInstanceFamilyLevel() const { + return instanceFamilyLevel_; +} + +void DescribeInstanceTypesRequest::setInstanceFamilyLevel(const std::string &instanceFamilyLevel) { + instanceFamilyLevel_ = instanceFamilyLevel; + setParameter(std::string("InstanceFamilyLevel"), instanceFamilyLevel); +} + +int DescribeInstanceTypesRequest::getMinimumQueuePairNumber() const { + return minimumQueuePairNumber_; +} + +void DescribeInstanceTypesRequest::setMinimumQueuePairNumber(int minimumQueuePairNumber) { + minimumQueuePairNumber_ = minimumQueuePairNumber; + setParameter(std::string("MinimumQueuePairNumber"), std::to_string(minimumQueuePairNumber)); +} + +int DescribeInstanceTypesRequest::getMinimumLocalStorageAmount() const { + return minimumLocalStorageAmount_; +} + +void DescribeInstanceTypesRequest::setMinimumLocalStorageAmount(int minimumLocalStorageAmount) { + minimumLocalStorageAmount_ = minimumLocalStorageAmount; + setParameter(std::string("MinimumLocalStorageAmount"), std::to_string(minimumLocalStorageAmount)); +} + +long DescribeInstanceTypesRequest::getMaxResults() const { + return maxResults_; +} + +void DescribeInstanceTypesRequest::setMaxResults(long maxResults) { + maxResults_ = maxResults; + setParameter(std::string("MaxResults"), std::to_string(maxResults)); +} + +std::string DescribeInstanceTypesRequest::getPhysicalProcessorModel() const { + return physicalProcessorModel_; +} + +void DescribeInstanceTypesRequest::setPhysicalProcessorModel(const std::string &physicalProcessorModel) { + physicalProcessorModel_ = physicalProcessorModel; + setParameter(std::string("PhysicalProcessorModel"), physicalProcessorModel); +} + +float DescribeInstanceTypesRequest::getMaximumCpuTurboFrequency() const { + return maximumCpuTurboFrequency_; +} + +void DescribeInstanceTypesRequest::setMaximumCpuTurboFrequency(float maximumCpuTurboFrequency) { + maximumCpuTurboFrequency_ = maximumCpuTurboFrequency; + setParameter(std::string("MaximumCpuTurboFrequency"), std::to_string(maximumCpuTurboFrequency)); +} + std::vector DescribeInstanceTypesRequest::getInstanceTypes() const { return instanceTypes_; } @@ -42,6 +258,51 @@ void DescribeInstanceTypesRequest::setInstanceTypes(const std::vector