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

Update Open API.

Browse Source
This commit is contained in:
sdk-team
2021-01-25 02:08:21 +00:00
parent 32dccef2ae
commit eaa6b3cb18
46 changed files with 130 additions and 3034 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -1,3 +1,6 @@
2021-01-25 Version: patch
- Update Open API.
2021-01-21 Version: patch
- Modify some field types.

36
rds/CMakeLists.txt
View File

@@ -65,12 +65,6 @@ set(rds_public_header_model
include/alibabacloud/rds/model/CreateDdrInstanceResult.h
include/alibabacloud/rds/model/CreateDedicatedHostRequest.h
include/alibabacloud/rds/model/CreateDedicatedHostResult.h
include/alibabacloud/rds/model/CreateDedicatedHostAccountRequest.h
include/alibabacloud/rds/model/CreateDedicatedHostAccountResult.h
include/alibabacloud/rds/model/CreateDedicatedHostGroupRequest.h
include/alibabacloud/rds/model/CreateDedicatedHostGroupResult.h
include/alibabacloud/rds/model/CreateDedicatedHostUserRequest.h
include/alibabacloud/rds/model/CreateDedicatedHostUserResult.h
include/alibabacloud/rds/model/CreateDiagnosticReportRequest.h
include/alibabacloud/rds/model/CreateDiagnosticReportResult.h
include/alibabacloud/rds/model/CreateHostAccountRequest.h
@@ -99,10 +93,6 @@ set(rds_public_header_model
include/alibabacloud/rds/model/DeleteDBProxyEndpointAddressResult.h
include/alibabacloud/rds/model/DeleteDatabaseRequest.h
include/alibabacloud/rds/model/DeleteDatabaseResult.h
include/alibabacloud/rds/model/DeleteDedicatedHostAccountRequest.h
include/alibabacloud/rds/model/DeleteDedicatedHostAccountResult.h
include/alibabacloud/rds/model/DeleteDedicatedHostGroupRequest.h
include/alibabacloud/rds/model/DeleteDedicatedHostGroupResult.h
include/alibabacloud/rds/model/DeleteHostAccountRequest.h
include/alibabacloud/rds/model/DeleteHostAccountResult.h
include/alibabacloud/rds/model/DeleteParameterGroupRequest.h
@@ -119,8 +109,6 @@ set(rds_public_header_model
include/alibabacloud/rds/model/DescribeAvailableCrossRegionResult.h
include/alibabacloud/rds/model/DescribeAvailableDedicatedHostClassesRequest.h
include/alibabacloud/rds/model/DescribeAvailableDedicatedHostClassesResult.h
include/alibabacloud/rds/model/DescribeAvailableDedicatedHostZonesRequest.h
include/alibabacloud/rds/model/DescribeAvailableDedicatedHostZonesResult.h
include/alibabacloud/rds/model/DescribeAvailableRecoveryTimeRequest.h
include/alibabacloud/rds/model/DescribeAvailableRecoveryTimeResult.h
include/alibabacloud/rds/model/DescribeAvailableResourceRequest.h
@@ -283,10 +271,6 @@ set(rds_public_header_model
include/alibabacloud/rds/model/DescribeTasksResult.h
include/alibabacloud/rds/model/DestroyDBInstanceRequest.h
include/alibabacloud/rds/model/DestroyDBInstanceResult.h
include/alibabacloud/rds/model/DropDedicatedHostUserRequest.h
include/alibabacloud/rds/model/DropDedicatedHostUserResult.h
include/alibabacloud/rds/model/EvaluateDedicatedHostInstanceResourceRequest.h
include/alibabacloud/rds/model/EvaluateDedicatedHostInstanceResourceResult.h
include/alibabacloud/rds/model/GetDBInstanceTopologyRequest.h
include/alibabacloud/rds/model/GetDBInstanceTopologyResult.h
include/alibabacloud/rds/model/GetDbProxyInstanceSslRequest.h
@@ -369,8 +353,6 @@ set(rds_public_header_model
include/alibabacloud/rds/model/ModifyDedicatedHostAttributeResult.h
include/alibabacloud/rds/model/ModifyDedicatedHostGroupAttributeRequest.h
include/alibabacloud/rds/model/ModifyDedicatedHostGroupAttributeResult.h
include/alibabacloud/rds/model/ModifyDedicatedHostUserRequest.h
include/alibabacloud/rds/model/ModifyDedicatedHostUserResult.h
include/alibabacloud/rds/model/ModifyHASwitchConfigRequest.h
include/alibabacloud/rds/model/ModifyHASwitchConfigResult.h
include/alibabacloud/rds/model/ModifyInstanceAutoRenewalAttributeRequest.h
@@ -510,12 +492,6 @@ set(rds_src
src/model/CreateDdrInstanceResult.cc
src/model/CreateDedicatedHostRequest.cc
src/model/CreateDedicatedHostResult.cc
src/model/CreateDedicatedHostAccountRequest.cc
src/model/CreateDedicatedHostAccountResult.cc
src/model/CreateDedicatedHostGroupRequest.cc
src/model/CreateDedicatedHostGroupResult.cc
src/model/CreateDedicatedHostUserRequest.cc
src/model/CreateDedicatedHostUserResult.cc
src/model/CreateDiagnosticReportRequest.cc
src/model/CreateDiagnosticReportResult.cc
src/model/CreateHostAccountRequest.cc
@@ -544,10 +520,6 @@ set(rds_src
src/model/DeleteDBProxyEndpointAddressResult.cc
src/model/DeleteDatabaseRequest.cc
src/model/DeleteDatabaseResult.cc
src/model/DeleteDedicatedHostAccountRequest.cc
src/model/DeleteDedicatedHostAccountResult.cc
src/model/DeleteDedicatedHostGroupRequest.cc
src/model/DeleteDedicatedHostGroupResult.cc
src/model/DeleteHostAccountRequest.cc
src/model/DeleteHostAccountResult.cc
src/model/DeleteParameterGroupRequest.cc
@@ -564,8 +536,6 @@ set(rds_src
src/model/DescribeAvailableCrossRegionResult.cc
src/model/DescribeAvailableDedicatedHostClassesRequest.cc
src/model/DescribeAvailableDedicatedHostClassesResult.cc
src/model/DescribeAvailableDedicatedHostZonesRequest.cc
src/model/DescribeAvailableDedicatedHostZonesResult.cc
src/model/DescribeAvailableRecoveryTimeRequest.cc
src/model/DescribeAvailableRecoveryTimeResult.cc
src/model/DescribeAvailableResourceRequest.cc
@@ -728,10 +698,6 @@ set(rds_src
src/model/DescribeTasksResult.cc
src/model/DestroyDBInstanceRequest.cc
src/model/DestroyDBInstanceResult.cc
src/model/DropDedicatedHostUserRequest.cc
src/model/DropDedicatedHostUserResult.cc
src/model/EvaluateDedicatedHostInstanceResourceRequest.cc
src/model/EvaluateDedicatedHostInstanceResourceResult.cc
src/model/GetDBInstanceTopologyRequest.cc
src/model/GetDBInstanceTopologyResult.cc
src/model/GetDbProxyInstanceSslRequest.cc
@@ -814,8 +780,6 @@ set(rds_src
src/model/ModifyDedicatedHostAttributeResult.cc
src/model/ModifyDedicatedHostGroupAttributeRequest.cc
src/model/ModifyDedicatedHostGroupAttributeResult.cc
src/model/ModifyDedicatedHostUserRequest.cc
src/model/ModifyDedicatedHostUserResult.cc
src/model/ModifyHASwitchConfigRequest.cc
src/model/ModifyHASwitchConfigResult.cc
src/model/ModifyInstanceAutoRenewalAttributeRequest.cc

72
rds/include/alibabacloud/rds/RdsClient.h
View File

@@ -66,12 +66,6 @@
#include "model/CreateDdrInstanceResult.h"
#include "model/CreateDedicatedHostRequest.h"
#include "model/CreateDedicatedHostResult.h"
#include "model/CreateDedicatedHostAccountRequest.h"
#include "model/CreateDedicatedHostAccountResult.h"
#include "model/CreateDedicatedHostGroupRequest.h"
#include "model/CreateDedicatedHostGroupResult.h"
#include "model/CreateDedicatedHostUserRequest.h"
#include "model/CreateDedicatedHostUserResult.h"
#include "model/CreateDiagnosticReportRequest.h"
#include "model/CreateDiagnosticReportResult.h"
#include "model/CreateHostAccountRequest.h"
@@ -100,10 +94,6 @@
#include "model/DeleteDBProxyEndpointAddressResult.h"
#include "model/DeleteDatabaseRequest.h"
#include "model/DeleteDatabaseResult.h"
#include "model/DeleteDedicatedHostAccountRequest.h"
#include "model/DeleteDedicatedHostAccountResult.h"
#include "model/DeleteDedicatedHostGroupRequest.h"
#include "model/DeleteDedicatedHostGroupResult.h"
#include "model/DeleteHostAccountRequest.h"
#include "model/DeleteHostAccountResult.h"
#include "model/DeleteParameterGroupRequest.h"
@@ -120,8 +110,6 @@
#include "model/DescribeAvailableCrossRegionResult.h"
#include "model/DescribeAvailableDedicatedHostClassesRequest.h"
#include "model/DescribeAvailableDedicatedHostClassesResult.h"
#include "model/DescribeAvailableDedicatedHostZonesRequest.h"
#include "model/DescribeAvailableDedicatedHostZonesResult.h"
#include "model/DescribeAvailableRecoveryTimeRequest.h"
#include "model/DescribeAvailableRecoveryTimeResult.h"
#include "model/DescribeAvailableResourceRequest.h"
@@ -284,10 +272,6 @@
#include "model/DescribeTasksResult.h"
#include "model/DestroyDBInstanceRequest.h"
#include "model/DestroyDBInstanceResult.h"
#include "model/DropDedicatedHostUserRequest.h"
#include "model/DropDedicatedHostUserResult.h"
#include "model/EvaluateDedicatedHostInstanceResourceRequest.h"
#include "model/EvaluateDedicatedHostInstanceResourceResult.h"
#include "model/GetDBInstanceTopologyRequest.h"
#include "model/GetDBInstanceTopologyResult.h"
#include "model/GetDbProxyInstanceSslRequest.h"
@@ -370,8 +354,6 @@
#include "model/ModifyDedicatedHostAttributeResult.h"
#include "model/ModifyDedicatedHostGroupAttributeRequest.h"
#include "model/ModifyDedicatedHostGroupAttributeResult.h"
#include "model/ModifyDedicatedHostUserRequest.h"
#include "model/ModifyDedicatedHostUserResult.h"
#include "model/ModifyHASwitchConfigRequest.h"
#include "model/ModifyHASwitchConfigResult.h"
#include "model/ModifyInstanceAutoRenewalAttributeRequest.h"
@@ -539,15 +521,6 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CreateDedicatedHostResult> CreateDedicatedHostOutcome;
typedef std::future<CreateDedicatedHostOutcome> CreateDedicatedHostOutcomeCallable;
typedef std::function<void(const RdsClient*, const Model::CreateDedicatedHostRequest&, const CreateDedicatedHostOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDedicatedHostAsyncHandler;
typedef Outcome<Error, Model::CreateDedicatedHostAccountResult> CreateDedicatedHostAccountOutcome;
typedef std::future<CreateDedicatedHostAccountOutcome> CreateDedicatedHostAccountOutcomeCallable;
typedef std::function<void(const RdsClient*, const Model::CreateDedicatedHostAccountRequest&, const CreateDedicatedHostAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDedicatedHostAccountAsyncHandler;
typedef Outcome<Error, Model::CreateDedicatedHostGroupResult> CreateDedicatedHostGroupOutcome;
typedef std::future<CreateDedicatedHostGroupOutcome> CreateDedicatedHostGroupOutcomeCallable;
typedef std::function<void(const RdsClient*, const Model::CreateDedicatedHostGroupRequest&, const CreateDedicatedHostGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDedicatedHostGroupAsyncHandler;
typedef Outcome<Error, Model::CreateDedicatedHostUserResult> CreateDedicatedHostUserOutcome;
typedef std::future<CreateDedicatedHostUserOutcome> CreateDedicatedHostUserOutcomeCallable;
typedef std::function<void(const RdsClient*, const Model::CreateDedicatedHostUserRequest&, const CreateDedicatedHostUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDedicatedHostUserAsyncHandler;
typedef Outcome<Error, Model::CreateDiagnosticReportResult> CreateDiagnosticReportOutcome;
typedef std::future<CreateDiagnosticReportOutcome> CreateDiagnosticReportOutcomeCallable;
typedef std::function<void(const RdsClient*, const Model::CreateDiagnosticReportRequest&, const CreateDiagnosticReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDiagnosticReportAsyncHandler;
@@ -590,12 +563,6 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DeleteDatabaseResult> DeleteDatabaseOutcome;
typedef std::future<DeleteDatabaseOutcome> DeleteDatabaseOutcomeCallable;
typedef std::function<void(const RdsClient*, const Model::DeleteDatabaseRequest&, const DeleteDatabaseOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDatabaseAsyncHandler;
typedef Outcome<Error, Model::DeleteDedicatedHostAccountResult> DeleteDedicatedHostAccountOutcome;
typedef std::future<DeleteDedicatedHostAccountOutcome> DeleteDedicatedHostAccountOutcomeCallable;
typedef std::function<void(const RdsClient*, const Model::DeleteDedicatedHostAccountRequest&, const DeleteDedicatedHostAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDedicatedHostAccountAsyncHandler;
typedef Outcome<Error, Model::DeleteDedicatedHostGroupResult> DeleteDedicatedHostGroupOutcome;
typedef std::future<DeleteDedicatedHostGroupOutcome> DeleteDedicatedHostGroupOutcomeCallable;
typedef std::function<void(const RdsClient*, const Model::DeleteDedicatedHostGroupRequest&, const DeleteDedicatedHostGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDedicatedHostGroupAsyncHandler;
typedef Outcome<Error, Model::DeleteHostAccountResult> DeleteHostAccountOutcome;
typedef std::future<DeleteHostAccountOutcome> DeleteHostAccountOutcomeCallable;
typedef std::function<void(const RdsClient*, const Model::DeleteHostAccountRequest&, const DeleteHostAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteHostAccountAsyncHandler;
@@ -620,9 +587,6 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeAvailableDedicatedHostClassesResult> DescribeAvailableDedicatedHostClassesOutcome;
typedef std::future<DescribeAvailableDedicatedHostClassesOutcome> DescribeAvailableDedicatedHostClassesOutcomeCallable;
typedef std::function<void(const RdsClient*, const Model::DescribeAvailableDedicatedHostClassesRequest&, const DescribeAvailableDedicatedHostClassesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAvailableDedicatedHostClassesAsyncHandler;
typedef Outcome<Error, Model::DescribeAvailableDedicatedHostZonesResult> DescribeAvailableDedicatedHostZonesOutcome;
typedef std::future<DescribeAvailableDedicatedHostZonesOutcome> DescribeAvailableDedicatedHostZonesOutcomeCallable;
typedef std::function<void(const RdsClient*, const Model::DescribeAvailableDedicatedHostZonesRequest&, const DescribeAvailableDedicatedHostZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAvailableDedicatedHostZonesAsyncHandler;
typedef Outcome<Error, Model::DescribeAvailableRecoveryTimeResult> DescribeAvailableRecoveryTimeOutcome;
typedef std::future<DescribeAvailableRecoveryTimeOutcome> DescribeAvailableRecoveryTimeOutcomeCallable;
typedef std::function<void(const RdsClient*, const Model::DescribeAvailableRecoveryTimeRequest&, const DescribeAvailableRecoveryTimeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAvailableRecoveryTimeAsyncHandler;
@@ -866,12 +830,6 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DestroyDBInstanceResult> DestroyDBInstanceOutcome;
typedef std::future<DestroyDBInstanceOutcome> DestroyDBInstanceOutcomeCallable;
typedef std::function<void(const RdsClient*, const Model::DestroyDBInstanceRequest&, const DestroyDBInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DestroyDBInstanceAsyncHandler;
typedef Outcome<Error, Model::DropDedicatedHostUserResult> DropDedicatedHostUserOutcome;
typedef std::future<DropDedicatedHostUserOutcome> DropDedicatedHostUserOutcomeCallable;
typedef std::function<void(const RdsClient*, const Model::DropDedicatedHostUserRequest&, const DropDedicatedHostUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DropDedicatedHostUserAsyncHandler;
typedef Outcome<Error, Model::EvaluateDedicatedHostInstanceResourceResult> EvaluateDedicatedHostInstanceResourceOutcome;
typedef std::future<EvaluateDedicatedHostInstanceResourceOutcome> EvaluateDedicatedHostInstanceResourceOutcomeCallable;
typedef std::function<void(const RdsClient*, const Model::EvaluateDedicatedHostInstanceResourceRequest&, const EvaluateDedicatedHostInstanceResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EvaluateDedicatedHostInstanceResourceAsyncHandler;
typedef Outcome<Error, Model::GetDBInstanceTopologyResult> GetDBInstanceTopologyOutcome;
typedef std::future<GetDBInstanceTopologyOutcome> GetDBInstanceTopologyOutcomeCallable;
typedef std::function<void(const RdsClient*, const Model::GetDBInstanceTopologyRequest&, const GetDBInstanceTopologyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDBInstanceTopologyAsyncHandler;
@@ -995,9 +953,6 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ModifyDedicatedHostGroupAttributeResult> ModifyDedicatedHostGroupAttributeOutcome;
typedef std::future<ModifyDedicatedHostGroupAttributeOutcome> ModifyDedicatedHostGroupAttributeOutcomeCallable;
typedef std::function<void(const RdsClient*, const Model::ModifyDedicatedHostGroupAttributeRequest&, const ModifyDedicatedHostGroupAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDedicatedHostGroupAttributeAsyncHandler;
typedef Outcome<Error, Model::ModifyDedicatedHostUserResult> ModifyDedicatedHostUserOutcome;
typedef std::future<ModifyDedicatedHostUserOutcome> ModifyDedicatedHostUserOutcomeCallable;
typedef std::function<void(const RdsClient*, const Model::ModifyDedicatedHostUserRequest&, const ModifyDedicatedHostUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDedicatedHostUserAsyncHandler;
typedef Outcome<Error, Model::ModifyHASwitchConfigResult> ModifyHASwitchConfigOutcome;
typedef std::future<ModifyHASwitchConfigOutcome> ModifyHASwitchConfigOutcomeCallable;
typedef std::function<void(const RdsClient*, const Model::ModifyHASwitchConfigRequest&, const ModifyHASwitchConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyHASwitchConfigAsyncHandler;
@@ -1207,15 +1162,6 @@ namespace AlibabaCloud
CreateDedicatedHostOutcome createDedicatedHost(const Model::CreateDedicatedHostRequest &request)const;
void createDedicatedHostAsync(const Model::CreateDedicatedHostRequest& request, const CreateDedicatedHostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDedicatedHostOutcomeCallable createDedicatedHostCallable(const Model::CreateDedicatedHostRequest& request) const;
CreateDedicatedHostAccountOutcome createDedicatedHostAccount(const Model::CreateDedicatedHostAccountRequest &request)const;
void createDedicatedHostAccountAsync(const Model::CreateDedicatedHostAccountRequest& request, const CreateDedicatedHostAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDedicatedHostAccountOutcomeCallable createDedicatedHostAccountCallable(const Model::CreateDedicatedHostAccountRequest& request) const;
CreateDedicatedHostGroupOutcome createDedicatedHostGroup(const Model::CreateDedicatedHostGroupRequest &request)const;
void createDedicatedHostGroupAsync(const Model::CreateDedicatedHostGroupRequest& request, const CreateDedicatedHostGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDedicatedHostGroupOutcomeCallable createDedicatedHostGroupCallable(const Model::CreateDedicatedHostGroupRequest& request) const;
CreateDedicatedHostUserOutcome createDedicatedHostUser(const Model::CreateDedicatedHostUserRequest &request)const;
void createDedicatedHostUserAsync(const Model::CreateDedicatedHostUserRequest& request, const CreateDedicatedHostUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDedicatedHostUserOutcomeCallable createDedicatedHostUserCallable(const Model::CreateDedicatedHostUserRequest& request) const;
CreateDiagnosticReportOutcome createDiagnosticReport(const Model::CreateDiagnosticReportRequest &request)const;
void createDiagnosticReportAsync(const Model::CreateDiagnosticReportRequest& request, const CreateDiagnosticReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDiagnosticReportOutcomeCallable createDiagnosticReportCallable(const Model::CreateDiagnosticReportRequest& request) const;
@@ -1258,12 +1204,6 @@ namespace AlibabaCloud
DeleteDatabaseOutcome deleteDatabase(const Model::DeleteDatabaseRequest &request)const;
void deleteDatabaseAsync(const Model::DeleteDatabaseRequest& request, const DeleteDatabaseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteDatabaseOutcomeCallable deleteDatabaseCallable(const Model::DeleteDatabaseRequest& request) const;
DeleteDedicatedHostAccountOutcome deleteDedicatedHostAccount(const Model::DeleteDedicatedHostAccountRequest &request)const;
void deleteDedicatedHostAccountAsync(const Model::DeleteDedicatedHostAccountRequest& request, const DeleteDedicatedHostAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteDedicatedHostAccountOutcomeCallable deleteDedicatedHostAccountCallable(const Model::DeleteDedicatedHostAccountRequest& request) const;
DeleteDedicatedHostGroupOutcome deleteDedicatedHostGroup(const Model::DeleteDedicatedHostGroupRequest &request)const;
void deleteDedicatedHostGroupAsync(const Model::DeleteDedicatedHostGroupRequest& request, const DeleteDedicatedHostGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteDedicatedHostGroupOutcomeCallable deleteDedicatedHostGroupCallable(const Model::DeleteDedicatedHostGroupRequest& request) const;
DeleteHostAccountOutcome deleteHostAccount(const Model::DeleteHostAccountRequest &request)const;
void deleteHostAccountAsync(const Model::DeleteHostAccountRequest& request, const DeleteHostAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteHostAccountOutcomeCallable deleteHostAccountCallable(const Model::DeleteHostAccountRequest& request) const;
@@ -1288,9 +1228,6 @@ namespace AlibabaCloud
DescribeAvailableDedicatedHostClassesOutcome describeAvailableDedicatedHostClasses(const Model::DescribeAvailableDedicatedHostClassesRequest &request)const;
void describeAvailableDedicatedHostClassesAsync(const Model::DescribeAvailableDedicatedHostClassesRequest& request, const DescribeAvailableDedicatedHostClassesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeAvailableDedicatedHostClassesOutcomeCallable describeAvailableDedicatedHostClassesCallable(const Model::DescribeAvailableDedicatedHostClassesRequest& request) const;
DescribeAvailableDedicatedHostZonesOutcome describeAvailableDedicatedHostZones(const Model::DescribeAvailableDedicatedHostZonesRequest &request)const;
void describeAvailableDedicatedHostZonesAsync(const Model::DescribeAvailableDedicatedHostZonesRequest& request, const DescribeAvailableDedicatedHostZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeAvailableDedicatedHostZonesOutcomeCallable describeAvailableDedicatedHostZonesCallable(const Model::DescribeAvailableDedicatedHostZonesRequest& request) const;
DescribeAvailableRecoveryTimeOutcome describeAvailableRecoveryTime(const Model::DescribeAvailableRecoveryTimeRequest &request)const;
void describeAvailableRecoveryTimeAsync(const Model::DescribeAvailableRecoveryTimeRequest& request, const DescribeAvailableRecoveryTimeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeAvailableRecoveryTimeOutcomeCallable describeAvailableRecoveryTimeCallable(const Model::DescribeAvailableRecoveryTimeRequest& request) const;
@@ -1534,12 +1471,6 @@ namespace AlibabaCloud
DestroyDBInstanceOutcome destroyDBInstance(const Model::DestroyDBInstanceRequest &request)const;
void destroyDBInstanceAsync(const Model::DestroyDBInstanceRequest& request, const DestroyDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DestroyDBInstanceOutcomeCallable destroyDBInstanceCallable(const Model::DestroyDBInstanceRequest& request) const;
DropDedicatedHostUserOutcome dropDedicatedHostUser(const Model::DropDedicatedHostUserRequest &request)const;
void dropDedicatedHostUserAsync(const Model::DropDedicatedHostUserRequest& request, const DropDedicatedHostUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DropDedicatedHostUserOutcomeCallable dropDedicatedHostUserCallable(const Model::DropDedicatedHostUserRequest& request) const;
EvaluateDedicatedHostInstanceResourceOutcome evaluateDedicatedHostInstanceResource(const Model::EvaluateDedicatedHostInstanceResourceRequest &request)const;
void evaluateDedicatedHostInstanceResourceAsync(const Model::EvaluateDedicatedHostInstanceResourceRequest& request, const EvaluateDedicatedHostInstanceResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EvaluateDedicatedHostInstanceResourceOutcomeCallable evaluateDedicatedHostInstanceResourceCallable(const Model::EvaluateDedicatedHostInstanceResourceRequest& request) const;
GetDBInstanceTopologyOutcome getDBInstanceTopology(const Model::GetDBInstanceTopologyRequest &request)const;
void getDBInstanceTopologyAsync(const Model::GetDBInstanceTopologyRequest& request, const GetDBInstanceTopologyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetDBInstanceTopologyOutcomeCallable getDBInstanceTopologyCallable(const Model::GetDBInstanceTopologyRequest& request) const;
@@ -1663,9 +1594,6 @@ namespace AlibabaCloud
ModifyDedicatedHostGroupAttributeOutcome modifyDedicatedHostGroupAttribute(const Model::ModifyDedicatedHostGroupAttributeRequest &request)const;
void modifyDedicatedHostGroupAttributeAsync(const Model::ModifyDedicatedHostGroupAttributeRequest& request, const ModifyDedicatedHostGroupAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDedicatedHostGroupAttributeOutcomeCallable modifyDedicatedHostGroupAttributeCallable(const Model::ModifyDedicatedHostGroupAttributeRequest& request) const;
ModifyDedicatedHostUserOutcome modifyDedicatedHostUser(const Model::ModifyDedicatedHostUserRequest &request)const;
void modifyDedicatedHostUserAsync(const Model::ModifyDedicatedHostUserRequest& request, const ModifyDedicatedHostUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDedicatedHostUserOutcomeCallable modifyDedicatedHostUserCallable(const Model::ModifyDedicatedHostUserRequest& request) const;
ModifyHASwitchConfigOutcome modifyHASwitchConfig(const Model::ModifyHASwitchConfigRequest &request)const;
void modifyHASwitchConfigAsync(const Model::ModifyHASwitchConfigRequest& request, const ModifyHASwitchConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyHASwitchConfigOutcomeCallable modifyHASwitchConfigCallable(const Model::ModifyHASwitchConfigRequest& request) const;

69
rds/include/alibabacloud/rds/model/CreateDedicatedHostAccountRequest.h
View File

@@ -1,69 +0,0 @@
/*
* 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_RDS_MODEL_CREATEDEDICATEDHOSTACCOUNTREQUEST_H_
#define ALIBABACLOUD_RDS_MODEL_CREATEDEDICATEDHOSTACCOUNTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/rds/RdsExport.h>
namespace AlibabaCloud
{
namespace Rds
{
namespace Model
{
class ALIBABACLOUD_RDS_EXPORT CreateDedicatedHostAccountRequest : public RpcServiceRequest
{
public:
CreateDedicatedHostAccountRequest();
~CreateDedicatedHostAccountRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getAccountName()const;
void setAccountName(const std::string& accountName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDedicatedHostId()const;
void setDedicatedHostId(const std::string& dedicatedHostId);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccountPassword()const;
void setAccountPassword(const std::string& accountPassword);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string accountName_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string dedicatedHostId_;
long ownerId_;
std::string accountPassword_;
};
}
}
}
#endif // !ALIBABACLOUD_RDS_MODEL_CREATEDEDICATEDHOSTACCOUNTREQUEST_H_

49
rds/include/alibabacloud/rds/model/CreateDedicatedHostAccountResult.h
View File

@@ -1,49 +0,0 @@
/*
* 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_RDS_MODEL_CREATEDEDICATEDHOSTACCOUNTRESULT_H_
#define ALIBABACLOUD_RDS_MODEL_CREATEDEDICATEDHOSTACCOUNTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/rds/RdsExport.h>
namespace AlibabaCloud
{
namespace Rds
{
namespace Model
{
class ALIBABACLOUD_RDS_EXPORT CreateDedicatedHostAccountResult : public ServiceResult
{
public:
CreateDedicatedHostAccountResult();
explicit CreateDedicatedHostAccountResult(const std::string &payload);
~CreateDedicatedHostAccountResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_RDS_MODEL_CREATEDEDICATEDHOSTACCOUNTRESULT_H_

87
rds/include/alibabacloud/rds/model/CreateDedicatedHostGroupRequest.h
View File

@@ -1,87 +0,0 @@
/*
* 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_RDS_MODEL_CREATEDEDICATEDHOSTGROUPREQUEST_H_
#define ALIBABACLOUD_RDS_MODEL_CREATEDEDICATEDHOSTGROUPREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/rds/RdsExport.h>
namespace AlibabaCloud
{
namespace Rds
{
namespace Model
{
class ALIBABACLOUD_RDS_EXPORT CreateDedicatedHostGroupRequest : public RpcServiceRequest
{
public:
CreateDedicatedHostGroupRequest();
~CreateDedicatedHostGroupRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
int getCpuAllocationRatio()const;
void setCpuAllocationRatio(int cpuAllocationRatio);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getEngine()const;
void setEngine(const std::string& engine);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
int getDiskAllocationRatio()const;
void setDiskAllocationRatio(int diskAllocationRatio);
int getOpenPermission()const;
void setOpenPermission(int openPermission);
int getMemAllocationRatio()const;
void setMemAllocationRatio(int memAllocationRatio);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getHostReplacePolicy()const;
void setHostReplacePolicy(const std::string& hostReplacePolicy);
std::string getAllocationPolicy()const;
void setAllocationPolicy(const std::string& allocationPolicy);
std::string getVPCId()const;
void setVPCId(const std::string& vPCId);
private:
long resourceOwnerId_;
int cpuAllocationRatio_;
std::string clientToken_;
std::string accessKeyId_;
std::string regionId_;
std::string engine_;
std::string resourceOwnerAccount_;
int diskAllocationRatio_;
int openPermission_;
int memAllocationRatio_;
long ownerId_;
std::string hostReplacePolicy_;
std::string allocationPolicy_;
std::string vPCId_;
};
}
}
}
#endif // !ALIBABACLOUD_RDS_MODEL_CREATEDEDICATEDHOSTGROUPREQUEST_H_

51
rds/include/alibabacloud/rds/model/CreateDedicatedHostGroupResult.h
View File

@@ -1,51 +0,0 @@
/*
* 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_RDS_MODEL_CREATEDEDICATEDHOSTGROUPRESULT_H_
#define ALIBABACLOUD_RDS_MODEL_CREATEDEDICATEDHOSTGROUPRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/rds/RdsExport.h>
namespace AlibabaCloud
{
namespace Rds
{
namespace Model
{
class ALIBABACLOUD_RDS_EXPORT CreateDedicatedHostGroupResult : public ServiceResult
{
public:
CreateDedicatedHostGroupResult();
explicit CreateDedicatedHostGroupResult(const std::string &payload);
~CreateDedicatedHostGroupResult();
std::string getDedicatedHostGroupId()const;
protected:
void parse(const std::string &payload);
private:
std::string dedicatedHostGroupId_;
};
}
}
}
#endif // !ALIBABACLOUD_RDS_MODEL_CREATEDEDICATEDHOSTGROUPRESULT_H_

69
rds/include/alibabacloud/rds/model/CreateDedicatedHostUserRequest.h
View File

@@ -1,69 +0,0 @@
/*
* 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_RDS_MODEL_CREATEDEDICATEDHOSTUSERREQUEST_H_
#define ALIBABACLOUD_RDS_MODEL_CREATEDEDICATEDHOSTUSERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/rds/RdsExport.h>
namespace AlibabaCloud
{
namespace Rds
{
namespace Model
{
class ALIBABACLOUD_RDS_EXPORT CreateDedicatedHostUserRequest : public RpcServiceRequest
{
public:
CreateDedicatedHostUserRequest();
~CreateDedicatedHostUserRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getUserPassword()const;
void setUserPassword(const std::string& userPassword);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getDedicatedHostName()const;
void setDedicatedHostName(const std::string& dedicatedHostName);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getUserName()const;
void setUserName(const std::string& userName);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string userPassword_;
std::string regionId_;
std::string dedicatedHostName_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string userName_;
};
}
}
}
#endif // !ALIBABACLOUD_RDS_MODEL_CREATEDEDICATEDHOSTUSERREQUEST_H_

49
rds/include/alibabacloud/rds/model/CreateDedicatedHostUserResult.h
View File

@@ -1,49 +0,0 @@
/*
* 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_RDS_MODEL_CREATEDEDICATEDHOSTUSERRESULT_H_
#define ALIBABACLOUD_RDS_MODEL_CREATEDEDICATEDHOSTUSERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/rds/RdsExport.h>
namespace AlibabaCloud
{
namespace Rds
{
namespace Model
{
class ALIBABACLOUD_RDS_EXPORT CreateDedicatedHostUserResult : public ServiceResult
{
public:
CreateDedicatedHostUserResult();
explicit CreateDedicatedHostUserResult(const std::string &payload);
~CreateDedicatedHostUserResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_RDS_MODEL_CREATEDEDICATEDHOSTUSERRESULT_H_

66
rds/include/alibabacloud/rds/model/DeleteDedicatedHostAccountRequest.h
View File

@@ -1,66 +0,0 @@
/*
* 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_RDS_MODEL_DELETEDEDICATEDHOSTACCOUNTREQUEST_H_
#define ALIBABACLOUD_RDS_MODEL_DELETEDEDICATEDHOSTACCOUNTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/rds/RdsExport.h>
namespace AlibabaCloud
{
namespace Rds
{
namespace Model
{
class ALIBABACLOUD_RDS_EXPORT DeleteDedicatedHostAccountRequest : public RpcServiceRequest
{
public:
DeleteDedicatedHostAccountRequest();
~DeleteDedicatedHostAccountRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDedicatedHostId()const;
void setDedicatedHostId(const std::string& dedicatedHostId);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getAccountName()const;
void setAccountName(const std::string& accountName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string dedicatedHostId_;
long ownerId_;
std::string accessKeyId_;
std::string accountName_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_RDS_MODEL_DELETEDEDICATEDHOSTACCOUNTREQUEST_H_

49
rds/include/alibabacloud/rds/model/DeleteDedicatedHostAccountResult.h
View File

@@ -1,49 +0,0 @@
/*
* 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_RDS_MODEL_DELETEDEDICATEDHOSTACCOUNTRESULT_H_
#define ALIBABACLOUD_RDS_MODEL_DELETEDEDICATEDHOSTACCOUNTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/rds/RdsExport.h>
namespace AlibabaCloud
{
namespace Rds
{
namespace Model
{
class ALIBABACLOUD_RDS_EXPORT DeleteDedicatedHostAccountResult : public ServiceResult
{
public:
DeleteDedicatedHostAccountResult();
explicit DeleteDedicatedHostAccountResult(const std::string &payload);
~DeleteDedicatedHostAccountResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_RDS_MODEL_DELETEDEDICATEDHOSTACCOUNTRESULT_H_

63
rds/include/alibabacloud/rds/model/DeleteDedicatedHostGroupRequest.h
View File

@@ -1,63 +0,0 @@
/*
* 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_RDS_MODEL_DELETEDEDICATEDHOSTGROUPREQUEST_H_
#define ALIBABACLOUD_RDS_MODEL_DELETEDEDICATEDHOSTGROUPREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/rds/RdsExport.h>
namespace AlibabaCloud
{
namespace Rds
{
namespace Model
{
class ALIBABACLOUD_RDS_EXPORT DeleteDedicatedHostGroupRequest : public RpcServiceRequest
{
public:
DeleteDedicatedHostGroupRequest();
~DeleteDedicatedHostGroupRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getDedicatedHostGroupId()const;
void setDedicatedHostGroupId(const std::string& dedicatedHostGroupId);
private:
long resourceOwnerId_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string regionId_;
std::string dedicatedHostGroupId_;
};
}
}
}
#endif // !ALIBABACLOUD_RDS_MODEL_DELETEDEDICATEDHOSTGROUPREQUEST_H_

49
rds/include/alibabacloud/rds/model/DeleteDedicatedHostGroupResult.h
View File

@@ -1,49 +0,0 @@
/*
* 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_RDS_MODEL_DELETEDEDICATEDHOSTGROUPRESULT_H_
#define ALIBABACLOUD_RDS_MODEL_DELETEDEDICATEDHOSTGROUPRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/rds/RdsExport.h>
namespace AlibabaCloud
{
namespace Rds
{
namespace Model
{
class ALIBABACLOUD_RDS_EXPORT DeleteDedicatedHostGroupResult : public ServiceResult
{
public:
DeleteDedicatedHostGroupResult();
explicit DeleteDedicatedHostGroupResult(const std::string &payload);
~DeleteDedicatedHostGroupResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_RDS_MODEL_DELETEDEDICATEDHOSTGROUPRESULT_H_

60
rds/include/alibabacloud/rds/model/DescribeAvailableDedicatedHostZonesRequest.h
View File

@@ -1,60 +0,0 @@
/*
* 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_RDS_MODEL_DESCRIBEAVAILABLEDEDICATEDHOSTZONESREQUEST_H_
#define ALIBABACLOUD_RDS_MODEL_DESCRIBEAVAILABLEDEDICATEDHOSTZONESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/rds/RdsExport.h>
namespace AlibabaCloud
{
namespace Rds
{
namespace Model
{
class ALIBABACLOUD_RDS_EXPORT DescribeAvailableDedicatedHostZonesRequest : public RpcServiceRequest
{
public:
DescribeAvailableDedicatedHostZonesRequest();
~DescribeAvailableDedicatedHostZonesRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
long resourceOwnerId_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_RDS_MODEL_DESCRIBEAVAILABLEDEDICATEDHOSTZONESREQUEST_H_

56
rds/include/alibabacloud/rds/model/DescribeAvailableDedicatedHostZonesResult.h
View File

@@ -1,56 +0,0 @@
/*
* 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_RDS_MODEL_DESCRIBEAVAILABLEDEDICATEDHOSTZONESRESULT_H_
#define ALIBABACLOUD_RDS_MODEL_DESCRIBEAVAILABLEDEDICATEDHOSTZONESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/rds/RdsExport.h>
namespace AlibabaCloud
{
namespace Rds
{
namespace Model
{
class ALIBABACLOUD_RDS_EXPORT DescribeAvailableDedicatedHostZonesResult : public ServiceResult
{
public:
struct DedicatedHostZones
{
std::string description;
std::string zoneId;
};
DescribeAvailableDedicatedHostZonesResult();
explicit DescribeAvailableDedicatedHostZonesResult(const std::string &payload);
~DescribeAvailableDedicatedHostZonesResult();
std::vector<DedicatedHostZones> getZones()const;
protected:
void parse(const std::string &payload);
private:
std::vector<DedicatedHostZones> zones_;
};
}
}
}
#endif // !ALIBABACLOUD_RDS_MODEL_DESCRIBEAVAILABLEDEDICATEDHOSTZONESRESULT_H_

12
rds/include/alibabacloud/rds/model/DescribeDBProxyEndpointResult.h
View File

@@ -32,30 +32,42 @@ namespace AlibabaCloud
class ALIBABACLOUD_RDS_EXPORT DescribeDBProxyEndpointResult : public ServiceResult
{
public:
struct EndpointConnectItemsItem
{
std::string dbProxyEndpointNetType;
std::string dbProxyEndpointPort;
std::string dbProxyEndpointConnectString;
};
DescribeDBProxyEndpointResult();
explicit DescribeDBProxyEndpointResult(const std::string &payload);
~DescribeDBProxyEndpointResult();
std::string getReadOnlyInstanceDistributionType()const;
std::string getDbProxyEndpointReadWriteMode()const;
std::string getDBProxyConnectString()const;
std::string getDBProxyEndpointId()const;
std::string getDbProxyEndpointAliases()const;
std::string getDBProxyFeatures()const;
std::string getReadOnlyInstanceWeight()const;
std::string getReadOnlyInstanceMaxDelayTime()const;
std::string getDBProxyConnectStringNetType()const;
std::vector<EndpointConnectItemsItem> getEndpointConnectItems()const;
std::string getDBProxyConnectStringPort()const;
protected:
void parse(const std::string &payload);
private:
std::string readOnlyInstanceDistributionType_;
std::string dbProxyEndpointReadWriteMode_;
std::string dBProxyConnectString_;
std::string dBProxyEndpointId_;
std::string dbProxyEndpointAliases_;
std::string dBProxyFeatures_;
std::string readOnlyInstanceWeight_;
std::string readOnlyInstanceMaxDelayTime_;
std::string dBProxyConnectStringNetType_;
std::vector<EndpointConnectItemsItem> endpointConnectItems_;
std::string dBProxyConnectStringPort_;
};

9
rds/include/alibabacloud/rds/model/DescribeDBProxyResult.h
View File

@@ -42,6 +42,13 @@ namespace AlibabaCloud
std::string dBProxyConnectStringPort;
std::string dBProxyVpcInstanceId;
};
struct DbProxyEndpointItemsItem
{
std::string dbProxyEndpointName;
std::string dbProxyEndpointAliases;
std::string dbProxyEndpointType;
std::string dbProxyReadWriteMode;
};
DescribeDBProxyResult();
@@ -52,6 +59,7 @@ namespace AlibabaCloud
std::string getDBProxyServiceStatus()const;
int getDBProxyInstanceNum()const;
std::string getDBProxyInstanceLatestMinorVersion()const;
std::vector<DbProxyEndpointItemsItem> getDbProxyEndpointItems()const;
std::vector<DBProxyConnectStringItemsItem> getDBProxyConnectStringItems()const;
std::string getDBProxyInstanceStatus()const;
std::string getDBProxyInstanceType()const;
@@ -64,6 +72,7 @@ namespace AlibabaCloud
std::string dBProxyServiceStatus_;
int dBProxyInstanceNum_;
std::string dBProxyInstanceLatestMinorVersion_;
std::vector<DbProxyEndpointItemsItem> dbProxyEndpointItems_;
std::vector<DBProxyConnectStringItemsItem> dBProxyConnectStringItems_;
std::string dBProxyInstanceStatus_;
std::string dBProxyInstanceType_;

66
rds/include/alibabacloud/rds/model/DropDedicatedHostUserRequest.h
View File

@@ -1,66 +0,0 @@
/*
* 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_RDS_MODEL_DROPDEDICATEDHOSTUSERREQUEST_H_
#define ALIBABACLOUD_RDS_MODEL_DROPDEDICATEDHOSTUSERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/rds/RdsExport.h>
namespace AlibabaCloud
{
namespace Rds
{
namespace Model
{
class ALIBABACLOUD_RDS_EXPORT DropDedicatedHostUserRequest : public RpcServiceRequest
{
public:
DropDedicatedHostUserRequest();
~DropDedicatedHostUserRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getDedicatedHostName()const;
void setDedicatedHostName(const std::string& dedicatedHostName);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getUserName()const;
void setUserName(const std::string& userName);
private:
long resourceOwnerId_;
std::string dedicatedHostName_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string regionId_;
std::string userName_;
};
}
}
}
#endif // !ALIBABACLOUD_RDS_MODEL_DROPDEDICATEDHOSTUSERREQUEST_H_

49
rds/include/alibabacloud/rds/model/DropDedicatedHostUserResult.h
View File

@@ -1,49 +0,0 @@
/*
* 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_RDS_MODEL_DROPDEDICATEDHOSTUSERRESULT_H_
#define ALIBABACLOUD_RDS_MODEL_DROPDEDICATEDHOSTUSERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/rds/RdsExport.h>
namespace AlibabaCloud
{
namespace Rds
{
namespace Model
{
class ALIBABACLOUD_RDS_EXPORT DropDedicatedHostUserResult : public ServiceResult
{
public:
DropDedicatedHostUserResult();
explicit DropDedicatedHostUserResult(const std::string &payload);
~DropDedicatedHostUserResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_RDS_MODEL_DROPDEDICATEDHOSTUSERRESULT_H_

78
rds/include/alibabacloud/rds/model/EvaluateDedicatedHostInstanceResourceRequest.h
View File

@@ -1,78 +0,0 @@
/*
* 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_RDS_MODEL_EVALUATEDEDICATEDHOSTINSTANCERESOURCEREQUEST_H_
#define ALIBABACLOUD_RDS_MODEL_EVALUATEDEDICATEDHOSTINSTANCERESOURCEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/rds/RdsExport.h>
namespace AlibabaCloud
{
namespace Rds
{
namespace Model
{
class ALIBABACLOUD_RDS_EXPORT EvaluateDedicatedHostInstanceResourceRequest : public RpcServiceRequest
{
public:
EvaluateDedicatedHostInstanceResourceRequest();
~EvaluateDedicatedHostInstanceResourceRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getEngineVersion()const;
void setEngineVersion(const std::string& engineVersion);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getEngine()const;
void setEngine(const std::string& engine);
std::string getDedicatedHostGroupId()const;
void setDedicatedHostGroupId(const std::string& dedicatedHostGroupId);
std::string getInstanceClassNames()const;
void setInstanceClassNames(const std::string& instanceClassNames);
std::string getDiskSize()const;
void setDiskSize(const std::string& diskSize);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getDiskType()const;
void setDiskType(const std::string& diskType);
private:
long resourceOwnerId_;
std::string engineVersion_;
std::string accessKeyId_;
std::string regionId_;
std::string engine_;
std::string dedicatedHostGroupId_;
std::string instanceClassNames_;
std::string diskSize_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string diskType_;
};
}
}
}
#endif // !ALIBABACLOUD_RDS_MODEL_EVALUATEDEDICATEDHOSTINSTANCERESOURCEREQUEST_H_

53
rds/include/alibabacloud/rds/model/EvaluateDedicatedHostInstanceResourceResult.h
View File

@@ -1,53 +0,0 @@
/*
* 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_RDS_MODEL_EVALUATEDEDICATEDHOSTINSTANCERESOURCERESULT_H_
#define ALIBABACLOUD_RDS_MODEL_EVALUATEDEDICATEDHOSTINSTANCERESOURCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/rds/RdsExport.h>
namespace AlibabaCloud
{
namespace Rds
{
namespace Model
{
class ALIBABACLOUD_RDS_EXPORT EvaluateDedicatedHostInstanceResourceResult : public ServiceResult
{
public:
EvaluateDedicatedHostInstanceResourceResult();
explicit EvaluateDedicatedHostInstanceResourceResult(const std::string &payload);
~EvaluateDedicatedHostInstanceResourceResult();
std::string getDBInstanceClass()const;
int getAvailable()const;
protected:
void parse(const std::string &payload);
private:
std::string dBInstanceClass_;
int available_;
};
}
}
}
#endif // !ALIBABACLOUD_RDS_MODEL_EVALUATEDEDICATEDHOSTINSTANCERESOURCERESULT_H_

12
rds/include/alibabacloud/rds/model/ModifyDBProxyEndpointRequest.h
View File

@@ -51,8 +51,16 @@ namespace AlibabaCloud
void setReadOnlyInstanceMaxDelayTime(const std::string& readOnlyInstanceMaxDelayTime);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDbEndpointAliases()const;
void setDbEndpointAliases(const std::string& dbEndpointAliases);
std::string getDbEndpointOperator()const;
void setDbEndpointOperator(const std::string& dbEndpointOperator);
std::string getDbEndpointType()const;
void setDbEndpointType(const std::string& dbEndpointType);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getDbEndpointReadWriteMode()const;
void setDbEndpointReadWriteMode(const std::string& dbEndpointReadWriteMode);
std::string getDBProxyEndpointId()const;
void setDBProxyEndpointId(const std::string& dBProxyEndpointId);
std::string getReadOnlyInstanceDistributionType()const;
@@ -67,7 +75,11 @@ namespace AlibabaCloud
std::string readOnlyInstanceWeight_;
std::string readOnlyInstanceMaxDelayTime_;
std::string resourceOwnerAccount_;
std::string dbEndpointAliases_;
std::string dbEndpointOperator_;
std::string dbEndpointType_;
long ownerId_;
std::string dbEndpointReadWriteMode_;
std::string dBProxyEndpointId_;
std::string readOnlyInstanceDistributionType_;

72
rds/include/alibabacloud/rds/model/ModifyDedicatedHostUserRequest.h
View File

@@ -1,72 +0,0 @@
/*
* 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_RDS_MODEL_MODIFYDEDICATEDHOSTUSERREQUEST_H_
#define ALIBABACLOUD_RDS_MODEL_MODIFYDEDICATEDHOSTUSERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/rds/RdsExport.h>
namespace AlibabaCloud
{
namespace Rds
{
namespace Model
{
class ALIBABACLOUD_RDS_EXPORT ModifyDedicatedHostUserRequest : public RpcServiceRequest
{
public:
ModifyDedicatedHostUserRequest();
~ModifyDedicatedHostUserRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getDedicatedHostName()const;
void setDedicatedHostName(const std::string& dedicatedHostName);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOldPassword()const;
void setOldPassword(const std::string& oldPassword);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getNewPassword()const;
void setNewPassword(const std::string& newPassword);
std::string getUserName()const;
void setUserName(const std::string& userName);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string regionId_;
std::string dedicatedHostName_;
std::string resourceOwnerAccount_;
std::string oldPassword_;
long ownerId_;
std::string newPassword_;
std::string userName_;
};
}
}
}
#endif // !ALIBABACLOUD_RDS_MODEL_MODIFYDEDICATEDHOSTUSERREQUEST_H_

49
rds/include/alibabacloud/rds/model/ModifyDedicatedHostUserResult.h
View File

@@ -1,49 +0,0 @@
/*
* 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_RDS_MODEL_MODIFYDEDICATEDHOSTUSERRESULT_H_
#define ALIBABACLOUD_RDS_MODEL_MODIFYDEDICATEDHOSTUSERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/rds/RdsExport.h>
namespace AlibabaCloud
{
namespace Rds
{
namespace Model
{
class ALIBABACLOUD_RDS_EXPORT ModifyDedicatedHostUserResult : public ServiceResult
{
public:
ModifyDedicatedHostUserResult();
explicit ModifyDedicatedHostUserResult(const std::string &payload);
~ModifyDedicatedHostUserResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_RDS_MODEL_MODIFYDEDICATEDHOSTUSERRESULT_H_

324
rds/src/RdsClient.cc
View File

@@ -843,114 +843,6 @@ RdsClient::CreateDedicatedHostOutcomeCallable RdsClient::createDedicatedHostCall
return task->get_future();
}
RdsClient::CreateDedicatedHostAccountOutcome RdsClient::createDedicatedHostAccount(const CreateDedicatedHostAccountRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateDedicatedHostAccountOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateDedicatedHostAccountOutcome(CreateDedicatedHostAccountResult(outcome.result()));
else
return CreateDedicatedHostAccountOutcome(outcome.error());
}
void RdsClient::createDedicatedHostAccountAsync(const CreateDedicatedHostAccountRequest& request, const CreateDedicatedHostAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createDedicatedHostAccount(request), context);
};
asyncExecute(new Runnable(fn));
}
RdsClient::CreateDedicatedHostAccountOutcomeCallable RdsClient::createDedicatedHostAccountCallable(const CreateDedicatedHostAccountRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateDedicatedHostAccountOutcome()>>(
[this, request]()
{
return this->createDedicatedHostAccount(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
RdsClient::CreateDedicatedHostGroupOutcome RdsClient::createDedicatedHostGroup(const CreateDedicatedHostGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateDedicatedHostGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateDedicatedHostGroupOutcome(CreateDedicatedHostGroupResult(outcome.result()));
else
return CreateDedicatedHostGroupOutcome(outcome.error());
}
void RdsClient::createDedicatedHostGroupAsync(const CreateDedicatedHostGroupRequest& request, const CreateDedicatedHostGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createDedicatedHostGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
RdsClient::CreateDedicatedHostGroupOutcomeCallable RdsClient::createDedicatedHostGroupCallable(const CreateDedicatedHostGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateDedicatedHostGroupOutcome()>>(
[this, request]()
{
return this->createDedicatedHostGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
RdsClient::CreateDedicatedHostUserOutcome RdsClient::createDedicatedHostUser(const CreateDedicatedHostUserRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateDedicatedHostUserOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateDedicatedHostUserOutcome(CreateDedicatedHostUserResult(outcome.result()));
else
return CreateDedicatedHostUserOutcome(outcome.error());
}
void RdsClient::createDedicatedHostUserAsync(const CreateDedicatedHostUserRequest& request, const CreateDedicatedHostUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createDedicatedHostUser(request), context);
};
asyncExecute(new Runnable(fn));
}
RdsClient::CreateDedicatedHostUserOutcomeCallable RdsClient::createDedicatedHostUserCallable(const CreateDedicatedHostUserRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateDedicatedHostUserOutcome()>>(
[this, request]()
{
return this->createDedicatedHostUser(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
RdsClient::CreateDiagnosticReportOutcome RdsClient::createDiagnosticReport(const CreateDiagnosticReportRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1455,78 +1347,6 @@ RdsClient::DeleteDatabaseOutcomeCallable RdsClient::deleteDatabaseCallable(const
return task->get_future();
}
RdsClient::DeleteDedicatedHostAccountOutcome RdsClient::deleteDedicatedHostAccount(const DeleteDedicatedHostAccountRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteDedicatedHostAccountOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteDedicatedHostAccountOutcome(DeleteDedicatedHostAccountResult(outcome.result()));
else
return DeleteDedicatedHostAccountOutcome(outcome.error());
}
void RdsClient::deleteDedicatedHostAccountAsync(const DeleteDedicatedHostAccountRequest& request, const DeleteDedicatedHostAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteDedicatedHostAccount(request), context);
};
asyncExecute(new Runnable(fn));
}
RdsClient::DeleteDedicatedHostAccountOutcomeCallable RdsClient::deleteDedicatedHostAccountCallable(const DeleteDedicatedHostAccountRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteDedicatedHostAccountOutcome()>>(
[this, request]()
{
return this->deleteDedicatedHostAccount(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
RdsClient::DeleteDedicatedHostGroupOutcome RdsClient::deleteDedicatedHostGroup(const DeleteDedicatedHostGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteDedicatedHostGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteDedicatedHostGroupOutcome(DeleteDedicatedHostGroupResult(outcome.result()));
else
return DeleteDedicatedHostGroupOutcome(outcome.error());
}
void RdsClient::deleteDedicatedHostGroupAsync(const DeleteDedicatedHostGroupRequest& request, const DeleteDedicatedHostGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteDedicatedHostGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
RdsClient::DeleteDedicatedHostGroupOutcomeCallable RdsClient::deleteDedicatedHostGroupCallable(const DeleteDedicatedHostGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteDedicatedHostGroupOutcome()>>(
[this, request]()
{
return this->deleteDedicatedHostGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
RdsClient::DeleteHostAccountOutcome RdsClient::deleteHostAccount(const DeleteHostAccountRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1815,42 +1635,6 @@ RdsClient::DescribeAvailableDedicatedHostClassesOutcomeCallable RdsClient::descr
return task->get_future();
}
RdsClient::DescribeAvailableDedicatedHostZonesOutcome RdsClient::describeAvailableDedicatedHostZones(const DescribeAvailableDedicatedHostZonesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeAvailableDedicatedHostZonesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeAvailableDedicatedHostZonesOutcome(DescribeAvailableDedicatedHostZonesResult(outcome.result()));
else
return DescribeAvailableDedicatedHostZonesOutcome(outcome.error());
}
void RdsClient::describeAvailableDedicatedHostZonesAsync(const DescribeAvailableDedicatedHostZonesRequest& request, const DescribeAvailableDedicatedHostZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeAvailableDedicatedHostZones(request), context);
};
asyncExecute(new Runnable(fn));
}
RdsClient::DescribeAvailableDedicatedHostZonesOutcomeCallable RdsClient::describeAvailableDedicatedHostZonesCallable(const DescribeAvailableDedicatedHostZonesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeAvailableDedicatedHostZonesOutcome()>>(
[this, request]()
{
return this->describeAvailableDedicatedHostZones(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
RdsClient::DescribeAvailableRecoveryTimeOutcome RdsClient::describeAvailableRecoveryTime(const DescribeAvailableRecoveryTimeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4767,78 +4551,6 @@ RdsClient::DestroyDBInstanceOutcomeCallable RdsClient::destroyDBInstanceCallable
return task->get_future();
}
RdsClient::DropDedicatedHostUserOutcome RdsClient::dropDedicatedHostUser(const DropDedicatedHostUserRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DropDedicatedHostUserOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DropDedicatedHostUserOutcome(DropDedicatedHostUserResult(outcome.result()));
else
return DropDedicatedHostUserOutcome(outcome.error());
}
void RdsClient::dropDedicatedHostUserAsync(const DropDedicatedHostUserRequest& request, const DropDedicatedHostUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, dropDedicatedHostUser(request), context);
};
asyncExecute(new Runnable(fn));
}
RdsClient::DropDedicatedHostUserOutcomeCallable RdsClient::dropDedicatedHostUserCallable(const DropDedicatedHostUserRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DropDedicatedHostUserOutcome()>>(
[this, request]()
{
return this->dropDedicatedHostUser(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
RdsClient::EvaluateDedicatedHostInstanceResourceOutcome RdsClient::evaluateDedicatedHostInstanceResource(const EvaluateDedicatedHostInstanceResourceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return EvaluateDedicatedHostInstanceResourceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return EvaluateDedicatedHostInstanceResourceOutcome(EvaluateDedicatedHostInstanceResourceResult(outcome.result()));
else
return EvaluateDedicatedHostInstanceResourceOutcome(outcome.error());
}
void RdsClient::evaluateDedicatedHostInstanceResourceAsync(const EvaluateDedicatedHostInstanceResourceRequest& request, const EvaluateDedicatedHostInstanceResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, evaluateDedicatedHostInstanceResource(request), context);
};
asyncExecute(new Runnable(fn));
}
RdsClient::EvaluateDedicatedHostInstanceResourceOutcomeCallable RdsClient::evaluateDedicatedHostInstanceResourceCallable(const EvaluateDedicatedHostInstanceResourceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<EvaluateDedicatedHostInstanceResourceOutcome()>>(
[this, request]()
{
return this->evaluateDedicatedHostInstanceResource(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
RdsClient::GetDBInstanceTopologyOutcome RdsClient::getDBInstanceTopology(const GetDBInstanceTopologyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -6315,42 +6027,6 @@ RdsClient::ModifyDedicatedHostGroupAttributeOutcomeCallable RdsClient::modifyDed
return task->get_future();
}
RdsClient::ModifyDedicatedHostUserOutcome RdsClient::modifyDedicatedHostUser(const ModifyDedicatedHostUserRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyDedicatedHostUserOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyDedicatedHostUserOutcome(ModifyDedicatedHostUserResult(outcome.result()));
else
return ModifyDedicatedHostUserOutcome(outcome.error());
}
void RdsClient::modifyDedicatedHostUserAsync(const ModifyDedicatedHostUserRequest& request, const ModifyDedicatedHostUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyDedicatedHostUser(request), context);
};
asyncExecute(new Runnable(fn));
}
RdsClient::ModifyDedicatedHostUserOutcomeCallable RdsClient::modifyDedicatedHostUserCallable(const ModifyDedicatedHostUserRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyDedicatedHostUserOutcome()>>(
[this, request]()
{
return this->modifyDedicatedHostUser(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
RdsClient::ModifyHASwitchConfigOutcome RdsClient::modifyHASwitchConfig(const ModifyHASwitchConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

117
rds/src/model/CreateDedicatedHostAccountRequest.cc
View File

@@ -1,117 +0,0 @@
/*
* 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/rds/model/CreateDedicatedHostAccountRequest.h>
using AlibabaCloud::Rds::Model::CreateDedicatedHostAccountRequest;
CreateDedicatedHostAccountRequest::CreateDedicatedHostAccountRequest() :
RpcServiceRequest("rds", "2014-08-15", "CreateDedicatedHostAccount")
{
setMethod(HttpRequest::Method::Post);
}
CreateDedicatedHostAccountRequest::~CreateDedicatedHostAccountRequest()
{}
long CreateDedicatedHostAccountRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateDedicatedHostAccountRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateDedicatedHostAccountRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateDedicatedHostAccountRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateDedicatedHostAccountRequest::getAccountName()const
{
return accountName_;
}
void CreateDedicatedHostAccountRequest::setAccountName(const std::string& accountName)
{
accountName_ = accountName;
setParameter("AccountName", accountName);
}
std::string CreateDedicatedHostAccountRequest::getRegionId()const
{
return regionId_;
}
void CreateDedicatedHostAccountRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateDedicatedHostAccountRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateDedicatedHostAccountRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateDedicatedHostAccountRequest::getDedicatedHostId()const
{
return dedicatedHostId_;
}
void CreateDedicatedHostAccountRequest::setDedicatedHostId(const std::string& dedicatedHostId)
{
dedicatedHostId_ = dedicatedHostId;
setParameter("DedicatedHostId", dedicatedHostId);
}
long CreateDedicatedHostAccountRequest::getOwnerId()const
{
return ownerId_;
}
void CreateDedicatedHostAccountRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateDedicatedHostAccountRequest::getAccountPassword()const
{
return accountPassword_;
}
void CreateDedicatedHostAccountRequest::setAccountPassword(const std::string& accountPassword)
{
accountPassword_ = accountPassword;
setParameter("AccountPassword", accountPassword);
}

44
rds/src/model/CreateDedicatedHostAccountResult.cc
View File

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

183
rds/src/model/CreateDedicatedHostGroupRequest.cc
View File

@@ -1,183 +0,0 @@
/*
* 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/rds/model/CreateDedicatedHostGroupRequest.h>
using AlibabaCloud::Rds::Model::CreateDedicatedHostGroupRequest;
CreateDedicatedHostGroupRequest::CreateDedicatedHostGroupRequest() :
RpcServiceRequest("rds", "2014-08-15", "CreateDedicatedHostGroup")
{
setMethod(HttpRequest::Method::Post);
}
CreateDedicatedHostGroupRequest::~CreateDedicatedHostGroupRequest()
{}
long CreateDedicatedHostGroupRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateDedicatedHostGroupRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
int CreateDedicatedHostGroupRequest::getCpuAllocationRatio()const
{
return cpuAllocationRatio_;
}
void CreateDedicatedHostGroupRequest::setCpuAllocationRatio(int cpuAllocationRatio)
{
cpuAllocationRatio_ = cpuAllocationRatio;
setParameter("CpuAllocationRatio", std::to_string(cpuAllocationRatio));
}
std::string CreateDedicatedHostGroupRequest::getClientToken()const
{
return clientToken_;
}
void CreateDedicatedHostGroupRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CreateDedicatedHostGroupRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateDedicatedHostGroupRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateDedicatedHostGroupRequest::getRegionId()const
{
return regionId_;
}
void CreateDedicatedHostGroupRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateDedicatedHostGroupRequest::getEngine()const
{
return engine_;
}
void CreateDedicatedHostGroupRequest::setEngine(const std::string& engine)
{
engine_ = engine;
setParameter("Engine", engine);
}
std::string CreateDedicatedHostGroupRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateDedicatedHostGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
int CreateDedicatedHostGroupRequest::getDiskAllocationRatio()const
{
return diskAllocationRatio_;
}
void CreateDedicatedHostGroupRequest::setDiskAllocationRatio(int diskAllocationRatio)
{
diskAllocationRatio_ = diskAllocationRatio;
setParameter("DiskAllocationRatio", std::to_string(diskAllocationRatio));
}
int CreateDedicatedHostGroupRequest::getOpenPermission()const
{
return openPermission_;
}
void CreateDedicatedHostGroupRequest::setOpenPermission(int openPermission)
{
openPermission_ = openPermission;
setParameter("OpenPermission", std::to_string(openPermission));
}
int CreateDedicatedHostGroupRequest::getMemAllocationRatio()const
{
return memAllocationRatio_;
}
void CreateDedicatedHostGroupRequest::setMemAllocationRatio(int memAllocationRatio)
{
memAllocationRatio_ = memAllocationRatio;
setParameter("MemAllocationRatio", std::to_string(memAllocationRatio));
}
long CreateDedicatedHostGroupRequest::getOwnerId()const
{
return ownerId_;
}
void CreateDedicatedHostGroupRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateDedicatedHostGroupRequest::getHostReplacePolicy()const
{
return hostReplacePolicy_;
}
void CreateDedicatedHostGroupRequest::setHostReplacePolicy(const std::string& hostReplacePolicy)
{
hostReplacePolicy_ = hostReplacePolicy;
setParameter("HostReplacePolicy", hostReplacePolicy);
}
std::string CreateDedicatedHostGroupRequest::getAllocationPolicy()const
{
return allocationPolicy_;
}
void CreateDedicatedHostGroupRequest::setAllocationPolicy(const std::string& allocationPolicy)
{
allocationPolicy_ = allocationPolicy;
setParameter("AllocationPolicy", allocationPolicy);
}
std::string CreateDedicatedHostGroupRequest::getVPCId()const
{
return vPCId_;
}
void CreateDedicatedHostGroupRequest::setVPCId(const std::string& vPCId)
{
vPCId_ = vPCId;
setParameter("VPCId", vPCId);
}

51
rds/src/model/CreateDedicatedHostGroupResult.cc
View File

@@ -1,51 +0,0 @@
/*
* 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/rds/model/CreateDedicatedHostGroupResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
CreateDedicatedHostGroupResult::CreateDedicatedHostGroupResult() :
ServiceResult()
{}
CreateDedicatedHostGroupResult::CreateDedicatedHostGroupResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateDedicatedHostGroupResult::~CreateDedicatedHostGroupResult()
{}
void CreateDedicatedHostGroupResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["DedicatedHostGroupId"].isNull())
dedicatedHostGroupId_ = value["DedicatedHostGroupId"].asString();
}
std::string CreateDedicatedHostGroupResult::getDedicatedHostGroupId()const
{
return dedicatedHostGroupId_;
}

117
rds/src/model/CreateDedicatedHostUserRequest.cc
View File

@@ -1,117 +0,0 @@
/*
* 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/rds/model/CreateDedicatedHostUserRequest.h>
using AlibabaCloud::Rds::Model::CreateDedicatedHostUserRequest;
CreateDedicatedHostUserRequest::CreateDedicatedHostUserRequest() :
RpcServiceRequest("rds", "2014-08-15", "CreateDedicatedHostUser")
{
setMethod(HttpRequest::Method::Post);
}
CreateDedicatedHostUserRequest::~CreateDedicatedHostUserRequest()
{}
long CreateDedicatedHostUserRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateDedicatedHostUserRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateDedicatedHostUserRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateDedicatedHostUserRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateDedicatedHostUserRequest::getUserPassword()const
{
return userPassword_;
}
void CreateDedicatedHostUserRequest::setUserPassword(const std::string& userPassword)
{
userPassword_ = userPassword;
setParameter("UserPassword", userPassword);
}
std::string CreateDedicatedHostUserRequest::getRegionId()const
{
return regionId_;
}
void CreateDedicatedHostUserRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateDedicatedHostUserRequest::getDedicatedHostName()const
{
return dedicatedHostName_;
}
void CreateDedicatedHostUserRequest::setDedicatedHostName(const std::string& dedicatedHostName)
{
dedicatedHostName_ = dedicatedHostName;
setParameter("DedicatedHostName", dedicatedHostName);
}
std::string CreateDedicatedHostUserRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateDedicatedHostUserRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long CreateDedicatedHostUserRequest::getOwnerId()const
{
return ownerId_;
}
void CreateDedicatedHostUserRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateDedicatedHostUserRequest::getUserName()const
{
return userName_;
}
void CreateDedicatedHostUserRequest::setUserName(const std::string& userName)
{
userName_ = userName;
setParameter("UserName", userName);
}

44
rds/src/model/CreateDedicatedHostUserResult.cc
View File

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

106
rds/src/model/DeleteDedicatedHostAccountRequest.cc
View File

@@ -1,106 +0,0 @@
/*
* 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/rds/model/DeleteDedicatedHostAccountRequest.h>
using AlibabaCloud::Rds::Model::DeleteDedicatedHostAccountRequest;
DeleteDedicatedHostAccountRequest::DeleteDedicatedHostAccountRequest() :
RpcServiceRequest("rds", "2014-08-15", "DeleteDedicatedHostAccount")
{
setMethod(HttpRequest::Method::Post);
}
DeleteDedicatedHostAccountRequest::~DeleteDedicatedHostAccountRequest()
{}
long DeleteDedicatedHostAccountRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteDedicatedHostAccountRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteDedicatedHostAccountRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteDedicatedHostAccountRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteDedicatedHostAccountRequest::getDedicatedHostId()const
{
return dedicatedHostId_;
}
void DeleteDedicatedHostAccountRequest::setDedicatedHostId(const std::string& dedicatedHostId)
{
dedicatedHostId_ = dedicatedHostId;
setParameter("DedicatedHostId", dedicatedHostId);
}
long DeleteDedicatedHostAccountRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteDedicatedHostAccountRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteDedicatedHostAccountRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteDedicatedHostAccountRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DeleteDedicatedHostAccountRequest::getAccountName()const
{
return accountName_;
}
void DeleteDedicatedHostAccountRequest::setAccountName(const std::string& accountName)
{
accountName_ = accountName;
setParameter("AccountName", accountName);
}
std::string DeleteDedicatedHostAccountRequest::getRegionId()const
{
return regionId_;
}
void DeleteDedicatedHostAccountRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}

44
rds/src/model/DeleteDedicatedHostAccountResult.cc
View File

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

95
rds/src/model/DeleteDedicatedHostGroupRequest.cc
View File

@@ -1,95 +0,0 @@
/*
* 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/rds/model/DeleteDedicatedHostGroupRequest.h>
using AlibabaCloud::Rds::Model::DeleteDedicatedHostGroupRequest;
DeleteDedicatedHostGroupRequest::DeleteDedicatedHostGroupRequest() :
RpcServiceRequest("rds", "2014-08-15", "DeleteDedicatedHostGroup")
{
setMethod(HttpRequest::Method::Post);
}
DeleteDedicatedHostGroupRequest::~DeleteDedicatedHostGroupRequest()
{}
long DeleteDedicatedHostGroupRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteDedicatedHostGroupRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteDedicatedHostGroupRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteDedicatedHostGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long DeleteDedicatedHostGroupRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteDedicatedHostGroupRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteDedicatedHostGroupRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteDedicatedHostGroupRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DeleteDedicatedHostGroupRequest::getRegionId()const
{
return regionId_;
}
void DeleteDedicatedHostGroupRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DeleteDedicatedHostGroupRequest::getDedicatedHostGroupId()const
{
return dedicatedHostGroupId_;
}
void DeleteDedicatedHostGroupRequest::setDedicatedHostGroupId(const std::string& dedicatedHostGroupId)
{
dedicatedHostGroupId_ = dedicatedHostGroupId;
setParameter("DedicatedHostGroupId", dedicatedHostGroupId);
}

44
rds/src/model/DeleteDedicatedHostGroupResult.cc
View File

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

84
rds/src/model/DescribeAvailableDedicatedHostZonesRequest.cc
View File

@@ -1,84 +0,0 @@
/*
* 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/rds/model/DescribeAvailableDedicatedHostZonesRequest.h>
using AlibabaCloud::Rds::Model::DescribeAvailableDedicatedHostZonesRequest;
DescribeAvailableDedicatedHostZonesRequest::DescribeAvailableDedicatedHostZonesRequest() :
RpcServiceRequest("rds", "2014-08-15", "DescribeAvailableDedicatedHostZones")
{
setMethod(HttpRequest::Method::Post);
}
DescribeAvailableDedicatedHostZonesRequest::~DescribeAvailableDedicatedHostZonesRequest()
{}
long DescribeAvailableDedicatedHostZonesRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeAvailableDedicatedHostZonesRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeAvailableDedicatedHostZonesRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeAvailableDedicatedHostZonesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long DescribeAvailableDedicatedHostZonesRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeAvailableDedicatedHostZonesRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeAvailableDedicatedHostZonesRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeAvailableDedicatedHostZonesRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeAvailableDedicatedHostZonesRequest::getRegionId()const
{
return regionId_;
}
void DescribeAvailableDedicatedHostZonesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}

59
rds/src/model/DescribeAvailableDedicatedHostZonesResult.cc
View File

@@ -1,59 +0,0 @@
/*
* 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/rds/model/DescribeAvailableDedicatedHostZonesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
DescribeAvailableDedicatedHostZonesResult::DescribeAvailableDedicatedHostZonesResult() :
ServiceResult()
{}
DescribeAvailableDedicatedHostZonesResult::DescribeAvailableDedicatedHostZonesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeAvailableDedicatedHostZonesResult::~DescribeAvailableDedicatedHostZonesResult()
{}
void DescribeAvailableDedicatedHostZonesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allZonesNode = value["Zones"]["DedicatedHostZones"];
for (auto valueZonesDedicatedHostZones : allZonesNode)
{
DedicatedHostZones zonesObject;
if(!valueZonesDedicatedHostZones["ZoneId"].isNull())
zonesObject.zoneId = valueZonesDedicatedHostZones["ZoneId"].asString();
if(!valueZonesDedicatedHostZones["Description"].isNull())
zonesObject.description = valueZonesDedicatedHostZones["Description"].asString();
zones_.push_back(zonesObject);
}
}
std::vector<DescribeAvailableDedicatedHostZonesResult::DedicatedHostZones> DescribeAvailableDedicatedHostZonesResult::getZones()const
{
return zones_;
}

31
rds/src/model/DescribeDBProxyEndpointResult.cc
View File

@@ -39,6 +39,18 @@ void DescribeDBProxyEndpointResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allEndpointConnectItemsNode = value["EndpointConnectItems"]["EndpointConnectItemsItem"];
for (auto valueEndpointConnectItemsEndpointConnectItemsItem : allEndpointConnectItemsNode)
{
EndpointConnectItemsItem endpointConnectItemsObject;
if(!valueEndpointConnectItemsEndpointConnectItemsItem["DbProxyEndpointConnectString"].isNull())
endpointConnectItemsObject.dbProxyEndpointConnectString = valueEndpointConnectItemsEndpointConnectItemsItem["DbProxyEndpointConnectString"].asString();
if(!valueEndpointConnectItemsEndpointConnectItemsItem["DbProxyEndpointPort"].isNull())
endpointConnectItemsObject.dbProxyEndpointPort = valueEndpointConnectItemsEndpointConnectItemsItem["DbProxyEndpointPort"].asString();
if(!valueEndpointConnectItemsEndpointConnectItemsItem["DbProxyEndpointNetType"].isNull())
endpointConnectItemsObject.dbProxyEndpointNetType = valueEndpointConnectItemsEndpointConnectItemsItem["DbProxyEndpointNetType"].asString();
endpointConnectItems_.push_back(endpointConnectItemsObject);
}
if(!value["DBProxyEndpointId"].isNull())
dBProxyEndpointId_ = value["DBProxyEndpointId"].asString();
if(!value["DBProxyConnectString"].isNull())
@@ -55,6 +67,10 @@ void DescribeDBProxyEndpointResult::parse(const std::string &payload)
readOnlyInstanceDistributionType_ = value["ReadOnlyInstanceDistributionType"].asString();
if(!value["ReadOnlyInstanceWeight"].isNull())
readOnlyInstanceWeight_ = value["ReadOnlyInstanceWeight"].asString();
if(!value["DbProxyEndpointAliases"].isNull())
dbProxyEndpointAliases_ = value["DbProxyEndpointAliases"].asString();
if(!value["DbProxyEndpointReadWriteMode"].isNull())
dbProxyEndpointReadWriteMode_ = value["DbProxyEndpointReadWriteMode"].asString();
}
@@ -63,6 +79,11 @@ std::string DescribeDBProxyEndpointResult::getReadOnlyInstanceDistributionType()
return readOnlyInstanceDistributionType_;
}
std::string DescribeDBProxyEndpointResult::getDbProxyEndpointReadWriteMode()const
{
return dbProxyEndpointReadWriteMode_;
}
std::string DescribeDBProxyEndpointResult::getDBProxyConnectString()const
{
return dBProxyConnectString_;
@@ -73,6 +94,11 @@ std::string DescribeDBProxyEndpointResult::getDBProxyEndpointId()const
return dBProxyEndpointId_;
}
std::string DescribeDBProxyEndpointResult::getDbProxyEndpointAliases()const
{
return dbProxyEndpointAliases_;
}
std::string DescribeDBProxyEndpointResult::getDBProxyFeatures()const
{
return dBProxyFeatures_;
@@ -93,6 +119,11 @@ std::string DescribeDBProxyEndpointResult::getDBProxyConnectStringNetType()const
return dBProxyConnectStringNetType_;
}
std::vector<DescribeDBProxyEndpointResult::EndpointConnectItemsItem> DescribeDBProxyEndpointResult::getEndpointConnectItems()const
{
return endpointConnectItems_;
}
std::string DescribeDBProxyEndpointResult::getDBProxyConnectStringPort()const
{
return dBProxyConnectStringPort_;

19
rds/src/model/DescribeDBProxyResult.cc
View File

@@ -59,6 +59,20 @@ void DescribeDBProxyResult::parse(const std::string &payload)
dBProxyConnectStringItemsObject.dBProxyConnectStringNetWorkType = valueDBProxyConnectStringItemsDBProxyConnectStringItemsItem["DBProxyConnectStringNetWorkType"].asString();
dBProxyConnectStringItems_.push_back(dBProxyConnectStringItemsObject);
}
auto allDbProxyEndpointItemsNode = value["DbProxyEndpointItems"]["DbProxyEndpointItemsItem"];
for (auto valueDbProxyEndpointItemsDbProxyEndpointItemsItem : allDbProxyEndpointItemsNode)
{
DbProxyEndpointItemsItem dbProxyEndpointItemsObject;
if(!valueDbProxyEndpointItemsDbProxyEndpointItemsItem["DbProxyEndpointName"].isNull())
dbProxyEndpointItemsObject.dbProxyEndpointName = valueDbProxyEndpointItemsDbProxyEndpointItemsItem["DbProxyEndpointName"].asString();
if(!valueDbProxyEndpointItemsDbProxyEndpointItemsItem["DbProxyEndpointType"].isNull())
dbProxyEndpointItemsObject.dbProxyEndpointType = valueDbProxyEndpointItemsDbProxyEndpointItemsItem["DbProxyEndpointType"].asString();
if(!valueDbProxyEndpointItemsDbProxyEndpointItemsItem["DbProxyReadWriteMode"].isNull())
dbProxyEndpointItemsObject.dbProxyReadWriteMode = valueDbProxyEndpointItemsDbProxyEndpointItemsItem["DbProxyReadWriteMode"].asString();
if(!valueDbProxyEndpointItemsDbProxyEndpointItemsItem["DbProxyEndpointAliases"].isNull())
dbProxyEndpointItemsObject.dbProxyEndpointAliases = valueDbProxyEndpointItemsDbProxyEndpointItemsItem["DbProxyEndpointAliases"].asString();
dbProxyEndpointItems_.push_back(dbProxyEndpointItemsObject);
}
if(!value["DBProxyServiceStatus"].isNull())
dBProxyServiceStatus_ = value["DBProxyServiceStatus"].asString();
if(!value["DBProxyInstanceType"].isNull())
@@ -101,6 +115,11 @@ std::string DescribeDBProxyResult::getDBProxyInstanceLatestMinorVersion()const
return dBProxyInstanceLatestMinorVersion_;
}
std::vector<DescribeDBProxyResult::DbProxyEndpointItemsItem> DescribeDBProxyResult::getDbProxyEndpointItems()const
{
return dbProxyEndpointItems_;
}
std::vector<DescribeDBProxyResult::DBProxyConnectStringItemsItem> DescribeDBProxyResult::getDBProxyConnectStringItems()const
{
return dBProxyConnectStringItems_;

106
rds/src/model/DropDedicatedHostUserRequest.cc
View File

@@ -1,106 +0,0 @@
/*
* 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/rds/model/DropDedicatedHostUserRequest.h>
using AlibabaCloud::Rds::Model::DropDedicatedHostUserRequest;
DropDedicatedHostUserRequest::DropDedicatedHostUserRequest() :
RpcServiceRequest("rds", "2014-08-15", "DropDedicatedHostUser")
{
setMethod(HttpRequest::Method::Post);
}
DropDedicatedHostUserRequest::~DropDedicatedHostUserRequest()
{}
long DropDedicatedHostUserRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DropDedicatedHostUserRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DropDedicatedHostUserRequest::getDedicatedHostName()const
{
return dedicatedHostName_;
}
void DropDedicatedHostUserRequest::setDedicatedHostName(const std::string& dedicatedHostName)
{
dedicatedHostName_ = dedicatedHostName;
setParameter("DedicatedHostName", dedicatedHostName);
}
std::string DropDedicatedHostUserRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DropDedicatedHostUserRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long DropDedicatedHostUserRequest::getOwnerId()const
{
return ownerId_;
}
void DropDedicatedHostUserRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DropDedicatedHostUserRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DropDedicatedHostUserRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DropDedicatedHostUserRequest::getRegionId()const
{
return regionId_;
}
void DropDedicatedHostUserRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DropDedicatedHostUserRequest::getUserName()const
{
return userName_;
}
void DropDedicatedHostUserRequest::setUserName(const std::string& userName)
{
userName_ = userName;
setParameter("UserName", userName);
}

44
rds/src/model/DropDedicatedHostUserResult.cc
View File

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

150
rds/src/model/EvaluateDedicatedHostInstanceResourceRequest.cc
View File

@@ -1,150 +0,0 @@
/*
* 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/rds/model/EvaluateDedicatedHostInstanceResourceRequest.h>
using AlibabaCloud::Rds::Model::EvaluateDedicatedHostInstanceResourceRequest;
EvaluateDedicatedHostInstanceResourceRequest::EvaluateDedicatedHostInstanceResourceRequest() :
RpcServiceRequest("rds", "2014-08-15", "EvaluateDedicatedHostInstanceResource")
{
setMethod(HttpRequest::Method::Post);
}
EvaluateDedicatedHostInstanceResourceRequest::~EvaluateDedicatedHostInstanceResourceRequest()
{}
long EvaluateDedicatedHostInstanceResourceRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string EvaluateDedicatedHostInstanceResourceRequest::getEngineVersion()const
{
return engineVersion_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setEngineVersion(const std::string& engineVersion)
{
engineVersion_ = engineVersion;
setParameter("EngineVersion", engineVersion);
}
std::string EvaluateDedicatedHostInstanceResourceRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string EvaluateDedicatedHostInstanceResourceRequest::getRegionId()const
{
return regionId_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string EvaluateDedicatedHostInstanceResourceRequest::getEngine()const
{
return engine_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setEngine(const std::string& engine)
{
engine_ = engine;
setParameter("Engine", engine);
}
std::string EvaluateDedicatedHostInstanceResourceRequest::getDedicatedHostGroupId()const
{
return dedicatedHostGroupId_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setDedicatedHostGroupId(const std::string& dedicatedHostGroupId)
{
dedicatedHostGroupId_ = dedicatedHostGroupId;
setParameter("DedicatedHostGroupId", dedicatedHostGroupId);
}
std::string EvaluateDedicatedHostInstanceResourceRequest::getInstanceClassNames()const
{
return instanceClassNames_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setInstanceClassNames(const std::string& instanceClassNames)
{
instanceClassNames_ = instanceClassNames;
setParameter("InstanceClassNames", instanceClassNames);
}
std::string EvaluateDedicatedHostInstanceResourceRequest::getDiskSize()const
{
return diskSize_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setDiskSize(const std::string& diskSize)
{
diskSize_ = diskSize;
setParameter("DiskSize", diskSize);
}
std::string EvaluateDedicatedHostInstanceResourceRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long EvaluateDedicatedHostInstanceResourceRequest::getOwnerId()const
{
return ownerId_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string EvaluateDedicatedHostInstanceResourceRequest::getDiskType()const
{
return diskType_;
}
void EvaluateDedicatedHostInstanceResourceRequest::setDiskType(const std::string& diskType)
{
diskType_ = diskType;
setParameter("DiskType", diskType);
}

58
rds/src/model/EvaluateDedicatedHostInstanceResourceResult.cc
View File

@@ -1,58 +0,0 @@
/*
* 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/rds/model/EvaluateDedicatedHostInstanceResourceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Rds;
using namespace AlibabaCloud::Rds::Model;
EvaluateDedicatedHostInstanceResourceResult::EvaluateDedicatedHostInstanceResourceResult() :
ServiceResult()
{}
EvaluateDedicatedHostInstanceResourceResult::EvaluateDedicatedHostInstanceResourceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
EvaluateDedicatedHostInstanceResourceResult::~EvaluateDedicatedHostInstanceResourceResult()
{}
void EvaluateDedicatedHostInstanceResourceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["DBInstanceClass"].isNull())
dBInstanceClass_ = value["DBInstanceClass"].asString();
if(!value["Available"].isNull())
available_ = std::stoi(value["Available"].asString());
}
std::string EvaluateDedicatedHostInstanceResourceResult::getDBInstanceClass()const
{
return dBInstanceClass_;
}
int EvaluateDedicatedHostInstanceResourceResult::getAvailable()const
{
return available_;
}

44
rds/src/model/ModifyDBProxyEndpointRequest.cc
View File

@@ -115,6 +115,39 @@ void ModifyDBProxyEndpointRequest::setResourceOwnerAccount(const std::string& re
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string ModifyDBProxyEndpointRequest::getDbEndpointAliases()const
{
return dbEndpointAliases_;
}
void ModifyDBProxyEndpointRequest::setDbEndpointAliases(const std::string& dbEndpointAliases)
{
dbEndpointAliases_ = dbEndpointAliases;
setParameter("DbEndpointAliases", dbEndpointAliases);
}
std::string ModifyDBProxyEndpointRequest::getDbEndpointOperator()const
{
return dbEndpointOperator_;
}
void ModifyDBProxyEndpointRequest::setDbEndpointOperator(const std::string& dbEndpointOperator)
{
dbEndpointOperator_ = dbEndpointOperator;
setParameter("DbEndpointOperator", dbEndpointOperator);
}
std::string ModifyDBProxyEndpointRequest::getDbEndpointType()const
{
return dbEndpointType_;
}
void ModifyDBProxyEndpointRequest::setDbEndpointType(const std::string& dbEndpointType)
{
dbEndpointType_ = dbEndpointType;
setParameter("DbEndpointType", dbEndpointType);
}
long ModifyDBProxyEndpointRequest::getOwnerId()const
{
return ownerId_;
@@ -126,6 +159,17 @@ void ModifyDBProxyEndpointRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string ModifyDBProxyEndpointRequest::getDbEndpointReadWriteMode()const
{
return dbEndpointReadWriteMode_;
}
void ModifyDBProxyEndpointRequest::setDbEndpointReadWriteMode(const std::string& dbEndpointReadWriteMode)
{
dbEndpointReadWriteMode_ = dbEndpointReadWriteMode;
setParameter("DbEndpointReadWriteMode", dbEndpointReadWriteMode);
}
std::string ModifyDBProxyEndpointRequest::getDBProxyEndpointId()const
{
return dBProxyEndpointId_;

128
rds/src/model/ModifyDedicatedHostUserRequest.cc
View File

@@ -1,128 +0,0 @@
/*
* 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/rds/model/ModifyDedicatedHostUserRequest.h>
using AlibabaCloud::Rds::Model::ModifyDedicatedHostUserRequest;
ModifyDedicatedHostUserRequest::ModifyDedicatedHostUserRequest() :
RpcServiceRequest("rds", "2014-08-15", "ModifyDedicatedHostUser")
{
setMethod(HttpRequest::Method::Post);
}
ModifyDedicatedHostUserRequest::~ModifyDedicatedHostUserRequest()
{}
long ModifyDedicatedHostUserRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void ModifyDedicatedHostUserRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string ModifyDedicatedHostUserRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void ModifyDedicatedHostUserRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string ModifyDedicatedHostUserRequest::getRegionId()const
{
return regionId_;
}
void ModifyDedicatedHostUserRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string ModifyDedicatedHostUserRequest::getDedicatedHostName()const
{
return dedicatedHostName_;
}
void ModifyDedicatedHostUserRequest::setDedicatedHostName(const std::string& dedicatedHostName)
{
dedicatedHostName_ = dedicatedHostName;
setParameter("DedicatedHostName", dedicatedHostName);
}
std::string ModifyDedicatedHostUserRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void ModifyDedicatedHostUserRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string ModifyDedicatedHostUserRequest::getOldPassword()const
{
return oldPassword_;
}
void ModifyDedicatedHostUserRequest::setOldPassword(const std::string& oldPassword)
{
oldPassword_ = oldPassword;
setParameter("OldPassword", oldPassword);
}
long ModifyDedicatedHostUserRequest::getOwnerId()const
{
return ownerId_;
}
void ModifyDedicatedHostUserRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string ModifyDedicatedHostUserRequest::getNewPassword()const
{
return newPassword_;
}
void ModifyDedicatedHostUserRequest::setNewPassword(const std::string& newPassword)
{
newPassword_ = newPassword;
setParameter("NewPassword", newPassword);
}
std::string ModifyDedicatedHostUserRequest::getUserName()const
{
return userName_;
}
void ModifyDedicatedHostUserRequest::setUserName(const std::string& userName)
{
userName_ = userName;
setParameter("UserName", userName);
}

44
rds/src/model/ModifyDedicatedHostUserResult.cc
View File

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