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

Generated 2014-05-26 for Ecs.

Browse Source
This commit is contained in:
sdk-team
2020-10-26 14:44:03 +00:00
parent a180b00ed8
commit dcb1633973
24 changed files with 1816 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -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`.

16
ecs/CMakeLists.txt
View File

@@ -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

32
ecs/include/alibabacloud/ecs/EcsClient.h
View File

@@ -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<Error, Model::CreateAutoSnapshotPolicyResult> CreateAutoSnapshotPolicyOutcome;
typedef std::future<CreateAutoSnapshotPolicyOutcome> CreateAutoSnapshotPolicyOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::CreateAutoSnapshotPolicyRequest&, const CreateAutoSnapshotPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAutoSnapshotPolicyAsyncHandler;
typedef Outcome<Error, Model::CreateCapacityReservationResult> CreateCapacityReservationOutcome;
typedef std::future<CreateCapacityReservationOutcome> CreateCapacityReservationOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::CreateCapacityReservationRequest&, const CreateCapacityReservationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCapacityReservationAsyncHandler;
typedef Outcome<Error, Model::CreateCommandResult> CreateCommandOutcome;
typedef std::future<CreateCommandOutcome> CreateCommandOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::CreateCommandRequest&, const CreateCommandOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCommandAsyncHandler;
@@ -913,6 +924,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeBandwidthPackagesResult> DescribeBandwidthPackagesOutcome;
typedef std::future<DescribeBandwidthPackagesOutcome> DescribeBandwidthPackagesOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::DescribeBandwidthPackagesRequest&, const DescribeBandwidthPackagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBandwidthPackagesAsyncHandler;
typedef Outcome<Error, Model::DescribeCapacityReservationInstancesResult> DescribeCapacityReservationInstancesOutcome;
typedef std::future<DescribeCapacityReservationInstancesOutcome> DescribeCapacityReservationInstancesOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::DescribeCapacityReservationInstancesRequest&, const DescribeCapacityReservationInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCapacityReservationInstancesAsyncHandler;
typedef Outcome<Error, Model::DescribeCapacityReservationsResult> DescribeCapacityReservationsOutcome;
typedef std::future<DescribeCapacityReservationsOutcome> DescribeCapacityReservationsOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::DescribeCapacityReservationsRequest&, const DescribeCapacityReservationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCapacityReservationsAsyncHandler;
typedef Outcome<Error, Model::DescribeClassicLinkInstancesResult> DescribeClassicLinkInstancesOutcome;
typedef std::future<DescribeClassicLinkInstancesOutcome> DescribeClassicLinkInstancesOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::DescribeClassicLinkInstancesRequest&, const DescribeClassicLinkInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeClassicLinkInstancesAsyncHandler;
@@ -1426,6 +1443,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::RedeployInstanceResult> RedeployInstanceOutcome;
typedef std::future<RedeployInstanceOutcome> RedeployInstanceOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::RedeployInstanceRequest&, const RedeployInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RedeployInstanceAsyncHandler;
typedef Outcome<Error, Model::ReleaseCapacityReservationResult> ReleaseCapacityReservationOutcome;
typedef std::future<ReleaseCapacityReservationOutcome> ReleaseCapacityReservationOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::ReleaseCapacityReservationRequest&, const ReleaseCapacityReservationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReleaseCapacityReservationAsyncHandler;
typedef Outcome<Error, Model::ReleaseDedicatedHostResult> ReleaseDedicatedHostOutcome;
typedef std::future<ReleaseDedicatedHostOutcome> ReleaseDedicatedHostOutcomeCallable;
typedef std::function<void(const EcsClient*, const Model::ReleaseDedicatedHostRequest&, const ReleaseDedicatedHostOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& context = nullptr) const;
ReleaseDedicatedHostOutcomeCallable releaseDedicatedHostCallable(const Model::ReleaseDedicatedHostRequest& request) const;

114
ecs/include/alibabacloud/ecs/model/CreateCapacityReservationRequest.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ecs/EcsExport.h>
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<std::string> getZoneId()const;
void setZoneId(const std::vector<std::string>& 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<std::string> zoneId_;
std::string chargeType_;
std::string packageType_;
int instanceAmount_;
};
}
}
}
#endif // !ALIBABACLOUD_ECS_MODEL_CREATECAPACITYRESERVATIONREQUEST_H_

51
ecs/include/alibabacloud/ecs/model/CreateCapacityReservationResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ECS_MODEL_CREATECAPACITYRESERVATIONRESULT_H_
#define ALIBABACLOUD_ECS_MODEL_CREATECAPACITYRESERVATIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ecs/EcsExport.h>
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_

72
ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationInstancesRequest.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ecs/EcsExport.h>
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_

61
ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationInstancesResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ecs/EcsExport.h>
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<InstanceIdSet> getCapacityReservationItem()const;
int getTotalCount()const;
std::string getNextToken()const;
int getMaxResults()const;
protected:
void parse(const std::string &payload);
private:
std::vector<InstanceIdSet> capacityReservationItem_;
int totalCount_;
std::string nextToken_;
int maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONINSTANCESRESULT_H_

84
ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationsRequest.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ecs/EcsExport.h>
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_

79
ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationsResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ecs/EcsExport.h>
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<CapacityReservationItem::AllocatedResource> allocatedResources;
std::string privatePoolOptionsId;
};
DescribeCapacityReservationsResult();
explicit DescribeCapacityReservationsResult(const std::string &payload);
~DescribeCapacityReservationsResult();
int getTotalCount()const;
std::string getNextToken()const;
int getMaxResults()const;
std::vector<CapacityReservationItem> getCapacityReservationSet()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
std::string nextToken_;
int maxResults_;
std::vector<CapacityReservationItem> capacityReservationSet_;
};
}
}
}
#endif // !ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONSRESULT_H_

12
ecs/include/alibabacloud/ecs/model/DescribeElasticityAssurancesRequest.h
View File

@@ -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_;
};

66
ecs/include/alibabacloud/ecs/model/ReleaseCapacityReservationRequest.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ecs/EcsExport.h>
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_

49
ecs/include/alibabacloud/ecs/model/ReleaseCapacityReservationResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ecs/EcsExport.h>
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_

3
ecs/include/alibabacloud/ecs/model/RunInstancesRequest.h
View File

@@ -226,6 +226,8 @@ namespace AlibabaCloud
void setDataDisk(const std::vector<DataDisk>& 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> dataDisk_;
long launchTemplateVersion_;
std::string schedulerOptionsManagedPrivateSpaceId_;
std::string storageSetId_;
std::string httpTokens_;
std::string systemDiskDescription_;

144
ecs/src/EcsClient.cc
View File

@@ -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<const AsyncCallerContext>& 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<std::packaged_task<CreateCapacityReservationOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<DescribeCapacityReservationInstancesOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<DescribeCapacityReservationsOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<ReleaseCapacityReservationOutcome()>>(
[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();

284
ecs/src/model/CreateCapacityReservationRequest.cc Normal file
View File

@@ -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 <alibabacloud/ecs/model/CreateCapacityReservationRequest.h>
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<std::string> CreateCapacityReservationRequest::getZoneId()const
{
return zoneId_;
}
void CreateCapacityReservationRequest::setZoneId(const std::vector<std::string>& 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));
}

51
ecs/src/model/CreateCapacityReservationResult.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ecs/model/CreateCapacityReservationResult.h>
#include <json/json.h>
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_;
}

128
ecs/src/model/DescribeCapacityReservationInstancesRequest.cc Normal file
View File

@@ -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 <alibabacloud/ecs/model/DescribeCapacityReservationInstancesRequest.h>
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);
}

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

@@ -0,0 +1,78 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ecs/model/DescribeCapacityReservationInstancesResult.h>
#include <json/json.h>
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::InstanceIdSet> DescribeCapacityReservationInstancesResult::getCapacityReservationItem()const
{
return capacityReservationItem_;
}
int DescribeCapacityReservationInstancesResult::getTotalCount()const
{
return totalCount_;
}
std::string DescribeCapacityReservationInstancesResult::getNextToken()const
{
return nextToken_;
}
int DescribeCapacityReservationInstancesResult::getMaxResults()const
{
return maxResults_;
}

172
ecs/src/model/DescribeCapacityReservationsRequest.cc Normal file
View File

@@ -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 <alibabacloud/ecs/model/DescribeCapacityReservationsRequest.h>
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);
}

112
ecs/src/model/DescribeCapacityReservationsResult.cc Normal file
View File

@@ -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 <alibabacloud/ecs/model/DescribeCapacityReservationsResult.h>
#include <json/json.h>
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::CapacityReservationItem> DescribeCapacityReservationsResult::getCapacityReservationSet()const
{
return capacityReservationSet_;
}

44
ecs/src/model/DescribeElasticityAssurancesRequest.cc
View File

@@ -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_;

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

@@ -0,0 +1,106 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ecs/model/ReleaseCapacityReservationRequest.h>
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));
}

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

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ecs/model/ReleaseCapacityReservationResult.h>
#include <json/json.h>
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());
}

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

@@ -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_;