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

Generated 2019-01-01 for HBase.

Browse Source
This commit is contained in:
sdk-team
2019-12-04 21:02:23 +08:00
parent 3da02ee896
commit 099e528d4d
47 changed files with 2737 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
hbase/CMakeLists.txt
View File

@@ -25,16 +25,24 @@ set(hbase_public_header_model
include/alibabacloud/hbase/model/AddUserHdfsInfoResult.h
include/alibabacloud/hbase/model/ConvertInstanceRequest.h
include/alibabacloud/hbase/model/ConvertInstanceResult.h
include/alibabacloud/hbase/model/CreateHbaseHaSlbRequest.h
include/alibabacloud/hbase/model/CreateHbaseHaSlbResult.h
include/alibabacloud/hbase/model/CreateInstanceRequest.h
include/alibabacloud/hbase/model/CreateInstanceResult.h
include/alibabacloud/hbase/model/DeleteHbaseHaSlbRequest.h
include/alibabacloud/hbase/model/DeleteHbaseHaSlbResult.h
include/alibabacloud/hbase/model/DeleteInstanceRequest.h
include/alibabacloud/hbase/model/DeleteInstanceResult.h
include/alibabacloud/hbase/model/DeleteUserHdfsInfoRequest.h
include/alibabacloud/hbase/model/DeleteUserHdfsInfoResult.h
include/alibabacloud/hbase/model/DescribeDBInstanceUsageRequest.h
include/alibabacloud/hbase/model/DescribeDBInstanceUsageResult.h
include/alibabacloud/hbase/model/DescribeEndpointsRequest.h
include/alibabacloud/hbase/model/DescribeEndpointsResult.h
include/alibabacloud/hbase/model/DescribeInstanceRequest.h
include/alibabacloud/hbase/model/DescribeInstanceResult.h
include/alibabacloud/hbase/model/DescribeInstanceTypeRequest.h
include/alibabacloud/hbase/model/DescribeInstanceTypeResult.h
include/alibabacloud/hbase/model/DescribeInstancesRequest.h
include/alibabacloud/hbase/model/DescribeInstancesResult.h
include/alibabacloud/hbase/model/DescribeIpWhitelistRequest.h
@@ -43,6 +51,10 @@ set(hbase_public_header_model
include/alibabacloud/hbase/model/DescribeRegionsResult.h
include/alibabacloud/hbase/model/DescribeSecurityGroupsRequest.h
include/alibabacloud/hbase/model/DescribeSecurityGroupsResult.h
include/alibabacloud/hbase/model/ListTagResourcesRequest.h
include/alibabacloud/hbase/model/ListTagResourcesResult.h
include/alibabacloud/hbase/model/ModifyInstanceMaintainTimeRequest.h
include/alibabacloud/hbase/model/ModifyInstanceMaintainTimeResult.h
include/alibabacloud/hbase/model/ModifyInstanceNameRequest.h
include/alibabacloud/hbase/model/ModifyInstanceNameResult.h
include/alibabacloud/hbase/model/ModifyIpWhitelistRequest.h
@@ -51,6 +63,8 @@ set(hbase_public_header_model
include/alibabacloud/hbase/model/ModifySecurityGroupsResult.h
include/alibabacloud/hbase/model/ModifyUIAccountPasswordRequest.h
include/alibabacloud/hbase/model/ModifyUIAccountPasswordResult.h
include/alibabacloud/hbase/model/QueryHBaseHaDBRequest.h
include/alibabacloud/hbase/model/QueryHBaseHaDBResult.h
include/alibabacloud/hbase/model/QueryXpackRelateDBRequest.h
include/alibabacloud/hbase/model/QueryXpackRelateDBResult.h
include/alibabacloud/hbase/model/RenewInstanceRequest.h
@@ -61,6 +75,12 @@ set(hbase_public_header_model
include/alibabacloud/hbase/model/ResizeNodeCountResult.h
include/alibabacloud/hbase/model/RestartInstanceRequest.h
include/alibabacloud/hbase/model/RestartInstanceResult.h
include/alibabacloud/hbase/model/SwitchHbaseHaSlbRequest.h
include/alibabacloud/hbase/model/SwitchHbaseHaSlbResult.h
include/alibabacloud/hbase/model/TagResourcesRequest.h
include/alibabacloud/hbase/model/TagResourcesResult.h
include/alibabacloud/hbase/model/UnTagResourcesRequest.h
include/alibabacloud/hbase/model/UnTagResourcesResult.h
include/alibabacloud/hbase/model/XpackRelateDBRequest.h
include/alibabacloud/hbase/model/XpackRelateDBResult.h )
@@ -70,16 +90,24 @@ set(hbase_src
src/model/AddUserHdfsInfoResult.cc
src/model/ConvertInstanceRequest.cc
src/model/ConvertInstanceResult.cc
src/model/CreateHbaseHaSlbRequest.cc
src/model/CreateHbaseHaSlbResult.cc
src/model/CreateInstanceRequest.cc
src/model/CreateInstanceResult.cc
src/model/DeleteHbaseHaSlbRequest.cc
src/model/DeleteHbaseHaSlbResult.cc
src/model/DeleteInstanceRequest.cc
src/model/DeleteInstanceResult.cc
src/model/DeleteUserHdfsInfoRequest.cc
src/model/DeleteUserHdfsInfoResult.cc
src/model/DescribeDBInstanceUsageRequest.cc
src/model/DescribeDBInstanceUsageResult.cc
src/model/DescribeEndpointsRequest.cc
src/model/DescribeEndpointsResult.cc
src/model/DescribeInstanceRequest.cc
src/model/DescribeInstanceResult.cc
src/model/DescribeInstanceTypeRequest.cc
src/model/DescribeInstanceTypeResult.cc
src/model/DescribeInstancesRequest.cc
src/model/DescribeInstancesResult.cc
src/model/DescribeIpWhitelistRequest.cc
@@ -88,6 +116,10 @@ set(hbase_src
src/model/DescribeRegionsResult.cc
src/model/DescribeSecurityGroupsRequest.cc
src/model/DescribeSecurityGroupsResult.cc
src/model/ListTagResourcesRequest.cc
src/model/ListTagResourcesResult.cc
src/model/ModifyInstanceMaintainTimeRequest.cc
src/model/ModifyInstanceMaintainTimeResult.cc
src/model/ModifyInstanceNameRequest.cc
src/model/ModifyInstanceNameResult.cc
src/model/ModifyIpWhitelistRequest.cc
@@ -96,6 +128,8 @@ set(hbase_src
src/model/ModifySecurityGroupsResult.cc
src/model/ModifyUIAccountPasswordRequest.cc
src/model/ModifyUIAccountPasswordResult.cc
src/model/QueryHBaseHaDBRequest.cc
src/model/QueryHBaseHaDBResult.cc
src/model/QueryXpackRelateDBRequest.cc
src/model/QueryXpackRelateDBResult.cc
src/model/RenewInstanceRequest.cc
@@ -106,6 +140,12 @@ set(hbase_src
src/model/ResizeNodeCountResult.cc
src/model/RestartInstanceRequest.cc
src/model/RestartInstanceResult.cc
src/model/SwitchHbaseHaSlbRequest.cc
src/model/SwitchHbaseHaSlbResult.cc
src/model/TagResourcesRequest.cc
src/model/TagResourcesResult.cc
src/model/UnTagResourcesRequest.cc
src/model/UnTagResourcesResult.cc
src/model/XpackRelateDBRequest.cc
src/model/XpackRelateDBResult.cc )

80
hbase/include/alibabacloud/hbase/HBaseClient.h
View File

@@ -26,16 +26,24 @@
#include "model/AddUserHdfsInfoResult.h"
#include "model/ConvertInstanceRequest.h"
#include "model/ConvertInstanceResult.h"
#include "model/CreateHbaseHaSlbRequest.h"
#include "model/CreateHbaseHaSlbResult.h"
#include "model/CreateInstanceRequest.h"
#include "model/CreateInstanceResult.h"
#include "model/DeleteHbaseHaSlbRequest.h"
#include "model/DeleteHbaseHaSlbResult.h"
#include "model/DeleteInstanceRequest.h"
#include "model/DeleteInstanceResult.h"
#include "model/DeleteUserHdfsInfoRequest.h"
#include "model/DeleteUserHdfsInfoResult.h"
#include "model/DescribeDBInstanceUsageRequest.h"
#include "model/DescribeDBInstanceUsageResult.h"
#include "model/DescribeEndpointsRequest.h"
#include "model/DescribeEndpointsResult.h"
#include "model/DescribeInstanceRequest.h"
#include "model/DescribeInstanceResult.h"
#include "model/DescribeInstanceTypeRequest.h"
#include "model/DescribeInstanceTypeResult.h"
#include "model/DescribeInstancesRequest.h"
#include "model/DescribeInstancesResult.h"
#include "model/DescribeIpWhitelistRequest.h"
@@ -44,6 +52,10 @@
#include "model/DescribeRegionsResult.h"
#include "model/DescribeSecurityGroupsRequest.h"
#include "model/DescribeSecurityGroupsResult.h"
#include "model/ListTagResourcesRequest.h"
#include "model/ListTagResourcesResult.h"
#include "model/ModifyInstanceMaintainTimeRequest.h"
#include "model/ModifyInstanceMaintainTimeResult.h"
#include "model/ModifyInstanceNameRequest.h"
#include "model/ModifyInstanceNameResult.h"
#include "model/ModifyIpWhitelistRequest.h"
@@ -52,6 +64,8 @@
#include "model/ModifySecurityGroupsResult.h"
#include "model/ModifyUIAccountPasswordRequest.h"
#include "model/ModifyUIAccountPasswordResult.h"
#include "model/QueryHBaseHaDBRequest.h"
#include "model/QueryHBaseHaDBResult.h"
#include "model/QueryXpackRelateDBRequest.h"
#include "model/QueryXpackRelateDBResult.h"
#include "model/RenewInstanceRequest.h"
@@ -62,6 +76,12 @@
#include "model/ResizeNodeCountResult.h"
#include "model/RestartInstanceRequest.h"
#include "model/RestartInstanceResult.h"
#include "model/SwitchHbaseHaSlbRequest.h"
#include "model/SwitchHbaseHaSlbResult.h"
#include "model/TagResourcesRequest.h"
#include "model/TagResourcesResult.h"
#include "model/UnTagResourcesRequest.h"
#include "model/UnTagResourcesResult.h"
#include "model/XpackRelateDBRequest.h"
#include "model/XpackRelateDBResult.h"
@@ -79,21 +99,33 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ConvertInstanceResult> ConvertInstanceOutcome;
typedef std::future<ConvertInstanceOutcome> ConvertInstanceOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::ConvertInstanceRequest&, const ConvertInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ConvertInstanceAsyncHandler;
typedef Outcome<Error, Model::CreateHbaseHaSlbResult> CreateHbaseHaSlbOutcome;
typedef std::future<CreateHbaseHaSlbOutcome> CreateHbaseHaSlbOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::CreateHbaseHaSlbRequest&, const CreateHbaseHaSlbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateHbaseHaSlbAsyncHandler;
typedef Outcome<Error, Model::CreateInstanceResult> CreateInstanceOutcome;
typedef std::future<CreateInstanceOutcome> CreateInstanceOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::CreateInstanceRequest&, const CreateInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateInstanceAsyncHandler;
typedef Outcome<Error, Model::DeleteHbaseHaSlbResult> DeleteHbaseHaSlbOutcome;
typedef std::future<DeleteHbaseHaSlbOutcome> DeleteHbaseHaSlbOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::DeleteHbaseHaSlbRequest&, const DeleteHbaseHaSlbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteHbaseHaSlbAsyncHandler;
typedef Outcome<Error, Model::DeleteInstanceResult> DeleteInstanceOutcome;
typedef std::future<DeleteInstanceOutcome> DeleteInstanceOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::DeleteInstanceRequest&, const DeleteInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteInstanceAsyncHandler;
typedef Outcome<Error, Model::DeleteUserHdfsInfoResult> DeleteUserHdfsInfoOutcome;
typedef std::future<DeleteUserHdfsInfoOutcome> DeleteUserHdfsInfoOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::DeleteUserHdfsInfoRequest&, const DeleteUserHdfsInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteUserHdfsInfoAsyncHandler;
typedef Outcome<Error, Model::DescribeDBInstanceUsageResult> DescribeDBInstanceUsageOutcome;
typedef std::future<DescribeDBInstanceUsageOutcome> DescribeDBInstanceUsageOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::DescribeDBInstanceUsageRequest&, const DescribeDBInstanceUsageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInstanceUsageAsyncHandler;
typedef Outcome<Error, Model::DescribeEndpointsResult> DescribeEndpointsOutcome;
typedef std::future<DescribeEndpointsOutcome> DescribeEndpointsOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::DescribeEndpointsRequest&, const DescribeEndpointsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeEndpointsAsyncHandler;
typedef Outcome<Error, Model::DescribeInstanceResult> DescribeInstanceOutcome;
typedef std::future<DescribeInstanceOutcome> DescribeInstanceOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::DescribeInstanceRequest&, const DescribeInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeInstanceAsyncHandler;
typedef Outcome<Error, Model::DescribeInstanceTypeResult> DescribeInstanceTypeOutcome;
typedef std::future<DescribeInstanceTypeOutcome> DescribeInstanceTypeOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::DescribeInstanceTypeRequest&, const DescribeInstanceTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeInstanceTypeAsyncHandler;
typedef Outcome<Error, Model::DescribeInstancesResult> DescribeInstancesOutcome;
typedef std::future<DescribeInstancesOutcome> DescribeInstancesOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::DescribeInstancesRequest&, const DescribeInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeInstancesAsyncHandler;
@@ -106,6 +138,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeSecurityGroupsResult> DescribeSecurityGroupsOutcome;
typedef std::future<DescribeSecurityGroupsOutcome> DescribeSecurityGroupsOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::DescribeSecurityGroupsRequest&, const DescribeSecurityGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSecurityGroupsAsyncHandler;
typedef Outcome<Error, Model::ListTagResourcesResult> ListTagResourcesOutcome;
typedef std::future<ListTagResourcesOutcome> ListTagResourcesOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::ListTagResourcesRequest&, const ListTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagResourcesAsyncHandler;
typedef Outcome<Error, Model::ModifyInstanceMaintainTimeResult> ModifyInstanceMaintainTimeOutcome;
typedef std::future<ModifyInstanceMaintainTimeOutcome> ModifyInstanceMaintainTimeOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::ModifyInstanceMaintainTimeRequest&, const ModifyInstanceMaintainTimeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyInstanceMaintainTimeAsyncHandler;
typedef Outcome<Error, Model::ModifyInstanceNameResult> ModifyInstanceNameOutcome;
typedef std::future<ModifyInstanceNameOutcome> ModifyInstanceNameOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::ModifyInstanceNameRequest&, const ModifyInstanceNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyInstanceNameAsyncHandler;
@@ -118,6 +156,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ModifyUIAccountPasswordResult> ModifyUIAccountPasswordOutcome;
typedef std::future<ModifyUIAccountPasswordOutcome> ModifyUIAccountPasswordOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::ModifyUIAccountPasswordRequest&, const ModifyUIAccountPasswordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyUIAccountPasswordAsyncHandler;
typedef Outcome<Error, Model::QueryHBaseHaDBResult> QueryHBaseHaDBOutcome;
typedef std::future<QueryHBaseHaDBOutcome> QueryHBaseHaDBOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::QueryHBaseHaDBRequest&, const QueryHBaseHaDBOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryHBaseHaDBAsyncHandler;
typedef Outcome<Error, Model::QueryXpackRelateDBResult> QueryXpackRelateDBOutcome;
typedef std::future<QueryXpackRelateDBOutcome> QueryXpackRelateDBOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::QueryXpackRelateDBRequest&, const QueryXpackRelateDBOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryXpackRelateDBAsyncHandler;
@@ -133,6 +174,15 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::RestartInstanceResult> RestartInstanceOutcome;
typedef std::future<RestartInstanceOutcome> RestartInstanceOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::RestartInstanceRequest&, const RestartInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RestartInstanceAsyncHandler;
typedef Outcome<Error, Model::SwitchHbaseHaSlbResult> SwitchHbaseHaSlbOutcome;
typedef std::future<SwitchHbaseHaSlbOutcome> SwitchHbaseHaSlbOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::SwitchHbaseHaSlbRequest&, const SwitchHbaseHaSlbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SwitchHbaseHaSlbAsyncHandler;
typedef Outcome<Error, Model::TagResourcesResult> TagResourcesOutcome;
typedef std::future<TagResourcesOutcome> TagResourcesOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::TagResourcesRequest&, const TagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TagResourcesAsyncHandler;
typedef Outcome<Error, Model::UnTagResourcesResult> UnTagResourcesOutcome;
typedef std::future<UnTagResourcesOutcome> UnTagResourcesOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::UnTagResourcesRequest&, const UnTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnTagResourcesAsyncHandler;
typedef Outcome<Error, Model::XpackRelateDBResult> XpackRelateDBOutcome;
typedef std::future<XpackRelateDBOutcome> XpackRelateDBOutcomeCallable;
typedef std::function<void(const HBaseClient*, const Model::XpackRelateDBRequest&, const XpackRelateDBOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> XpackRelateDBAsyncHandler;
@@ -147,21 +197,33 @@ namespace AlibabaCloud
ConvertInstanceOutcome convertInstance(const Model::ConvertInstanceRequest &request)const;
void convertInstanceAsync(const Model::ConvertInstanceRequest& request, const ConvertInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ConvertInstanceOutcomeCallable convertInstanceCallable(const Model::ConvertInstanceRequest& request) const;
CreateHbaseHaSlbOutcome createHbaseHaSlb(const Model::CreateHbaseHaSlbRequest &request)const;
void createHbaseHaSlbAsync(const Model::CreateHbaseHaSlbRequest& request, const CreateHbaseHaSlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateHbaseHaSlbOutcomeCallable createHbaseHaSlbCallable(const Model::CreateHbaseHaSlbRequest& request) const;
CreateInstanceOutcome createInstance(const Model::CreateInstanceRequest &request)const;
void createInstanceAsync(const Model::CreateInstanceRequest& request, const CreateInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateInstanceOutcomeCallable createInstanceCallable(const Model::CreateInstanceRequest& request) const;
DeleteHbaseHaSlbOutcome deleteHbaseHaSlb(const Model::DeleteHbaseHaSlbRequest &request)const;
void deleteHbaseHaSlbAsync(const Model::DeleteHbaseHaSlbRequest& request, const DeleteHbaseHaSlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteHbaseHaSlbOutcomeCallable deleteHbaseHaSlbCallable(const Model::DeleteHbaseHaSlbRequest& request) const;
DeleteInstanceOutcome deleteInstance(const Model::DeleteInstanceRequest &request)const;
void deleteInstanceAsync(const Model::DeleteInstanceRequest& request, const DeleteInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteInstanceOutcomeCallable deleteInstanceCallable(const Model::DeleteInstanceRequest& request) const;
DeleteUserHdfsInfoOutcome deleteUserHdfsInfo(const Model::DeleteUserHdfsInfoRequest &request)const;
void deleteUserHdfsInfoAsync(const Model::DeleteUserHdfsInfoRequest& request, const DeleteUserHdfsInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteUserHdfsInfoOutcomeCallable deleteUserHdfsInfoCallable(const Model::DeleteUserHdfsInfoRequest& request) const;
DescribeDBInstanceUsageOutcome describeDBInstanceUsage(const Model::DescribeDBInstanceUsageRequest &request)const;
void describeDBInstanceUsageAsync(const Model::DescribeDBInstanceUsageRequest& request, const DescribeDBInstanceUsageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBInstanceUsageOutcomeCallable describeDBInstanceUsageCallable(const Model::DescribeDBInstanceUsageRequest& request) const;
DescribeEndpointsOutcome describeEndpoints(const Model::DescribeEndpointsRequest &request)const;
void describeEndpointsAsync(const Model::DescribeEndpointsRequest& request, const DescribeEndpointsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeEndpointsOutcomeCallable describeEndpointsCallable(const Model::DescribeEndpointsRequest& request) const;
DescribeInstanceOutcome describeInstance(const Model::DescribeInstanceRequest &request)const;
void describeInstanceAsync(const Model::DescribeInstanceRequest& request, const DescribeInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeInstanceOutcomeCallable describeInstanceCallable(const Model::DescribeInstanceRequest& request) const;
DescribeInstanceTypeOutcome describeInstanceType(const Model::DescribeInstanceTypeRequest &request)const;
void describeInstanceTypeAsync(const Model::DescribeInstanceTypeRequest& request, const DescribeInstanceTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeInstanceTypeOutcomeCallable describeInstanceTypeCallable(const Model::DescribeInstanceTypeRequest& request) const;
DescribeInstancesOutcome describeInstances(const Model::DescribeInstancesRequest &request)const;
void describeInstancesAsync(const Model::DescribeInstancesRequest& request, const DescribeInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeInstancesOutcomeCallable describeInstancesCallable(const Model::DescribeInstancesRequest& request) const;
@@ -174,6 +236,12 @@ namespace AlibabaCloud
DescribeSecurityGroupsOutcome describeSecurityGroups(const Model::DescribeSecurityGroupsRequest &request)const;
void describeSecurityGroupsAsync(const Model::DescribeSecurityGroupsRequest& request, const DescribeSecurityGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeSecurityGroupsOutcomeCallable describeSecurityGroupsCallable(const Model::DescribeSecurityGroupsRequest& request) const;
ListTagResourcesOutcome listTagResources(const Model::ListTagResourcesRequest &request)const;
void listTagResourcesAsync(const Model::ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const;
ModifyInstanceMaintainTimeOutcome modifyInstanceMaintainTime(const Model::ModifyInstanceMaintainTimeRequest &request)const;
void modifyInstanceMaintainTimeAsync(const Model::ModifyInstanceMaintainTimeRequest& request, const ModifyInstanceMaintainTimeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyInstanceMaintainTimeOutcomeCallable modifyInstanceMaintainTimeCallable(const Model::ModifyInstanceMaintainTimeRequest& request) const;
ModifyInstanceNameOutcome modifyInstanceName(const Model::ModifyInstanceNameRequest &request)const;
void modifyInstanceNameAsync(const Model::ModifyInstanceNameRequest& request, const ModifyInstanceNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyInstanceNameOutcomeCallable modifyInstanceNameCallable(const Model::ModifyInstanceNameRequest& request) const;
@@ -186,6 +254,9 @@ namespace AlibabaCloud
ModifyUIAccountPasswordOutcome modifyUIAccountPassword(const Model::ModifyUIAccountPasswordRequest &request)const;
void modifyUIAccountPasswordAsync(const Model::ModifyUIAccountPasswordRequest& request, const ModifyUIAccountPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyUIAccountPasswordOutcomeCallable modifyUIAccountPasswordCallable(const Model::ModifyUIAccountPasswordRequest& request) const;
QueryHBaseHaDBOutcome queryHBaseHaDB(const Model::QueryHBaseHaDBRequest &request)const;
void queryHBaseHaDBAsync(const Model::QueryHBaseHaDBRequest& request, const QueryHBaseHaDBAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryHBaseHaDBOutcomeCallable queryHBaseHaDBCallable(const Model::QueryHBaseHaDBRequest& request) const;
QueryXpackRelateDBOutcome queryXpackRelateDB(const Model::QueryXpackRelateDBRequest &request)const;
void queryXpackRelateDBAsync(const Model::QueryXpackRelateDBRequest& request, const QueryXpackRelateDBAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryXpackRelateDBOutcomeCallable queryXpackRelateDBCallable(const Model::QueryXpackRelateDBRequest& request) const;
@@ -201,6 +272,15 @@ namespace AlibabaCloud
RestartInstanceOutcome restartInstance(const Model::RestartInstanceRequest &request)const;
void restartInstanceAsync(const Model::RestartInstanceRequest& request, const RestartInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RestartInstanceOutcomeCallable restartInstanceCallable(const Model::RestartInstanceRequest& request) const;
SwitchHbaseHaSlbOutcome switchHbaseHaSlb(const Model::SwitchHbaseHaSlbRequest &request)const;
void switchHbaseHaSlbAsync(const Model::SwitchHbaseHaSlbRequest& request, const SwitchHbaseHaSlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SwitchHbaseHaSlbOutcomeCallable switchHbaseHaSlbCallable(const Model::SwitchHbaseHaSlbRequest& request) const;
TagResourcesOutcome tagResources(const Model::TagResourcesRequest &request)const;
void tagResourcesAsync(const Model::TagResourcesRequest& request, const TagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
TagResourcesOutcomeCallable tagResourcesCallable(const Model::TagResourcesRequest& request) const;
UnTagResourcesOutcome unTagResources(const Model::UnTagResourcesRequest &request)const;
void unTagResourcesAsync(const Model::UnTagResourcesRequest& request, const UnTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UnTagResourcesOutcomeCallable unTagResourcesCallable(const Model::UnTagResourcesRequest& request) const;
XpackRelateDBOutcome xpackRelateDB(const Model::XpackRelateDBRequest &request)const;
void xpackRelateDBAsync(const Model::XpackRelateDBRequest& request, const XpackRelateDBAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
XpackRelateDBOutcomeCallable xpackRelateDBCallable(const Model::XpackRelateDBRequest& request) const;

57
hbase/include/alibabacloud/hbase/model/CreateHbaseHaSlbRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_HBASE_MODEL_CREATEHBASEHASLBREQUEST_H_
#define ALIBABACLOUD_HBASE_MODEL_CREATEHBASEHASLBREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/hbase/HBaseExport.h>
namespace AlibabaCloud
{
namespace HBase
{
namespace Model
{
class ALIBABACLOUD_HBASE_EXPORT CreateHbaseHaSlbRequest : public RpcServiceRequest
{
public:
CreateHbaseHaSlbRequest();
~CreateHbaseHaSlbRequest();
std::string getHaTypes()const;
void setHaTypes(const std::string& haTypes);
std::string getHbaseType()const;
void setHbaseType(const std::string& hbaseType);
std::string getBdsId()const;
void setBdsId(const std::string& bdsId);
std::string getHaId()const;
void setHaId(const std::string& haId);
private:
std::string haTypes_;
std::string hbaseType_;
std::string bdsId_;
std::string haId_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_CREATEHBASEHASLBREQUEST_H_

49
hbase/include/alibabacloud/hbase/model/CreateHbaseHaSlbResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_HBASE_MODEL_CREATEHBASEHASLBRESULT_H_
#define ALIBABACLOUD_HBASE_MODEL_CREATEHBASEHASLBRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/hbase/HBaseExport.h>
namespace AlibabaCloud
{
namespace HBase
{
namespace Model
{
class ALIBABACLOUD_HBASE_EXPORT CreateHbaseHaSlbResult : public ServiceResult
{
public:
CreateHbaseHaSlbResult();
explicit CreateHbaseHaSlbResult(const std::string &payload);
~CreateHbaseHaSlbResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_CREATEHBASEHASLBRESULT_H_

54
hbase/include/alibabacloud/hbase/model/DeleteHbaseHaSlbRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* 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_HBASE_MODEL_DELETEHBASEHASLBREQUEST_H_
#define ALIBABACLOUD_HBASE_MODEL_DELETEHBASEHASLBREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/hbase/HBaseExport.h>
namespace AlibabaCloud
{
namespace HBase
{
namespace Model
{
class ALIBABACLOUD_HBASE_EXPORT DeleteHbaseHaSlbRequest : public RpcServiceRequest
{
public:
DeleteHbaseHaSlbRequest();
~DeleteHbaseHaSlbRequest();
std::string getHaId()const;
void setHaId(const std::string& haId);
std::string getHaTypes()const;
void setHaTypes(const std::string& haTypes);
std::string getBdsId()const;
void setBdsId(const std::string& bdsId);
private:
std::string haId_;
std::string haTypes_;
std::string bdsId_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_DELETEHBASEHASLBREQUEST_H_

49
hbase/include/alibabacloud/hbase/model/DeleteHbaseHaSlbResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_HBASE_MODEL_DELETEHBASEHASLBRESULT_H_
#define ALIBABACLOUD_HBASE_MODEL_DELETEHBASEHASLBRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/hbase/HBaseExport.h>
namespace AlibabaCloud
{
namespace HBase
{
namespace Model
{
class ALIBABACLOUD_HBASE_EXPORT DeleteHbaseHaSlbResult : public ServiceResult
{
public:
DeleteHbaseHaSlbResult();
explicit DeleteHbaseHaSlbResult(const std::string &payload);
~DeleteHbaseHaSlbResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_DELETEHBASEHASLBRESULT_H_

48
hbase/include/alibabacloud/hbase/model/DescribeDBInstanceUsageRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* 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_HBASE_MODEL_DESCRIBEDBINSTANCEUSAGEREQUEST_H_
#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEDBINSTANCEUSAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/hbase/HBaseExport.h>
namespace AlibabaCloud
{
namespace HBase
{
namespace Model
{
class ALIBABACLOUD_HBASE_EXPORT DescribeDBInstanceUsageRequest : public RpcServiceRequest
{
public:
DescribeDBInstanceUsageRequest();
~DescribeDBInstanceUsageRequest();
std::string getClusterId()const;
void setClusterId(const std::string& clusterId);
private:
std::string clusterId_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEDBINSTANCEUSAGEREQUEST_H_

51
hbase/include/alibabacloud/hbase/model/DescribeDBInstanceUsageResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_HBASE_MODEL_DESCRIBEDBINSTANCEUSAGERESULT_H_
#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEDBINSTANCEUSAGERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/hbase/HBaseExport.h>
namespace AlibabaCloud
{
namespace HBase
{
namespace Model
{
class ALIBABACLOUD_HBASE_EXPORT DescribeDBInstanceUsageResult : public ServiceResult
{
public:
DescribeDBInstanceUsageResult();
explicit DescribeDBInstanceUsageResult(const std::string &payload);
~DescribeDBInstanceUsageResult();
std::string getResult()const;
protected:
void parse(const std::string &payload);
private:
std::string result_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEDBINSTANCEUSAGERESULT_H_

4
hbase/include/alibabacloud/hbase/model/DescribeInstanceResult.h
View File

@@ -45,11 +45,13 @@ namespace AlibabaCloud
bool getIsHa()const;
std::string getCreatedTime()const;
std::string getMasterInstanceType()const;
std::string getMaintainEndTime()const;
std::string getNetworkType()const;
std::string getCoreInstanceType()const;
std::string getMasterDiskType()const;
std::vector<Tag> getTags()const;
std::string getEngine()const;
std::string getMaintainStartTime()const;
std::string getStatus()const;
std::string getMajorVersion()const;
std::string getCoreDiskCount()const;
@@ -76,11 +78,13 @@ namespace AlibabaCloud
bool isHa_;
std::string createdTime_;
std::string masterInstanceType_;
std::string maintainEndTime_;
std::string networkType_;
std::string coreInstanceType_;
std::string masterDiskType_;
std::vector<Tag> tags_;
std::string engine_;
std::string maintainStartTime_;
std::string status_;
std::string majorVersion_;
std::string coreDiskCount_;

48
hbase/include/alibabacloud/hbase/model/DescribeInstanceTypeRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* 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_HBASE_MODEL_DESCRIBEINSTANCETYPEREQUEST_H_
#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCETYPEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/hbase/HBaseExport.h>
namespace AlibabaCloud
{
namespace HBase
{
namespace Model
{
class ALIBABACLOUD_HBASE_EXPORT DescribeInstanceTypeRequest : public RpcServiceRequest
{
public:
DescribeInstanceTypeRequest();
~DescribeInstanceTypeRequest();
std::string getInstanceType()const;
void setInstanceType(const std::string& instanceType);
private:
std::string instanceType_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCETYPEREQUEST_H_

57
hbase/include/alibabacloud/hbase/model/DescribeInstanceTypeResult.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCETYPERESULT_H_
#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCETYPERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/hbase/HBaseExport.h>
namespace AlibabaCloud
{
namespace HBase
{
namespace Model
{
class ALIBABACLOUD_HBASE_EXPORT DescribeInstanceTypeResult : public ServiceResult
{
public:
struct InstanceTypeSpec
{
long cpuSize;
long memSize;
std::string instanceType;
};
DescribeInstanceTypeResult();
explicit DescribeInstanceTypeResult(const std::string &payload);
~DescribeInstanceTypeResult();
std::vector<InstanceTypeSpec> getInstanceTypeSpecList()const;
protected:
void parse(const std::string &payload);
private:
std::vector<InstanceTypeSpec> instanceTypeSpecList_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEINSTANCETYPERESULT_H_

62
hbase/include/alibabacloud/hbase/model/ListTagResourcesRequest.h Normal file
View File

@@ -0,0 +1,62 @@
/*
* 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_HBASE_MODEL_LISTTAGRESOURCESREQUEST_H_
#define ALIBABACLOUD_HBASE_MODEL_LISTTAGRESOURCESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/hbase/HBaseExport.h>
namespace AlibabaCloud
{
namespace HBase
{
namespace Model
{
class ALIBABACLOUD_HBASE_EXPORT ListTagResourcesRequest : public RpcServiceRequest
{
struct Tag
{
std::string value;
std::string key;
};
public:
ListTagResourcesRequest();
~ListTagResourcesRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
std::vector<Tag> getTag()const;
void setTag(const std::vector<Tag>& tag);
std::vector<std::string> getResourceId()const;
void setResourceId(const std::vector<std::string>& resourceId);
private:
std::string regionId_;
std::string nextToken_;
std::vector<Tag> tag_;
std::vector<std::string> resourceId_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_LISTTAGRESOURCESREQUEST_H_

60
hbase/include/alibabacloud/hbase/model/ListTagResourcesResult.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_HBASE_MODEL_LISTTAGRESOURCESRESULT_H_
#define ALIBABACLOUD_HBASE_MODEL_LISTTAGRESOURCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/hbase/HBaseExport.h>
namespace AlibabaCloud
{
namespace HBase
{
namespace Model
{
class ALIBABACLOUD_HBASE_EXPORT ListTagResourcesResult : public ServiceResult
{
public:
struct TagResource
{
std::string resourceId;
std::string tagKey;
std::string resourceType;
std::string tagValue;
};
ListTagResourcesResult();
explicit ListTagResourcesResult(const std::string &payload);
~ListTagResourcesResult();
std::string getNextToken()const;
std::vector<TagResource> getTagResources()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
std::vector<TagResource> tagResources_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_LISTTAGRESOURCESRESULT_H_

54
hbase/include/alibabacloud/hbase/model/ModifyInstanceMaintainTimeRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* 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_HBASE_MODEL_MODIFYINSTANCEMAINTAINTIMEREQUEST_H_
#define ALIBABACLOUD_HBASE_MODEL_MODIFYINSTANCEMAINTAINTIMEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/hbase/HBaseExport.h>
namespace AlibabaCloud
{
namespace HBase
{
namespace Model
{
class ALIBABACLOUD_HBASE_EXPORT ModifyInstanceMaintainTimeRequest : public RpcServiceRequest
{
public:
ModifyInstanceMaintainTimeRequest();
~ModifyInstanceMaintainTimeRequest();
std::string getClusterId()const;
void setClusterId(const std::string& clusterId);
std::string getMaintainEndTime()const;
void setMaintainEndTime(const std::string& maintainEndTime);
std::string getMaintainStartTime()const;
void setMaintainStartTime(const std::string& maintainStartTime);
private:
std::string clusterId_;
std::string maintainEndTime_;
std::string maintainStartTime_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYINSTANCEMAINTAINTIMEREQUEST_H_

49
hbase/include/alibabacloud/hbase/model/ModifyInstanceMaintainTimeResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_HBASE_MODEL_MODIFYINSTANCEMAINTAINTIMERESULT_H_
#define ALIBABACLOUD_HBASE_MODEL_MODIFYINSTANCEMAINTAINTIMERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/hbase/HBaseExport.h>
namespace AlibabaCloud
{
namespace HBase
{
namespace Model
{
class ALIBABACLOUD_HBASE_EXPORT ModifyInstanceMaintainTimeResult : public ServiceResult
{
public:
ModifyInstanceMaintainTimeResult();
explicit ModifyInstanceMaintainTimeResult(const std::string &payload);
~ModifyInstanceMaintainTimeResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_MODIFYINSTANCEMAINTAINTIMERESULT_H_

48
hbase/include/alibabacloud/hbase/model/QueryHBaseHaDBRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* 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_HBASE_MODEL_QUERYHBASEHADBREQUEST_H_
#define ALIBABACLOUD_HBASE_MODEL_QUERYHBASEHADBREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/hbase/HBaseExport.h>
namespace AlibabaCloud
{
namespace HBase
{
namespace Model
{
class ALIBABACLOUD_HBASE_EXPORT QueryHBaseHaDBRequest : public RpcServiceRequest
{
public:
QueryHBaseHaDBRequest();
~QueryHBaseHaDBRequest();
std::string getBdsId()const;
void setBdsId(const std::string& bdsId);
private:
std::string bdsId_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_QUERYHBASEHADBREQUEST_H_

71
hbase/include/alibabacloud/hbase/model/QueryHBaseHaDBResult.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* 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_HBASE_MODEL_QUERYHBASEHADBRESULT_H_
#define ALIBABACLOUD_HBASE_MODEL_QUERYHBASEHADBRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/hbase/HBaseExport.h>
namespace AlibabaCloud
{
namespace HBase
{
namespace Model
{
class ALIBABACLOUD_HBASE_EXPORT QueryHBaseHaDBResult : public ServiceResult
{
public:
struct Cluster
{
struct HaSlbConn
{
std::string hbaseType;
std::string slbType;
std::string slbConnAddr;
};
std::string activeName;
std::string bdsName;
std::string haName;
std::string standbyName;
std::vector<Cluster::HaSlbConn> haSlbConnList;
};
QueryHBaseHaDBResult();
explicit QueryHBaseHaDBResult(const std::string &payload);
~QueryHBaseHaDBResult();
long getTotalCount()const;
std::vector<Cluster> getClusterList()const;
int getPageSize()const;
int getPageNumber()const;
protected:
void parse(const std::string &payload);
private:
long totalCount_;
std::vector<Cluster> clusterList_;
int pageSize_;
int pageNumber_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_QUERYHBASEHADBRESULT_H_

57
hbase/include/alibabacloud/hbase/model/SwitchHbaseHaSlbRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_HBASE_MODEL_SWITCHHBASEHASLBREQUEST_H_
#define ALIBABACLOUD_HBASE_MODEL_SWITCHHBASEHASLBREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/hbase/HBaseExport.h>
namespace AlibabaCloud
{
namespace HBase
{
namespace Model
{
class ALIBABACLOUD_HBASE_EXPORT SwitchHbaseHaSlbRequest : public RpcServiceRequest
{
public:
SwitchHbaseHaSlbRequest();
~SwitchHbaseHaSlbRequest();
std::string getHaTypes()const;
void setHaTypes(const std::string& haTypes);
std::string getHbaseType()const;
void setHbaseType(const std::string& hbaseType);
std::string getBdsId()const;
void setBdsId(const std::string& bdsId);
std::string getHaId()const;
void setHaId(const std::string& haId);
private:
std::string haTypes_;
std::string hbaseType_;
std::string bdsId_;
std::string haId_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_SWITCHHBASEHASLBREQUEST_H_

49
hbase/include/alibabacloud/hbase/model/SwitchHbaseHaSlbResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_HBASE_MODEL_SWITCHHBASEHASLBRESULT_H_
#define ALIBABACLOUD_HBASE_MODEL_SWITCHHBASEHASLBRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/hbase/HBaseExport.h>
namespace AlibabaCloud
{
namespace HBase
{
namespace Model
{
class ALIBABACLOUD_HBASE_EXPORT SwitchHbaseHaSlbResult : public ServiceResult
{
public:
SwitchHbaseHaSlbResult();
explicit SwitchHbaseHaSlbResult(const std::string &payload);
~SwitchHbaseHaSlbResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_SWITCHHBASEHASLBRESULT_H_

59
hbase/include/alibabacloud/hbase/model/TagResourcesRequest.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* 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_HBASE_MODEL_TAGRESOURCESREQUEST_H_
#define ALIBABACLOUD_HBASE_MODEL_TAGRESOURCESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/hbase/HBaseExport.h>
namespace AlibabaCloud
{
namespace HBase
{
namespace Model
{
class ALIBABACLOUD_HBASE_EXPORT TagResourcesRequest : public RpcServiceRequest
{
struct Tag
{
std::string value;
std::string key;
};
public:
TagResourcesRequest();
~TagResourcesRequest();
std::vector<std::string> getResourceId()const;
void setResourceId(const std::vector<std::string>& resourceId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::vector<Tag> getTag()const;
void setTag(const std::vector<Tag>& tag);
private:
std::vector<std::string> resourceId_;
std::string regionId_;
std::vector<Tag> tag_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_TAGRESOURCESREQUEST_H_

49
hbase/include/alibabacloud/hbase/model/TagResourcesResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_HBASE_MODEL_TAGRESOURCESRESULT_H_
#define ALIBABACLOUD_HBASE_MODEL_TAGRESOURCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/hbase/HBaseExport.h>
namespace AlibabaCloud
{
namespace HBase
{
namespace Model
{
class ALIBABACLOUD_HBASE_EXPORT TagResourcesResult : public ServiceResult
{
public:
TagResourcesResult();
explicit TagResourcesResult(const std::string &payload);
~TagResourcesResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_TAGRESOURCESRESULT_H_

57
hbase/include/alibabacloud/hbase/model/UnTagResourcesRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_HBASE_MODEL_UNTAGRESOURCESREQUEST_H_
#define ALIBABACLOUD_HBASE_MODEL_UNTAGRESOURCESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/hbase/HBaseExport.h>
namespace AlibabaCloud
{
namespace HBase
{
namespace Model
{
class ALIBABACLOUD_HBASE_EXPORT UnTagResourcesRequest : public RpcServiceRequest
{
public:
UnTagResourcesRequest();
~UnTagResourcesRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getAll()const;
void setAll(bool all);
std::vector<std::string> getResourceId()const;
void setResourceId(const std::vector<std::string>& resourceId);
std::vector<std::string> getTagKey()const;
void setTagKey(const std::vector<std::string>& tagKey);
private:
std::string regionId_;
bool all_;
std::vector<std::string> resourceId_;
std::vector<std::string> tagKey_;
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_UNTAGRESOURCESREQUEST_H_

49
hbase/include/alibabacloud/hbase/model/UnTagResourcesResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_HBASE_MODEL_UNTAGRESOURCESRESULT_H_
#define ALIBABACLOUD_HBASE_MODEL_UNTAGRESOURCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/hbase/HBaseExport.h>
namespace AlibabaCloud
{
namespace HBase
{
namespace Model
{
class ALIBABACLOUD_HBASE_EXPORT UnTagResourcesResult : public ServiceResult
{
public:
UnTagResourcesResult();
explicit UnTagResourcesResult(const std::string &payload);
~UnTagResourcesResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_HBASE_MODEL_UNTAGRESOURCESRESULT_H_

360
hbase/src/HBaseClient.cc
View File

@@ -123,6 +123,42 @@ HBaseClient::ConvertInstanceOutcomeCallable HBaseClient::convertInstanceCallable
return task->get_future();
}
HBaseClient::CreateHbaseHaSlbOutcome HBaseClient::createHbaseHaSlb(const CreateHbaseHaSlbRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateHbaseHaSlbOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateHbaseHaSlbOutcome(CreateHbaseHaSlbResult(outcome.result()));
else
return CreateHbaseHaSlbOutcome(outcome.error());
}
void HBaseClient::createHbaseHaSlbAsync(const CreateHbaseHaSlbRequest& request, const CreateHbaseHaSlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createHbaseHaSlb(request), context);
};
asyncExecute(new Runnable(fn));
}
HBaseClient::CreateHbaseHaSlbOutcomeCallable HBaseClient::createHbaseHaSlbCallable(const CreateHbaseHaSlbRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateHbaseHaSlbOutcome()>>(
[this, request]()
{
return this->createHbaseHaSlb(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
HBaseClient::CreateInstanceOutcome HBaseClient::createInstance(const CreateInstanceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -159,6 +195,42 @@ HBaseClient::CreateInstanceOutcomeCallable HBaseClient::createInstanceCallable(c
return task->get_future();
}
HBaseClient::DeleteHbaseHaSlbOutcome HBaseClient::deleteHbaseHaSlb(const DeleteHbaseHaSlbRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteHbaseHaSlbOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteHbaseHaSlbOutcome(DeleteHbaseHaSlbResult(outcome.result()));
else
return DeleteHbaseHaSlbOutcome(outcome.error());
}
void HBaseClient::deleteHbaseHaSlbAsync(const DeleteHbaseHaSlbRequest& request, const DeleteHbaseHaSlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteHbaseHaSlb(request), context);
};
asyncExecute(new Runnable(fn));
}
HBaseClient::DeleteHbaseHaSlbOutcomeCallable HBaseClient::deleteHbaseHaSlbCallable(const DeleteHbaseHaSlbRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteHbaseHaSlbOutcome()>>(
[this, request]()
{
return this->deleteHbaseHaSlb(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
HBaseClient::DeleteInstanceOutcome HBaseClient::deleteInstance(const DeleteInstanceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -231,6 +303,42 @@ HBaseClient::DeleteUserHdfsInfoOutcomeCallable HBaseClient::deleteUserHdfsInfoCa
return task->get_future();
}
HBaseClient::DescribeDBInstanceUsageOutcome HBaseClient::describeDBInstanceUsage(const DescribeDBInstanceUsageRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeDBInstanceUsageOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeDBInstanceUsageOutcome(DescribeDBInstanceUsageResult(outcome.result()));
else
return DescribeDBInstanceUsageOutcome(outcome.error());
}
void HBaseClient::describeDBInstanceUsageAsync(const DescribeDBInstanceUsageRequest& request, const DescribeDBInstanceUsageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeDBInstanceUsage(request), context);
};
asyncExecute(new Runnable(fn));
}
HBaseClient::DescribeDBInstanceUsageOutcomeCallable HBaseClient::describeDBInstanceUsageCallable(const DescribeDBInstanceUsageRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeDBInstanceUsageOutcome()>>(
[this, request]()
{
return this->describeDBInstanceUsage(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
HBaseClient::DescribeEndpointsOutcome HBaseClient::describeEndpoints(const DescribeEndpointsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -303,6 +411,42 @@ HBaseClient::DescribeInstanceOutcomeCallable HBaseClient::describeInstanceCallab
return task->get_future();
}
HBaseClient::DescribeInstanceTypeOutcome HBaseClient::describeInstanceType(const DescribeInstanceTypeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeInstanceTypeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeInstanceTypeOutcome(DescribeInstanceTypeResult(outcome.result()));
else
return DescribeInstanceTypeOutcome(outcome.error());
}
void HBaseClient::describeInstanceTypeAsync(const DescribeInstanceTypeRequest& request, const DescribeInstanceTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeInstanceType(request), context);
};
asyncExecute(new Runnable(fn));
}
HBaseClient::DescribeInstanceTypeOutcomeCallable HBaseClient::describeInstanceTypeCallable(const DescribeInstanceTypeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeInstanceTypeOutcome()>>(
[this, request]()
{
return this->describeInstanceType(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
HBaseClient::DescribeInstancesOutcome HBaseClient::describeInstances(const DescribeInstancesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -447,6 +591,78 @@ HBaseClient::DescribeSecurityGroupsOutcomeCallable HBaseClient::describeSecurity
return task->get_future();
}
HBaseClient::ListTagResourcesOutcome HBaseClient::listTagResources(const ListTagResourcesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListTagResourcesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListTagResourcesOutcome(ListTagResourcesResult(outcome.result()));
else
return ListTagResourcesOutcome(outcome.error());
}
void HBaseClient::listTagResourcesAsync(const ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listTagResources(request), context);
};
asyncExecute(new Runnable(fn));
}
HBaseClient::ListTagResourcesOutcomeCallable HBaseClient::listTagResourcesCallable(const ListTagResourcesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListTagResourcesOutcome()>>(
[this, request]()
{
return this->listTagResources(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
HBaseClient::ModifyInstanceMaintainTimeOutcome HBaseClient::modifyInstanceMaintainTime(const ModifyInstanceMaintainTimeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyInstanceMaintainTimeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyInstanceMaintainTimeOutcome(ModifyInstanceMaintainTimeResult(outcome.result()));
else
return ModifyInstanceMaintainTimeOutcome(outcome.error());
}
void HBaseClient::modifyInstanceMaintainTimeAsync(const ModifyInstanceMaintainTimeRequest& request, const ModifyInstanceMaintainTimeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyInstanceMaintainTime(request), context);
};
asyncExecute(new Runnable(fn));
}
HBaseClient::ModifyInstanceMaintainTimeOutcomeCallable HBaseClient::modifyInstanceMaintainTimeCallable(const ModifyInstanceMaintainTimeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyInstanceMaintainTimeOutcome()>>(
[this, request]()
{
return this->modifyInstanceMaintainTime(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
HBaseClient::ModifyInstanceNameOutcome HBaseClient::modifyInstanceName(const ModifyInstanceNameRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -591,6 +807,42 @@ HBaseClient::ModifyUIAccountPasswordOutcomeCallable HBaseClient::modifyUIAccount
return task->get_future();
}
HBaseClient::QueryHBaseHaDBOutcome HBaseClient::queryHBaseHaDB(const QueryHBaseHaDBRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return QueryHBaseHaDBOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return QueryHBaseHaDBOutcome(QueryHBaseHaDBResult(outcome.result()));
else
return QueryHBaseHaDBOutcome(outcome.error());
}
void HBaseClient::queryHBaseHaDBAsync(const QueryHBaseHaDBRequest& request, const QueryHBaseHaDBAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, queryHBaseHaDB(request), context);
};
asyncExecute(new Runnable(fn));
}
HBaseClient::QueryHBaseHaDBOutcomeCallable HBaseClient::queryHBaseHaDBCallable(const QueryHBaseHaDBRequest &request) const
{
auto task = std::make_shared<std::packaged_task<QueryHBaseHaDBOutcome()>>(
[this, request]()
{
return this->queryHBaseHaDB(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
HBaseClient::QueryXpackRelateDBOutcome HBaseClient::queryXpackRelateDB(const QueryXpackRelateDBRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -771,6 +1023,114 @@ HBaseClient::RestartInstanceOutcomeCallable HBaseClient::restartInstanceCallable
return task->get_future();
}
HBaseClient::SwitchHbaseHaSlbOutcome HBaseClient::switchHbaseHaSlb(const SwitchHbaseHaSlbRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SwitchHbaseHaSlbOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SwitchHbaseHaSlbOutcome(SwitchHbaseHaSlbResult(outcome.result()));
else
return SwitchHbaseHaSlbOutcome(outcome.error());
}
void HBaseClient::switchHbaseHaSlbAsync(const SwitchHbaseHaSlbRequest& request, const SwitchHbaseHaSlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, switchHbaseHaSlb(request), context);
};
asyncExecute(new Runnable(fn));
}
HBaseClient::SwitchHbaseHaSlbOutcomeCallable HBaseClient::switchHbaseHaSlbCallable(const SwitchHbaseHaSlbRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SwitchHbaseHaSlbOutcome()>>(
[this, request]()
{
return this->switchHbaseHaSlb(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
HBaseClient::TagResourcesOutcome HBaseClient::tagResources(const TagResourcesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return TagResourcesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return TagResourcesOutcome(TagResourcesResult(outcome.result()));
else
return TagResourcesOutcome(outcome.error());
}
void HBaseClient::tagResourcesAsync(const TagResourcesRequest& request, const TagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, tagResources(request), context);
};
asyncExecute(new Runnable(fn));
}
HBaseClient::TagResourcesOutcomeCallable HBaseClient::tagResourcesCallable(const TagResourcesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<TagResourcesOutcome()>>(
[this, request]()
{
return this->tagResources(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
HBaseClient::UnTagResourcesOutcome HBaseClient::unTagResources(const UnTagResourcesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UnTagResourcesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UnTagResourcesOutcome(UnTagResourcesResult(outcome.result()));
else
return UnTagResourcesOutcome(outcome.error());
}
void HBaseClient::unTagResourcesAsync(const UnTagResourcesRequest& request, const UnTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, unTagResources(request), context);
};
asyncExecute(new Runnable(fn));
}
HBaseClient::UnTagResourcesOutcomeCallable HBaseClient::unTagResourcesCallable(const UnTagResourcesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UnTagResourcesOutcome()>>(
[this, request]()
{
return this->unTagResources(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
HBaseClient::XpackRelateDBOutcome HBaseClient::xpackRelateDB(const XpackRelateDBRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

73
hbase/src/model/CreateHbaseHaSlbRequest.cc Normal file
View File

@@ -0,0 +1,73 @@
/*
* 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/hbase/model/CreateHbaseHaSlbRequest.h>
using AlibabaCloud::HBase::Model::CreateHbaseHaSlbRequest;
CreateHbaseHaSlbRequest::CreateHbaseHaSlbRequest() :
RpcServiceRequest("hbase", "2019-01-01", "CreateHbaseHaSlb")
{
setMethod(HttpRequest::Method::Post);
}
CreateHbaseHaSlbRequest::~CreateHbaseHaSlbRequest()
{}
std::string CreateHbaseHaSlbRequest::getHaTypes()const
{
return haTypes_;
}
void CreateHbaseHaSlbRequest::setHaTypes(const std::string& haTypes)
{
haTypes_ = haTypes;
setCoreParameter("HaTypes", haTypes);
}
std::string CreateHbaseHaSlbRequest::getHbaseType()const
{
return hbaseType_;
}
void CreateHbaseHaSlbRequest::setHbaseType(const std::string& hbaseType)
{
hbaseType_ = hbaseType;
setCoreParameter("HbaseType", hbaseType);
}
std::string CreateHbaseHaSlbRequest::getBdsId()const
{
return bdsId_;
}
void CreateHbaseHaSlbRequest::setBdsId(const std::string& bdsId)
{
bdsId_ = bdsId;
setCoreParameter("BdsId", bdsId);
}
std::string CreateHbaseHaSlbRequest::getHaId()const
{
return haId_;
}
void CreateHbaseHaSlbRequest::setHaId(const std::string& haId)
{
haId_ = haId;
setCoreParameter("HaId", haId);
}

44
hbase/src/model/CreateHbaseHaSlbResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/hbase/model/CreateHbaseHaSlbResult.h>
#include <json/json.h>
using namespace AlibabaCloud::HBase;
using namespace AlibabaCloud::HBase::Model;
CreateHbaseHaSlbResult::CreateHbaseHaSlbResult() :
ServiceResult()
{}
CreateHbaseHaSlbResult::CreateHbaseHaSlbResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateHbaseHaSlbResult::~CreateHbaseHaSlbResult()
{}
void CreateHbaseHaSlbResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

62
hbase/src/model/DeleteHbaseHaSlbRequest.cc Normal file
View File

@@ -0,0 +1,62 @@
/*
* 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/hbase/model/DeleteHbaseHaSlbRequest.h>
using AlibabaCloud::HBase::Model::DeleteHbaseHaSlbRequest;
DeleteHbaseHaSlbRequest::DeleteHbaseHaSlbRequest() :
RpcServiceRequest("hbase", "2019-01-01", "DeleteHbaseHaSlb")
{
setMethod(HttpRequest::Method::Post);
}
DeleteHbaseHaSlbRequest::~DeleteHbaseHaSlbRequest()
{}
std::string DeleteHbaseHaSlbRequest::getHaId()const
{
return haId_;
}
void DeleteHbaseHaSlbRequest::setHaId(const std::string& haId)
{
haId_ = haId;
setCoreParameter("HaId", haId);
}
std::string DeleteHbaseHaSlbRequest::getHaTypes()const
{
return haTypes_;
}
void DeleteHbaseHaSlbRequest::setHaTypes(const std::string& haTypes)
{
haTypes_ = haTypes;
setCoreParameter("HaTypes", haTypes);
}
std::string DeleteHbaseHaSlbRequest::getBdsId()const
{
return bdsId_;
}
void DeleteHbaseHaSlbRequest::setBdsId(const std::string& bdsId)
{
bdsId_ = bdsId;
setCoreParameter("BdsId", bdsId);
}

44
hbase/src/model/DeleteHbaseHaSlbResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/hbase/model/DeleteHbaseHaSlbResult.h>
#include <json/json.h>
using namespace AlibabaCloud::HBase;
using namespace AlibabaCloud::HBase::Model;
DeleteHbaseHaSlbResult::DeleteHbaseHaSlbResult() :
ServiceResult()
{}
DeleteHbaseHaSlbResult::DeleteHbaseHaSlbResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteHbaseHaSlbResult::~DeleteHbaseHaSlbResult()
{}
void DeleteHbaseHaSlbResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

40
hbase/src/model/DescribeDBInstanceUsageRequest.cc Normal file
View File

@@ -0,0 +1,40 @@
/*
* 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/hbase/model/DescribeDBInstanceUsageRequest.h>
using AlibabaCloud::HBase::Model::DescribeDBInstanceUsageRequest;
DescribeDBInstanceUsageRequest::DescribeDBInstanceUsageRequest() :
RpcServiceRequest("hbase", "2019-01-01", "DescribeDBInstanceUsage")
{
setMethod(HttpRequest::Method::Post);
}
DescribeDBInstanceUsageRequest::~DescribeDBInstanceUsageRequest()
{}
std::string DescribeDBInstanceUsageRequest::getClusterId()const
{
return clusterId_;
}
void DescribeDBInstanceUsageRequest::setClusterId(const std::string& clusterId)
{
clusterId_ = clusterId;
setCoreParameter("ClusterId", clusterId);
}

51
hbase/src/model/DescribeDBInstanceUsageResult.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/hbase/model/DescribeDBInstanceUsageResult.h>
#include <json/json.h>
using namespace AlibabaCloud::HBase;
using namespace AlibabaCloud::HBase::Model;
DescribeDBInstanceUsageResult::DescribeDBInstanceUsageResult() :
ServiceResult()
{}
DescribeDBInstanceUsageResult::DescribeDBInstanceUsageResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeDBInstanceUsageResult::~DescribeDBInstanceUsageResult()
{}
void DescribeDBInstanceUsageResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Result"].isNull())
result_ = value["Result"].asString();
}
std::string DescribeDBInstanceUsageResult::getResult()const
{
return result_;
}

14
hbase/src/model/DescribeInstanceResult.cc
View File

@@ -101,6 +101,10 @@ void DescribeInstanceResult::parse(const std::string &payload)
backupStatus_ = value["BackupStatus"].asString();
if(!value["CoreDiskCount"].isNull())
coreDiskCount_ = value["CoreDiskCount"].asString();
if(!value["MaintainStartTime"].isNull())
maintainStartTime_ = value["MaintainStartTime"].asString();
if(!value["MaintainEndTime"].isNull())
maintainEndTime_ = value["MaintainEndTime"].asString();
}
@@ -119,6 +123,11 @@ std::string DescribeInstanceResult::getMasterInstanceType()const
return masterInstanceType_;
}
std::string DescribeInstanceResult::getMaintainEndTime()const
{
return maintainEndTime_;
}
std::string DescribeInstanceResult::getNetworkType()const
{
return networkType_;
@@ -144,6 +153,11 @@ std::string DescribeInstanceResult::getEngine()const
return engine_;
}
std::string DescribeInstanceResult::getMaintainStartTime()const
{
return maintainStartTime_;
}
std::string DescribeInstanceResult::getStatus()const
{
return status_;

40
hbase/src/model/DescribeInstanceTypeRequest.cc Normal file
View File

@@ -0,0 +1,40 @@
/*
* 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/hbase/model/DescribeInstanceTypeRequest.h>
using AlibabaCloud::HBase::Model::DescribeInstanceTypeRequest;
DescribeInstanceTypeRequest::DescribeInstanceTypeRequest() :
RpcServiceRequest("hbase", "2019-01-01", "DescribeInstanceType")
{
setMethod(HttpRequest::Method::Post);
}
DescribeInstanceTypeRequest::~DescribeInstanceTypeRequest()
{}
std::string DescribeInstanceTypeRequest::getInstanceType()const
{
return instanceType_;
}
void DescribeInstanceTypeRequest::setInstanceType(const std::string& instanceType)
{
instanceType_ = instanceType;
setCoreParameter("InstanceType", instanceType);
}

61
hbase/src/model/DescribeInstanceTypeResult.cc Normal file
View File

@@ -0,0 +1,61 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/hbase/model/DescribeInstanceTypeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::HBase;
using namespace AlibabaCloud::HBase::Model;
DescribeInstanceTypeResult::DescribeInstanceTypeResult() :
ServiceResult()
{}
DescribeInstanceTypeResult::DescribeInstanceTypeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeInstanceTypeResult::~DescribeInstanceTypeResult()
{}
void DescribeInstanceTypeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allInstanceTypeSpecListNode = value["InstanceTypeSpecList"]["InstanceTypeSpec"];
for (auto valueInstanceTypeSpecListInstanceTypeSpec : allInstanceTypeSpecListNode)
{
InstanceTypeSpec instanceTypeSpecListObject;
if(!valueInstanceTypeSpecListInstanceTypeSpec["InstanceType"].isNull())
instanceTypeSpecListObject.instanceType = valueInstanceTypeSpecListInstanceTypeSpec["InstanceType"].asString();
if(!valueInstanceTypeSpecListInstanceTypeSpec["CpuSize"].isNull())
instanceTypeSpecListObject.cpuSize = std::stol(valueInstanceTypeSpecListInstanceTypeSpec["CpuSize"].asString());
if(!valueInstanceTypeSpecListInstanceTypeSpec["MemSize"].isNull())
instanceTypeSpecListObject.memSize = std::stol(valueInstanceTypeSpecListInstanceTypeSpec["MemSize"].asString());
instanceTypeSpecList_.push_back(instanceTypeSpecListObject);
}
}
std::vector<DescribeInstanceTypeResult::InstanceTypeSpec> DescribeInstanceTypeResult::getInstanceTypeSpecList()const
{
return instanceTypeSpecList_;
}

80
hbase/src/model/ListTagResourcesRequest.cc Normal file
View File

@@ -0,0 +1,80 @@
/*
* 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/hbase/model/ListTagResourcesRequest.h>
using AlibabaCloud::HBase::Model::ListTagResourcesRequest;
ListTagResourcesRequest::ListTagResourcesRequest() :
RpcServiceRequest("hbase", "2019-01-01", "ListTagResources")
{
setMethod(HttpRequest::Method::Post);
}
ListTagResourcesRequest::~ListTagResourcesRequest()
{}
std::string ListTagResourcesRequest::getRegionId()const
{
return regionId_;
}
void ListTagResourcesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string ListTagResourcesRequest::getNextToken()const
{
return nextToken_;
}
void ListTagResourcesRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setCoreParameter("NextToken", nextToken);
}
std::vector<ListTagResourcesRequest::Tag> ListTagResourcesRequest::getTag()const
{
return tag_;
}
void ListTagResourcesRequest::setTag(const std::vector<Tag>& tag)
{
tag_ = tag;
for(int dep1 = 0; dep1!= tag.size(); dep1++) {
auto tagObj = tag.at(dep1);
std::string tagObjStr = "Tag." + std::to_string(dep1);
setCoreParameter(tagObjStr + ".Value", tagObj.value);
setCoreParameter(tagObjStr + ".Key", tagObj.key);
}
}
std::vector<std::string> ListTagResourcesRequest::getResourceId()const
{
return resourceId_;
}
void ListTagResourcesRequest::setResourceId(const std::vector<std::string>& resourceId)
{
resourceId_ = resourceId;
for(int dep1 = 0; dep1!= resourceId.size(); dep1++) {
setCoreParameter("ResourceId."+ std::to_string(dep1), resourceId.at(dep1));
}
}

70
hbase/src/model/ListTagResourcesResult.cc Normal file
View File

@@ -0,0 +1,70 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/hbase/model/ListTagResourcesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::HBase;
using namespace AlibabaCloud::HBase::Model;
ListTagResourcesResult::ListTagResourcesResult() :
ServiceResult()
{}
ListTagResourcesResult::ListTagResourcesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListTagResourcesResult::~ListTagResourcesResult()
{}
void ListTagResourcesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allTagResourcesNode = value["TagResources"]["TagResource"];
for (auto valueTagResourcesTagResource : allTagResourcesNode)
{
TagResource tagResourcesObject;
if(!valueTagResourcesTagResource["TagKey"].isNull())
tagResourcesObject.tagKey = valueTagResourcesTagResource["TagKey"].asString();
if(!valueTagResourcesTagResource["TagValue"].isNull())
tagResourcesObject.tagValue = valueTagResourcesTagResource["TagValue"].asString();
if(!valueTagResourcesTagResource["ResourceType"].isNull())
tagResourcesObject.resourceType = valueTagResourcesTagResource["ResourceType"].asString();
if(!valueTagResourcesTagResource["ResourceId"].isNull())
tagResourcesObject.resourceId = valueTagResourcesTagResource["ResourceId"].asString();
tagResources_.push_back(tagResourcesObject);
}
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
}
std::string ListTagResourcesResult::getNextToken()const
{
return nextToken_;
}
std::vector<ListTagResourcesResult::TagResource> ListTagResourcesResult::getTagResources()const
{
return tagResources_;
}

62
hbase/src/model/ModifyInstanceMaintainTimeRequest.cc Normal file
View File

@@ -0,0 +1,62 @@
/*
* 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/hbase/model/ModifyInstanceMaintainTimeRequest.h>
using AlibabaCloud::HBase::Model::ModifyInstanceMaintainTimeRequest;
ModifyInstanceMaintainTimeRequest::ModifyInstanceMaintainTimeRequest() :
RpcServiceRequest("hbase", "2019-01-01", "ModifyInstanceMaintainTime")
{
setMethod(HttpRequest::Method::Post);
}
ModifyInstanceMaintainTimeRequest::~ModifyInstanceMaintainTimeRequest()
{}
std::string ModifyInstanceMaintainTimeRequest::getClusterId()const
{
return clusterId_;
}
void ModifyInstanceMaintainTimeRequest::setClusterId(const std::string& clusterId)
{
clusterId_ = clusterId;
setCoreParameter("ClusterId", clusterId);
}
std::string ModifyInstanceMaintainTimeRequest::getMaintainEndTime()const
{
return maintainEndTime_;
}
void ModifyInstanceMaintainTimeRequest::setMaintainEndTime(const std::string& maintainEndTime)
{
maintainEndTime_ = maintainEndTime;
setCoreParameter("MaintainEndTime", maintainEndTime);
}
std::string ModifyInstanceMaintainTimeRequest::getMaintainStartTime()const
{
return maintainStartTime_;
}
void ModifyInstanceMaintainTimeRequest::setMaintainStartTime(const std::string& maintainStartTime)
{
maintainStartTime_ = maintainStartTime;
setCoreParameter("MaintainStartTime", maintainStartTime);
}

44
hbase/src/model/ModifyInstanceMaintainTimeResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/hbase/model/ModifyInstanceMaintainTimeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::HBase;
using namespace AlibabaCloud::HBase::Model;
ModifyInstanceMaintainTimeResult::ModifyInstanceMaintainTimeResult() :
ServiceResult()
{}
ModifyInstanceMaintainTimeResult::ModifyInstanceMaintainTimeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ModifyInstanceMaintainTimeResult::~ModifyInstanceMaintainTimeResult()
{}
void ModifyInstanceMaintainTimeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

40
hbase/src/model/QueryHBaseHaDBRequest.cc Normal file
View File

@@ -0,0 +1,40 @@
/*
* 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/hbase/model/QueryHBaseHaDBRequest.h>
using AlibabaCloud::HBase::Model::QueryHBaseHaDBRequest;
QueryHBaseHaDBRequest::QueryHBaseHaDBRequest() :
RpcServiceRequest("hbase", "2019-01-01", "QueryHBaseHaDB")
{
setMethod(HttpRequest::Method::Post);
}
QueryHBaseHaDBRequest::~QueryHBaseHaDBRequest()
{}
std::string QueryHBaseHaDBRequest::getBdsId()const
{
return bdsId_;
}
void QueryHBaseHaDBRequest::setBdsId(const std::string& bdsId)
{
bdsId_ = bdsId;
setCoreParameter("BdsId", bdsId);
}

96
hbase/src/model/QueryHBaseHaDBResult.cc Normal file
View File

@@ -0,0 +1,96 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/hbase/model/QueryHBaseHaDBResult.h>
#include <json/json.h>
using namespace AlibabaCloud::HBase;
using namespace AlibabaCloud::HBase::Model;
QueryHBaseHaDBResult::QueryHBaseHaDBResult() :
ServiceResult()
{}
QueryHBaseHaDBResult::QueryHBaseHaDBResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
QueryHBaseHaDBResult::~QueryHBaseHaDBResult()
{}
void QueryHBaseHaDBResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allClusterListNode = value["ClusterList"]["Cluster"];
for (auto valueClusterListCluster : allClusterListNode)
{
Cluster clusterListObject;
if(!valueClusterListCluster["HaName"].isNull())
clusterListObject.haName = valueClusterListCluster["HaName"].asString();
if(!valueClusterListCluster["BdsName"].isNull())
clusterListObject.bdsName = valueClusterListCluster["BdsName"].asString();
if(!valueClusterListCluster["ActiveName"].isNull())
clusterListObject.activeName = valueClusterListCluster["ActiveName"].asString();
if(!valueClusterListCluster["StandbyName"].isNull())
clusterListObject.standbyName = valueClusterListCluster["StandbyName"].asString();
auto allHaSlbConnListNode = allClusterListNode["HaSlbConnList"]["HaSlbConn"];
for (auto allClusterListNodeHaSlbConnListHaSlbConn : allHaSlbConnListNode)
{
Cluster::HaSlbConn haSlbConnListObject;
if(!allClusterListNodeHaSlbConnListHaSlbConn["SlbType"].isNull())
haSlbConnListObject.slbType = allClusterListNodeHaSlbConnListHaSlbConn["SlbType"].asString();
if(!allClusterListNodeHaSlbConnListHaSlbConn["SlbConnAddr"].isNull())
haSlbConnListObject.slbConnAddr = allClusterListNodeHaSlbConnListHaSlbConn["SlbConnAddr"].asString();
if(!allClusterListNodeHaSlbConnListHaSlbConn["HbaseType"].isNull())
haSlbConnListObject.hbaseType = allClusterListNodeHaSlbConnListHaSlbConn["HbaseType"].asString();
clusterListObject.haSlbConnList.push_back(haSlbConnListObject);
}
clusterList_.push_back(clusterListObject);
}
if(!value["TotalCount"].isNull())
totalCount_ = std::stol(value["TotalCount"].asString());
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
}
long QueryHBaseHaDBResult::getTotalCount()const
{
return totalCount_;
}
std::vector<QueryHBaseHaDBResult::Cluster> QueryHBaseHaDBResult::getClusterList()const
{
return clusterList_;
}
int QueryHBaseHaDBResult::getPageSize()const
{
return pageSize_;
}
int QueryHBaseHaDBResult::getPageNumber()const
{
return pageNumber_;
}

73
hbase/src/model/SwitchHbaseHaSlbRequest.cc Normal file
View File

@@ -0,0 +1,73 @@
/*
* 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/hbase/model/SwitchHbaseHaSlbRequest.h>
using AlibabaCloud::HBase::Model::SwitchHbaseHaSlbRequest;
SwitchHbaseHaSlbRequest::SwitchHbaseHaSlbRequest() :
RpcServiceRequest("hbase", "2019-01-01", "SwitchHbaseHaSlb")
{
setMethod(HttpRequest::Method::Post);
}
SwitchHbaseHaSlbRequest::~SwitchHbaseHaSlbRequest()
{}
std::string SwitchHbaseHaSlbRequest::getHaTypes()const
{
return haTypes_;
}
void SwitchHbaseHaSlbRequest::setHaTypes(const std::string& haTypes)
{
haTypes_ = haTypes;
setCoreParameter("HaTypes", haTypes);
}
std::string SwitchHbaseHaSlbRequest::getHbaseType()const
{
return hbaseType_;
}
void SwitchHbaseHaSlbRequest::setHbaseType(const std::string& hbaseType)
{
hbaseType_ = hbaseType;
setCoreParameter("HbaseType", hbaseType);
}
std::string SwitchHbaseHaSlbRequest::getBdsId()const
{
return bdsId_;
}
void SwitchHbaseHaSlbRequest::setBdsId(const std::string& bdsId)
{
bdsId_ = bdsId;
setCoreParameter("BdsId", bdsId);
}
std::string SwitchHbaseHaSlbRequest::getHaId()const
{
return haId_;
}
void SwitchHbaseHaSlbRequest::setHaId(const std::string& haId)
{
haId_ = haId;
setCoreParameter("HaId", haId);
}

44
hbase/src/model/SwitchHbaseHaSlbResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/hbase/model/SwitchHbaseHaSlbResult.h>
#include <json/json.h>
using namespace AlibabaCloud::HBase;
using namespace AlibabaCloud::HBase::Model;
SwitchHbaseHaSlbResult::SwitchHbaseHaSlbResult() :
ServiceResult()
{}
SwitchHbaseHaSlbResult::SwitchHbaseHaSlbResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SwitchHbaseHaSlbResult::~SwitchHbaseHaSlbResult()
{}
void SwitchHbaseHaSlbResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

69
hbase/src/model/TagResourcesRequest.cc Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/hbase/model/TagResourcesRequest.h>
using AlibabaCloud::HBase::Model::TagResourcesRequest;
TagResourcesRequest::TagResourcesRequest() :
RpcServiceRequest("hbase", "2019-01-01", "TagResources")
{
setMethod(HttpRequest::Method::Post);
}
TagResourcesRequest::~TagResourcesRequest()
{}
std::vector<std::string> TagResourcesRequest::getResourceId()const
{
return resourceId_;
}
void TagResourcesRequest::setResourceId(const std::vector<std::string>& resourceId)
{
resourceId_ = resourceId;
for(int dep1 = 0; dep1!= resourceId.size(); dep1++) {
setCoreParameter("ResourceId."+ std::to_string(dep1), resourceId.at(dep1));
}
}
std::string TagResourcesRequest::getRegionId()const
{
return regionId_;
}
void TagResourcesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::vector<TagResourcesRequest::Tag> TagResourcesRequest::getTag()const
{
return tag_;
}
void TagResourcesRequest::setTag(const std::vector<Tag>& tag)
{
tag_ = tag;
for(int dep1 = 0; dep1!= tag.size(); dep1++) {
auto tagObj = tag.at(dep1);
std::string tagObjStr = "Tag." + std::to_string(dep1);
setCoreParameter(tagObjStr + ".Value", tagObj.value);
setCoreParameter(tagObjStr + ".Key", tagObj.key);
}
}

44
hbase/src/model/TagResourcesResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/hbase/model/TagResourcesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::HBase;
using namespace AlibabaCloud::HBase::Model;
TagResourcesResult::TagResourcesResult() :
ServiceResult()
{}
TagResourcesResult::TagResourcesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
TagResourcesResult::~TagResourcesResult()
{}
void TagResourcesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

77
hbase/src/model/UnTagResourcesRequest.cc Normal file
View File

@@ -0,0 +1,77 @@
/*
* 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/hbase/model/UnTagResourcesRequest.h>
using AlibabaCloud::HBase::Model::UnTagResourcesRequest;
UnTagResourcesRequest::UnTagResourcesRequest() :
RpcServiceRequest("hbase", "2019-01-01", "UnTagResources")
{
setMethod(HttpRequest::Method::Post);
}
UnTagResourcesRequest::~UnTagResourcesRequest()
{}
std::string UnTagResourcesRequest::getRegionId()const
{
return regionId_;
}
void UnTagResourcesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
bool UnTagResourcesRequest::getAll()const
{
return all_;
}
void UnTagResourcesRequest::setAll(bool all)
{
all_ = all;
setCoreParameter("All", all ? "true" : "false");
}
std::vector<std::string> UnTagResourcesRequest::getResourceId()const
{
return resourceId_;
}
void UnTagResourcesRequest::setResourceId(const std::vector<std::string>& resourceId)
{
resourceId_ = resourceId;
for(int dep1 = 0; dep1!= resourceId.size(); dep1++) {
setCoreParameter("ResourceId."+ std::to_string(dep1), resourceId.at(dep1));
}
}
std::vector<std::string> UnTagResourcesRequest::getTagKey()const
{
return tagKey_;
}
void UnTagResourcesRequest::setTagKey(const std::vector<std::string>& tagKey)
{
tagKey_ = tagKey;
for(int dep1 = 0; dep1!= tagKey.size(); dep1++) {
setCoreParameter("TagKey."+ std::to_string(dep1), tagKey.at(dep1));
}
}

44
hbase/src/model/UnTagResourcesResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/hbase/model/UnTagResourcesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::HBase;
using namespace AlibabaCloud::HBase::Model;
UnTagResourcesResult::UnTagResourcesResult() :
ServiceResult()
{}
UnTagResourcesResult::UnTagResourcesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UnTagResourcesResult::~UnTagResourcesResult()
{}
void UnTagResourcesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}