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

Generated 2017-11-10 for Ens.

Browse Source
This commit is contained in:
sdk-team
2024-08-23 02:42:48 +00:00
parent 1f76e81f67
commit 776d68f0aa
54 changed files with 2336 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.1977
1.36.1978

28
ens/CMakeLists.txt
View File

@@ -107,6 +107,10 @@ set(ens_public_header_model
include/alibabacloud/ens/model/CreateSnapshotResult.h
include/alibabacloud/ens/model/CreateSnatEntryRequest.h
include/alibabacloud/ens/model/CreateSnatEntryResult.h
include/alibabacloud/ens/model/CreateStorageGatewayRequest.h
include/alibabacloud/ens/model/CreateStorageGatewayResult.h
include/alibabacloud/ens/model/CreateStorageVolumeRequest.h
include/alibabacloud/ens/model/CreateStorageVolumeResult.h
include/alibabacloud/ens/model/CreateVSwitchRequest.h
include/alibabacloud/ens/model/CreateVSwitchResult.h
include/alibabacloud/ens/model/DeleteApplicationRequest.h
@@ -159,6 +163,10 @@ set(ens_public_header_model
include/alibabacloud/ens/model/DeleteSnatEntryResult.h
include/alibabacloud/ens/model/DeleteSnatIpForSnatEntryRequest.h
include/alibabacloud/ens/model/DeleteSnatIpForSnatEntryResult.h
include/alibabacloud/ens/model/DeleteStorageGatewayRequest.h
include/alibabacloud/ens/model/DeleteStorageGatewayResult.h
include/alibabacloud/ens/model/DeleteStorageVolumeRequest.h
include/alibabacloud/ens/model/DeleteStorageVolumeResult.h
include/alibabacloud/ens/model/DeleteVSwitchRequest.h
include/alibabacloud/ens/model/DeleteVSwitchResult.h
include/alibabacloud/ens/model/DeployInstanceSDGRequest.h
@@ -329,6 +337,10 @@ set(ens_public_header_model
include/alibabacloud/ens/model/DescribeSnatAttributeResult.h
include/alibabacloud/ens/model/DescribeSnatTableEntriesRequest.h
include/alibabacloud/ens/model/DescribeSnatTableEntriesResult.h
include/alibabacloud/ens/model/DescribeStorageGatewayRequest.h
include/alibabacloud/ens/model/DescribeStorageGatewayResult.h
include/alibabacloud/ens/model/DescribeStorageVolumeRequest.h
include/alibabacloud/ens/model/DescribeStorageVolumeResult.h
include/alibabacloud/ens/model/DescribeUserBandWidthDataRequest.h
include/alibabacloud/ens/model/DescribeUserBandWidthDataResult.h
include/alibabacloud/ens/model/DescribeVSwitchesRequest.h
@@ -405,6 +417,8 @@ set(ens_public_header_model
include/alibabacloud/ens/model/ModifyVSwitchAttributeResult.h
include/alibabacloud/ens/model/PreloadRegionSDGRequest.h
include/alibabacloud/ens/model/PreloadRegionSDGResult.h
include/alibabacloud/ens/model/PrepareUploadRequest.h
include/alibabacloud/ens/model/PrepareUploadResult.h
include/alibabacloud/ens/model/PushApplicationDataRequest.h
include/alibabacloud/ens/model/PushApplicationDataResult.h
include/alibabacloud/ens/model/PutBucketRequest.h
@@ -618,6 +632,10 @@ set(ens_src
src/model/CreateSnapshotResult.cc
src/model/CreateSnatEntryRequest.cc
src/model/CreateSnatEntryResult.cc
src/model/CreateStorageGatewayRequest.cc
src/model/CreateStorageGatewayResult.cc
src/model/CreateStorageVolumeRequest.cc
src/model/CreateStorageVolumeResult.cc
src/model/CreateVSwitchRequest.cc
src/model/CreateVSwitchResult.cc
src/model/DeleteApplicationRequest.cc
@@ -670,6 +688,10 @@ set(ens_src
src/model/DeleteSnatEntryResult.cc
src/model/DeleteSnatIpForSnatEntryRequest.cc
src/model/DeleteSnatIpForSnatEntryResult.cc
src/model/DeleteStorageGatewayRequest.cc
src/model/DeleteStorageGatewayResult.cc
src/model/DeleteStorageVolumeRequest.cc
src/model/DeleteStorageVolumeResult.cc
src/model/DeleteVSwitchRequest.cc
src/model/DeleteVSwitchResult.cc
src/model/DeployInstanceSDGRequest.cc
@@ -840,6 +862,10 @@ set(ens_src
src/model/DescribeSnatAttributeResult.cc
src/model/DescribeSnatTableEntriesRequest.cc
src/model/DescribeSnatTableEntriesResult.cc
src/model/DescribeStorageGatewayRequest.cc
src/model/DescribeStorageGatewayResult.cc
src/model/DescribeStorageVolumeRequest.cc
src/model/DescribeStorageVolumeResult.cc
src/model/DescribeUserBandWidthDataRequest.cc
src/model/DescribeUserBandWidthDataResult.cc
src/model/DescribeVSwitchesRequest.cc
@@ -916,6 +942,8 @@ set(ens_src
src/model/ModifyVSwitchAttributeResult.cc
src/model/PreloadRegionSDGRequest.cc
src/model/PreloadRegionSDGResult.cc
src/model/PrepareUploadRequest.cc
src/model/PrepareUploadResult.cc
src/model/PushApplicationDataRequest.cc
src/model/PushApplicationDataResult.cc
src/model/PutBucketRequest.cc

56
ens/include/alibabacloud/ens/EnsClient.h
View File

@@ -108,6 +108,10 @@
#include "model/CreateSnapshotResult.h"
#include "model/CreateSnatEntryRequest.h"
#include "model/CreateSnatEntryResult.h"
#include "model/CreateStorageGatewayRequest.h"
#include "model/CreateStorageGatewayResult.h"
#include "model/CreateStorageVolumeRequest.h"
#include "model/CreateStorageVolumeResult.h"
#include "model/CreateVSwitchRequest.h"
#include "model/CreateVSwitchResult.h"
#include "model/DeleteApplicationRequest.h"
@@ -160,6 +164,10 @@
#include "model/DeleteSnatEntryResult.h"
#include "model/DeleteSnatIpForSnatEntryRequest.h"
#include "model/DeleteSnatIpForSnatEntryResult.h"
#include "model/DeleteStorageGatewayRequest.h"
#include "model/DeleteStorageGatewayResult.h"
#include "model/DeleteStorageVolumeRequest.h"
#include "model/DeleteStorageVolumeResult.h"
#include "model/DeleteVSwitchRequest.h"
#include "model/DeleteVSwitchResult.h"
#include "model/DeployInstanceSDGRequest.h"
@@ -330,6 +338,10 @@
#include "model/DescribeSnatAttributeResult.h"
#include "model/DescribeSnatTableEntriesRequest.h"
#include "model/DescribeSnatTableEntriesResult.h"
#include "model/DescribeStorageGatewayRequest.h"
#include "model/DescribeStorageGatewayResult.h"
#include "model/DescribeStorageVolumeRequest.h"
#include "model/DescribeStorageVolumeResult.h"
#include "model/DescribeUserBandWidthDataRequest.h"
#include "model/DescribeUserBandWidthDataResult.h"
#include "model/DescribeVSwitchesRequest.h"
@@ -406,6 +418,8 @@
#include "model/ModifyVSwitchAttributeResult.h"
#include "model/PreloadRegionSDGRequest.h"
#include "model/PreloadRegionSDGResult.h"
#include "model/PrepareUploadRequest.h"
#include "model/PrepareUploadResult.h"
#include "model/PushApplicationDataRequest.h"
#include "model/PushApplicationDataResult.h"
#include "model/PutBucketRequest.h"
@@ -668,6 +682,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CreateSnatEntryResult> CreateSnatEntryOutcome;
typedef std::future<CreateSnatEntryOutcome> CreateSnatEntryOutcomeCallable;
typedef std::function<void(const EnsClient*, const Model::CreateSnatEntryRequest&, const CreateSnatEntryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateSnatEntryAsyncHandler;
typedef Outcome<Error, Model::CreateStorageGatewayResult> CreateStorageGatewayOutcome;
typedef std::future<CreateStorageGatewayOutcome> CreateStorageGatewayOutcomeCallable;
typedef std::function<void(const EnsClient*, const Model::CreateStorageGatewayRequest&, const CreateStorageGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateStorageGatewayAsyncHandler;
typedef Outcome<Error, Model::CreateStorageVolumeResult> CreateStorageVolumeOutcome;
typedef std::future<CreateStorageVolumeOutcome> CreateStorageVolumeOutcomeCallable;
typedef std::function<void(const EnsClient*, const Model::CreateStorageVolumeRequest&, const CreateStorageVolumeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateStorageVolumeAsyncHandler;
typedef Outcome<Error, Model::CreateVSwitchResult> CreateVSwitchOutcome;
typedef std::future<CreateVSwitchOutcome> CreateVSwitchOutcomeCallable;
typedef std::function<void(const EnsClient*, const Model::CreateVSwitchRequest&, const CreateVSwitchOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVSwitchAsyncHandler;
@@ -746,6 +766,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DeleteSnatIpForSnatEntryResult> DeleteSnatIpForSnatEntryOutcome;
typedef std::future<DeleteSnatIpForSnatEntryOutcome> DeleteSnatIpForSnatEntryOutcomeCallable;
typedef std::function<void(const EnsClient*, const Model::DeleteSnatIpForSnatEntryRequest&, const DeleteSnatIpForSnatEntryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSnatIpForSnatEntryAsyncHandler;
typedef Outcome<Error, Model::DeleteStorageGatewayResult> DeleteStorageGatewayOutcome;
typedef std::future<DeleteStorageGatewayOutcome> DeleteStorageGatewayOutcomeCallable;
typedef std::function<void(const EnsClient*, const Model::DeleteStorageGatewayRequest&, const DeleteStorageGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteStorageGatewayAsyncHandler;
typedef Outcome<Error, Model::DeleteStorageVolumeResult> DeleteStorageVolumeOutcome;
typedef std::future<DeleteStorageVolumeOutcome> DeleteStorageVolumeOutcomeCallable;
typedef std::function<void(const EnsClient*, const Model::DeleteStorageVolumeRequest&, const DeleteStorageVolumeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteStorageVolumeAsyncHandler;
typedef Outcome<Error, Model::DeleteVSwitchResult> DeleteVSwitchOutcome;
typedef std::future<DeleteVSwitchOutcome> DeleteVSwitchOutcomeCallable;
typedef std::function<void(const EnsClient*, const Model::DeleteVSwitchRequest&, const DeleteVSwitchOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVSwitchAsyncHandler;
@@ -1001,6 +1027,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeSnatTableEntriesResult> DescribeSnatTableEntriesOutcome;
typedef std::future<DescribeSnatTableEntriesOutcome> DescribeSnatTableEntriesOutcomeCallable;
typedef std::function<void(const EnsClient*, const Model::DescribeSnatTableEntriesRequest&, const DescribeSnatTableEntriesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSnatTableEntriesAsyncHandler;
typedef Outcome<Error, Model::DescribeStorageGatewayResult> DescribeStorageGatewayOutcome;
typedef std::future<DescribeStorageGatewayOutcome> DescribeStorageGatewayOutcomeCallable;
typedef std::function<void(const EnsClient*, const Model::DescribeStorageGatewayRequest&, const DescribeStorageGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeStorageGatewayAsyncHandler;
typedef Outcome<Error, Model::DescribeStorageVolumeResult> DescribeStorageVolumeOutcome;
typedef std::future<DescribeStorageVolumeOutcome> DescribeStorageVolumeOutcomeCallable;
typedef std::function<void(const EnsClient*, const Model::DescribeStorageVolumeRequest&, const DescribeStorageVolumeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeStorageVolumeAsyncHandler;
typedef Outcome<Error, Model::DescribeUserBandWidthDataResult> DescribeUserBandWidthDataOutcome;
typedef std::future<DescribeUserBandWidthDataOutcome> DescribeUserBandWidthDataOutcomeCallable;
typedef std::function<void(const EnsClient*, const Model::DescribeUserBandWidthDataRequest&, const DescribeUserBandWidthDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeUserBandWidthDataAsyncHandler;
@@ -1115,6 +1147,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::PreloadRegionSDGResult> PreloadRegionSDGOutcome;
typedef std::future<PreloadRegionSDGOutcome> PreloadRegionSDGOutcomeCallable;
typedef std::function<void(const EnsClient*, const Model::PreloadRegionSDGRequest&, const PreloadRegionSDGOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PreloadRegionSDGAsyncHandler;
typedef Outcome<Error, Model::PrepareUploadResult> PrepareUploadOutcome;
typedef std::future<PrepareUploadOutcome> PrepareUploadOutcomeCallable;
typedef std::function<void(const EnsClient*, const Model::PrepareUploadRequest&, const PrepareUploadOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PrepareUploadAsyncHandler;
typedef Outcome<Error, Model::PushApplicationDataResult> PushApplicationDataOutcome;
typedef std::future<PushApplicationDataOutcome> PushApplicationDataOutcomeCallable;
typedef std::function<void(const EnsClient*, const Model::PushApplicationDataRequest&, const PushApplicationDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PushApplicationDataAsyncHandler;
@@ -1435,6 +1470,12 @@ namespace AlibabaCloud
CreateSnatEntryOutcome createSnatEntry(const Model::CreateSnatEntryRequest &request)const;
void createSnatEntryAsync(const Model::CreateSnatEntryRequest& request, const CreateSnatEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateSnatEntryOutcomeCallable createSnatEntryCallable(const Model::CreateSnatEntryRequest& request) const;
CreateStorageGatewayOutcome createStorageGateway(const Model::CreateStorageGatewayRequest &request)const;
void createStorageGatewayAsync(const Model::CreateStorageGatewayRequest& request, const CreateStorageGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateStorageGatewayOutcomeCallable createStorageGatewayCallable(const Model::CreateStorageGatewayRequest& request) const;
CreateStorageVolumeOutcome createStorageVolume(const Model::CreateStorageVolumeRequest &request)const;
void createStorageVolumeAsync(const Model::CreateStorageVolumeRequest& request, const CreateStorageVolumeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateStorageVolumeOutcomeCallable createStorageVolumeCallable(const Model::CreateStorageVolumeRequest& request) const;
CreateVSwitchOutcome createVSwitch(const Model::CreateVSwitchRequest &request)const;
void createVSwitchAsync(const Model::CreateVSwitchRequest& request, const CreateVSwitchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateVSwitchOutcomeCallable createVSwitchCallable(const Model::CreateVSwitchRequest& request) const;
@@ -1513,6 +1554,12 @@ namespace AlibabaCloud
DeleteSnatIpForSnatEntryOutcome deleteSnatIpForSnatEntry(const Model::DeleteSnatIpForSnatEntryRequest &request)const;
void deleteSnatIpForSnatEntryAsync(const Model::DeleteSnatIpForSnatEntryRequest& request, const DeleteSnatIpForSnatEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteSnatIpForSnatEntryOutcomeCallable deleteSnatIpForSnatEntryCallable(const Model::DeleteSnatIpForSnatEntryRequest& request) const;
DeleteStorageGatewayOutcome deleteStorageGateway(const Model::DeleteStorageGatewayRequest &request)const;
void deleteStorageGatewayAsync(const Model::DeleteStorageGatewayRequest& request, const DeleteStorageGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteStorageGatewayOutcomeCallable deleteStorageGatewayCallable(const Model::DeleteStorageGatewayRequest& request) const;
DeleteStorageVolumeOutcome deleteStorageVolume(const Model::DeleteStorageVolumeRequest &request)const;
void deleteStorageVolumeAsync(const Model::DeleteStorageVolumeRequest& request, const DeleteStorageVolumeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteStorageVolumeOutcomeCallable deleteStorageVolumeCallable(const Model::DeleteStorageVolumeRequest& request) const;
DeleteVSwitchOutcome deleteVSwitch(const Model::DeleteVSwitchRequest &request)const;
void deleteVSwitchAsync(const Model::DeleteVSwitchRequest& request, const DeleteVSwitchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteVSwitchOutcomeCallable deleteVSwitchCallable(const Model::DeleteVSwitchRequest& request) const;
@@ -1768,6 +1815,12 @@ namespace AlibabaCloud
DescribeSnatTableEntriesOutcome describeSnatTableEntries(const Model::DescribeSnatTableEntriesRequest &request)const;
void describeSnatTableEntriesAsync(const Model::DescribeSnatTableEntriesRequest& request, const DescribeSnatTableEntriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeSnatTableEntriesOutcomeCallable describeSnatTableEntriesCallable(const Model::DescribeSnatTableEntriesRequest& request) const;
DescribeStorageGatewayOutcome describeStorageGateway(const Model::DescribeStorageGatewayRequest &request)const;
void describeStorageGatewayAsync(const Model::DescribeStorageGatewayRequest& request, const DescribeStorageGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeStorageGatewayOutcomeCallable describeStorageGatewayCallable(const Model::DescribeStorageGatewayRequest& request) const;
DescribeStorageVolumeOutcome describeStorageVolume(const Model::DescribeStorageVolumeRequest &request)const;
void describeStorageVolumeAsync(const Model::DescribeStorageVolumeRequest& request, const DescribeStorageVolumeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeStorageVolumeOutcomeCallable describeStorageVolumeCallable(const Model::DescribeStorageVolumeRequest& request) const;
DescribeUserBandWidthDataOutcome describeUserBandWidthData(const Model::DescribeUserBandWidthDataRequest &request)const;
void describeUserBandWidthDataAsync(const Model::DescribeUserBandWidthDataRequest& request, const DescribeUserBandWidthDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeUserBandWidthDataOutcomeCallable describeUserBandWidthDataCallable(const Model::DescribeUserBandWidthDataRequest& request) const;
@@ -1882,6 +1935,9 @@ namespace AlibabaCloud
PreloadRegionSDGOutcome preloadRegionSDG(const Model::PreloadRegionSDGRequest &request)const;
void preloadRegionSDGAsync(const Model::PreloadRegionSDGRequest& request, const PreloadRegionSDGAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
PreloadRegionSDGOutcomeCallable preloadRegionSDGCallable(const Model::PreloadRegionSDGRequest& request) const;
PrepareUploadOutcome prepareUpload(const Model::PrepareUploadRequest &request)const;
void prepareUploadAsync(const Model::PrepareUploadRequest& request, const PrepareUploadAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
PrepareUploadOutcomeCallable prepareUploadCallable(const Model::PrepareUploadRequest& request) const;
PushApplicationDataOutcome pushApplicationData(const Model::PushApplicationDataRequest &request)const;
void pushApplicationDataAsync(const Model::PushApplicationDataRequest& request, const PushApplicationDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
PushApplicationDataOutcomeCallable pushApplicationDataCallable(const Model::PushApplicationDataRequest& request) const;

3
ens/include/alibabacloud/ens/model/CreateLoadBalancerHTTPListenerRequest.h
View File

@@ -54,6 +54,8 @@ public:
void setLoadBalancerId(const std::string &loadBalancerId);
int getHealthCheckInterval() const;
void setHealthCheckInterval(int healthCheckInterval);
int getBackendServerPort() const;
void setBackendServerPort(int backendServerPort);
std::string getDescription() const;
void setDescription(const std::string &description);
int getUnhealthyThreshold() const;
@@ -92,6 +94,7 @@ private:
int requestTimeout_;
std::string loadBalancerId_;
int healthCheckInterval_;
int backendServerPort_;
std::string description_;
int unhealthyThreshold_;
int healthyThreshold_;

3
ens/include/alibabacloud/ens/model/CreateLoadBalancerHTTPSListenerRequest.h
View File

@@ -52,6 +52,8 @@ public:
void setLoadBalancerId(const std::string &loadBalancerId);
int getHealthCheckInterval() const;
void setHealthCheckInterval(int healthCheckInterval);
int getBackendServerPort() const;
void setBackendServerPort(int backendServerPort);
std::string getDescription() const;
void setDescription(const std::string &description);
int getUnhealthyThreshold() const;
@@ -91,6 +93,7 @@ private:
int requestTimeout_;
std::string loadBalancerId_;
int healthCheckInterval_;
int backendServerPort_;
std::string description_;
int unhealthyThreshold_;
int healthyThreshold_;

3
ens/include/alibabacloud/ens/model/CreateLoadBalancerUDPListenerRequest.h
View File

@@ -32,6 +32,8 @@ public:
~CreateLoadBalancerUDPListenerRequest();
std::string getProtocol() const;
void setProtocol(const std::string &protocol);
int getEstablishedTimeout() const;
void setEstablishedTimeout(int establishedTimeout);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
std::string getHealthCheckReq() const;
@@ -61,6 +63,7 @@ public:
private:
std::string protocol_;
int establishedTimeout_;
std::string loadBalancerId_;
std::string healthCheckReq_;
int healthCheckInterval_;

49
ens/include/alibabacloud/ens/model/CreateStorageGatewayRequest.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_ENS_MODEL_CREATESTORAGEGATEWAYREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATESTORAGEGATEWAYREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateStorageGatewayRequest : public RpcServiceRequest {
public:
struct OrderDetails {
std::string gatewayType;
std::string vpcId;
std::string gatewayName;
std::string ensRegionId;
std::string description;
};
CreateStorageGatewayRequest();
~CreateStorageGatewayRequest();
std::vector<OrderDetails> getOrderDetails() const;
void setOrderDetails(const std::vector<OrderDetails> &orderDetails);
private:
std::vector<OrderDetails> orderDetails_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATESTORAGEGATEWAYREQUEST_H_

65
ens/include/alibabacloud/ens/model/CreateStorageGatewayResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* 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_ENS_MODEL_CREATESTORAGEGATEWAYRESULT_H_
#define ALIBABACLOUD_ENS_MODEL_CREATESTORAGEGATEWAYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ens/EnsExport.h>
namespace AlibabaCloud
{
namespace Ens
{
namespace Model
{
class ALIBABACLOUD_ENS_EXPORT CreateStorageGatewayResult : public ServiceResult
{
public:
struct AllocationIdItem
{
std::string instanceId;
std::string ensRegionId;
};
struct UnAllocationIdItem
{
std::string instanceId;
std::string ensRegionId;
};
CreateStorageGatewayResult();
explicit CreateStorageGatewayResult(const std::string &payload);
~CreateStorageGatewayResult();
std::string getBizStatusCode()const;
std::vector<AllocationIdItem> getAllocationId()const;
std::vector<UnAllocationIdItem> getUnAllocationId()const;
protected:
void parse(const std::string &payload);
private:
std::string bizStatusCode_;
std::vector<AllocationIdItem> allocationId_;
std::vector<UnAllocationIdItem> unAllocationId_;
};
}
}
}
#endif // !ALIBABACLOUD_ENS_MODEL_CREATESTORAGEGATEWAYRESULT_H_

69
ens/include/alibabacloud/ens/model/CreateStorageVolumeRequest.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* 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_ENS_MODEL_CREATESTORAGEVOLUMEREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATESTORAGEVOLUMEREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateStorageVolumeRequest : public RpcServiceRequest {
public:
CreateStorageVolumeRequest();
~CreateStorageVolumeRequest();
std::string getEnsRegionId() const;
void setEnsRegionId(const std::string &ensRegionId);
std::string getGatewayId() const;
void setGatewayId(const std::string &gatewayId);
std::string getAuthUser() const;
void setAuthUser(const std::string &authUser);
std::string getVolumeName() const;
void setVolumeName(const std::string &volumeName);
std::string getAuthPassword() const;
void setAuthPassword(const std::string &authPassword);
std::string getAuthProtocol() const;
void setAuthProtocol(const std::string &authProtocol);
std::string getDescription() const;
void setDescription(const std::string &description);
std::string getIsEnable() const;
void setIsEnable(const std::string &isEnable);
std::string getIsAuth() const;
void setIsAuth(const std::string &isAuth);
std::string getStorageId() const;
void setStorageId(const std::string &storageId);
private:
std::string ensRegionId_;
std::string gatewayId_;
std::string authUser_;
std::string volumeName_;
std::string authPassword_;
std::string authProtocol_;
std::string description_;
std::string isEnable_;
std::string isAuth_;
std::string storageId_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATESTORAGEVOLUMEREQUEST_H_

51
ens/include/alibabacloud/ens/model/CreateStorageVolumeResult.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_ENS_MODEL_CREATESTORAGEVOLUMERESULT_H_
#define ALIBABACLOUD_ENS_MODEL_CREATESTORAGEVOLUMERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ens/EnsExport.h>
namespace AlibabaCloud
{
namespace Ens
{
namespace Model
{
class ALIBABACLOUD_ENS_EXPORT CreateStorageVolumeResult : public ServiceResult
{
public:
CreateStorageVolumeResult();
explicit CreateStorageVolumeResult(const std::string &payload);
~CreateStorageVolumeResult();
std::vector<std::string> getVolumeId()const;
protected:
void parse(const std::string &payload);
private:
std::vector<std::string> volumeId_;
};
}
}
}
#endif // !ALIBABACLOUD_ENS_MODEL_CREATESTORAGEVOLUMERESULT_H_

42
ens/include/alibabacloud/ens/model/DeleteStorageGatewayRequest.h Normal file
View File

@@ -0,0 +1,42 @@
/*
* 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_ENS_MODEL_DELETESTORAGEGATEWAYREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_DELETESTORAGEGATEWAYREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT DeleteStorageGatewayRequest : public RpcServiceRequest {
public:
DeleteStorageGatewayRequest();
~DeleteStorageGatewayRequest();
std::string getGatewayId() const;
void setGatewayId(const std::string &gatewayId);
private:
std::string gatewayId_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_DELETESTORAGEGATEWAYREQUEST_H_

49
ens/include/alibabacloud/ens/model/DeleteStorageGatewayResult.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_ENS_MODEL_DELETESTORAGEGATEWAYRESULT_H_
#define ALIBABACLOUD_ENS_MODEL_DELETESTORAGEGATEWAYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ens/EnsExport.h>
namespace AlibabaCloud
{
namespace Ens
{
namespace Model
{
class ALIBABACLOUD_ENS_EXPORT DeleteStorageGatewayResult : public ServiceResult
{
public:
DeleteStorageGatewayResult();
explicit DeleteStorageGatewayResult(const std::string &payload);
~DeleteStorageGatewayResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ENS_MODEL_DELETESTORAGEGATEWAYRESULT_H_

42
ens/include/alibabacloud/ens/model/DeleteStorageVolumeRequest.h Normal file
View File

@@ -0,0 +1,42 @@
/*
* 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_ENS_MODEL_DELETESTORAGEVOLUMEREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_DELETESTORAGEVOLUMEREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT DeleteStorageVolumeRequest : public RpcServiceRequest {
public:
DeleteStorageVolumeRequest();
~DeleteStorageVolumeRequest();
std::string getVolumeId() const;
void setVolumeId(const std::string &volumeId);
private:
std::string volumeId_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_DELETESTORAGEVOLUMEREQUEST_H_

49
ens/include/alibabacloud/ens/model/DeleteStorageVolumeResult.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_ENS_MODEL_DELETESTORAGEVOLUMERESULT_H_
#define ALIBABACLOUD_ENS_MODEL_DELETESTORAGEVOLUMERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ens/EnsExport.h>
namespace AlibabaCloud
{
namespace Ens
{
namespace Model
{
class ALIBABACLOUD_ENS_EXPORT DeleteStorageVolumeResult : public ServiceResult
{
public:
DeleteStorageVolumeResult();
explicit DeleteStorageVolumeResult(const std::string &payload);
~DeleteStorageVolumeResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ENS_MODEL_DELETESTORAGEVOLUMERESULT_H_

2
ens/include/alibabacloud/ens/model/DescribeInstancesResult.h
View File

@@ -59,7 +59,9 @@ namespace AlibabaCloud
std::string uuid;
int storage;
std::string category;
std::string encryptKeyId;
int size;
bool encrypted;
int diskSize;
std::string diskName;
std::string diskId;

2
ens/include/alibabacloud/ens/model/DescribeLoadBalancerHTTPListenerAttributeResult.h
View File

@@ -44,6 +44,7 @@ namespace AlibabaCloud
std::string getHealthCheckURI()const;
std::string getHealthCheck()const;
int getIdleTimeout()const;
int getBackendServerPort()const;
int getHealthCheckConnectPort()const;
std::string getHealthCheckMethod()const;
int getBandwidth()const;
@@ -73,6 +74,7 @@ namespace AlibabaCloud
std::string healthCheckURI_;
std::string healthCheck_;
int idleTimeout_;
int backendServerPort_;
int healthCheckConnectPort_;
std::string healthCheckMethod_;
int bandwidth_;

46
ens/include/alibabacloud/ens/model/DescribeLoadBalancerHTTPSListenerAttributeResult.h
View File

@@ -37,58 +37,60 @@ namespace AlibabaCloud
DescribeLoadBalancerHTTPSListenerAttributeResult();
explicit DescribeLoadBalancerHTTPSListenerAttributeResult(const std::string &payload);
~DescribeLoadBalancerHTTPSListenerAttributeResult();
std::string getStatus()const;
int getCookieTimeout()const;
std::string getCookie()const;
int getListenerPort()const;
int getRequestTimeout()const;
int getHealthCheckInterval()const;
std::string getDescription()const;
int getUnhealthyThreshold()const;
std::string getScheduler()const;
std::string getHealthCheckURI()const;
std::string getHealthCheck()const;
int getIdleTimeout()const;
int getHealthCheckTimeout()const;
std::string getListenerForward()const;
std::string getStickySession()const;
int getBackendServerPort()const;
int getHealthCheckConnectPort()const;
int getForwardPort()const;
std::string getHealthCheckMethod()const;
int getBandwidth()const;
int getHealthyThreshold()const;
std::string getHealthCheckDomain()const;
std::string getServerCertificateId()const;
std::string getStickySessionType()const;
std::string getHealthCheckHttpCode()const;
std::string getStatus()const;
std::string getCookie()const;
int getListenerPort()const;
int getRequestTimeout()const;
int getHealthCheckInterval()const;
int getHealthCheckTimeout()const;
std::string getListenerForward()const;
std::string getStickySession()const;
int getForwardPort()const;
int getHealthyThreshold()const;
std::string getHealthCheckDomain()const;
protected:
void parse(const std::string &payload);
private:
std::string status_;
int cookieTimeout_;
std::string cookie_;
int listenerPort_;
int requestTimeout_;
int healthCheckInterval_;
std::string description_;
int unhealthyThreshold_;
std::string scheduler_;
std::string healthCheckURI_;
std::string healthCheck_;
int idleTimeout_;
int healthCheckTimeout_;
std::string listenerForward_;
std::string stickySession_;
int backendServerPort_;
int healthCheckConnectPort_;
int forwardPort_;
std::string healthCheckMethod_;
int bandwidth_;
int healthyThreshold_;
std::string healthCheckDomain_;
std::string serverCertificateId_;
std::string stickySessionType_;
std::string healthCheckHttpCode_;
std::string status_;
std::string cookie_;
int listenerPort_;
int requestTimeout_;
int healthCheckInterval_;
int healthCheckTimeout_;
std::string listenerForward_;
std::string stickySession_;
int forwardPort_;
int healthyThreshold_;
std::string healthCheckDomain_;
};
}

2
ens/include/alibabacloud/ens/model/DescribeLoadBalancerUDPListenerAttributeResult.h
View File

@@ -52,6 +52,7 @@ namespace AlibabaCloud
int getHealthyThreshold()const;
std::string getHealthCheckExp()const;
std::string getEipTransmit()const;
int getEstablishedTimeout()const;
protected:
void parse(const std::string &payload);
@@ -71,6 +72,7 @@ namespace AlibabaCloud
int healthyThreshold_;
std::string healthCheckExp_;
std::string eipTransmit_;
int establishedTimeout_;
};
}

24
ens/include/alibabacloud/ens/model/DescribeSDGDeploymentStatusRequest.h
View File

@@ -30,17 +30,29 @@ class ALIBABACLOUD_ENS_EXPORT DescribeSDGDeploymentStatusRequest : public RpcSer
public:
DescribeSDGDeploymentStatusRequest();
~DescribeSDGDeploymentStatusRequest();
std::string getPageNumber() const;
void setPageNumber(const std::string &pageNumber);
std::vector<std::string> getRegionIds() const;
void setRegionIds(const std::vector<std::string> &regionIds);
std::vector<std::string> getInstanceIds() const;
void setInstanceIds(const std::vector<std::string> &instanceIds);
std::string getStatus() const;
void setStatus(const std::string &status);
std::string getDeploymentType() const;
void setDeploymentType(const std::string &deploymentType);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getSDGId() const;
void setSDGId(const std::string &sDGId);
std::string getPageSize() const;
void setPageSize(const std::string &pageSize);
int getPageSize() const;
void setPageSize(int pageSize);
private:
std::string pageNumber_;
std::vector<std::string> regionIds_;
std::vector<std::string> instanceIds_;
std::string status_;
std::string deploymentType_;
int pageNumber_;
std::string sDGId_;
std::string pageSize_;
int pageSize_;
};
} // namespace Model
} // namespace Ens

7
ens/include/alibabacloud/ens/model/DescribeSelfImagesResult.h
View File

@@ -36,16 +36,17 @@ namespace AlibabaCloud
{
std::string imageOwnerAlias;
std::string status;
std::string imageName;
std::string snapshotId;
std::string architecture;
std::string platform;
std::string imageSize;
std::string instanceId;
std::string osVersion;
std::string computeType;
std::string imageStorageSize;
std::string imageName;
std::string snapshotId;
std::string creationTime;
std::string imageId;
std::string computeType;
};

57
ens/include/alibabacloud/ens/model/DescribeStorageGatewayRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* 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_ENS_MODEL_DESCRIBESTORAGEGATEWAYREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_DESCRIBESTORAGEGATEWAYREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT DescribeStorageGatewayRequest : public RpcServiceRequest {
public:
DescribeStorageGatewayRequest();
~DescribeStorageGatewayRequest();
std::string getPageNumber() const;
void setPageNumber(const std::string &pageNumber);
std::string getEnsRegionId() const;
void setEnsRegionId(const std::string &ensRegionId);
std::string getPageSize() const;
void setPageSize(const std::string &pageSize);
std::string getGatewayId() const;
void setGatewayId(const std::string &gatewayId);
std::string getGatewayType() const;
void setGatewayType(const std::string &gatewayType);
std::string getVpcId() const;
void setVpcId(const std::string &vpcId);
private:
std::string pageNumber_;
std::string ensRegionId_;
std::string pageSize_;
std::string gatewayId_;
std::string gatewayType_;
std::string vpcId_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBESTORAGEGATEWAYREQUEST_H_

70
ens/include/alibabacloud/ens/model/DescribeStorageGatewayResult.h Normal file
View File

@@ -0,0 +1,70 @@
/*
* 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_ENS_MODEL_DESCRIBESTORAGEGATEWAYRESULT_H_
#define ALIBABACLOUD_ENS_MODEL_DESCRIBESTORAGEGATEWAYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ens/EnsExport.h>
namespace AlibabaCloud
{
namespace Ens
{
namespace Model
{
class ALIBABACLOUD_ENS_EXPORT DescribeStorageGatewayResult : public ServiceResult
{
public:
struct StorageGatewaysItem
{
std::string storageGatewayName;
std::string status;
std::string serviceIp;
std::string description;
int storageGatewayType;
std::string vpcId;
std::string creationTime;
std::string cidrBlock;
std::string ensRegionId;
std::string storageGatewayId;
};
DescribeStorageGatewayResult();
explicit DescribeStorageGatewayResult(const std::string &payload);
~DescribeStorageGatewayResult();
std::vector<StorageGatewaysItem> getStorageGateways()const;
int getTotalCount()const;
int getPageSize()const;
int getPageNumber()const;
protected:
void parse(const std::string &payload);
private:
std::vector<StorageGatewaysItem> storageGateways_;
int totalCount_;
int pageSize_;
int pageNumber_;
};
}
}
}
#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBESTORAGEGATEWAYRESULT_H_

60
ens/include/alibabacloud/ens/model/DescribeStorageVolumeRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* 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_ENS_MODEL_DESCRIBESTORAGEVOLUMEREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_DESCRIBESTORAGEVOLUMEREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT DescribeStorageVolumeRequest : public RpcServiceRequest {
public:
DescribeStorageVolumeRequest();
~DescribeStorageVolumeRequest();
std::string getEnsRegionId() const;
void setEnsRegionId(const std::string &ensRegionId);
std::string getGatewayId() const;
void setGatewayId(const std::string &gatewayId);
std::string getVolumeId() const;
void setVolumeId(const std::string &volumeId);
int getPageNumber() const;
void setPageNumber(int pageNumber);
int getPageSize() const;
void setPageSize(int pageSize);
int getIsEnable() const;
void setIsEnable(int isEnable);
std::string getStorageId() const;
void setStorageId(const std::string &storageId);
private:
std::string ensRegionId_;
std::string gatewayId_;
std::string volumeId_;
int pageNumber_;
int pageSize_;
int isEnable_;
std::string storageId_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBESTORAGEVOLUMEREQUEST_H_

72
ens/include/alibabacloud/ens/model/DescribeStorageVolumeResult.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_ENS_MODEL_DESCRIBESTORAGEVOLUMERESULT_H_
#define ALIBABACLOUD_ENS_MODEL_DESCRIBESTORAGEVOLUMERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ens/EnsExport.h>
namespace AlibabaCloud
{
namespace Ens
{
namespace Model
{
class ALIBABACLOUD_ENS_EXPORT DescribeStorageVolumeResult : public ServiceResult
{
public:
struct StorageVolumesItem
{
std::string storageVolumeName;
std::string status;
int isEnable;
std::string description;
int isAuth;
std::string creationTime;
std::string authProtocol;
std::string storageVolumeId;
std::string targetName;
std::string ensRegionId;
std::string storageId;
std::string storageGatewayId;
};
DescribeStorageVolumeResult();
explicit DescribeStorageVolumeResult(const std::string &payload);
~DescribeStorageVolumeResult();
std::string getTotalCount()const;
std::string getPageSize()const;
std::string getPageNumber()const;
std::vector<StorageVolumesItem> getStorageVolumes()const;
protected:
void parse(const std::string &payload);
private:
std::string totalCount_;
std::string pageSize_;
std::string pageNumber_;
std::vector<StorageVolumesItem> storageVolumes_;
};
}
}
}
#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBESTORAGEVOLUMERESULT_H_

60
ens/include/alibabacloud/ens/model/PrepareUploadRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* 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_ENS_MODEL_PREPAREUPLOADREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_PREPAREUPLOADREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT PrepareUploadRequest : public RpcServiceRequest {
public:
PrepareUploadRequest();
~PrepareUploadRequest();
std::string getClientIp() const;
void setClientIp(const std::string &clientIp);
std::string getEnsRegionId() const;
void setEnsRegionId(const std::string &ensRegionId);
std::string getAdditionType() const;
void setAdditionType(const std::string &additionType);
std::string getBucketName() const;
void setBucketName(const std::string &bucketName);
std::string getStation() const;
void setStation(const std::string &station);
std::string getObjectKey() const;
void setObjectKey(const std::string &objectKey);
long getStorageCost() const;
void setStorageCost(long storageCost);
private:
std::string clientIp_;
std::string ensRegionId_;
std::string additionType_;
std::string bucketName_;
std::string station_;
std::string objectKey_;
long storageCost_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_PREPAREUPLOADREQUEST_H_

55
ens/include/alibabacloud/ens/model/PrepareUploadResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* 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_ENS_MODEL_PREPAREUPLOADRESULT_H_
#define ALIBABACLOUD_ENS_MODEL_PREPAREUPLOADRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ens/EnsExport.h>
namespace AlibabaCloud
{
namespace Ens
{
namespace Model
{
class ALIBABACLOUD_ENS_EXPORT PrepareUploadResult : public ServiceResult
{
public:
PrepareUploadResult();
explicit PrepareUploadResult(const std::string &payload);
~PrepareUploadResult();
std::string getBucketName()const;
std::string getEndpoint()const;
std::string getAdditionInfo()const;
protected:
void parse(const std::string &payload);
private:
std::string bucketName_;
std::string endpoint_;
std::string additionInfo_;
};
}
}
}
#endif // !ALIBABACLOUD_ENS_MODEL_PREPAREUPLOADRESULT_H_

2
ens/include/alibabacloud/ens/model/PutBucketLifecycleResult.h
View File

@@ -37,10 +37,12 @@ namespace AlibabaCloud
PutBucketLifecycleResult();
explicit PutBucketLifecycleResult(const std::string &payload);
~PutBucketLifecycleResult();
std::string getRuleId()const;
protected:
void parse(const std::string &payload);
private:
std::string ruleId_;
};
}

3
ens/include/alibabacloud/ens/model/SetLoadBalancerUDPListenerAttributeRequest.h
View File

@@ -32,6 +32,8 @@ public:
~SetLoadBalancerUDPListenerAttributeRequest();
std::string getProtocol() const;
void setProtocol(const std::string &protocol);
int getEstablishedTimeout() const;
void setEstablishedTimeout(int establishedTimeout);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
std::string getHealthCheckReq() const;
@@ -59,6 +61,7 @@ public:
private:
std::string protocol_;
int establishedTimeout_;
std::string loadBalancerId_;
std::string healthCheckReq_;
int healthCheckInterval_;

252
ens/src/EnsClient.cc
View File

@@ -1599,6 +1599,78 @@ EnsClient::CreateSnatEntryOutcomeCallable EnsClient::createSnatEntryCallable(con
return task->get_future();
}
EnsClient::CreateStorageGatewayOutcome EnsClient::createStorageGateway(const CreateStorageGatewayRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateStorageGatewayOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateStorageGatewayOutcome(CreateStorageGatewayResult(outcome.result()));
else
return CreateStorageGatewayOutcome(outcome.error());
}
void EnsClient::createStorageGatewayAsync(const CreateStorageGatewayRequest& request, const CreateStorageGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createStorageGateway(request), context);
};
asyncExecute(new Runnable(fn));
}
EnsClient::CreateStorageGatewayOutcomeCallable EnsClient::createStorageGatewayCallable(const CreateStorageGatewayRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateStorageGatewayOutcome()>>(
[this, request]()
{
return this->createStorageGateway(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EnsClient::CreateStorageVolumeOutcome EnsClient::createStorageVolume(const CreateStorageVolumeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateStorageVolumeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateStorageVolumeOutcome(CreateStorageVolumeResult(outcome.result()));
else
return CreateStorageVolumeOutcome(outcome.error());
}
void EnsClient::createStorageVolumeAsync(const CreateStorageVolumeRequest& request, const CreateStorageVolumeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createStorageVolume(request), context);
};
asyncExecute(new Runnable(fn));
}
EnsClient::CreateStorageVolumeOutcomeCallable EnsClient::createStorageVolumeCallable(const CreateStorageVolumeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateStorageVolumeOutcome()>>(
[this, request]()
{
return this->createStorageVolume(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EnsClient::CreateVSwitchOutcome EnsClient::createVSwitch(const CreateVSwitchRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2535,6 +2607,78 @@ EnsClient::DeleteSnatIpForSnatEntryOutcomeCallable EnsClient::deleteSnatIpForSna
return task->get_future();
}
EnsClient::DeleteStorageGatewayOutcome EnsClient::deleteStorageGateway(const DeleteStorageGatewayRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteStorageGatewayOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteStorageGatewayOutcome(DeleteStorageGatewayResult(outcome.result()));
else
return DeleteStorageGatewayOutcome(outcome.error());
}
void EnsClient::deleteStorageGatewayAsync(const DeleteStorageGatewayRequest& request, const DeleteStorageGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteStorageGateway(request), context);
};
asyncExecute(new Runnable(fn));
}
EnsClient::DeleteStorageGatewayOutcomeCallable EnsClient::deleteStorageGatewayCallable(const DeleteStorageGatewayRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteStorageGatewayOutcome()>>(
[this, request]()
{
return this->deleteStorageGateway(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EnsClient::DeleteStorageVolumeOutcome EnsClient::deleteStorageVolume(const DeleteStorageVolumeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteStorageVolumeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteStorageVolumeOutcome(DeleteStorageVolumeResult(outcome.result()));
else
return DeleteStorageVolumeOutcome(outcome.error());
}
void EnsClient::deleteStorageVolumeAsync(const DeleteStorageVolumeRequest& request, const DeleteStorageVolumeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteStorageVolume(request), context);
};
asyncExecute(new Runnable(fn));
}
EnsClient::DeleteStorageVolumeOutcomeCallable EnsClient::deleteStorageVolumeCallable(const DeleteStorageVolumeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteStorageVolumeOutcome()>>(
[this, request]()
{
return this->deleteStorageVolume(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EnsClient::DeleteVSwitchOutcome EnsClient::deleteVSwitch(const DeleteVSwitchRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -5595,6 +5739,78 @@ EnsClient::DescribeSnatTableEntriesOutcomeCallable EnsClient::describeSnatTableE
return task->get_future();
}
EnsClient::DescribeStorageGatewayOutcome EnsClient::describeStorageGateway(const DescribeStorageGatewayRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeStorageGatewayOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeStorageGatewayOutcome(DescribeStorageGatewayResult(outcome.result()));
else
return DescribeStorageGatewayOutcome(outcome.error());
}
void EnsClient::describeStorageGatewayAsync(const DescribeStorageGatewayRequest& request, const DescribeStorageGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeStorageGateway(request), context);
};
asyncExecute(new Runnable(fn));
}
EnsClient::DescribeStorageGatewayOutcomeCallable EnsClient::describeStorageGatewayCallable(const DescribeStorageGatewayRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeStorageGatewayOutcome()>>(
[this, request]()
{
return this->describeStorageGateway(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EnsClient::DescribeStorageVolumeOutcome EnsClient::describeStorageVolume(const DescribeStorageVolumeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeStorageVolumeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeStorageVolumeOutcome(DescribeStorageVolumeResult(outcome.result()));
else
return DescribeStorageVolumeOutcome(outcome.error());
}
void EnsClient::describeStorageVolumeAsync(const DescribeStorageVolumeRequest& request, const DescribeStorageVolumeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeStorageVolume(request), context);
};
asyncExecute(new Runnable(fn));
}
EnsClient::DescribeStorageVolumeOutcomeCallable EnsClient::describeStorageVolumeCallable(const DescribeStorageVolumeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeStorageVolumeOutcome()>>(
[this, request]()
{
return this->describeStorageVolume(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EnsClient::DescribeUserBandWidthDataOutcome EnsClient::describeUserBandWidthData(const DescribeUserBandWidthDataRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -6963,6 +7179,42 @@ EnsClient::PreloadRegionSDGOutcomeCallable EnsClient::preloadRegionSDGCallable(c
return task->get_future();
}
EnsClient::PrepareUploadOutcome EnsClient::prepareUpload(const PrepareUploadRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return PrepareUploadOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return PrepareUploadOutcome(PrepareUploadResult(outcome.result()));
else
return PrepareUploadOutcome(outcome.error());
}
void EnsClient::prepareUploadAsync(const PrepareUploadRequest& request, const PrepareUploadAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, prepareUpload(request), context);
};
asyncExecute(new Runnable(fn));
}
EnsClient::PrepareUploadOutcomeCallable EnsClient::prepareUploadCallable(const PrepareUploadRequest &request) const
{
auto task = std::make_shared<std::packaged_task<PrepareUploadOutcome()>>(
[this, request]()
{
return this->prepareUpload(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EnsClient::PushApplicationDataOutcome EnsClient::pushApplicationData(const PushApplicationDataRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

9
ens/src/model/CreateLoadBalancerHTTPListenerRequest.cc
View File

@@ -133,6 +133,15 @@ void CreateLoadBalancerHTTPListenerRequest::setHealthCheckInterval(int healthChe
setParameter(std::string("HealthCheckInterval"), std::to_string(healthCheckInterval));
}
int CreateLoadBalancerHTTPListenerRequest::getBackendServerPort() const {
return backendServerPort_;
}
void CreateLoadBalancerHTTPListenerRequest::setBackendServerPort(int backendServerPort) {
backendServerPort_ = backendServerPort;
setParameter(std::string("BackendServerPort"), std::to_string(backendServerPort));
}
std::string CreateLoadBalancerHTTPListenerRequest::getDescription() const {
return description_;
}

9
ens/src/model/CreateLoadBalancerHTTPSListenerRequest.cc
View File

@@ -124,6 +124,15 @@ void CreateLoadBalancerHTTPSListenerRequest::setHealthCheckInterval(int healthCh
setParameter(std::string("HealthCheckInterval"), std::to_string(healthCheckInterval));
}
int CreateLoadBalancerHTTPSListenerRequest::getBackendServerPort() const {
return backendServerPort_;
}
void CreateLoadBalancerHTTPSListenerRequest::setBackendServerPort(int backendServerPort) {
backendServerPort_ = backendServerPort;
setParameter(std::string("BackendServerPort"), std::to_string(backendServerPort));
}
std::string CreateLoadBalancerHTTPSListenerRequest::getDescription() const {
return description_;
}

9
ens/src/model/CreateLoadBalancerUDPListenerRequest.cc
View File

@@ -34,6 +34,15 @@ void CreateLoadBalancerUDPListenerRequest::setProtocol(const std::string &protoc
setParameter(std::string("Protocol"), protocol);
}
int CreateLoadBalancerUDPListenerRequest::getEstablishedTimeout() const {
return establishedTimeout_;
}
void CreateLoadBalancerUDPListenerRequest::setEstablishedTimeout(int establishedTimeout) {
establishedTimeout_ = establishedTimeout;
setParameter(std::string("EstablishedTimeout"), std::to_string(establishedTimeout));
}
std::string CreateLoadBalancerUDPListenerRequest::getLoadBalancerId() const {
return loadBalancerId_;
}

42
ens/src/model/CreateStorageGatewayRequest.cc Normal file
View File

@@ -0,0 +1,42 @@
/*
* 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/ens/model/CreateStorageGatewayRequest.h>
using AlibabaCloud::Ens::Model::CreateStorageGatewayRequest;
CreateStorageGatewayRequest::CreateStorageGatewayRequest()
: RpcServiceRequest("ens", "2017-11-10", "CreateStorageGateway") {
setMethod(HttpRequest::Method::Post);
}
CreateStorageGatewayRequest::~CreateStorageGatewayRequest() {}
std::vector<CreateStorageGatewayRequest::OrderDetails> CreateStorageGatewayRequest::getOrderDetails() const {
return orderDetails_;
}
void CreateStorageGatewayRequest::setOrderDetails(const std::vector<CreateStorageGatewayRequest::OrderDetails> &orderDetails) {
orderDetails_ = orderDetails;
for(int dep1 = 0; dep1 != orderDetails.size(); dep1++) {
setParameter(std::string("OrderDetails") + "." + std::to_string(dep1 + 1) + ".GatewayType", orderDetails[dep1].gatewayType);
setParameter(std::string("OrderDetails") + "." + std::to_string(dep1 + 1) + ".VpcId", orderDetails[dep1].vpcId);
setParameter(std::string("OrderDetails") + "." + std::to_string(dep1 + 1) + ".GatewayName", orderDetails[dep1].gatewayName);
setParameter(std::string("OrderDetails") + "." + std::to_string(dep1 + 1) + ".EnsRegionId", orderDetails[dep1].ensRegionId);
setParameter(std::string("OrderDetails") + "." + std::to_string(dep1 + 1) + ".Description", orderDetails[dep1].description);
}
}

81
ens/src/model/CreateStorageGatewayResult.cc Normal file
View File

@@ -0,0 +1,81 @@
/*
* 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/ens/model/CreateStorageGatewayResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ens;
using namespace AlibabaCloud::Ens::Model;
CreateStorageGatewayResult::CreateStorageGatewayResult() :
ServiceResult()
{}
CreateStorageGatewayResult::CreateStorageGatewayResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateStorageGatewayResult::~CreateStorageGatewayResult()
{}
void CreateStorageGatewayResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allAllocationIdNode = value["AllocationId"]["AllocationIdItem"];
for (auto valueAllocationIdAllocationIdItem : allAllocationIdNode)
{
AllocationIdItem allocationIdObject;
if(!valueAllocationIdAllocationIdItem["InstanceId"].isNull())
allocationIdObject.instanceId = valueAllocationIdAllocationIdItem["InstanceId"].asString();
if(!valueAllocationIdAllocationIdItem["EnsRegionId"].isNull())
allocationIdObject.ensRegionId = valueAllocationIdAllocationIdItem["EnsRegionId"].asString();
allocationId_.push_back(allocationIdObject);
}
auto allUnAllocationIdNode = value["UnAllocationId"]["UnAllocationIdItem"];
for (auto valueUnAllocationIdUnAllocationIdItem : allUnAllocationIdNode)
{
UnAllocationIdItem unAllocationIdObject;
if(!valueUnAllocationIdUnAllocationIdItem["InstanceId"].isNull())
unAllocationIdObject.instanceId = valueUnAllocationIdUnAllocationIdItem["InstanceId"].asString();
if(!valueUnAllocationIdUnAllocationIdItem["EnsRegionId"].isNull())
unAllocationIdObject.ensRegionId = valueUnAllocationIdUnAllocationIdItem["EnsRegionId"].asString();
unAllocationId_.push_back(unAllocationIdObject);
}
if(!value["BizStatusCode"].isNull())
bizStatusCode_ = value["BizStatusCode"].asString();
}
std::string CreateStorageGatewayResult::getBizStatusCode()const
{
return bizStatusCode_;
}
std::vector<CreateStorageGatewayResult::AllocationIdItem> CreateStorageGatewayResult::getAllocationId()const
{
return allocationId_;
}
std::vector<CreateStorageGatewayResult::UnAllocationIdItem> CreateStorageGatewayResult::getUnAllocationId()const
{
return unAllocationId_;
}

117
ens/src/model/CreateStorageVolumeRequest.cc Normal file
View File

@@ -0,0 +1,117 @@
/*
* 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/ens/model/CreateStorageVolumeRequest.h>
using AlibabaCloud::Ens::Model::CreateStorageVolumeRequest;
CreateStorageVolumeRequest::CreateStorageVolumeRequest()
: RpcServiceRequest("ens", "2017-11-10", "CreateStorageVolume") {
setMethod(HttpRequest::Method::Post);
}
CreateStorageVolumeRequest::~CreateStorageVolumeRequest() {}
std::string CreateStorageVolumeRequest::getEnsRegionId() const {
return ensRegionId_;
}
void CreateStorageVolumeRequest::setEnsRegionId(const std::string &ensRegionId) {
ensRegionId_ = ensRegionId;
setParameter(std::string("EnsRegionId"), ensRegionId);
}
std::string CreateStorageVolumeRequest::getGatewayId() const {
return gatewayId_;
}
void CreateStorageVolumeRequest::setGatewayId(const std::string &gatewayId) {
gatewayId_ = gatewayId;
setParameter(std::string("GatewayId"), gatewayId);
}
std::string CreateStorageVolumeRequest::getAuthUser() const {
return authUser_;
}
void CreateStorageVolumeRequest::setAuthUser(const std::string &authUser) {
authUser_ = authUser;
setParameter(std::string("AuthUser"), authUser);
}
std::string CreateStorageVolumeRequest::getVolumeName() const {
return volumeName_;
}
void CreateStorageVolumeRequest::setVolumeName(const std::string &volumeName) {
volumeName_ = volumeName;
setParameter(std::string("VolumeName"), volumeName);
}
std::string CreateStorageVolumeRequest::getAuthPassword() const {
return authPassword_;
}
void CreateStorageVolumeRequest::setAuthPassword(const std::string &authPassword) {
authPassword_ = authPassword;
setParameter(std::string("AuthPassword"), authPassword);
}
std::string CreateStorageVolumeRequest::getAuthProtocol() const {
return authProtocol_;
}
void CreateStorageVolumeRequest::setAuthProtocol(const std::string &authProtocol) {
authProtocol_ = authProtocol;
setParameter(std::string("AuthProtocol"), authProtocol);
}
std::string CreateStorageVolumeRequest::getDescription() const {
return description_;
}
void CreateStorageVolumeRequest::setDescription(const std::string &description) {
description_ = description;
setParameter(std::string("Description"), description);
}
std::string CreateStorageVolumeRequest::getIsEnable() const {
return isEnable_;
}
void CreateStorageVolumeRequest::setIsEnable(const std::string &isEnable) {
isEnable_ = isEnable;
setParameter(std::string("IsEnable"), isEnable);
}
std::string CreateStorageVolumeRequest::getIsAuth() const {
return isAuth_;
}
void CreateStorageVolumeRequest::setIsAuth(const std::string &isAuth) {
isAuth_ = isAuth;
setParameter(std::string("IsAuth"), isAuth);
}
std::string CreateStorageVolumeRequest::getStorageId() const {
return storageId_;
}
void CreateStorageVolumeRequest::setStorageId(const std::string &storageId) {
storageId_ = storageId;
setParameter(std::string("StorageId"), storageId);
}

52
ens/src/model/CreateStorageVolumeResult.cc Normal file
View File

@@ -0,0 +1,52 @@
/*
* 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/ens/model/CreateStorageVolumeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ens;
using namespace AlibabaCloud::Ens::Model;
CreateStorageVolumeResult::CreateStorageVolumeResult() :
ServiceResult()
{}
CreateStorageVolumeResult::CreateStorageVolumeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateStorageVolumeResult::~CreateStorageVolumeResult()
{}
void CreateStorageVolumeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allVolumeId = value["VolumeId"]["VolumeId"];
for (const auto &item : allVolumeId)
volumeId_.push_back(item.asString());
}
std::vector<std::string> CreateStorageVolumeResult::getVolumeId()const
{
return volumeId_;
}

36
ens/src/model/DeleteStorageGatewayRequest.cc Normal file
View File

@@ -0,0 +1,36 @@
/*
* 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/ens/model/DeleteStorageGatewayRequest.h>
using AlibabaCloud::Ens::Model::DeleteStorageGatewayRequest;
DeleteStorageGatewayRequest::DeleteStorageGatewayRequest()
: RpcServiceRequest("ens", "2017-11-10", "DeleteStorageGateway") {
setMethod(HttpRequest::Method::Post);
}
DeleteStorageGatewayRequest::~DeleteStorageGatewayRequest() {}
std::string DeleteStorageGatewayRequest::getGatewayId() const {
return gatewayId_;
}
void DeleteStorageGatewayRequest::setGatewayId(const std::string &gatewayId) {
gatewayId_ = gatewayId;
setParameter(std::string("GatewayId"), gatewayId);
}

44
ens/src/model/DeleteStorageGatewayResult.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/ens/model/DeleteStorageGatewayResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ens;
using namespace AlibabaCloud::Ens::Model;
DeleteStorageGatewayResult::DeleteStorageGatewayResult() :
ServiceResult()
{}
DeleteStorageGatewayResult::DeleteStorageGatewayResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteStorageGatewayResult::~DeleteStorageGatewayResult()
{}
void DeleteStorageGatewayResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

36
ens/src/model/DeleteStorageVolumeRequest.cc Normal file
View File

@@ -0,0 +1,36 @@
/*
* 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/ens/model/DeleteStorageVolumeRequest.h>
using AlibabaCloud::Ens::Model::DeleteStorageVolumeRequest;
DeleteStorageVolumeRequest::DeleteStorageVolumeRequest()
: RpcServiceRequest("ens", "2017-11-10", "DeleteStorageVolume") {
setMethod(HttpRequest::Method::Post);
}
DeleteStorageVolumeRequest::~DeleteStorageVolumeRequest() {}
std::string DeleteStorageVolumeRequest::getVolumeId() const {
return volumeId_;
}
void DeleteStorageVolumeRequest::setVolumeId(const std::string &volumeId) {
volumeId_ = volumeId;
setParameter(std::string("VolumeId"), volumeId);
}

44
ens/src/model/DeleteStorageVolumeResult.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/ens/model/DeleteStorageVolumeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ens;
using namespace AlibabaCloud::Ens::Model;
DeleteStorageVolumeResult::DeleteStorageVolumeResult() :
ServiceResult()
{}
DeleteStorageVolumeResult::DeleteStorageVolumeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteStorageVolumeResult::~DeleteStorageVolumeResult()
{}
void DeleteStorageVolumeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

4
ens/src/model/DescribeInstancesResult.cc
View File

@@ -105,6 +105,10 @@ void DescribeInstancesResult::parse(const std::string &payload)
dataDiskObject.name = valueInstancesInstanceDataDiskDataDiskItem["name"].asString();
if(!valueInstancesInstanceDataDiskDataDiskItem["DiskSize"].isNull())
dataDiskObject.diskSize = std::stoi(valueInstancesInstanceDataDiskDataDiskItem["DiskSize"].asString());
if(!valueInstancesInstanceDataDiskDataDiskItem["EncryptKeyId"].isNull())
dataDiskObject.encryptKeyId = valueInstancesInstanceDataDiskDataDiskItem["EncryptKeyId"].asString();
if(!valueInstancesInstanceDataDiskDataDiskItem["Encrypted"].isNull())
dataDiskObject.encrypted = valueInstancesInstanceDataDiskDataDiskItem["Encrypted"].asString() == "true";
instancesObject.dataDisk.push_back(dataDiskObject);
}
auto allPublicIpAddressesNode = valueInstancesInstance["PublicIpAddresses"]["PublicIpAddress"];

7
ens/src/model/DescribeLoadBalancerHTTPListenerAttributeResult.cc
View File

@@ -89,6 +89,8 @@ void DescribeLoadBalancerHTTPListenerAttributeResult::parse(const std::string &p
healthCheckMethod_ = value["HealthCheckMethod"].asString();
if(!value["XForwardedFor"].isNull())
xForwardedFor_ = value["XForwardedFor"].asString();
if(!value["BackendServerPort"].isNull())
backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
}
@@ -127,6 +129,11 @@ int DescribeLoadBalancerHTTPListenerAttributeResult::getIdleTimeout()const
return idleTimeout_;
}
int DescribeLoadBalancerHTTPListenerAttributeResult::getBackendServerPort()const
{
return backendServerPort_;
}
int DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckConnectPort()const
{
return healthCheckConnectPort_;

111
ens/src/model/DescribeLoadBalancerHTTPSListenerAttributeResult.cc
View File

@@ -87,39 +87,16 @@ void DescribeLoadBalancerHTTPSListenerAttributeResult::parse(const std::string &
serverCertificateId_ = value["ServerCertificateId"].asString();
if(!value["HealthCheckMethod"].isNull())
healthCheckMethod_ = value["HealthCheckMethod"].asString();
if(!value["BackendServerPort"].isNull())
backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStatus()const
{
return status_;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getCookieTimeout()const
{
return cookieTimeout_;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getCookie()const
{
return cookie_;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getListenerPort()const
{
return listenerPort_;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getRequestTimeout()const
{
return requestTimeout_;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckInterval()const
{
return healthCheckInterval_;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getDescription()const
{
return description_;
@@ -150,19 +127,9 @@ int DescribeLoadBalancerHTTPSListenerAttributeResult::getIdleTimeout()const
return idleTimeout_;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckTimeout()const
int DescribeLoadBalancerHTTPSListenerAttributeResult::getBackendServerPort()const
{
return healthCheckTimeout_;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getListenerForward()const
{
return listenerForward_;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStickySession()const
{
return stickySession_;
return backendServerPort_;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckConnectPort()const
@@ -170,11 +137,6 @@ int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckConnectPort(
return healthCheckConnectPort_;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getForwardPort()const
{
return forwardPort_;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckMethod()const
{
return healthCheckMethod_;
@@ -185,16 +147,6 @@ int DescribeLoadBalancerHTTPSListenerAttributeResult::getBandwidth()const
return bandwidth_;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthyThreshold()const
{
return healthyThreshold_;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckDomain()const
{
return healthCheckDomain_;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getServerCertificateId()const
{
return serverCertificateId_;
@@ -210,3 +162,58 @@ std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckHttp
return healthCheckHttpCode_;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStatus()const
{
return status_;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getCookie()const
{
return cookie_;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getListenerPort()const
{
return listenerPort_;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getRequestTimeout()const
{
return requestTimeout_;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckInterval()const
{
return healthCheckInterval_;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckTimeout()const
{
return healthCheckTimeout_;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getListenerForward()const
{
return listenerForward_;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStickySession()const
{
return stickySession_;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getForwardPort()const
{
return forwardPort_;
}
int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthyThreshold()const
{
return healthyThreshold_;
}
std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckDomain()const
{
return healthCheckDomain_;
}

7
ens/src/model/DescribeLoadBalancerUDPListenerAttributeResult.cc
View File

@@ -69,6 +69,8 @@ void DescribeLoadBalancerUDPListenerAttributeResult::parse(const std::string &pa
healthCheckExp_ = value["HealthCheckExp"].asString();
if(!value["EipTransmit"].isNull())
eipTransmit_ = value["EipTransmit"].asString();
if(!value["EstablishedTimeout"].isNull())
establishedTimeout_ = std::stoi(value["EstablishedTimeout"].asString());
}
@@ -147,3 +149,8 @@ std::string DescribeLoadBalancerUDPListenerAttributeResult::getEipTransmit()cons
return eipTransmit_;
}
int DescribeLoadBalancerUDPListenerAttributeResult::getEstablishedTimeout()const
{
return establishedTimeout_;
}

54
ens/src/model/DescribeSDGDeploymentStatusRequest.cc
View File

@@ -20,18 +20,58 @@ using AlibabaCloud::Ens::Model::DescribeSDGDeploymentStatusRequest;
DescribeSDGDeploymentStatusRequest::DescribeSDGDeploymentStatusRequest()
: RpcServiceRequest("ens", "2017-11-10", "DescribeSDGDeploymentStatus") {
setMethod(HttpRequest::Method::Get);
setMethod(HttpRequest::Method::Post);
}
DescribeSDGDeploymentStatusRequest::~DescribeSDGDeploymentStatusRequest() {}
std::string DescribeSDGDeploymentStatusRequest::getPageNumber() const {
std::vector<DescribeSDGDeploymentStatusRequest::std::string> DescribeSDGDeploymentStatusRequest::getRegionIds() const {
return regionIds_;
}
void DescribeSDGDeploymentStatusRequest::setRegionIds(const std::vector<DescribeSDGDeploymentStatusRequest::std::string> &regionIds) {
regionIds_ = regionIds;
for(int dep1 = 0; dep1 != regionIds.size(); dep1++) {
setParameter(std::string("RegionIds") + "." + std::to_string(dep1 + 1), regionIds[dep1]);
}
}
std::vector<DescribeSDGDeploymentStatusRequest::std::string> DescribeSDGDeploymentStatusRequest::getInstanceIds() const {
return instanceIds_;
}
void DescribeSDGDeploymentStatusRequest::setInstanceIds(const std::vector<DescribeSDGDeploymentStatusRequest::std::string> &instanceIds) {
instanceIds_ = instanceIds;
for(int dep1 = 0; dep1 != instanceIds.size(); dep1++) {
setParameter(std::string("InstanceIds") + "." + std::to_string(dep1 + 1), instanceIds[dep1]);
}
}
std::string DescribeSDGDeploymentStatusRequest::getStatus() const {
return status_;
}
void DescribeSDGDeploymentStatusRequest::setStatus(const std::string &status) {
status_ = status;
setParameter(std::string("Status"), status);
}
std::string DescribeSDGDeploymentStatusRequest::getDeploymentType() const {
return deploymentType_;
}
void DescribeSDGDeploymentStatusRequest::setDeploymentType(const std::string &deploymentType) {
deploymentType_ = deploymentType;
setParameter(std::string("DeploymentType"), deploymentType);
}
int DescribeSDGDeploymentStatusRequest::getPageNumber() const {
return pageNumber_;
}
void DescribeSDGDeploymentStatusRequest::setPageNumber(const std::string &pageNumber) {
void DescribeSDGDeploymentStatusRequest::setPageNumber(int pageNumber) {
pageNumber_ = pageNumber;
setParameter(std::string("PageNumber"), pageNumber);
setParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
std::string DescribeSDGDeploymentStatusRequest::getSDGId() const {
@@ -43,12 +83,12 @@ void DescribeSDGDeploymentStatusRequest::setSDGId(const std::string &sDGId) {
setParameter(std::string("SDGId"), sDGId);
}
std::string DescribeSDGDeploymentStatusRequest::getPageSize() const {
int DescribeSDGDeploymentStatusRequest::getPageSize() const {
return pageSize_;
}
void DescribeSDGDeploymentStatusRequest::setPageSize(const std::string &pageSize) {
void DescribeSDGDeploymentStatusRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), pageSize);
setParameter(std::string("PageSize"), std::to_string(pageSize));
}

2
ens/src/model/DescribeSelfImagesResult.cc
View File

@@ -67,6 +67,8 @@ void DescribeSelfImagesResult::parse(const std::string &payload)
imagesObject.computeType = valueImagesImage["ComputeType"].asString();
if(!valueImagesImage["SnapshotId"].isNull())
imagesObject.snapshotId = valueImagesImage["SnapshotId"].asString();
if(!valueImagesImage["ImageStorageSize"].isNull())
imagesObject.imageStorageSize = valueImagesImage["ImageStorageSize"].asString();
images_.push_back(imagesObject);
}
if(!value["Code"].isNull())

81
ens/src/model/DescribeStorageGatewayRequest.cc Normal file
View File

@@ -0,0 +1,81 @@
/*
* 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/ens/model/DescribeStorageGatewayRequest.h>
using AlibabaCloud::Ens::Model::DescribeStorageGatewayRequest;
DescribeStorageGatewayRequest::DescribeStorageGatewayRequest()
: RpcServiceRequest("ens", "2017-11-10", "DescribeStorageGateway") {
setMethod(HttpRequest::Method::Post);
}
DescribeStorageGatewayRequest::~DescribeStorageGatewayRequest() {}
std::string DescribeStorageGatewayRequest::getPageNumber() const {
return pageNumber_;
}
void DescribeStorageGatewayRequest::setPageNumber(const std::string &pageNumber) {
pageNumber_ = pageNumber;
setParameter(std::string("PageNumber"), pageNumber);
}
std::string DescribeStorageGatewayRequest::getEnsRegionId() const {
return ensRegionId_;
}
void DescribeStorageGatewayRequest::setEnsRegionId(const std::string &ensRegionId) {
ensRegionId_ = ensRegionId;
setParameter(std::string("EnsRegionId"), ensRegionId);
}
std::string DescribeStorageGatewayRequest::getPageSize() const {
return pageSize_;
}
void DescribeStorageGatewayRequest::setPageSize(const std::string &pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), pageSize);
}
std::string DescribeStorageGatewayRequest::getGatewayId() const {
return gatewayId_;
}
void DescribeStorageGatewayRequest::setGatewayId(const std::string &gatewayId) {
gatewayId_ = gatewayId;
setParameter(std::string("GatewayId"), gatewayId);
}
std::string DescribeStorageGatewayRequest::getGatewayType() const {
return gatewayType_;
}
void DescribeStorageGatewayRequest::setGatewayType(const std::string &gatewayType) {
gatewayType_ = gatewayType;
setParameter(std::string("GatewayType"), gatewayType);
}
std::string DescribeStorageGatewayRequest::getVpcId() const {
return vpcId_;
}
void DescribeStorageGatewayRequest::setVpcId(const std::string &vpcId) {
vpcId_ = vpcId;
setParameter(std::string("VpcId"), vpcId);
}

96
ens/src/model/DescribeStorageGatewayResult.cc Normal file
View File

@@ -0,0 +1,96 @@
/*
* 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/ens/model/DescribeStorageGatewayResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ens;
using namespace AlibabaCloud::Ens::Model;
DescribeStorageGatewayResult::DescribeStorageGatewayResult() :
ServiceResult()
{}
DescribeStorageGatewayResult::DescribeStorageGatewayResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeStorageGatewayResult::~DescribeStorageGatewayResult()
{}
void DescribeStorageGatewayResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allStorageGatewaysNode = value["StorageGateways"]["StorageGatewaysItem"];
for (auto valueStorageGatewaysStorageGatewaysItem : allStorageGatewaysNode)
{
StorageGatewaysItem storageGatewaysObject;
if(!valueStorageGatewaysStorageGatewaysItem["EnsRegionId"].isNull())
storageGatewaysObject.ensRegionId = valueStorageGatewaysStorageGatewaysItem["EnsRegionId"].asString();
if(!valueStorageGatewaysStorageGatewaysItem["StorageGatewayId"].isNull())
storageGatewaysObject.storageGatewayId = valueStorageGatewaysStorageGatewaysItem["StorageGatewayId"].asString();
if(!valueStorageGatewaysStorageGatewaysItem["StorageGatewayName"].isNull())
storageGatewaysObject.storageGatewayName = valueStorageGatewaysStorageGatewaysItem["StorageGatewayName"].asString();
if(!valueStorageGatewaysStorageGatewaysItem["StorageGatewayType"].isNull())
storageGatewaysObject.storageGatewayType = std::stoi(valueStorageGatewaysStorageGatewaysItem["StorageGatewayType"].asString());
if(!valueStorageGatewaysStorageGatewaysItem["ServiceIp"].isNull())
storageGatewaysObject.serviceIp = valueStorageGatewaysStorageGatewaysItem["ServiceIp"].asString();
if(!valueStorageGatewaysStorageGatewaysItem["CreationTime"].isNull())
storageGatewaysObject.creationTime = valueStorageGatewaysStorageGatewaysItem["CreationTime"].asString();
if(!valueStorageGatewaysStorageGatewaysItem["Status"].isNull())
storageGatewaysObject.status = valueStorageGatewaysStorageGatewaysItem["Status"].asString();
if(!valueStorageGatewaysStorageGatewaysItem["Description"].isNull())
storageGatewaysObject.description = valueStorageGatewaysStorageGatewaysItem["Description"].asString();
if(!valueStorageGatewaysStorageGatewaysItem["VpcId"].isNull())
storageGatewaysObject.vpcId = valueStorageGatewaysStorageGatewaysItem["VpcId"].asString();
if(!valueStorageGatewaysStorageGatewaysItem["CidrBlock"].isNull())
storageGatewaysObject.cidrBlock = valueStorageGatewaysStorageGatewaysItem["CidrBlock"].asString();
storageGateways_.push_back(storageGatewaysObject);
}
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
}
std::vector<DescribeStorageGatewayResult::StorageGatewaysItem> DescribeStorageGatewayResult::getStorageGateways()const
{
return storageGateways_;
}
int DescribeStorageGatewayResult::getTotalCount()const
{
return totalCount_;
}
int DescribeStorageGatewayResult::getPageSize()const
{
return pageSize_;
}
int DescribeStorageGatewayResult::getPageNumber()const
{
return pageNumber_;
}

90
ens/src/model/DescribeStorageVolumeRequest.cc Normal file
View File

@@ -0,0 +1,90 @@
/*
* 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/ens/model/DescribeStorageVolumeRequest.h>
using AlibabaCloud::Ens::Model::DescribeStorageVolumeRequest;
DescribeStorageVolumeRequest::DescribeStorageVolumeRequest()
: RpcServiceRequest("ens", "2017-11-10", "DescribeStorageVolume") {
setMethod(HttpRequest::Method::Post);
}
DescribeStorageVolumeRequest::~DescribeStorageVolumeRequest() {}
std::string DescribeStorageVolumeRequest::getEnsRegionId() const {
return ensRegionId_;
}
void DescribeStorageVolumeRequest::setEnsRegionId(const std::string &ensRegionId) {
ensRegionId_ = ensRegionId;
setParameter(std::string("EnsRegionId"), ensRegionId);
}
std::string DescribeStorageVolumeRequest::getGatewayId() const {
return gatewayId_;
}
void DescribeStorageVolumeRequest::setGatewayId(const std::string &gatewayId) {
gatewayId_ = gatewayId;
setParameter(std::string("GatewayId"), gatewayId);
}
std::string DescribeStorageVolumeRequest::getVolumeId() const {
return volumeId_;
}
void DescribeStorageVolumeRequest::setVolumeId(const std::string &volumeId) {
volumeId_ = volumeId;
setParameter(std::string("VolumeId"), volumeId);
}
int DescribeStorageVolumeRequest::getPageNumber() const {
return pageNumber_;
}
void DescribeStorageVolumeRequest::setPageNumber(int pageNumber) {
pageNumber_ = pageNumber;
setParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
int DescribeStorageVolumeRequest::getPageSize() const {
return pageSize_;
}
void DescribeStorageVolumeRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), std::to_string(pageSize));
}
int DescribeStorageVolumeRequest::getIsEnable() const {
return isEnable_;
}
void DescribeStorageVolumeRequest::setIsEnable(int isEnable) {
isEnable_ = isEnable;
setParameter(std::string("IsEnable"), std::to_string(isEnable));
}
std::string DescribeStorageVolumeRequest::getStorageId() const {
return storageId_;
}
void DescribeStorageVolumeRequest::setStorageId(const std::string &storageId) {
storageId_ = storageId;
setParameter(std::string("StorageId"), storageId);
}

100
ens/src/model/DescribeStorageVolumeResult.cc Normal file
View File

@@ -0,0 +1,100 @@
/*
* 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/ens/model/DescribeStorageVolumeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ens;
using namespace AlibabaCloud::Ens::Model;
DescribeStorageVolumeResult::DescribeStorageVolumeResult() :
ServiceResult()
{}
DescribeStorageVolumeResult::DescribeStorageVolumeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeStorageVolumeResult::~DescribeStorageVolumeResult()
{}
void DescribeStorageVolumeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allStorageVolumesNode = value["StorageVolumes"]["StorageVolumesItem"];
for (auto valueStorageVolumesStorageVolumesItem : allStorageVolumesNode)
{
StorageVolumesItem storageVolumesObject;
if(!valueStorageVolumesStorageVolumesItem["StorageVolumeId"].isNull())
storageVolumesObject.storageVolumeId = valueStorageVolumesStorageVolumesItem["StorageVolumeId"].asString();
if(!valueStorageVolumesStorageVolumesItem["StorageVolumeName"].isNull())
storageVolumesObject.storageVolumeName = valueStorageVolumesStorageVolumesItem["StorageVolumeName"].asString();
if(!valueStorageVolumesStorageVolumesItem["StorageGatewayId"].isNull())
storageVolumesObject.storageGatewayId = valueStorageVolumesStorageVolumesItem["StorageGatewayId"].asString();
if(!valueStorageVolumesStorageVolumesItem["StorageId"].isNull())
storageVolumesObject.storageId = valueStorageVolumesStorageVolumesItem["StorageId"].asString();
if(!valueStorageVolumesStorageVolumesItem["CreationTime"].isNull())
storageVolumesObject.creationTime = valueStorageVolumesStorageVolumesItem["CreationTime"].asString();
if(!valueStorageVolumesStorageVolumesItem["IsEnable"].isNull())
storageVolumesObject.isEnable = std::stoi(valueStorageVolumesStorageVolumesItem["IsEnable"].asString());
if(!valueStorageVolumesStorageVolumesItem["IsAuth"].isNull())
storageVolumesObject.isAuth = std::stoi(valueStorageVolumesStorageVolumesItem["IsAuth"].asString());
if(!valueStorageVolumesStorageVolumesItem["Description"].isNull())
storageVolumesObject.description = valueStorageVolumesStorageVolumesItem["Description"].asString();
if(!valueStorageVolumesStorageVolumesItem["TargetName"].isNull())
storageVolumesObject.targetName = valueStorageVolumesStorageVolumesItem["TargetName"].asString();
if(!valueStorageVolumesStorageVolumesItem["Status"].isNull())
storageVolumesObject.status = valueStorageVolumesStorageVolumesItem["Status"].asString();
if(!valueStorageVolumesStorageVolumesItem["AuthProtocol"].isNull())
storageVolumesObject.authProtocol = valueStorageVolumesStorageVolumesItem["AuthProtocol"].asString();
if(!valueStorageVolumesStorageVolumesItem["EnsRegionId"].isNull())
storageVolumesObject.ensRegionId = valueStorageVolumesStorageVolumesItem["EnsRegionId"].asString();
storageVolumes_.push_back(storageVolumesObject);
}
if(!value["PageNumber"].isNull())
pageNumber_ = value["PageNumber"].asString();
if(!value["PageSize"].isNull())
pageSize_ = value["PageSize"].asString();
if(!value["TotalCount"].isNull())
totalCount_ = value["TotalCount"].asString();
}
std::string DescribeStorageVolumeResult::getTotalCount()const
{
return totalCount_;
}
std::string DescribeStorageVolumeResult::getPageSize()const
{
return pageSize_;
}
std::string DescribeStorageVolumeResult::getPageNumber()const
{
return pageNumber_;
}
std::vector<DescribeStorageVolumeResult::StorageVolumesItem> DescribeStorageVolumeResult::getStorageVolumes()const
{
return storageVolumes_;
}

90
ens/src/model/PrepareUploadRequest.cc Normal file
View File

@@ -0,0 +1,90 @@
/*
* 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/ens/model/PrepareUploadRequest.h>
using AlibabaCloud::Ens::Model::PrepareUploadRequest;
PrepareUploadRequest::PrepareUploadRequest()
: RpcServiceRequest("ens", "2017-11-10", "PrepareUpload") {
setMethod(HttpRequest::Method::Post);
}
PrepareUploadRequest::~PrepareUploadRequest() {}
std::string PrepareUploadRequest::getClientIp() const {
return clientIp_;
}
void PrepareUploadRequest::setClientIp(const std::string &clientIp) {
clientIp_ = clientIp;
setParameter(std::string("ClientIp"), clientIp);
}
std::string PrepareUploadRequest::getEnsRegionId() const {
return ensRegionId_;
}
void PrepareUploadRequest::setEnsRegionId(const std::string &ensRegionId) {
ensRegionId_ = ensRegionId;
setParameter(std::string("EnsRegionId"), ensRegionId);
}
std::string PrepareUploadRequest::getAdditionType() const {
return additionType_;
}
void PrepareUploadRequest::setAdditionType(const std::string &additionType) {
additionType_ = additionType;
setParameter(std::string("AdditionType"), additionType);
}
std::string PrepareUploadRequest::getBucketName() const {
return bucketName_;
}
void PrepareUploadRequest::setBucketName(const std::string &bucketName) {
bucketName_ = bucketName;
setParameter(std::string("BucketName"), bucketName);
}
std::string PrepareUploadRequest::getStation() const {
return station_;
}
void PrepareUploadRequest::setStation(const std::string &station) {
station_ = station;
setParameter(std::string("Station"), station);
}
std::string PrepareUploadRequest::getObjectKey() const {
return objectKey_;
}
void PrepareUploadRequest::setObjectKey(const std::string &objectKey) {
objectKey_ = objectKey;
setParameter(std::string("ObjectKey"), objectKey);
}
long PrepareUploadRequest::getStorageCost() const {
return storageCost_;
}
void PrepareUploadRequest::setStorageCost(long storageCost) {
storageCost_ = storageCost;
setParameter(std::string("StorageCost"), std::to_string(storageCost));
}

65
ens/src/model/PrepareUploadResult.cc Normal file
View File

@@ -0,0 +1,65 @@
/*
* 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/ens/model/PrepareUploadResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ens;
using namespace AlibabaCloud::Ens::Model;
PrepareUploadResult::PrepareUploadResult() :
ServiceResult()
{}
PrepareUploadResult::PrepareUploadResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
PrepareUploadResult::~PrepareUploadResult()
{}
void PrepareUploadResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["BucketName"].isNull())
bucketName_ = value["BucketName"].asString();
if(!value["Endpoint"].isNull())
endpoint_ = value["Endpoint"].asString();
if(!value["AdditionInfo"].isNull())
additionInfo_ = value["AdditionInfo"].asString();
}
std::string PrepareUploadResult::getBucketName()const
{
return bucketName_;
}
std::string PrepareUploadResult::getEndpoint()const
{
return endpoint_;
}
std::string PrepareUploadResult::getAdditionInfo()const
{
return additionInfo_;
}

7
ens/src/model/PutBucketLifecycleResult.cc
View File

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

9
ens/src/model/SetLoadBalancerUDPListenerAttributeRequest.cc
View File

@@ -34,6 +34,15 @@ void SetLoadBalancerUDPListenerAttributeRequest::setProtocol(const std::string &
setParameter(std::string("Protocol"), protocol);
}
int SetLoadBalancerUDPListenerAttributeRequest::getEstablishedTimeout() const {
return establishedTimeout_;
}
void SetLoadBalancerUDPListenerAttributeRequest::setEstablishedTimeout(int establishedTimeout) {
establishedTimeout_ = establishedTimeout;
setParameter(std::string("EstablishedTimeout"), std::to_string(establishedTimeout));
}
std::string SetLoadBalancerUDPListenerAttributeRequest::getLoadBalancerId() const {
return loadBalancerId_;
}