Generated 2019-03-27 for dg.

This commit is contained in:
sdk-team
2021-01-18 13:58:07 +00:00
parent f3fbed5766
commit 31aec3f28f
89 changed files with 6804 additions and 0 deletions

View File

@@ -1,3 +1,6 @@
2021-01-18 Version: patch
- Generated 2019-03-27 for `dg`.
2021-01-18 Version: patch
- Add a set of API to support device distribution management, including CreateProductDistributeJob, CreateDeviceDistributeJob, QueryDeviceDistributeJob, ListDeviceDistributeJob, QueryDeviceDistributeDetail, DeleteDeviceDistributeJob, ListDistributedDevice, ListDistributedProduct etc.

166
dg/CMakeLists.txt Normal file
View File

@@ -0,0 +1,166 @@
#
# 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.
#
set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
set(dg_public_header
include/alibabacloud/dg/DgClient.h
include/alibabacloud/dg/DgExport.h )
set(dg_public_header_model
include/alibabacloud/dg/model/AddDatabaseRequest.h
include/alibabacloud/dg/model/AddDatabaseResult.h
include/alibabacloud/dg/model/AddDatabaseListRequest.h
include/alibabacloud/dg/model/AddDatabaseListResult.h
include/alibabacloud/dg/model/ConnectDatabaseRequest.h
include/alibabacloud/dg/model/ConnectDatabaseResult.h
include/alibabacloud/dg/model/CreateDatabaseAccessPointRequest.h
include/alibabacloud/dg/model/CreateDatabaseAccessPointResult.h
include/alibabacloud/dg/model/CreateGatewayRequest.h
include/alibabacloud/dg/model/CreateGatewayResult.h
include/alibabacloud/dg/model/CreateGatewayVerifyCodeRequest.h
include/alibabacloud/dg/model/CreateGatewayVerifyCodeResult.h
include/alibabacloud/dg/model/DeleteDatabaseRequest.h
include/alibabacloud/dg/model/DeleteDatabaseResult.h
include/alibabacloud/dg/model/DeleteDatabaseAccessPointRequest.h
include/alibabacloud/dg/model/DeleteDatabaseAccessPointResult.h
include/alibabacloud/dg/model/DeleteGatewayRequest.h
include/alibabacloud/dg/model/DeleteGatewayResult.h
include/alibabacloud/dg/model/DeleteGatewayInstanceRequest.h
include/alibabacloud/dg/model/DeleteGatewayInstanceResult.h
include/alibabacloud/dg/model/DescribeRegionsRequest.h
include/alibabacloud/dg/model/DescribeRegionsResult.h
include/alibabacloud/dg/model/DownloadGatewayProgramRequest.h
include/alibabacloud/dg/model/DownloadGatewayProgramResult.h
include/alibabacloud/dg/model/FindUserGatewayByIdRequest.h
include/alibabacloud/dg/model/FindUserGatewayByIdResult.h
include/alibabacloud/dg/model/GetUserDatabasesRequest.h
include/alibabacloud/dg/model/GetUserDatabasesResult.h
include/alibabacloud/dg/model/GetUserGatewayInstancesRequest.h
include/alibabacloud/dg/model/GetUserGatewayInstancesResult.h
include/alibabacloud/dg/model/GetUserGatewaysRequest.h
include/alibabacloud/dg/model/GetUserGatewaysResult.h
include/alibabacloud/dg/model/ListDatabaseAccessPointRequest.h
include/alibabacloud/dg/model/ListDatabaseAccessPointResult.h
include/alibabacloud/dg/model/ModifyDatabaseRequest.h
include/alibabacloud/dg/model/ModifyDatabaseResult.h
include/alibabacloud/dg/model/ModifyGatewayRequest.h
include/alibabacloud/dg/model/ModifyGatewayResult.h
include/alibabacloud/dg/model/RetryDatabaseRequest.h
include/alibabacloud/dg/model/RetryDatabaseResult.h
include/alibabacloud/dg/model/StopGatewayRequest.h
include/alibabacloud/dg/model/StopGatewayResult.h )
set(dg_src
src/DgClient.cc
src/model/AddDatabaseRequest.cc
src/model/AddDatabaseResult.cc
src/model/AddDatabaseListRequest.cc
src/model/AddDatabaseListResult.cc
src/model/ConnectDatabaseRequest.cc
src/model/ConnectDatabaseResult.cc
src/model/CreateDatabaseAccessPointRequest.cc
src/model/CreateDatabaseAccessPointResult.cc
src/model/CreateGatewayRequest.cc
src/model/CreateGatewayResult.cc
src/model/CreateGatewayVerifyCodeRequest.cc
src/model/CreateGatewayVerifyCodeResult.cc
src/model/DeleteDatabaseRequest.cc
src/model/DeleteDatabaseResult.cc
src/model/DeleteDatabaseAccessPointRequest.cc
src/model/DeleteDatabaseAccessPointResult.cc
src/model/DeleteGatewayRequest.cc
src/model/DeleteGatewayResult.cc
src/model/DeleteGatewayInstanceRequest.cc
src/model/DeleteGatewayInstanceResult.cc
src/model/DescribeRegionsRequest.cc
src/model/DescribeRegionsResult.cc
src/model/DownloadGatewayProgramRequest.cc
src/model/DownloadGatewayProgramResult.cc
src/model/FindUserGatewayByIdRequest.cc
src/model/FindUserGatewayByIdResult.cc
src/model/GetUserDatabasesRequest.cc
src/model/GetUserDatabasesResult.cc
src/model/GetUserGatewayInstancesRequest.cc
src/model/GetUserGatewayInstancesResult.cc
src/model/GetUserGatewaysRequest.cc
src/model/GetUserGatewaysResult.cc
src/model/ListDatabaseAccessPointRequest.cc
src/model/ListDatabaseAccessPointResult.cc
src/model/ModifyDatabaseRequest.cc
src/model/ModifyDatabaseResult.cc
src/model/ModifyGatewayRequest.cc
src/model/ModifyGatewayResult.cc
src/model/RetryDatabaseRequest.cc
src/model/RetryDatabaseResult.cc
src/model/StopGatewayRequest.cc
src/model/StopGatewayResult.cc )
add_library(dg ${LIB_TYPE}
${dg_public_header}
${dg_public_header_model}
${dg_src})
set_target_properties(dg
PROPERTIES
LINKER_LANGUAGE CXX
ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}dg
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(dg
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_DG_LIBRARY)
endif()
target_include_directories(dg
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(dg
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(dg
jsoncpp)
target_include_directories(dg
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(dg
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(dg
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(dg
PRIVATE /usr/include/jsoncpp)
target_link_libraries(dg
jsoncpp)
endif()
install(FILES ${dg_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/dg)
install(FILES ${dg_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/dg/model)
install(TARGETS dg
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

View File

@@ -0,0 +1,214 @@
/*
* 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_DG_DGCLIENT_H_
#define ALIBABACLOUD_DG_DGCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "DgExport.h"
#include "model/AddDatabaseRequest.h"
#include "model/AddDatabaseResult.h"
#include "model/AddDatabaseListRequest.h"
#include "model/AddDatabaseListResult.h"
#include "model/ConnectDatabaseRequest.h"
#include "model/ConnectDatabaseResult.h"
#include "model/CreateDatabaseAccessPointRequest.h"
#include "model/CreateDatabaseAccessPointResult.h"
#include "model/CreateGatewayRequest.h"
#include "model/CreateGatewayResult.h"
#include "model/CreateGatewayVerifyCodeRequest.h"
#include "model/CreateGatewayVerifyCodeResult.h"
#include "model/DeleteDatabaseRequest.h"
#include "model/DeleteDatabaseResult.h"
#include "model/DeleteDatabaseAccessPointRequest.h"
#include "model/DeleteDatabaseAccessPointResult.h"
#include "model/DeleteGatewayRequest.h"
#include "model/DeleteGatewayResult.h"
#include "model/DeleteGatewayInstanceRequest.h"
#include "model/DeleteGatewayInstanceResult.h"
#include "model/DescribeRegionsRequest.h"
#include "model/DescribeRegionsResult.h"
#include "model/DownloadGatewayProgramRequest.h"
#include "model/DownloadGatewayProgramResult.h"
#include "model/FindUserGatewayByIdRequest.h"
#include "model/FindUserGatewayByIdResult.h"
#include "model/GetUserDatabasesRequest.h"
#include "model/GetUserDatabasesResult.h"
#include "model/GetUserGatewayInstancesRequest.h"
#include "model/GetUserGatewayInstancesResult.h"
#include "model/GetUserGatewaysRequest.h"
#include "model/GetUserGatewaysResult.h"
#include "model/ListDatabaseAccessPointRequest.h"
#include "model/ListDatabaseAccessPointResult.h"
#include "model/ModifyDatabaseRequest.h"
#include "model/ModifyDatabaseResult.h"
#include "model/ModifyGatewayRequest.h"
#include "model/ModifyGatewayResult.h"
#include "model/RetryDatabaseRequest.h"
#include "model/RetryDatabaseResult.h"
#include "model/StopGatewayRequest.h"
#include "model/StopGatewayResult.h"
namespace AlibabaCloud
{
namespace Dg
{
class ALIBABACLOUD_DG_EXPORT DgClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::AddDatabaseResult> AddDatabaseOutcome;
typedef std::future<AddDatabaseOutcome> AddDatabaseOutcomeCallable;
typedef std::function<void(const DgClient*, const Model::AddDatabaseRequest&, const AddDatabaseOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddDatabaseAsyncHandler;
typedef Outcome<Error, Model::AddDatabaseListResult> AddDatabaseListOutcome;
typedef std::future<AddDatabaseListOutcome> AddDatabaseListOutcomeCallable;
typedef std::function<void(const DgClient*, const Model::AddDatabaseListRequest&, const AddDatabaseListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddDatabaseListAsyncHandler;
typedef Outcome<Error, Model::ConnectDatabaseResult> ConnectDatabaseOutcome;
typedef std::future<ConnectDatabaseOutcome> ConnectDatabaseOutcomeCallable;
typedef std::function<void(const DgClient*, const Model::ConnectDatabaseRequest&, const ConnectDatabaseOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ConnectDatabaseAsyncHandler;
typedef Outcome<Error, Model::CreateDatabaseAccessPointResult> CreateDatabaseAccessPointOutcome;
typedef std::future<CreateDatabaseAccessPointOutcome> CreateDatabaseAccessPointOutcomeCallable;
typedef std::function<void(const DgClient*, const Model::CreateDatabaseAccessPointRequest&, const CreateDatabaseAccessPointOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDatabaseAccessPointAsyncHandler;
typedef Outcome<Error, Model::CreateGatewayResult> CreateGatewayOutcome;
typedef std::future<CreateGatewayOutcome> CreateGatewayOutcomeCallable;
typedef std::function<void(const DgClient*, const Model::CreateGatewayRequest&, const CreateGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGatewayAsyncHandler;
typedef Outcome<Error, Model::CreateGatewayVerifyCodeResult> CreateGatewayVerifyCodeOutcome;
typedef std::future<CreateGatewayVerifyCodeOutcome> CreateGatewayVerifyCodeOutcomeCallable;
typedef std::function<void(const DgClient*, const Model::CreateGatewayVerifyCodeRequest&, const CreateGatewayVerifyCodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGatewayVerifyCodeAsyncHandler;
typedef Outcome<Error, Model::DeleteDatabaseResult> DeleteDatabaseOutcome;
typedef std::future<DeleteDatabaseOutcome> DeleteDatabaseOutcomeCallable;
typedef std::function<void(const DgClient*, const Model::DeleteDatabaseRequest&, const DeleteDatabaseOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDatabaseAsyncHandler;
typedef Outcome<Error, Model::DeleteDatabaseAccessPointResult> DeleteDatabaseAccessPointOutcome;
typedef std::future<DeleteDatabaseAccessPointOutcome> DeleteDatabaseAccessPointOutcomeCallable;
typedef std::function<void(const DgClient*, const Model::DeleteDatabaseAccessPointRequest&, const DeleteDatabaseAccessPointOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDatabaseAccessPointAsyncHandler;
typedef Outcome<Error, Model::DeleteGatewayResult> DeleteGatewayOutcome;
typedef std::future<DeleteGatewayOutcome> DeleteGatewayOutcomeCallable;
typedef std::function<void(const DgClient*, const Model::DeleteGatewayRequest&, const DeleteGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayAsyncHandler;
typedef Outcome<Error, Model::DeleteGatewayInstanceResult> DeleteGatewayInstanceOutcome;
typedef std::future<DeleteGatewayInstanceOutcome> DeleteGatewayInstanceOutcomeCallable;
typedef std::function<void(const DgClient*, const Model::DeleteGatewayInstanceRequest&, const DeleteGatewayInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayInstanceAsyncHandler;
typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
typedef std::function<void(const DgClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
typedef Outcome<Error, Model::DownloadGatewayProgramResult> DownloadGatewayProgramOutcome;
typedef std::future<DownloadGatewayProgramOutcome> DownloadGatewayProgramOutcomeCallable;
typedef std::function<void(const DgClient*, const Model::DownloadGatewayProgramRequest&, const DownloadGatewayProgramOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DownloadGatewayProgramAsyncHandler;
typedef Outcome<Error, Model::FindUserGatewayByIdResult> FindUserGatewayByIdOutcome;
typedef std::future<FindUserGatewayByIdOutcome> FindUserGatewayByIdOutcomeCallable;
typedef std::function<void(const DgClient*, const Model::FindUserGatewayByIdRequest&, const FindUserGatewayByIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FindUserGatewayByIdAsyncHandler;
typedef Outcome<Error, Model::GetUserDatabasesResult> GetUserDatabasesOutcome;
typedef std::future<GetUserDatabasesOutcome> GetUserDatabasesOutcomeCallable;
typedef std::function<void(const DgClient*, const Model::GetUserDatabasesRequest&, const GetUserDatabasesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetUserDatabasesAsyncHandler;
typedef Outcome<Error, Model::GetUserGatewayInstancesResult> GetUserGatewayInstancesOutcome;
typedef std::future<GetUserGatewayInstancesOutcome> GetUserGatewayInstancesOutcomeCallable;
typedef std::function<void(const DgClient*, const Model::GetUserGatewayInstancesRequest&, const GetUserGatewayInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetUserGatewayInstancesAsyncHandler;
typedef Outcome<Error, Model::GetUserGatewaysResult> GetUserGatewaysOutcome;
typedef std::future<GetUserGatewaysOutcome> GetUserGatewaysOutcomeCallable;
typedef std::function<void(const DgClient*, const Model::GetUserGatewaysRequest&, const GetUserGatewaysOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetUserGatewaysAsyncHandler;
typedef Outcome<Error, Model::ListDatabaseAccessPointResult> ListDatabaseAccessPointOutcome;
typedef std::future<ListDatabaseAccessPointOutcome> ListDatabaseAccessPointOutcomeCallable;
typedef std::function<void(const DgClient*, const Model::ListDatabaseAccessPointRequest&, const ListDatabaseAccessPointOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDatabaseAccessPointAsyncHandler;
typedef Outcome<Error, Model::ModifyDatabaseResult> ModifyDatabaseOutcome;
typedef std::future<ModifyDatabaseOutcome> ModifyDatabaseOutcomeCallable;
typedef std::function<void(const DgClient*, const Model::ModifyDatabaseRequest&, const ModifyDatabaseOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDatabaseAsyncHandler;
typedef Outcome<Error, Model::ModifyGatewayResult> ModifyGatewayOutcome;
typedef std::future<ModifyGatewayOutcome> ModifyGatewayOutcomeCallable;
typedef std::function<void(const DgClient*, const Model::ModifyGatewayRequest&, const ModifyGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyGatewayAsyncHandler;
typedef Outcome<Error, Model::RetryDatabaseResult> RetryDatabaseOutcome;
typedef std::future<RetryDatabaseOutcome> RetryDatabaseOutcomeCallable;
typedef std::function<void(const DgClient*, const Model::RetryDatabaseRequest&, const RetryDatabaseOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RetryDatabaseAsyncHandler;
typedef Outcome<Error, Model::StopGatewayResult> StopGatewayOutcome;
typedef std::future<StopGatewayOutcome> StopGatewayOutcomeCallable;
typedef std::function<void(const DgClient*, const Model::StopGatewayRequest&, const StopGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopGatewayAsyncHandler;
DgClient(const Credentials &credentials, const ClientConfiguration &configuration);
DgClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
DgClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~DgClient();
AddDatabaseOutcome addDatabase(const Model::AddDatabaseRequest &request)const;
void addDatabaseAsync(const Model::AddDatabaseRequest& request, const AddDatabaseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddDatabaseOutcomeCallable addDatabaseCallable(const Model::AddDatabaseRequest& request) const;
AddDatabaseListOutcome addDatabaseList(const Model::AddDatabaseListRequest &request)const;
void addDatabaseListAsync(const Model::AddDatabaseListRequest& request, const AddDatabaseListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddDatabaseListOutcomeCallable addDatabaseListCallable(const Model::AddDatabaseListRequest& request) const;
ConnectDatabaseOutcome connectDatabase(const Model::ConnectDatabaseRequest &request)const;
void connectDatabaseAsync(const Model::ConnectDatabaseRequest& request, const ConnectDatabaseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ConnectDatabaseOutcomeCallable connectDatabaseCallable(const Model::ConnectDatabaseRequest& request) const;
CreateDatabaseAccessPointOutcome createDatabaseAccessPoint(const Model::CreateDatabaseAccessPointRequest &request)const;
void createDatabaseAccessPointAsync(const Model::CreateDatabaseAccessPointRequest& request, const CreateDatabaseAccessPointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDatabaseAccessPointOutcomeCallable createDatabaseAccessPointCallable(const Model::CreateDatabaseAccessPointRequest& request) const;
CreateGatewayOutcome createGateway(const Model::CreateGatewayRequest &request)const;
void createGatewayAsync(const Model::CreateGatewayRequest& request, const CreateGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateGatewayOutcomeCallable createGatewayCallable(const Model::CreateGatewayRequest& request) const;
CreateGatewayVerifyCodeOutcome createGatewayVerifyCode(const Model::CreateGatewayVerifyCodeRequest &request)const;
void createGatewayVerifyCodeAsync(const Model::CreateGatewayVerifyCodeRequest& request, const CreateGatewayVerifyCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateGatewayVerifyCodeOutcomeCallable createGatewayVerifyCodeCallable(const Model::CreateGatewayVerifyCodeRequest& request) const;
DeleteDatabaseOutcome deleteDatabase(const Model::DeleteDatabaseRequest &request)const;
void deleteDatabaseAsync(const Model::DeleteDatabaseRequest& request, const DeleteDatabaseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteDatabaseOutcomeCallable deleteDatabaseCallable(const Model::DeleteDatabaseRequest& request) const;
DeleteDatabaseAccessPointOutcome deleteDatabaseAccessPoint(const Model::DeleteDatabaseAccessPointRequest &request)const;
void deleteDatabaseAccessPointAsync(const Model::DeleteDatabaseAccessPointRequest& request, const DeleteDatabaseAccessPointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteDatabaseAccessPointOutcomeCallable deleteDatabaseAccessPointCallable(const Model::DeleteDatabaseAccessPointRequest& request) const;
DeleteGatewayOutcome deleteGateway(const Model::DeleteGatewayRequest &request)const;
void deleteGatewayAsync(const Model::DeleteGatewayRequest& request, const DeleteGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteGatewayOutcomeCallable deleteGatewayCallable(const Model::DeleteGatewayRequest& request) const;
DeleteGatewayInstanceOutcome deleteGatewayInstance(const Model::DeleteGatewayInstanceRequest &request)const;
void deleteGatewayInstanceAsync(const Model::DeleteGatewayInstanceRequest& request, const DeleteGatewayInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteGatewayInstanceOutcomeCallable deleteGatewayInstanceCallable(const Model::DeleteGatewayInstanceRequest& request) const;
DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
DownloadGatewayProgramOutcome downloadGatewayProgram(const Model::DownloadGatewayProgramRequest &request)const;
void downloadGatewayProgramAsync(const Model::DownloadGatewayProgramRequest& request, const DownloadGatewayProgramAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DownloadGatewayProgramOutcomeCallable downloadGatewayProgramCallable(const Model::DownloadGatewayProgramRequest& request) const;
FindUserGatewayByIdOutcome findUserGatewayById(const Model::FindUserGatewayByIdRequest &request)const;
void findUserGatewayByIdAsync(const Model::FindUserGatewayByIdRequest& request, const FindUserGatewayByIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
FindUserGatewayByIdOutcomeCallable findUserGatewayByIdCallable(const Model::FindUserGatewayByIdRequest& request) const;
GetUserDatabasesOutcome getUserDatabases(const Model::GetUserDatabasesRequest &request)const;
void getUserDatabasesAsync(const Model::GetUserDatabasesRequest& request, const GetUserDatabasesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetUserDatabasesOutcomeCallable getUserDatabasesCallable(const Model::GetUserDatabasesRequest& request) const;
GetUserGatewayInstancesOutcome getUserGatewayInstances(const Model::GetUserGatewayInstancesRequest &request)const;
void getUserGatewayInstancesAsync(const Model::GetUserGatewayInstancesRequest& request, const GetUserGatewayInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetUserGatewayInstancesOutcomeCallable getUserGatewayInstancesCallable(const Model::GetUserGatewayInstancesRequest& request) const;
GetUserGatewaysOutcome getUserGateways(const Model::GetUserGatewaysRequest &request)const;
void getUserGatewaysAsync(const Model::GetUserGatewaysRequest& request, const GetUserGatewaysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetUserGatewaysOutcomeCallable getUserGatewaysCallable(const Model::GetUserGatewaysRequest& request) const;
ListDatabaseAccessPointOutcome listDatabaseAccessPoint(const Model::ListDatabaseAccessPointRequest &request)const;
void listDatabaseAccessPointAsync(const Model::ListDatabaseAccessPointRequest& request, const ListDatabaseAccessPointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListDatabaseAccessPointOutcomeCallable listDatabaseAccessPointCallable(const Model::ListDatabaseAccessPointRequest& request) const;
ModifyDatabaseOutcome modifyDatabase(const Model::ModifyDatabaseRequest &request)const;
void modifyDatabaseAsync(const Model::ModifyDatabaseRequest& request, const ModifyDatabaseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDatabaseOutcomeCallable modifyDatabaseCallable(const Model::ModifyDatabaseRequest& request) const;
ModifyGatewayOutcome modifyGateway(const Model::ModifyGatewayRequest &request)const;
void modifyGatewayAsync(const Model::ModifyGatewayRequest& request, const ModifyGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyGatewayOutcomeCallable modifyGatewayCallable(const Model::ModifyGatewayRequest& request) const;
RetryDatabaseOutcome retryDatabase(const Model::RetryDatabaseRequest &request)const;
void retryDatabaseAsync(const Model::RetryDatabaseRequest& request, const RetryDatabaseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RetryDatabaseOutcomeCallable retryDatabaseCallable(const Model::RetryDatabaseRequest& request) const;
StopGatewayOutcome stopGateway(const Model::StopGatewayRequest &request)const;
void stopGatewayAsync(const Model::StopGatewayRequest& request, const StopGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopGatewayOutcomeCallable stopGatewayCallable(const Model::StopGatewayRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_DG_DGCLIENT_H_

View File

@@ -0,0 +1,32 @@
/*
* 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_DG_DGEXPORT_H_
#define ALIBABACLOUD_DG_DGEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_DG_LIBRARY)
# define ALIBABACLOUD_DG_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_DG_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_DG_EXPORT
#endif
#endif // !ALIBABACLOUD_DG_DGEXPORT_H_

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_DG_MODEL_ADDDATABASELISTREQUEST_H_
#define ALIBABACLOUD_DG_MODEL_ADDDATABASELISTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT AddDatabaseListRequest : public RpcServiceRequest
{
public:
AddDatabaseListRequest();
~AddDatabaseListRequest();
std::string getDatabaseString()const;
void setDatabaseString(const std::string& databaseString);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
private:
std::string databaseString_;
std::string clientToken_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_ADDDATABASELISTREQUEST_H_

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_DG_MODEL_ADDDATABASELISTRESULT_H_
#define ALIBABACLOUD_DG_MODEL_ADDDATABASELISTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT AddDatabaseListResult : public ServiceResult
{
public:
AddDatabaseListResult();
explicit AddDatabaseListResult(const std::string &payload);
~AddDatabaseListResult();
std::string getErrorMsg()const;
std::string getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string errorMsg_;
std::string data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_ADDDATABASELISTRESULT_H_

View File

@@ -0,0 +1,75 @@
/*
* 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_DG_MODEL_ADDDATABASEREQUEST_H_
#define ALIBABACLOUD_DG_MODEL_ADDDATABASEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT AddDatabaseRequest : public RpcServiceRequest
{
public:
AddDatabaseRequest();
~AddDatabaseRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getHost()const;
void setHost(const std::string& host);
std::string getDbUserName()const;
void setDbUserName(const std::string& dbUserName);
std::string getDbDescription()const;
void setDbDescription(const std::string& dbDescription);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
std::string getDbName()const;
void setDbName(const std::string& dbName);
int getPort()const;
void setPort(int port);
std::string getDbPassword()const;
void setDbPassword(const std::string& dbPassword);
std::string getDbType()const;
void setDbType(const std::string& dbType);
private:
std::string clientToken_;
std::string regionId_;
std::string host_;
std::string dbUserName_;
std::string dbDescription_;
std::string gatewayId_;
std::string dbName_;
int port_;
std::string dbPassword_;
std::string dbType_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_ADDDATABASEREQUEST_H_

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_DG_MODEL_ADDDATABASERESULT_H_
#define ALIBABACLOUD_DG_MODEL_ADDDATABASERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT AddDatabaseResult : public ServiceResult
{
public:
AddDatabaseResult();
explicit AddDatabaseResult(const std::string &payload);
~AddDatabaseResult();
std::string getErrorMsg()const;
std::string getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string errorMsg_;
std::string data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_ADDDATABASERESULT_H_

View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_DG_MODEL_CONNECTDATABASEREQUEST_H_
#define ALIBABACLOUD_DG_MODEL_CONNECTDATABASEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT ConnectDatabaseRequest : public RpcServiceRequest
{
public:
ConnectDatabaseRequest();
~ConnectDatabaseRequest();
std::string getDbName()const;
void setDbName(const std::string& dbName);
int getPort()const;
void setPort(int port);
std::string getDbPassword()const;
void setDbPassword(const std::string& dbPassword);
std::string getHost()const;
void setHost(const std::string& host);
std::string getDbType()const;
void setDbType(const std::string& dbType);
std::string getDbUserName()const;
void setDbUserName(const std::string& dbUserName);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string dbName_;
int port_;
std::string dbPassword_;
std::string host_;
std::string dbType_;
std::string dbUserName_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_CONNECTDATABASEREQUEST_H_

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_DG_MODEL_CONNECTDATABASERESULT_H_
#define ALIBABACLOUD_DG_MODEL_CONNECTDATABASERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT ConnectDatabaseResult : public ServiceResult
{
public:
ConnectDatabaseResult();
explicit ConnectDatabaseResult(const std::string &payload);
~ConnectDatabaseResult();
std::string getErrorMsg()const;
std::string getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string errorMsg_;
std::string data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_CONNECTDATABASERESULT_H_

View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_DG_MODEL_CREATEDATABASEACCESSPOINTREQUEST_H_
#define ALIBABACLOUD_DG_MODEL_CREATEDATABASEACCESSPOINTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT CreateDatabaseAccessPointRequest : public RpcServiceRequest
{
public:
CreateDatabaseAccessPointRequest();
~CreateDatabaseAccessPointRequest();
std::string getVpcAZone()const;
void setVpcAZone(const std::string& vpcAZone);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getDbInstanceId()const;
void setDbInstanceId(const std::string& dbInstanceId);
std::string getVpcRegionId()const;
void setVpcRegionId(const std::string& vpcRegionId);
std::string getVSwitchId()const;
void setVSwitchId(const std::string& vSwitchId);
std::string getVpcId()const;
void setVpcId(const std::string& vpcId);
private:
std::string vpcAZone_;
std::string clientToken_;
std::string regionId_;
std::string dbInstanceId_;
std::string vpcRegionId_;
std::string vSwitchId_;
std::string vpcId_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_CREATEDATABASEACCESSPOINTREQUEST_H_

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_DG_MODEL_CREATEDATABASEACCESSPOINTRESULT_H_
#define ALIBABACLOUD_DG_MODEL_CREATEDATABASEACCESSPOINTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT CreateDatabaseAccessPointResult : public ServiceResult
{
public:
CreateDatabaseAccessPointResult();
explicit CreateDatabaseAccessPointResult(const std::string &payload);
~CreateDatabaseAccessPointResult();
std::string getErrorMsg()const;
std::string getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string errorMsg_;
std::string data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_CREATEDATABASEACCESSPOINTRESULT_H_

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_DG_MODEL_CREATEGATEWAYREQUEST_H_
#define ALIBABACLOUD_DG_MODEL_CREATEGATEWAYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT CreateGatewayRequest : public RpcServiceRequest
{
public:
CreateGatewayRequest();
~CreateGatewayRequest();
std::string getGatewayDesc()const;
void setGatewayDesc(const std::string& gatewayDesc);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getGatewayName()const;
void setGatewayName(const std::string& gatewayName);
private:
std::string gatewayDesc_;
std::string regionId_;
std::string gatewayName_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_CREATEGATEWAYREQUEST_H_

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_DG_MODEL_CREATEGATEWAYRESULT_H_
#define ALIBABACLOUD_DG_MODEL_CREATEGATEWAYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT CreateGatewayResult : public ServiceResult
{
public:
CreateGatewayResult();
explicit CreateGatewayResult(const std::string &payload);
~CreateGatewayResult();
std::string getErrorMsg()const;
std::string getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string errorMsg_;
std::string data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_CREATEGATEWAYRESULT_H_

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_DG_MODEL_CREATEGATEWAYVERIFYCODEREQUEST_H_
#define ALIBABACLOUD_DG_MODEL_CREATEGATEWAYVERIFYCODEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT CreateGatewayVerifyCodeRequest : public RpcServiceRequest
{
public:
CreateGatewayVerifyCodeRequest();
~CreateGatewayVerifyCodeRequest();
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_CREATEGATEWAYVERIFYCODEREQUEST_H_

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_DG_MODEL_CREATEGATEWAYVERIFYCODERESULT_H_
#define ALIBABACLOUD_DG_MODEL_CREATEGATEWAYVERIFYCODERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT CreateGatewayVerifyCodeResult : public ServiceResult
{
public:
CreateGatewayVerifyCodeResult();
explicit CreateGatewayVerifyCodeResult(const std::string &payload);
~CreateGatewayVerifyCodeResult();
std::string getErrorMsg()const;
std::string getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string errorMsg_;
std::string data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_CREATEGATEWAYVERIFYCODERESULT_H_

View File

@@ -0,0 +1,63 @@
/*
* 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_DG_MODEL_DELETEDATABASEACCESSPOINTREQUEST_H_
#define ALIBABACLOUD_DG_MODEL_DELETEDATABASEACCESSPOINTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT DeleteDatabaseAccessPointRequest : public RpcServiceRequest
{
public:
DeleteDatabaseAccessPointRequest();
~DeleteDatabaseAccessPointRequest();
std::string getVpcAZone()const;
void setVpcAZone(const std::string& vpcAZone);
std::string getVpcRegionId()const;
void setVpcRegionId(const std::string& vpcRegionId);
std::string getVSwitchId()const;
void setVSwitchId(const std::string& vSwitchId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getVpcId()const;
void setVpcId(const std::string& vpcId);
std::string getDbInstanceId()const;
void setDbInstanceId(const std::string& dbInstanceId);
private:
std::string vpcAZone_;
std::string vpcRegionId_;
std::string vSwitchId_;
std::string regionId_;
std::string vpcId_;
std::string dbInstanceId_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_DELETEDATABASEACCESSPOINTREQUEST_H_

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_DG_MODEL_DELETEDATABASEACCESSPOINTRESULT_H_
#define ALIBABACLOUD_DG_MODEL_DELETEDATABASEACCESSPOINTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT DeleteDatabaseAccessPointResult : public ServiceResult
{
public:
DeleteDatabaseAccessPointResult();
explicit DeleteDatabaseAccessPointResult(const std::string &payload);
~DeleteDatabaseAccessPointResult();
std::string getErrorMsg()const;
std::string getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string errorMsg_;
std::string data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_DELETEDATABASEACCESSPOINTRESULT_H_

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_DG_MODEL_DELETEDATABASEREQUEST_H_
#define ALIBABACLOUD_DG_MODEL_DELETEDATABASEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT DeleteDatabaseRequest : public RpcServiceRequest
{
public:
DeleteDatabaseRequest();
~DeleteDatabaseRequest();
std::string getInstanceId()const;
void setInstanceId(const std::string& instanceId);
private:
std::string instanceId_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_DELETEDATABASEREQUEST_H_

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_DG_MODEL_DELETEDATABASERESULT_H_
#define ALIBABACLOUD_DG_MODEL_DELETEDATABASERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT DeleteDatabaseResult : public ServiceResult
{
public:
DeleteDatabaseResult();
explicit DeleteDatabaseResult(const std::string &payload);
~DeleteDatabaseResult();
std::string getErrorMsg()const;
std::string getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string errorMsg_;
std::string data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_DELETEDATABASERESULT_H_

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_DG_MODEL_DELETEGATEWAYINSTANCEREQUEST_H_
#define ALIBABACLOUD_DG_MODEL_DELETEGATEWAYINSTANCEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT DeleteGatewayInstanceRequest : public RpcServiceRequest
{
public:
DeleteGatewayInstanceRequest();
~DeleteGatewayInstanceRequest();
std::string getGatewayInstanceId()const;
void setGatewayInstanceId(const std::string& gatewayInstanceId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string gatewayInstanceId_;
std::string regionId_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_DELETEGATEWAYINSTANCEREQUEST_H_

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_DG_MODEL_DELETEGATEWAYINSTANCERESULT_H_
#define ALIBABACLOUD_DG_MODEL_DELETEGATEWAYINSTANCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT DeleteGatewayInstanceResult : public ServiceResult
{
public:
DeleteGatewayInstanceResult();
explicit DeleteGatewayInstanceResult(const std::string &payload);
~DeleteGatewayInstanceResult();
std::string getErrorMsg()const;
std::string getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string errorMsg_;
std::string data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_DELETEGATEWAYINSTANCERESULT_H_

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_DG_MODEL_DELETEGATEWAYREQUEST_H_
#define ALIBABACLOUD_DG_MODEL_DELETEGATEWAYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT DeleteGatewayRequest : public RpcServiceRequest
{
public:
DeleteGatewayRequest();
~DeleteGatewayRequest();
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_DELETEGATEWAYREQUEST_H_

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_DG_MODEL_DELETEGATEWAYRESULT_H_
#define ALIBABACLOUD_DG_MODEL_DELETEGATEWAYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT DeleteGatewayResult : public ServiceResult
{
public:
DeleteGatewayResult();
explicit DeleteGatewayResult(const std::string &payload);
~DeleteGatewayResult();
std::string getErrorMsg()const;
std::string getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string errorMsg_;
std::string data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_DELETEGATEWAYRESULT_H_

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_DG_MODEL_DESCRIBEREGIONSREQUEST_H_
#define ALIBABACLOUD_DG_MODEL_DESCRIBEREGIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT DescribeRegionsRequest : public RpcServiceRequest
{
public:
DescribeRegionsRequest();
~DescribeRegionsRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_DESCRIBEREGIONSREQUEST_H_

View File

@@ -0,0 +1,63 @@
/*
* 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_DG_MODEL_DESCRIBEREGIONSRESULT_H_
#define ALIBABACLOUD_DG_MODEL_DESCRIBEREGIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT DescribeRegionsResult : public ServiceResult
{
public:
struct Region
{
std::string regionId;
std::string regionEndpoint;
std::string localName;
};
DescribeRegionsResult();
explicit DescribeRegionsResult(const std::string &payload);
~DescribeRegionsResult();
std::string getErrorMsg()const;
std::vector<Region> getRegions()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string errorMsg_;
std::vector<Region> regions_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_DESCRIBEREGIONSRESULT_H_

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_DG_MODEL_DOWNLOADGATEWAYPROGRAMREQUEST_H_
#define ALIBABACLOUD_DG_MODEL_DOWNLOADGATEWAYPROGRAMREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT DownloadGatewayProgramRequest : public RpcServiceRequest
{
public:
DownloadGatewayProgramRequest();
~DownloadGatewayProgramRequest();
std::string getUserOS()const;
void setUserOS(const std::string& userOS);
std::string getDgVersion()const;
void setDgVersion(const std::string& dgVersion);
private:
std::string userOS_;
std::string dgVersion_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_DOWNLOADGATEWAYPROGRAMREQUEST_H_

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_DG_MODEL_DOWNLOADGATEWAYPROGRAMRESULT_H_
#define ALIBABACLOUD_DG_MODEL_DOWNLOADGATEWAYPROGRAMRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT DownloadGatewayProgramResult : public ServiceResult
{
public:
DownloadGatewayProgramResult();
explicit DownloadGatewayProgramResult(const std::string &payload);
~DownloadGatewayProgramResult();
std::string getErrorMsg()const;
std::string getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string errorMsg_;
std::string data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_DOWNLOADGATEWAYPROGRAMRESULT_H_

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_DG_MODEL_FINDUSERGATEWAYBYIDREQUEST_H_
#define ALIBABACLOUD_DG_MODEL_FINDUSERGATEWAYBYIDREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT FindUserGatewayByIdRequest : public RpcServiceRequest
{
public:
FindUserGatewayByIdRequest();
~FindUserGatewayByIdRequest();
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_FINDUSERGATEWAYBYIDREQUEST_H_

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_DG_MODEL_FINDUSERGATEWAYBYIDRESULT_H_
#define ALIBABACLOUD_DG_MODEL_FINDUSERGATEWAYBYIDRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT FindUserGatewayByIdResult : public ServiceResult
{
public:
FindUserGatewayByIdResult();
explicit FindUserGatewayByIdResult(const std::string &payload);
~FindUserGatewayByIdResult();
std::string getErrorMsg()const;
std::string getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string errorMsg_;
std::string data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_FINDUSERGATEWAYBYIDRESULT_H_

View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_DG_MODEL_GETUSERDATABASESREQUEST_H_
#define ALIBABACLOUD_DG_MODEL_GETUSERDATABASESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT GetUserDatabasesRequest : public RpcServiceRequest
{
public:
GetUserDatabasesRequest();
~GetUserDatabasesRequest();
std::string getSearchKey()const;
void setSearchKey(const std::string& searchKey);
std::string getPageNumber()const;
void setPageNumber(const std::string& pageNumber);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getPageSize()const;
void setPageSize(const std::string& pageSize);
std::string getHost()const;
void setHost(const std::string& host);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
std::string getInstanceId()const;
void setInstanceId(const std::string& instanceId);
int getPort()const;
void setPort(int port);
std::string getDbType()const;
void setDbType(const std::string& dbType);
private:
std::string searchKey_;
std::string pageNumber_;
std::string regionId_;
std::string pageSize_;
std::string host_;
std::string gatewayId_;
std::string instanceId_;
int port_;
std::string dbType_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_GETUSERDATABASESREQUEST_H_

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_DG_MODEL_GETUSERDATABASESRESULT_H_
#define ALIBABACLOUD_DG_MODEL_GETUSERDATABASESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT GetUserDatabasesResult : public ServiceResult
{
public:
GetUserDatabasesResult();
explicit GetUserDatabasesResult(const std::string &payload);
~GetUserDatabasesResult();
std::string getErrorMsg()const;
std::string getData()const;
int getCount()const;
std::string getCode()const;
std::string getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string errorMsg_;
std::string data_;
int count_;
std::string code_;
std::string success_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_GETUSERDATABASESRESULT_H_

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_DG_MODEL_GETUSERGATEWAYINSTANCESREQUEST_H_
#define ALIBABACLOUD_DG_MODEL_GETUSERGATEWAYINSTANCESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT GetUserGatewayInstancesRequest : public RpcServiceRequest
{
public:
GetUserGatewayInstancesRequest();
~GetUserGatewayInstancesRequest();
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_GETUSERGATEWAYINSTANCESREQUEST_H_

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_DG_MODEL_GETUSERGATEWAYINSTANCESRESULT_H_
#define ALIBABACLOUD_DG_MODEL_GETUSERGATEWAYINSTANCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT GetUserGatewayInstancesResult : public ServiceResult
{
public:
GetUserGatewayInstancesResult();
explicit GetUserGatewayInstancesResult(const std::string &payload);
~GetUserGatewayInstancesResult();
std::string getErrorMsg()const;
std::string getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string errorMsg_;
std::string data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_GETUSERGATEWAYINSTANCESRESULT_H_

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_DG_MODEL_GETUSERGATEWAYSREQUEST_H_
#define ALIBABACLOUD_DG_MODEL_GETUSERGATEWAYSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT GetUserGatewaysRequest : public RpcServiceRequest
{
public:
GetUserGatewaysRequest();
~GetUserGatewaysRequest();
std::string getSearchKey()const;
void setSearchKey(const std::string& searchKey);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getPageSize()const;
void setPageSize(int pageSize);
private:
std::string searchKey_;
int pageNumber_;
std::string regionId_;
int pageSize_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_GETUSERGATEWAYSREQUEST_H_

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_DG_MODEL_GETUSERGATEWAYSRESULT_H_
#define ALIBABACLOUD_DG_MODEL_GETUSERGATEWAYSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT GetUserGatewaysResult : public ServiceResult
{
public:
GetUserGatewaysResult();
explicit GetUserGatewaysResult(const std::string &payload);
~GetUserGatewaysResult();
std::string getErrorMsg()const;
std::string getData()const;
int getCount()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string errorMsg_;
std::string data_;
int count_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_GETUSERGATEWAYSRESULT_H_

View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_DG_MODEL_LISTDATABASEACCESSPOINTREQUEST_H_
#define ALIBABACLOUD_DG_MODEL_LISTDATABASEACCESSPOINTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT ListDatabaseAccessPointRequest : public RpcServiceRequest
{
public:
ListDatabaseAccessPointRequest();
~ListDatabaseAccessPointRequest();
std::string getSearchKey()const;
void setSearchKey(const std::string& searchKey);
std::string getPageNumber()const;
void setPageNumber(const std::string& pageNumber);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getPageSize()const;
void setPageSize(const std::string& pageSize);
std::string getHost()const;
void setHost(const std::string& host);
std::string getDbInstanceId()const;
void setDbInstanceId(const std::string& dbInstanceId);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
int getPort()const;
void setPort(int port);
std::string getVpcId()const;
void setVpcId(const std::string& vpcId);
private:
std::string searchKey_;
std::string pageNumber_;
std::string regionId_;
std::string pageSize_;
std::string host_;
std::string dbInstanceId_;
std::string gatewayId_;
int port_;
std::string vpcId_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_LISTDATABASEACCESSPOINTREQUEST_H_

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_DG_MODEL_LISTDATABASEACCESSPOINTRESULT_H_
#define ALIBABACLOUD_DG_MODEL_LISTDATABASEACCESSPOINTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT ListDatabaseAccessPointResult : public ServiceResult
{
public:
ListDatabaseAccessPointResult();
explicit ListDatabaseAccessPointResult(const std::string &payload);
~ListDatabaseAccessPointResult();
std::string getErrorMsg()const;
std::string getData()const;
int getCount()const;
std::string getCode()const;
std::string getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string errorMsg_;
std::string data_;
int count_;
std::string code_;
std::string success_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_LISTDATABASEACCESSPOINTRESULT_H_

View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_DG_MODEL_MODIFYDATABASEREQUEST_H_
#define ALIBABACLOUD_DG_MODEL_MODIFYDATABASEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT ModifyDatabaseRequest : public RpcServiceRequest
{
public:
ModifyDatabaseRequest();
~ModifyDatabaseRequest();
std::string getHost()const;
void setHost(const std::string& host);
std::string getDbUserName()const;
void setDbUserName(const std::string& dbUserName);
std::string getDbDescription()const;
void setDbDescription(const std::string& dbDescription);
std::string getInstanceId()const;
void setInstanceId(const std::string& instanceId);
std::string getDbName()const;
void setDbName(const std::string& dbName);
int getPort()const;
void setPort(int port);
std::string getDbPassword()const;
void setDbPassword(const std::string& dbPassword);
std::string getDbType()const;
void setDbType(const std::string& dbType);
private:
std::string host_;
std::string dbUserName_;
std::string dbDescription_;
std::string instanceId_;
std::string dbName_;
int port_;
std::string dbPassword_;
std::string dbType_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_MODIFYDATABASEREQUEST_H_

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_DG_MODEL_MODIFYDATABASERESULT_H_
#define ALIBABACLOUD_DG_MODEL_MODIFYDATABASERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT ModifyDatabaseResult : public ServiceResult
{
public:
ModifyDatabaseResult();
explicit ModifyDatabaseResult(const std::string &payload);
~ModifyDatabaseResult();
std::string getErrorMsg()const;
std::string getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string errorMsg_;
std::string data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_MODIFYDATABASERESULT_H_

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_DG_MODEL_MODIFYGATEWAYREQUEST_H_
#define ALIBABACLOUD_DG_MODEL_MODIFYGATEWAYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT ModifyGatewayRequest : public RpcServiceRequest
{
public:
ModifyGatewayRequest();
~ModifyGatewayRequest();
std::string getGatewayDesc()const;
void setGatewayDesc(const std::string& gatewayDesc);
std::string getGatewayName()const;
void setGatewayName(const std::string& gatewayName);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string gatewayDesc_;
std::string gatewayName_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_MODIFYGATEWAYREQUEST_H_

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_DG_MODEL_MODIFYGATEWAYRESULT_H_
#define ALIBABACLOUD_DG_MODEL_MODIFYGATEWAYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT ModifyGatewayResult : public ServiceResult
{
public:
ModifyGatewayResult();
explicit ModifyGatewayResult(const std::string &payload);
~ModifyGatewayResult();
std::string getErrorMsg()const;
std::string getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string errorMsg_;
std::string data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_MODIFYGATEWAYRESULT_H_

View File

@@ -0,0 +1,75 @@
/*
* 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_DG_MODEL_RETRYDATABASEREQUEST_H_
#define ALIBABACLOUD_DG_MODEL_RETRYDATABASEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT RetryDatabaseRequest : public RpcServiceRequest
{
public:
RetryDatabaseRequest();
~RetryDatabaseRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getHost()const;
void setHost(const std::string& host);
std::string getDbUserName()const;
void setDbUserName(const std::string& dbUserName);
std::string getDbDescription()const;
void setDbDescription(const std::string& dbDescription);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
std::string getDbName()const;
void setDbName(const std::string& dbName);
int getPort()const;
void setPort(int port);
std::string getDbPassword()const;
void setDbPassword(const std::string& dbPassword);
std::string getDbType()const;
void setDbType(const std::string& dbType);
private:
std::string clientToken_;
std::string regionId_;
std::string host_;
std::string dbUserName_;
std::string dbDescription_;
std::string gatewayId_;
std::string dbName_;
int port_;
std::string dbPassword_;
std::string dbType_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_RETRYDATABASEREQUEST_H_

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_DG_MODEL_RETRYDATABASERESULT_H_
#define ALIBABACLOUD_DG_MODEL_RETRYDATABASERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT RetryDatabaseResult : public ServiceResult
{
public:
RetryDatabaseResult();
explicit RetryDatabaseResult(const std::string &payload);
~RetryDatabaseResult();
std::string getErrorMsg()const;
std::string getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string errorMsg_;
std::string data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_RETRYDATABASERESULT_H_

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_DG_MODEL_STOPGATEWAYREQUEST_H_
#define ALIBABACLOUD_DG_MODEL_STOPGATEWAYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT StopGatewayRequest : public RpcServiceRequest
{
public:
StopGatewayRequest();
~StopGatewayRequest();
std::string getGatewayInstanceId()const;
void setGatewayInstanceId(const std::string& gatewayInstanceId);
std::string getGatewayId()const;
void setGatewayId(const std::string& gatewayId);
private:
std::string gatewayInstanceId_;
std::string gatewayId_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_STOPGATEWAYREQUEST_H_

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_DG_MODEL_STOPGATEWAYRESULT_H_
#define ALIBABACLOUD_DG_MODEL_STOPGATEWAYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dg/DgExport.h>
namespace AlibabaCloud
{
namespace Dg
{
namespace Model
{
class ALIBABACLOUD_DG_EXPORT StopGatewayResult : public ServiceResult
{
public:
StopGatewayResult();
explicit StopGatewayResult(const std::string &payload);
~StopGatewayResult();
std::string getErrorMsg()const;
std::string getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string errorMsg_;
std::string data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_DG_MODEL_STOPGATEWAYRESULT_H_

809
dg/src/DgClient.cc Normal file
View File

@@ -0,0 +1,809 @@
/*
* 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/dg/DgClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::Dg;
using namespace AlibabaCloud::Dg::Model;
namespace
{
const std::string SERVICE_NAME = "dg";
}
DgClient::DgClient(const Credentials &credentials, const ClientConfiguration &configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "dg");
}
DgClient::DgClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "dg");
}
DgClient::DgClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "dg");
}
DgClient::~DgClient()
{}
DgClient::AddDatabaseOutcome DgClient::addDatabase(const AddDatabaseRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AddDatabaseOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AddDatabaseOutcome(AddDatabaseResult(outcome.result()));
else
return AddDatabaseOutcome(outcome.error());
}
void DgClient::addDatabaseAsync(const AddDatabaseRequest& request, const AddDatabaseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, addDatabase(request), context);
};
asyncExecute(new Runnable(fn));
}
DgClient::AddDatabaseOutcomeCallable DgClient::addDatabaseCallable(const AddDatabaseRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AddDatabaseOutcome()>>(
[this, request]()
{
return this->addDatabase(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DgClient::AddDatabaseListOutcome DgClient::addDatabaseList(const AddDatabaseListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AddDatabaseListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AddDatabaseListOutcome(AddDatabaseListResult(outcome.result()));
else
return AddDatabaseListOutcome(outcome.error());
}
void DgClient::addDatabaseListAsync(const AddDatabaseListRequest& request, const AddDatabaseListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, addDatabaseList(request), context);
};
asyncExecute(new Runnable(fn));
}
DgClient::AddDatabaseListOutcomeCallable DgClient::addDatabaseListCallable(const AddDatabaseListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AddDatabaseListOutcome()>>(
[this, request]()
{
return this->addDatabaseList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DgClient::ConnectDatabaseOutcome DgClient::connectDatabase(const ConnectDatabaseRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ConnectDatabaseOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ConnectDatabaseOutcome(ConnectDatabaseResult(outcome.result()));
else
return ConnectDatabaseOutcome(outcome.error());
}
void DgClient::connectDatabaseAsync(const ConnectDatabaseRequest& request, const ConnectDatabaseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, connectDatabase(request), context);
};
asyncExecute(new Runnable(fn));
}
DgClient::ConnectDatabaseOutcomeCallable DgClient::connectDatabaseCallable(const ConnectDatabaseRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ConnectDatabaseOutcome()>>(
[this, request]()
{
return this->connectDatabase(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DgClient::CreateDatabaseAccessPointOutcome DgClient::createDatabaseAccessPoint(const CreateDatabaseAccessPointRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateDatabaseAccessPointOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateDatabaseAccessPointOutcome(CreateDatabaseAccessPointResult(outcome.result()));
else
return CreateDatabaseAccessPointOutcome(outcome.error());
}
void DgClient::createDatabaseAccessPointAsync(const CreateDatabaseAccessPointRequest& request, const CreateDatabaseAccessPointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createDatabaseAccessPoint(request), context);
};
asyncExecute(new Runnable(fn));
}
DgClient::CreateDatabaseAccessPointOutcomeCallable DgClient::createDatabaseAccessPointCallable(const CreateDatabaseAccessPointRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateDatabaseAccessPointOutcome()>>(
[this, request]()
{
return this->createDatabaseAccessPoint(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DgClient::CreateGatewayOutcome DgClient::createGateway(const CreateGatewayRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateGatewayOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateGatewayOutcome(CreateGatewayResult(outcome.result()));
else
return CreateGatewayOutcome(outcome.error());
}
void DgClient::createGatewayAsync(const CreateGatewayRequest& request, const CreateGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createGateway(request), context);
};
asyncExecute(new Runnable(fn));
}
DgClient::CreateGatewayOutcomeCallable DgClient::createGatewayCallable(const CreateGatewayRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateGatewayOutcome()>>(
[this, request]()
{
return this->createGateway(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DgClient::CreateGatewayVerifyCodeOutcome DgClient::createGatewayVerifyCode(const CreateGatewayVerifyCodeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateGatewayVerifyCodeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateGatewayVerifyCodeOutcome(CreateGatewayVerifyCodeResult(outcome.result()));
else
return CreateGatewayVerifyCodeOutcome(outcome.error());
}
void DgClient::createGatewayVerifyCodeAsync(const CreateGatewayVerifyCodeRequest& request, const CreateGatewayVerifyCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createGatewayVerifyCode(request), context);
};
asyncExecute(new Runnable(fn));
}
DgClient::CreateGatewayVerifyCodeOutcomeCallable DgClient::createGatewayVerifyCodeCallable(const CreateGatewayVerifyCodeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateGatewayVerifyCodeOutcome()>>(
[this, request]()
{
return this->createGatewayVerifyCode(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DgClient::DeleteDatabaseOutcome DgClient::deleteDatabase(const DeleteDatabaseRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteDatabaseOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteDatabaseOutcome(DeleteDatabaseResult(outcome.result()));
else
return DeleteDatabaseOutcome(outcome.error());
}
void DgClient::deleteDatabaseAsync(const DeleteDatabaseRequest& request, const DeleteDatabaseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteDatabase(request), context);
};
asyncExecute(new Runnable(fn));
}
DgClient::DeleteDatabaseOutcomeCallable DgClient::deleteDatabaseCallable(const DeleteDatabaseRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteDatabaseOutcome()>>(
[this, request]()
{
return this->deleteDatabase(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DgClient::DeleteDatabaseAccessPointOutcome DgClient::deleteDatabaseAccessPoint(const DeleteDatabaseAccessPointRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteDatabaseAccessPointOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteDatabaseAccessPointOutcome(DeleteDatabaseAccessPointResult(outcome.result()));
else
return DeleteDatabaseAccessPointOutcome(outcome.error());
}
void DgClient::deleteDatabaseAccessPointAsync(const DeleteDatabaseAccessPointRequest& request, const DeleteDatabaseAccessPointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteDatabaseAccessPoint(request), context);
};
asyncExecute(new Runnable(fn));
}
DgClient::DeleteDatabaseAccessPointOutcomeCallable DgClient::deleteDatabaseAccessPointCallable(const DeleteDatabaseAccessPointRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteDatabaseAccessPointOutcome()>>(
[this, request]()
{
return this->deleteDatabaseAccessPoint(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DgClient::DeleteGatewayOutcome DgClient::deleteGateway(const DeleteGatewayRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteGatewayOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteGatewayOutcome(DeleteGatewayResult(outcome.result()));
else
return DeleteGatewayOutcome(outcome.error());
}
void DgClient::deleteGatewayAsync(const DeleteGatewayRequest& request, const DeleteGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteGateway(request), context);
};
asyncExecute(new Runnable(fn));
}
DgClient::DeleteGatewayOutcomeCallable DgClient::deleteGatewayCallable(const DeleteGatewayRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteGatewayOutcome()>>(
[this, request]()
{
return this->deleteGateway(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DgClient::DeleteGatewayInstanceOutcome DgClient::deleteGatewayInstance(const DeleteGatewayInstanceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteGatewayInstanceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteGatewayInstanceOutcome(DeleteGatewayInstanceResult(outcome.result()));
else
return DeleteGatewayInstanceOutcome(outcome.error());
}
void DgClient::deleteGatewayInstanceAsync(const DeleteGatewayInstanceRequest& request, const DeleteGatewayInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteGatewayInstance(request), context);
};
asyncExecute(new Runnable(fn));
}
DgClient::DeleteGatewayInstanceOutcomeCallable DgClient::deleteGatewayInstanceCallable(const DeleteGatewayInstanceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteGatewayInstanceOutcome()>>(
[this, request]()
{
return this->deleteGatewayInstance(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DgClient::DescribeRegionsOutcome DgClient::describeRegions(const DescribeRegionsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeRegionsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeRegionsOutcome(DescribeRegionsResult(outcome.result()));
else
return DescribeRegionsOutcome(outcome.error());
}
void DgClient::describeRegionsAsync(const DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeRegions(request), context);
};
asyncExecute(new Runnable(fn));
}
DgClient::DescribeRegionsOutcomeCallable DgClient::describeRegionsCallable(const DescribeRegionsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeRegionsOutcome()>>(
[this, request]()
{
return this->describeRegions(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DgClient::DownloadGatewayProgramOutcome DgClient::downloadGatewayProgram(const DownloadGatewayProgramRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DownloadGatewayProgramOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DownloadGatewayProgramOutcome(DownloadGatewayProgramResult(outcome.result()));
else
return DownloadGatewayProgramOutcome(outcome.error());
}
void DgClient::downloadGatewayProgramAsync(const DownloadGatewayProgramRequest& request, const DownloadGatewayProgramAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, downloadGatewayProgram(request), context);
};
asyncExecute(new Runnable(fn));
}
DgClient::DownloadGatewayProgramOutcomeCallable DgClient::downloadGatewayProgramCallable(const DownloadGatewayProgramRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DownloadGatewayProgramOutcome()>>(
[this, request]()
{
return this->downloadGatewayProgram(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DgClient::FindUserGatewayByIdOutcome DgClient::findUserGatewayById(const FindUserGatewayByIdRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return FindUserGatewayByIdOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return FindUserGatewayByIdOutcome(FindUserGatewayByIdResult(outcome.result()));
else
return FindUserGatewayByIdOutcome(outcome.error());
}
void DgClient::findUserGatewayByIdAsync(const FindUserGatewayByIdRequest& request, const FindUserGatewayByIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, findUserGatewayById(request), context);
};
asyncExecute(new Runnable(fn));
}
DgClient::FindUserGatewayByIdOutcomeCallable DgClient::findUserGatewayByIdCallable(const FindUserGatewayByIdRequest &request) const
{
auto task = std::make_shared<std::packaged_task<FindUserGatewayByIdOutcome()>>(
[this, request]()
{
return this->findUserGatewayById(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DgClient::GetUserDatabasesOutcome DgClient::getUserDatabases(const GetUserDatabasesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetUserDatabasesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetUserDatabasesOutcome(GetUserDatabasesResult(outcome.result()));
else
return GetUserDatabasesOutcome(outcome.error());
}
void DgClient::getUserDatabasesAsync(const GetUserDatabasesRequest& request, const GetUserDatabasesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getUserDatabases(request), context);
};
asyncExecute(new Runnable(fn));
}
DgClient::GetUserDatabasesOutcomeCallable DgClient::getUserDatabasesCallable(const GetUserDatabasesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetUserDatabasesOutcome()>>(
[this, request]()
{
return this->getUserDatabases(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DgClient::GetUserGatewayInstancesOutcome DgClient::getUserGatewayInstances(const GetUserGatewayInstancesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetUserGatewayInstancesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetUserGatewayInstancesOutcome(GetUserGatewayInstancesResult(outcome.result()));
else
return GetUserGatewayInstancesOutcome(outcome.error());
}
void DgClient::getUserGatewayInstancesAsync(const GetUserGatewayInstancesRequest& request, const GetUserGatewayInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getUserGatewayInstances(request), context);
};
asyncExecute(new Runnable(fn));
}
DgClient::GetUserGatewayInstancesOutcomeCallable DgClient::getUserGatewayInstancesCallable(const GetUserGatewayInstancesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetUserGatewayInstancesOutcome()>>(
[this, request]()
{
return this->getUserGatewayInstances(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DgClient::GetUserGatewaysOutcome DgClient::getUserGateways(const GetUserGatewaysRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetUserGatewaysOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetUserGatewaysOutcome(GetUserGatewaysResult(outcome.result()));
else
return GetUserGatewaysOutcome(outcome.error());
}
void DgClient::getUserGatewaysAsync(const GetUserGatewaysRequest& request, const GetUserGatewaysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getUserGateways(request), context);
};
asyncExecute(new Runnable(fn));
}
DgClient::GetUserGatewaysOutcomeCallable DgClient::getUserGatewaysCallable(const GetUserGatewaysRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetUserGatewaysOutcome()>>(
[this, request]()
{
return this->getUserGateways(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DgClient::ListDatabaseAccessPointOutcome DgClient::listDatabaseAccessPoint(const ListDatabaseAccessPointRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListDatabaseAccessPointOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListDatabaseAccessPointOutcome(ListDatabaseAccessPointResult(outcome.result()));
else
return ListDatabaseAccessPointOutcome(outcome.error());
}
void DgClient::listDatabaseAccessPointAsync(const ListDatabaseAccessPointRequest& request, const ListDatabaseAccessPointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listDatabaseAccessPoint(request), context);
};
asyncExecute(new Runnable(fn));
}
DgClient::ListDatabaseAccessPointOutcomeCallable DgClient::listDatabaseAccessPointCallable(const ListDatabaseAccessPointRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListDatabaseAccessPointOutcome()>>(
[this, request]()
{
return this->listDatabaseAccessPoint(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DgClient::ModifyDatabaseOutcome DgClient::modifyDatabase(const ModifyDatabaseRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyDatabaseOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyDatabaseOutcome(ModifyDatabaseResult(outcome.result()));
else
return ModifyDatabaseOutcome(outcome.error());
}
void DgClient::modifyDatabaseAsync(const ModifyDatabaseRequest& request, const ModifyDatabaseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyDatabase(request), context);
};
asyncExecute(new Runnable(fn));
}
DgClient::ModifyDatabaseOutcomeCallable DgClient::modifyDatabaseCallable(const ModifyDatabaseRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyDatabaseOutcome()>>(
[this, request]()
{
return this->modifyDatabase(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DgClient::ModifyGatewayOutcome DgClient::modifyGateway(const ModifyGatewayRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyGatewayOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyGatewayOutcome(ModifyGatewayResult(outcome.result()));
else
return ModifyGatewayOutcome(outcome.error());
}
void DgClient::modifyGatewayAsync(const ModifyGatewayRequest& request, const ModifyGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyGateway(request), context);
};
asyncExecute(new Runnable(fn));
}
DgClient::ModifyGatewayOutcomeCallable DgClient::modifyGatewayCallable(const ModifyGatewayRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyGatewayOutcome()>>(
[this, request]()
{
return this->modifyGateway(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DgClient::RetryDatabaseOutcome DgClient::retryDatabase(const RetryDatabaseRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RetryDatabaseOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RetryDatabaseOutcome(RetryDatabaseResult(outcome.result()));
else
return RetryDatabaseOutcome(outcome.error());
}
void DgClient::retryDatabaseAsync(const RetryDatabaseRequest& request, const RetryDatabaseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, retryDatabase(request), context);
};
asyncExecute(new Runnable(fn));
}
DgClient::RetryDatabaseOutcomeCallable DgClient::retryDatabaseCallable(const RetryDatabaseRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RetryDatabaseOutcome()>>(
[this, request]()
{
return this->retryDatabase(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DgClient::StopGatewayOutcome DgClient::stopGateway(const StopGatewayRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StopGatewayOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StopGatewayOutcome(StopGatewayResult(outcome.result()));
else
return StopGatewayOutcome(outcome.error());
}
void DgClient::stopGatewayAsync(const StopGatewayRequest& request, const StopGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, stopGateway(request), context);
};
asyncExecute(new Runnable(fn));
}
DgClient::StopGatewayOutcomeCallable DgClient::stopGatewayCallable(const StopGatewayRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StopGatewayOutcome()>>(
[this, request]()
{
return this->stopGateway(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

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/dg/model/AddDatabaseListRequest.h>
using AlibabaCloud::Dg::Model::AddDatabaseListRequest;
AddDatabaseListRequest::AddDatabaseListRequest() :
RpcServiceRequest("dg", "2019-03-27", "AddDatabaseList")
{
setMethod(HttpRequest::Method::Post);
}
AddDatabaseListRequest::~AddDatabaseListRequest()
{}
std::string AddDatabaseListRequest::getDatabaseString()const
{
return databaseString_;
}
void AddDatabaseListRequest::setDatabaseString(const std::string& databaseString)
{
databaseString_ = databaseString;
setBodyParameter("DatabaseString", databaseString);
}
std::string AddDatabaseListRequest::getClientToken()const
{
return clientToken_;
}
void AddDatabaseListRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setBodyParameter("ClientToken", clientToken);
}

View File

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

View File

@@ -0,0 +1,139 @@
/*
* 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/dg/model/AddDatabaseRequest.h>
using AlibabaCloud::Dg::Model::AddDatabaseRequest;
AddDatabaseRequest::AddDatabaseRequest() :
RpcServiceRequest("dg", "2019-03-27", "AddDatabase")
{
setMethod(HttpRequest::Method::Post);
}
AddDatabaseRequest::~AddDatabaseRequest()
{}
std::string AddDatabaseRequest::getClientToken()const
{
return clientToken_;
}
void AddDatabaseRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setBodyParameter("ClientToken", clientToken);
}
std::string AddDatabaseRequest::getRegionId()const
{
return regionId_;
}
void AddDatabaseRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setBodyParameter("RegionId", regionId);
}
std::string AddDatabaseRequest::getHost()const
{
return host_;
}
void AddDatabaseRequest::setHost(const std::string& host)
{
host_ = host;
setBodyParameter("Host", host);
}
std::string AddDatabaseRequest::getDbUserName()const
{
return dbUserName_;
}
void AddDatabaseRequest::setDbUserName(const std::string& dbUserName)
{
dbUserName_ = dbUserName;
setBodyParameter("DbUserName", dbUserName);
}
std::string AddDatabaseRequest::getDbDescription()const
{
return dbDescription_;
}
void AddDatabaseRequest::setDbDescription(const std::string& dbDescription)
{
dbDescription_ = dbDescription;
setBodyParameter("DbDescription", dbDescription);
}
std::string AddDatabaseRequest::getGatewayId()const
{
return gatewayId_;
}
void AddDatabaseRequest::setGatewayId(const std::string& gatewayId)
{
gatewayId_ = gatewayId;
setBodyParameter("GatewayId", gatewayId);
}
std::string AddDatabaseRequest::getDbName()const
{
return dbName_;
}
void AddDatabaseRequest::setDbName(const std::string& dbName)
{
dbName_ = dbName;
setBodyParameter("DbName", dbName);
}
int AddDatabaseRequest::getPort()const
{
return port_;
}
void AddDatabaseRequest::setPort(int port)
{
port_ = port;
setBodyParameter("Port", std::to_string(port));
}
std::string AddDatabaseRequest::getDbPassword()const
{
return dbPassword_;
}
void AddDatabaseRequest::setDbPassword(const std::string& dbPassword)
{
dbPassword_ = dbPassword;
setBodyParameter("DbPassword", dbPassword);
}
std::string AddDatabaseRequest::getDbType()const
{
return dbType_;
}
void AddDatabaseRequest::setDbType(const std::string& dbType)
{
dbType_ = dbType;
setBodyParameter("DbType", dbType);
}

View File

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

View File

@@ -0,0 +1,106 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/dg/model/ConnectDatabaseRequest.h>
using AlibabaCloud::Dg::Model::ConnectDatabaseRequest;
ConnectDatabaseRequest::ConnectDatabaseRequest() :
RpcServiceRequest("dg", "2019-03-27", "ConnectDatabase")
{
setMethod(HttpRequest::Method::Post);
}
ConnectDatabaseRequest::~ConnectDatabaseRequest()
{}
std::string ConnectDatabaseRequest::getDbName()const
{
return dbName_;
}
void ConnectDatabaseRequest::setDbName(const std::string& dbName)
{
dbName_ = dbName;
setBodyParameter("DbName", dbName);
}
int ConnectDatabaseRequest::getPort()const
{
return port_;
}
void ConnectDatabaseRequest::setPort(int port)
{
port_ = port;
setBodyParameter("Port", std::to_string(port));
}
std::string ConnectDatabaseRequest::getDbPassword()const
{
return dbPassword_;
}
void ConnectDatabaseRequest::setDbPassword(const std::string& dbPassword)
{
dbPassword_ = dbPassword;
setBodyParameter("DbPassword", dbPassword);
}
std::string ConnectDatabaseRequest::getHost()const
{
return host_;
}
void ConnectDatabaseRequest::setHost(const std::string& host)
{
host_ = host;
setBodyParameter("Host", host);
}
std::string ConnectDatabaseRequest::getDbType()const
{
return dbType_;
}
void ConnectDatabaseRequest::setDbType(const std::string& dbType)
{
dbType_ = dbType;
setBodyParameter("DbType", dbType);
}
std::string ConnectDatabaseRequest::getDbUserName()const
{
return dbUserName_;
}
void ConnectDatabaseRequest::setDbUserName(const std::string& dbUserName)
{
dbUserName_ = dbUserName;
setBodyParameter("DbUserName", dbUserName);
}
std::string ConnectDatabaseRequest::getGatewayId()const
{
return gatewayId_;
}
void ConnectDatabaseRequest::setGatewayId(const std::string& gatewayId)
{
gatewayId_ = gatewayId;
setBodyParameter("GatewayId", gatewayId);
}

View File

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

View File

@@ -0,0 +1,106 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/dg/model/CreateDatabaseAccessPointRequest.h>
using AlibabaCloud::Dg::Model::CreateDatabaseAccessPointRequest;
CreateDatabaseAccessPointRequest::CreateDatabaseAccessPointRequest() :
RpcServiceRequest("dg", "2019-03-27", "CreateDatabaseAccessPoint")
{
setMethod(HttpRequest::Method::Post);
}
CreateDatabaseAccessPointRequest::~CreateDatabaseAccessPointRequest()
{}
std::string CreateDatabaseAccessPointRequest::getVpcAZone()const
{
return vpcAZone_;
}
void CreateDatabaseAccessPointRequest::setVpcAZone(const std::string& vpcAZone)
{
vpcAZone_ = vpcAZone;
setBodyParameter("VpcAZone", vpcAZone);
}
std::string CreateDatabaseAccessPointRequest::getClientToken()const
{
return clientToken_;
}
void CreateDatabaseAccessPointRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setBodyParameter("ClientToken", clientToken);
}
std::string CreateDatabaseAccessPointRequest::getRegionId()const
{
return regionId_;
}
void CreateDatabaseAccessPointRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setBodyParameter("RegionId", regionId);
}
std::string CreateDatabaseAccessPointRequest::getDbInstanceId()const
{
return dbInstanceId_;
}
void CreateDatabaseAccessPointRequest::setDbInstanceId(const std::string& dbInstanceId)
{
dbInstanceId_ = dbInstanceId;
setBodyParameter("DbInstanceId", dbInstanceId);
}
std::string CreateDatabaseAccessPointRequest::getVpcRegionId()const
{
return vpcRegionId_;
}
void CreateDatabaseAccessPointRequest::setVpcRegionId(const std::string& vpcRegionId)
{
vpcRegionId_ = vpcRegionId;
setBodyParameter("VpcRegionId", vpcRegionId);
}
std::string CreateDatabaseAccessPointRequest::getVSwitchId()const
{
return vSwitchId_;
}
void CreateDatabaseAccessPointRequest::setVSwitchId(const std::string& vSwitchId)
{
vSwitchId_ = vSwitchId;
setBodyParameter("VSwitchId", vSwitchId);
}
std::string CreateDatabaseAccessPointRequest::getVpcId()const
{
return vpcId_;
}
void CreateDatabaseAccessPointRequest::setVpcId(const std::string& vpcId)
{
vpcId_ = vpcId;
setBodyParameter("VpcId", vpcId);
}

View File

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

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/dg/model/CreateGatewayRequest.h>
using AlibabaCloud::Dg::Model::CreateGatewayRequest;
CreateGatewayRequest::CreateGatewayRequest() :
RpcServiceRequest("dg", "2019-03-27", "CreateGateway")
{
setMethod(HttpRequest::Method::Post);
}
CreateGatewayRequest::~CreateGatewayRequest()
{}
std::string CreateGatewayRequest::getGatewayDesc()const
{
return gatewayDesc_;
}
void CreateGatewayRequest::setGatewayDesc(const std::string& gatewayDesc)
{
gatewayDesc_ = gatewayDesc;
setBodyParameter("GatewayDesc", gatewayDesc);
}
std::string CreateGatewayRequest::getRegionId()const
{
return regionId_;
}
void CreateGatewayRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setBodyParameter("RegionId", regionId);
}
std::string CreateGatewayRequest::getGatewayName()const
{
return gatewayName_;
}
void CreateGatewayRequest::setGatewayName(const std::string& gatewayName)
{
gatewayName_ = gatewayName;
setBodyParameter("GatewayName", gatewayName);
}

View File

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

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/dg/model/CreateGatewayVerifyCodeRequest.h>
using AlibabaCloud::Dg::Model::CreateGatewayVerifyCodeRequest;
CreateGatewayVerifyCodeRequest::CreateGatewayVerifyCodeRequest() :
RpcServiceRequest("dg", "2019-03-27", "CreateGatewayVerifyCode")
{
setMethod(HttpRequest::Method::Post);
}
CreateGatewayVerifyCodeRequest::~CreateGatewayVerifyCodeRequest()
{}
std::string CreateGatewayVerifyCodeRequest::getGatewayId()const
{
return gatewayId_;
}
void CreateGatewayVerifyCodeRequest::setGatewayId(const std::string& gatewayId)
{
gatewayId_ = gatewayId;
setBodyParameter("GatewayId", gatewayId);
}

View File

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

View File

@@ -0,0 +1,95 @@
/*
* 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/dg/model/DeleteDatabaseAccessPointRequest.h>
using AlibabaCloud::Dg::Model::DeleteDatabaseAccessPointRequest;
DeleteDatabaseAccessPointRequest::DeleteDatabaseAccessPointRequest() :
RpcServiceRequest("dg", "2019-03-27", "DeleteDatabaseAccessPoint")
{
setMethod(HttpRequest::Method::Post);
}
DeleteDatabaseAccessPointRequest::~DeleteDatabaseAccessPointRequest()
{}
std::string DeleteDatabaseAccessPointRequest::getVpcAZone()const
{
return vpcAZone_;
}
void DeleteDatabaseAccessPointRequest::setVpcAZone(const std::string& vpcAZone)
{
vpcAZone_ = vpcAZone;
setBodyParameter("VpcAZone", vpcAZone);
}
std::string DeleteDatabaseAccessPointRequest::getVpcRegionId()const
{
return vpcRegionId_;
}
void DeleteDatabaseAccessPointRequest::setVpcRegionId(const std::string& vpcRegionId)
{
vpcRegionId_ = vpcRegionId;
setBodyParameter("VpcRegionId", vpcRegionId);
}
std::string DeleteDatabaseAccessPointRequest::getVSwitchId()const
{
return vSwitchId_;
}
void DeleteDatabaseAccessPointRequest::setVSwitchId(const std::string& vSwitchId)
{
vSwitchId_ = vSwitchId;
setBodyParameter("VSwitchId", vSwitchId);
}
std::string DeleteDatabaseAccessPointRequest::getRegionId()const
{
return regionId_;
}
void DeleteDatabaseAccessPointRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setBodyParameter("RegionId", regionId);
}
std::string DeleteDatabaseAccessPointRequest::getVpcId()const
{
return vpcId_;
}
void DeleteDatabaseAccessPointRequest::setVpcId(const std::string& vpcId)
{
vpcId_ = vpcId;
setBodyParameter("VpcId", vpcId);
}
std::string DeleteDatabaseAccessPointRequest::getDbInstanceId()const
{
return dbInstanceId_;
}
void DeleteDatabaseAccessPointRequest::setDbInstanceId(const std::string& dbInstanceId)
{
dbInstanceId_ = dbInstanceId;
setBodyParameter("DbInstanceId", dbInstanceId);
}

View File

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

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/dg/model/DeleteDatabaseRequest.h>
using AlibabaCloud::Dg::Model::DeleteDatabaseRequest;
DeleteDatabaseRequest::DeleteDatabaseRequest() :
RpcServiceRequest("dg", "2019-03-27", "DeleteDatabase")
{
setMethod(HttpRequest::Method::Post);
}
DeleteDatabaseRequest::~DeleteDatabaseRequest()
{}
std::string DeleteDatabaseRequest::getInstanceId()const
{
return instanceId_;
}
void DeleteDatabaseRequest::setInstanceId(const std::string& instanceId)
{
instanceId_ = instanceId;
setBodyParameter("InstanceId", instanceId);
}

View File

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

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/dg/model/DeleteGatewayInstanceRequest.h>
using AlibabaCloud::Dg::Model::DeleteGatewayInstanceRequest;
DeleteGatewayInstanceRequest::DeleteGatewayInstanceRequest() :
RpcServiceRequest("dg", "2019-03-27", "DeleteGatewayInstance")
{
setMethod(HttpRequest::Method::Post);
}
DeleteGatewayInstanceRequest::~DeleteGatewayInstanceRequest()
{}
std::string DeleteGatewayInstanceRequest::getGatewayInstanceId()const
{
return gatewayInstanceId_;
}
void DeleteGatewayInstanceRequest::setGatewayInstanceId(const std::string& gatewayInstanceId)
{
gatewayInstanceId_ = gatewayInstanceId;
setBodyParameter("GatewayInstanceId", gatewayInstanceId);
}
std::string DeleteGatewayInstanceRequest::getRegionId()const
{
return regionId_;
}
void DeleteGatewayInstanceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setBodyParameter("RegionId", regionId);
}
std::string DeleteGatewayInstanceRequest::getGatewayId()const
{
return gatewayId_;
}
void DeleteGatewayInstanceRequest::setGatewayId(const std::string& gatewayId)
{
gatewayId_ = gatewayId;
setBodyParameter("GatewayId", gatewayId);
}

View File

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

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/dg/model/DeleteGatewayRequest.h>
using AlibabaCloud::Dg::Model::DeleteGatewayRequest;
DeleteGatewayRequest::DeleteGatewayRequest() :
RpcServiceRequest("dg", "2019-03-27", "DeleteGateway")
{
setMethod(HttpRequest::Method::Post);
}
DeleteGatewayRequest::~DeleteGatewayRequest()
{}
std::string DeleteGatewayRequest::getGatewayId()const
{
return gatewayId_;
}
void DeleteGatewayRequest::setGatewayId(const std::string& gatewayId)
{
gatewayId_ = gatewayId;
setBodyParameter("GatewayId", gatewayId);
}

View File

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

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/dg/model/DescribeRegionsRequest.h>
using AlibabaCloud::Dg::Model::DescribeRegionsRequest;
DescribeRegionsRequest::DescribeRegionsRequest() :
RpcServiceRequest("dg", "2019-03-27", "DescribeRegions")
{
setMethod(HttpRequest::Method::Post);
}
DescribeRegionsRequest::~DescribeRegionsRequest()
{}
std::string DescribeRegionsRequest::getRegionId()const
{
return regionId_;
}
void DescribeRegionsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setBodyParameter("RegionId", regionId);
}

View File

@@ -0,0 +1,82 @@
/*
* 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/dg/model/DescribeRegionsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Dg;
using namespace AlibabaCloud::Dg::Model;
DescribeRegionsResult::DescribeRegionsResult() :
ServiceResult()
{}
DescribeRegionsResult::DescribeRegionsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeRegionsResult::~DescribeRegionsResult()
{}
void DescribeRegionsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allRegionsNode = value["Regions"]["Region"];
for (auto valueRegionsRegion : allRegionsNode)
{
Region regionsObject;
if(!valueRegionsRegion["RegionId"].isNull())
regionsObject.regionId = valueRegionsRegion["RegionId"].asString();
if(!valueRegionsRegion["LocalName"].isNull())
regionsObject.localName = valueRegionsRegion["LocalName"].asString();
if(!valueRegionsRegion["RegionEndpoint"].isNull())
regionsObject.regionEndpoint = valueRegionsRegion["RegionEndpoint"].asString();
regions_.push_back(regionsObject);
}
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["ErrorMsg"].isNull())
errorMsg_ = value["ErrorMsg"].asString();
}
std::string DescribeRegionsResult::getErrorMsg()const
{
return errorMsg_;
}
std::vector<DescribeRegionsResult::Region> DescribeRegionsResult::getRegions()const
{
return regions_;
}
std::string DescribeRegionsResult::getCode()const
{
return code_;
}
bool DescribeRegionsResult::getSuccess()const
{
return success_;
}

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/dg/model/DownloadGatewayProgramRequest.h>
using AlibabaCloud::Dg::Model::DownloadGatewayProgramRequest;
DownloadGatewayProgramRequest::DownloadGatewayProgramRequest() :
RpcServiceRequest("dg", "2019-03-27", "DownloadGatewayProgram")
{
setMethod(HttpRequest::Method::Post);
}
DownloadGatewayProgramRequest::~DownloadGatewayProgramRequest()
{}
std::string DownloadGatewayProgramRequest::getUserOS()const
{
return userOS_;
}
void DownloadGatewayProgramRequest::setUserOS(const std::string& userOS)
{
userOS_ = userOS;
setBodyParameter("UserOS", userOS);
}
std::string DownloadGatewayProgramRequest::getDgVersion()const
{
return dgVersion_;
}
void DownloadGatewayProgramRequest::setDgVersion(const std::string& dgVersion)
{
dgVersion_ = dgVersion;
setBodyParameter("DgVersion", dgVersion);
}

View File

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

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/dg/model/FindUserGatewayByIdRequest.h>
using AlibabaCloud::Dg::Model::FindUserGatewayByIdRequest;
FindUserGatewayByIdRequest::FindUserGatewayByIdRequest() :
RpcServiceRequest("dg", "2019-03-27", "FindUserGatewayById")
{
setMethod(HttpRequest::Method::Post);
}
FindUserGatewayByIdRequest::~FindUserGatewayByIdRequest()
{}
std::string FindUserGatewayByIdRequest::getGatewayId()const
{
return gatewayId_;
}
void FindUserGatewayByIdRequest::setGatewayId(const std::string& gatewayId)
{
gatewayId_ = gatewayId;
setBodyParameter("GatewayId", gatewayId);
}

View File

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

View File

@@ -0,0 +1,128 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/dg/model/GetUserDatabasesRequest.h>
using AlibabaCloud::Dg::Model::GetUserDatabasesRequest;
GetUserDatabasesRequest::GetUserDatabasesRequest() :
RpcServiceRequest("dg", "2019-03-27", "GetUserDatabases")
{
setMethod(HttpRequest::Method::Post);
}
GetUserDatabasesRequest::~GetUserDatabasesRequest()
{}
std::string GetUserDatabasesRequest::getSearchKey()const
{
return searchKey_;
}
void GetUserDatabasesRequest::setSearchKey(const std::string& searchKey)
{
searchKey_ = searchKey;
setBodyParameter("SearchKey", searchKey);
}
std::string GetUserDatabasesRequest::getPageNumber()const
{
return pageNumber_;
}
void GetUserDatabasesRequest::setPageNumber(const std::string& pageNumber)
{
pageNumber_ = pageNumber;
setBodyParameter("PageNumber", pageNumber);
}
std::string GetUserDatabasesRequest::getRegionId()const
{
return regionId_;
}
void GetUserDatabasesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setBodyParameter("RegionId", regionId);
}
std::string GetUserDatabasesRequest::getPageSize()const
{
return pageSize_;
}
void GetUserDatabasesRequest::setPageSize(const std::string& pageSize)
{
pageSize_ = pageSize;
setBodyParameter("PageSize", pageSize);
}
std::string GetUserDatabasesRequest::getHost()const
{
return host_;
}
void GetUserDatabasesRequest::setHost(const std::string& host)
{
host_ = host;
setBodyParameter("Host", host);
}
std::string GetUserDatabasesRequest::getGatewayId()const
{
return gatewayId_;
}
void GetUserDatabasesRequest::setGatewayId(const std::string& gatewayId)
{
gatewayId_ = gatewayId;
setBodyParameter("GatewayId", gatewayId);
}
std::string GetUserDatabasesRequest::getInstanceId()const
{
return instanceId_;
}
void GetUserDatabasesRequest::setInstanceId(const std::string& instanceId)
{
instanceId_ = instanceId;
setBodyParameter("InstanceId", instanceId);
}
int GetUserDatabasesRequest::getPort()const
{
return port_;
}
void GetUserDatabasesRequest::setPort(int port)
{
port_ = port;
setBodyParameter("Port", std::to_string(port));
}
std::string GetUserDatabasesRequest::getDbType()const
{
return dbType_;
}
void GetUserDatabasesRequest::setDbType(const std::string& dbType)
{
dbType_ = dbType;
setBodyParameter("DbType", dbType);
}

View File

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

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/dg/model/GetUserGatewayInstancesRequest.h>
using AlibabaCloud::Dg::Model::GetUserGatewayInstancesRequest;
GetUserGatewayInstancesRequest::GetUserGatewayInstancesRequest() :
RpcServiceRequest("dg", "2019-03-27", "GetUserGatewayInstances")
{
setMethod(HttpRequest::Method::Post);
}
GetUserGatewayInstancesRequest::~GetUserGatewayInstancesRequest()
{}
std::string GetUserGatewayInstancesRequest::getGatewayId()const
{
return gatewayId_;
}
void GetUserGatewayInstancesRequest::setGatewayId(const std::string& gatewayId)
{
gatewayId_ = gatewayId;
setBodyParameter("GatewayId", gatewayId);
}

View File

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

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/dg/model/GetUserGatewaysRequest.h>
using AlibabaCloud::Dg::Model::GetUserGatewaysRequest;
GetUserGatewaysRequest::GetUserGatewaysRequest() :
RpcServiceRequest("dg", "2019-03-27", "GetUserGateways")
{
setMethod(HttpRequest::Method::Post);
}
GetUserGatewaysRequest::~GetUserGatewaysRequest()
{}
std::string GetUserGatewaysRequest::getSearchKey()const
{
return searchKey_;
}
void GetUserGatewaysRequest::setSearchKey(const std::string& searchKey)
{
searchKey_ = searchKey;
setBodyParameter("SearchKey", searchKey);
}
int GetUserGatewaysRequest::getPageNumber()const
{
return pageNumber_;
}
void GetUserGatewaysRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setBodyParameter("PageNumber", std::to_string(pageNumber));
}
std::string GetUserGatewaysRequest::getRegionId()const
{
return regionId_;
}
void GetUserGatewaysRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setBodyParameter("RegionId", regionId);
}
int GetUserGatewaysRequest::getPageSize()const
{
return pageSize_;
}
void GetUserGatewaysRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setBodyParameter("PageSize", std::to_string(pageSize));
}

View File

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

View File

@@ -0,0 +1,128 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/dg/model/ListDatabaseAccessPointRequest.h>
using AlibabaCloud::Dg::Model::ListDatabaseAccessPointRequest;
ListDatabaseAccessPointRequest::ListDatabaseAccessPointRequest() :
RpcServiceRequest("dg", "2019-03-27", "ListDatabaseAccessPoint")
{
setMethod(HttpRequest::Method::Post);
}
ListDatabaseAccessPointRequest::~ListDatabaseAccessPointRequest()
{}
std::string ListDatabaseAccessPointRequest::getSearchKey()const
{
return searchKey_;
}
void ListDatabaseAccessPointRequest::setSearchKey(const std::string& searchKey)
{
searchKey_ = searchKey;
setBodyParameter("SearchKey", searchKey);
}
std::string ListDatabaseAccessPointRequest::getPageNumber()const
{
return pageNumber_;
}
void ListDatabaseAccessPointRequest::setPageNumber(const std::string& pageNumber)
{
pageNumber_ = pageNumber;
setBodyParameter("PageNumber", pageNumber);
}
std::string ListDatabaseAccessPointRequest::getRegionId()const
{
return regionId_;
}
void ListDatabaseAccessPointRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setBodyParameter("RegionId", regionId);
}
std::string ListDatabaseAccessPointRequest::getPageSize()const
{
return pageSize_;
}
void ListDatabaseAccessPointRequest::setPageSize(const std::string& pageSize)
{
pageSize_ = pageSize;
setBodyParameter("PageSize", pageSize);
}
std::string ListDatabaseAccessPointRequest::getHost()const
{
return host_;
}
void ListDatabaseAccessPointRequest::setHost(const std::string& host)
{
host_ = host;
setBodyParameter("Host", host);
}
std::string ListDatabaseAccessPointRequest::getDbInstanceId()const
{
return dbInstanceId_;
}
void ListDatabaseAccessPointRequest::setDbInstanceId(const std::string& dbInstanceId)
{
dbInstanceId_ = dbInstanceId;
setBodyParameter("DbInstanceId", dbInstanceId);
}
std::string ListDatabaseAccessPointRequest::getGatewayId()const
{
return gatewayId_;
}
void ListDatabaseAccessPointRequest::setGatewayId(const std::string& gatewayId)
{
gatewayId_ = gatewayId;
setBodyParameter("GatewayId", gatewayId);
}
int ListDatabaseAccessPointRequest::getPort()const
{
return port_;
}
void ListDatabaseAccessPointRequest::setPort(int port)
{
port_ = port;
setBodyParameter("Port", std::to_string(port));
}
std::string ListDatabaseAccessPointRequest::getVpcId()const
{
return vpcId_;
}
void ListDatabaseAccessPointRequest::setVpcId(const std::string& vpcId)
{
vpcId_ = vpcId;
setBodyParameter("VpcId", vpcId);
}

View File

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

View File

@@ -0,0 +1,117 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/dg/model/ModifyDatabaseRequest.h>
using AlibabaCloud::Dg::Model::ModifyDatabaseRequest;
ModifyDatabaseRequest::ModifyDatabaseRequest() :
RpcServiceRequest("dg", "2019-03-27", "ModifyDatabase")
{
setMethod(HttpRequest::Method::Post);
}
ModifyDatabaseRequest::~ModifyDatabaseRequest()
{}
std::string ModifyDatabaseRequest::getHost()const
{
return host_;
}
void ModifyDatabaseRequest::setHost(const std::string& host)
{
host_ = host;
setBodyParameter("Host", host);
}
std::string ModifyDatabaseRequest::getDbUserName()const
{
return dbUserName_;
}
void ModifyDatabaseRequest::setDbUserName(const std::string& dbUserName)
{
dbUserName_ = dbUserName;
setBodyParameter("DbUserName", dbUserName);
}
std::string ModifyDatabaseRequest::getDbDescription()const
{
return dbDescription_;
}
void ModifyDatabaseRequest::setDbDescription(const std::string& dbDescription)
{
dbDescription_ = dbDescription;
setBodyParameter("DbDescription", dbDescription);
}
std::string ModifyDatabaseRequest::getInstanceId()const
{
return instanceId_;
}
void ModifyDatabaseRequest::setInstanceId(const std::string& instanceId)
{
instanceId_ = instanceId;
setBodyParameter("InstanceId", instanceId);
}
std::string ModifyDatabaseRequest::getDbName()const
{
return dbName_;
}
void ModifyDatabaseRequest::setDbName(const std::string& dbName)
{
dbName_ = dbName;
setBodyParameter("DbName", dbName);
}
int ModifyDatabaseRequest::getPort()const
{
return port_;
}
void ModifyDatabaseRequest::setPort(int port)
{
port_ = port;
setBodyParameter("Port", std::to_string(port));
}
std::string ModifyDatabaseRequest::getDbPassword()const
{
return dbPassword_;
}
void ModifyDatabaseRequest::setDbPassword(const std::string& dbPassword)
{
dbPassword_ = dbPassword;
setBodyParameter("DbPassword", dbPassword);
}
std::string ModifyDatabaseRequest::getDbType()const
{
return dbType_;
}
void ModifyDatabaseRequest::setDbType(const std::string& dbType)
{
dbType_ = dbType;
setBodyParameter("DbType", dbType);
}

View File

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

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/dg/model/ModifyGatewayRequest.h>
using AlibabaCloud::Dg::Model::ModifyGatewayRequest;
ModifyGatewayRequest::ModifyGatewayRequest() :
RpcServiceRequest("dg", "2019-03-27", "ModifyGateway")
{
setMethod(HttpRequest::Method::Post);
}
ModifyGatewayRequest::~ModifyGatewayRequest()
{}
std::string ModifyGatewayRequest::getGatewayDesc()const
{
return gatewayDesc_;
}
void ModifyGatewayRequest::setGatewayDesc(const std::string& gatewayDesc)
{
gatewayDesc_ = gatewayDesc;
setBodyParameter("GatewayDesc", gatewayDesc);
}
std::string ModifyGatewayRequest::getGatewayName()const
{
return gatewayName_;
}
void ModifyGatewayRequest::setGatewayName(const std::string& gatewayName)
{
gatewayName_ = gatewayName;
setBodyParameter("GatewayName", gatewayName);
}
std::string ModifyGatewayRequest::getGatewayId()const
{
return gatewayId_;
}
void ModifyGatewayRequest::setGatewayId(const std::string& gatewayId)
{
gatewayId_ = gatewayId;
setBodyParameter("GatewayId", gatewayId);
}

View File

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

View File

@@ -0,0 +1,139 @@
/*
* 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/dg/model/RetryDatabaseRequest.h>
using AlibabaCloud::Dg::Model::RetryDatabaseRequest;
RetryDatabaseRequest::RetryDatabaseRequest() :
RpcServiceRequest("dg", "2019-03-27", "RetryDatabase")
{
setMethod(HttpRequest::Method::Post);
}
RetryDatabaseRequest::~RetryDatabaseRequest()
{}
std::string RetryDatabaseRequest::getClientToken()const
{
return clientToken_;
}
void RetryDatabaseRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setBodyParameter("ClientToken", clientToken);
}
std::string RetryDatabaseRequest::getRegionId()const
{
return regionId_;
}
void RetryDatabaseRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setBodyParameter("RegionId", regionId);
}
std::string RetryDatabaseRequest::getHost()const
{
return host_;
}
void RetryDatabaseRequest::setHost(const std::string& host)
{
host_ = host;
setBodyParameter("Host", host);
}
std::string RetryDatabaseRequest::getDbUserName()const
{
return dbUserName_;
}
void RetryDatabaseRequest::setDbUserName(const std::string& dbUserName)
{
dbUserName_ = dbUserName;
setBodyParameter("DbUserName", dbUserName);
}
std::string RetryDatabaseRequest::getDbDescription()const
{
return dbDescription_;
}
void RetryDatabaseRequest::setDbDescription(const std::string& dbDescription)
{
dbDescription_ = dbDescription;
setBodyParameter("DbDescription", dbDescription);
}
std::string RetryDatabaseRequest::getGatewayId()const
{
return gatewayId_;
}
void RetryDatabaseRequest::setGatewayId(const std::string& gatewayId)
{
gatewayId_ = gatewayId;
setBodyParameter("GatewayId", gatewayId);
}
std::string RetryDatabaseRequest::getDbName()const
{
return dbName_;
}
void RetryDatabaseRequest::setDbName(const std::string& dbName)
{
dbName_ = dbName;
setBodyParameter("DbName", dbName);
}
int RetryDatabaseRequest::getPort()const
{
return port_;
}
void RetryDatabaseRequest::setPort(int port)
{
port_ = port;
setBodyParameter("Port", std::to_string(port));
}
std::string RetryDatabaseRequest::getDbPassword()const
{
return dbPassword_;
}
void RetryDatabaseRequest::setDbPassword(const std::string& dbPassword)
{
dbPassword_ = dbPassword;
setBodyParameter("DbPassword", dbPassword);
}
std::string RetryDatabaseRequest::getDbType()const
{
return dbType_;
}
void RetryDatabaseRequest::setDbType(const std::string& dbType)
{
dbType_ = dbType;
setBodyParameter("DbType", dbType);
}

View File

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

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/dg/model/StopGatewayRequest.h>
using AlibabaCloud::Dg::Model::StopGatewayRequest;
StopGatewayRequest::StopGatewayRequest() :
RpcServiceRequest("dg", "2019-03-27", "StopGateway")
{
setMethod(HttpRequest::Method::Post);
}
StopGatewayRequest::~StopGatewayRequest()
{}
std::string StopGatewayRequest::getGatewayInstanceId()const
{
return gatewayInstanceId_;
}
void StopGatewayRequest::setGatewayInstanceId(const std::string& gatewayInstanceId)
{
gatewayInstanceId_ = gatewayInstanceId;
setBodyParameter("GatewayInstanceId", gatewayInstanceId);
}
std::string StopGatewayRequest::getGatewayId()const
{
return gatewayId_;
}
void StopGatewayRequest::setGatewayId(const std::string& gatewayId)
{
gatewayId_ = gatewayId;
setBodyParameter("GatewayId", gatewayId);
}

View File

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