diff --git a/CMakeLists.txt b/CMakeLists.txt index 0a82b7d33..e07e015e8 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -50,4 +50,5 @@ if(BUILD_TESTS) enable_testing() add_subdirectory(core-tests) endif() -add_subdirectory(ecs) \ No newline at end of file +add_subdirectory(ecs) +add_subdirectory(slb) \ No newline at end of file diff --git a/VERSION b/VERSION index 7f207341d..e6d5cb833 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.0.1 \ No newline at end of file +1.0.2 \ No newline at end of file diff --git a/slb/CMakeLists.txt b/slb/CMakeLists.txt new file mode 100644 index 000000000..c63152afe --- /dev/null +++ b/slb/CMakeLists.txt @@ -0,0 +1,358 @@ +# +# 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(slb_public_header + include/alibabacloud/slb/model/CreateLoadBalancerUDPListenerRequest.h + include/alibabacloud/slb/model/CreateLoadBalancerUDPListenerResult.h + include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsRequest.h + include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsResult.h + include/alibabacloud/slb/model/StartLoadBalancerListenerRequest.h + include/alibabacloud/slb/model/StartLoadBalancerListenerResult.h + include/alibabacloud/slb/model/DescribeLoadBalancerTCPListenerAttributeRequest.h + include/alibabacloud/slb/model/DescribeLoadBalancerTCPListenerAttributeResult.h + include/alibabacloud/slb/model/DescribeListenerAccessControlAttributeRequest.h + include/alibabacloud/slb/model/DescribeListenerAccessControlAttributeResult.h + include/alibabacloud/slb/model/StopLoadBalancerListenerRequest.h + include/alibabacloud/slb/model/StopLoadBalancerListenerResult.h + include/alibabacloud/slb/model/SetLoadBalancerStatusRequest.h + include/alibabacloud/slb/model/SetLoadBalancerStatusResult.h + include/alibabacloud/slb/model/ModifyLoadBalancerInstanceSpecRequest.h + include/alibabacloud/slb/model/ModifyLoadBalancerInstanceSpecResult.h + include/alibabacloud/slb/model/MoveResourceGroupRequest.h + include/alibabacloud/slb/model/MoveResourceGroupResult.h + include/alibabacloud/slb/model/SetLoadBalancerTCPListenerAttributeRequest.h + include/alibabacloud/slb/model/SetLoadBalancerTCPListenerAttributeResult.h + include/alibabacloud/slb/model/DeleteVServerGroupRequest.h + include/alibabacloud/slb/model/DeleteVServerGroupResult.h + include/alibabacloud/slb/model/DescribeVServerGroupAttributeRequest.h + include/alibabacloud/slb/model/DescribeVServerGroupAttributeResult.h + include/alibabacloud/slb/model/AddListenerWhiteListItemRequest.h + include/alibabacloud/slb/model/AddListenerWhiteListItemResult.h + include/alibabacloud/slb/model/RemoveTagsRequest.h + include/alibabacloud/slb/model/RemoveTagsResult.h + include/alibabacloud/slb/model/CreateLoadBalancerRequest.h + include/alibabacloud/slb/model/CreateLoadBalancerResult.h + include/alibabacloud/slb/model/SetLoadBalancerHTTPListenerAttributeRequest.h + include/alibabacloud/slb/model/SetLoadBalancerHTTPListenerAttributeResult.h + include/alibabacloud/slb/model/SetLoadBalancerAutoReleaseTimeRequest.h + include/alibabacloud/slb/model/SetLoadBalancerAutoReleaseTimeResult.h + include/alibabacloud/slb/model/SetListenerAccessControlStatusRequest.h + include/alibabacloud/slb/model/SetListenerAccessControlStatusResult.h + include/alibabacloud/slb/model/UploadCACertificateRequest.h + include/alibabacloud/slb/model/UploadCACertificateResult.h + include/alibabacloud/slb/model/DescribeZonesRequest.h + include/alibabacloud/slb/model/DescribeZonesResult.h + include/alibabacloud/slb/model/SetLoadBalancerHTTPSListenerAttributeRequest.h + include/alibabacloud/slb/model/SetLoadBalancerHTTPSListenerAttributeResult.h + include/alibabacloud/slb/model/DeleteLoadBalancerListenerRequest.h + include/alibabacloud/slb/model/DeleteLoadBalancerListenerResult.h + include/alibabacloud/slb/model/DescribeVServerGroupsRequest.h + include/alibabacloud/slb/model/DescribeVServerGroupsResult.h + include/alibabacloud/slb/model/DescribeLoadBalancerHTTPListenerAttributeRequest.h + include/alibabacloud/slb/model/DescribeLoadBalancerHTTPListenerAttributeResult.h + include/alibabacloud/slb/model/DescribeTagsRequest.h + include/alibabacloud/slb/model/DescribeTagsResult.h + include/alibabacloud/slb/model/DeleteLoadBalancerRequest.h + include/alibabacloud/slb/model/DeleteLoadBalancerResult.h + include/alibabacloud/slb/model/CreateVServerGroupRequest.h + include/alibabacloud/slb/model/CreateVServerGroupResult.h + include/alibabacloud/slb/model/DescribeLoadBalancersRelatedEcsRequest.h + include/alibabacloud/slb/model/DescribeLoadBalancersRelatedEcsResult.h + include/alibabacloud/slb/model/DescribeLoadBalancersRequest.h + include/alibabacloud/slb/model/DescribeLoadBalancersResult.h + include/alibabacloud/slb/model/SetCACertificateNameRequest.h + include/alibabacloud/slb/model/SetCACertificateNameResult.h + include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupAttributeRequest.h + include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupAttributeResult.h + include/alibabacloud/slb/model/CreateLoadBalancerHTTPListenerRequest.h + include/alibabacloud/slb/model/CreateLoadBalancerHTTPListenerResult.h + include/alibabacloud/slb/model/RemoveBackendServersRequest.h + include/alibabacloud/slb/model/RemoveBackendServersResult.h + include/alibabacloud/slb/model/ModifyVServerGroupBackendServersRequest.h + include/alibabacloud/slb/model/ModifyVServerGroupBackendServersResult.h + include/alibabacloud/slb/model/DescribeLoadBalancerUDPListenerAttributeRequest.h + include/alibabacloud/slb/model/DescribeLoadBalancerUDPListenerAttributeResult.h + include/alibabacloud/slb/model/DeleteRulesRequest.h + include/alibabacloud/slb/model/DeleteRulesResult.h + include/alibabacloud/slb/model/DeleteMasterSlaveVServerGroupRequest.h + include/alibabacloud/slb/model/DeleteMasterSlaveVServerGroupResult.h + include/alibabacloud/slb/model/DescribeCACertificatesRequest.h + include/alibabacloud/slb/model/DescribeCACertificatesResult.h + include/alibabacloud/slb/model/CreateMasterSlaveVServerGroupRequest.h + include/alibabacloud/slb/model/CreateMasterSlaveVServerGroupResult.h + include/alibabacloud/slb/model/SetBackendServersRequest.h + include/alibabacloud/slb/model/SetBackendServersResult.h + include/alibabacloud/slb/model/RemoveVServerGroupBackendServersRequest.h + include/alibabacloud/slb/model/RemoveVServerGroupBackendServersResult.h + include/alibabacloud/slb/model/DescribeLoadBalancerAttributeRequest.h + include/alibabacloud/slb/model/DescribeLoadBalancerAttributeResult.h + include/alibabacloud/slb/model/CreateMasterSlaveServerGroupRequest.h + include/alibabacloud/slb/model/CreateMasterSlaveServerGroupResult.h + include/alibabacloud/slb/model/SetServerCertificateNameRequest.h + include/alibabacloud/slb/model/SetServerCertificateNameResult.h + include/alibabacloud/slb/model/DeleteCACertificateRequest.h + include/alibabacloud/slb/model/DeleteCACertificateResult.h + include/alibabacloud/slb/model/CreateLoadBalancerTCPListenerRequest.h + include/alibabacloud/slb/model/CreateLoadBalancerTCPListenerResult.h + include/alibabacloud/slb/model/SetRuleRequest.h + include/alibabacloud/slb/model/SetRuleResult.h + include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupsRequest.h + include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupsResult.h + include/alibabacloud/slb/model/DescribeHealthStatusRequest.h + include/alibabacloud/slb/model/DescribeHealthStatusResult.h + include/alibabacloud/slb/model/DescribeRegionsRequest.h + include/alibabacloud/slb/model/DescribeRegionsResult.h + include/alibabacloud/slb/model/RemoveListenerWhiteListItemRequest.h + include/alibabacloud/slb/model/RemoveListenerWhiteListItemResult.h + include/alibabacloud/slb/model/CreateLoadBalancerHTTPSListenerRequest.h + include/alibabacloud/slb/model/CreateLoadBalancerHTTPSListenerResult.h + include/alibabacloud/slb/model/DeleteMasterSlaveServerGroupRequest.h + include/alibabacloud/slb/model/DeleteMasterSlaveServerGroupResult.h + include/alibabacloud/slb/model/DescribeServerCertificatesRequest.h + include/alibabacloud/slb/model/DescribeServerCertificatesResult.h + include/alibabacloud/slb/model/DescribeRulesRequest.h + include/alibabacloud/slb/model/DescribeRulesResult.h + include/alibabacloud/slb/model/DescribeRuleAttributeRequest.h + include/alibabacloud/slb/model/DescribeRuleAttributeResult.h + include/alibabacloud/slb/model/UploadServerCertificateRequest.h + include/alibabacloud/slb/model/UploadServerCertificateResult.h + include/alibabacloud/slb/model/DescribeLoadBalancerAutoReleaseTimeRequest.h + include/alibabacloud/slb/model/DescribeLoadBalancerAutoReleaseTimeResult.h + include/alibabacloud/slb/model/DeleteServerCertificateRequest.h + include/alibabacloud/slb/model/DeleteServerCertificateResult.h + include/alibabacloud/slb/model/SetLoadBalancerNameRequest.h + include/alibabacloud/slb/model/SetLoadBalancerNameResult.h + include/alibabacloud/slb/model/SetVServerGroupAttributeRequest.h + include/alibabacloud/slb/model/SetVServerGroupAttributeResult.h + include/alibabacloud/slb/model/ModifyLoadBalancerInternetSpecRequest.h + include/alibabacloud/slb/model/ModifyLoadBalancerInternetSpecResult.h + include/alibabacloud/slb/model/DescribeLoadBalancerHTTPSListenerAttributeRequest.h + include/alibabacloud/slb/model/DescribeLoadBalancerHTTPSListenerAttributeResult.h + include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupAttributeRequest.h + include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupAttributeResult.h + include/alibabacloud/slb/model/AddTagsRequest.h + include/alibabacloud/slb/model/AddTagsResult.h + include/alibabacloud/slb/model/ModifyLoadBalancerPayTypeRequest.h + include/alibabacloud/slb/model/ModifyLoadBalancerPayTypeResult.h + include/alibabacloud/slb/model/AddBackendServersRequest.h + include/alibabacloud/slb/model/AddBackendServersResult.h + include/alibabacloud/slb/model/CreateRulesRequest.h + include/alibabacloud/slb/model/CreateRulesResult.h + include/alibabacloud/slb/model/AddVServerGroupBackendServersRequest.h + include/alibabacloud/slb/model/AddVServerGroupBackendServersResult.h + include/alibabacloud/slb/model/SetLoadBalancerUDPListenerAttributeRequest.h + include/alibabacloud/slb/model/SetLoadBalancerUDPListenerAttributeResult.h + include/alibabacloud/slb/SlbClient.h + include/alibabacloud/slb/SlbExport.h + include/alibabacloud/slb/SlbRequest.h + ) + +set(slb_src + src/model/CreateLoadBalancerUDPListenerRequest.cc + src/model/CreateLoadBalancerUDPListenerResult.cc + src/model/DescribeMasterSlaveVServerGroupsRequest.cc + src/model/DescribeMasterSlaveVServerGroupsResult.cc + src/model/StartLoadBalancerListenerRequest.cc + src/model/StartLoadBalancerListenerResult.cc + src/model/DescribeLoadBalancerTCPListenerAttributeRequest.cc + src/model/DescribeLoadBalancerTCPListenerAttributeResult.cc + src/model/DescribeListenerAccessControlAttributeRequest.cc + src/model/DescribeListenerAccessControlAttributeResult.cc + src/model/StopLoadBalancerListenerRequest.cc + src/model/StopLoadBalancerListenerResult.cc + src/model/SetLoadBalancerStatusRequest.cc + src/model/SetLoadBalancerStatusResult.cc + src/model/ModifyLoadBalancerInstanceSpecRequest.cc + src/model/ModifyLoadBalancerInstanceSpecResult.cc + src/model/MoveResourceGroupRequest.cc + src/model/MoveResourceGroupResult.cc + src/model/SetLoadBalancerTCPListenerAttributeRequest.cc + src/model/SetLoadBalancerTCPListenerAttributeResult.cc + src/model/DeleteVServerGroupRequest.cc + src/model/DeleteVServerGroupResult.cc + src/model/DescribeVServerGroupAttributeRequest.cc + src/model/DescribeVServerGroupAttributeResult.cc + src/model/AddListenerWhiteListItemRequest.cc + src/model/AddListenerWhiteListItemResult.cc + src/model/RemoveTagsRequest.cc + src/model/RemoveTagsResult.cc + src/model/CreateLoadBalancerRequest.cc + src/model/CreateLoadBalancerResult.cc + src/model/SetLoadBalancerHTTPListenerAttributeRequest.cc + src/model/SetLoadBalancerHTTPListenerAttributeResult.cc + src/model/SetLoadBalancerAutoReleaseTimeRequest.cc + src/model/SetLoadBalancerAutoReleaseTimeResult.cc + src/model/SetListenerAccessControlStatusRequest.cc + src/model/SetListenerAccessControlStatusResult.cc + src/model/UploadCACertificateRequest.cc + src/model/UploadCACertificateResult.cc + src/model/DescribeZonesRequest.cc + src/model/DescribeZonesResult.cc + src/model/SetLoadBalancerHTTPSListenerAttributeRequest.cc + src/model/SetLoadBalancerHTTPSListenerAttributeResult.cc + src/model/DeleteLoadBalancerListenerRequest.cc + src/model/DeleteLoadBalancerListenerResult.cc + src/model/DescribeVServerGroupsRequest.cc + src/model/DescribeVServerGroupsResult.cc + src/model/DescribeLoadBalancerHTTPListenerAttributeRequest.cc + src/model/DescribeLoadBalancerHTTPListenerAttributeResult.cc + src/model/DescribeTagsRequest.cc + src/model/DescribeTagsResult.cc + src/model/DeleteLoadBalancerRequest.cc + src/model/DeleteLoadBalancerResult.cc + src/model/CreateVServerGroupRequest.cc + src/model/CreateVServerGroupResult.cc + src/model/DescribeLoadBalancersRelatedEcsRequest.cc + src/model/DescribeLoadBalancersRelatedEcsResult.cc + src/model/DescribeLoadBalancersRequest.cc + src/model/DescribeLoadBalancersResult.cc + src/model/SetCACertificateNameRequest.cc + src/model/SetCACertificateNameResult.cc + src/model/DescribeMasterSlaveVServerGroupAttributeRequest.cc + src/model/DescribeMasterSlaveVServerGroupAttributeResult.cc + src/model/CreateLoadBalancerHTTPListenerRequest.cc + src/model/CreateLoadBalancerHTTPListenerResult.cc + src/model/RemoveBackendServersRequest.cc + src/model/RemoveBackendServersResult.cc + src/model/ModifyVServerGroupBackendServersRequest.cc + src/model/ModifyVServerGroupBackendServersResult.cc + src/model/DescribeLoadBalancerUDPListenerAttributeRequest.cc + src/model/DescribeLoadBalancerUDPListenerAttributeResult.cc + src/model/DeleteRulesRequest.cc + src/model/DeleteRulesResult.cc + src/model/DeleteMasterSlaveVServerGroupRequest.cc + src/model/DeleteMasterSlaveVServerGroupResult.cc + src/model/DescribeCACertificatesRequest.cc + src/model/DescribeCACertificatesResult.cc + src/model/CreateMasterSlaveVServerGroupRequest.cc + src/model/CreateMasterSlaveVServerGroupResult.cc + src/model/SetBackendServersRequest.cc + src/model/SetBackendServersResult.cc + src/model/RemoveVServerGroupBackendServersRequest.cc + src/model/RemoveVServerGroupBackendServersResult.cc + src/model/DescribeLoadBalancerAttributeRequest.cc + src/model/DescribeLoadBalancerAttributeResult.cc + src/model/CreateMasterSlaveServerGroupRequest.cc + src/model/CreateMasterSlaveServerGroupResult.cc + src/model/SetServerCertificateNameRequest.cc + src/model/SetServerCertificateNameResult.cc + src/model/DeleteCACertificateRequest.cc + src/model/DeleteCACertificateResult.cc + src/model/CreateLoadBalancerTCPListenerRequest.cc + src/model/CreateLoadBalancerTCPListenerResult.cc + src/model/SetRuleRequest.cc + src/model/SetRuleResult.cc + src/model/DescribeMasterSlaveServerGroupsRequest.cc + src/model/DescribeMasterSlaveServerGroupsResult.cc + src/model/DescribeHealthStatusRequest.cc + src/model/DescribeHealthStatusResult.cc + src/model/DescribeRegionsRequest.cc + src/model/DescribeRegionsResult.cc + src/model/RemoveListenerWhiteListItemRequest.cc + src/model/RemoveListenerWhiteListItemResult.cc + src/model/CreateLoadBalancerHTTPSListenerRequest.cc + src/model/CreateLoadBalancerHTTPSListenerResult.cc + src/model/DeleteMasterSlaveServerGroupRequest.cc + src/model/DeleteMasterSlaveServerGroupResult.cc + src/model/DescribeServerCertificatesRequest.cc + src/model/DescribeServerCertificatesResult.cc + src/model/DescribeRulesRequest.cc + src/model/DescribeRulesResult.cc + src/model/DescribeRuleAttributeRequest.cc + src/model/DescribeRuleAttributeResult.cc + src/model/UploadServerCertificateRequest.cc + src/model/UploadServerCertificateResult.cc + src/model/DescribeLoadBalancerAutoReleaseTimeRequest.cc + src/model/DescribeLoadBalancerAutoReleaseTimeResult.cc + src/model/DeleteServerCertificateRequest.cc + src/model/DeleteServerCertificateResult.cc + src/model/SetLoadBalancerNameRequest.cc + src/model/SetLoadBalancerNameResult.cc + src/model/SetVServerGroupAttributeRequest.cc + src/model/SetVServerGroupAttributeResult.cc + src/model/ModifyLoadBalancerInternetSpecRequest.cc + src/model/ModifyLoadBalancerInternetSpecResult.cc + src/model/DescribeLoadBalancerHTTPSListenerAttributeRequest.cc + src/model/DescribeLoadBalancerHTTPSListenerAttributeResult.cc + src/model/DescribeMasterSlaveServerGroupAttributeRequest.cc + src/model/DescribeMasterSlaveServerGroupAttributeResult.cc + src/model/AddTagsRequest.cc + src/model/AddTagsResult.cc + src/model/ModifyLoadBalancerPayTypeRequest.cc + src/model/ModifyLoadBalancerPayTypeResult.cc + src/model/AddBackendServersRequest.cc + src/model/AddBackendServersResult.cc + src/model/CreateRulesRequest.cc + src/model/CreateRulesResult.cc + src/model/AddVServerGroupBackendServersRequest.cc + src/model/AddVServerGroupBackendServersResult.cc + src/model/SetLoadBalancerUDPListenerAttributeRequest.cc + src/model/SetLoadBalancerUDPListenerAttributeResult.cc + src/SlbClient.cc + src/SlbRequest.cc + ) + +add_library(slb ${LIB_TYPE} ${slb_public_header} ${slb_src}) + +set_target_properties(slb + 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}slb + PUBLIC_HEADER "${slb_public_header}" + ) + +if(${LIB_TYPE} STREQUAL "SHARED") + set_target_properties(slb + PROPERTIES + DEFINE_SYMBOL ALIBABACLOUD_SLB_LIBRARY) +endif() + +target_include_directories(slb + PRIVATE include + ${CMAKE_SOURCE_DIR}/core/include + ) +target_link_libraries(slb + core) + +if(CMAKE_HOST_WIN32) + ExternalProject_Get_Property(jsoncpp INSTALL_DIR) + set(jsoncpp_install_dir ${INSTALL_DIR}) + add_dependencies(slb + jsoncpp) + target_include_directories(slb + PRIVATE ${jsoncpp_install_dir}/include) + target_link_libraries(slb + ${jsoncpp_install_dir}/lib/jsoncpp.lib) + set_target_properties(slb + PROPERTIES + COMPILE_OPTIONS "/bigobj") +else() + target_include_directories(slb + PRIVATE /usr/include/jsoncpp) + target_link_libraries(slb + jsoncpp) +endif() + +install(TARGETS slb + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/slb + ) diff --git a/slb/ChangeLog.txt b/slb/ChangeLog.txt new file mode 100644 index 000000000..507902eb1 --- /dev/null +++ b/slb/ChangeLog.txt @@ -0,0 +1,3 @@ +2018-01-10 Version: 升级小版本 +1, First release slb for C++ + diff --git a/slb/include/alibabacloud/slb/SlbClient.h b/slb/include/alibabacloud/slb/SlbClient.h new file mode 100644 index 000000000..9b61778e4 --- /dev/null +++ b/slb/include/alibabacloud/slb/SlbClient.h @@ -0,0 +1,609 @@ +/* + * 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_SLB_SLBCLIENT_H_ +#define ALIBABACLOUD_SLB_SLBCLIENT_H_ + +#include +#include +#include +#include +#include "SlbExport.h" +#include "model/CreateLoadBalancerUDPListenerRequest.h" +#include "model/CreateLoadBalancerUDPListenerResult.h" +#include "model/DescribeMasterSlaveVServerGroupsRequest.h" +#include "model/DescribeMasterSlaveVServerGroupsResult.h" +#include "model/StartLoadBalancerListenerRequest.h" +#include "model/StartLoadBalancerListenerResult.h" +#include "model/DescribeLoadBalancerTCPListenerAttributeRequest.h" +#include "model/DescribeLoadBalancerTCPListenerAttributeResult.h" +#include "model/DescribeListenerAccessControlAttributeRequest.h" +#include "model/DescribeListenerAccessControlAttributeResult.h" +#include "model/StopLoadBalancerListenerRequest.h" +#include "model/StopLoadBalancerListenerResult.h" +#include "model/SetLoadBalancerStatusRequest.h" +#include "model/SetLoadBalancerStatusResult.h" +#include "model/ModifyLoadBalancerInstanceSpecRequest.h" +#include "model/ModifyLoadBalancerInstanceSpecResult.h" +#include "model/MoveResourceGroupRequest.h" +#include "model/MoveResourceGroupResult.h" +#include "model/SetLoadBalancerTCPListenerAttributeRequest.h" +#include "model/SetLoadBalancerTCPListenerAttributeResult.h" +#include "model/DeleteVServerGroupRequest.h" +#include "model/DeleteVServerGroupResult.h" +#include "model/DescribeVServerGroupAttributeRequest.h" +#include "model/DescribeVServerGroupAttributeResult.h" +#include "model/AddListenerWhiteListItemRequest.h" +#include "model/AddListenerWhiteListItemResult.h" +#include "model/RemoveTagsRequest.h" +#include "model/RemoveTagsResult.h" +#include "model/CreateLoadBalancerRequest.h" +#include "model/CreateLoadBalancerResult.h" +#include "model/SetLoadBalancerHTTPListenerAttributeRequest.h" +#include "model/SetLoadBalancerHTTPListenerAttributeResult.h" +#include "model/SetLoadBalancerAutoReleaseTimeRequest.h" +#include "model/SetLoadBalancerAutoReleaseTimeResult.h" +#include "model/SetListenerAccessControlStatusRequest.h" +#include "model/SetListenerAccessControlStatusResult.h" +#include "model/UploadCACertificateRequest.h" +#include "model/UploadCACertificateResult.h" +#include "model/DescribeZonesRequest.h" +#include "model/DescribeZonesResult.h" +#include "model/SetLoadBalancerHTTPSListenerAttributeRequest.h" +#include "model/SetLoadBalancerHTTPSListenerAttributeResult.h" +#include "model/DeleteLoadBalancerListenerRequest.h" +#include "model/DeleteLoadBalancerListenerResult.h" +#include "model/DescribeVServerGroupsRequest.h" +#include "model/DescribeVServerGroupsResult.h" +#include "model/DescribeLoadBalancerHTTPListenerAttributeRequest.h" +#include "model/DescribeLoadBalancerHTTPListenerAttributeResult.h" +#include "model/DescribeTagsRequest.h" +#include "model/DescribeTagsResult.h" +#include "model/DeleteLoadBalancerRequest.h" +#include "model/DeleteLoadBalancerResult.h" +#include "model/CreateVServerGroupRequest.h" +#include "model/CreateVServerGroupResult.h" +#include "model/DescribeLoadBalancersRelatedEcsRequest.h" +#include "model/DescribeLoadBalancersRelatedEcsResult.h" +#include "model/DescribeLoadBalancersRequest.h" +#include "model/DescribeLoadBalancersResult.h" +#include "model/SetCACertificateNameRequest.h" +#include "model/SetCACertificateNameResult.h" +#include "model/DescribeMasterSlaveVServerGroupAttributeRequest.h" +#include "model/DescribeMasterSlaveVServerGroupAttributeResult.h" +#include "model/CreateLoadBalancerHTTPListenerRequest.h" +#include "model/CreateLoadBalancerHTTPListenerResult.h" +#include "model/RemoveBackendServersRequest.h" +#include "model/RemoveBackendServersResult.h" +#include "model/ModifyVServerGroupBackendServersRequest.h" +#include "model/ModifyVServerGroupBackendServersResult.h" +#include "model/DescribeLoadBalancerUDPListenerAttributeRequest.h" +#include "model/DescribeLoadBalancerUDPListenerAttributeResult.h" +#include "model/DeleteRulesRequest.h" +#include "model/DeleteRulesResult.h" +#include "model/DeleteMasterSlaveVServerGroupRequest.h" +#include "model/DeleteMasterSlaveVServerGroupResult.h" +#include "model/DescribeCACertificatesRequest.h" +#include "model/DescribeCACertificatesResult.h" +#include "model/CreateMasterSlaveVServerGroupRequest.h" +#include "model/CreateMasterSlaveVServerGroupResult.h" +#include "model/SetBackendServersRequest.h" +#include "model/SetBackendServersResult.h" +#include "model/RemoveVServerGroupBackendServersRequest.h" +#include "model/RemoveVServerGroupBackendServersResult.h" +#include "model/DescribeLoadBalancerAttributeRequest.h" +#include "model/DescribeLoadBalancerAttributeResult.h" +#include "model/CreateMasterSlaveServerGroupRequest.h" +#include "model/CreateMasterSlaveServerGroupResult.h" +#include "model/SetServerCertificateNameRequest.h" +#include "model/SetServerCertificateNameResult.h" +#include "model/DeleteCACertificateRequest.h" +#include "model/DeleteCACertificateResult.h" +#include "model/CreateLoadBalancerTCPListenerRequest.h" +#include "model/CreateLoadBalancerTCPListenerResult.h" +#include "model/SetRuleRequest.h" +#include "model/SetRuleResult.h" +#include "model/DescribeMasterSlaveServerGroupsRequest.h" +#include "model/DescribeMasterSlaveServerGroupsResult.h" +#include "model/DescribeHealthStatusRequest.h" +#include "model/DescribeHealthStatusResult.h" +#include "model/DescribeRegionsRequest.h" +#include "model/DescribeRegionsResult.h" +#include "model/RemoveListenerWhiteListItemRequest.h" +#include "model/RemoveListenerWhiteListItemResult.h" +#include "model/CreateLoadBalancerHTTPSListenerRequest.h" +#include "model/CreateLoadBalancerHTTPSListenerResult.h" +#include "model/DeleteMasterSlaveServerGroupRequest.h" +#include "model/DeleteMasterSlaveServerGroupResult.h" +#include "model/DescribeServerCertificatesRequest.h" +#include "model/DescribeServerCertificatesResult.h" +#include "model/DescribeRulesRequest.h" +#include "model/DescribeRulesResult.h" +#include "model/DescribeRuleAttributeRequest.h" +#include "model/DescribeRuleAttributeResult.h" +#include "model/UploadServerCertificateRequest.h" +#include "model/UploadServerCertificateResult.h" +#include "model/DescribeLoadBalancerAutoReleaseTimeRequest.h" +#include "model/DescribeLoadBalancerAutoReleaseTimeResult.h" +#include "model/DeleteServerCertificateRequest.h" +#include "model/DeleteServerCertificateResult.h" +#include "model/SetLoadBalancerNameRequest.h" +#include "model/SetLoadBalancerNameResult.h" +#include "model/SetVServerGroupAttributeRequest.h" +#include "model/SetVServerGroupAttributeResult.h" +#include "model/ModifyLoadBalancerInternetSpecRequest.h" +#include "model/ModifyLoadBalancerInternetSpecResult.h" +#include "model/DescribeLoadBalancerHTTPSListenerAttributeRequest.h" +#include "model/DescribeLoadBalancerHTTPSListenerAttributeResult.h" +#include "model/DescribeMasterSlaveServerGroupAttributeRequest.h" +#include "model/DescribeMasterSlaveServerGroupAttributeResult.h" +#include "model/AddTagsRequest.h" +#include "model/AddTagsResult.h" +#include "model/ModifyLoadBalancerPayTypeRequest.h" +#include "model/ModifyLoadBalancerPayTypeResult.h" +#include "model/AddBackendServersRequest.h" +#include "model/AddBackendServersResult.h" +#include "model/CreateRulesRequest.h" +#include "model/CreateRulesResult.h" +#include "model/AddVServerGroupBackendServersRequest.h" +#include "model/AddVServerGroupBackendServersResult.h" +#include "model/SetLoadBalancerUDPListenerAttributeRequest.h" +#include "model/SetLoadBalancerUDPListenerAttributeResult.h" + + +namespace AlibabaCloud +{ + namespace Slb + { + class ALIBABACLOUD_SLB_EXPORT SlbClient : public RpcServiceClient + { + public: + typedef Outcome CreateLoadBalancerUDPListenerOutcome; + typedef std::future CreateLoadBalancerUDPListenerOutcomeCallable; + typedef std::function&)> CreateLoadBalancerUDPListenerAsyncHandler; + typedef Outcome DescribeMasterSlaveVServerGroupsOutcome; + typedef std::future DescribeMasterSlaveVServerGroupsOutcomeCallable; + typedef std::function&)> DescribeMasterSlaveVServerGroupsAsyncHandler; + typedef Outcome StartLoadBalancerListenerOutcome; + typedef std::future StartLoadBalancerListenerOutcomeCallable; + typedef std::function&)> StartLoadBalancerListenerAsyncHandler; + typedef Outcome DescribeLoadBalancerTCPListenerAttributeOutcome; + typedef std::future DescribeLoadBalancerTCPListenerAttributeOutcomeCallable; + typedef std::function&)> DescribeLoadBalancerTCPListenerAttributeAsyncHandler; + typedef Outcome DescribeListenerAccessControlAttributeOutcome; + typedef std::future DescribeListenerAccessControlAttributeOutcomeCallable; + typedef std::function&)> DescribeListenerAccessControlAttributeAsyncHandler; + typedef Outcome StopLoadBalancerListenerOutcome; + typedef std::future StopLoadBalancerListenerOutcomeCallable; + typedef std::function&)> StopLoadBalancerListenerAsyncHandler; + typedef Outcome SetLoadBalancerStatusOutcome; + typedef std::future SetLoadBalancerStatusOutcomeCallable; + typedef std::function&)> SetLoadBalancerStatusAsyncHandler; + typedef Outcome ModifyLoadBalancerInstanceSpecOutcome; + typedef std::future ModifyLoadBalancerInstanceSpecOutcomeCallable; + typedef std::function&)> ModifyLoadBalancerInstanceSpecAsyncHandler; + typedef Outcome MoveResourceGroupOutcome; + typedef std::future MoveResourceGroupOutcomeCallable; + typedef std::function&)> MoveResourceGroupAsyncHandler; + typedef Outcome SetLoadBalancerTCPListenerAttributeOutcome; + typedef std::future SetLoadBalancerTCPListenerAttributeOutcomeCallable; + typedef std::function&)> SetLoadBalancerTCPListenerAttributeAsyncHandler; + typedef Outcome DeleteVServerGroupOutcome; + typedef std::future DeleteVServerGroupOutcomeCallable; + typedef std::function&)> DeleteVServerGroupAsyncHandler; + typedef Outcome DescribeVServerGroupAttributeOutcome; + typedef std::future DescribeVServerGroupAttributeOutcomeCallable; + typedef std::function&)> DescribeVServerGroupAttributeAsyncHandler; + typedef Outcome AddListenerWhiteListItemOutcome; + typedef std::future AddListenerWhiteListItemOutcomeCallable; + typedef std::function&)> AddListenerWhiteListItemAsyncHandler; + typedef Outcome RemoveTagsOutcome; + typedef std::future RemoveTagsOutcomeCallable; + typedef std::function&)> RemoveTagsAsyncHandler; + typedef Outcome CreateLoadBalancerOutcome; + typedef std::future CreateLoadBalancerOutcomeCallable; + typedef std::function&)> CreateLoadBalancerAsyncHandler; + typedef Outcome SetLoadBalancerHTTPListenerAttributeOutcome; + typedef std::future SetLoadBalancerHTTPListenerAttributeOutcomeCallable; + typedef std::function&)> SetLoadBalancerHTTPListenerAttributeAsyncHandler; + typedef Outcome SetLoadBalancerAutoReleaseTimeOutcome; + typedef std::future SetLoadBalancerAutoReleaseTimeOutcomeCallable; + typedef std::function&)> SetLoadBalancerAutoReleaseTimeAsyncHandler; + typedef Outcome SetListenerAccessControlStatusOutcome; + typedef std::future SetListenerAccessControlStatusOutcomeCallable; + typedef std::function&)> SetListenerAccessControlStatusAsyncHandler; + typedef Outcome UploadCACertificateOutcome; + typedef std::future UploadCACertificateOutcomeCallable; + typedef std::function&)> UploadCACertificateAsyncHandler; + typedef Outcome DescribeZonesOutcome; + typedef std::future DescribeZonesOutcomeCallable; + typedef std::function&)> DescribeZonesAsyncHandler; + typedef Outcome SetLoadBalancerHTTPSListenerAttributeOutcome; + typedef std::future SetLoadBalancerHTTPSListenerAttributeOutcomeCallable; + typedef std::function&)> SetLoadBalancerHTTPSListenerAttributeAsyncHandler; + typedef Outcome DeleteLoadBalancerListenerOutcome; + typedef std::future DeleteLoadBalancerListenerOutcomeCallable; + typedef std::function&)> DeleteLoadBalancerListenerAsyncHandler; + typedef Outcome DescribeVServerGroupsOutcome; + typedef std::future DescribeVServerGroupsOutcomeCallable; + typedef std::function&)> DescribeVServerGroupsAsyncHandler; + typedef Outcome DescribeLoadBalancerHTTPListenerAttributeOutcome; + typedef std::future DescribeLoadBalancerHTTPListenerAttributeOutcomeCallable; + typedef std::function&)> DescribeLoadBalancerHTTPListenerAttributeAsyncHandler; + typedef Outcome DescribeTagsOutcome; + typedef std::future DescribeTagsOutcomeCallable; + typedef std::function&)> DescribeTagsAsyncHandler; + typedef Outcome DeleteLoadBalancerOutcome; + typedef std::future DeleteLoadBalancerOutcomeCallable; + typedef std::function&)> DeleteLoadBalancerAsyncHandler; + typedef Outcome CreateVServerGroupOutcome; + typedef std::future CreateVServerGroupOutcomeCallable; + typedef std::function&)> CreateVServerGroupAsyncHandler; + typedef Outcome DescribeLoadBalancersRelatedEcsOutcome; + typedef std::future DescribeLoadBalancersRelatedEcsOutcomeCallable; + typedef std::function&)> DescribeLoadBalancersRelatedEcsAsyncHandler; + typedef Outcome DescribeLoadBalancersOutcome; + typedef std::future DescribeLoadBalancersOutcomeCallable; + typedef std::function&)> DescribeLoadBalancersAsyncHandler; + typedef Outcome SetCACertificateNameOutcome; + typedef std::future SetCACertificateNameOutcomeCallable; + typedef std::function&)> SetCACertificateNameAsyncHandler; + typedef Outcome DescribeMasterSlaveVServerGroupAttributeOutcome; + typedef std::future DescribeMasterSlaveVServerGroupAttributeOutcomeCallable; + typedef std::function&)> DescribeMasterSlaveVServerGroupAttributeAsyncHandler; + typedef Outcome CreateLoadBalancerHTTPListenerOutcome; + typedef std::future CreateLoadBalancerHTTPListenerOutcomeCallable; + typedef std::function&)> CreateLoadBalancerHTTPListenerAsyncHandler; + typedef Outcome RemoveBackendServersOutcome; + typedef std::future RemoveBackendServersOutcomeCallable; + typedef std::function&)> RemoveBackendServersAsyncHandler; + typedef Outcome ModifyVServerGroupBackendServersOutcome; + typedef std::future ModifyVServerGroupBackendServersOutcomeCallable; + typedef std::function&)> ModifyVServerGroupBackendServersAsyncHandler; + typedef Outcome DescribeLoadBalancerUDPListenerAttributeOutcome; + typedef std::future DescribeLoadBalancerUDPListenerAttributeOutcomeCallable; + typedef std::function&)> DescribeLoadBalancerUDPListenerAttributeAsyncHandler; + typedef Outcome DeleteRulesOutcome; + typedef std::future DeleteRulesOutcomeCallable; + typedef std::function&)> DeleteRulesAsyncHandler; + typedef Outcome DeleteMasterSlaveVServerGroupOutcome; + typedef std::future DeleteMasterSlaveVServerGroupOutcomeCallable; + typedef std::function&)> DeleteMasterSlaveVServerGroupAsyncHandler; + typedef Outcome DescribeCACertificatesOutcome; + typedef std::future DescribeCACertificatesOutcomeCallable; + typedef std::function&)> DescribeCACertificatesAsyncHandler; + typedef Outcome CreateMasterSlaveVServerGroupOutcome; + typedef std::future CreateMasterSlaveVServerGroupOutcomeCallable; + typedef std::function&)> CreateMasterSlaveVServerGroupAsyncHandler; + typedef Outcome SetBackendServersOutcome; + typedef std::future SetBackendServersOutcomeCallable; + typedef std::function&)> SetBackendServersAsyncHandler; + typedef Outcome RemoveVServerGroupBackendServersOutcome; + typedef std::future RemoveVServerGroupBackendServersOutcomeCallable; + typedef std::function&)> RemoveVServerGroupBackendServersAsyncHandler; + typedef Outcome DescribeLoadBalancerAttributeOutcome; + typedef std::future DescribeLoadBalancerAttributeOutcomeCallable; + typedef std::function&)> DescribeLoadBalancerAttributeAsyncHandler; + typedef Outcome CreateMasterSlaveServerGroupOutcome; + typedef std::future CreateMasterSlaveServerGroupOutcomeCallable; + typedef std::function&)> CreateMasterSlaveServerGroupAsyncHandler; + typedef Outcome SetServerCertificateNameOutcome; + typedef std::future SetServerCertificateNameOutcomeCallable; + typedef std::function&)> SetServerCertificateNameAsyncHandler; + typedef Outcome DeleteCACertificateOutcome; + typedef std::future DeleteCACertificateOutcomeCallable; + typedef std::function&)> DeleteCACertificateAsyncHandler; + typedef Outcome CreateLoadBalancerTCPListenerOutcome; + typedef std::future CreateLoadBalancerTCPListenerOutcomeCallable; + typedef std::function&)> CreateLoadBalancerTCPListenerAsyncHandler; + typedef Outcome SetRuleOutcome; + typedef std::future SetRuleOutcomeCallable; + typedef std::function&)> SetRuleAsyncHandler; + typedef Outcome DescribeMasterSlaveServerGroupsOutcome; + typedef std::future DescribeMasterSlaveServerGroupsOutcomeCallable; + typedef std::function&)> DescribeMasterSlaveServerGroupsAsyncHandler; + typedef Outcome DescribeHealthStatusOutcome; + typedef std::future DescribeHealthStatusOutcomeCallable; + typedef std::function&)> DescribeHealthStatusAsyncHandler; + typedef Outcome DescribeRegionsOutcome; + typedef std::future DescribeRegionsOutcomeCallable; + typedef std::function&)> DescribeRegionsAsyncHandler; + typedef Outcome RemoveListenerWhiteListItemOutcome; + typedef std::future RemoveListenerWhiteListItemOutcomeCallable; + typedef std::function&)> RemoveListenerWhiteListItemAsyncHandler; + typedef Outcome CreateLoadBalancerHTTPSListenerOutcome; + typedef std::future CreateLoadBalancerHTTPSListenerOutcomeCallable; + typedef std::function&)> CreateLoadBalancerHTTPSListenerAsyncHandler; + typedef Outcome DeleteMasterSlaveServerGroupOutcome; + typedef std::future DeleteMasterSlaveServerGroupOutcomeCallable; + typedef std::function&)> DeleteMasterSlaveServerGroupAsyncHandler; + typedef Outcome DescribeServerCertificatesOutcome; + typedef std::future DescribeServerCertificatesOutcomeCallable; + typedef std::function&)> DescribeServerCertificatesAsyncHandler; + typedef Outcome DescribeRulesOutcome; + typedef std::future DescribeRulesOutcomeCallable; + typedef std::function&)> DescribeRulesAsyncHandler; + typedef Outcome DescribeRuleAttributeOutcome; + typedef std::future DescribeRuleAttributeOutcomeCallable; + typedef std::function&)> DescribeRuleAttributeAsyncHandler; + typedef Outcome UploadServerCertificateOutcome; + typedef std::future UploadServerCertificateOutcomeCallable; + typedef std::function&)> UploadServerCertificateAsyncHandler; + typedef Outcome DescribeLoadBalancerAutoReleaseTimeOutcome; + typedef std::future DescribeLoadBalancerAutoReleaseTimeOutcomeCallable; + typedef std::function&)> DescribeLoadBalancerAutoReleaseTimeAsyncHandler; + typedef Outcome DeleteServerCertificateOutcome; + typedef std::future DeleteServerCertificateOutcomeCallable; + typedef std::function&)> DeleteServerCertificateAsyncHandler; + typedef Outcome SetLoadBalancerNameOutcome; + typedef std::future SetLoadBalancerNameOutcomeCallable; + typedef std::function&)> SetLoadBalancerNameAsyncHandler; + typedef Outcome SetVServerGroupAttributeOutcome; + typedef std::future SetVServerGroupAttributeOutcomeCallable; + typedef std::function&)> SetVServerGroupAttributeAsyncHandler; + typedef Outcome ModifyLoadBalancerInternetSpecOutcome; + typedef std::future ModifyLoadBalancerInternetSpecOutcomeCallable; + typedef std::function&)> ModifyLoadBalancerInternetSpecAsyncHandler; + typedef Outcome DescribeLoadBalancerHTTPSListenerAttributeOutcome; + typedef std::future DescribeLoadBalancerHTTPSListenerAttributeOutcomeCallable; + typedef std::function&)> DescribeLoadBalancerHTTPSListenerAttributeAsyncHandler; + typedef Outcome DescribeMasterSlaveServerGroupAttributeOutcome; + typedef std::future DescribeMasterSlaveServerGroupAttributeOutcomeCallable; + typedef std::function&)> DescribeMasterSlaveServerGroupAttributeAsyncHandler; + typedef Outcome AddTagsOutcome; + typedef std::future AddTagsOutcomeCallable; + typedef std::function&)> AddTagsAsyncHandler; + typedef Outcome ModifyLoadBalancerPayTypeOutcome; + typedef std::future ModifyLoadBalancerPayTypeOutcomeCallable; + typedef std::function&)> ModifyLoadBalancerPayTypeAsyncHandler; + typedef Outcome AddBackendServersOutcome; + typedef std::future AddBackendServersOutcomeCallable; + typedef std::function&)> AddBackendServersAsyncHandler; + typedef Outcome CreateRulesOutcome; + typedef std::future CreateRulesOutcomeCallable; + typedef std::function&)> CreateRulesAsyncHandler; + typedef Outcome AddVServerGroupBackendServersOutcome; + typedef std::future AddVServerGroupBackendServersOutcomeCallable; + typedef std::function&)> AddVServerGroupBackendServersAsyncHandler; + typedef Outcome SetLoadBalancerUDPListenerAttributeOutcome; + typedef std::future SetLoadBalancerUDPListenerAttributeOutcomeCallable; + typedef std::function&)> SetLoadBalancerUDPListenerAttributeAsyncHandler; + + + SlbClient(const Credentials &credentials, const ClientConfiguration &configuration); + SlbClient(const std::shared_ptr &credentialsProvider, const ClientConfiguration &configuration); + SlbClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration); + ~SlbClient(); + + CreateLoadBalancerUDPListenerOutcome createLoadBalancerUDPListener(const Model::CreateLoadBalancerUDPListenerRequest &request)const; + void createLoadBalancerUDPListenerAsync(const Model::CreateLoadBalancerUDPListenerRequest& request, const CreateLoadBalancerUDPListenerAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateLoadBalancerUDPListenerOutcomeCallable createLoadBalancerUDPListenerCallable(const Model::CreateLoadBalancerUDPListenerRequest& request) const; + DescribeMasterSlaveVServerGroupsOutcome describeMasterSlaveVServerGroups(const Model::DescribeMasterSlaveVServerGroupsRequest &request)const; + void describeMasterSlaveVServerGroupsAsync(const Model::DescribeMasterSlaveVServerGroupsRequest& request, const DescribeMasterSlaveVServerGroupsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeMasterSlaveVServerGroupsOutcomeCallable describeMasterSlaveVServerGroupsCallable(const Model::DescribeMasterSlaveVServerGroupsRequest& request) const; + StartLoadBalancerListenerOutcome startLoadBalancerListener(const Model::StartLoadBalancerListenerRequest &request)const; + void startLoadBalancerListenerAsync(const Model::StartLoadBalancerListenerRequest& request, const StartLoadBalancerListenerAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + StartLoadBalancerListenerOutcomeCallable startLoadBalancerListenerCallable(const Model::StartLoadBalancerListenerRequest& request) const; + DescribeLoadBalancerTCPListenerAttributeOutcome describeLoadBalancerTCPListenerAttribute(const Model::DescribeLoadBalancerTCPListenerAttributeRequest &request)const; + void describeLoadBalancerTCPListenerAttributeAsync(const Model::DescribeLoadBalancerTCPListenerAttributeRequest& request, const DescribeLoadBalancerTCPListenerAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeLoadBalancerTCPListenerAttributeOutcomeCallable describeLoadBalancerTCPListenerAttributeCallable(const Model::DescribeLoadBalancerTCPListenerAttributeRequest& request) const; + DescribeListenerAccessControlAttributeOutcome describeListenerAccessControlAttribute(const Model::DescribeListenerAccessControlAttributeRequest &request)const; + void describeListenerAccessControlAttributeAsync(const Model::DescribeListenerAccessControlAttributeRequest& request, const DescribeListenerAccessControlAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeListenerAccessControlAttributeOutcomeCallable describeListenerAccessControlAttributeCallable(const Model::DescribeListenerAccessControlAttributeRequest& request) const; + StopLoadBalancerListenerOutcome stopLoadBalancerListener(const Model::StopLoadBalancerListenerRequest &request)const; + void stopLoadBalancerListenerAsync(const Model::StopLoadBalancerListenerRequest& request, const StopLoadBalancerListenerAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + StopLoadBalancerListenerOutcomeCallable stopLoadBalancerListenerCallable(const Model::StopLoadBalancerListenerRequest& request) const; + SetLoadBalancerStatusOutcome setLoadBalancerStatus(const Model::SetLoadBalancerStatusRequest &request)const; + void setLoadBalancerStatusAsync(const Model::SetLoadBalancerStatusRequest& request, const SetLoadBalancerStatusAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + SetLoadBalancerStatusOutcomeCallable setLoadBalancerStatusCallable(const Model::SetLoadBalancerStatusRequest& request) const; + ModifyLoadBalancerInstanceSpecOutcome modifyLoadBalancerInstanceSpec(const Model::ModifyLoadBalancerInstanceSpecRequest &request)const; + void modifyLoadBalancerInstanceSpecAsync(const Model::ModifyLoadBalancerInstanceSpecRequest& request, const ModifyLoadBalancerInstanceSpecAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ModifyLoadBalancerInstanceSpecOutcomeCallable modifyLoadBalancerInstanceSpecCallable(const Model::ModifyLoadBalancerInstanceSpecRequest& request) const; + MoveResourceGroupOutcome moveResourceGroup(const Model::MoveResourceGroupRequest &request)const; + void moveResourceGroupAsync(const Model::MoveResourceGroupRequest& request, const MoveResourceGroupAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + MoveResourceGroupOutcomeCallable moveResourceGroupCallable(const Model::MoveResourceGroupRequest& request) const; + SetLoadBalancerTCPListenerAttributeOutcome setLoadBalancerTCPListenerAttribute(const Model::SetLoadBalancerTCPListenerAttributeRequest &request)const; + void setLoadBalancerTCPListenerAttributeAsync(const Model::SetLoadBalancerTCPListenerAttributeRequest& request, const SetLoadBalancerTCPListenerAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + SetLoadBalancerTCPListenerAttributeOutcomeCallable setLoadBalancerTCPListenerAttributeCallable(const Model::SetLoadBalancerTCPListenerAttributeRequest& request) const; + DeleteVServerGroupOutcome deleteVServerGroup(const Model::DeleteVServerGroupRequest &request)const; + void deleteVServerGroupAsync(const Model::DeleteVServerGroupRequest& request, const DeleteVServerGroupAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteVServerGroupOutcomeCallable deleteVServerGroupCallable(const Model::DeleteVServerGroupRequest& request) const; + DescribeVServerGroupAttributeOutcome describeVServerGroupAttribute(const Model::DescribeVServerGroupAttributeRequest &request)const; + void describeVServerGroupAttributeAsync(const Model::DescribeVServerGroupAttributeRequest& request, const DescribeVServerGroupAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeVServerGroupAttributeOutcomeCallable describeVServerGroupAttributeCallable(const Model::DescribeVServerGroupAttributeRequest& request) const; + AddListenerWhiteListItemOutcome addListenerWhiteListItem(const Model::AddListenerWhiteListItemRequest &request)const; + void addListenerWhiteListItemAsync(const Model::AddListenerWhiteListItemRequest& request, const AddListenerWhiteListItemAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + AddListenerWhiteListItemOutcomeCallable addListenerWhiteListItemCallable(const Model::AddListenerWhiteListItemRequest& request) const; + RemoveTagsOutcome removeTags(const Model::RemoveTagsRequest &request)const; + void removeTagsAsync(const Model::RemoveTagsRequest& request, const RemoveTagsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + RemoveTagsOutcomeCallable removeTagsCallable(const Model::RemoveTagsRequest& request) const; + CreateLoadBalancerOutcome createLoadBalancer(const Model::CreateLoadBalancerRequest &request)const; + void createLoadBalancerAsync(const Model::CreateLoadBalancerRequest& request, const CreateLoadBalancerAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateLoadBalancerOutcomeCallable createLoadBalancerCallable(const Model::CreateLoadBalancerRequest& request) const; + SetLoadBalancerHTTPListenerAttributeOutcome setLoadBalancerHTTPListenerAttribute(const Model::SetLoadBalancerHTTPListenerAttributeRequest &request)const; + void setLoadBalancerHTTPListenerAttributeAsync(const Model::SetLoadBalancerHTTPListenerAttributeRequest& request, const SetLoadBalancerHTTPListenerAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + SetLoadBalancerHTTPListenerAttributeOutcomeCallable setLoadBalancerHTTPListenerAttributeCallable(const Model::SetLoadBalancerHTTPListenerAttributeRequest& request) const; + SetLoadBalancerAutoReleaseTimeOutcome setLoadBalancerAutoReleaseTime(const Model::SetLoadBalancerAutoReleaseTimeRequest &request)const; + void setLoadBalancerAutoReleaseTimeAsync(const Model::SetLoadBalancerAutoReleaseTimeRequest& request, const SetLoadBalancerAutoReleaseTimeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + SetLoadBalancerAutoReleaseTimeOutcomeCallable setLoadBalancerAutoReleaseTimeCallable(const Model::SetLoadBalancerAutoReleaseTimeRequest& request) const; + SetListenerAccessControlStatusOutcome setListenerAccessControlStatus(const Model::SetListenerAccessControlStatusRequest &request)const; + void setListenerAccessControlStatusAsync(const Model::SetListenerAccessControlStatusRequest& request, const SetListenerAccessControlStatusAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + SetListenerAccessControlStatusOutcomeCallable setListenerAccessControlStatusCallable(const Model::SetListenerAccessControlStatusRequest& request) const; + UploadCACertificateOutcome uploadCACertificate(const Model::UploadCACertificateRequest &request)const; + void uploadCACertificateAsync(const Model::UploadCACertificateRequest& request, const UploadCACertificateAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UploadCACertificateOutcomeCallable uploadCACertificateCallable(const Model::UploadCACertificateRequest& request) const; + DescribeZonesOutcome describeZones(const Model::DescribeZonesRequest &request)const; + void describeZonesAsync(const Model::DescribeZonesRequest& request, const DescribeZonesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeZonesOutcomeCallable describeZonesCallable(const Model::DescribeZonesRequest& request) const; + SetLoadBalancerHTTPSListenerAttributeOutcome setLoadBalancerHTTPSListenerAttribute(const Model::SetLoadBalancerHTTPSListenerAttributeRequest &request)const; + void setLoadBalancerHTTPSListenerAttributeAsync(const Model::SetLoadBalancerHTTPSListenerAttributeRequest& request, const SetLoadBalancerHTTPSListenerAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + SetLoadBalancerHTTPSListenerAttributeOutcomeCallable setLoadBalancerHTTPSListenerAttributeCallable(const Model::SetLoadBalancerHTTPSListenerAttributeRequest& request) const; + DeleteLoadBalancerListenerOutcome deleteLoadBalancerListener(const Model::DeleteLoadBalancerListenerRequest &request)const; + void deleteLoadBalancerListenerAsync(const Model::DeleteLoadBalancerListenerRequest& request, const DeleteLoadBalancerListenerAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteLoadBalancerListenerOutcomeCallable deleteLoadBalancerListenerCallable(const Model::DeleteLoadBalancerListenerRequest& request) const; + DescribeVServerGroupsOutcome describeVServerGroups(const Model::DescribeVServerGroupsRequest &request)const; + void describeVServerGroupsAsync(const Model::DescribeVServerGroupsRequest& request, const DescribeVServerGroupsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeVServerGroupsOutcomeCallable describeVServerGroupsCallable(const Model::DescribeVServerGroupsRequest& request) const; + DescribeLoadBalancerHTTPListenerAttributeOutcome describeLoadBalancerHTTPListenerAttribute(const Model::DescribeLoadBalancerHTTPListenerAttributeRequest &request)const; + void describeLoadBalancerHTTPListenerAttributeAsync(const Model::DescribeLoadBalancerHTTPListenerAttributeRequest& request, const DescribeLoadBalancerHTTPListenerAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeLoadBalancerHTTPListenerAttributeOutcomeCallable describeLoadBalancerHTTPListenerAttributeCallable(const Model::DescribeLoadBalancerHTTPListenerAttributeRequest& request) const; + DescribeTagsOutcome describeTags(const Model::DescribeTagsRequest &request)const; + void describeTagsAsync(const Model::DescribeTagsRequest& request, const DescribeTagsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeTagsOutcomeCallable describeTagsCallable(const Model::DescribeTagsRequest& request) const; + DeleteLoadBalancerOutcome deleteLoadBalancer(const Model::DeleteLoadBalancerRequest &request)const; + void deleteLoadBalancerAsync(const Model::DeleteLoadBalancerRequest& request, const DeleteLoadBalancerAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteLoadBalancerOutcomeCallable deleteLoadBalancerCallable(const Model::DeleteLoadBalancerRequest& request) const; + CreateVServerGroupOutcome createVServerGroup(const Model::CreateVServerGroupRequest &request)const; + void createVServerGroupAsync(const Model::CreateVServerGroupRequest& request, const CreateVServerGroupAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateVServerGroupOutcomeCallable createVServerGroupCallable(const Model::CreateVServerGroupRequest& request) const; + DescribeLoadBalancersRelatedEcsOutcome describeLoadBalancersRelatedEcs(const Model::DescribeLoadBalancersRelatedEcsRequest &request)const; + void describeLoadBalancersRelatedEcsAsync(const Model::DescribeLoadBalancersRelatedEcsRequest& request, const DescribeLoadBalancersRelatedEcsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeLoadBalancersRelatedEcsOutcomeCallable describeLoadBalancersRelatedEcsCallable(const Model::DescribeLoadBalancersRelatedEcsRequest& request) const; + DescribeLoadBalancersOutcome describeLoadBalancers(const Model::DescribeLoadBalancersRequest &request)const; + void describeLoadBalancersAsync(const Model::DescribeLoadBalancersRequest& request, const DescribeLoadBalancersAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeLoadBalancersOutcomeCallable describeLoadBalancersCallable(const Model::DescribeLoadBalancersRequest& request) const; + SetCACertificateNameOutcome setCACertificateName(const Model::SetCACertificateNameRequest &request)const; + void setCACertificateNameAsync(const Model::SetCACertificateNameRequest& request, const SetCACertificateNameAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + SetCACertificateNameOutcomeCallable setCACertificateNameCallable(const Model::SetCACertificateNameRequest& request) const; + DescribeMasterSlaveVServerGroupAttributeOutcome describeMasterSlaveVServerGroupAttribute(const Model::DescribeMasterSlaveVServerGroupAttributeRequest &request)const; + void describeMasterSlaveVServerGroupAttributeAsync(const Model::DescribeMasterSlaveVServerGroupAttributeRequest& request, const DescribeMasterSlaveVServerGroupAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeMasterSlaveVServerGroupAttributeOutcomeCallable describeMasterSlaveVServerGroupAttributeCallable(const Model::DescribeMasterSlaveVServerGroupAttributeRequest& request) const; + CreateLoadBalancerHTTPListenerOutcome createLoadBalancerHTTPListener(const Model::CreateLoadBalancerHTTPListenerRequest &request)const; + void createLoadBalancerHTTPListenerAsync(const Model::CreateLoadBalancerHTTPListenerRequest& request, const CreateLoadBalancerHTTPListenerAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateLoadBalancerHTTPListenerOutcomeCallable createLoadBalancerHTTPListenerCallable(const Model::CreateLoadBalancerHTTPListenerRequest& request) const; + RemoveBackendServersOutcome removeBackendServers(const Model::RemoveBackendServersRequest &request)const; + void removeBackendServersAsync(const Model::RemoveBackendServersRequest& request, const RemoveBackendServersAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + RemoveBackendServersOutcomeCallable removeBackendServersCallable(const Model::RemoveBackendServersRequest& request) const; + ModifyVServerGroupBackendServersOutcome modifyVServerGroupBackendServers(const Model::ModifyVServerGroupBackendServersRequest &request)const; + void modifyVServerGroupBackendServersAsync(const Model::ModifyVServerGroupBackendServersRequest& request, const ModifyVServerGroupBackendServersAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ModifyVServerGroupBackendServersOutcomeCallable modifyVServerGroupBackendServersCallable(const Model::ModifyVServerGroupBackendServersRequest& request) const; + DescribeLoadBalancerUDPListenerAttributeOutcome describeLoadBalancerUDPListenerAttribute(const Model::DescribeLoadBalancerUDPListenerAttributeRequest &request)const; + void describeLoadBalancerUDPListenerAttributeAsync(const Model::DescribeLoadBalancerUDPListenerAttributeRequest& request, const DescribeLoadBalancerUDPListenerAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeLoadBalancerUDPListenerAttributeOutcomeCallable describeLoadBalancerUDPListenerAttributeCallable(const Model::DescribeLoadBalancerUDPListenerAttributeRequest& request) const; + DeleteRulesOutcome deleteRules(const Model::DeleteRulesRequest &request)const; + void deleteRulesAsync(const Model::DeleteRulesRequest& request, const DeleteRulesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteRulesOutcomeCallable deleteRulesCallable(const Model::DeleteRulesRequest& request) const; + DeleteMasterSlaveVServerGroupOutcome deleteMasterSlaveVServerGroup(const Model::DeleteMasterSlaveVServerGroupRequest &request)const; + void deleteMasterSlaveVServerGroupAsync(const Model::DeleteMasterSlaveVServerGroupRequest& request, const DeleteMasterSlaveVServerGroupAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteMasterSlaveVServerGroupOutcomeCallable deleteMasterSlaveVServerGroupCallable(const Model::DeleteMasterSlaveVServerGroupRequest& request) const; + DescribeCACertificatesOutcome describeCACertificates(const Model::DescribeCACertificatesRequest &request)const; + void describeCACertificatesAsync(const Model::DescribeCACertificatesRequest& request, const DescribeCACertificatesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeCACertificatesOutcomeCallable describeCACertificatesCallable(const Model::DescribeCACertificatesRequest& request) const; + CreateMasterSlaveVServerGroupOutcome createMasterSlaveVServerGroup(const Model::CreateMasterSlaveVServerGroupRequest &request)const; + void createMasterSlaveVServerGroupAsync(const Model::CreateMasterSlaveVServerGroupRequest& request, const CreateMasterSlaveVServerGroupAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateMasterSlaveVServerGroupOutcomeCallable createMasterSlaveVServerGroupCallable(const Model::CreateMasterSlaveVServerGroupRequest& request) const; + SetBackendServersOutcome setBackendServers(const Model::SetBackendServersRequest &request)const; + void setBackendServersAsync(const Model::SetBackendServersRequest& request, const SetBackendServersAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + SetBackendServersOutcomeCallable setBackendServersCallable(const Model::SetBackendServersRequest& request) const; + RemoveVServerGroupBackendServersOutcome removeVServerGroupBackendServers(const Model::RemoveVServerGroupBackendServersRequest &request)const; + void removeVServerGroupBackendServersAsync(const Model::RemoveVServerGroupBackendServersRequest& request, const RemoveVServerGroupBackendServersAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + RemoveVServerGroupBackendServersOutcomeCallable removeVServerGroupBackendServersCallable(const Model::RemoveVServerGroupBackendServersRequest& request) const; + DescribeLoadBalancerAttributeOutcome describeLoadBalancerAttribute(const Model::DescribeLoadBalancerAttributeRequest &request)const; + void describeLoadBalancerAttributeAsync(const Model::DescribeLoadBalancerAttributeRequest& request, const DescribeLoadBalancerAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeLoadBalancerAttributeOutcomeCallable describeLoadBalancerAttributeCallable(const Model::DescribeLoadBalancerAttributeRequest& request) const; + CreateMasterSlaveServerGroupOutcome createMasterSlaveServerGroup(const Model::CreateMasterSlaveServerGroupRequest &request)const; + void createMasterSlaveServerGroupAsync(const Model::CreateMasterSlaveServerGroupRequest& request, const CreateMasterSlaveServerGroupAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateMasterSlaveServerGroupOutcomeCallable createMasterSlaveServerGroupCallable(const Model::CreateMasterSlaveServerGroupRequest& request) const; + SetServerCertificateNameOutcome setServerCertificateName(const Model::SetServerCertificateNameRequest &request)const; + void setServerCertificateNameAsync(const Model::SetServerCertificateNameRequest& request, const SetServerCertificateNameAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + SetServerCertificateNameOutcomeCallable setServerCertificateNameCallable(const Model::SetServerCertificateNameRequest& request) const; + DeleteCACertificateOutcome deleteCACertificate(const Model::DeleteCACertificateRequest &request)const; + void deleteCACertificateAsync(const Model::DeleteCACertificateRequest& request, const DeleteCACertificateAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteCACertificateOutcomeCallable deleteCACertificateCallable(const Model::DeleteCACertificateRequest& request) const; + CreateLoadBalancerTCPListenerOutcome createLoadBalancerTCPListener(const Model::CreateLoadBalancerTCPListenerRequest &request)const; + void createLoadBalancerTCPListenerAsync(const Model::CreateLoadBalancerTCPListenerRequest& request, const CreateLoadBalancerTCPListenerAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateLoadBalancerTCPListenerOutcomeCallable createLoadBalancerTCPListenerCallable(const Model::CreateLoadBalancerTCPListenerRequest& request) const; + SetRuleOutcome setRule(const Model::SetRuleRequest &request)const; + void setRuleAsync(const Model::SetRuleRequest& request, const SetRuleAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + SetRuleOutcomeCallable setRuleCallable(const Model::SetRuleRequest& request) const; + DescribeMasterSlaveServerGroupsOutcome describeMasterSlaveServerGroups(const Model::DescribeMasterSlaveServerGroupsRequest &request)const; + void describeMasterSlaveServerGroupsAsync(const Model::DescribeMasterSlaveServerGroupsRequest& request, const DescribeMasterSlaveServerGroupsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeMasterSlaveServerGroupsOutcomeCallable describeMasterSlaveServerGroupsCallable(const Model::DescribeMasterSlaveServerGroupsRequest& request) const; + DescribeHealthStatusOutcome describeHealthStatus(const Model::DescribeHealthStatusRequest &request)const; + void describeHealthStatusAsync(const Model::DescribeHealthStatusRequest& request, const DescribeHealthStatusAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeHealthStatusOutcomeCallable describeHealthStatusCallable(const Model::DescribeHealthStatusRequest& request) const; + DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const; + void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const; + RemoveListenerWhiteListItemOutcome removeListenerWhiteListItem(const Model::RemoveListenerWhiteListItemRequest &request)const; + void removeListenerWhiteListItemAsync(const Model::RemoveListenerWhiteListItemRequest& request, const RemoveListenerWhiteListItemAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + RemoveListenerWhiteListItemOutcomeCallable removeListenerWhiteListItemCallable(const Model::RemoveListenerWhiteListItemRequest& request) const; + CreateLoadBalancerHTTPSListenerOutcome createLoadBalancerHTTPSListener(const Model::CreateLoadBalancerHTTPSListenerRequest &request)const; + void createLoadBalancerHTTPSListenerAsync(const Model::CreateLoadBalancerHTTPSListenerRequest& request, const CreateLoadBalancerHTTPSListenerAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateLoadBalancerHTTPSListenerOutcomeCallable createLoadBalancerHTTPSListenerCallable(const Model::CreateLoadBalancerHTTPSListenerRequest& request) const; + DeleteMasterSlaveServerGroupOutcome deleteMasterSlaveServerGroup(const Model::DeleteMasterSlaveServerGroupRequest &request)const; + void deleteMasterSlaveServerGroupAsync(const Model::DeleteMasterSlaveServerGroupRequest& request, const DeleteMasterSlaveServerGroupAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteMasterSlaveServerGroupOutcomeCallable deleteMasterSlaveServerGroupCallable(const Model::DeleteMasterSlaveServerGroupRequest& request) const; + DescribeServerCertificatesOutcome describeServerCertificates(const Model::DescribeServerCertificatesRequest &request)const; + void describeServerCertificatesAsync(const Model::DescribeServerCertificatesRequest& request, const DescribeServerCertificatesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeServerCertificatesOutcomeCallable describeServerCertificatesCallable(const Model::DescribeServerCertificatesRequest& request) const; + DescribeRulesOutcome describeRules(const Model::DescribeRulesRequest &request)const; + void describeRulesAsync(const Model::DescribeRulesRequest& request, const DescribeRulesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeRulesOutcomeCallable describeRulesCallable(const Model::DescribeRulesRequest& request) const; + DescribeRuleAttributeOutcome describeRuleAttribute(const Model::DescribeRuleAttributeRequest &request)const; + void describeRuleAttributeAsync(const Model::DescribeRuleAttributeRequest& request, const DescribeRuleAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeRuleAttributeOutcomeCallable describeRuleAttributeCallable(const Model::DescribeRuleAttributeRequest& request) const; + UploadServerCertificateOutcome uploadServerCertificate(const Model::UploadServerCertificateRequest &request)const; + void uploadServerCertificateAsync(const Model::UploadServerCertificateRequest& request, const UploadServerCertificateAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UploadServerCertificateOutcomeCallable uploadServerCertificateCallable(const Model::UploadServerCertificateRequest& request) const; + DescribeLoadBalancerAutoReleaseTimeOutcome describeLoadBalancerAutoReleaseTime(const Model::DescribeLoadBalancerAutoReleaseTimeRequest &request)const; + void describeLoadBalancerAutoReleaseTimeAsync(const Model::DescribeLoadBalancerAutoReleaseTimeRequest& request, const DescribeLoadBalancerAutoReleaseTimeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeLoadBalancerAutoReleaseTimeOutcomeCallable describeLoadBalancerAutoReleaseTimeCallable(const Model::DescribeLoadBalancerAutoReleaseTimeRequest& request) const; + DeleteServerCertificateOutcome deleteServerCertificate(const Model::DeleteServerCertificateRequest &request)const; + void deleteServerCertificateAsync(const Model::DeleteServerCertificateRequest& request, const DeleteServerCertificateAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteServerCertificateOutcomeCallable deleteServerCertificateCallable(const Model::DeleteServerCertificateRequest& request) const; + SetLoadBalancerNameOutcome setLoadBalancerName(const Model::SetLoadBalancerNameRequest &request)const; + void setLoadBalancerNameAsync(const Model::SetLoadBalancerNameRequest& request, const SetLoadBalancerNameAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + SetLoadBalancerNameOutcomeCallable setLoadBalancerNameCallable(const Model::SetLoadBalancerNameRequest& request) const; + SetVServerGroupAttributeOutcome setVServerGroupAttribute(const Model::SetVServerGroupAttributeRequest &request)const; + void setVServerGroupAttributeAsync(const Model::SetVServerGroupAttributeRequest& request, const SetVServerGroupAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + SetVServerGroupAttributeOutcomeCallable setVServerGroupAttributeCallable(const Model::SetVServerGroupAttributeRequest& request) const; + ModifyLoadBalancerInternetSpecOutcome modifyLoadBalancerInternetSpec(const Model::ModifyLoadBalancerInternetSpecRequest &request)const; + void modifyLoadBalancerInternetSpecAsync(const Model::ModifyLoadBalancerInternetSpecRequest& request, const ModifyLoadBalancerInternetSpecAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ModifyLoadBalancerInternetSpecOutcomeCallable modifyLoadBalancerInternetSpecCallable(const Model::ModifyLoadBalancerInternetSpecRequest& request) const; + DescribeLoadBalancerHTTPSListenerAttributeOutcome describeLoadBalancerHTTPSListenerAttribute(const Model::DescribeLoadBalancerHTTPSListenerAttributeRequest &request)const; + void describeLoadBalancerHTTPSListenerAttributeAsync(const Model::DescribeLoadBalancerHTTPSListenerAttributeRequest& request, const DescribeLoadBalancerHTTPSListenerAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeLoadBalancerHTTPSListenerAttributeOutcomeCallable describeLoadBalancerHTTPSListenerAttributeCallable(const Model::DescribeLoadBalancerHTTPSListenerAttributeRequest& request) const; + DescribeMasterSlaveServerGroupAttributeOutcome describeMasterSlaveServerGroupAttribute(const Model::DescribeMasterSlaveServerGroupAttributeRequest &request)const; + void describeMasterSlaveServerGroupAttributeAsync(const Model::DescribeMasterSlaveServerGroupAttributeRequest& request, const DescribeMasterSlaveServerGroupAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeMasterSlaveServerGroupAttributeOutcomeCallable describeMasterSlaveServerGroupAttributeCallable(const Model::DescribeMasterSlaveServerGroupAttributeRequest& request) const; + AddTagsOutcome addTags(const Model::AddTagsRequest &request)const; + void addTagsAsync(const Model::AddTagsRequest& request, const AddTagsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + AddTagsOutcomeCallable addTagsCallable(const Model::AddTagsRequest& request) const; + ModifyLoadBalancerPayTypeOutcome modifyLoadBalancerPayType(const Model::ModifyLoadBalancerPayTypeRequest &request)const; + void modifyLoadBalancerPayTypeAsync(const Model::ModifyLoadBalancerPayTypeRequest& request, const ModifyLoadBalancerPayTypeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ModifyLoadBalancerPayTypeOutcomeCallable modifyLoadBalancerPayTypeCallable(const Model::ModifyLoadBalancerPayTypeRequest& request) const; + AddBackendServersOutcome addBackendServers(const Model::AddBackendServersRequest &request)const; + void addBackendServersAsync(const Model::AddBackendServersRequest& request, const AddBackendServersAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + AddBackendServersOutcomeCallable addBackendServersCallable(const Model::AddBackendServersRequest& request) const; + CreateRulesOutcome createRules(const Model::CreateRulesRequest &request)const; + void createRulesAsync(const Model::CreateRulesRequest& request, const CreateRulesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateRulesOutcomeCallable createRulesCallable(const Model::CreateRulesRequest& request) const; + AddVServerGroupBackendServersOutcome addVServerGroupBackendServers(const Model::AddVServerGroupBackendServersRequest &request)const; + void addVServerGroupBackendServersAsync(const Model::AddVServerGroupBackendServersRequest& request, const AddVServerGroupBackendServersAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + AddVServerGroupBackendServersOutcomeCallable addVServerGroupBackendServersCallable(const Model::AddVServerGroupBackendServersRequest& request) const; + SetLoadBalancerUDPListenerAttributeOutcome setLoadBalancerUDPListenerAttribute(const Model::SetLoadBalancerUDPListenerAttributeRequest &request)const; + void setLoadBalancerUDPListenerAttributeAsync(const Model::SetLoadBalancerUDPListenerAttributeRequest& request, const SetLoadBalancerUDPListenerAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + SetLoadBalancerUDPListenerAttributeOutcomeCallable setLoadBalancerUDPListenerAttributeCallable(const Model::SetLoadBalancerUDPListenerAttributeRequest& request) const; + + private: + virtual EndpointOutcome endpoint()const override; + std::shared_ptr endpointProvider_; + }; + } +} + +#endif // !ALIBABACLOUD_SLB_SLBCLIENT_H_ diff --git a/slb/include/alibabacloud/slb/SlbExport.h b/slb/include/alibabacloud/slb/SlbExport.h new file mode 100644 index 000000000..fa6395031 --- /dev/null +++ b/slb/include/alibabacloud/slb/SlbExport.h @@ -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_SLB_SLBEXPORT_H_ +#define ALIBABACLOUD_SLB_SLBEXPORT_H_ + +#include + +#if defined(ALIBABACLOUD_SHARED) +# if defined(ALIBABACLOUD_SLB_LIBRARY) +# define ALIBABACLOUD_SLB_EXPORT ALIBABACLOUD_DECL_EXPORT +# else +# define ALIBABACLOUD_SLB_EXPORT ALIBABACLOUD_DECL_IMPORT +# endif +#else +# define ALIBABACLOUD_SLB_EXPORT +#endif + +#endif // !ALIBABACLOUD_SLB_SLBEXPORT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/SlbRequest.h b/slb/include/alibabacloud/slb/SlbRequest.h new file mode 100644 index 000000000..c96463060 --- /dev/null +++ b/slb/include/alibabacloud/slb/SlbRequest.h @@ -0,0 +1,39 @@ +/* + * 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_SLB_SLBREQUEST_H_ +#define ALIBABACLOUD_SLB_SLBREQUEST_H_ + +#include +#include "SlbExport.h" + +namespace AlibabaCloud +{ + namespace Slb + { + class ALIBABACLOUD_SLB_EXPORT SlbRequest : public RpcServiceRequest + { + public: + explicit SlbRequest(const std::string & action); + virtual ~SlbRequest(); + + private: + + }; + } +} + +#endif // !ALIBABACLOUD_SLB_SLBREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/AddBackendServersRequest.h b/slb/include/alibabacloud/slb/model/AddBackendServersRequest.h new file mode 100644 index 000000000..b73be5d9c --- /dev/null +++ b/slb/include/alibabacloud/slb/model/AddBackendServersRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_ADDBACKENDSERVERSREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_ADDBACKENDSERVERSREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT AddBackendServersRequest : public SlbRequest + { + + public: + AddBackendServersRequest(); + ~AddBackendServersRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getBackendServers()const; + void setBackendServers(const std::string& backendServers); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string loadBalancerId_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string backendServers_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_ADDBACKENDSERVERSREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/AddBackendServersResult.h b/slb/include/alibabacloud/slb/model/AddBackendServersResult.h new file mode 100644 index 000000000..3738a427e --- /dev/null +++ b/slb/include/alibabacloud/slb/model/AddBackendServersResult.h @@ -0,0 +1,60 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_ADDBACKENDSERVERSRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_ADDBACKENDSERVERSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT AddBackendServersResult : public ServiceResult + { + public: + struct BackendServer + { + std::string serverId; + std::string weight; + }; + + + AddBackendServersResult(); + explicit AddBackendServersResult(const std::string &payload); + ~AddBackendServersResult(); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::vector getBackendServers()const; + void setBackendServers(const std::vector& backendServers); + + protected: + void parse(const std::string &payload); + private: + std::string loadBalancerId_; + std::vector backendServers_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_ADDBACKENDSERVERSRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/AddListenerWhiteListItemRequest.h b/slb/include/alibabacloud/slb/model/AddListenerWhiteListItemRequest.h new file mode 100644 index 000000000..bf72014f3 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/AddListenerWhiteListItemRequest.h @@ -0,0 +1,77 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_ADDLISTENERWHITELISTITEMREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_ADDLISTENERWHITELISTITEMREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT AddListenerWhiteListItemRequest : public SlbRequest + { + + public: + AddListenerWhiteListItemRequest(); + ~AddListenerWhiteListItemRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getSourceItems()const; + void setSourceItems(const std::string& sourceItems); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + int listenerPort_; + std::string loadBalancerId_; + std::string sourceItems_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_ADDLISTENERWHITELISTITEMREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/AddListenerWhiteListItemResult.h b/slb/include/alibabacloud/slb/model/AddListenerWhiteListItemResult.h new file mode 100644 index 000000000..9056acc8b --- /dev/null +++ b/slb/include/alibabacloud/slb/model/AddListenerWhiteListItemResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_ADDLISTENERWHITELISTITEMRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_ADDLISTENERWHITELISTITEMRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT AddListenerWhiteListItemResult : public ServiceResult + { + public: + + + AddListenerWhiteListItemResult(); + explicit AddListenerWhiteListItemResult(const std::string &payload); + ~AddListenerWhiteListItemResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_ADDLISTENERWHITELISTITEMRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/AddTagsRequest.h b/slb/include/alibabacloud/slb/model/AddTagsRequest.h new file mode 100644 index 000000000..99b74770d --- /dev/null +++ b/slb/include/alibabacloud/slb/model/AddTagsRequest.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_ADDTAGSREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_ADDTAGSREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT AddTagsRequest : public SlbRequest + { + + public: + AddTagsRequest(); + ~AddTagsRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string loadBalancerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_ADDTAGSREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/AddTagsResult.h b/slb/include/alibabacloud/slb/model/AddTagsResult.h new file mode 100644 index 000000000..bb122558d --- /dev/null +++ b/slb/include/alibabacloud/slb/model/AddTagsResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_ADDTAGSRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_ADDTAGSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT AddTagsResult : public ServiceResult + { + public: + + + AddTagsResult(); + explicit AddTagsResult(const std::string &payload); + ~AddTagsResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_ADDTAGSRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/AddVServerGroupBackendServersRequest.h b/slb/include/alibabacloud/slb/model/AddVServerGroupBackendServersRequest.h new file mode 100644 index 000000000..67f5dff30 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/AddVServerGroupBackendServersRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_ADDVSERVERGROUPBACKENDSERVERSREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_ADDVSERVERGROUPBACKENDSERVERSREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT AddVServerGroupBackendServersRequest : public SlbRequest + { + + public: + AddVServerGroupBackendServersRequest(); + ~AddVServerGroupBackendServersRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getBackendServers()const; + void setBackendServers(const std::string& backendServers); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + std::string vServerGroupId_; + long resourceOwnerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string backendServers_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_ADDVSERVERGROUPBACKENDSERVERSREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/AddVServerGroupBackendServersResult.h b/slb/include/alibabacloud/slb/model/AddVServerGroupBackendServersResult.h new file mode 100644 index 000000000..9b843d4a8 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/AddVServerGroupBackendServersResult.h @@ -0,0 +1,61 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_ADDVSERVERGROUPBACKENDSERVERSRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_ADDVSERVERGROUPBACKENDSERVERSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT AddVServerGroupBackendServersResult : public ServiceResult + { + public: + struct BackendServer + { + std::string serverId; + int port; + int weight; + }; + + + AddVServerGroupBackendServersResult(); + explicit AddVServerGroupBackendServersResult(const std::string &payload); + ~AddVServerGroupBackendServersResult(); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + std::vector getBackendServers()const; + void setBackendServers(const std::vector& backendServers); + + protected: + void parse(const std::string &payload); + private: + std::string vServerGroupId_; + std::vector backendServers_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_ADDVSERVERGROUPBACKENDSERVERSRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/CreateLoadBalancerHTTPListenerRequest.h b/slb/include/alibabacloud/slb/model/CreateLoadBalancerHTTPListenerRequest.h new file mode 100644 index 000000000..2e83858c3 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/CreateLoadBalancerHTTPListenerRequest.h @@ -0,0 +1,143 @@ +/* + * 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_SLB_MODEL_CREATELOADBALANCERHTTPLISTENERREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPLISTENERREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerHTTPListenerRequest : public SlbRequest + { + + public: + CreateLoadBalancerHTTPListenerRequest(); + ~CreateLoadBalancerHTTPListenerRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + int getHealthCheckTimeout()const; + void setHealthCheckTimeout(int healthCheckTimeout); + std::string getXForwardedFor()const; + void setXForwardedFor(const std::string& xForwardedFor); + std::string getHealthCheckURI()const; + void setHealthCheckURI(const std::string& healthCheckURI); + int getUnhealthyThreshold()const; + void setUnhealthyThreshold(int unhealthyThreshold); + int getHealthyThreshold()const; + void setHealthyThreshold(int healthyThreshold); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getScheduler()const; + void setScheduler(const std::string& scheduler); + std::string getHealthCheck()const; + void setHealthCheck(const std::string& healthCheck); + int getMaxConnection()const; + void setMaxConnection(int maxConnection); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + int getCookieTimeout()const; + void setCookieTimeout(int cookieTimeout); + std::string getStickySessionType()const; + void setStickySessionType(const std::string& stickySessionType); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getCookie()const; + void setCookie(const std::string& cookie); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + int getBandwidth()const; + void setBandwidth(int bandwidth); + std::string getStickySession()const; + void setStickySession(const std::string& stickySession); + std::string getHealthCheckDomain()const; + void setHealthCheckDomain(const std::string& healthCheckDomain); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + std::string getGzip()const; + void setGzip(const std::string& gzip); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getTags()const; + void setTags(const std::string& tags); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getXForwardedFor_SLBIP()const; + void setXForwardedFor_SLBIP(const std::string& xForwardedFor_SLBIP); + int getBackendServerPort()const; + void setBackendServerPort(int backendServerPort); + int getHealthCheckInterval()const; + void setHealthCheckInterval(int healthCheckInterval); + std::string getXForwardedFor_proto()const; + void setXForwardedFor_proto(const std::string& xForwardedFor_proto); + std::string getXForwardedFor_SLBID()const; + void setXForwardedFor_SLBID(const std::string& xForwardedFor_SLBID); + int getHealthCheckConnectPort()const; + void setHealthCheckConnectPort(int healthCheckConnectPort); + std::string getHealthCheckHttpCode()const; + void setHealthCheckHttpCode(const std::string& healthCheckHttpCode); + + private: + std::string access_key_id_; + long resourceOwnerId_; + int healthCheckTimeout_; + std::string xForwardedFor_; + std::string healthCheckURI_; + int unhealthyThreshold_; + int healthyThreshold_; + std::string accessKeyId_; + std::string scheduler_; + std::string healthCheck_; + int maxConnection_; + std::string regionId_; + int cookieTimeout_; + std::string stickySessionType_; + std::string vServerGroupId_; + int listenerPort_; + std::string cookie_; + std::string resourceOwnerAccount_; + int bandwidth_; + std::string stickySession_; + std::string healthCheckDomain_; + std::string ownerAccount_; + std::string gzip_; + long ownerId_; + std::string tags_; + std::string loadBalancerId_; + std::string xForwardedFor_SLBIP_; + int backendServerPort_; + int healthCheckInterval_; + std::string xForwardedFor_proto_; + std::string xForwardedFor_SLBID_; + int healthCheckConnectPort_; + std::string healthCheckHttpCode_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPLISTENERREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/CreateLoadBalancerHTTPListenerResult.h b/slb/include/alibabacloud/slb/model/CreateLoadBalancerHTTPListenerResult.h new file mode 100644 index 000000000..48215e248 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/CreateLoadBalancerHTTPListenerResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPLISTENERRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPLISTENERRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerHTTPListenerResult : public ServiceResult + { + public: + + + CreateLoadBalancerHTTPListenerResult(); + explicit CreateLoadBalancerHTTPListenerResult(const std::string &payload); + ~CreateLoadBalancerHTTPListenerResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPLISTENERRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/CreateLoadBalancerHTTPSListenerRequest.h b/slb/include/alibabacloud/slb/model/CreateLoadBalancerHTTPSListenerRequest.h new file mode 100644 index 000000000..65ad56fa6 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/CreateLoadBalancerHTTPSListenerRequest.h @@ -0,0 +1,149 @@ +/* + * 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_SLB_MODEL_CREATELOADBALANCERHTTPSLISTENERREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPSLISTENERREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerHTTPSListenerRequest : public SlbRequest + { + + public: + CreateLoadBalancerHTTPSListenerRequest(); + ~CreateLoadBalancerHTTPSListenerRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + int getHealthCheckTimeout()const; + void setHealthCheckTimeout(int healthCheckTimeout); + std::string getXForwardedFor()const; + void setXForwardedFor(const std::string& xForwardedFor); + std::string getHealthCheckURI()const; + void setHealthCheckURI(const std::string& healthCheckURI); + int getUnhealthyThreshold()const; + void setUnhealthyThreshold(int unhealthyThreshold); + int getHealthyThreshold()const; + void setHealthyThreshold(int healthyThreshold); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getScheduler()const; + void setScheduler(const std::string& scheduler); + std::string getHealthCheck()const; + void setHealthCheck(const std::string& healthCheck); + int getMaxConnection()const; + void setMaxConnection(int maxConnection); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + int getCookieTimeout()const; + void setCookieTimeout(int cookieTimeout); + std::string getStickySessionType()const; + void setStickySessionType(const std::string& stickySessionType); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getCookie()const; + void setCookie(const std::string& cookie); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + int getBandwidth()const; + void setBandwidth(int bandwidth); + std::string getStickySession()const; + void setStickySession(const std::string& stickySession); + std::string getHealthCheckDomain()const; + void setHealthCheckDomain(const std::string& healthCheckDomain); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + std::string getGzip()const; + void setGzip(const std::string& gzip); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getServerCertificateId()const; + void setServerCertificateId(const std::string& serverCertificateId); + std::string getCACertificateId()const; + void setCACertificateId(const std::string& cACertificateId); + std::string getTags()const; + void setTags(const std::string& tags); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getXForwardedFor_SLBIP()const; + void setXForwardedFor_SLBIP(const std::string& xForwardedFor_SLBIP); + int getBackendServerPort()const; + void setBackendServerPort(int backendServerPort); + int getHealthCheckInterval()const; + void setHealthCheckInterval(int healthCheckInterval); + std::string getXForwardedFor_proto()const; + void setXForwardedFor_proto(const std::string& xForwardedFor_proto); + std::string getXForwardedFor_SLBID()const; + void setXForwardedFor_SLBID(const std::string& xForwardedFor_SLBID); + int getHealthCheckConnectPort()const; + void setHealthCheckConnectPort(int healthCheckConnectPort); + std::string getHealthCheckHttpCode()const; + void setHealthCheckHttpCode(const std::string& healthCheckHttpCode); + + private: + std::string access_key_id_; + long resourceOwnerId_; + int healthCheckTimeout_; + std::string xForwardedFor_; + std::string healthCheckURI_; + int unhealthyThreshold_; + int healthyThreshold_; + std::string accessKeyId_; + std::string scheduler_; + std::string healthCheck_; + int maxConnection_; + std::string regionId_; + int cookieTimeout_; + std::string stickySessionType_; + std::string vServerGroupId_; + int listenerPort_; + std::string cookie_; + std::string resourceOwnerAccount_; + int bandwidth_; + std::string stickySession_; + std::string healthCheckDomain_; + std::string ownerAccount_; + std::string gzip_; + long ownerId_; + std::string serverCertificateId_; + std::string cACertificateId_; + std::string tags_; + std::string loadBalancerId_; + std::string xForwardedFor_SLBIP_; + int backendServerPort_; + int healthCheckInterval_; + std::string xForwardedFor_proto_; + std::string xForwardedFor_SLBID_; + int healthCheckConnectPort_; + std::string healthCheckHttpCode_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPSLISTENERREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/CreateLoadBalancerHTTPSListenerResult.h b/slb/include/alibabacloud/slb/model/CreateLoadBalancerHTTPSListenerResult.h new file mode 100644 index 000000000..cd11deed0 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/CreateLoadBalancerHTTPSListenerResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPSLISTENERRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPSLISTENERRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerHTTPSListenerResult : public ServiceResult + { + public: + + + CreateLoadBalancerHTTPSListenerResult(); + explicit CreateLoadBalancerHTTPSListenerResult(const std::string &payload); + ~CreateLoadBalancerHTTPSListenerResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPSLISTENERRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/CreateLoadBalancerRequest.h b/slb/include/alibabacloud/slb/model/CreateLoadBalancerRequest.h new file mode 100644 index 000000000..a1aae2e01 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/CreateLoadBalancerRequest.h @@ -0,0 +1,116 @@ +/* + * 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_SLB_MODEL_CREATELOADBALANCERREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerRequest : public SlbRequest + { + + public: + CreateLoadBalancerRequest(); + ~CreateLoadBalancerRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getClientToken()const; + void setClientToken(const std::string& clientToken); + std::string getMasterZoneId()const; + void setMasterZoneId(const std::string& masterZoneId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + int getDuration()const; + void setDuration(int duration); + std::string getResourceGroupId()const; + void setResourceGroupId(const std::string& resourceGroupId); + std::string getLoadBalancerName()const; + void setLoadBalancerName(const std::string& loadBalancerName); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getAddressType()const; + void setAddressType(const std::string& addressType); + std::string getSlaveZoneId()const; + void setSlaveZoneId(const std::string& slaveZoneId); + std::string getLoadBalancerSpec()const; + void setLoadBalancerSpec(const std::string& loadBalancerSpec); + bool getAutoPay()const; + void setAutoPay(bool autoPay); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + int getBandwidth()const; + void setBandwidth(int bandwidth); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getTags()const; + void setTags(const std::string& tags); + std::string getVSwitchId()const; + void setVSwitchId(const std::string& vSwitchId); + std::string getEnableVpcVipFlow()const; + void setEnableVpcVipFlow(const std::string& enableVpcVipFlow); + std::string getInternetChargeType()const; + void setInternetChargeType(const std::string& internetChargeType); + std::string getVpcId()const; + void setVpcId(const std::string& vpcId); + std::string getPayType()const; + void setPayType(const std::string& payType); + std::string getPricingCycle()const; + void setPricingCycle(const std::string& pricingCycle); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string clientToken_; + std::string masterZoneId_; + std::string accessKeyId_; + int duration_; + std::string resourceGroupId_; + std::string loadBalancerName_; + std::string regionId_; + std::string addressType_; + std::string slaveZoneId_; + std::string loadBalancerSpec_; + bool autoPay_; + std::string resourceOwnerAccount_; + int bandwidth_; + std::string ownerAccount_; + long ownerId_; + std::string tags_; + std::string vSwitchId_; + std::string enableVpcVipFlow_; + std::string internetChargeType_; + std::string vpcId_; + std::string payType_; + std::string pricingCycle_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/CreateLoadBalancerResult.h b/slb/include/alibabacloud/slb/model/CreateLoadBalancerResult.h new file mode 100644 index 000000000..aa5dc9fef --- /dev/null +++ b/slb/include/alibabacloud/slb/model/CreateLoadBalancerResult.h @@ -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. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerResult : public ServiceResult + { + public: + + + CreateLoadBalancerResult(); + explicit CreateLoadBalancerResult(const std::string &payload); + ~CreateLoadBalancerResult(); + std::string getLoadBalancerName()const; + void setLoadBalancerName(const std::string& loadBalancerName); + std::string getResourceGroupId()const; + void setResourceGroupId(const std::string& resourceGroupId); + std::string getAddress()const; + void setAddress(const std::string& address); + std::string getVpcId()const; + void setVpcId(const std::string& vpcId); + std::string getNetworkType()const; + void setNetworkType(const std::string& networkType); + std::string getVSwitchId()const; + void setVSwitchId(const std::string& vSwitchId); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + long getOrderId()const; + void setOrderId(long orderId); + + protected: + void parse(const std::string &payload); + private: + std::string loadBalancerName_; + std::string resourceGroupId_; + std::string address_; + std::string vpcId_; + std::string networkType_; + std::string vSwitchId_; + std::string loadBalancerId_; + long orderId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/CreateLoadBalancerTCPListenerRequest.h b/slb/include/alibabacloud/slb/model/CreateLoadBalancerTCPListenerRequest.h new file mode 100644 index 000000000..40c99e172 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/CreateLoadBalancerTCPListenerRequest.h @@ -0,0 +1,125 @@ +/* + * 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_SLB_MODEL_CREATELOADBALANCERTCPLISTENERREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERTCPLISTENERREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerTCPListenerRequest : public SlbRequest + { + + public: + CreateLoadBalancerTCPListenerRequest(); + ~CreateLoadBalancerTCPListenerRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + int getHealthCheckConnectTimeout()const; + void setHealthCheckConnectTimeout(int healthCheckConnectTimeout); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getHealthCheckURI()const; + void setHealthCheckURI(const std::string& healthCheckURI); + int getUnhealthyThreshold()const; + void setUnhealthyThreshold(int unhealthyThreshold); + int getHealthyThreshold()const; + void setHealthyThreshold(int healthyThreshold); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getScheduler()const; + void setScheduler(const std::string& scheduler); + int getEstablishedTimeout()const; + void setEstablishedTimeout(int establishedTimeout); + int getMaxConnection()const; + void setMaxConnection(int maxConnection); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + int getPersistenceTimeout()const; + void setPersistenceTimeout(int persistenceTimeout); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getHealthCheckType()const; + void setHealthCheckType(const std::string& healthCheckType); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + int getBandwidth()const; + void setBandwidth(int bandwidth); + std::string getHealthCheckDomain()const; + void setHealthCheckDomain(const std::string& healthCheckDomain); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getTags()const; + void setTags(const std::string& tags); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getMasterSlaveServerGroupId()const; + void setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId); + int getBackendServerPort()const; + void setBackendServerPort(int backendServerPort); + int getHealthCheckInterval()const; + void setHealthCheckInterval(int healthCheckInterval); + int getHealthCheckConnectPort()const; + void setHealthCheckConnectPort(int healthCheckConnectPort); + std::string getHealthCheckHttpCode()const; + void setHealthCheckHttpCode(const std::string& healthCheckHttpCode); + + private: + std::string access_key_id_; + int healthCheckConnectTimeout_; + long resourceOwnerId_; + std::string healthCheckURI_; + int unhealthyThreshold_; + int healthyThreshold_; + std::string accessKeyId_; + std::string scheduler_; + int establishedTimeout_; + int maxConnection_; + std::string regionId_; + int persistenceTimeout_; + std::string vServerGroupId_; + int listenerPort_; + std::string healthCheckType_; + std::string resourceOwnerAccount_; + int bandwidth_; + std::string healthCheckDomain_; + std::string ownerAccount_; + long ownerId_; + std::string tags_; + std::string loadBalancerId_; + std::string masterSlaveServerGroupId_; + int backendServerPort_; + int healthCheckInterval_; + int healthCheckConnectPort_; + std::string healthCheckHttpCode_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERTCPLISTENERREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/CreateLoadBalancerTCPListenerResult.h b/slb/include/alibabacloud/slb/model/CreateLoadBalancerTCPListenerResult.h new file mode 100644 index 000000000..7e72b8aa9 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/CreateLoadBalancerTCPListenerResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERTCPLISTENERRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERTCPLISTENERRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerTCPListenerResult : public ServiceResult + { + public: + + + CreateLoadBalancerTCPListenerResult(); + explicit CreateLoadBalancerTCPListenerResult(const std::string &payload); + ~CreateLoadBalancerTCPListenerResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERTCPLISTENERRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/CreateLoadBalancerUDPListenerRequest.h b/slb/include/alibabacloud/slb/model/CreateLoadBalancerUDPListenerRequest.h new file mode 100644 index 000000000..bd493e038 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/CreateLoadBalancerUDPListenerRequest.h @@ -0,0 +1,116 @@ +/* + * 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_SLB_MODEL_CREATELOADBALANCERUDPLISTENERREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERUDPLISTENERREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerUDPListenerRequest : public SlbRequest + { + + public: + CreateLoadBalancerUDPListenerRequest(); + ~CreateLoadBalancerUDPListenerRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + int getHealthCheckConnectTimeout()const; + void setHealthCheckConnectTimeout(int healthCheckConnectTimeout); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + int getUnhealthyThreshold()const; + void setUnhealthyThreshold(int unhealthyThreshold); + int getHealthyThreshold()const; + void setHealthyThreshold(int healthyThreshold); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getScheduler()const; + void setScheduler(const std::string& scheduler); + int getMaxConnection()const; + void setMaxConnection(int maxConnection); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + int getPersistenceTimeout()const; + void setPersistenceTimeout(int persistenceTimeout); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + int getBandwidth()const; + void setBandwidth(int bandwidth); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getTags()const; + void setTags(const std::string& tags); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getMasterSlaveServerGroupId()const; + void setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId); + std::string getHealthCheckReq()const; + void setHealthCheckReq(const std::string& healthCheckReq); + int getBackendServerPort()const; + void setBackendServerPort(int backendServerPort); + int getHealthCheckInterval()const; + void setHealthCheckInterval(int healthCheckInterval); + std::string getHealthCheckExp()const; + void setHealthCheckExp(const std::string& healthCheckExp); + int getHealthCheckConnectPort()const; + void setHealthCheckConnectPort(int healthCheckConnectPort); + + private: + std::string access_key_id_; + int healthCheckConnectTimeout_; + long resourceOwnerId_; + int unhealthyThreshold_; + int healthyThreshold_; + std::string accessKeyId_; + std::string scheduler_; + int maxConnection_; + std::string regionId_; + int persistenceTimeout_; + std::string vServerGroupId_; + int listenerPort_; + std::string resourceOwnerAccount_; + int bandwidth_; + std::string ownerAccount_; + long ownerId_; + std::string tags_; + std::string loadBalancerId_; + std::string masterSlaveServerGroupId_; + std::string healthCheckReq_; + int backendServerPort_; + int healthCheckInterval_; + std::string healthCheckExp_; + int healthCheckConnectPort_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERUDPLISTENERREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/CreateLoadBalancerUDPListenerResult.h b/slb/include/alibabacloud/slb/model/CreateLoadBalancerUDPListenerResult.h new file mode 100644 index 000000000..f539b0ffa --- /dev/null +++ b/slb/include/alibabacloud/slb/model/CreateLoadBalancerUDPListenerResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERUDPLISTENERRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERUDPLISTENERRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerUDPListenerResult : public ServiceResult + { + public: + + + CreateLoadBalancerUDPListenerResult(); + explicit CreateLoadBalancerUDPListenerResult(const std::string &payload); + ~CreateLoadBalancerUDPListenerResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERUDPLISTENERRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/CreateMasterSlaveServerGroupRequest.h b/slb/include/alibabacloud/slb/model/CreateMasterSlaveServerGroupRequest.h new file mode 100644 index 000000000..791126153 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/CreateMasterSlaveServerGroupRequest.h @@ -0,0 +1,77 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVESERVERGROUPREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVESERVERGROUPREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT CreateMasterSlaveServerGroupRequest : public SlbRequest + { + + public: + CreateMasterSlaveServerGroupRequest(); + ~CreateMasterSlaveServerGroupRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getMasterSlaveBackendServers()const; + void setMasterSlaveBackendServers(const std::string& masterSlaveBackendServers); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + std::string getMasterSlaveServerGroupName()const; + void setMasterSlaveServerGroupName(const std::string& masterSlaveServerGroupName); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string masterSlaveBackendServers_; + std::string loadBalancerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + std::string masterSlaveServerGroupName_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVESERVERGROUPREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/CreateMasterSlaveServerGroupResult.h b/slb/include/alibabacloud/slb/model/CreateMasterSlaveServerGroupResult.h new file mode 100644 index 000000000..976aaf8e8 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/CreateMasterSlaveServerGroupResult.h @@ -0,0 +1,62 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVESERVERGROUPRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVESERVERGROUPRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT CreateMasterSlaveServerGroupResult : public ServiceResult + { + public: + struct MasterSlaveBackendServer + { + std::string serverType; + std::string serverId; + int port; + int weight; + }; + + + CreateMasterSlaveServerGroupResult(); + explicit CreateMasterSlaveServerGroupResult(const std::string &payload); + ~CreateMasterSlaveServerGroupResult(); + std::string getMasterSlaveServerGroupId()const; + void setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId); + std::vector getMasterSlaveBackendServers()const; + void setMasterSlaveBackendServers(const std::vector& masterSlaveBackendServers); + + protected: + void parse(const std::string &payload); + private: + std::string masterSlaveServerGroupId_; + std::vector masterSlaveBackendServers_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVESERVERGROUPRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/CreateMasterSlaveVServerGroupRequest.h b/slb/include/alibabacloud/slb/model/CreateMasterSlaveVServerGroupRequest.h new file mode 100644 index 000000000..2ce18d4c6 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/CreateMasterSlaveVServerGroupRequest.h @@ -0,0 +1,77 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT CreateMasterSlaveVServerGroupRequest : public SlbRequest + { + + public: + CreateMasterSlaveVServerGroupRequest(); + ~CreateMasterSlaveVServerGroupRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getMasterSlaveBackendServers()const; + void setMasterSlaveBackendServers(const std::string& masterSlaveBackendServers); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + std::string getMasterSlaveVServerGroupName()const; + void setMasterSlaveVServerGroupName(const std::string& masterSlaveVServerGroupName); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string masterSlaveBackendServers_; + std::string loadBalancerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + std::string masterSlaveVServerGroupName_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/CreateMasterSlaveVServerGroupResult.h b/slb/include/alibabacloud/slb/model/CreateMasterSlaveVServerGroupResult.h new file mode 100644 index 000000000..609fcd6f9 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/CreateMasterSlaveVServerGroupResult.h @@ -0,0 +1,62 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT CreateMasterSlaveVServerGroupResult : public ServiceResult + { + public: + struct MasterSlaveBackendServer + { + std::string serverId; + int port; + int isBackup; + int weight; + }; + + + CreateMasterSlaveVServerGroupResult(); + explicit CreateMasterSlaveVServerGroupResult(const std::string &payload); + ~CreateMasterSlaveVServerGroupResult(); + std::string getMasterSlaveVServerGroupId()const; + void setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId); + std::vector getMasterSlaveBackendServers()const; + void setMasterSlaveBackendServers(const std::vector& masterSlaveBackendServers); + + protected: + void parse(const std::string &payload); + private: + std::string masterSlaveVServerGroupId_; + std::vector masterSlaveBackendServers_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/CreateRulesRequest.h b/slb/include/alibabacloud/slb/model/CreateRulesRequest.h new file mode 100644 index 000000000..20ff0c771 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/CreateRulesRequest.h @@ -0,0 +1,77 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_CREATERULESREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_CREATERULESREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT CreateRulesRequest : public SlbRequest + { + + public: + CreateRulesRequest(); + ~CreateRulesRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getRuleList()const; + void setRuleList(const std::string& ruleList); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + int listenerPort_; + std::string loadBalancerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ruleList_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_CREATERULESREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/CreateRulesResult.h b/slb/include/alibabacloud/slb/model/CreateRulesResult.h new file mode 100644 index 000000000..81e3fbd7f --- /dev/null +++ b/slb/include/alibabacloud/slb/model/CreateRulesResult.h @@ -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_SLB_MODEL_CREATERULESRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_CREATERULESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT CreateRulesResult : public ServiceResult + { + public: + struct Rule + { + std::string ruleId; + std::string ruleName; + }; + + + CreateRulesResult(); + explicit CreateRulesResult(const std::string &payload); + ~CreateRulesResult(); + std::vector getRules()const; + void setRules(const std::vector& rules); + + protected: + void parse(const std::string &payload); + private: + std::vector rules_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_CREATERULESRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/CreateVServerGroupRequest.h b/slb/include/alibabacloud/slb/model/CreateVServerGroupRequest.h new file mode 100644 index 000000000..814fad32b --- /dev/null +++ b/slb/include/alibabacloud/slb/model/CreateVServerGroupRequest.h @@ -0,0 +1,77 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_CREATEVSERVERGROUPREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_CREATEVSERVERGROUPREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT CreateVServerGroupRequest : public SlbRequest + { + + public: + CreateVServerGroupRequest(); + ~CreateVServerGroupRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getBackendServers()const; + void setBackendServers(const std::string& backendServers); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + std::string getVServerGroupName()const; + void setVServerGroupName(const std::string& vServerGroupName); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string loadBalancerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string backendServers_; + std::string accessKeyId_; + std::string tags_; + std::string vServerGroupName_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_CREATEVSERVERGROUPREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/CreateVServerGroupResult.h b/slb/include/alibabacloud/slb/model/CreateVServerGroupResult.h new file mode 100644 index 000000000..b50202e6b --- /dev/null +++ b/slb/include/alibabacloud/slb/model/CreateVServerGroupResult.h @@ -0,0 +1,61 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_CREATEVSERVERGROUPRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_CREATEVSERVERGROUPRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT CreateVServerGroupResult : public ServiceResult + { + public: + struct BackendServer + { + std::string serverId; + int port; + int weight; + }; + + + CreateVServerGroupResult(); + explicit CreateVServerGroupResult(const std::string &payload); + ~CreateVServerGroupResult(); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + std::vector getBackendServers()const; + void setBackendServers(const std::vector& backendServers); + + protected: + void parse(const std::string &payload); + private: + std::string vServerGroupId_; + std::vector backendServers_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_CREATEVSERVERGROUPRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DeleteCACertificateRequest.h b/slb/include/alibabacloud/slb/model/DeleteCACertificateRequest.h new file mode 100644 index 000000000..8b226b4fe --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DeleteCACertificateRequest.h @@ -0,0 +1,68 @@ +/* + * 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_SLB_MODEL_DELETECACERTIFICATEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DELETECACERTIFICATEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DeleteCACertificateRequest : public SlbRequest + { + + public: + DeleteCACertificateRequest(); + ~DeleteCACertificateRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getCACertificateId()const; + void setCACertificateId(const std::string& cACertificateId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string cACertificateId_; + std::string accessKeyId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DELETECACERTIFICATEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DeleteCACertificateResult.h b/slb/include/alibabacloud/slb/model/DeleteCACertificateResult.h new file mode 100644 index 000000000..ca976a58e --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DeleteCACertificateResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DELETECACERTIFICATERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DELETECACERTIFICATERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DeleteCACertificateResult : public ServiceResult + { + public: + + + DeleteCACertificateResult(); + explicit DeleteCACertificateResult(const std::string &payload); + ~DeleteCACertificateResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DELETECACERTIFICATERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DeleteLoadBalancerListenerRequest.h b/slb/include/alibabacloud/slb/model/DeleteLoadBalancerListenerRequest.h new file mode 100644 index 000000000..b6c16a450 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DeleteLoadBalancerListenerRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_DELETELOADBALANCERLISTENERREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERLISTENERREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DeleteLoadBalancerListenerRequest : public SlbRequest + { + + public: + DeleteLoadBalancerListenerRequest(); + ~DeleteLoadBalancerListenerRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + int listenerPort_; + std::string loadBalancerId_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERLISTENERREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DeleteLoadBalancerListenerResult.h b/slb/include/alibabacloud/slb/model/DeleteLoadBalancerListenerResult.h new file mode 100644 index 000000000..9d4fa81a7 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DeleteLoadBalancerListenerResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERLISTENERRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERLISTENERRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DeleteLoadBalancerListenerResult : public ServiceResult + { + public: + + + DeleteLoadBalancerListenerResult(); + explicit DeleteLoadBalancerListenerResult(const std::string &payload); + ~DeleteLoadBalancerListenerResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERLISTENERRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DeleteLoadBalancerRequest.h b/slb/include/alibabacloud/slb/model/DeleteLoadBalancerRequest.h new file mode 100644 index 000000000..155eb6082 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DeleteLoadBalancerRequest.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DeleteLoadBalancerRequest : public SlbRequest + { + + public: + DeleteLoadBalancerRequest(); + ~DeleteLoadBalancerRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string loadBalancerId_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DeleteLoadBalancerResult.h b/slb/include/alibabacloud/slb/model/DeleteLoadBalancerResult.h new file mode 100644 index 000000000..18e7ffebb --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DeleteLoadBalancerResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DeleteLoadBalancerResult : public ServiceResult + { + public: + + + DeleteLoadBalancerResult(); + explicit DeleteLoadBalancerResult(const std::string &payload); + ~DeleteLoadBalancerResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DeleteMasterSlaveServerGroupRequest.h b/slb/include/alibabacloud/slb/model/DeleteMasterSlaveServerGroupRequest.h new file mode 100644 index 000000000..0d903c646 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DeleteMasterSlaveServerGroupRequest.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVESERVERGROUPREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVESERVERGROUPREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DeleteMasterSlaveServerGroupRequest : public SlbRequest + { + + public: + DeleteMasterSlaveServerGroupRequest(); + ~DeleteMasterSlaveServerGroupRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getMasterSlaveServerGroupId()const; + void setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string masterSlaveServerGroupId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVESERVERGROUPREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DeleteMasterSlaveServerGroupResult.h b/slb/include/alibabacloud/slb/model/DeleteMasterSlaveServerGroupResult.h new file mode 100644 index 000000000..20b324fa7 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DeleteMasterSlaveServerGroupResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVESERVERGROUPRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVESERVERGROUPRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DeleteMasterSlaveServerGroupResult : public ServiceResult + { + public: + + + DeleteMasterSlaveServerGroupResult(); + explicit DeleteMasterSlaveServerGroupResult(const std::string &payload); + ~DeleteMasterSlaveServerGroupResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVESERVERGROUPRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DeleteMasterSlaveVServerGroupRequest.h b/slb/include/alibabacloud/slb/model/DeleteMasterSlaveVServerGroupRequest.h new file mode 100644 index 000000000..e7b60bf8a --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DeleteMasterSlaveVServerGroupRequest.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DeleteMasterSlaveVServerGroupRequest : public SlbRequest + { + + public: + DeleteMasterSlaveVServerGroupRequest(); + ~DeleteMasterSlaveVServerGroupRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getMasterSlaveVServerGroupId()const; + void setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string masterSlaveVServerGroupId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DeleteMasterSlaveVServerGroupResult.h b/slb/include/alibabacloud/slb/model/DeleteMasterSlaveVServerGroupResult.h new file mode 100644 index 000000000..d86c1127b --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DeleteMasterSlaveVServerGroupResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DeleteMasterSlaveVServerGroupResult : public ServiceResult + { + public: + + + DeleteMasterSlaveVServerGroupResult(); + explicit DeleteMasterSlaveVServerGroupResult(const std::string &payload); + ~DeleteMasterSlaveVServerGroupResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DeleteRulesRequest.h b/slb/include/alibabacloud/slb/model/DeleteRulesRequest.h new file mode 100644 index 000000000..dab980fcd --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DeleteRulesRequest.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DELETERULESREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DELETERULESREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DeleteRulesRequest : public SlbRequest + { + + public: + DeleteRulesRequest(); + ~DeleteRulesRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getRuleIds()const; + void setRuleIds(const std::string& ruleIds); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string ruleIds_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DELETERULESREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DeleteRulesResult.h b/slb/include/alibabacloud/slb/model/DeleteRulesResult.h new file mode 100644 index 000000000..e73f875a3 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DeleteRulesResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DELETERULESRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DELETERULESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DeleteRulesResult : public ServiceResult + { + public: + + + DeleteRulesResult(); + explicit DeleteRulesResult(const std::string &payload); + ~DeleteRulesResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DELETERULESRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DeleteServerCertificateRequest.h b/slb/include/alibabacloud/slb/model/DeleteServerCertificateRequest.h new file mode 100644 index 000000000..423cc787c --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DeleteServerCertificateRequest.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DELETESERVERCERTIFICATEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DELETESERVERCERTIFICATEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DeleteServerCertificateRequest : public SlbRequest + { + + public: + DeleteServerCertificateRequest(); + ~DeleteServerCertificateRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getServerCertificateId()const; + void setServerCertificateId(const std::string& serverCertificateId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string serverCertificateId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DELETESERVERCERTIFICATEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DeleteServerCertificateResult.h b/slb/include/alibabacloud/slb/model/DeleteServerCertificateResult.h new file mode 100644 index 000000000..f4b425f0b --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DeleteServerCertificateResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DELETESERVERCERTIFICATERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DELETESERVERCERTIFICATERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DeleteServerCertificateResult : public ServiceResult + { + public: + + + DeleteServerCertificateResult(); + explicit DeleteServerCertificateResult(const std::string &payload); + ~DeleteServerCertificateResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DELETESERVERCERTIFICATERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DeleteVServerGroupRequest.h b/slb/include/alibabacloud/slb/model/DeleteVServerGroupRequest.h new file mode 100644 index 000000000..caa34ffdb --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DeleteVServerGroupRequest.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DELETEVSERVERGROUPREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DELETEVSERVERGROUPREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DeleteVServerGroupRequest : public SlbRequest + { + + public: + DeleteVServerGroupRequest(); + ~DeleteVServerGroupRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + std::string vServerGroupId_; + long resourceOwnerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DELETEVSERVERGROUPREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DeleteVServerGroupResult.h b/slb/include/alibabacloud/slb/model/DeleteVServerGroupResult.h new file mode 100644 index 000000000..3766a1610 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DeleteVServerGroupResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DELETEVSERVERGROUPRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DELETEVSERVERGROUPRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DeleteVServerGroupResult : public ServiceResult + { + public: + + + DeleteVServerGroupResult(); + explicit DeleteVServerGroupResult(const std::string &payload); + ~DeleteVServerGroupResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DELETEVSERVERGROUPRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeCACertificatesRequest.h b/slb/include/alibabacloud/slb/model/DescribeCACertificatesRequest.h new file mode 100644 index 000000000..8ac5797f5 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeCACertificatesRequest.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBECACERTIFICATESREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBECACERTIFICATESREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeCACertificatesRequest : public SlbRequest + { + + public: + DescribeCACertificatesRequest(); + ~DescribeCACertificatesRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + std::string getResourceGroupId()const; + void setResourceGroupId(const std::string& resourceGroupId); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getCACertificateId()const; + void setCACertificateId(const std::string& cACertificateId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + + private: + std::string access_key_id_; + std::string resourceGroupId_; + long resourceOwnerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string cACertificateId_; + std::string accessKeyId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBECACERTIFICATESREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeCACertificatesResult.h b/slb/include/alibabacloud/slb/model/DescribeCACertificatesResult.h new file mode 100644 index 000000000..fd3ffaf09 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeCACertificatesResult.h @@ -0,0 +1,62 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBECACERTIFICATESRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBECACERTIFICATESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeCACertificatesResult : public ServiceResult + { + public: + struct CACertificate + { + std::string fingerprint; + std::string resourceGroupId; + std::string cACertificateId; + std::string createTime; + std::string cACertificateName; + std::string regionId; + long createTimeStamp; + }; + + + DescribeCACertificatesResult(); + explicit DescribeCACertificatesResult(const std::string &payload); + ~DescribeCACertificatesResult(); + std::vector getCACertificates()const; + void setCACertificates(const std::vector& cACertificates); + + protected: + void parse(const std::string &payload); + private: + std::vector cACertificates_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBECACERTIFICATESRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeHealthStatusRequest.h b/slb/include/alibabacloud/slb/model/DescribeHealthStatusRequest.h new file mode 100644 index 000000000..fe79c1be9 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeHealthStatusRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_DESCRIBEHEALTHSTATUSREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBEHEALTHSTATUSREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeHealthStatusRequest : public SlbRequest + { + + public: + DescribeHealthStatusRequest(); + ~DescribeHealthStatusRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + int listenerPort_; + std::string loadBalancerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEHEALTHSTATUSREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeHealthStatusResult.h b/slb/include/alibabacloud/slb/model/DescribeHealthStatusResult.h new file mode 100644 index 000000000..73954a0eb --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeHealthStatusResult.h @@ -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_SLB_MODEL_DESCRIBEHEALTHSTATUSRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBEHEALTHSTATUSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeHealthStatusResult : public ServiceResult + { + public: + struct BackendServer + { + int listenerPort; + std::string serverId; + int port; + std::string serverHealthStatus; + }; + + + DescribeHealthStatusResult(); + explicit DescribeHealthStatusResult(const std::string &payload); + ~DescribeHealthStatusResult(); + std::vector getBackendServers()const; + void setBackendServers(const std::vector& backendServers); + + protected: + void parse(const std::string &payload); + private: + std::vector backendServers_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEHEALTHSTATUSRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeListenerAccessControlAttributeRequest.h b/slb/include/alibabacloud/slb/model/DescribeListenerAccessControlAttributeRequest.h new file mode 100644 index 000000000..23fd6e533 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeListenerAccessControlAttributeRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_DESCRIBELISTENERACCESSCONTROLATTRIBUTEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBELISTENERACCESSCONTROLATTRIBUTEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeListenerAccessControlAttributeRequest : public SlbRequest + { + + public: + DescribeListenerAccessControlAttributeRequest(); + ~DescribeListenerAccessControlAttributeRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + int listenerPort_; + std::string loadBalancerId_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELISTENERACCESSCONTROLATTRIBUTEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeListenerAccessControlAttributeResult.h b/slb/include/alibabacloud/slb/model/DescribeListenerAccessControlAttributeResult.h new file mode 100644 index 000000000..047964c06 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeListenerAccessControlAttributeResult.h @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBELISTENERACCESSCONTROLATTRIBUTERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBELISTENERACCESSCONTROLATTRIBUTERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeListenerAccessControlAttributeResult : public ServiceResult + { + public: + + + DescribeListenerAccessControlAttributeResult(); + explicit DescribeListenerAccessControlAttributeResult(const std::string &payload); + ~DescribeListenerAccessControlAttributeResult(); + std::string getAccessControlStatus()const; + void setAccessControlStatus(const std::string& accessControlStatus); + std::string getSourceItems()const; + void setSourceItems(const std::string& sourceItems); + + protected: + void parse(const std::string &payload); + private: + std::string accessControlStatus_; + std::string sourceItems_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELISTENERACCESSCONTROLATTRIBUTERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeLoadBalancerAttributeRequest.h b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerAttributeRequest.h new file mode 100644 index 000000000..a5f6c56d4 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerAttributeRequest.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERATTRIBUTEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERATTRIBUTEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerAttributeRequest : public SlbRequest + { + + public: + DescribeLoadBalancerAttributeRequest(); + ~DescribeLoadBalancerAttributeRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string loadBalancerId_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERATTRIBUTEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeLoadBalancerAttributeResult.h b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerAttributeResult.h new file mode 100644 index 000000000..a691535a0 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerAttributeResult.h @@ -0,0 +1,142 @@ +/* + * 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_SLB_MODEL_DESCRIBELOADBALANCERATTRIBUTERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERATTRIBUTERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerAttributeResult : public ServiceResult + { + public: + struct ListenerPortAndProtocal + { + int listenerPort; + std::string listenerProtocal; + }; + struct ListenerPortAndProtocol + { + int listenerPort; + std::string listenerProtocol; + }; + struct BackendServer + { + std::string serverId; + int weight; + }; + + + DescribeLoadBalancerAttributeResult(); + explicit DescribeLoadBalancerAttributeResult(const std::string &payload); + ~DescribeLoadBalancerAttributeResult(); + std::vector getListenerPortsAndProtocal()const; + void setListenerPortsAndProtocal(const std::vector& listenerPortsAndProtocal); + std::string getResourceGroupId()const; + void setResourceGroupId(const std::string& resourceGroupId); + std::string getAddress()const; + void setAddress(const std::string& address); + std::string getEndTime()const; + void setEndTime(const std::string& endTime); + std::vector getListenerPortsAndProtocol()const; + void setListenerPortsAndProtocol(const std::vector& listenerPortsAndProtocol); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::vector getBackendServers()const; + void setBackendServers(const std::vector& backendServers); + std::string getLoadBalancerSpec()const; + void setLoadBalancerSpec(const std::string& loadBalancerSpec); + std::string getNetworkType()const; + void setNetworkType(const std::string& networkType); + int getBandwidth()const; + void setBandwidth(int bandwidth); + std::vector getListenerPorts()const; + void setListenerPorts(const std::vector& listenerPorts); + std::string getMasterZoneId()const; + void setMasterZoneId(const std::string& masterZoneId); + std::string getVSwitchId()const; + void setVSwitchId(const std::string& vSwitchId); + std::string getCreateTime()const; + void setCreateTime(const std::string& createTime); + std::string getPayType()const; + void setPayType(const std::string& payType); + std::string getSlaveZoneId()const; + void setSlaveZoneId(const std::string& slaveZoneId); + std::string getInternetChargeType()const; + void setInternetChargeType(const std::string& internetChargeType); + std::string getRegionIdAlias()const; + void setRegionIdAlias(const std::string& regionIdAlias); + std::string getLoadBalancerName()const; + void setLoadBalancerName(const std::string& loadBalancerName); + std::string getVpcId()const; + void setVpcId(const std::string& vpcId); + long getEndTimeStamp()const; + void setEndTimeStamp(long endTimeStamp); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getAddressType()const; + void setAddressType(const std::string& addressType); + std::string getLoadBalancerStatus()const; + void setLoadBalancerStatus(const std::string& loadBalancerStatus); + long getCreateTimeStamp()const; + void setCreateTimeStamp(long createTimeStamp); + long getAutoReleaseTime()const; + void setAutoReleaseTime(long autoReleaseTime); + + protected: + void parse(const std::string &payload); + private: + std::vector listenerPortsAndProtocal_; + std::string resourceGroupId_; + std::string address_; + std::string endTime_; + std::vector listenerPortsAndProtocol_; + std::string loadBalancerId_; + std::vector backendServers_; + std::string loadBalancerSpec_; + std::string networkType_; + int bandwidth_; + std::vector listenerPorts_; + std::string masterZoneId_; + std::string vSwitchId_; + std::string createTime_; + std::string payType_; + std::string slaveZoneId_; + std::string internetChargeType_; + std::string regionIdAlias_; + std::string loadBalancerName_; + std::string vpcId_; + long endTimeStamp_; + std::string regionId_; + std::string addressType_; + std::string loadBalancerStatus_; + long createTimeStamp_; + long autoReleaseTime_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERATTRIBUTERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeLoadBalancerAutoReleaseTimeRequest.h b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerAutoReleaseTimeRequest.h new file mode 100644 index 000000000..0854cc24c --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerAutoReleaseTimeRequest.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERAUTORELEASETIMEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERAUTORELEASETIMEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerAutoReleaseTimeRequest : public SlbRequest + { + + public: + DescribeLoadBalancerAutoReleaseTimeRequest(); + ~DescribeLoadBalancerAutoReleaseTimeRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string loadBalancerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERAUTORELEASETIMEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeLoadBalancerAutoReleaseTimeResult.h b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerAutoReleaseTimeResult.h new file mode 100644 index 000000000..f4be7449c --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerAutoReleaseTimeResult.h @@ -0,0 +1,52 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERAUTORELEASETIMERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERAUTORELEASETIMERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerAutoReleaseTimeResult : public ServiceResult + { + public: + + + DescribeLoadBalancerAutoReleaseTimeResult(); + explicit DescribeLoadBalancerAutoReleaseTimeResult(const std::string &payload); + ~DescribeLoadBalancerAutoReleaseTimeResult(); + long getAutoReleaseTime()const; + void setAutoReleaseTime(long autoReleaseTime); + + protected: + void parse(const std::string &payload); + private: + long autoReleaseTime_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERAUTORELEASETIMERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeLoadBalancerHTTPListenerAttributeRequest.h b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerHTTPListenerAttributeRequest.h new file mode 100644 index 000000000..886f71892 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerHTTPListenerAttributeRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_DESCRIBELOADBALANCERHTTPLISTENERATTRIBUTEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPLISTENERATTRIBUTEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerHTTPListenerAttributeRequest : public SlbRequest + { + + public: + DescribeLoadBalancerHTTPListenerAttributeRequest(); + ~DescribeLoadBalancerHTTPListenerAttributeRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + int listenerPort_; + std::string loadBalancerId_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPLISTENERATTRIBUTEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeLoadBalancerHTTPListenerAttributeResult.h b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerHTTPListenerAttributeResult.h new file mode 100644 index 000000000..cd8df79a6 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerHTTPListenerAttributeResult.h @@ -0,0 +1,127 @@ +/* + * 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_SLB_MODEL_DESCRIBELOADBALANCERHTTPLISTENERATTRIBUTERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPLISTENERATTRIBUTERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerHTTPListenerAttributeResult : public ServiceResult + { + public: + + + DescribeLoadBalancerHTTPListenerAttributeResult(); + explicit DescribeLoadBalancerHTTPListenerAttributeResult(const std::string &payload); + ~DescribeLoadBalancerHTTPListenerAttributeResult(); + int getCookieTimeout()const; + void setCookieTimeout(int cookieTimeout); + int getMaxConnection()const; + void setMaxConnection(int maxConnection); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + int getUnhealthyThreshold()const; + void setUnhealthyThreshold(int unhealthyThreshold); + std::string getScheduler()const; + void setScheduler(const std::string& scheduler); + std::string getHealthCheckURI()const; + void setHealthCheckURI(const std::string& healthCheckURI); + std::string getHealthCheck()const; + void setHealthCheck(const std::string& healthCheck); + int getBackendServerPort()const; + void setBackendServerPort(int backendServerPort); + std::string getXForwardedFor_SLBID()const; + void setXForwardedFor_SLBID(const std::string& xForwardedFor_SLBID); + int getHealthCheckConnectPort()const; + void setHealthCheckConnectPort(int healthCheckConnectPort); + int getBandwidth()const; + void setBandwidth(int bandwidth); + std::string getSecurityStatus()const; + void setSecurityStatus(const std::string& securityStatus); + std::string getGzip()const; + void setGzip(const std::string& gzip); + std::string getStickySessionType()const; + void setStickySessionType(const std::string& stickySessionType); + std::string getXForwardedFor_SLBIP()const; + void setXForwardedFor_SLBIP(const std::string& xForwardedFor_SLBIP); + std::string getHealthCheckHttpCode()const; + void setHealthCheckHttpCode(const std::string& healthCheckHttpCode); + std::string getStatus()const; + void setStatus(const std::string& status); + std::string getCookie()const; + void setCookie(const std::string& cookie); + int getListenerPort()const; + void setListenerPort(int listenerPort); + int getHealthCheckInterval()const; + void setHealthCheckInterval(int healthCheckInterval); + int getHealthCheckTimeout()const; + void setHealthCheckTimeout(int healthCheckTimeout); + std::string getStickySession()const; + void setStickySession(const std::string& stickySession); + int getHealthyThreshold()const; + void setHealthyThreshold(int healthyThreshold); + std::string getXForwardedFor()const; + void setXForwardedFor(const std::string& xForwardedFor); + std::string getHealthCheckDomain()const; + void setHealthCheckDomain(const std::string& healthCheckDomain); + std::string getXForwardedFor_proto()const; + void setXForwardedFor_proto(const std::string& xForwardedFor_proto); + + protected: + void parse(const std::string &payload); + private: + int cookieTimeout_; + int maxConnection_; + std::string vServerGroupId_; + int unhealthyThreshold_; + std::string scheduler_; + std::string healthCheckURI_; + std::string healthCheck_; + int backendServerPort_; + std::string xForwardedFor_SLBID_; + int healthCheckConnectPort_; + int bandwidth_; + std::string securityStatus_; + std::string gzip_; + std::string stickySessionType_; + std::string xForwardedFor_SLBIP_; + std::string healthCheckHttpCode_; + std::string status_; + std::string cookie_; + int listenerPort_; + int healthCheckInterval_; + int healthCheckTimeout_; + std::string stickySession_; + int healthyThreshold_; + std::string xForwardedFor_; + std::string healthCheckDomain_; + std::string xForwardedFor_proto_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPLISTENERATTRIBUTERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeLoadBalancerHTTPSListenerAttributeRequest.h b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerHTTPSListenerAttributeRequest.h new file mode 100644 index 000000000..ab5884888 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerHTTPSListenerAttributeRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_DESCRIBELOADBALANCERHTTPSLISTENERATTRIBUTEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPSLISTENERATTRIBUTEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerHTTPSListenerAttributeRequest : public SlbRequest + { + + public: + DescribeLoadBalancerHTTPSListenerAttributeRequest(); + ~DescribeLoadBalancerHTTPSListenerAttributeRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + int listenerPort_; + std::string loadBalancerId_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPSLISTENERATTRIBUTEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeLoadBalancerHTTPSListenerAttributeResult.h b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerHTTPSListenerAttributeResult.h new file mode 100644 index 000000000..fd7fdc0e7 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerHTTPSListenerAttributeResult.h @@ -0,0 +1,133 @@ +/* + * 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_SLB_MODEL_DESCRIBELOADBALANCERHTTPSLISTENERATTRIBUTERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPSLISTENERATTRIBUTERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerHTTPSListenerAttributeResult : public ServiceResult + { + public: + + + DescribeLoadBalancerHTTPSListenerAttributeResult(); + explicit DescribeLoadBalancerHTTPSListenerAttributeResult(const std::string &payload); + ~DescribeLoadBalancerHTTPSListenerAttributeResult(); + int getCookieTimeout()const; + void setCookieTimeout(int cookieTimeout); + int getMaxConnection()const; + void setMaxConnection(int maxConnection); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + int getUnhealthyThreshold()const; + void setUnhealthyThreshold(int unhealthyThreshold); + std::string getScheduler()const; + void setScheduler(const std::string& scheduler); + std::string getHealthCheckURI()const; + void setHealthCheckURI(const std::string& healthCheckURI); + std::string getHealthCheck()const; + void setHealthCheck(const std::string& healthCheck); + int getBackendServerPort()const; + void setBackendServerPort(int backendServerPort); + std::string getXForwardedFor_SLBID()const; + void setXForwardedFor_SLBID(const std::string& xForwardedFor_SLBID); + int getHealthCheckConnectPort()const; + void setHealthCheckConnectPort(int healthCheckConnectPort); + int getBandwidth()const; + void setBandwidth(int bandwidth); + std::string getSecurityStatus()const; + void setSecurityStatus(const std::string& securityStatus); + std::string getGzip()const; + void setGzip(const std::string& gzip); + std::string getServerCertificateId()const; + void setServerCertificateId(const std::string& serverCertificateId); + std::string getStickySessionType()const; + void setStickySessionType(const std::string& stickySessionType); + std::string getXForwardedFor_SLBIP()const; + void setXForwardedFor_SLBIP(const std::string& xForwardedFor_SLBIP); + std::string getHealthCheckHttpCode()const; + void setHealthCheckHttpCode(const std::string& healthCheckHttpCode); + std::string getStatus()const; + void setStatus(const std::string& status); + std::string getCookie()const; + void setCookie(const std::string& cookie); + int getListenerPort()const; + void setListenerPort(int listenerPort); + int getHealthCheckInterval()const; + void setHealthCheckInterval(int healthCheckInterval); + std::string getCACertificateId()const; + void setCACertificateId(const std::string& cACertificateId); + int getHealthCheckTimeout()const; + void setHealthCheckTimeout(int healthCheckTimeout); + std::string getStickySession()const; + void setStickySession(const std::string& stickySession); + int getHealthyThreshold()const; + void setHealthyThreshold(int healthyThreshold); + std::string getXForwardedFor()const; + void setXForwardedFor(const std::string& xForwardedFor); + std::string getHealthCheckDomain()const; + void setHealthCheckDomain(const std::string& healthCheckDomain); + std::string getXForwardedFor_proto()const; + void setXForwardedFor_proto(const std::string& xForwardedFor_proto); + + protected: + void parse(const std::string &payload); + private: + int cookieTimeout_; + int maxConnection_; + std::string vServerGroupId_; + int unhealthyThreshold_; + std::string scheduler_; + std::string healthCheckURI_; + std::string healthCheck_; + int backendServerPort_; + std::string xForwardedFor_SLBID_; + int healthCheckConnectPort_; + int bandwidth_; + std::string securityStatus_; + std::string gzip_; + std::string serverCertificateId_; + std::string stickySessionType_; + std::string xForwardedFor_SLBIP_; + std::string healthCheckHttpCode_; + std::string status_; + std::string cookie_; + int listenerPort_; + int healthCheckInterval_; + std::string cACertificateId_; + int healthCheckTimeout_; + std::string stickySession_; + int healthyThreshold_; + std::string xForwardedFor_; + std::string healthCheckDomain_; + std::string xForwardedFor_proto_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPSLISTENERATTRIBUTERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeLoadBalancerTCPListenerAttributeRequest.h b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerTCPListenerAttributeRequest.h new file mode 100644 index 000000000..e3fc184bf --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerTCPListenerAttributeRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_DESCRIBELOADBALANCERTCPLISTENERATTRIBUTEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERTCPLISTENERATTRIBUTEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerTCPListenerAttributeRequest : public SlbRequest + { + + public: + DescribeLoadBalancerTCPListenerAttributeRequest(); + ~DescribeLoadBalancerTCPListenerAttributeRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + int listenerPort_; + std::string loadBalancerId_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERTCPLISTENERATTRIBUTEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeLoadBalancerTCPListenerAttributeResult.h b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerTCPListenerAttributeResult.h new file mode 100644 index 000000000..29b0a5ab9 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerTCPListenerAttributeResult.h @@ -0,0 +1,112 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERTCPLISTENERATTRIBUTERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERTCPLISTENERATTRIBUTERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerTCPListenerAttributeResult : public ServiceResult + { + public: + + + DescribeLoadBalancerTCPListenerAttributeResult(); + explicit DescribeLoadBalancerTCPListenerAttributeResult(const std::string &payload); + ~DescribeLoadBalancerTCPListenerAttributeResult(); + std::string getStatus()const; + void setStatus(const std::string& status); + int getMaxConnection()const; + void setMaxConnection(int maxConnection); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + std::string getSynProxy()const; + void setSynProxy(const std::string& synProxy); + int getHealthCheckInterval()const; + void setHealthCheckInterval(int healthCheckInterval); + int getUnhealthyThreshold()const; + void setUnhealthyThreshold(int unhealthyThreshold); + std::string getScheduler()const; + void setScheduler(const std::string& scheduler); + std::string getHealthCheckURI()const; + void setHealthCheckURI(const std::string& healthCheckURI); + std::string getHealthCheck()const; + void setHealthCheck(const std::string& healthCheck); + int getHealthCheckConnectTimeout()const; + void setHealthCheckConnectTimeout(int healthCheckConnectTimeout); + int getBackendServerPort()const; + void setBackendServerPort(int backendServerPort); + int getPersistenceTimeout()const; + void setPersistenceTimeout(int persistenceTimeout); + int getHealthCheckConnectPort()const; + void setHealthCheckConnectPort(int healthCheckConnectPort); + int getBandwidth()const; + void setBandwidth(int bandwidth); + int getHealthyThreshold()const; + void setHealthyThreshold(int healthyThreshold); + std::string getHealthCheckDomain()const; + void setHealthCheckDomain(const std::string& healthCheckDomain); + std::string getMasterSlaveServerGroupId()const; + void setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId); + std::string getHealthCheckHttpCode()const; + void setHealthCheckHttpCode(const std::string& healthCheckHttpCode); + std::string getHealthCheckType()const; + void setHealthCheckType(const std::string& healthCheckType); + int getEstablishedTimeout()const; + void setEstablishedTimeout(int establishedTimeout); + + protected: + void parse(const std::string &payload); + private: + std::string status_; + int maxConnection_; + int listenerPort_; + std::string vServerGroupId_; + std::string synProxy_; + int healthCheckInterval_; + int unhealthyThreshold_; + std::string scheduler_; + std::string healthCheckURI_; + std::string healthCheck_; + int healthCheckConnectTimeout_; + int backendServerPort_; + int persistenceTimeout_; + int healthCheckConnectPort_; + int bandwidth_; + int healthyThreshold_; + std::string healthCheckDomain_; + std::string masterSlaveServerGroupId_; + std::string healthCheckHttpCode_; + std::string healthCheckType_; + int establishedTimeout_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERTCPLISTENERATTRIBUTERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeLoadBalancerUDPListenerAttributeRequest.h b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerUDPListenerAttributeRequest.h new file mode 100644 index 000000000..a9e7245a5 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerUDPListenerAttributeRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_DESCRIBELOADBALANCERUDPLISTENERATTRIBUTEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERUDPLISTENERATTRIBUTEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerUDPListenerAttributeRequest : public SlbRequest + { + + public: + DescribeLoadBalancerUDPListenerAttributeRequest(); + ~DescribeLoadBalancerUDPListenerAttributeRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + int listenerPort_; + std::string loadBalancerId_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERUDPLISTENERATTRIBUTEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeLoadBalancerUDPListenerAttributeResult.h b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerUDPListenerAttributeResult.h new file mode 100644 index 000000000..ddc3695f4 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeLoadBalancerUDPListenerAttributeResult.h @@ -0,0 +1,100 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERUDPLISTENERATTRIBUTERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERUDPLISTENERATTRIBUTERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerUDPListenerAttributeResult : public ServiceResult + { + public: + + + DescribeLoadBalancerUDPListenerAttributeResult(); + explicit DescribeLoadBalancerUDPListenerAttributeResult(const std::string &payload); + ~DescribeLoadBalancerUDPListenerAttributeResult(); + std::string getStatus()const; + void setStatus(const std::string& status); + int getMaxConnection()const; + void setMaxConnection(int maxConnection); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + int getHealthCheckInterval()const; + void setHealthCheckInterval(int healthCheckInterval); + int getUnhealthyThreshold()const; + void setUnhealthyThreshold(int unhealthyThreshold); + std::string getScheduler()const; + void setScheduler(const std::string& scheduler); + std::string getHealthCheck()const; + void setHealthCheck(const std::string& healthCheck); + int getHealthCheckConnectTimeout()const; + void setHealthCheckConnectTimeout(int healthCheckConnectTimeout); + int getBackendServerPort()const; + void setBackendServerPort(int backendServerPort); + int getPersistenceTimeout()const; + void setPersistenceTimeout(int persistenceTimeout); + int getHealthCheckConnectPort()const; + void setHealthCheckConnectPort(int healthCheckConnectPort); + std::string getHealthCheckReq()const; + void setHealthCheckReq(const std::string& healthCheckReq); + int getBandwidth()const; + void setBandwidth(int bandwidth); + int getHealthyThreshold()const; + void setHealthyThreshold(int healthyThreshold); + std::string getHealthCheckExp()const; + void setHealthCheckExp(const std::string& healthCheckExp); + std::string getMasterSlaveServerGroupId()const; + void setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId); + + protected: + void parse(const std::string &payload); + private: + std::string status_; + int maxConnection_; + int listenerPort_; + std::string vServerGroupId_; + int healthCheckInterval_; + int unhealthyThreshold_; + std::string scheduler_; + std::string healthCheck_; + int healthCheckConnectTimeout_; + int backendServerPort_; + int persistenceTimeout_; + int healthCheckConnectPort_; + std::string healthCheckReq_; + int bandwidth_; + int healthyThreshold_; + std::string healthCheckExp_; + std::string masterSlaveServerGroupId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERUDPLISTENERATTRIBUTERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeLoadBalancersRelatedEcsRequest.h b/slb/include/alibabacloud/slb/model/DescribeLoadBalancersRelatedEcsRequest.h new file mode 100644 index 000000000..f66fde892 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeLoadBalancersRelatedEcsRequest.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSRELATEDECSREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSRELATEDECSREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancersRelatedEcsRequest : public SlbRequest + { + + public: + DescribeLoadBalancersRelatedEcsRequest(); + ~DescribeLoadBalancersRelatedEcsRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string loadBalancerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSRELATEDECSREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeLoadBalancersRelatedEcsResult.h b/slb/include/alibabacloud/slb/model/DescribeLoadBalancersRelatedEcsResult.h new file mode 100644 index 000000000..41606ad50 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeLoadBalancersRelatedEcsResult.h @@ -0,0 +1,99 @@ +/* + * 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_SLB_MODEL_DESCRIBELOADBALANCERSRELATEDECSRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSRELATEDECSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancersRelatedEcsResult : public ServiceResult + { + public: + struct LoadBalancer + { + struct MasterSlaveVServerGroup + { + struct BackendServer + { + std::string networkType; + std::string vmName; + int port; + int weight; + }; + std::string groupName; + std::vector backendServers1; + std::string groupId; + }; + struct VServerGroup + { + struct BackendServer + { + std::string networkType; + std::string vmName; + int port; + int weight; + }; + std::string groupName; + std::vector backendServers2; + std::string groupId; + }; + struct BackendServer + { + std::string networkType; + std::string vmName; + int port; + int weight; + }; + std::string loadBalancerId; + std::vector masterSlaveVServerGroups; + std::vector vServerGroups; + int count; + std::vector backendServers; + }; + + + DescribeLoadBalancersRelatedEcsResult(); + explicit DescribeLoadBalancersRelatedEcsResult(const std::string &payload); + ~DescribeLoadBalancersRelatedEcsResult(); + std::string getMessage()const; + void setMessage(const std::string& message); + std::vector getLoadBalancers()const; + void setLoadBalancers(const std::vector& loadBalancers); + bool getSuccess()const; + void setSuccess(bool success); + + protected: + void parse(const std::string &payload); + private: + std::string message_; + std::vector loadBalancers_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSRELATEDECSRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeLoadBalancersRequest.h b/slb/include/alibabacloud/slb/model/DescribeLoadBalancersRequest.h new file mode 100644 index 000000000..11e35c016 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeLoadBalancersRequest.h @@ -0,0 +1,116 @@ +/* + * 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_SLB_MODEL_DESCRIBELOADBALANCERSREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancersRequest : public SlbRequest + { + + public: + DescribeLoadBalancersRequest(); + ~DescribeLoadBalancersRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getNetworkType()const; + void setNetworkType(const std::string& networkType); + std::string getMasterZoneId()const; + void setMasterZoneId(const std::string& masterZoneId); + int getPageNumber()const; + void setPageNumber(int pageNumber); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getResourceGroupId()const; + void setResourceGroupId(const std::string& resourceGroupId); + std::string getLoadBalancerName()const; + void setLoadBalancerName(const std::string& loadBalancerName); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + int getPageSize()const; + void setPageSize(int pageSize); + std::string getAddressType()const; + void setAddressType(const std::string& addressType); + std::string getSlaveZoneId()const; + void setSlaveZoneId(const std::string& slaveZoneId); + std::string getAddress()const; + void setAddress(const std::string& address); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getServerId()const; + void setServerId(const std::string& serverId); + std::string getTags()const; + void setTags(const std::string& tags); + std::string getServerIntranetAddress()const; + void setServerIntranetAddress(const std::string& serverIntranetAddress); + std::string getVSwitchId()const; + void setVSwitchId(const std::string& vSwitchId); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getInternetChargeType()const; + void setInternetChargeType(const std::string& internetChargeType); + std::string getVpcId()const; + void setVpcId(const std::string& vpcId); + std::string getPayType()const; + void setPayType(const std::string& payType); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string networkType_; + std::string masterZoneId_; + int pageNumber_; + std::string accessKeyId_; + std::string resourceGroupId_; + std::string loadBalancerName_; + std::string regionId_; + int pageSize_; + std::string addressType_; + std::string slaveZoneId_; + std::string address_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string serverId_; + std::string tags_; + std::string serverIntranetAddress_; + std::string vSwitchId_; + std::string loadBalancerId_; + std::string internetChargeType_; + std::string vpcId_; + std::string payType_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeLoadBalancersResult.h b/slb/include/alibabacloud/slb/model/DescribeLoadBalancersResult.h new file mode 100644 index 000000000..aae7925ff --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeLoadBalancersResult.h @@ -0,0 +1,81 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancersResult : public ServiceResult + { + public: + struct LoadBalancer + { + std::string address; + std::string resourceGroupId; + std::string vSwitchId; + std::string createTime; + std::string loadBalancerId; + std::string payType; + std::string slaveZoneId; + std::string internetChargeType; + std::string regionIdAlias; + std::string loadBalancerName; + std::string vpcId; + std::string networkType; + std::string regionId; + std::string addressType; + std::string loadBalancerStatus; + std::string masterZoneId; + long createTimeStamp; + }; + + + DescribeLoadBalancersResult(); + explicit DescribeLoadBalancersResult(const std::string &payload); + ~DescribeLoadBalancersResult(); + int getTotalCount()const; + void setTotalCount(int totalCount); + int getPageSize()const; + void setPageSize(int pageSize); + int getPageNumber()const; + void setPageNumber(int pageNumber); + std::vector getLoadBalancers()const; + void setLoadBalancers(const std::vector& loadBalancers); + + protected: + void parse(const std::string &payload); + private: + int totalCount_; + int pageSize_; + int pageNumber_; + std::vector loadBalancers_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupAttributeRequest.h b/slb/include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupAttributeRequest.h new file mode 100644 index 000000000..581c42f67 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupAttributeRequest.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPATTRIBUTEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPATTRIBUTEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveServerGroupAttributeRequest : public SlbRequest + { + + public: + DescribeMasterSlaveServerGroupAttributeRequest(); + ~DescribeMasterSlaveServerGroupAttributeRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getMasterSlaveServerGroupId()const; + void setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string masterSlaveServerGroupId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPATTRIBUTEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupAttributeResult.h b/slb/include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupAttributeResult.h new file mode 100644 index 000000000..f866d741c --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupAttributeResult.h @@ -0,0 +1,65 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPATTRIBUTERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPATTRIBUTERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveServerGroupAttributeResult : public ServiceResult + { + public: + struct MasterSlaveBackendServer + { + std::string serverType; + std::string serverId; + int port; + int weight; + }; + + + DescribeMasterSlaveServerGroupAttributeResult(); + explicit DescribeMasterSlaveServerGroupAttributeResult(const std::string &payload); + ~DescribeMasterSlaveServerGroupAttributeResult(); + std::string getMasterSlaveServerGroupId()const; + void setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId); + std::string getMasterSlaveServerGroupName()const; + void setMasterSlaveServerGroupName(const std::string& masterSlaveServerGroupName); + std::vector getMasterSlaveBackendServers()const; + void setMasterSlaveBackendServers(const std::vector& masterSlaveBackendServers); + + protected: + void parse(const std::string &payload); + private: + std::string masterSlaveServerGroupId_; + std::string masterSlaveServerGroupName_; + std::vector masterSlaveBackendServers_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPATTRIBUTERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupsRequest.h b/slb/include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupsRequest.h new file mode 100644 index 000000000..49c55bfe9 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupsRequest.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPSREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPSREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveServerGroupsRequest : public SlbRequest + { + + public: + DescribeMasterSlaveServerGroupsRequest(); + ~DescribeMasterSlaveServerGroupsRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string loadBalancerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPSREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupsResult.h b/slb/include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupsResult.h new file mode 100644 index 000000000..d6aa03b91 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupsResult.h @@ -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_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPSRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveServerGroupsResult : public ServiceResult + { + public: + struct MasterSlaveServerGroup + { + std::string masterSlaveServerGroupId; + std::string masterSlaveServerGroupName; + }; + + + DescribeMasterSlaveServerGroupsResult(); + explicit DescribeMasterSlaveServerGroupsResult(const std::string &payload); + ~DescribeMasterSlaveServerGroupsResult(); + std::vector getMasterSlaveServerGroups()const; + void setMasterSlaveServerGroups(const std::vector& masterSlaveServerGroups); + + protected: + void parse(const std::string &payload); + private: + std::vector masterSlaveServerGroups_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPSRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupAttributeRequest.h b/slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupAttributeRequest.h new file mode 100644 index 000000000..4aa9e4314 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupAttributeRequest.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveVServerGroupAttributeRequest : public SlbRequest + { + + public: + DescribeMasterSlaveVServerGroupAttributeRequest(); + ~DescribeMasterSlaveVServerGroupAttributeRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getMasterSlaveVServerGroupId()const; + void setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string masterSlaveVServerGroupId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupAttributeResult.h b/slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupAttributeResult.h new file mode 100644 index 000000000..fba842f39 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupAttributeResult.h @@ -0,0 +1,65 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveVServerGroupAttributeResult : public ServiceResult + { + public: + struct MasterSlaveBackendServer + { + std::string serverId; + int port; + int isBackup; + int weight; + }; + + + DescribeMasterSlaveVServerGroupAttributeResult(); + explicit DescribeMasterSlaveVServerGroupAttributeResult(const std::string &payload); + ~DescribeMasterSlaveVServerGroupAttributeResult(); + std::string getMasterSlaveVServerGroupId()const; + void setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId); + std::vector getMasterSlaveBackendServers()const; + void setMasterSlaveBackendServers(const std::vector& masterSlaveBackendServers); + std::string getMasterSlaveVServerGroupName()const; + void setMasterSlaveVServerGroupName(const std::string& masterSlaveVServerGroupName); + + protected: + void parse(const std::string &payload); + private: + std::string masterSlaveVServerGroupId_; + std::vector masterSlaveBackendServers_; + std::string masterSlaveVServerGroupName_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsRequest.h b/slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsRequest.h new file mode 100644 index 000000000..b93967a63 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsRequest.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveVServerGroupsRequest : public SlbRequest + { + + public: + DescribeMasterSlaveVServerGroupsRequest(); + ~DescribeMasterSlaveVServerGroupsRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string loadBalancerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsResult.h b/slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsResult.h new file mode 100644 index 000000000..945aa44bf --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsResult.h @@ -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_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveVServerGroupsResult : public ServiceResult + { + public: + struct MasterSlaveVServerGroup + { + std::string masterSlaveVServerGroupId; + std::string masterSlaveVServerGroupName; + }; + + + DescribeMasterSlaveVServerGroupsResult(); + explicit DescribeMasterSlaveVServerGroupsResult(const std::string &payload); + ~DescribeMasterSlaveVServerGroupsResult(); + std::vector getMasterSlaveVServerGroups()const; + void setMasterSlaveVServerGroups(const std::vector& masterSlaveVServerGroups); + + protected: + void parse(const std::string &payload); + private: + std::vector masterSlaveVServerGroups_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeRegionsRequest.h b/slb/include/alibabacloud/slb/model/DescribeRegionsRequest.h new file mode 100644 index 000000000..889d97cb6 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeRegionsRequest.h @@ -0,0 +1,68 @@ +/* + * 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_SLB_MODEL_DESCRIBEREGIONSREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBEREGIONSREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeRegionsRequest : public SlbRequest + { + + public: + DescribeRegionsRequest(); + ~DescribeRegionsRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEREGIONSREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeRegionsResult.h b/slb/include/alibabacloud/slb/model/DescribeRegionsResult.h new file mode 100644 index 000000000..f5b57bc78 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeRegionsResult.h @@ -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_SLB_MODEL_DESCRIBEREGIONSRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBEREGIONSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeRegionsResult : public ServiceResult + { + public: + struct Region + { + std::string regionId; + std::string localName; + }; + + + DescribeRegionsResult(); + explicit DescribeRegionsResult(const std::string &payload); + ~DescribeRegionsResult(); + std::vector getRegions()const; + void setRegions(const std::vector& regions); + + protected: + void parse(const std::string &payload); + private: + std::vector regions_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEREGIONSRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeRuleAttributeRequest.h b/slb/include/alibabacloud/slb/model/DescribeRuleAttributeRequest.h new file mode 100644 index 000000000..5adbe24f3 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeRuleAttributeRequest.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBERULEATTRIBUTEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBERULEATTRIBUTEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeRuleAttributeRequest : public SlbRequest + { + + public: + DescribeRuleAttributeRequest(); + ~DescribeRuleAttributeRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getRuleId()const; + void setRuleId(const std::string& ruleId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string ruleId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBERULEATTRIBUTEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeRuleAttributeResult.h b/slb/include/alibabacloud/slb/model/DescribeRuleAttributeResult.h new file mode 100644 index 000000000..6b1f22e4e --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeRuleAttributeResult.h @@ -0,0 +1,67 @@ +/* + * 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_SLB_MODEL_DESCRIBERULEATTRIBUTERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBERULEATTRIBUTERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeRuleAttributeResult : public ServiceResult + { + public: + + + DescribeRuleAttributeResult(); + explicit DescribeRuleAttributeResult(const std::string &payload); + ~DescribeRuleAttributeResult(); + std::string getListenerPort()const; + void setListenerPort(const std::string& listenerPort); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getDomain()const; + void setDomain(const std::string& domain); + std::string getRuleName()const; + void setRuleName(const std::string& ruleName); + std::string getUrl()const; + void setUrl(const std::string& url); + + protected: + void parse(const std::string &payload); + private: + std::string listenerPort_; + std::string vServerGroupId_; + std::string loadBalancerId_; + std::string domain_; + std::string ruleName_; + std::string url_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBERULEATTRIBUTERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeRulesRequest.h b/slb/include/alibabacloud/slb/model/DescribeRulesRequest.h new file mode 100644 index 000000000..2b9a53fed --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeRulesRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_DESCRIBERULESREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBERULESREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeRulesRequest : public SlbRequest + { + + public: + DescribeRulesRequest(); + ~DescribeRulesRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + int listenerPort_; + std::string loadBalancerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBERULESREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeRulesResult.h b/slb/include/alibabacloud/slb/model/DescribeRulesResult.h new file mode 100644 index 000000000..d020b91b2 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeRulesResult.h @@ -0,0 +1,60 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBERULESRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBERULESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeRulesResult : public ServiceResult + { + public: + struct Rule + { + std::string vServerGroupId; + std::string ruleId; + std::string domain; + std::string ruleName; + std::string url; + }; + + + DescribeRulesResult(); + explicit DescribeRulesResult(const std::string &payload); + ~DescribeRulesResult(); + std::vector getRules()const; + void setRules(const std::vector& rules); + + protected: + void parse(const std::string &payload); + private: + std::vector rules_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBERULESRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeServerCertificatesRequest.h b/slb/include/alibabacloud/slb/model/DescribeServerCertificatesRequest.h new file mode 100644 index 000000000..f7b7b5a74 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeServerCertificatesRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_DESCRIBESERVERCERTIFICATESREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBESERVERCERTIFICATESREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeServerCertificatesRequest : public SlbRequest + { + + public: + DescribeServerCertificatesRequest(); + ~DescribeServerCertificatesRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + std::string getResourceGroupId()const; + void setResourceGroupId(const std::string& resourceGroupId); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getServerCertificateId()const; + void setServerCertificateId(const std::string& serverCertificateId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + std::string resourceGroupId_; + long resourceOwnerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string serverCertificateId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBESERVERCERTIFICATESREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeServerCertificatesResult.h b/slb/include/alibabacloud/slb/model/DescribeServerCertificatesResult.h new file mode 100644 index 000000000..bb1ea6a58 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeServerCertificatesResult.h @@ -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_SLB_MODEL_DESCRIBESERVERCERTIFICATESRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBESERVERCERTIFICATESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeServerCertificatesResult : public ServiceResult + { + public: + struct ServerCertificate + { + std::string regionIdAlias; + std::string fingerprint; + std::string aliCloudCertificateName; + std::string resourceGroupId; + int isAliCloudCertificate; + std::string createTime; + std::string serverCertificateId; + std::string serverCertificateName; + std::string regionId; + long createTimeStamp; + std::string aliCloudCertificateId; + }; + + + DescribeServerCertificatesResult(); + explicit DescribeServerCertificatesResult(const std::string &payload); + ~DescribeServerCertificatesResult(); + std::vector getServerCertificates()const; + void setServerCertificates(const std::vector& serverCertificates); + + protected: + void parse(const std::string &payload); + private: + std::vector serverCertificates_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBESERVERCERTIFICATESRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeTagsRequest.h b/slb/include/alibabacloud/slb/model/DescribeTagsRequest.h new file mode 100644 index 000000000..f1480ab94 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeTagsRequest.h @@ -0,0 +1,80 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBETAGSREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBETAGSREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeTagsRequest : public SlbRequest + { + + public: + DescribeTagsRequest(); + ~DescribeTagsRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + bool getDistinctKey()const; + void setDistinctKey(bool distinctKey); + long getOwnerId()const; + void setOwnerId(long ownerId); + int getPageNumber()const; + void setPageNumber(int pageNumber); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + int getPageSize()const; + void setPageSize(int pageSize); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + bool distinctKey_; + long ownerId_; + int pageNumber_; + std::string accessKeyId_; + std::string tags_; + std::string loadBalancerId_; + std::string regionId_; + int pageSize_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBETAGSREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeTagsResult.h b/slb/include/alibabacloud/slb/model/DescribeTagsResult.h new file mode 100644 index 000000000..37c0b695c --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeTagsResult.h @@ -0,0 +1,67 @@ +/* + * 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_SLB_MODEL_DESCRIBETAGSRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBETAGSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeTagsResult : public ServiceResult + { + public: + struct TagSet + { + int instanceCount; + std::string tagKey; + std::string tagValue; + }; + + + DescribeTagsResult(); + explicit DescribeTagsResult(const std::string &payload); + ~DescribeTagsResult(); + int getTotalCount()const; + void setTotalCount(int totalCount); + int getPageSize()const; + void setPageSize(int pageSize); + int getPageNumber()const; + void setPageNumber(int pageNumber); + std::vector getTagSets()const; + void setTagSets(const std::vector& tagSets); + + protected: + void parse(const std::string &payload); + private: + int totalCount_; + int pageSize_; + int pageNumber_; + std::vector tagSets_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBETAGSRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeVServerGroupAttributeRequest.h b/slb/include/alibabacloud/slb/model/DescribeVServerGroupAttributeRequest.h new file mode 100644 index 000000000..c4a4af85f --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeVServerGroupAttributeRequest.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPATTRIBUTEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPATTRIBUTEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeVServerGroupAttributeRequest : public SlbRequest + { + + public: + DescribeVServerGroupAttributeRequest(); + ~DescribeVServerGroupAttributeRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + std::string vServerGroupId_; + long resourceOwnerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPATTRIBUTEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeVServerGroupAttributeResult.h b/slb/include/alibabacloud/slb/model/DescribeVServerGroupAttributeResult.h new file mode 100644 index 000000000..354396e03 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeVServerGroupAttributeResult.h @@ -0,0 +1,64 @@ +/* + * 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_SLB_MODEL_DESCRIBEVSERVERGROUPATTRIBUTERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPATTRIBUTERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeVServerGroupAttributeResult : public ServiceResult + { + public: + struct BackendServer + { + std::string serverId; + int port; + int weight; + }; + + + DescribeVServerGroupAttributeResult(); + explicit DescribeVServerGroupAttributeResult(const std::string &payload); + ~DescribeVServerGroupAttributeResult(); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + std::string getVServerGroupName()const; + void setVServerGroupName(const std::string& vServerGroupName); + std::vector getBackendServers()const; + void setBackendServers(const std::vector& backendServers); + + protected: + void parse(const std::string &payload); + private: + std::string vServerGroupId_; + std::string vServerGroupName_; + std::vector backendServers_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPATTRIBUTERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeVServerGroupsRequest.h b/slb/include/alibabacloud/slb/model/DescribeVServerGroupsRequest.h new file mode 100644 index 000000000..7e6e578e6 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeVServerGroupsRequest.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPSREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPSREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeVServerGroupsRequest : public SlbRequest + { + + public: + DescribeVServerGroupsRequest(); + ~DescribeVServerGroupsRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string loadBalancerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPSREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeVServerGroupsResult.h b/slb/include/alibabacloud/slb/model/DescribeVServerGroupsResult.h new file mode 100644 index 000000000..5163e0c5d --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeVServerGroupsResult.h @@ -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_SLB_MODEL_DESCRIBEVSERVERGROUPSRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeVServerGroupsResult : public ServiceResult + { + public: + struct VServerGroup + { + std::string vServerGroupId; + std::string vServerGroupName; + }; + + + DescribeVServerGroupsResult(); + explicit DescribeVServerGroupsResult(const std::string &payload); + ~DescribeVServerGroupsResult(); + std::vector getVServerGroups()const; + void setVServerGroups(const std::vector& vServerGroups); + + protected: + void parse(const std::string &payload); + private: + std::vector vServerGroups_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPSRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeZonesRequest.h b/slb/include/alibabacloud/slb/model/DescribeZonesRequest.h new file mode 100644 index 000000000..ff431a308 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeZonesRequest.h @@ -0,0 +1,68 @@ +/* + * 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_SLB_MODEL_DESCRIBEZONESREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBEZONESREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeZonesRequest : public SlbRequest + { + + public: + DescribeZonesRequest(); + ~DescribeZonesRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEZONESREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/DescribeZonesResult.h b/slb/include/alibabacloud/slb/model/DescribeZonesResult.h new file mode 100644 index 000000000..b7c6f0041 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/DescribeZonesResult.h @@ -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_SLB_MODEL_DESCRIBEZONESRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_DESCRIBEZONESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT DescribeZonesResult : public ServiceResult + { + public: + struct Zone + { + struct SlaveZone + { + std::string zoneId; + std::string localName; + }; + std::vector slaveZones; + std::string zoneId; + std::string localName; + }; + + + DescribeZonesResult(); + explicit DescribeZonesResult(const std::string &payload); + ~DescribeZonesResult(); + std::vector getZones()const; + void setZones(const std::vector& zones); + + protected: + void parse(const std::string &payload); + private: + std::vector zones_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEZONESRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/ModifyLoadBalancerInstanceSpecRequest.h b/slb/include/alibabacloud/slb/model/ModifyLoadBalancerInstanceSpecRequest.h new file mode 100644 index 000000000..0d4dba1d8 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/ModifyLoadBalancerInstanceSpecRequest.h @@ -0,0 +1,77 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINSTANCESPECREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINSTANCESPECREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT ModifyLoadBalancerInstanceSpecRequest : public SlbRequest + { + + public: + ModifyLoadBalancerInstanceSpecRequest(); + ~ModifyLoadBalancerInstanceSpecRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + std::string getLoadBalancerSpec()const; + void setLoadBalancerSpec(const std::string& loadBalancerSpec); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + bool getAutoPay()const; + void setAutoPay(bool autoPay); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + std::string loadBalancerSpec_; + long resourceOwnerId_; + std::string loadBalancerId_; + bool autoPay_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINSTANCESPECREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/ModifyLoadBalancerInstanceSpecResult.h b/slb/include/alibabacloud/slb/model/ModifyLoadBalancerInstanceSpecResult.h new file mode 100644 index 000000000..36ffbe61f --- /dev/null +++ b/slb/include/alibabacloud/slb/model/ModifyLoadBalancerInstanceSpecResult.h @@ -0,0 +1,52 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINSTANCESPECRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINSTANCESPECRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT ModifyLoadBalancerInstanceSpecResult : public ServiceResult + { + public: + + + ModifyLoadBalancerInstanceSpecResult(); + explicit ModifyLoadBalancerInstanceSpecResult(const std::string &payload); + ~ModifyLoadBalancerInstanceSpecResult(); + long getOrderId()const; + void setOrderId(long orderId); + + protected: + void parse(const std::string &payload); + private: + long orderId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINSTANCESPECRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/ModifyLoadBalancerInternetSpecRequest.h b/slb/include/alibabacloud/slb/model/ModifyLoadBalancerInternetSpecRequest.h new file mode 100644 index 000000000..734119d4b --- /dev/null +++ b/slb/include/alibabacloud/slb/model/ModifyLoadBalancerInternetSpecRequest.h @@ -0,0 +1,80 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINTERNETSPECREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINTERNETSPECREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT ModifyLoadBalancerInternetSpecRequest : public SlbRequest + { + + public: + ModifyLoadBalancerInternetSpecRequest(); + ~ModifyLoadBalancerInternetSpecRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + bool getAutoPay()const; + void setAutoPay(bool autoPay); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + int getBandwidth()const; + void setBandwidth(int bandwidth); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getInternetChargeType()const; + void setInternetChargeType(const std::string& internetChargeType); + + private: + std::string access_key_id_; + long resourceOwnerId_; + bool autoPay_; + std::string resourceOwnerAccount_; + int bandwidth_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + std::string loadBalancerId_; + std::string regionId_; + std::string internetChargeType_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINTERNETSPECREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/ModifyLoadBalancerInternetSpecResult.h b/slb/include/alibabacloud/slb/model/ModifyLoadBalancerInternetSpecResult.h new file mode 100644 index 000000000..ad91933be --- /dev/null +++ b/slb/include/alibabacloud/slb/model/ModifyLoadBalancerInternetSpecResult.h @@ -0,0 +1,52 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINTERNETSPECRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINTERNETSPECRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT ModifyLoadBalancerInternetSpecResult : public ServiceResult + { + public: + + + ModifyLoadBalancerInternetSpecResult(); + explicit ModifyLoadBalancerInternetSpecResult(const std::string &payload); + ~ModifyLoadBalancerInternetSpecResult(); + long getOrderId()const; + void setOrderId(long orderId); + + protected: + void parse(const std::string &payload); + private: + long orderId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINTERNETSPECRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/ModifyLoadBalancerPayTypeRequest.h b/slb/include/alibabacloud/slb/model/ModifyLoadBalancerPayTypeRequest.h new file mode 100644 index 000000000..4d7f67ae4 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/ModifyLoadBalancerPayTypeRequest.h @@ -0,0 +1,83 @@ +/* + * 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_SLB_MODEL_MODIFYLOADBALANCERPAYTYPEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERPAYTYPEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT ModifyLoadBalancerPayTypeRequest : public SlbRequest + { + + public: + ModifyLoadBalancerPayTypeRequest(); + ~ModifyLoadBalancerPayTypeRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + bool getAutoPay()const; + void setAutoPay(bool autoPay); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + int getDuration()const; + void setDuration(int duration); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getPayType()const; + void setPayType(const std::string& payType); + std::string getPricingCycle()const; + void setPricingCycle(const std::string& pricingCycle); + + private: + std::string access_key_id_; + long resourceOwnerId_; + bool autoPay_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + int duration_; + std::string loadBalancerId_; + std::string regionId_; + std::string payType_; + std::string pricingCycle_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERPAYTYPEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/ModifyLoadBalancerPayTypeResult.h b/slb/include/alibabacloud/slb/model/ModifyLoadBalancerPayTypeResult.h new file mode 100644 index 000000000..e5366c7ba --- /dev/null +++ b/slb/include/alibabacloud/slb/model/ModifyLoadBalancerPayTypeResult.h @@ -0,0 +1,52 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERPAYTYPERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERPAYTYPERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT ModifyLoadBalancerPayTypeResult : public ServiceResult + { + public: + + + ModifyLoadBalancerPayTypeResult(); + explicit ModifyLoadBalancerPayTypeResult(const std::string &payload); + ~ModifyLoadBalancerPayTypeResult(); + long getOrderId()const; + void setOrderId(long orderId); + + protected: + void parse(const std::string &payload); + private: + long orderId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERPAYTYPERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/ModifyVServerGroupBackendServersRequest.h b/slb/include/alibabacloud/slb/model/ModifyVServerGroupBackendServersRequest.h new file mode 100644 index 000000000..0ce3c181f --- /dev/null +++ b/slb/include/alibabacloud/slb/model/ModifyVServerGroupBackendServersRequest.h @@ -0,0 +1,77 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_MODIFYVSERVERGROUPBACKENDSERVERSREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_MODIFYVSERVERGROUPBACKENDSERVERSREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT ModifyVServerGroupBackendServersRequest : public SlbRequest + { + + public: + ModifyVServerGroupBackendServersRequest(); + ~ModifyVServerGroupBackendServersRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getOldBackendServers()const; + void setOldBackendServers(const std::string& oldBackendServers); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getNewBackendServers()const; + void setNewBackendServers(const std::string& newBackendServers); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + std::string vServerGroupId_; + long resourceOwnerId_; + std::string oldBackendServers_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string newBackendServers_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_MODIFYVSERVERGROUPBACKENDSERVERSREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/ModifyVServerGroupBackendServersResult.h b/slb/include/alibabacloud/slb/model/ModifyVServerGroupBackendServersResult.h new file mode 100644 index 000000000..af2e52b50 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/ModifyVServerGroupBackendServersResult.h @@ -0,0 +1,61 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_MODIFYVSERVERGROUPBACKENDSERVERSRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_MODIFYVSERVERGROUPBACKENDSERVERSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT ModifyVServerGroupBackendServersResult : public ServiceResult + { + public: + struct BackendServer + { + std::string serverId; + int port; + int weight; + }; + + + ModifyVServerGroupBackendServersResult(); + explicit ModifyVServerGroupBackendServersResult(const std::string &payload); + ~ModifyVServerGroupBackendServersResult(); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + std::vector getBackendServers()const; + void setBackendServers(const std::vector& backendServers); + + protected: + void parse(const std::string &payload); + private: + std::string vServerGroupId_; + std::vector backendServers_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_MODIFYVSERVERGROUPBACKENDSERVERSRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/MoveResourceGroupRequest.h b/slb/include/alibabacloud/slb/model/MoveResourceGroupRequest.h new file mode 100644 index 000000000..d4ac22088 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/MoveResourceGroupRequest.h @@ -0,0 +1,80 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_MOVERESOURCEGROUPREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_MOVERESOURCEGROUPREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT MoveResourceGroupRequest : public SlbRequest + { + + public: + MoveResourceGroupRequest(); + ~MoveResourceGroupRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getResourceId()const; + void setResourceId(const std::string& resourceId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getResourceType()const; + void setResourceType(const std::string& resourceType); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + std::string getResourceGroupId()const; + void setResourceGroupId(const std::string& resourceGroupId); + std::string getNewResourceGroupId()const; + void setNewResourceGroupId(const std::string& newResourceGroupId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string resourceId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string resourceType_; + std::string accessKeyId_; + std::string tags_; + std::string resourceGroupId_; + std::string newResourceGroupId_; + std::string regionId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_MOVERESOURCEGROUPREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/MoveResourceGroupResult.h b/slb/include/alibabacloud/slb/model/MoveResourceGroupResult.h new file mode 100644 index 000000000..5fbd8e002 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/MoveResourceGroupResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_MOVERESOURCEGROUPRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_MOVERESOURCEGROUPRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT MoveResourceGroupResult : public ServiceResult + { + public: + + + MoveResourceGroupResult(); + explicit MoveResourceGroupResult(const std::string &payload); + ~MoveResourceGroupResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_MOVERESOURCEGROUPRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/RemoveBackendServersRequest.h b/slb/include/alibabacloud/slb/model/RemoveBackendServersRequest.h new file mode 100644 index 000000000..da533d760 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/RemoveBackendServersRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_REMOVEBACKENDSERVERSREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_REMOVEBACKENDSERVERSREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT RemoveBackendServersRequest : public SlbRequest + { + + public: + RemoveBackendServersRequest(); + ~RemoveBackendServersRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getBackendServers()const; + void setBackendServers(const std::string& backendServers); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string loadBalancerId_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string backendServers_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_REMOVEBACKENDSERVERSREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/RemoveBackendServersResult.h b/slb/include/alibabacloud/slb/model/RemoveBackendServersResult.h new file mode 100644 index 000000000..9860d460c --- /dev/null +++ b/slb/include/alibabacloud/slb/model/RemoveBackendServersResult.h @@ -0,0 +1,60 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_REMOVEBACKENDSERVERSRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_REMOVEBACKENDSERVERSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT RemoveBackendServersResult : public ServiceResult + { + public: + struct BackendServer + { + std::string serverId; + int weight; + }; + + + RemoveBackendServersResult(); + explicit RemoveBackendServersResult(const std::string &payload); + ~RemoveBackendServersResult(); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::vector getBackendServers()const; + void setBackendServers(const std::vector& backendServers); + + protected: + void parse(const std::string &payload); + private: + std::string loadBalancerId_; + std::vector backendServers_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_REMOVEBACKENDSERVERSRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/RemoveListenerWhiteListItemRequest.h b/slb/include/alibabacloud/slb/model/RemoveListenerWhiteListItemRequest.h new file mode 100644 index 000000000..047b21104 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/RemoveListenerWhiteListItemRequest.h @@ -0,0 +1,77 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_REMOVELISTENERWHITELISTITEMREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_REMOVELISTENERWHITELISTITEMREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT RemoveListenerWhiteListItemRequest : public SlbRequest + { + + public: + RemoveListenerWhiteListItemRequest(); + ~RemoveListenerWhiteListItemRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getSourceItems()const; + void setSourceItems(const std::string& sourceItems); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + int listenerPort_; + std::string loadBalancerId_; + std::string sourceItems_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_REMOVELISTENERWHITELISTITEMREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/RemoveListenerWhiteListItemResult.h b/slb/include/alibabacloud/slb/model/RemoveListenerWhiteListItemResult.h new file mode 100644 index 000000000..93f3f56ed --- /dev/null +++ b/slb/include/alibabacloud/slb/model/RemoveListenerWhiteListItemResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_REMOVELISTENERWHITELISTITEMRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_REMOVELISTENERWHITELISTITEMRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT RemoveListenerWhiteListItemResult : public ServiceResult + { + public: + + + RemoveListenerWhiteListItemResult(); + explicit RemoveListenerWhiteListItemResult(const std::string &payload); + ~RemoveListenerWhiteListItemResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_REMOVELISTENERWHITELISTITEMRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/RemoveTagsRequest.h b/slb/include/alibabacloud/slb/model/RemoveTagsRequest.h new file mode 100644 index 000000000..4db8eb004 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/RemoveTagsRequest.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_REMOVETAGSREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_REMOVETAGSREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT RemoveTagsRequest : public SlbRequest + { + + public: + RemoveTagsRequest(); + ~RemoveTagsRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string loadBalancerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_REMOVETAGSREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/RemoveTagsResult.h b/slb/include/alibabacloud/slb/model/RemoveTagsResult.h new file mode 100644 index 000000000..ce402fc3f --- /dev/null +++ b/slb/include/alibabacloud/slb/model/RemoveTagsResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_REMOVETAGSRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_REMOVETAGSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT RemoveTagsResult : public ServiceResult + { + public: + + + RemoveTagsResult(); + explicit RemoveTagsResult(const std::string &payload); + ~RemoveTagsResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_REMOVETAGSRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/RemoveVServerGroupBackendServersRequest.h b/slb/include/alibabacloud/slb/model/RemoveVServerGroupBackendServersRequest.h new file mode 100644 index 000000000..505bc809f --- /dev/null +++ b/slb/include/alibabacloud/slb/model/RemoveVServerGroupBackendServersRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_REMOVEVSERVERGROUPBACKENDSERVERSREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_REMOVEVSERVERGROUPBACKENDSERVERSREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT RemoveVServerGroupBackendServersRequest : public SlbRequest + { + + public: + RemoveVServerGroupBackendServersRequest(); + ~RemoveVServerGroupBackendServersRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getBackendServers()const; + void setBackendServers(const std::string& backendServers); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + std::string vServerGroupId_; + long resourceOwnerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string backendServers_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_REMOVEVSERVERGROUPBACKENDSERVERSREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/RemoveVServerGroupBackendServersResult.h b/slb/include/alibabacloud/slb/model/RemoveVServerGroupBackendServersResult.h new file mode 100644 index 000000000..5a3dd5b69 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/RemoveVServerGroupBackendServersResult.h @@ -0,0 +1,61 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_REMOVEVSERVERGROUPBACKENDSERVERSRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_REMOVEVSERVERGROUPBACKENDSERVERSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT RemoveVServerGroupBackendServersResult : public ServiceResult + { + public: + struct BackendServer + { + std::string serverId; + int port; + int weight; + }; + + + RemoveVServerGroupBackendServersResult(); + explicit RemoveVServerGroupBackendServersResult(const std::string &payload); + ~RemoveVServerGroupBackendServersResult(); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + std::vector getBackendServers()const; + void setBackendServers(const std::vector& backendServers); + + protected: + void parse(const std::string &payload); + private: + std::string vServerGroupId_; + std::vector backendServers_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_REMOVEVSERVERGROUPBACKENDSERVERSRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetBackendServersRequest.h b/slb/include/alibabacloud/slb/model/SetBackendServersRequest.h new file mode 100644 index 000000000..f85c22178 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetBackendServersRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_SETBACKENDSERVERSREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_SETBACKENDSERVERSREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetBackendServersRequest : public SlbRequest + { + + public: + SetBackendServersRequest(); + ~SetBackendServersRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getBackendServers()const; + void setBackendServers(const std::string& backendServers); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string loadBalancerId_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string backendServers_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETBACKENDSERVERSREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetBackendServersResult.h b/slb/include/alibabacloud/slb/model/SetBackendServersResult.h new file mode 100644 index 000000000..0dcc3a3c4 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetBackendServersResult.h @@ -0,0 +1,60 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_SETBACKENDSERVERSRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_SETBACKENDSERVERSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetBackendServersResult : public ServiceResult + { + public: + struct BackendServer + { + std::string serverId; + std::string weight; + }; + + + SetBackendServersResult(); + explicit SetBackendServersResult(const std::string &payload); + ~SetBackendServersResult(); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::vector getBackendServers()const; + void setBackendServers(const std::vector& backendServers); + + protected: + void parse(const std::string &payload); + private: + std::string loadBalancerId_; + std::vector backendServers_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETBACKENDSERVERSRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetCACertificateNameRequest.h b/slb/include/alibabacloud/slb/model/SetCACertificateNameRequest.h new file mode 100644 index 000000000..0e858a76e --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetCACertificateNameRequest.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_SETCACERTIFICATENAMEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_SETCACERTIFICATENAMEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetCACertificateNameRequest : public SlbRequest + { + + public: + SetCACertificateNameRequest(); + ~SetCACertificateNameRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getCACertificateName()const; + void setCACertificateName(const std::string& cACertificateName); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getCACertificateId()const; + void setCACertificateId(const std::string& cACertificateId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string cACertificateName_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string cACertificateId_; + std::string accessKeyId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETCACERTIFICATENAMEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetCACertificateNameResult.h b/slb/include/alibabacloud/slb/model/SetCACertificateNameResult.h new file mode 100644 index 000000000..e42354d17 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetCACertificateNameResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_SETCACERTIFICATENAMERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_SETCACERTIFICATENAMERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetCACertificateNameResult : public ServiceResult + { + public: + + + SetCACertificateNameResult(); + explicit SetCACertificateNameResult(const std::string &payload); + ~SetCACertificateNameResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETCACERTIFICATENAMERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetListenerAccessControlStatusRequest.h b/slb/include/alibabacloud/slb/model/SetListenerAccessControlStatusRequest.h new file mode 100644 index 000000000..1789f71ed --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetListenerAccessControlStatusRequest.h @@ -0,0 +1,77 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_SETLISTENERACCESSCONTROLSTATUSREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_SETLISTENERACCESSCONTROLSTATUSREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetListenerAccessControlStatusRequest : public SlbRequest + { + + public: + SetListenerAccessControlStatusRequest(); + ~SetListenerAccessControlStatusRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + std::string getAccessControlStatus()const; + void setAccessControlStatus(const std::string& accessControlStatus); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + int listenerPort_; + std::string loadBalancerId_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + std::string accessControlStatus_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETLISTENERACCESSCONTROLSTATUSREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetListenerAccessControlStatusResult.h b/slb/include/alibabacloud/slb/model/SetListenerAccessControlStatusResult.h new file mode 100644 index 000000000..81c27c6cd --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetListenerAccessControlStatusResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_SETLISTENERACCESSCONTROLSTATUSRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_SETLISTENERACCESSCONTROLSTATUSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetListenerAccessControlStatusResult : public ServiceResult + { + public: + + + SetListenerAccessControlStatusResult(); + explicit SetListenerAccessControlStatusResult(const std::string &payload); + ~SetListenerAccessControlStatusResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETLISTENERACCESSCONTROLSTATUSRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetLoadBalancerAutoReleaseTimeRequest.h b/slb/include/alibabacloud/slb/model/SetLoadBalancerAutoReleaseTimeRequest.h new file mode 100644 index 000000000..813f09539 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetLoadBalancerAutoReleaseTimeRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_SETLOADBALANCERAUTORELEASETIMEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERAUTORELEASETIMEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerAutoReleaseTimeRequest : public SlbRequest + { + + public: + SetLoadBalancerAutoReleaseTimeRequest(); + ~SetLoadBalancerAutoReleaseTimeRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getAutoReleaseTime()const; + void setAutoReleaseTime(long autoReleaseTime); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string loadBalancerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long autoReleaseTime_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERAUTORELEASETIMEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetLoadBalancerAutoReleaseTimeResult.h b/slb/include/alibabacloud/slb/model/SetLoadBalancerAutoReleaseTimeResult.h new file mode 100644 index 000000000..51d931ed8 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetLoadBalancerAutoReleaseTimeResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERAUTORELEASETIMERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERAUTORELEASETIMERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerAutoReleaseTimeResult : public ServiceResult + { + public: + + + SetLoadBalancerAutoReleaseTimeResult(); + explicit SetLoadBalancerAutoReleaseTimeResult(const std::string &payload); + ~SetLoadBalancerAutoReleaseTimeResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERAUTORELEASETIMERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetLoadBalancerHTTPListenerAttributeRequest.h b/slb/include/alibabacloud/slb/model/SetLoadBalancerHTTPListenerAttributeRequest.h new file mode 100644 index 000000000..0d79845f9 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetLoadBalancerHTTPListenerAttributeRequest.h @@ -0,0 +1,143 @@ +/* + * 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_SLB_MODEL_SETLOADBALANCERHTTPLISTENERATTRIBUTEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERHTTPLISTENERATTRIBUTEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerHTTPListenerAttributeRequest : public SlbRequest + { + + public: + SetLoadBalancerHTTPListenerAttributeRequest(); + ~SetLoadBalancerHTTPListenerAttributeRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + int getHealthCheckTimeout()const; + void setHealthCheckTimeout(int healthCheckTimeout); + std::string getXForwardedFor()const; + void setXForwardedFor(const std::string& xForwardedFor); + std::string getHealthCheckURI()const; + void setHealthCheckURI(const std::string& healthCheckURI); + int getUnhealthyThreshold()const; + void setUnhealthyThreshold(int unhealthyThreshold); + int getHealthyThreshold()const; + void setHealthyThreshold(int healthyThreshold); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getScheduler()const; + void setScheduler(const std::string& scheduler); + std::string getHealthCheck()const; + void setHealthCheck(const std::string& healthCheck); + int getMaxConnection()const; + void setMaxConnection(int maxConnection); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + int getCookieTimeout()const; + void setCookieTimeout(int cookieTimeout); + std::string getStickySessionType()const; + void setStickySessionType(const std::string& stickySessionType); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getCookie()const; + void setCookie(const std::string& cookie); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + int getBandwidth()const; + void setBandwidth(int bandwidth); + std::string getStickySession()const; + void setStickySession(const std::string& stickySession); + std::string getHealthCheckDomain()const; + void setHealthCheckDomain(const std::string& healthCheckDomain); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + std::string getGzip()const; + void setGzip(const std::string& gzip); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getTags()const; + void setTags(const std::string& tags); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getXForwardedFor_SLBIP()const; + void setXForwardedFor_SLBIP(const std::string& xForwardedFor_SLBIP); + int getHealthCheckInterval()const; + void setHealthCheckInterval(int healthCheckInterval); + std::string getXForwardedFor_proto()const; + void setXForwardedFor_proto(const std::string& xForwardedFor_proto); + std::string getXForwardedFor_SLBID()const; + void setXForwardedFor_SLBID(const std::string& xForwardedFor_SLBID); + int getHealthCheckConnectPort()const; + void setHealthCheckConnectPort(int healthCheckConnectPort); + std::string getHealthCheckHttpCode()const; + void setHealthCheckHttpCode(const std::string& healthCheckHttpCode); + std::string getVServerGroup()const; + void setVServerGroup(const std::string& vServerGroup); + + private: + std::string access_key_id_; + long resourceOwnerId_; + int healthCheckTimeout_; + std::string xForwardedFor_; + std::string healthCheckURI_; + int unhealthyThreshold_; + int healthyThreshold_; + std::string accessKeyId_; + std::string scheduler_; + std::string healthCheck_; + int maxConnection_; + std::string regionId_; + int cookieTimeout_; + std::string stickySessionType_; + std::string vServerGroupId_; + int listenerPort_; + std::string cookie_; + std::string resourceOwnerAccount_; + int bandwidth_; + std::string stickySession_; + std::string healthCheckDomain_; + std::string ownerAccount_; + std::string gzip_; + long ownerId_; + std::string tags_; + std::string loadBalancerId_; + std::string xForwardedFor_SLBIP_; + int healthCheckInterval_; + std::string xForwardedFor_proto_; + std::string xForwardedFor_SLBID_; + int healthCheckConnectPort_; + std::string healthCheckHttpCode_; + std::string vServerGroup_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERHTTPLISTENERATTRIBUTEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetLoadBalancerHTTPListenerAttributeResult.h b/slb/include/alibabacloud/slb/model/SetLoadBalancerHTTPListenerAttributeResult.h new file mode 100644 index 000000000..db9129295 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetLoadBalancerHTTPListenerAttributeResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERHTTPLISTENERATTRIBUTERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERHTTPLISTENERATTRIBUTERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerHTTPListenerAttributeResult : public ServiceResult + { + public: + + + SetLoadBalancerHTTPListenerAttributeResult(); + explicit SetLoadBalancerHTTPListenerAttributeResult(const std::string &payload); + ~SetLoadBalancerHTTPListenerAttributeResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERHTTPLISTENERATTRIBUTERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetLoadBalancerHTTPSListenerAttributeRequest.h b/slb/include/alibabacloud/slb/model/SetLoadBalancerHTTPSListenerAttributeRequest.h new file mode 100644 index 000000000..4ff257ae4 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetLoadBalancerHTTPSListenerAttributeRequest.h @@ -0,0 +1,149 @@ +/* + * 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_SLB_MODEL_SETLOADBALANCERHTTPSLISTENERATTRIBUTEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERHTTPSLISTENERATTRIBUTEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerHTTPSListenerAttributeRequest : public SlbRequest + { + + public: + SetLoadBalancerHTTPSListenerAttributeRequest(); + ~SetLoadBalancerHTTPSListenerAttributeRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + int getHealthCheckTimeout()const; + void setHealthCheckTimeout(int healthCheckTimeout); + std::string getXForwardedFor()const; + void setXForwardedFor(const std::string& xForwardedFor); + std::string getHealthCheckURI()const; + void setHealthCheckURI(const std::string& healthCheckURI); + int getUnhealthyThreshold()const; + void setUnhealthyThreshold(int unhealthyThreshold); + int getHealthyThreshold()const; + void setHealthyThreshold(int healthyThreshold); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getScheduler()const; + void setScheduler(const std::string& scheduler); + std::string getHealthCheck()const; + void setHealthCheck(const std::string& healthCheck); + int getMaxConnection()const; + void setMaxConnection(int maxConnection); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + int getCookieTimeout()const; + void setCookieTimeout(int cookieTimeout); + std::string getStickySessionType()const; + void setStickySessionType(const std::string& stickySessionType); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getCookie()const; + void setCookie(const std::string& cookie); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + int getBandwidth()const; + void setBandwidth(int bandwidth); + std::string getStickySession()const; + void setStickySession(const std::string& stickySession); + std::string getHealthCheckDomain()const; + void setHealthCheckDomain(const std::string& healthCheckDomain); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + std::string getGzip()const; + void setGzip(const std::string& gzip); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getServerCertificateId()const; + void setServerCertificateId(const std::string& serverCertificateId); + std::string getCACertificateId()const; + void setCACertificateId(const std::string& cACertificateId); + std::string getTags()const; + void setTags(const std::string& tags); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getXForwardedFor_SLBIP()const; + void setXForwardedFor_SLBIP(const std::string& xForwardedFor_SLBIP); + int getHealthCheckInterval()const; + void setHealthCheckInterval(int healthCheckInterval); + std::string getXForwardedFor_proto()const; + void setXForwardedFor_proto(const std::string& xForwardedFor_proto); + std::string getXForwardedFor_SLBID()const; + void setXForwardedFor_SLBID(const std::string& xForwardedFor_SLBID); + int getHealthCheckConnectPort()const; + void setHealthCheckConnectPort(int healthCheckConnectPort); + std::string getHealthCheckHttpCode()const; + void setHealthCheckHttpCode(const std::string& healthCheckHttpCode); + std::string getVServerGroup()const; + void setVServerGroup(const std::string& vServerGroup); + + private: + std::string access_key_id_; + long resourceOwnerId_; + int healthCheckTimeout_; + std::string xForwardedFor_; + std::string healthCheckURI_; + int unhealthyThreshold_; + int healthyThreshold_; + std::string accessKeyId_; + std::string scheduler_; + std::string healthCheck_; + int maxConnection_; + std::string regionId_; + int cookieTimeout_; + std::string stickySessionType_; + std::string vServerGroupId_; + int listenerPort_; + std::string cookie_; + std::string resourceOwnerAccount_; + int bandwidth_; + std::string stickySession_; + std::string healthCheckDomain_; + std::string ownerAccount_; + std::string gzip_; + long ownerId_; + std::string serverCertificateId_; + std::string cACertificateId_; + std::string tags_; + std::string loadBalancerId_; + std::string xForwardedFor_SLBIP_; + int healthCheckInterval_; + std::string xForwardedFor_proto_; + std::string xForwardedFor_SLBID_; + int healthCheckConnectPort_; + std::string healthCheckHttpCode_; + std::string vServerGroup_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERHTTPSLISTENERATTRIBUTEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetLoadBalancerHTTPSListenerAttributeResult.h b/slb/include/alibabacloud/slb/model/SetLoadBalancerHTTPSListenerAttributeResult.h new file mode 100644 index 000000000..4befd18b1 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetLoadBalancerHTTPSListenerAttributeResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERHTTPSLISTENERATTRIBUTERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERHTTPSLISTENERATTRIBUTERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerHTTPSListenerAttributeResult : public ServiceResult + { + public: + + + SetLoadBalancerHTTPSListenerAttributeResult(); + explicit SetLoadBalancerHTTPSListenerAttributeResult(const std::string &payload); + ~SetLoadBalancerHTTPSListenerAttributeResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERHTTPSLISTENERATTRIBUTERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetLoadBalancerNameRequest.h b/slb/include/alibabacloud/slb/model/SetLoadBalancerNameRequest.h new file mode 100644 index 000000000..040156df3 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetLoadBalancerNameRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_SETLOADBALANCERNAMEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERNAMEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerNameRequest : public SlbRequest + { + + public: + SetLoadBalancerNameRequest(); + ~SetLoadBalancerNameRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getLoadBalancerName()const; + void setLoadBalancerName(const std::string& loadBalancerName); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string loadBalancerName_; + std::string loadBalancerId_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERNAMEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetLoadBalancerNameResult.h b/slb/include/alibabacloud/slb/model/SetLoadBalancerNameResult.h new file mode 100644 index 000000000..02f585abe --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetLoadBalancerNameResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERNAMERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERNAMERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerNameResult : public ServiceResult + { + public: + + + SetLoadBalancerNameResult(); + explicit SetLoadBalancerNameResult(const std::string &payload); + ~SetLoadBalancerNameResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERNAMERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetLoadBalancerStatusRequest.h b/slb/include/alibabacloud/slb/model/SetLoadBalancerStatusRequest.h new file mode 100644 index 000000000..209837468 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetLoadBalancerStatusRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_SETLOADBALANCERSTATUSREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERSTATUSREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerStatusRequest : public SlbRequest + { + + public: + SetLoadBalancerStatusRequest(); + ~SetLoadBalancerStatusRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getLoadBalancerStatus()const; + void setLoadBalancerStatus(const std::string& loadBalancerStatus); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string loadBalancerId_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string loadBalancerStatus_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERSTATUSREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetLoadBalancerStatusResult.h b/slb/include/alibabacloud/slb/model/SetLoadBalancerStatusResult.h new file mode 100644 index 000000000..7ba48083c --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetLoadBalancerStatusResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERSTATUSRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERSTATUSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerStatusResult : public ServiceResult + { + public: + + + SetLoadBalancerStatusResult(); + explicit SetLoadBalancerStatusResult(const std::string &payload); + ~SetLoadBalancerStatusResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERSTATUSRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetLoadBalancerTCPListenerAttributeRequest.h b/slb/include/alibabacloud/slb/model/SetLoadBalancerTCPListenerAttributeRequest.h new file mode 100644 index 000000000..d7eeed7e7 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetLoadBalancerTCPListenerAttributeRequest.h @@ -0,0 +1,131 @@ +/* + * 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_SLB_MODEL_SETLOADBALANCERTCPLISTENERATTRIBUTEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERTCPLISTENERATTRIBUTEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerTCPListenerAttributeRequest : public SlbRequest + { + + public: + SetLoadBalancerTCPListenerAttributeRequest(); + ~SetLoadBalancerTCPListenerAttributeRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + int getHealthCheckConnectTimeout()const; + void setHealthCheckConnectTimeout(int healthCheckConnectTimeout); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getHealthCheckURI()const; + void setHealthCheckURI(const std::string& healthCheckURI); + int getUnhealthyThreshold()const; + void setUnhealthyThreshold(int unhealthyThreshold); + int getHealthyThreshold()const; + void setHealthyThreshold(int healthyThreshold); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getScheduler()const; + void setScheduler(const std::string& scheduler); + std::string getMasterSlaveServerGroup()const; + void setMasterSlaveServerGroup(const std::string& masterSlaveServerGroup); + int getEstablishedTimeout()const; + void setEstablishedTimeout(int establishedTimeout); + int getMaxConnection()const; + void setMaxConnection(int maxConnection); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + int getPersistenceTimeout()const; + void setPersistenceTimeout(int persistenceTimeout); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getHealthCheckType()const; + void setHealthCheckType(const std::string& healthCheckType); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + int getBandwidth()const; + void setBandwidth(int bandwidth); + std::string getHealthCheckDomain()const; + void setHealthCheckDomain(const std::string& healthCheckDomain); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + std::string getSynProxy()const; + void setSynProxy(const std::string& synProxy); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getTags()const; + void setTags(const std::string& tags); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getMasterSlaveServerGroupId()const; + void setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId); + int getHealthCheckInterval()const; + void setHealthCheckInterval(int healthCheckInterval); + int getHealthCheckConnectPort()const; + void setHealthCheckConnectPort(int healthCheckConnectPort); + std::string getHealthCheckHttpCode()const; + void setHealthCheckHttpCode(const std::string& healthCheckHttpCode); + std::string getVServerGroup()const; + void setVServerGroup(const std::string& vServerGroup); + + private: + std::string access_key_id_; + int healthCheckConnectTimeout_; + long resourceOwnerId_; + std::string healthCheckURI_; + int unhealthyThreshold_; + int healthyThreshold_; + std::string accessKeyId_; + std::string scheduler_; + std::string masterSlaveServerGroup_; + int establishedTimeout_; + int maxConnection_; + std::string regionId_; + int persistenceTimeout_; + std::string vServerGroupId_; + int listenerPort_; + std::string healthCheckType_; + std::string resourceOwnerAccount_; + int bandwidth_; + std::string healthCheckDomain_; + std::string ownerAccount_; + std::string synProxy_; + long ownerId_; + std::string tags_; + std::string loadBalancerId_; + std::string masterSlaveServerGroupId_; + int healthCheckInterval_; + int healthCheckConnectPort_; + std::string healthCheckHttpCode_; + std::string vServerGroup_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERTCPLISTENERATTRIBUTEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetLoadBalancerTCPListenerAttributeResult.h b/slb/include/alibabacloud/slb/model/SetLoadBalancerTCPListenerAttributeResult.h new file mode 100644 index 000000000..007862a54 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetLoadBalancerTCPListenerAttributeResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERTCPLISTENERATTRIBUTERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERTCPLISTENERATTRIBUTERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerTCPListenerAttributeResult : public ServiceResult + { + public: + + + SetLoadBalancerTCPListenerAttributeResult(); + explicit SetLoadBalancerTCPListenerAttributeResult(const std::string &payload); + ~SetLoadBalancerTCPListenerAttributeResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERTCPLISTENERATTRIBUTERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetLoadBalancerUDPListenerAttributeRequest.h b/slb/include/alibabacloud/slb/model/SetLoadBalancerUDPListenerAttributeRequest.h new file mode 100644 index 000000000..b021fbb36 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetLoadBalancerUDPListenerAttributeRequest.h @@ -0,0 +1,119 @@ +/* + * 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_SLB_MODEL_SETLOADBALANCERUDPLISTENERATTRIBUTEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERUDPLISTENERATTRIBUTEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerUDPListenerAttributeRequest : public SlbRequest + { + + public: + SetLoadBalancerUDPListenerAttributeRequest(); + ~SetLoadBalancerUDPListenerAttributeRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + int getHealthCheckConnectTimeout()const; + void setHealthCheckConnectTimeout(int healthCheckConnectTimeout); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + int getUnhealthyThreshold()const; + void setUnhealthyThreshold(int unhealthyThreshold); + int getHealthyThreshold()const; + void setHealthyThreshold(int healthyThreshold); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getScheduler()const; + void setScheduler(const std::string& scheduler); + std::string getMasterSlaveServerGroup()const; + void setMasterSlaveServerGroup(const std::string& masterSlaveServerGroup); + int getMaxConnection()const; + void setMaxConnection(int maxConnection); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + int getPersistenceTimeout()const; + void setPersistenceTimeout(int persistenceTimeout); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + int getBandwidth()const; + void setBandwidth(int bandwidth); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getTags()const; + void setTags(const std::string& tags); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getMasterSlaveServerGroupId()const; + void setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId); + std::string getHealthCheckReq()const; + void setHealthCheckReq(const std::string& healthCheckReq); + int getHealthCheckInterval()const; + void setHealthCheckInterval(int healthCheckInterval); + std::string getHealthCheckExp()const; + void setHealthCheckExp(const std::string& healthCheckExp); + int getHealthCheckConnectPort()const; + void setHealthCheckConnectPort(int healthCheckConnectPort); + std::string getVServerGroup()const; + void setVServerGroup(const std::string& vServerGroup); + + private: + std::string access_key_id_; + int healthCheckConnectTimeout_; + long resourceOwnerId_; + int unhealthyThreshold_; + int healthyThreshold_; + std::string accessKeyId_; + std::string scheduler_; + std::string masterSlaveServerGroup_; + int maxConnection_; + std::string regionId_; + int persistenceTimeout_; + std::string vServerGroupId_; + int listenerPort_; + std::string resourceOwnerAccount_; + int bandwidth_; + std::string ownerAccount_; + long ownerId_; + std::string tags_; + std::string loadBalancerId_; + std::string masterSlaveServerGroupId_; + std::string healthCheckReq_; + int healthCheckInterval_; + std::string healthCheckExp_; + int healthCheckConnectPort_; + std::string vServerGroup_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERUDPLISTENERATTRIBUTEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetLoadBalancerUDPListenerAttributeResult.h b/slb/include/alibabacloud/slb/model/SetLoadBalancerUDPListenerAttributeResult.h new file mode 100644 index 000000000..9d94eb604 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetLoadBalancerUDPListenerAttributeResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERUDPLISTENERATTRIBUTERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERUDPLISTENERATTRIBUTERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerUDPListenerAttributeResult : public ServiceResult + { + public: + + + SetLoadBalancerUDPListenerAttributeResult(); + explicit SetLoadBalancerUDPListenerAttributeResult(const std::string &payload); + ~SetLoadBalancerUDPListenerAttributeResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERUDPLISTENERATTRIBUTERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetRuleRequest.h b/slb/include/alibabacloud/slb/model/SetRuleRequest.h new file mode 100644 index 000000000..c9f13b821 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetRuleRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_SETRULEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_SETRULEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetRuleRequest : public SlbRequest + { + + public: + SetRuleRequest(); + ~SetRuleRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getRuleId()const; + void setRuleId(const std::string& ruleId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + std::string vServerGroupId_; + long resourceOwnerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string ruleId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETRULEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetRuleResult.h b/slb/include/alibabacloud/slb/model/SetRuleResult.h new file mode 100644 index 000000000..4097b6742 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetRuleResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_SETRULERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_SETRULERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetRuleResult : public ServiceResult + { + public: + + + SetRuleResult(); + explicit SetRuleResult(const std::string &payload); + ~SetRuleResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETRULERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetServerCertificateNameRequest.h b/slb/include/alibabacloud/slb/model/SetServerCertificateNameRequest.h new file mode 100644 index 000000000..f5a8ccec3 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetServerCertificateNameRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_SETSERVERCERTIFICATENAMEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_SETSERVERCERTIFICATENAMEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetServerCertificateNameRequest : public SlbRequest + { + + public: + SetServerCertificateNameRequest(); + ~SetServerCertificateNameRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getServerCertificateId()const; + void setServerCertificateId(const std::string& serverCertificateId); + std::string getServerCertificateName()const; + void setServerCertificateName(const std::string& serverCertificateName); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string serverCertificateId_; + std::string serverCertificateName_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETSERVERCERTIFICATENAMEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetServerCertificateNameResult.h b/slb/include/alibabacloud/slb/model/SetServerCertificateNameResult.h new file mode 100644 index 000000000..96c46bc1a --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetServerCertificateNameResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_SETSERVERCERTIFICATENAMERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_SETSERVERCERTIFICATENAMERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetServerCertificateNameResult : public ServiceResult + { + public: + + + SetServerCertificateNameResult(); + explicit SetServerCertificateNameResult(const std::string &payload); + ~SetServerCertificateNameResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETSERVERCERTIFICATENAMERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetVServerGroupAttributeRequest.h b/slb/include/alibabacloud/slb/model/SetVServerGroupAttributeRequest.h new file mode 100644 index 000000000..ddeec9def --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetVServerGroupAttributeRequest.h @@ -0,0 +1,77 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_SETVSERVERGROUPATTRIBUTEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_SETVSERVERGROUPATTRIBUTEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetVServerGroupAttributeRequest : public SlbRequest + { + + public: + SetVServerGroupAttributeRequest(); + ~SetVServerGroupAttributeRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getBackendServers()const; + void setBackendServers(const std::string& backendServers); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + std::string getVServerGroupName()const; + void setVServerGroupName(const std::string& vServerGroupName); + + private: + std::string access_key_id_; + std::string vServerGroupId_; + long resourceOwnerId_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string backendServers_; + std::string accessKeyId_; + std::string tags_; + std::string vServerGroupName_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETVSERVERGROUPATTRIBUTEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/SetVServerGroupAttributeResult.h b/slb/include/alibabacloud/slb/model/SetVServerGroupAttributeResult.h new file mode 100644 index 000000000..baff3f065 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/SetVServerGroupAttributeResult.h @@ -0,0 +1,64 @@ +/* + * 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_SLB_MODEL_SETVSERVERGROUPATTRIBUTERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_SETVSERVERGROUPATTRIBUTERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT SetVServerGroupAttributeResult : public ServiceResult + { + public: + struct BackendServer + { + std::string serverId; + int port; + int weight; + }; + + + SetVServerGroupAttributeResult(); + explicit SetVServerGroupAttributeResult(const std::string &payload); + ~SetVServerGroupAttributeResult(); + std::string getVServerGroupId()const; + void setVServerGroupId(const std::string& vServerGroupId); + std::string getVServerGroupName()const; + void setVServerGroupName(const std::string& vServerGroupName); + std::vector getBackendServers()const; + void setBackendServers(const std::vector& backendServers); + + protected: + void parse(const std::string &payload); + private: + std::string vServerGroupId_; + std::string vServerGroupName_; + std::vector backendServers_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_SETVSERVERGROUPATTRIBUTERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/StartLoadBalancerListenerRequest.h b/slb/include/alibabacloud/slb/model/StartLoadBalancerListenerRequest.h new file mode 100644 index 000000000..fc88495e0 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/StartLoadBalancerListenerRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_STARTLOADBALANCERLISTENERREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_STARTLOADBALANCERLISTENERREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT StartLoadBalancerListenerRequest : public SlbRequest + { + + public: + StartLoadBalancerListenerRequest(); + ~StartLoadBalancerListenerRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + int listenerPort_; + std::string loadBalancerId_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_STARTLOADBALANCERLISTENERREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/StartLoadBalancerListenerResult.h b/slb/include/alibabacloud/slb/model/StartLoadBalancerListenerResult.h new file mode 100644 index 000000000..393a6378a --- /dev/null +++ b/slb/include/alibabacloud/slb/model/StartLoadBalancerListenerResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_STARTLOADBALANCERLISTENERRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_STARTLOADBALANCERLISTENERRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT StartLoadBalancerListenerResult : public ServiceResult + { + public: + + + StartLoadBalancerListenerResult(); + explicit StartLoadBalancerListenerResult(const std::string &payload); + ~StartLoadBalancerListenerResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_STARTLOADBALANCERLISTENERRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/StopLoadBalancerListenerRequest.h b/slb/include/alibabacloud/slb/model/StopLoadBalancerListenerRequest.h new file mode 100644 index 000000000..0e89cacf4 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/StopLoadBalancerListenerRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_STOPLOADBALANCERLISTENERREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_STOPLOADBALANCERLISTENERREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT StopLoadBalancerListenerRequest : public SlbRequest + { + + public: + StopLoadBalancerListenerRequest(); + ~StopLoadBalancerListenerRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + int getListenerPort()const; + void setListenerPort(int listenerPort); + std::string getLoadBalancerId()const; + void setLoadBalancerId(const std::string& loadBalancerId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + + private: + std::string access_key_id_; + long resourceOwnerId_; + int listenerPort_; + std::string loadBalancerId_; + std::string regionId_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_STOPLOADBALANCERLISTENERREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/StopLoadBalancerListenerResult.h b/slb/include/alibabacloud/slb/model/StopLoadBalancerListenerResult.h new file mode 100644 index 000000000..8f3246856 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/StopLoadBalancerListenerResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_STOPLOADBALANCERLISTENERRESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_STOPLOADBALANCERLISTENERRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT StopLoadBalancerListenerResult : public ServiceResult + { + public: + + + StopLoadBalancerListenerResult(); + explicit StopLoadBalancerListenerResult(const std::string &payload); + ~StopLoadBalancerListenerResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_STOPLOADBALANCERLISTENERRESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/UploadCACertificateRequest.h b/slb/include/alibabacloud/slb/model/UploadCACertificateRequest.h new file mode 100644 index 000000000..bb22a3774 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/UploadCACertificateRequest.h @@ -0,0 +1,74 @@ +/* + * 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_SLB_MODEL_UPLOADCACERTIFICATEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_UPLOADCACERTIFICATEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT UploadCACertificateRequest : public SlbRequest + { + + public: + UploadCACertificateRequest(); + ~UploadCACertificateRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + std::string getResourceGroupId()const; + void setResourceGroupId(const std::string& resourceGroupId); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getCACertificate()const; + void setCACertificate(const std::string& cACertificate); + std::string getCACertificateName()const; + void setCACertificateName(const std::string& cACertificateName); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + + private: + std::string access_key_id_; + std::string resourceGroupId_; + long resourceOwnerId_; + std::string cACertificate_; + std::string cACertificateName_; + std::string resourceOwnerAccount_; + std::string regionId_; + std::string ownerAccount_; + long ownerId_; + std::string accessKeyId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_UPLOADCACERTIFICATEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/UploadCACertificateResult.h b/slb/include/alibabacloud/slb/model/UploadCACertificateResult.h new file mode 100644 index 000000000..cef6a0069 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/UploadCACertificateResult.h @@ -0,0 +1,67 @@ +/* + * 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_SLB_MODEL_UPLOADCACERTIFICATERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_UPLOADCACERTIFICATERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT UploadCACertificateResult : public ServiceResult + { + public: + + + UploadCACertificateResult(); + explicit UploadCACertificateResult(const std::string &payload); + ~UploadCACertificateResult(); + std::string getFingerprint()const; + void setFingerprint(const std::string& fingerprint); + std::string getResourceGroupId()const; + void setResourceGroupId(const std::string& resourceGroupId); + std::string getCACertificateId()const; + void setCACertificateId(const std::string& cACertificateId); + std::string getCreateTime()const; + void setCreateTime(const std::string& createTime); + std::string getCACertificateName()const; + void setCACertificateName(const std::string& cACertificateName); + long getCreateTimeStamp()const; + void setCreateTimeStamp(long createTimeStamp); + + protected: + void parse(const std::string &payload); + private: + std::string fingerprint_; + std::string resourceGroupId_; + std::string cACertificateId_; + std::string createTime_; + std::string cACertificateName_; + long createTimeStamp_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_UPLOADCACERTIFICATERESULT_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/UploadServerCertificateRequest.h b/slb/include/alibabacloud/slb/model/UploadServerCertificateRequest.h new file mode 100644 index 000000000..165322cdb --- /dev/null +++ b/slb/include/alibabacloud/slb/model/UploadServerCertificateRequest.h @@ -0,0 +1,86 @@ +/* + * 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_SLB_MODEL_UPLOADSERVERCERTIFICATEREQUEST_H_ +#define ALIBABACLOUD_SLB_MODEL_UPLOADSERVERCERTIFICATEREQUEST_H_ + +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT UploadServerCertificateRequest : public SlbRequest + { + + public: + UploadServerCertificateRequest(); + ~UploadServerCertificateRequest(); + + std::string getAccess_key_id()const; + void setAccess_key_id(const std::string& access_key_id); + long getResourceOwnerId()const; + void setResourceOwnerId(long resourceOwnerId); + std::string getServerCertificate()const; + void setServerCertificate(const std::string& serverCertificate); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getOwnerAccount()const; + void setOwnerAccount(const std::string& ownerAccount); + std::string getAliCloudCertificateName()const; + void setAliCloudCertificateName(const std::string& aliCloudCertificateName); + std::string getAliCloudCertificateId()const; + void setAliCloudCertificateId(const std::string& aliCloudCertificateId); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getTags()const; + void setTags(const std::string& tags); + std::string getPrivateKey()const; + void setPrivateKey(const std::string& privateKey); + std::string getResourceGroupId()const; + void setResourceGroupId(const std::string& resourceGroupId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getServerCertificateName()const; + void setServerCertificateName(const std::string& serverCertificateName); + + private: + std::string access_key_id_; + long resourceOwnerId_; + std::string serverCertificate_; + std::string resourceOwnerAccount_; + std::string ownerAccount_; + std::string aliCloudCertificateName_; + std::string aliCloudCertificateId_; + long ownerId_; + std::string accessKeyId_; + std::string tags_; + std::string privateKey_; + std::string resourceGroupId_; + std::string regionId_; + std::string serverCertificateName_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_UPLOADSERVERCERTIFICATEREQUEST_H_ \ No newline at end of file diff --git a/slb/include/alibabacloud/slb/model/UploadServerCertificateResult.h b/slb/include/alibabacloud/slb/model/UploadServerCertificateResult.h new file mode 100644 index 000000000..c982eeae8 --- /dev/null +++ b/slb/include/alibabacloud/slb/model/UploadServerCertificateResult.h @@ -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. + */ + +#ifndef ALIBABACLOUD_SLB_MODEL_UPLOADSERVERCERTIFICATERESULT_H_ +#define ALIBABACLOUD_SLB_MODEL_UPLOADSERVERCERTIFICATERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Slb + { + namespace Model + { + class ALIBABACLOUD_SLB_EXPORT UploadServerCertificateResult : public ServiceResult + { + public: + + + UploadServerCertificateResult(); + explicit UploadServerCertificateResult(const std::string &payload); + ~UploadServerCertificateResult(); + std::string getRegionIdAlias()const; + void setRegionIdAlias(const std::string& regionIdAlias); + std::string getFingerprint()const; + void setFingerprint(const std::string& fingerprint); + std::string getAliCloudCertificateName()const; + void setAliCloudCertificateName(const std::string& aliCloudCertificateName); + std::string getResourceGroupId()const; + void setResourceGroupId(const std::string& resourceGroupId); + int getIsAliCloudCertificate()const; + void setIsAliCloudCertificate(int isAliCloudCertificate); + std::string getCreateTime()const; + void setCreateTime(const std::string& createTime); + std::string getServerCertificateId()const; + void setServerCertificateId(const std::string& serverCertificateId); + std::string getServerCertificateName()const; + void setServerCertificateName(const std::string& serverCertificateName); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + long getCreateTimeStamp()const; + void setCreateTimeStamp(long createTimeStamp); + std::string getAliCloudCertificateId()const; + void setAliCloudCertificateId(const std::string& aliCloudCertificateId); + + protected: + void parse(const std::string &payload); + private: + std::string regionIdAlias_; + std::string fingerprint_; + std::string aliCloudCertificateName_; + std::string resourceGroupId_; + int isAliCloudCertificate_; + std::string createTime_; + std::string serverCertificateId_; + std::string serverCertificateName_; + std::string regionId_; + long createTimeStamp_; + std::string aliCloudCertificateId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SLB_MODEL_UPLOADSERVERCERTIFICATERESULT_H_ \ No newline at end of file diff --git a/slb/src/SlbClient.cc b/slb/src/SlbClient.cc new file mode 100644 index 000000000..72531f3b5 --- /dev/null +++ b/slb/src/SlbClient.cc @@ -0,0 +1,2581 @@ +/* + * 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 +#include + +using namespace AlibabaCloud; +using namespace AlibabaCloud::Location; +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SlbClient::SlbClient(const Credentials &credentials, const ClientConfiguration &configuration) : + RpcServiceClient(std::make_shared(credentials), configuration) +{ + auto locationClient = std::make_shared(credentials, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), "slb"); +} + +SlbClient::SlbClient(const std::shared_ptr& credentialsProvider, const ClientConfiguration & configuration) : + RpcServiceClient(credentialsProvider, configuration) +{ + auto locationClient = std::make_shared(credentialsProvider, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), "slb"); +} + +SlbClient::SlbClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) : + RpcServiceClient(std::make_shared(accessKeyId, accessKeySecret), configuration) +{ + auto locationClient = std::make_shared(accessKeyId, accessKeySecret, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), "slb"); +} + +SlbClient::~SlbClient() +{} + +CoreClient::EndpointOutcome SlbClient::endpoint()const +{ + if(!configuration().endpoint().empty()) + return CoreClient::EndpointOutcome(configuration().endpoint()); + + auto endpoint = endpointProvider_->getEndpoint(); + + if (endpoint.empty()) + return CoreClient::EndpointOutcome(Error("InvalidEndpoint","")); + else + return CoreClient::EndpointOutcome(endpoint); +} + +SlbClient::CreateLoadBalancerUDPListenerOutcome SlbClient::createLoadBalancerUDPListener(const CreateLoadBalancerUDPListenerRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return CreateLoadBalancerUDPListenerOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateLoadBalancerUDPListenerOutcome(CreateLoadBalancerUDPListenerResult(outcome.result())); + else + return CreateLoadBalancerUDPListenerOutcome(outcome.error()); +} + +void SlbClient::createLoadBalancerUDPListenerAsync(const CreateLoadBalancerUDPListenerRequest& request, const CreateLoadBalancerUDPListenerAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createLoadBalancerUDPListener(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::CreateLoadBalancerUDPListenerOutcomeCallable SlbClient::createLoadBalancerUDPListenerCallable(const CreateLoadBalancerUDPListenerRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createLoadBalancerUDPListener(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeMasterSlaveVServerGroupsOutcome SlbClient::describeMasterSlaveVServerGroups(const DescribeMasterSlaveVServerGroupsRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeMasterSlaveVServerGroupsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeMasterSlaveVServerGroupsOutcome(DescribeMasterSlaveVServerGroupsResult(outcome.result())); + else + return DescribeMasterSlaveVServerGroupsOutcome(outcome.error()); +} + +void SlbClient::describeMasterSlaveVServerGroupsAsync(const DescribeMasterSlaveVServerGroupsRequest& request, const DescribeMasterSlaveVServerGroupsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeMasterSlaveVServerGroups(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeMasterSlaveVServerGroupsOutcomeCallable SlbClient::describeMasterSlaveVServerGroupsCallable(const DescribeMasterSlaveVServerGroupsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeMasterSlaveVServerGroups(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::StartLoadBalancerListenerOutcome SlbClient::startLoadBalancerListener(const StartLoadBalancerListenerRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return StartLoadBalancerListenerOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return StartLoadBalancerListenerOutcome(StartLoadBalancerListenerResult(outcome.result())); + else + return StartLoadBalancerListenerOutcome(outcome.error()); +} + +void SlbClient::startLoadBalancerListenerAsync(const StartLoadBalancerListenerRequest& request, const StartLoadBalancerListenerAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, startLoadBalancerListener(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::StartLoadBalancerListenerOutcomeCallable SlbClient::startLoadBalancerListenerCallable(const StartLoadBalancerListenerRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->startLoadBalancerListener(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeLoadBalancerTCPListenerAttributeOutcome SlbClient::describeLoadBalancerTCPListenerAttribute(const DescribeLoadBalancerTCPListenerAttributeRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeLoadBalancerTCPListenerAttributeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeLoadBalancerTCPListenerAttributeOutcome(DescribeLoadBalancerTCPListenerAttributeResult(outcome.result())); + else + return DescribeLoadBalancerTCPListenerAttributeOutcome(outcome.error()); +} + +void SlbClient::describeLoadBalancerTCPListenerAttributeAsync(const DescribeLoadBalancerTCPListenerAttributeRequest& request, const DescribeLoadBalancerTCPListenerAttributeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeLoadBalancerTCPListenerAttribute(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeLoadBalancerTCPListenerAttributeOutcomeCallable SlbClient::describeLoadBalancerTCPListenerAttributeCallable(const DescribeLoadBalancerTCPListenerAttributeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeLoadBalancerTCPListenerAttribute(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeListenerAccessControlAttributeOutcome SlbClient::describeListenerAccessControlAttribute(const DescribeListenerAccessControlAttributeRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeListenerAccessControlAttributeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeListenerAccessControlAttributeOutcome(DescribeListenerAccessControlAttributeResult(outcome.result())); + else + return DescribeListenerAccessControlAttributeOutcome(outcome.error()); +} + +void SlbClient::describeListenerAccessControlAttributeAsync(const DescribeListenerAccessControlAttributeRequest& request, const DescribeListenerAccessControlAttributeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeListenerAccessControlAttribute(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeListenerAccessControlAttributeOutcomeCallable SlbClient::describeListenerAccessControlAttributeCallable(const DescribeListenerAccessControlAttributeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeListenerAccessControlAttribute(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::StopLoadBalancerListenerOutcome SlbClient::stopLoadBalancerListener(const StopLoadBalancerListenerRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return StopLoadBalancerListenerOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return StopLoadBalancerListenerOutcome(StopLoadBalancerListenerResult(outcome.result())); + else + return StopLoadBalancerListenerOutcome(outcome.error()); +} + +void SlbClient::stopLoadBalancerListenerAsync(const StopLoadBalancerListenerRequest& request, const StopLoadBalancerListenerAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, stopLoadBalancerListener(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::StopLoadBalancerListenerOutcomeCallable SlbClient::stopLoadBalancerListenerCallable(const StopLoadBalancerListenerRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->stopLoadBalancerListener(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::SetLoadBalancerStatusOutcome SlbClient::setLoadBalancerStatus(const SetLoadBalancerStatusRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return SetLoadBalancerStatusOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return SetLoadBalancerStatusOutcome(SetLoadBalancerStatusResult(outcome.result())); + else + return SetLoadBalancerStatusOutcome(outcome.error()); +} + +void SlbClient::setLoadBalancerStatusAsync(const SetLoadBalancerStatusRequest& request, const SetLoadBalancerStatusAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, setLoadBalancerStatus(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::SetLoadBalancerStatusOutcomeCallable SlbClient::setLoadBalancerStatusCallable(const SetLoadBalancerStatusRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->setLoadBalancerStatus(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::ModifyLoadBalancerInstanceSpecOutcome SlbClient::modifyLoadBalancerInstanceSpec(const ModifyLoadBalancerInstanceSpecRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return ModifyLoadBalancerInstanceSpecOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ModifyLoadBalancerInstanceSpecOutcome(ModifyLoadBalancerInstanceSpecResult(outcome.result())); + else + return ModifyLoadBalancerInstanceSpecOutcome(outcome.error()); +} + +void SlbClient::modifyLoadBalancerInstanceSpecAsync(const ModifyLoadBalancerInstanceSpecRequest& request, const ModifyLoadBalancerInstanceSpecAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, modifyLoadBalancerInstanceSpec(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::ModifyLoadBalancerInstanceSpecOutcomeCallable SlbClient::modifyLoadBalancerInstanceSpecCallable(const ModifyLoadBalancerInstanceSpecRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->modifyLoadBalancerInstanceSpec(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::MoveResourceGroupOutcome SlbClient::moveResourceGroup(const MoveResourceGroupRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return MoveResourceGroupOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return MoveResourceGroupOutcome(MoveResourceGroupResult(outcome.result())); + else + return MoveResourceGroupOutcome(outcome.error()); +} + +void SlbClient::moveResourceGroupAsync(const MoveResourceGroupRequest& request, const MoveResourceGroupAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, moveResourceGroup(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::MoveResourceGroupOutcomeCallable SlbClient::moveResourceGroupCallable(const MoveResourceGroupRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->moveResourceGroup(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::SetLoadBalancerTCPListenerAttributeOutcome SlbClient::setLoadBalancerTCPListenerAttribute(const SetLoadBalancerTCPListenerAttributeRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return SetLoadBalancerTCPListenerAttributeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return SetLoadBalancerTCPListenerAttributeOutcome(SetLoadBalancerTCPListenerAttributeResult(outcome.result())); + else + return SetLoadBalancerTCPListenerAttributeOutcome(outcome.error()); +} + +void SlbClient::setLoadBalancerTCPListenerAttributeAsync(const SetLoadBalancerTCPListenerAttributeRequest& request, const SetLoadBalancerTCPListenerAttributeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, setLoadBalancerTCPListenerAttribute(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::SetLoadBalancerTCPListenerAttributeOutcomeCallable SlbClient::setLoadBalancerTCPListenerAttributeCallable(const SetLoadBalancerTCPListenerAttributeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->setLoadBalancerTCPListenerAttribute(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DeleteVServerGroupOutcome SlbClient::deleteVServerGroup(const DeleteVServerGroupRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteVServerGroupOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteVServerGroupOutcome(DeleteVServerGroupResult(outcome.result())); + else + return DeleteVServerGroupOutcome(outcome.error()); +} + +void SlbClient::deleteVServerGroupAsync(const DeleteVServerGroupRequest& request, const DeleteVServerGroupAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteVServerGroup(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DeleteVServerGroupOutcomeCallable SlbClient::deleteVServerGroupCallable(const DeleteVServerGroupRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteVServerGroup(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeVServerGroupAttributeOutcome SlbClient::describeVServerGroupAttribute(const DescribeVServerGroupAttributeRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeVServerGroupAttributeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeVServerGroupAttributeOutcome(DescribeVServerGroupAttributeResult(outcome.result())); + else + return DescribeVServerGroupAttributeOutcome(outcome.error()); +} + +void SlbClient::describeVServerGroupAttributeAsync(const DescribeVServerGroupAttributeRequest& request, const DescribeVServerGroupAttributeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeVServerGroupAttribute(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeVServerGroupAttributeOutcomeCallable SlbClient::describeVServerGroupAttributeCallable(const DescribeVServerGroupAttributeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeVServerGroupAttribute(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::AddListenerWhiteListItemOutcome SlbClient::addListenerWhiteListItem(const AddListenerWhiteListItemRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return AddListenerWhiteListItemOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return AddListenerWhiteListItemOutcome(AddListenerWhiteListItemResult(outcome.result())); + else + return AddListenerWhiteListItemOutcome(outcome.error()); +} + +void SlbClient::addListenerWhiteListItemAsync(const AddListenerWhiteListItemRequest& request, const AddListenerWhiteListItemAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, addListenerWhiteListItem(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::AddListenerWhiteListItemOutcomeCallable SlbClient::addListenerWhiteListItemCallable(const AddListenerWhiteListItemRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->addListenerWhiteListItem(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::RemoveTagsOutcome SlbClient::removeTags(const RemoveTagsRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return RemoveTagsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return RemoveTagsOutcome(RemoveTagsResult(outcome.result())); + else + return RemoveTagsOutcome(outcome.error()); +} + +void SlbClient::removeTagsAsync(const RemoveTagsRequest& request, const RemoveTagsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, removeTags(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::RemoveTagsOutcomeCallable SlbClient::removeTagsCallable(const RemoveTagsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->removeTags(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::CreateLoadBalancerOutcome SlbClient::createLoadBalancer(const CreateLoadBalancerRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return CreateLoadBalancerOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateLoadBalancerOutcome(CreateLoadBalancerResult(outcome.result())); + else + return CreateLoadBalancerOutcome(outcome.error()); +} + +void SlbClient::createLoadBalancerAsync(const CreateLoadBalancerRequest& request, const CreateLoadBalancerAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createLoadBalancer(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::CreateLoadBalancerOutcomeCallable SlbClient::createLoadBalancerCallable(const CreateLoadBalancerRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createLoadBalancer(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::SetLoadBalancerHTTPListenerAttributeOutcome SlbClient::setLoadBalancerHTTPListenerAttribute(const SetLoadBalancerHTTPListenerAttributeRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return SetLoadBalancerHTTPListenerAttributeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return SetLoadBalancerHTTPListenerAttributeOutcome(SetLoadBalancerHTTPListenerAttributeResult(outcome.result())); + else + return SetLoadBalancerHTTPListenerAttributeOutcome(outcome.error()); +} + +void SlbClient::setLoadBalancerHTTPListenerAttributeAsync(const SetLoadBalancerHTTPListenerAttributeRequest& request, const SetLoadBalancerHTTPListenerAttributeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, setLoadBalancerHTTPListenerAttribute(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::SetLoadBalancerHTTPListenerAttributeOutcomeCallable SlbClient::setLoadBalancerHTTPListenerAttributeCallable(const SetLoadBalancerHTTPListenerAttributeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->setLoadBalancerHTTPListenerAttribute(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::SetLoadBalancerAutoReleaseTimeOutcome SlbClient::setLoadBalancerAutoReleaseTime(const SetLoadBalancerAutoReleaseTimeRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return SetLoadBalancerAutoReleaseTimeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return SetLoadBalancerAutoReleaseTimeOutcome(SetLoadBalancerAutoReleaseTimeResult(outcome.result())); + else + return SetLoadBalancerAutoReleaseTimeOutcome(outcome.error()); +} + +void SlbClient::setLoadBalancerAutoReleaseTimeAsync(const SetLoadBalancerAutoReleaseTimeRequest& request, const SetLoadBalancerAutoReleaseTimeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, setLoadBalancerAutoReleaseTime(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::SetLoadBalancerAutoReleaseTimeOutcomeCallable SlbClient::setLoadBalancerAutoReleaseTimeCallable(const SetLoadBalancerAutoReleaseTimeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->setLoadBalancerAutoReleaseTime(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::SetListenerAccessControlStatusOutcome SlbClient::setListenerAccessControlStatus(const SetListenerAccessControlStatusRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return SetListenerAccessControlStatusOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return SetListenerAccessControlStatusOutcome(SetListenerAccessControlStatusResult(outcome.result())); + else + return SetListenerAccessControlStatusOutcome(outcome.error()); +} + +void SlbClient::setListenerAccessControlStatusAsync(const SetListenerAccessControlStatusRequest& request, const SetListenerAccessControlStatusAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, setListenerAccessControlStatus(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::SetListenerAccessControlStatusOutcomeCallable SlbClient::setListenerAccessControlStatusCallable(const SetListenerAccessControlStatusRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->setListenerAccessControlStatus(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::UploadCACertificateOutcome SlbClient::uploadCACertificate(const UploadCACertificateRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return UploadCACertificateOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UploadCACertificateOutcome(UploadCACertificateResult(outcome.result())); + else + return UploadCACertificateOutcome(outcome.error()); +} + +void SlbClient::uploadCACertificateAsync(const UploadCACertificateRequest& request, const UploadCACertificateAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, uploadCACertificate(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::UploadCACertificateOutcomeCallable SlbClient::uploadCACertificateCallable(const UploadCACertificateRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->uploadCACertificate(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeZonesOutcome SlbClient::describeZones(const DescribeZonesRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeZonesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeZonesOutcome(DescribeZonesResult(outcome.result())); + else + return DescribeZonesOutcome(outcome.error()); +} + +void SlbClient::describeZonesAsync(const DescribeZonesRequest& request, const DescribeZonesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeZones(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeZonesOutcomeCallable SlbClient::describeZonesCallable(const DescribeZonesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeZones(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::SetLoadBalancerHTTPSListenerAttributeOutcome SlbClient::setLoadBalancerHTTPSListenerAttribute(const SetLoadBalancerHTTPSListenerAttributeRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return SetLoadBalancerHTTPSListenerAttributeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return SetLoadBalancerHTTPSListenerAttributeOutcome(SetLoadBalancerHTTPSListenerAttributeResult(outcome.result())); + else + return SetLoadBalancerHTTPSListenerAttributeOutcome(outcome.error()); +} + +void SlbClient::setLoadBalancerHTTPSListenerAttributeAsync(const SetLoadBalancerHTTPSListenerAttributeRequest& request, const SetLoadBalancerHTTPSListenerAttributeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, setLoadBalancerHTTPSListenerAttribute(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::SetLoadBalancerHTTPSListenerAttributeOutcomeCallable SlbClient::setLoadBalancerHTTPSListenerAttributeCallable(const SetLoadBalancerHTTPSListenerAttributeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->setLoadBalancerHTTPSListenerAttribute(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DeleteLoadBalancerListenerOutcome SlbClient::deleteLoadBalancerListener(const DeleteLoadBalancerListenerRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteLoadBalancerListenerOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteLoadBalancerListenerOutcome(DeleteLoadBalancerListenerResult(outcome.result())); + else + return DeleteLoadBalancerListenerOutcome(outcome.error()); +} + +void SlbClient::deleteLoadBalancerListenerAsync(const DeleteLoadBalancerListenerRequest& request, const DeleteLoadBalancerListenerAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteLoadBalancerListener(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DeleteLoadBalancerListenerOutcomeCallable SlbClient::deleteLoadBalancerListenerCallable(const DeleteLoadBalancerListenerRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteLoadBalancerListener(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeVServerGroupsOutcome SlbClient::describeVServerGroups(const DescribeVServerGroupsRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeVServerGroupsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeVServerGroupsOutcome(DescribeVServerGroupsResult(outcome.result())); + else + return DescribeVServerGroupsOutcome(outcome.error()); +} + +void SlbClient::describeVServerGroupsAsync(const DescribeVServerGroupsRequest& request, const DescribeVServerGroupsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeVServerGroups(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeVServerGroupsOutcomeCallable SlbClient::describeVServerGroupsCallable(const DescribeVServerGroupsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeVServerGroups(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeLoadBalancerHTTPListenerAttributeOutcome SlbClient::describeLoadBalancerHTTPListenerAttribute(const DescribeLoadBalancerHTTPListenerAttributeRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeLoadBalancerHTTPListenerAttributeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeLoadBalancerHTTPListenerAttributeOutcome(DescribeLoadBalancerHTTPListenerAttributeResult(outcome.result())); + else + return DescribeLoadBalancerHTTPListenerAttributeOutcome(outcome.error()); +} + +void SlbClient::describeLoadBalancerHTTPListenerAttributeAsync(const DescribeLoadBalancerHTTPListenerAttributeRequest& request, const DescribeLoadBalancerHTTPListenerAttributeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeLoadBalancerHTTPListenerAttribute(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeLoadBalancerHTTPListenerAttributeOutcomeCallable SlbClient::describeLoadBalancerHTTPListenerAttributeCallable(const DescribeLoadBalancerHTTPListenerAttributeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeLoadBalancerHTTPListenerAttribute(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeTagsOutcome SlbClient::describeTags(const DescribeTagsRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeTagsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeTagsOutcome(DescribeTagsResult(outcome.result())); + else + return DescribeTagsOutcome(outcome.error()); +} + +void SlbClient::describeTagsAsync(const DescribeTagsRequest& request, const DescribeTagsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeTags(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeTagsOutcomeCallable SlbClient::describeTagsCallable(const DescribeTagsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeTags(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DeleteLoadBalancerOutcome SlbClient::deleteLoadBalancer(const DeleteLoadBalancerRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteLoadBalancerOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteLoadBalancerOutcome(DeleteLoadBalancerResult(outcome.result())); + else + return DeleteLoadBalancerOutcome(outcome.error()); +} + +void SlbClient::deleteLoadBalancerAsync(const DeleteLoadBalancerRequest& request, const DeleteLoadBalancerAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteLoadBalancer(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DeleteLoadBalancerOutcomeCallable SlbClient::deleteLoadBalancerCallable(const DeleteLoadBalancerRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteLoadBalancer(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::CreateVServerGroupOutcome SlbClient::createVServerGroup(const CreateVServerGroupRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return CreateVServerGroupOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateVServerGroupOutcome(CreateVServerGroupResult(outcome.result())); + else + return CreateVServerGroupOutcome(outcome.error()); +} + +void SlbClient::createVServerGroupAsync(const CreateVServerGroupRequest& request, const CreateVServerGroupAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createVServerGroup(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::CreateVServerGroupOutcomeCallable SlbClient::createVServerGroupCallable(const CreateVServerGroupRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createVServerGroup(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeLoadBalancersRelatedEcsOutcome SlbClient::describeLoadBalancersRelatedEcs(const DescribeLoadBalancersRelatedEcsRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeLoadBalancersRelatedEcsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeLoadBalancersRelatedEcsOutcome(DescribeLoadBalancersRelatedEcsResult(outcome.result())); + else + return DescribeLoadBalancersRelatedEcsOutcome(outcome.error()); +} + +void SlbClient::describeLoadBalancersRelatedEcsAsync(const DescribeLoadBalancersRelatedEcsRequest& request, const DescribeLoadBalancersRelatedEcsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeLoadBalancersRelatedEcs(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeLoadBalancersRelatedEcsOutcomeCallable SlbClient::describeLoadBalancersRelatedEcsCallable(const DescribeLoadBalancersRelatedEcsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeLoadBalancersRelatedEcs(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeLoadBalancersOutcome SlbClient::describeLoadBalancers(const DescribeLoadBalancersRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeLoadBalancersOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeLoadBalancersOutcome(DescribeLoadBalancersResult(outcome.result())); + else + return DescribeLoadBalancersOutcome(outcome.error()); +} + +void SlbClient::describeLoadBalancersAsync(const DescribeLoadBalancersRequest& request, const DescribeLoadBalancersAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeLoadBalancers(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeLoadBalancersOutcomeCallable SlbClient::describeLoadBalancersCallable(const DescribeLoadBalancersRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeLoadBalancers(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::SetCACertificateNameOutcome SlbClient::setCACertificateName(const SetCACertificateNameRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return SetCACertificateNameOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return SetCACertificateNameOutcome(SetCACertificateNameResult(outcome.result())); + else + return SetCACertificateNameOutcome(outcome.error()); +} + +void SlbClient::setCACertificateNameAsync(const SetCACertificateNameRequest& request, const SetCACertificateNameAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, setCACertificateName(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::SetCACertificateNameOutcomeCallable SlbClient::setCACertificateNameCallable(const SetCACertificateNameRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->setCACertificateName(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeMasterSlaveVServerGroupAttributeOutcome SlbClient::describeMasterSlaveVServerGroupAttribute(const DescribeMasterSlaveVServerGroupAttributeRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeMasterSlaveVServerGroupAttributeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeMasterSlaveVServerGroupAttributeOutcome(DescribeMasterSlaveVServerGroupAttributeResult(outcome.result())); + else + return DescribeMasterSlaveVServerGroupAttributeOutcome(outcome.error()); +} + +void SlbClient::describeMasterSlaveVServerGroupAttributeAsync(const DescribeMasterSlaveVServerGroupAttributeRequest& request, const DescribeMasterSlaveVServerGroupAttributeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeMasterSlaveVServerGroupAttribute(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeMasterSlaveVServerGroupAttributeOutcomeCallable SlbClient::describeMasterSlaveVServerGroupAttributeCallable(const DescribeMasterSlaveVServerGroupAttributeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeMasterSlaveVServerGroupAttribute(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::CreateLoadBalancerHTTPListenerOutcome SlbClient::createLoadBalancerHTTPListener(const CreateLoadBalancerHTTPListenerRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return CreateLoadBalancerHTTPListenerOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateLoadBalancerHTTPListenerOutcome(CreateLoadBalancerHTTPListenerResult(outcome.result())); + else + return CreateLoadBalancerHTTPListenerOutcome(outcome.error()); +} + +void SlbClient::createLoadBalancerHTTPListenerAsync(const CreateLoadBalancerHTTPListenerRequest& request, const CreateLoadBalancerHTTPListenerAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createLoadBalancerHTTPListener(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::CreateLoadBalancerHTTPListenerOutcomeCallable SlbClient::createLoadBalancerHTTPListenerCallable(const CreateLoadBalancerHTTPListenerRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createLoadBalancerHTTPListener(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::RemoveBackendServersOutcome SlbClient::removeBackendServers(const RemoveBackendServersRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return RemoveBackendServersOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return RemoveBackendServersOutcome(RemoveBackendServersResult(outcome.result())); + else + return RemoveBackendServersOutcome(outcome.error()); +} + +void SlbClient::removeBackendServersAsync(const RemoveBackendServersRequest& request, const RemoveBackendServersAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, removeBackendServers(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::RemoveBackendServersOutcomeCallable SlbClient::removeBackendServersCallable(const RemoveBackendServersRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->removeBackendServers(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::ModifyVServerGroupBackendServersOutcome SlbClient::modifyVServerGroupBackendServers(const ModifyVServerGroupBackendServersRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return ModifyVServerGroupBackendServersOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ModifyVServerGroupBackendServersOutcome(ModifyVServerGroupBackendServersResult(outcome.result())); + else + return ModifyVServerGroupBackendServersOutcome(outcome.error()); +} + +void SlbClient::modifyVServerGroupBackendServersAsync(const ModifyVServerGroupBackendServersRequest& request, const ModifyVServerGroupBackendServersAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, modifyVServerGroupBackendServers(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::ModifyVServerGroupBackendServersOutcomeCallable SlbClient::modifyVServerGroupBackendServersCallable(const ModifyVServerGroupBackendServersRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->modifyVServerGroupBackendServers(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeLoadBalancerUDPListenerAttributeOutcome SlbClient::describeLoadBalancerUDPListenerAttribute(const DescribeLoadBalancerUDPListenerAttributeRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeLoadBalancerUDPListenerAttributeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeLoadBalancerUDPListenerAttributeOutcome(DescribeLoadBalancerUDPListenerAttributeResult(outcome.result())); + else + return DescribeLoadBalancerUDPListenerAttributeOutcome(outcome.error()); +} + +void SlbClient::describeLoadBalancerUDPListenerAttributeAsync(const DescribeLoadBalancerUDPListenerAttributeRequest& request, const DescribeLoadBalancerUDPListenerAttributeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeLoadBalancerUDPListenerAttribute(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeLoadBalancerUDPListenerAttributeOutcomeCallable SlbClient::describeLoadBalancerUDPListenerAttributeCallable(const DescribeLoadBalancerUDPListenerAttributeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeLoadBalancerUDPListenerAttribute(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DeleteRulesOutcome SlbClient::deleteRules(const DeleteRulesRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteRulesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteRulesOutcome(DeleteRulesResult(outcome.result())); + else + return DeleteRulesOutcome(outcome.error()); +} + +void SlbClient::deleteRulesAsync(const DeleteRulesRequest& request, const DeleteRulesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteRules(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DeleteRulesOutcomeCallable SlbClient::deleteRulesCallable(const DeleteRulesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteRules(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DeleteMasterSlaveVServerGroupOutcome SlbClient::deleteMasterSlaveVServerGroup(const DeleteMasterSlaveVServerGroupRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteMasterSlaveVServerGroupOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteMasterSlaveVServerGroupOutcome(DeleteMasterSlaveVServerGroupResult(outcome.result())); + else + return DeleteMasterSlaveVServerGroupOutcome(outcome.error()); +} + +void SlbClient::deleteMasterSlaveVServerGroupAsync(const DeleteMasterSlaveVServerGroupRequest& request, const DeleteMasterSlaveVServerGroupAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteMasterSlaveVServerGroup(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DeleteMasterSlaveVServerGroupOutcomeCallable SlbClient::deleteMasterSlaveVServerGroupCallable(const DeleteMasterSlaveVServerGroupRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteMasterSlaveVServerGroup(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeCACertificatesOutcome SlbClient::describeCACertificates(const DescribeCACertificatesRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeCACertificatesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeCACertificatesOutcome(DescribeCACertificatesResult(outcome.result())); + else + return DescribeCACertificatesOutcome(outcome.error()); +} + +void SlbClient::describeCACertificatesAsync(const DescribeCACertificatesRequest& request, const DescribeCACertificatesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeCACertificates(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeCACertificatesOutcomeCallable SlbClient::describeCACertificatesCallable(const DescribeCACertificatesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeCACertificates(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::CreateMasterSlaveVServerGroupOutcome SlbClient::createMasterSlaveVServerGroup(const CreateMasterSlaveVServerGroupRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return CreateMasterSlaveVServerGroupOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateMasterSlaveVServerGroupOutcome(CreateMasterSlaveVServerGroupResult(outcome.result())); + else + return CreateMasterSlaveVServerGroupOutcome(outcome.error()); +} + +void SlbClient::createMasterSlaveVServerGroupAsync(const CreateMasterSlaveVServerGroupRequest& request, const CreateMasterSlaveVServerGroupAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createMasterSlaveVServerGroup(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::CreateMasterSlaveVServerGroupOutcomeCallable SlbClient::createMasterSlaveVServerGroupCallable(const CreateMasterSlaveVServerGroupRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createMasterSlaveVServerGroup(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::SetBackendServersOutcome SlbClient::setBackendServers(const SetBackendServersRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return SetBackendServersOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return SetBackendServersOutcome(SetBackendServersResult(outcome.result())); + else + return SetBackendServersOutcome(outcome.error()); +} + +void SlbClient::setBackendServersAsync(const SetBackendServersRequest& request, const SetBackendServersAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, setBackendServers(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::SetBackendServersOutcomeCallable SlbClient::setBackendServersCallable(const SetBackendServersRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->setBackendServers(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::RemoveVServerGroupBackendServersOutcome SlbClient::removeVServerGroupBackendServers(const RemoveVServerGroupBackendServersRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return RemoveVServerGroupBackendServersOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return RemoveVServerGroupBackendServersOutcome(RemoveVServerGroupBackendServersResult(outcome.result())); + else + return RemoveVServerGroupBackendServersOutcome(outcome.error()); +} + +void SlbClient::removeVServerGroupBackendServersAsync(const RemoveVServerGroupBackendServersRequest& request, const RemoveVServerGroupBackendServersAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, removeVServerGroupBackendServers(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::RemoveVServerGroupBackendServersOutcomeCallable SlbClient::removeVServerGroupBackendServersCallable(const RemoveVServerGroupBackendServersRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->removeVServerGroupBackendServers(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeLoadBalancerAttributeOutcome SlbClient::describeLoadBalancerAttribute(const DescribeLoadBalancerAttributeRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeLoadBalancerAttributeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeLoadBalancerAttributeOutcome(DescribeLoadBalancerAttributeResult(outcome.result())); + else + return DescribeLoadBalancerAttributeOutcome(outcome.error()); +} + +void SlbClient::describeLoadBalancerAttributeAsync(const DescribeLoadBalancerAttributeRequest& request, const DescribeLoadBalancerAttributeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeLoadBalancerAttribute(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeLoadBalancerAttributeOutcomeCallable SlbClient::describeLoadBalancerAttributeCallable(const DescribeLoadBalancerAttributeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeLoadBalancerAttribute(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::CreateMasterSlaveServerGroupOutcome SlbClient::createMasterSlaveServerGroup(const CreateMasterSlaveServerGroupRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return CreateMasterSlaveServerGroupOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateMasterSlaveServerGroupOutcome(CreateMasterSlaveServerGroupResult(outcome.result())); + else + return CreateMasterSlaveServerGroupOutcome(outcome.error()); +} + +void SlbClient::createMasterSlaveServerGroupAsync(const CreateMasterSlaveServerGroupRequest& request, const CreateMasterSlaveServerGroupAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createMasterSlaveServerGroup(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::CreateMasterSlaveServerGroupOutcomeCallable SlbClient::createMasterSlaveServerGroupCallable(const CreateMasterSlaveServerGroupRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createMasterSlaveServerGroup(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::SetServerCertificateNameOutcome SlbClient::setServerCertificateName(const SetServerCertificateNameRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return SetServerCertificateNameOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return SetServerCertificateNameOutcome(SetServerCertificateNameResult(outcome.result())); + else + return SetServerCertificateNameOutcome(outcome.error()); +} + +void SlbClient::setServerCertificateNameAsync(const SetServerCertificateNameRequest& request, const SetServerCertificateNameAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, setServerCertificateName(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::SetServerCertificateNameOutcomeCallable SlbClient::setServerCertificateNameCallable(const SetServerCertificateNameRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->setServerCertificateName(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DeleteCACertificateOutcome SlbClient::deleteCACertificate(const DeleteCACertificateRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteCACertificateOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteCACertificateOutcome(DeleteCACertificateResult(outcome.result())); + else + return DeleteCACertificateOutcome(outcome.error()); +} + +void SlbClient::deleteCACertificateAsync(const DeleteCACertificateRequest& request, const DeleteCACertificateAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteCACertificate(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DeleteCACertificateOutcomeCallable SlbClient::deleteCACertificateCallable(const DeleteCACertificateRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteCACertificate(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::CreateLoadBalancerTCPListenerOutcome SlbClient::createLoadBalancerTCPListener(const CreateLoadBalancerTCPListenerRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return CreateLoadBalancerTCPListenerOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateLoadBalancerTCPListenerOutcome(CreateLoadBalancerTCPListenerResult(outcome.result())); + else + return CreateLoadBalancerTCPListenerOutcome(outcome.error()); +} + +void SlbClient::createLoadBalancerTCPListenerAsync(const CreateLoadBalancerTCPListenerRequest& request, const CreateLoadBalancerTCPListenerAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createLoadBalancerTCPListener(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::CreateLoadBalancerTCPListenerOutcomeCallable SlbClient::createLoadBalancerTCPListenerCallable(const CreateLoadBalancerTCPListenerRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createLoadBalancerTCPListener(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::SetRuleOutcome SlbClient::setRule(const SetRuleRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return SetRuleOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return SetRuleOutcome(SetRuleResult(outcome.result())); + else + return SetRuleOutcome(outcome.error()); +} + +void SlbClient::setRuleAsync(const SetRuleRequest& request, const SetRuleAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, setRule(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::SetRuleOutcomeCallable SlbClient::setRuleCallable(const SetRuleRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->setRule(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeMasterSlaveServerGroupsOutcome SlbClient::describeMasterSlaveServerGroups(const DescribeMasterSlaveServerGroupsRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeMasterSlaveServerGroupsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeMasterSlaveServerGroupsOutcome(DescribeMasterSlaveServerGroupsResult(outcome.result())); + else + return DescribeMasterSlaveServerGroupsOutcome(outcome.error()); +} + +void SlbClient::describeMasterSlaveServerGroupsAsync(const DescribeMasterSlaveServerGroupsRequest& request, const DescribeMasterSlaveServerGroupsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeMasterSlaveServerGroups(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeMasterSlaveServerGroupsOutcomeCallable SlbClient::describeMasterSlaveServerGroupsCallable(const DescribeMasterSlaveServerGroupsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeMasterSlaveServerGroups(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeHealthStatusOutcome SlbClient::describeHealthStatus(const DescribeHealthStatusRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeHealthStatusOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeHealthStatusOutcome(DescribeHealthStatusResult(outcome.result())); + else + return DescribeHealthStatusOutcome(outcome.error()); +} + +void SlbClient::describeHealthStatusAsync(const DescribeHealthStatusRequest& request, const DescribeHealthStatusAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeHealthStatus(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeHealthStatusOutcomeCallable SlbClient::describeHealthStatusCallable(const DescribeHealthStatusRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeHealthStatus(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeRegionsOutcome SlbClient::describeRegions(const DescribeRegionsRequest &request) const +{ + auto endpointOutcome = endpoint(); + 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 SlbClient::describeRegionsAsync(const DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeRegions(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeRegionsOutcomeCallable SlbClient::describeRegionsCallable(const DescribeRegionsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeRegions(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::RemoveListenerWhiteListItemOutcome SlbClient::removeListenerWhiteListItem(const RemoveListenerWhiteListItemRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return RemoveListenerWhiteListItemOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return RemoveListenerWhiteListItemOutcome(RemoveListenerWhiteListItemResult(outcome.result())); + else + return RemoveListenerWhiteListItemOutcome(outcome.error()); +} + +void SlbClient::removeListenerWhiteListItemAsync(const RemoveListenerWhiteListItemRequest& request, const RemoveListenerWhiteListItemAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, removeListenerWhiteListItem(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::RemoveListenerWhiteListItemOutcomeCallable SlbClient::removeListenerWhiteListItemCallable(const RemoveListenerWhiteListItemRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->removeListenerWhiteListItem(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::CreateLoadBalancerHTTPSListenerOutcome SlbClient::createLoadBalancerHTTPSListener(const CreateLoadBalancerHTTPSListenerRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return CreateLoadBalancerHTTPSListenerOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateLoadBalancerHTTPSListenerOutcome(CreateLoadBalancerHTTPSListenerResult(outcome.result())); + else + return CreateLoadBalancerHTTPSListenerOutcome(outcome.error()); +} + +void SlbClient::createLoadBalancerHTTPSListenerAsync(const CreateLoadBalancerHTTPSListenerRequest& request, const CreateLoadBalancerHTTPSListenerAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createLoadBalancerHTTPSListener(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::CreateLoadBalancerHTTPSListenerOutcomeCallable SlbClient::createLoadBalancerHTTPSListenerCallable(const CreateLoadBalancerHTTPSListenerRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createLoadBalancerHTTPSListener(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DeleteMasterSlaveServerGroupOutcome SlbClient::deleteMasterSlaveServerGroup(const DeleteMasterSlaveServerGroupRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteMasterSlaveServerGroupOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteMasterSlaveServerGroupOutcome(DeleteMasterSlaveServerGroupResult(outcome.result())); + else + return DeleteMasterSlaveServerGroupOutcome(outcome.error()); +} + +void SlbClient::deleteMasterSlaveServerGroupAsync(const DeleteMasterSlaveServerGroupRequest& request, const DeleteMasterSlaveServerGroupAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteMasterSlaveServerGroup(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DeleteMasterSlaveServerGroupOutcomeCallable SlbClient::deleteMasterSlaveServerGroupCallable(const DeleteMasterSlaveServerGroupRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteMasterSlaveServerGroup(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeServerCertificatesOutcome SlbClient::describeServerCertificates(const DescribeServerCertificatesRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeServerCertificatesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeServerCertificatesOutcome(DescribeServerCertificatesResult(outcome.result())); + else + return DescribeServerCertificatesOutcome(outcome.error()); +} + +void SlbClient::describeServerCertificatesAsync(const DescribeServerCertificatesRequest& request, const DescribeServerCertificatesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeServerCertificates(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeServerCertificatesOutcomeCallable SlbClient::describeServerCertificatesCallable(const DescribeServerCertificatesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeServerCertificates(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeRulesOutcome SlbClient::describeRules(const DescribeRulesRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeRulesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeRulesOutcome(DescribeRulesResult(outcome.result())); + else + return DescribeRulesOutcome(outcome.error()); +} + +void SlbClient::describeRulesAsync(const DescribeRulesRequest& request, const DescribeRulesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeRules(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeRulesOutcomeCallable SlbClient::describeRulesCallable(const DescribeRulesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeRules(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeRuleAttributeOutcome SlbClient::describeRuleAttribute(const DescribeRuleAttributeRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeRuleAttributeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeRuleAttributeOutcome(DescribeRuleAttributeResult(outcome.result())); + else + return DescribeRuleAttributeOutcome(outcome.error()); +} + +void SlbClient::describeRuleAttributeAsync(const DescribeRuleAttributeRequest& request, const DescribeRuleAttributeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeRuleAttribute(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeRuleAttributeOutcomeCallable SlbClient::describeRuleAttributeCallable(const DescribeRuleAttributeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeRuleAttribute(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::UploadServerCertificateOutcome SlbClient::uploadServerCertificate(const UploadServerCertificateRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return UploadServerCertificateOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UploadServerCertificateOutcome(UploadServerCertificateResult(outcome.result())); + else + return UploadServerCertificateOutcome(outcome.error()); +} + +void SlbClient::uploadServerCertificateAsync(const UploadServerCertificateRequest& request, const UploadServerCertificateAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, uploadServerCertificate(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::UploadServerCertificateOutcomeCallable SlbClient::uploadServerCertificateCallable(const UploadServerCertificateRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->uploadServerCertificate(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeLoadBalancerAutoReleaseTimeOutcome SlbClient::describeLoadBalancerAutoReleaseTime(const DescribeLoadBalancerAutoReleaseTimeRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeLoadBalancerAutoReleaseTimeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeLoadBalancerAutoReleaseTimeOutcome(DescribeLoadBalancerAutoReleaseTimeResult(outcome.result())); + else + return DescribeLoadBalancerAutoReleaseTimeOutcome(outcome.error()); +} + +void SlbClient::describeLoadBalancerAutoReleaseTimeAsync(const DescribeLoadBalancerAutoReleaseTimeRequest& request, const DescribeLoadBalancerAutoReleaseTimeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeLoadBalancerAutoReleaseTime(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeLoadBalancerAutoReleaseTimeOutcomeCallable SlbClient::describeLoadBalancerAutoReleaseTimeCallable(const DescribeLoadBalancerAutoReleaseTimeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeLoadBalancerAutoReleaseTime(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DeleteServerCertificateOutcome SlbClient::deleteServerCertificate(const DeleteServerCertificateRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteServerCertificateOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteServerCertificateOutcome(DeleteServerCertificateResult(outcome.result())); + else + return DeleteServerCertificateOutcome(outcome.error()); +} + +void SlbClient::deleteServerCertificateAsync(const DeleteServerCertificateRequest& request, const DeleteServerCertificateAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteServerCertificate(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DeleteServerCertificateOutcomeCallable SlbClient::deleteServerCertificateCallable(const DeleteServerCertificateRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteServerCertificate(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::SetLoadBalancerNameOutcome SlbClient::setLoadBalancerName(const SetLoadBalancerNameRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return SetLoadBalancerNameOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return SetLoadBalancerNameOutcome(SetLoadBalancerNameResult(outcome.result())); + else + return SetLoadBalancerNameOutcome(outcome.error()); +} + +void SlbClient::setLoadBalancerNameAsync(const SetLoadBalancerNameRequest& request, const SetLoadBalancerNameAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, setLoadBalancerName(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::SetLoadBalancerNameOutcomeCallable SlbClient::setLoadBalancerNameCallable(const SetLoadBalancerNameRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->setLoadBalancerName(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::SetVServerGroupAttributeOutcome SlbClient::setVServerGroupAttribute(const SetVServerGroupAttributeRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return SetVServerGroupAttributeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return SetVServerGroupAttributeOutcome(SetVServerGroupAttributeResult(outcome.result())); + else + return SetVServerGroupAttributeOutcome(outcome.error()); +} + +void SlbClient::setVServerGroupAttributeAsync(const SetVServerGroupAttributeRequest& request, const SetVServerGroupAttributeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, setVServerGroupAttribute(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::SetVServerGroupAttributeOutcomeCallable SlbClient::setVServerGroupAttributeCallable(const SetVServerGroupAttributeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->setVServerGroupAttribute(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::ModifyLoadBalancerInternetSpecOutcome SlbClient::modifyLoadBalancerInternetSpec(const ModifyLoadBalancerInternetSpecRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return ModifyLoadBalancerInternetSpecOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ModifyLoadBalancerInternetSpecOutcome(ModifyLoadBalancerInternetSpecResult(outcome.result())); + else + return ModifyLoadBalancerInternetSpecOutcome(outcome.error()); +} + +void SlbClient::modifyLoadBalancerInternetSpecAsync(const ModifyLoadBalancerInternetSpecRequest& request, const ModifyLoadBalancerInternetSpecAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, modifyLoadBalancerInternetSpec(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::ModifyLoadBalancerInternetSpecOutcomeCallable SlbClient::modifyLoadBalancerInternetSpecCallable(const ModifyLoadBalancerInternetSpecRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->modifyLoadBalancerInternetSpec(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeLoadBalancerHTTPSListenerAttributeOutcome SlbClient::describeLoadBalancerHTTPSListenerAttribute(const DescribeLoadBalancerHTTPSListenerAttributeRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeLoadBalancerHTTPSListenerAttributeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeLoadBalancerHTTPSListenerAttributeOutcome(DescribeLoadBalancerHTTPSListenerAttributeResult(outcome.result())); + else + return DescribeLoadBalancerHTTPSListenerAttributeOutcome(outcome.error()); +} + +void SlbClient::describeLoadBalancerHTTPSListenerAttributeAsync(const DescribeLoadBalancerHTTPSListenerAttributeRequest& request, const DescribeLoadBalancerHTTPSListenerAttributeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeLoadBalancerHTTPSListenerAttribute(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeLoadBalancerHTTPSListenerAttributeOutcomeCallable SlbClient::describeLoadBalancerHTTPSListenerAttributeCallable(const DescribeLoadBalancerHTTPSListenerAttributeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeLoadBalancerHTTPSListenerAttribute(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::DescribeMasterSlaveServerGroupAttributeOutcome SlbClient::describeMasterSlaveServerGroupAttribute(const DescribeMasterSlaveServerGroupAttributeRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeMasterSlaveServerGroupAttributeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeMasterSlaveServerGroupAttributeOutcome(DescribeMasterSlaveServerGroupAttributeResult(outcome.result())); + else + return DescribeMasterSlaveServerGroupAttributeOutcome(outcome.error()); +} + +void SlbClient::describeMasterSlaveServerGroupAttributeAsync(const DescribeMasterSlaveServerGroupAttributeRequest& request, const DescribeMasterSlaveServerGroupAttributeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeMasterSlaveServerGroupAttribute(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::DescribeMasterSlaveServerGroupAttributeOutcomeCallable SlbClient::describeMasterSlaveServerGroupAttributeCallable(const DescribeMasterSlaveServerGroupAttributeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeMasterSlaveServerGroupAttribute(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::AddTagsOutcome SlbClient::addTags(const AddTagsRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return AddTagsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return AddTagsOutcome(AddTagsResult(outcome.result())); + else + return AddTagsOutcome(outcome.error()); +} + +void SlbClient::addTagsAsync(const AddTagsRequest& request, const AddTagsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, addTags(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::AddTagsOutcomeCallable SlbClient::addTagsCallable(const AddTagsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->addTags(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::ModifyLoadBalancerPayTypeOutcome SlbClient::modifyLoadBalancerPayType(const ModifyLoadBalancerPayTypeRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return ModifyLoadBalancerPayTypeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ModifyLoadBalancerPayTypeOutcome(ModifyLoadBalancerPayTypeResult(outcome.result())); + else + return ModifyLoadBalancerPayTypeOutcome(outcome.error()); +} + +void SlbClient::modifyLoadBalancerPayTypeAsync(const ModifyLoadBalancerPayTypeRequest& request, const ModifyLoadBalancerPayTypeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, modifyLoadBalancerPayType(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::ModifyLoadBalancerPayTypeOutcomeCallable SlbClient::modifyLoadBalancerPayTypeCallable(const ModifyLoadBalancerPayTypeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->modifyLoadBalancerPayType(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::AddBackendServersOutcome SlbClient::addBackendServers(const AddBackendServersRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return AddBackendServersOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return AddBackendServersOutcome(AddBackendServersResult(outcome.result())); + else + return AddBackendServersOutcome(outcome.error()); +} + +void SlbClient::addBackendServersAsync(const AddBackendServersRequest& request, const AddBackendServersAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, addBackendServers(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::AddBackendServersOutcomeCallable SlbClient::addBackendServersCallable(const AddBackendServersRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->addBackendServers(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::CreateRulesOutcome SlbClient::createRules(const CreateRulesRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return CreateRulesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateRulesOutcome(CreateRulesResult(outcome.result())); + else + return CreateRulesOutcome(outcome.error()); +} + +void SlbClient::createRulesAsync(const CreateRulesRequest& request, const CreateRulesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createRules(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::CreateRulesOutcomeCallable SlbClient::createRulesCallable(const CreateRulesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createRules(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::AddVServerGroupBackendServersOutcome SlbClient::addVServerGroupBackendServers(const AddVServerGroupBackendServersRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return AddVServerGroupBackendServersOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return AddVServerGroupBackendServersOutcome(AddVServerGroupBackendServersResult(outcome.result())); + else + return AddVServerGroupBackendServersOutcome(outcome.error()); +} + +void SlbClient::addVServerGroupBackendServersAsync(const AddVServerGroupBackendServersRequest& request, const AddVServerGroupBackendServersAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, addVServerGroupBackendServers(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::AddVServerGroupBackendServersOutcomeCallable SlbClient::addVServerGroupBackendServersCallable(const AddVServerGroupBackendServersRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->addVServerGroupBackendServers(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SlbClient::SetLoadBalancerUDPListenerAttributeOutcome SlbClient::setLoadBalancerUDPListenerAttribute(const SetLoadBalancerUDPListenerAttributeRequest &request) const +{ + auto endpointOutcome = endpoint(); + if (!endpointOutcome.isSuccess()) + return SetLoadBalancerUDPListenerAttributeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return SetLoadBalancerUDPListenerAttributeOutcome(SetLoadBalancerUDPListenerAttributeResult(outcome.result())); + else + return SetLoadBalancerUDPListenerAttributeOutcome(outcome.error()); +} + +void SlbClient::setLoadBalancerUDPListenerAttributeAsync(const SetLoadBalancerUDPListenerAttributeRequest& request, const SetLoadBalancerUDPListenerAttributeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, setLoadBalancerUDPListenerAttribute(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SlbClient::SetLoadBalancerUDPListenerAttributeOutcomeCallable SlbClient::setLoadBalancerUDPListenerAttributeCallable(const SetLoadBalancerUDPListenerAttributeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->setLoadBalancerUDPListenerAttribute(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + diff --git a/slb/src/SlbRequest.cc b/slb/src/SlbRequest.cc new file mode 100644 index 000000000..c96095850 --- /dev/null +++ b/slb/src/SlbRequest.cc @@ -0,0 +1,27 @@ +/* + * 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 + +using namespace AlibabaCloud; +using namespace AlibabaCloud::Slb; + +SlbRequest::SlbRequest(const std::string & action) : + RpcServiceRequest("slb", "2014-05-15", action) +{ } + +SlbRequest::~SlbRequest() +{ } \ No newline at end of file diff --git a/slb/src/model/AddBackendServersRequest.cc b/slb/src/model/AddBackendServersRequest.cc new file mode 100644 index 000000000..4e3588871 --- /dev/null +++ b/slb/src/model/AddBackendServersRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +AddBackendServersRequest::AddBackendServersRequest() : + SlbRequest("AddBackendServers") +{} + +AddBackendServersRequest::~AddBackendServersRequest() +{} + +std::string AddBackendServersRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void AddBackendServersRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long AddBackendServersRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void AddBackendServersRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string AddBackendServersRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void AddBackendServersRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string AddBackendServersRequest::getRegionId()const +{ + return regionId_; +} + +void AddBackendServersRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string AddBackendServersRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void AddBackendServersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string AddBackendServersRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void AddBackendServersRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long AddBackendServersRequest::getOwnerId()const +{ + return ownerId_; +} + +void AddBackendServersRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string AddBackendServersRequest::getBackendServers()const +{ + return backendServers_; +} + +void AddBackendServersRequest::setBackendServers(const std::string& backendServers) +{ + backendServers_ = backendServers; + setParameter("BackendServers", backendServers); +} + +std::string AddBackendServersRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void AddBackendServersRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string AddBackendServersRequest::getTags()const +{ + return tags_; +} + +void AddBackendServersRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/AddBackendServersResult.cc b/slb/src/model/AddBackendServersResult.cc new file mode 100644 index 000000000..96f6e089a --- /dev/null +++ b/slb/src/model/AddBackendServersResult.cc @@ -0,0 +1,64 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +AddBackendServersResult::AddBackendServersResult() : + ServiceResult() +{} + +AddBackendServersResult::AddBackendServersResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +AddBackendServersResult::~AddBackendServersResult() +{} + +void AddBackendServersResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allBackendServers = value["BackendServers"]["BackendServer"]; + for (auto value : allBackendServers) + { + BackendServer backendServerObject; + backendServerObject.serverId = value["ServerId"].asString(); + backendServerObject.weight = value["Weight"].asString(); + backendServers_.push_back(backendServerObject); + } + loadBalancerId_ = value["LoadBalancerId"].asString(); + +} + +std::string AddBackendServersResult::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void AddBackendServersResult::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; +} + diff --git a/slb/src/model/AddListenerWhiteListItemRequest.cc b/slb/src/model/AddListenerWhiteListItemRequest.cc new file mode 100644 index 000000000..a087c06e3 --- /dev/null +++ b/slb/src/model/AddListenerWhiteListItemRequest.cc @@ -0,0 +1,149 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +AddListenerWhiteListItemRequest::AddListenerWhiteListItemRequest() : + SlbRequest("AddListenerWhiteListItem") +{} + +AddListenerWhiteListItemRequest::~AddListenerWhiteListItemRequest() +{} + +std::string AddListenerWhiteListItemRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void AddListenerWhiteListItemRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long AddListenerWhiteListItemRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void AddListenerWhiteListItemRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +int AddListenerWhiteListItemRequest::getListenerPort()const +{ + return listenerPort_; +} + +void AddListenerWhiteListItemRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string AddListenerWhiteListItemRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void AddListenerWhiteListItemRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string AddListenerWhiteListItemRequest::getSourceItems()const +{ + return sourceItems_; +} + +void AddListenerWhiteListItemRequest::setSourceItems(const std::string& sourceItems) +{ + sourceItems_ = sourceItems; + setParameter("SourceItems", sourceItems); +} + +std::string AddListenerWhiteListItemRequest::getRegionId()const +{ + return regionId_; +} + +void AddListenerWhiteListItemRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string AddListenerWhiteListItemRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void AddListenerWhiteListItemRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string AddListenerWhiteListItemRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void AddListenerWhiteListItemRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long AddListenerWhiteListItemRequest::getOwnerId()const +{ + return ownerId_; +} + +void AddListenerWhiteListItemRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string AddListenerWhiteListItemRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void AddListenerWhiteListItemRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string AddListenerWhiteListItemRequest::getTags()const +{ + return tags_; +} + +void AddListenerWhiteListItemRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/AddListenerWhiteListItemResult.cc b/slb/src/model/AddListenerWhiteListItemResult.cc new file mode 100644 index 000000000..9a69510a4 --- /dev/null +++ b/slb/src/model/AddListenerWhiteListItemResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +AddListenerWhiteListItemResult::AddListenerWhiteListItemResult() : + ServiceResult() +{} + +AddListenerWhiteListItemResult::AddListenerWhiteListItemResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +AddListenerWhiteListItemResult::~AddListenerWhiteListItemResult() +{} + +void AddListenerWhiteListItemResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/AddTagsRequest.cc b/slb/src/model/AddTagsRequest.cc new file mode 100644 index 000000000..a707f17c7 --- /dev/null +++ b/slb/src/model/AddTagsRequest.cc @@ -0,0 +1,127 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +AddTagsRequest::AddTagsRequest() : + SlbRequest("AddTags") +{} + +AddTagsRequest::~AddTagsRequest() +{} + +std::string AddTagsRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void AddTagsRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long AddTagsRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void AddTagsRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string AddTagsRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void AddTagsRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string AddTagsRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void AddTagsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string AddTagsRequest::getRegionId()const +{ + return regionId_; +} + +void AddTagsRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string AddTagsRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void AddTagsRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long AddTagsRequest::getOwnerId()const +{ + return ownerId_; +} + +void AddTagsRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string AddTagsRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void AddTagsRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string AddTagsRequest::getTags()const +{ + return tags_; +} + +void AddTagsRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/AddTagsResult.cc b/slb/src/model/AddTagsResult.cc new file mode 100644 index 000000000..86082cab7 --- /dev/null +++ b/slb/src/model/AddTagsResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +AddTagsResult::AddTagsResult() : + ServiceResult() +{} + +AddTagsResult::AddTagsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +AddTagsResult::~AddTagsResult() +{} + +void AddTagsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/AddVServerGroupBackendServersRequest.cc b/slb/src/model/AddVServerGroupBackendServersRequest.cc new file mode 100644 index 000000000..7958be2a3 --- /dev/null +++ b/slb/src/model/AddVServerGroupBackendServersRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +AddVServerGroupBackendServersRequest::AddVServerGroupBackendServersRequest() : + SlbRequest("AddVServerGroupBackendServers") +{} + +AddVServerGroupBackendServersRequest::~AddVServerGroupBackendServersRequest() +{} + +std::string AddVServerGroupBackendServersRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void AddVServerGroupBackendServersRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +std::string AddVServerGroupBackendServersRequest::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void AddVServerGroupBackendServersRequest::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; + setParameter("VServerGroupId", vServerGroupId); +} + +long AddVServerGroupBackendServersRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void AddVServerGroupBackendServersRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string AddVServerGroupBackendServersRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void AddVServerGroupBackendServersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string AddVServerGroupBackendServersRequest::getRegionId()const +{ + return regionId_; +} + +void AddVServerGroupBackendServersRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string AddVServerGroupBackendServersRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void AddVServerGroupBackendServersRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long AddVServerGroupBackendServersRequest::getOwnerId()const +{ + return ownerId_; +} + +void AddVServerGroupBackendServersRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string AddVServerGroupBackendServersRequest::getBackendServers()const +{ + return backendServers_; +} + +void AddVServerGroupBackendServersRequest::setBackendServers(const std::string& backendServers) +{ + backendServers_ = backendServers; + setParameter("BackendServers", backendServers); +} + +std::string AddVServerGroupBackendServersRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void AddVServerGroupBackendServersRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string AddVServerGroupBackendServersRequest::getTags()const +{ + return tags_; +} + +void AddVServerGroupBackendServersRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/AddVServerGroupBackendServersResult.cc b/slb/src/model/AddVServerGroupBackendServersResult.cc new file mode 100644 index 000000000..2f815b17e --- /dev/null +++ b/slb/src/model/AddVServerGroupBackendServersResult.cc @@ -0,0 +1,65 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +AddVServerGroupBackendServersResult::AddVServerGroupBackendServersResult() : + ServiceResult() +{} + +AddVServerGroupBackendServersResult::AddVServerGroupBackendServersResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +AddVServerGroupBackendServersResult::~AddVServerGroupBackendServersResult() +{} + +void AddVServerGroupBackendServersResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allBackendServers = value["BackendServers"]["BackendServer"]; + for (auto value : allBackendServers) + { + BackendServer backendServerObject; + backendServerObject.serverId = value["ServerId"].asString(); + backendServerObject.port = std::stoi(value["Port"].asString()); + backendServerObject.weight = std::stoi(value["Weight"].asString()); + backendServers_.push_back(backendServerObject); + } + vServerGroupId_ = value["VServerGroupId"].asString(); + +} + +std::string AddVServerGroupBackendServersResult::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void AddVServerGroupBackendServersResult::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; +} + diff --git a/slb/src/model/CreateLoadBalancerHTTPListenerRequest.cc b/slb/src/model/CreateLoadBalancerHTTPListenerRequest.cc new file mode 100644 index 000000000..9f293fe27 --- /dev/null +++ b/slb/src/model/CreateLoadBalancerHTTPListenerRequest.cc @@ -0,0 +1,391 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +CreateLoadBalancerHTTPListenerRequest::CreateLoadBalancerHTTPListenerRequest() : + SlbRequest("CreateLoadBalancerHTTPListener") +{} + +CreateLoadBalancerHTTPListenerRequest::~CreateLoadBalancerHTTPListenerRequest() +{} + +std::string CreateLoadBalancerHTTPListenerRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void CreateLoadBalancerHTTPListenerRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long CreateLoadBalancerHTTPListenerRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void CreateLoadBalancerHTTPListenerRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +int CreateLoadBalancerHTTPListenerRequest::getHealthCheckTimeout()const +{ + return healthCheckTimeout_; +} + +void CreateLoadBalancerHTTPListenerRequest::setHealthCheckTimeout(int healthCheckTimeout) +{ + healthCheckTimeout_ = healthCheckTimeout; + setParameter("HealthCheckTimeout", std::to_string(healthCheckTimeout)); +} + +std::string CreateLoadBalancerHTTPListenerRequest::getXForwardedFor()const +{ + return xForwardedFor_; +} + +void CreateLoadBalancerHTTPListenerRequest::setXForwardedFor(const std::string& xForwardedFor) +{ + xForwardedFor_ = xForwardedFor; + setParameter("XForwardedFor", xForwardedFor); +} + +std::string CreateLoadBalancerHTTPListenerRequest::getHealthCheckURI()const +{ + return healthCheckURI_; +} + +void CreateLoadBalancerHTTPListenerRequest::setHealthCheckURI(const std::string& healthCheckURI) +{ + healthCheckURI_ = healthCheckURI; + setParameter("HealthCheckURI", healthCheckURI); +} + +int CreateLoadBalancerHTTPListenerRequest::getUnhealthyThreshold()const +{ + return unhealthyThreshold_; +} + +void CreateLoadBalancerHTTPListenerRequest::setUnhealthyThreshold(int unhealthyThreshold) +{ + unhealthyThreshold_ = unhealthyThreshold; + setParameter("UnhealthyThreshold", std::to_string(unhealthyThreshold)); +} + +int CreateLoadBalancerHTTPListenerRequest::getHealthyThreshold()const +{ + return healthyThreshold_; +} + +void CreateLoadBalancerHTTPListenerRequest::setHealthyThreshold(int healthyThreshold) +{ + healthyThreshold_ = healthyThreshold; + setParameter("HealthyThreshold", std::to_string(healthyThreshold)); +} + +std::string CreateLoadBalancerHTTPListenerRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void CreateLoadBalancerHTTPListenerRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string CreateLoadBalancerHTTPListenerRequest::getScheduler()const +{ + return scheduler_; +} + +void CreateLoadBalancerHTTPListenerRequest::setScheduler(const std::string& scheduler) +{ + scheduler_ = scheduler; + setParameter("Scheduler", scheduler); +} + +std::string CreateLoadBalancerHTTPListenerRequest::getHealthCheck()const +{ + return healthCheck_; +} + +void CreateLoadBalancerHTTPListenerRequest::setHealthCheck(const std::string& healthCheck) +{ + healthCheck_ = healthCheck; + setParameter("HealthCheck", healthCheck); +} + +int CreateLoadBalancerHTTPListenerRequest::getMaxConnection()const +{ + return maxConnection_; +} + +void CreateLoadBalancerHTTPListenerRequest::setMaxConnection(int maxConnection) +{ + maxConnection_ = maxConnection; + setParameter("MaxConnection", std::to_string(maxConnection)); +} + +std::string CreateLoadBalancerHTTPListenerRequest::getRegionId()const +{ + return regionId_; +} + +void CreateLoadBalancerHTTPListenerRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +int CreateLoadBalancerHTTPListenerRequest::getCookieTimeout()const +{ + return cookieTimeout_; +} + +void CreateLoadBalancerHTTPListenerRequest::setCookieTimeout(int cookieTimeout) +{ + cookieTimeout_ = cookieTimeout; + setParameter("CookieTimeout", std::to_string(cookieTimeout)); +} + +std::string CreateLoadBalancerHTTPListenerRequest::getStickySessionType()const +{ + return stickySessionType_; +} + +void CreateLoadBalancerHTTPListenerRequest::setStickySessionType(const std::string& stickySessionType) +{ + stickySessionType_ = stickySessionType; + setParameter("StickySessionType", stickySessionType); +} + +std::string CreateLoadBalancerHTTPListenerRequest::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void CreateLoadBalancerHTTPListenerRequest::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; + setParameter("VServerGroupId", vServerGroupId); +} + +int CreateLoadBalancerHTTPListenerRequest::getListenerPort()const +{ + return listenerPort_; +} + +void CreateLoadBalancerHTTPListenerRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string CreateLoadBalancerHTTPListenerRequest::getCookie()const +{ + return cookie_; +} + +void CreateLoadBalancerHTTPListenerRequest::setCookie(const std::string& cookie) +{ + cookie_ = cookie; + setParameter("Cookie", cookie); +} + +std::string CreateLoadBalancerHTTPListenerRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void CreateLoadBalancerHTTPListenerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +int CreateLoadBalancerHTTPListenerRequest::getBandwidth()const +{ + return bandwidth_; +} + +void CreateLoadBalancerHTTPListenerRequest::setBandwidth(int bandwidth) +{ + bandwidth_ = bandwidth; + setParameter("Bandwidth", std::to_string(bandwidth)); +} + +std::string CreateLoadBalancerHTTPListenerRequest::getStickySession()const +{ + return stickySession_; +} + +void CreateLoadBalancerHTTPListenerRequest::setStickySession(const std::string& stickySession) +{ + stickySession_ = stickySession; + setParameter("StickySession", stickySession); +} + +std::string CreateLoadBalancerHTTPListenerRequest::getHealthCheckDomain()const +{ + return healthCheckDomain_; +} + +void CreateLoadBalancerHTTPListenerRequest::setHealthCheckDomain(const std::string& healthCheckDomain) +{ + healthCheckDomain_ = healthCheckDomain; + setParameter("HealthCheckDomain", healthCheckDomain); +} + +std::string CreateLoadBalancerHTTPListenerRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void CreateLoadBalancerHTTPListenerRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +std::string CreateLoadBalancerHTTPListenerRequest::getGzip()const +{ + return gzip_; +} + +void CreateLoadBalancerHTTPListenerRequest::setGzip(const std::string& gzip) +{ + gzip_ = gzip; + setParameter("Gzip", gzip); +} + +long CreateLoadBalancerHTTPListenerRequest::getOwnerId()const +{ + return ownerId_; +} + +void CreateLoadBalancerHTTPListenerRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string CreateLoadBalancerHTTPListenerRequest::getTags()const +{ + return tags_; +} + +void CreateLoadBalancerHTTPListenerRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + +std::string CreateLoadBalancerHTTPListenerRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void CreateLoadBalancerHTTPListenerRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string CreateLoadBalancerHTTPListenerRequest::getXForwardedFor_SLBIP()const +{ + return xForwardedFor_SLBIP_; +} + +void CreateLoadBalancerHTTPListenerRequest::setXForwardedFor_SLBIP(const std::string& xForwardedFor_SLBIP) +{ + xForwardedFor_SLBIP_ = xForwardedFor_SLBIP; + setParameter("XForwardedFor_SLBIP", xForwardedFor_SLBIP); +} + +int CreateLoadBalancerHTTPListenerRequest::getBackendServerPort()const +{ + return backendServerPort_; +} + +void CreateLoadBalancerHTTPListenerRequest::setBackendServerPort(int backendServerPort) +{ + backendServerPort_ = backendServerPort; + setParameter("BackendServerPort", std::to_string(backendServerPort)); +} + +int CreateLoadBalancerHTTPListenerRequest::getHealthCheckInterval()const +{ + return healthCheckInterval_; +} + +void CreateLoadBalancerHTTPListenerRequest::setHealthCheckInterval(int healthCheckInterval) +{ + healthCheckInterval_ = healthCheckInterval; + setParameter("HealthCheckInterval", std::to_string(healthCheckInterval)); +} + +std::string CreateLoadBalancerHTTPListenerRequest::getXForwardedFor_proto()const +{ + return xForwardedFor_proto_; +} + +void CreateLoadBalancerHTTPListenerRequest::setXForwardedFor_proto(const std::string& xForwardedFor_proto) +{ + xForwardedFor_proto_ = xForwardedFor_proto; + setParameter("XForwardedFor_proto", xForwardedFor_proto); +} + +std::string CreateLoadBalancerHTTPListenerRequest::getXForwardedFor_SLBID()const +{ + return xForwardedFor_SLBID_; +} + +void CreateLoadBalancerHTTPListenerRequest::setXForwardedFor_SLBID(const std::string& xForwardedFor_SLBID) +{ + xForwardedFor_SLBID_ = xForwardedFor_SLBID; + setParameter("XForwardedFor_SLBID", xForwardedFor_SLBID); +} + +int CreateLoadBalancerHTTPListenerRequest::getHealthCheckConnectPort()const +{ + return healthCheckConnectPort_; +} + +void CreateLoadBalancerHTTPListenerRequest::setHealthCheckConnectPort(int healthCheckConnectPort) +{ + healthCheckConnectPort_ = healthCheckConnectPort; + setParameter("HealthCheckConnectPort", std::to_string(healthCheckConnectPort)); +} + +std::string CreateLoadBalancerHTTPListenerRequest::getHealthCheckHttpCode()const +{ + return healthCheckHttpCode_; +} + +void CreateLoadBalancerHTTPListenerRequest::setHealthCheckHttpCode(const std::string& healthCheckHttpCode) +{ + healthCheckHttpCode_ = healthCheckHttpCode; + setParameter("HealthCheckHttpCode", healthCheckHttpCode); +} + diff --git a/slb/src/model/CreateLoadBalancerHTTPListenerResult.cc b/slb/src/model/CreateLoadBalancerHTTPListenerResult.cc new file mode 100644 index 000000000..de79b4e28 --- /dev/null +++ b/slb/src/model/CreateLoadBalancerHTTPListenerResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +CreateLoadBalancerHTTPListenerResult::CreateLoadBalancerHTTPListenerResult() : + ServiceResult() +{} + +CreateLoadBalancerHTTPListenerResult::CreateLoadBalancerHTTPListenerResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateLoadBalancerHTTPListenerResult::~CreateLoadBalancerHTTPListenerResult() +{} + +void CreateLoadBalancerHTTPListenerResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/CreateLoadBalancerHTTPSListenerRequest.cc b/slb/src/model/CreateLoadBalancerHTTPSListenerRequest.cc new file mode 100644 index 000000000..cddfaa8c0 --- /dev/null +++ b/slb/src/model/CreateLoadBalancerHTTPSListenerRequest.cc @@ -0,0 +1,413 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +CreateLoadBalancerHTTPSListenerRequest::CreateLoadBalancerHTTPSListenerRequest() : + SlbRequest("CreateLoadBalancerHTTPSListener") +{} + +CreateLoadBalancerHTTPSListenerRequest::~CreateLoadBalancerHTTPSListenerRequest() +{} + +std::string CreateLoadBalancerHTTPSListenerRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long CreateLoadBalancerHTTPSListenerRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +int CreateLoadBalancerHTTPSListenerRequest::getHealthCheckTimeout()const +{ + return healthCheckTimeout_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setHealthCheckTimeout(int healthCheckTimeout) +{ + healthCheckTimeout_ = healthCheckTimeout; + setParameter("HealthCheckTimeout", std::to_string(healthCheckTimeout)); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getXForwardedFor()const +{ + return xForwardedFor_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setXForwardedFor(const std::string& xForwardedFor) +{ + xForwardedFor_ = xForwardedFor; + setParameter("XForwardedFor", xForwardedFor); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getHealthCheckURI()const +{ + return healthCheckURI_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setHealthCheckURI(const std::string& healthCheckURI) +{ + healthCheckURI_ = healthCheckURI; + setParameter("HealthCheckURI", healthCheckURI); +} + +int CreateLoadBalancerHTTPSListenerRequest::getUnhealthyThreshold()const +{ + return unhealthyThreshold_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setUnhealthyThreshold(int unhealthyThreshold) +{ + unhealthyThreshold_ = unhealthyThreshold; + setParameter("UnhealthyThreshold", std::to_string(unhealthyThreshold)); +} + +int CreateLoadBalancerHTTPSListenerRequest::getHealthyThreshold()const +{ + return healthyThreshold_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setHealthyThreshold(int healthyThreshold) +{ + healthyThreshold_ = healthyThreshold; + setParameter("HealthyThreshold", std::to_string(healthyThreshold)); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getScheduler()const +{ + return scheduler_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setScheduler(const std::string& scheduler) +{ + scheduler_ = scheduler; + setParameter("Scheduler", scheduler); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getHealthCheck()const +{ + return healthCheck_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setHealthCheck(const std::string& healthCheck) +{ + healthCheck_ = healthCheck; + setParameter("HealthCheck", healthCheck); +} + +int CreateLoadBalancerHTTPSListenerRequest::getMaxConnection()const +{ + return maxConnection_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setMaxConnection(int maxConnection) +{ + maxConnection_ = maxConnection; + setParameter("MaxConnection", std::to_string(maxConnection)); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getRegionId()const +{ + return regionId_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +int CreateLoadBalancerHTTPSListenerRequest::getCookieTimeout()const +{ + return cookieTimeout_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setCookieTimeout(int cookieTimeout) +{ + cookieTimeout_ = cookieTimeout; + setParameter("CookieTimeout", std::to_string(cookieTimeout)); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getStickySessionType()const +{ + return stickySessionType_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setStickySessionType(const std::string& stickySessionType) +{ + stickySessionType_ = stickySessionType; + setParameter("StickySessionType", stickySessionType); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; + setParameter("VServerGroupId", vServerGroupId); +} + +int CreateLoadBalancerHTTPSListenerRequest::getListenerPort()const +{ + return listenerPort_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getCookie()const +{ + return cookie_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setCookie(const std::string& cookie) +{ + cookie_ = cookie; + setParameter("Cookie", cookie); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +int CreateLoadBalancerHTTPSListenerRequest::getBandwidth()const +{ + return bandwidth_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setBandwidth(int bandwidth) +{ + bandwidth_ = bandwidth; + setParameter("Bandwidth", std::to_string(bandwidth)); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getStickySession()const +{ + return stickySession_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setStickySession(const std::string& stickySession) +{ + stickySession_ = stickySession; + setParameter("StickySession", stickySession); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getHealthCheckDomain()const +{ + return healthCheckDomain_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setHealthCheckDomain(const std::string& healthCheckDomain) +{ + healthCheckDomain_ = healthCheckDomain; + setParameter("HealthCheckDomain", healthCheckDomain); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getGzip()const +{ + return gzip_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setGzip(const std::string& gzip) +{ + gzip_ = gzip; + setParameter("Gzip", gzip); +} + +long CreateLoadBalancerHTTPSListenerRequest::getOwnerId()const +{ + return ownerId_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getServerCertificateId()const +{ + return serverCertificateId_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setServerCertificateId(const std::string& serverCertificateId) +{ + serverCertificateId_ = serverCertificateId; + setParameter("ServerCertificateId", serverCertificateId); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getCACertificateId()const +{ + return cACertificateId_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setCACertificateId(const std::string& cACertificateId) +{ + cACertificateId_ = cACertificateId; + setParameter("CACertificateId", cACertificateId); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getTags()const +{ + return tags_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getXForwardedFor_SLBIP()const +{ + return xForwardedFor_SLBIP_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setXForwardedFor_SLBIP(const std::string& xForwardedFor_SLBIP) +{ + xForwardedFor_SLBIP_ = xForwardedFor_SLBIP; + setParameter("XForwardedFor_SLBIP", xForwardedFor_SLBIP); +} + +int CreateLoadBalancerHTTPSListenerRequest::getBackendServerPort()const +{ + return backendServerPort_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setBackendServerPort(int backendServerPort) +{ + backendServerPort_ = backendServerPort; + setParameter("BackendServerPort", std::to_string(backendServerPort)); +} + +int CreateLoadBalancerHTTPSListenerRequest::getHealthCheckInterval()const +{ + return healthCheckInterval_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setHealthCheckInterval(int healthCheckInterval) +{ + healthCheckInterval_ = healthCheckInterval; + setParameter("HealthCheckInterval", std::to_string(healthCheckInterval)); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getXForwardedFor_proto()const +{ + return xForwardedFor_proto_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setXForwardedFor_proto(const std::string& xForwardedFor_proto) +{ + xForwardedFor_proto_ = xForwardedFor_proto; + setParameter("XForwardedFor_proto", xForwardedFor_proto); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getXForwardedFor_SLBID()const +{ + return xForwardedFor_SLBID_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setXForwardedFor_SLBID(const std::string& xForwardedFor_SLBID) +{ + xForwardedFor_SLBID_ = xForwardedFor_SLBID; + setParameter("XForwardedFor_SLBID", xForwardedFor_SLBID); +} + +int CreateLoadBalancerHTTPSListenerRequest::getHealthCheckConnectPort()const +{ + return healthCheckConnectPort_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setHealthCheckConnectPort(int healthCheckConnectPort) +{ + healthCheckConnectPort_ = healthCheckConnectPort; + setParameter("HealthCheckConnectPort", std::to_string(healthCheckConnectPort)); +} + +std::string CreateLoadBalancerHTTPSListenerRequest::getHealthCheckHttpCode()const +{ + return healthCheckHttpCode_; +} + +void CreateLoadBalancerHTTPSListenerRequest::setHealthCheckHttpCode(const std::string& healthCheckHttpCode) +{ + healthCheckHttpCode_ = healthCheckHttpCode; + setParameter("HealthCheckHttpCode", healthCheckHttpCode); +} + diff --git a/slb/src/model/CreateLoadBalancerHTTPSListenerResult.cc b/slb/src/model/CreateLoadBalancerHTTPSListenerResult.cc new file mode 100644 index 000000000..b5a802980 --- /dev/null +++ b/slb/src/model/CreateLoadBalancerHTTPSListenerResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +CreateLoadBalancerHTTPSListenerResult::CreateLoadBalancerHTTPSListenerResult() : + ServiceResult() +{} + +CreateLoadBalancerHTTPSListenerResult::CreateLoadBalancerHTTPSListenerResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateLoadBalancerHTTPSListenerResult::~CreateLoadBalancerHTTPSListenerResult() +{} + +void CreateLoadBalancerHTTPSListenerResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/CreateLoadBalancerRequest.cc b/slb/src/model/CreateLoadBalancerRequest.cc new file mode 100644 index 000000000..36c27902f --- /dev/null +++ b/slb/src/model/CreateLoadBalancerRequest.cc @@ -0,0 +1,292 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +CreateLoadBalancerRequest::CreateLoadBalancerRequest() : + SlbRequest("CreateLoadBalancer") +{} + +CreateLoadBalancerRequest::~CreateLoadBalancerRequest() +{} + +std::string CreateLoadBalancerRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void CreateLoadBalancerRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long CreateLoadBalancerRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void CreateLoadBalancerRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string CreateLoadBalancerRequest::getClientToken()const +{ + return clientToken_; +} + +void CreateLoadBalancerRequest::setClientToken(const std::string& clientToken) +{ + clientToken_ = clientToken; + setParameter("ClientToken", clientToken); +} + +std::string CreateLoadBalancerRequest::getMasterZoneId()const +{ + return masterZoneId_; +} + +void CreateLoadBalancerRequest::setMasterZoneId(const std::string& masterZoneId) +{ + masterZoneId_ = masterZoneId; + setParameter("MasterZoneId", masterZoneId); +} + +std::string CreateLoadBalancerRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void CreateLoadBalancerRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +int CreateLoadBalancerRequest::getDuration()const +{ + return duration_; +} + +void CreateLoadBalancerRequest::setDuration(int duration) +{ + duration_ = duration; + setParameter("Duration", std::to_string(duration)); +} + +std::string CreateLoadBalancerRequest::getResourceGroupId()const +{ + return resourceGroupId_; +} + +void CreateLoadBalancerRequest::setResourceGroupId(const std::string& resourceGroupId) +{ + resourceGroupId_ = resourceGroupId; + setParameter("ResourceGroupId", resourceGroupId); +} + +std::string CreateLoadBalancerRequest::getLoadBalancerName()const +{ + return loadBalancerName_; +} + +void CreateLoadBalancerRequest::setLoadBalancerName(const std::string& loadBalancerName) +{ + loadBalancerName_ = loadBalancerName; + setParameter("LoadBalancerName", loadBalancerName); +} + +std::string CreateLoadBalancerRequest::getRegionId()const +{ + return regionId_; +} + +void CreateLoadBalancerRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string CreateLoadBalancerRequest::getAddressType()const +{ + return addressType_; +} + +void CreateLoadBalancerRequest::setAddressType(const std::string& addressType) +{ + addressType_ = addressType; + setParameter("AddressType", addressType); +} + +std::string CreateLoadBalancerRequest::getSlaveZoneId()const +{ + return slaveZoneId_; +} + +void CreateLoadBalancerRequest::setSlaveZoneId(const std::string& slaveZoneId) +{ + slaveZoneId_ = slaveZoneId; + setParameter("SlaveZoneId", slaveZoneId); +} + +std::string CreateLoadBalancerRequest::getLoadBalancerSpec()const +{ + return loadBalancerSpec_; +} + +void CreateLoadBalancerRequest::setLoadBalancerSpec(const std::string& loadBalancerSpec) +{ + loadBalancerSpec_ = loadBalancerSpec; + setParameter("LoadBalancerSpec", loadBalancerSpec); +} + +bool CreateLoadBalancerRequest::getAutoPay()const +{ + return autoPay_; +} + +void CreateLoadBalancerRequest::setAutoPay(bool autoPay) +{ + autoPay_ = autoPay; + setParameter("AutoPay", std::to_string(autoPay)); +} + +std::string CreateLoadBalancerRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void CreateLoadBalancerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +int CreateLoadBalancerRequest::getBandwidth()const +{ + return bandwidth_; +} + +void CreateLoadBalancerRequest::setBandwidth(int bandwidth) +{ + bandwidth_ = bandwidth; + setParameter("Bandwidth", std::to_string(bandwidth)); +} + +std::string CreateLoadBalancerRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void CreateLoadBalancerRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long CreateLoadBalancerRequest::getOwnerId()const +{ + return ownerId_; +} + +void CreateLoadBalancerRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string CreateLoadBalancerRequest::getTags()const +{ + return tags_; +} + +void CreateLoadBalancerRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + +std::string CreateLoadBalancerRequest::getVSwitchId()const +{ + return vSwitchId_; +} + +void CreateLoadBalancerRequest::setVSwitchId(const std::string& vSwitchId) +{ + vSwitchId_ = vSwitchId; + setParameter("VSwitchId", vSwitchId); +} + +std::string CreateLoadBalancerRequest::getEnableVpcVipFlow()const +{ + return enableVpcVipFlow_; +} + +void CreateLoadBalancerRequest::setEnableVpcVipFlow(const std::string& enableVpcVipFlow) +{ + enableVpcVipFlow_ = enableVpcVipFlow; + setParameter("EnableVpcVipFlow", enableVpcVipFlow); +} + +std::string CreateLoadBalancerRequest::getInternetChargeType()const +{ + return internetChargeType_; +} + +void CreateLoadBalancerRequest::setInternetChargeType(const std::string& internetChargeType) +{ + internetChargeType_ = internetChargeType; + setParameter("InternetChargeType", internetChargeType); +} + +std::string CreateLoadBalancerRequest::getVpcId()const +{ + return vpcId_; +} + +void CreateLoadBalancerRequest::setVpcId(const std::string& vpcId) +{ + vpcId_ = vpcId; + setParameter("VpcId", vpcId); +} + +std::string CreateLoadBalancerRequest::getPayType()const +{ + return payType_; +} + +void CreateLoadBalancerRequest::setPayType(const std::string& payType) +{ + payType_ = payType; + setParameter("PayType", payType); +} + +std::string CreateLoadBalancerRequest::getPricingCycle()const +{ + return pricingCycle_; +} + +void CreateLoadBalancerRequest::setPricingCycle(const std::string& pricingCycle) +{ + pricingCycle_ = pricingCycle; + setParameter("PricingCycle", pricingCycle); +} + diff --git a/slb/src/model/CreateLoadBalancerResult.cc b/slb/src/model/CreateLoadBalancerResult.cc new file mode 100644 index 000000000..af0de1e2d --- /dev/null +++ b/slb/src/model/CreateLoadBalancerResult.cc @@ -0,0 +1,133 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +CreateLoadBalancerResult::CreateLoadBalancerResult() : + ServiceResult() +{} + +CreateLoadBalancerResult::CreateLoadBalancerResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateLoadBalancerResult::~CreateLoadBalancerResult() +{} + +void CreateLoadBalancerResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + loadBalancerId_ = value["LoadBalancerId"].asString(); + resourceGroupId_ = value["ResourceGroupId"].asString(); + address_ = value["Address"].asString(); + loadBalancerName_ = value["LoadBalancerName"].asString(); + vpcId_ = value["VpcId"].asString(); + vSwitchId_ = value["VSwitchId"].asString(); + networkType_ = value["NetworkType"].asString(); + orderId_ = std::stol(value["OrderId"].asString()); + +} + +std::string CreateLoadBalancerResult::getLoadBalancerName()const +{ + return loadBalancerName_; +} + +void CreateLoadBalancerResult::setLoadBalancerName(const std::string& loadBalancerName) +{ + loadBalancerName_ = loadBalancerName; +} + +std::string CreateLoadBalancerResult::getResourceGroupId()const +{ + return resourceGroupId_; +} + +void CreateLoadBalancerResult::setResourceGroupId(const std::string& resourceGroupId) +{ + resourceGroupId_ = resourceGroupId; +} + +std::string CreateLoadBalancerResult::getAddress()const +{ + return address_; +} + +void CreateLoadBalancerResult::setAddress(const std::string& address) +{ + address_ = address; +} + +std::string CreateLoadBalancerResult::getVpcId()const +{ + return vpcId_; +} + +void CreateLoadBalancerResult::setVpcId(const std::string& vpcId) +{ + vpcId_ = vpcId; +} + +std::string CreateLoadBalancerResult::getNetworkType()const +{ + return networkType_; +} + +void CreateLoadBalancerResult::setNetworkType(const std::string& networkType) +{ + networkType_ = networkType; +} + +std::string CreateLoadBalancerResult::getVSwitchId()const +{ + return vSwitchId_; +} + +void CreateLoadBalancerResult::setVSwitchId(const std::string& vSwitchId) +{ + vSwitchId_ = vSwitchId; +} + +std::string CreateLoadBalancerResult::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void CreateLoadBalancerResult::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; +} + +long CreateLoadBalancerResult::getOrderId()const +{ + return orderId_; +} + +void CreateLoadBalancerResult::setOrderId(long orderId) +{ + orderId_ = orderId; +} + diff --git a/slb/src/model/CreateLoadBalancerTCPListenerRequest.cc b/slb/src/model/CreateLoadBalancerTCPListenerRequest.cc new file mode 100644 index 000000000..5a311b25f --- /dev/null +++ b/slb/src/model/CreateLoadBalancerTCPListenerRequest.cc @@ -0,0 +1,325 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +CreateLoadBalancerTCPListenerRequest::CreateLoadBalancerTCPListenerRequest() : + SlbRequest("CreateLoadBalancerTCPListener") +{} + +CreateLoadBalancerTCPListenerRequest::~CreateLoadBalancerTCPListenerRequest() +{} + +std::string CreateLoadBalancerTCPListenerRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void CreateLoadBalancerTCPListenerRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +int CreateLoadBalancerTCPListenerRequest::getHealthCheckConnectTimeout()const +{ + return healthCheckConnectTimeout_; +} + +void CreateLoadBalancerTCPListenerRequest::setHealthCheckConnectTimeout(int healthCheckConnectTimeout) +{ + healthCheckConnectTimeout_ = healthCheckConnectTimeout; + setParameter("HealthCheckConnectTimeout", std::to_string(healthCheckConnectTimeout)); +} + +long CreateLoadBalancerTCPListenerRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void CreateLoadBalancerTCPListenerRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string CreateLoadBalancerTCPListenerRequest::getHealthCheckURI()const +{ + return healthCheckURI_; +} + +void CreateLoadBalancerTCPListenerRequest::setHealthCheckURI(const std::string& healthCheckURI) +{ + healthCheckURI_ = healthCheckURI; + setParameter("HealthCheckURI", healthCheckURI); +} + +int CreateLoadBalancerTCPListenerRequest::getUnhealthyThreshold()const +{ + return unhealthyThreshold_; +} + +void CreateLoadBalancerTCPListenerRequest::setUnhealthyThreshold(int unhealthyThreshold) +{ + unhealthyThreshold_ = unhealthyThreshold; + setParameter("UnhealthyThreshold", std::to_string(unhealthyThreshold)); +} + +int CreateLoadBalancerTCPListenerRequest::getHealthyThreshold()const +{ + return healthyThreshold_; +} + +void CreateLoadBalancerTCPListenerRequest::setHealthyThreshold(int healthyThreshold) +{ + healthyThreshold_ = healthyThreshold; + setParameter("HealthyThreshold", std::to_string(healthyThreshold)); +} + +std::string CreateLoadBalancerTCPListenerRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void CreateLoadBalancerTCPListenerRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string CreateLoadBalancerTCPListenerRequest::getScheduler()const +{ + return scheduler_; +} + +void CreateLoadBalancerTCPListenerRequest::setScheduler(const std::string& scheduler) +{ + scheduler_ = scheduler; + setParameter("Scheduler", scheduler); +} + +int CreateLoadBalancerTCPListenerRequest::getEstablishedTimeout()const +{ + return establishedTimeout_; +} + +void CreateLoadBalancerTCPListenerRequest::setEstablishedTimeout(int establishedTimeout) +{ + establishedTimeout_ = establishedTimeout; + setParameter("EstablishedTimeout", std::to_string(establishedTimeout)); +} + +int CreateLoadBalancerTCPListenerRequest::getMaxConnection()const +{ + return maxConnection_; +} + +void CreateLoadBalancerTCPListenerRequest::setMaxConnection(int maxConnection) +{ + maxConnection_ = maxConnection; + setParameter("MaxConnection", std::to_string(maxConnection)); +} + +std::string CreateLoadBalancerTCPListenerRequest::getRegionId()const +{ + return regionId_; +} + +void CreateLoadBalancerTCPListenerRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +int CreateLoadBalancerTCPListenerRequest::getPersistenceTimeout()const +{ + return persistenceTimeout_; +} + +void CreateLoadBalancerTCPListenerRequest::setPersistenceTimeout(int persistenceTimeout) +{ + persistenceTimeout_ = persistenceTimeout; + setParameter("PersistenceTimeout", std::to_string(persistenceTimeout)); +} + +std::string CreateLoadBalancerTCPListenerRequest::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void CreateLoadBalancerTCPListenerRequest::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; + setParameter("VServerGroupId", vServerGroupId); +} + +int CreateLoadBalancerTCPListenerRequest::getListenerPort()const +{ + return listenerPort_; +} + +void CreateLoadBalancerTCPListenerRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string CreateLoadBalancerTCPListenerRequest::getHealthCheckType()const +{ + return healthCheckType_; +} + +void CreateLoadBalancerTCPListenerRequest::setHealthCheckType(const std::string& healthCheckType) +{ + healthCheckType_ = healthCheckType; + setParameter("HealthCheckType", healthCheckType); +} + +std::string CreateLoadBalancerTCPListenerRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void CreateLoadBalancerTCPListenerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +int CreateLoadBalancerTCPListenerRequest::getBandwidth()const +{ + return bandwidth_; +} + +void CreateLoadBalancerTCPListenerRequest::setBandwidth(int bandwidth) +{ + bandwidth_ = bandwidth; + setParameter("Bandwidth", std::to_string(bandwidth)); +} + +std::string CreateLoadBalancerTCPListenerRequest::getHealthCheckDomain()const +{ + return healthCheckDomain_; +} + +void CreateLoadBalancerTCPListenerRequest::setHealthCheckDomain(const std::string& healthCheckDomain) +{ + healthCheckDomain_ = healthCheckDomain; + setParameter("HealthCheckDomain", healthCheckDomain); +} + +std::string CreateLoadBalancerTCPListenerRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void CreateLoadBalancerTCPListenerRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long CreateLoadBalancerTCPListenerRequest::getOwnerId()const +{ + return ownerId_; +} + +void CreateLoadBalancerTCPListenerRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string CreateLoadBalancerTCPListenerRequest::getTags()const +{ + return tags_; +} + +void CreateLoadBalancerTCPListenerRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + +std::string CreateLoadBalancerTCPListenerRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void CreateLoadBalancerTCPListenerRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string CreateLoadBalancerTCPListenerRequest::getMasterSlaveServerGroupId()const +{ + return masterSlaveServerGroupId_; +} + +void CreateLoadBalancerTCPListenerRequest::setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId) +{ + masterSlaveServerGroupId_ = masterSlaveServerGroupId; + setParameter("MasterSlaveServerGroupId", masterSlaveServerGroupId); +} + +int CreateLoadBalancerTCPListenerRequest::getBackendServerPort()const +{ + return backendServerPort_; +} + +void CreateLoadBalancerTCPListenerRequest::setBackendServerPort(int backendServerPort) +{ + backendServerPort_ = backendServerPort; + setParameter("BackendServerPort", std::to_string(backendServerPort)); +} + +int CreateLoadBalancerTCPListenerRequest::getHealthCheckInterval()const +{ + return healthCheckInterval_; +} + +void CreateLoadBalancerTCPListenerRequest::setHealthCheckInterval(int healthCheckInterval) +{ + healthCheckInterval_ = healthCheckInterval; + setParameter("HealthCheckInterval", std::to_string(healthCheckInterval)); +} + +int CreateLoadBalancerTCPListenerRequest::getHealthCheckConnectPort()const +{ + return healthCheckConnectPort_; +} + +void CreateLoadBalancerTCPListenerRequest::setHealthCheckConnectPort(int healthCheckConnectPort) +{ + healthCheckConnectPort_ = healthCheckConnectPort; + setParameter("HealthCheckConnectPort", std::to_string(healthCheckConnectPort)); +} + +std::string CreateLoadBalancerTCPListenerRequest::getHealthCheckHttpCode()const +{ + return healthCheckHttpCode_; +} + +void CreateLoadBalancerTCPListenerRequest::setHealthCheckHttpCode(const std::string& healthCheckHttpCode) +{ + healthCheckHttpCode_ = healthCheckHttpCode; + setParameter("HealthCheckHttpCode", healthCheckHttpCode); +} + diff --git a/slb/src/model/CreateLoadBalancerTCPListenerResult.cc b/slb/src/model/CreateLoadBalancerTCPListenerResult.cc new file mode 100644 index 000000000..121761699 --- /dev/null +++ b/slb/src/model/CreateLoadBalancerTCPListenerResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +CreateLoadBalancerTCPListenerResult::CreateLoadBalancerTCPListenerResult() : + ServiceResult() +{} + +CreateLoadBalancerTCPListenerResult::CreateLoadBalancerTCPListenerResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateLoadBalancerTCPListenerResult::~CreateLoadBalancerTCPListenerResult() +{} + +void CreateLoadBalancerTCPListenerResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/CreateLoadBalancerUDPListenerRequest.cc b/slb/src/model/CreateLoadBalancerUDPListenerRequest.cc new file mode 100644 index 000000000..a5dedbb7f --- /dev/null +++ b/slb/src/model/CreateLoadBalancerUDPListenerRequest.cc @@ -0,0 +1,292 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +CreateLoadBalancerUDPListenerRequest::CreateLoadBalancerUDPListenerRequest() : + SlbRequest("CreateLoadBalancerUDPListener") +{} + +CreateLoadBalancerUDPListenerRequest::~CreateLoadBalancerUDPListenerRequest() +{} + +std::string CreateLoadBalancerUDPListenerRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void CreateLoadBalancerUDPListenerRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +int CreateLoadBalancerUDPListenerRequest::getHealthCheckConnectTimeout()const +{ + return healthCheckConnectTimeout_; +} + +void CreateLoadBalancerUDPListenerRequest::setHealthCheckConnectTimeout(int healthCheckConnectTimeout) +{ + healthCheckConnectTimeout_ = healthCheckConnectTimeout; + setParameter("HealthCheckConnectTimeout", std::to_string(healthCheckConnectTimeout)); +} + +long CreateLoadBalancerUDPListenerRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void CreateLoadBalancerUDPListenerRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +int CreateLoadBalancerUDPListenerRequest::getUnhealthyThreshold()const +{ + return unhealthyThreshold_; +} + +void CreateLoadBalancerUDPListenerRequest::setUnhealthyThreshold(int unhealthyThreshold) +{ + unhealthyThreshold_ = unhealthyThreshold; + setParameter("UnhealthyThreshold", std::to_string(unhealthyThreshold)); +} + +int CreateLoadBalancerUDPListenerRequest::getHealthyThreshold()const +{ + return healthyThreshold_; +} + +void CreateLoadBalancerUDPListenerRequest::setHealthyThreshold(int healthyThreshold) +{ + healthyThreshold_ = healthyThreshold; + setParameter("HealthyThreshold", std::to_string(healthyThreshold)); +} + +std::string CreateLoadBalancerUDPListenerRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void CreateLoadBalancerUDPListenerRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string CreateLoadBalancerUDPListenerRequest::getScheduler()const +{ + return scheduler_; +} + +void CreateLoadBalancerUDPListenerRequest::setScheduler(const std::string& scheduler) +{ + scheduler_ = scheduler; + setParameter("Scheduler", scheduler); +} + +int CreateLoadBalancerUDPListenerRequest::getMaxConnection()const +{ + return maxConnection_; +} + +void CreateLoadBalancerUDPListenerRequest::setMaxConnection(int maxConnection) +{ + maxConnection_ = maxConnection; + setParameter("MaxConnection", std::to_string(maxConnection)); +} + +std::string CreateLoadBalancerUDPListenerRequest::getRegionId()const +{ + return regionId_; +} + +void CreateLoadBalancerUDPListenerRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +int CreateLoadBalancerUDPListenerRequest::getPersistenceTimeout()const +{ + return persistenceTimeout_; +} + +void CreateLoadBalancerUDPListenerRequest::setPersistenceTimeout(int persistenceTimeout) +{ + persistenceTimeout_ = persistenceTimeout; + setParameter("PersistenceTimeout", std::to_string(persistenceTimeout)); +} + +std::string CreateLoadBalancerUDPListenerRequest::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void CreateLoadBalancerUDPListenerRequest::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; + setParameter("VServerGroupId", vServerGroupId); +} + +int CreateLoadBalancerUDPListenerRequest::getListenerPort()const +{ + return listenerPort_; +} + +void CreateLoadBalancerUDPListenerRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string CreateLoadBalancerUDPListenerRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void CreateLoadBalancerUDPListenerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +int CreateLoadBalancerUDPListenerRequest::getBandwidth()const +{ + return bandwidth_; +} + +void CreateLoadBalancerUDPListenerRequest::setBandwidth(int bandwidth) +{ + bandwidth_ = bandwidth; + setParameter("Bandwidth", std::to_string(bandwidth)); +} + +std::string CreateLoadBalancerUDPListenerRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void CreateLoadBalancerUDPListenerRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long CreateLoadBalancerUDPListenerRequest::getOwnerId()const +{ + return ownerId_; +} + +void CreateLoadBalancerUDPListenerRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string CreateLoadBalancerUDPListenerRequest::getTags()const +{ + return tags_; +} + +void CreateLoadBalancerUDPListenerRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + +std::string CreateLoadBalancerUDPListenerRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void CreateLoadBalancerUDPListenerRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string CreateLoadBalancerUDPListenerRequest::getMasterSlaveServerGroupId()const +{ + return masterSlaveServerGroupId_; +} + +void CreateLoadBalancerUDPListenerRequest::setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId) +{ + masterSlaveServerGroupId_ = masterSlaveServerGroupId; + setParameter("MasterSlaveServerGroupId", masterSlaveServerGroupId); +} + +std::string CreateLoadBalancerUDPListenerRequest::getHealthCheckReq()const +{ + return healthCheckReq_; +} + +void CreateLoadBalancerUDPListenerRequest::setHealthCheckReq(const std::string& healthCheckReq) +{ + healthCheckReq_ = healthCheckReq; + setParameter("HealthCheckReq", healthCheckReq); +} + +int CreateLoadBalancerUDPListenerRequest::getBackendServerPort()const +{ + return backendServerPort_; +} + +void CreateLoadBalancerUDPListenerRequest::setBackendServerPort(int backendServerPort) +{ + backendServerPort_ = backendServerPort; + setParameter("BackendServerPort", std::to_string(backendServerPort)); +} + +int CreateLoadBalancerUDPListenerRequest::getHealthCheckInterval()const +{ + return healthCheckInterval_; +} + +void CreateLoadBalancerUDPListenerRequest::setHealthCheckInterval(int healthCheckInterval) +{ + healthCheckInterval_ = healthCheckInterval; + setParameter("HealthCheckInterval", std::to_string(healthCheckInterval)); +} + +std::string CreateLoadBalancerUDPListenerRequest::getHealthCheckExp()const +{ + return healthCheckExp_; +} + +void CreateLoadBalancerUDPListenerRequest::setHealthCheckExp(const std::string& healthCheckExp) +{ + healthCheckExp_ = healthCheckExp; + setParameter("HealthCheckExp", healthCheckExp); +} + +int CreateLoadBalancerUDPListenerRequest::getHealthCheckConnectPort()const +{ + return healthCheckConnectPort_; +} + +void CreateLoadBalancerUDPListenerRequest::setHealthCheckConnectPort(int healthCheckConnectPort) +{ + healthCheckConnectPort_ = healthCheckConnectPort; + setParameter("HealthCheckConnectPort", std::to_string(healthCheckConnectPort)); +} + diff --git a/slb/src/model/CreateLoadBalancerUDPListenerResult.cc b/slb/src/model/CreateLoadBalancerUDPListenerResult.cc new file mode 100644 index 000000000..186e64b5e --- /dev/null +++ b/slb/src/model/CreateLoadBalancerUDPListenerResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +CreateLoadBalancerUDPListenerResult::CreateLoadBalancerUDPListenerResult() : + ServiceResult() +{} + +CreateLoadBalancerUDPListenerResult::CreateLoadBalancerUDPListenerResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateLoadBalancerUDPListenerResult::~CreateLoadBalancerUDPListenerResult() +{} + +void CreateLoadBalancerUDPListenerResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/CreateMasterSlaveServerGroupRequest.cc b/slb/src/model/CreateMasterSlaveServerGroupRequest.cc new file mode 100644 index 000000000..6a4528aaa --- /dev/null +++ b/slb/src/model/CreateMasterSlaveServerGroupRequest.cc @@ -0,0 +1,149 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +CreateMasterSlaveServerGroupRequest::CreateMasterSlaveServerGroupRequest() : + SlbRequest("CreateMasterSlaveServerGroup") +{} + +CreateMasterSlaveServerGroupRequest::~CreateMasterSlaveServerGroupRequest() +{} + +std::string CreateMasterSlaveServerGroupRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void CreateMasterSlaveServerGroupRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long CreateMasterSlaveServerGroupRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void CreateMasterSlaveServerGroupRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string CreateMasterSlaveServerGroupRequest::getMasterSlaveBackendServers()const +{ + return masterSlaveBackendServers_; +} + +void CreateMasterSlaveServerGroupRequest::setMasterSlaveBackendServers(const std::string& masterSlaveBackendServers) +{ + masterSlaveBackendServers_ = masterSlaveBackendServers; + setParameter("MasterSlaveBackendServers", masterSlaveBackendServers); +} + +std::string CreateMasterSlaveServerGroupRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void CreateMasterSlaveServerGroupRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string CreateMasterSlaveServerGroupRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void CreateMasterSlaveServerGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string CreateMasterSlaveServerGroupRequest::getRegionId()const +{ + return regionId_; +} + +void CreateMasterSlaveServerGroupRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string CreateMasterSlaveServerGroupRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void CreateMasterSlaveServerGroupRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +std::string CreateMasterSlaveServerGroupRequest::getMasterSlaveServerGroupName()const +{ + return masterSlaveServerGroupName_; +} + +void CreateMasterSlaveServerGroupRequest::setMasterSlaveServerGroupName(const std::string& masterSlaveServerGroupName) +{ + masterSlaveServerGroupName_ = masterSlaveServerGroupName; + setParameter("MasterSlaveServerGroupName", masterSlaveServerGroupName); +} + +long CreateMasterSlaveServerGroupRequest::getOwnerId()const +{ + return ownerId_; +} + +void CreateMasterSlaveServerGroupRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string CreateMasterSlaveServerGroupRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void CreateMasterSlaveServerGroupRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string CreateMasterSlaveServerGroupRequest::getTags()const +{ + return tags_; +} + +void CreateMasterSlaveServerGroupRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/CreateMasterSlaveServerGroupResult.cc b/slb/src/model/CreateMasterSlaveServerGroupResult.cc new file mode 100644 index 000000000..053d95c79 --- /dev/null +++ b/slb/src/model/CreateMasterSlaveServerGroupResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +CreateMasterSlaveServerGroupResult::CreateMasterSlaveServerGroupResult() : + ServiceResult() +{} + +CreateMasterSlaveServerGroupResult::CreateMasterSlaveServerGroupResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateMasterSlaveServerGroupResult::~CreateMasterSlaveServerGroupResult() +{} + +void CreateMasterSlaveServerGroupResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allMasterSlaveBackendServers = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"]; + for (auto value : allMasterSlaveBackendServers) + { + MasterSlaveBackendServer masterSlaveBackendServerObject; + masterSlaveBackendServerObject.serverId = value["ServerId"].asString(); + masterSlaveBackendServerObject.port = std::stoi(value["Port"].asString()); + masterSlaveBackendServerObject.weight = std::stoi(value["Weight"].asString()); + masterSlaveBackendServerObject.serverType = value["ServerType"].asString(); + masterSlaveBackendServers_.push_back(masterSlaveBackendServerObject); + } + masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString(); + +} + +std::string CreateMasterSlaveServerGroupResult::getMasterSlaveServerGroupId()const +{ + return masterSlaveServerGroupId_; +} + +void CreateMasterSlaveServerGroupResult::setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId) +{ + masterSlaveServerGroupId_ = masterSlaveServerGroupId; +} + diff --git a/slb/src/model/CreateMasterSlaveVServerGroupRequest.cc b/slb/src/model/CreateMasterSlaveVServerGroupRequest.cc new file mode 100644 index 000000000..9df5a8b2a --- /dev/null +++ b/slb/src/model/CreateMasterSlaveVServerGroupRequest.cc @@ -0,0 +1,149 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +CreateMasterSlaveVServerGroupRequest::CreateMasterSlaveVServerGroupRequest() : + SlbRequest("CreateMasterSlaveVServerGroup") +{} + +CreateMasterSlaveVServerGroupRequest::~CreateMasterSlaveVServerGroupRequest() +{} + +std::string CreateMasterSlaveVServerGroupRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void CreateMasterSlaveVServerGroupRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long CreateMasterSlaveVServerGroupRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void CreateMasterSlaveVServerGroupRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string CreateMasterSlaveVServerGroupRequest::getMasterSlaveBackendServers()const +{ + return masterSlaveBackendServers_; +} + +void CreateMasterSlaveVServerGroupRequest::setMasterSlaveBackendServers(const std::string& masterSlaveBackendServers) +{ + masterSlaveBackendServers_ = masterSlaveBackendServers; + setParameter("MasterSlaveBackendServers", masterSlaveBackendServers); +} + +std::string CreateMasterSlaveVServerGroupRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void CreateMasterSlaveVServerGroupRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string CreateMasterSlaveVServerGroupRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void CreateMasterSlaveVServerGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string CreateMasterSlaveVServerGroupRequest::getRegionId()const +{ + return regionId_; +} + +void CreateMasterSlaveVServerGroupRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string CreateMasterSlaveVServerGroupRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void CreateMasterSlaveVServerGroupRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +std::string CreateMasterSlaveVServerGroupRequest::getMasterSlaveVServerGroupName()const +{ + return masterSlaveVServerGroupName_; +} + +void CreateMasterSlaveVServerGroupRequest::setMasterSlaveVServerGroupName(const std::string& masterSlaveVServerGroupName) +{ + masterSlaveVServerGroupName_ = masterSlaveVServerGroupName; + setParameter("MasterSlaveVServerGroupName", masterSlaveVServerGroupName); +} + +long CreateMasterSlaveVServerGroupRequest::getOwnerId()const +{ + return ownerId_; +} + +void CreateMasterSlaveVServerGroupRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string CreateMasterSlaveVServerGroupRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void CreateMasterSlaveVServerGroupRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string CreateMasterSlaveVServerGroupRequest::getTags()const +{ + return tags_; +} + +void CreateMasterSlaveVServerGroupRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/CreateMasterSlaveVServerGroupResult.cc b/slb/src/model/CreateMasterSlaveVServerGroupResult.cc new file mode 100644 index 000000000..9ebea74df --- /dev/null +++ b/slb/src/model/CreateMasterSlaveVServerGroupResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +CreateMasterSlaveVServerGroupResult::CreateMasterSlaveVServerGroupResult() : + ServiceResult() +{} + +CreateMasterSlaveVServerGroupResult::CreateMasterSlaveVServerGroupResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateMasterSlaveVServerGroupResult::~CreateMasterSlaveVServerGroupResult() +{} + +void CreateMasterSlaveVServerGroupResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allMasterSlaveBackendServers = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"]; + for (auto value : allMasterSlaveBackendServers) + { + MasterSlaveBackendServer masterSlaveBackendServerObject; + masterSlaveBackendServerObject.serverId = value["ServerId"].asString(); + masterSlaveBackendServerObject.port = std::stoi(value["Port"].asString()); + masterSlaveBackendServerObject.weight = std::stoi(value["Weight"].asString()); + masterSlaveBackendServerObject.isBackup = std::stoi(value["IsBackup"].asString()); + masterSlaveBackendServers_.push_back(masterSlaveBackendServerObject); + } + masterSlaveVServerGroupId_ = value["MasterSlaveVServerGroupId"].asString(); + +} + +std::string CreateMasterSlaveVServerGroupResult::getMasterSlaveVServerGroupId()const +{ + return masterSlaveVServerGroupId_; +} + +void CreateMasterSlaveVServerGroupResult::setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId) +{ + masterSlaveVServerGroupId_ = masterSlaveVServerGroupId; +} + diff --git a/slb/src/model/CreateRulesRequest.cc b/slb/src/model/CreateRulesRequest.cc new file mode 100644 index 000000000..f192f56c2 --- /dev/null +++ b/slb/src/model/CreateRulesRequest.cc @@ -0,0 +1,149 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +CreateRulesRequest::CreateRulesRequest() : + SlbRequest("CreateRules") +{} + +CreateRulesRequest::~CreateRulesRequest() +{} + +std::string CreateRulesRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void CreateRulesRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long CreateRulesRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void CreateRulesRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +int CreateRulesRequest::getListenerPort()const +{ + return listenerPort_; +} + +void CreateRulesRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string CreateRulesRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void CreateRulesRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string CreateRulesRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void CreateRulesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string CreateRulesRequest::getRegionId()const +{ + return regionId_; +} + +void CreateRulesRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string CreateRulesRequest::getRuleList()const +{ + return ruleList_; +} + +void CreateRulesRequest::setRuleList(const std::string& ruleList) +{ + ruleList_ = ruleList; + setParameter("RuleList", ruleList); +} + +std::string CreateRulesRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void CreateRulesRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long CreateRulesRequest::getOwnerId()const +{ + return ownerId_; +} + +void CreateRulesRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string CreateRulesRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void CreateRulesRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string CreateRulesRequest::getTags()const +{ + return tags_; +} + +void CreateRulesRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/CreateRulesResult.cc b/slb/src/model/CreateRulesResult.cc new file mode 100644 index 000000000..2417ff0e7 --- /dev/null +++ b/slb/src/model/CreateRulesResult.cc @@ -0,0 +1,53 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +CreateRulesResult::CreateRulesResult() : + ServiceResult() +{} + +CreateRulesResult::CreateRulesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateRulesResult::~CreateRulesResult() +{} + +void CreateRulesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allRules = value["Rules"]["Rule"]; + for (auto value : allRules) + { + Rule ruleObject; + ruleObject.ruleId = value["RuleId"].asString(); + ruleObject.ruleName = value["RuleName"].asString(); + rules_.push_back(ruleObject); + } + +} + diff --git a/slb/src/model/CreateVServerGroupRequest.cc b/slb/src/model/CreateVServerGroupRequest.cc new file mode 100644 index 000000000..c0d971758 --- /dev/null +++ b/slb/src/model/CreateVServerGroupRequest.cc @@ -0,0 +1,149 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +CreateVServerGroupRequest::CreateVServerGroupRequest() : + SlbRequest("CreateVServerGroup") +{} + +CreateVServerGroupRequest::~CreateVServerGroupRequest() +{} + +std::string CreateVServerGroupRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void CreateVServerGroupRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long CreateVServerGroupRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void CreateVServerGroupRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string CreateVServerGroupRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void CreateVServerGroupRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string CreateVServerGroupRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void CreateVServerGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string CreateVServerGroupRequest::getRegionId()const +{ + return regionId_; +} + +void CreateVServerGroupRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string CreateVServerGroupRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void CreateVServerGroupRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long CreateVServerGroupRequest::getOwnerId()const +{ + return ownerId_; +} + +void CreateVServerGroupRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string CreateVServerGroupRequest::getBackendServers()const +{ + return backendServers_; +} + +void CreateVServerGroupRequest::setBackendServers(const std::string& backendServers) +{ + backendServers_ = backendServers; + setParameter("BackendServers", backendServers); +} + +std::string CreateVServerGroupRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void CreateVServerGroupRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string CreateVServerGroupRequest::getTags()const +{ + return tags_; +} + +void CreateVServerGroupRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + +std::string CreateVServerGroupRequest::getVServerGroupName()const +{ + return vServerGroupName_; +} + +void CreateVServerGroupRequest::setVServerGroupName(const std::string& vServerGroupName) +{ + vServerGroupName_ = vServerGroupName; + setParameter("VServerGroupName", vServerGroupName); +} + diff --git a/slb/src/model/CreateVServerGroupResult.cc b/slb/src/model/CreateVServerGroupResult.cc new file mode 100644 index 000000000..dac0e08dd --- /dev/null +++ b/slb/src/model/CreateVServerGroupResult.cc @@ -0,0 +1,65 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +CreateVServerGroupResult::CreateVServerGroupResult() : + ServiceResult() +{} + +CreateVServerGroupResult::CreateVServerGroupResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateVServerGroupResult::~CreateVServerGroupResult() +{} + +void CreateVServerGroupResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allBackendServers = value["BackendServers"]["BackendServer"]; + for (auto value : allBackendServers) + { + BackendServer backendServerObject; + backendServerObject.serverId = value["ServerId"].asString(); + backendServerObject.port = std::stoi(value["Port"].asString()); + backendServerObject.weight = std::stoi(value["Weight"].asString()); + backendServers_.push_back(backendServerObject); + } + vServerGroupId_ = value["VServerGroupId"].asString(); + +} + +std::string CreateVServerGroupResult::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void CreateVServerGroupResult::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; +} + diff --git a/slb/src/model/DeleteCACertificateRequest.cc b/slb/src/model/DeleteCACertificateRequest.cc new file mode 100644 index 000000000..09300adef --- /dev/null +++ b/slb/src/model/DeleteCACertificateRequest.cc @@ -0,0 +1,116 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DeleteCACertificateRequest::DeleteCACertificateRequest() : + SlbRequest("DeleteCACertificate") +{} + +DeleteCACertificateRequest::~DeleteCACertificateRequest() +{} + +std::string DeleteCACertificateRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DeleteCACertificateRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DeleteCACertificateRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DeleteCACertificateRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DeleteCACertificateRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DeleteCACertificateRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DeleteCACertificateRequest::getRegionId()const +{ + return regionId_; +} + +void DeleteCACertificateRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DeleteCACertificateRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DeleteCACertificateRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DeleteCACertificateRequest::getOwnerId()const +{ + return ownerId_; +} + +void DeleteCACertificateRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DeleteCACertificateRequest::getCACertificateId()const +{ + return cACertificateId_; +} + +void DeleteCACertificateRequest::setCACertificateId(const std::string& cACertificateId) +{ + cACertificateId_ = cACertificateId; + setParameter("CACertificateId", cACertificateId); +} + +std::string DeleteCACertificateRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DeleteCACertificateRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + diff --git a/slb/src/model/DeleteCACertificateResult.cc b/slb/src/model/DeleteCACertificateResult.cc new file mode 100644 index 000000000..1a2e77a07 --- /dev/null +++ b/slb/src/model/DeleteCACertificateResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DeleteCACertificateResult::DeleteCACertificateResult() : + ServiceResult() +{} + +DeleteCACertificateResult::DeleteCACertificateResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteCACertificateResult::~DeleteCACertificateResult() +{} + +void DeleteCACertificateResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/DeleteLoadBalancerListenerRequest.cc b/slb/src/model/DeleteLoadBalancerListenerRequest.cc new file mode 100644 index 000000000..28b43529b --- /dev/null +++ b/slb/src/model/DeleteLoadBalancerListenerRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DeleteLoadBalancerListenerRequest::DeleteLoadBalancerListenerRequest() : + SlbRequest("DeleteLoadBalancerListener") +{} + +DeleteLoadBalancerListenerRequest::~DeleteLoadBalancerListenerRequest() +{} + +std::string DeleteLoadBalancerListenerRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DeleteLoadBalancerListenerRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DeleteLoadBalancerListenerRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DeleteLoadBalancerListenerRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +int DeleteLoadBalancerListenerRequest::getListenerPort()const +{ + return listenerPort_; +} + +void DeleteLoadBalancerListenerRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string DeleteLoadBalancerListenerRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void DeleteLoadBalancerListenerRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string DeleteLoadBalancerListenerRequest::getRegionId()const +{ + return regionId_; +} + +void DeleteLoadBalancerListenerRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DeleteLoadBalancerListenerRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DeleteLoadBalancerListenerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DeleteLoadBalancerListenerRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DeleteLoadBalancerListenerRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DeleteLoadBalancerListenerRequest::getOwnerId()const +{ + return ownerId_; +} + +void DeleteLoadBalancerListenerRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DeleteLoadBalancerListenerRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DeleteLoadBalancerListenerRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DeleteLoadBalancerListenerRequest::getTags()const +{ + return tags_; +} + +void DeleteLoadBalancerListenerRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DeleteLoadBalancerListenerResult.cc b/slb/src/model/DeleteLoadBalancerListenerResult.cc new file mode 100644 index 000000000..ecfd2dd15 --- /dev/null +++ b/slb/src/model/DeleteLoadBalancerListenerResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DeleteLoadBalancerListenerResult::DeleteLoadBalancerListenerResult() : + ServiceResult() +{} + +DeleteLoadBalancerListenerResult::DeleteLoadBalancerListenerResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteLoadBalancerListenerResult::~DeleteLoadBalancerListenerResult() +{} + +void DeleteLoadBalancerListenerResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/DeleteLoadBalancerRequest.cc b/slb/src/model/DeleteLoadBalancerRequest.cc new file mode 100644 index 000000000..e03f3b210 --- /dev/null +++ b/slb/src/model/DeleteLoadBalancerRequest.cc @@ -0,0 +1,127 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DeleteLoadBalancerRequest::DeleteLoadBalancerRequest() : + SlbRequest("DeleteLoadBalancer") +{} + +DeleteLoadBalancerRequest::~DeleteLoadBalancerRequest() +{} + +std::string DeleteLoadBalancerRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DeleteLoadBalancerRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DeleteLoadBalancerRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DeleteLoadBalancerRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DeleteLoadBalancerRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void DeleteLoadBalancerRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string DeleteLoadBalancerRequest::getRegionId()const +{ + return regionId_; +} + +void DeleteLoadBalancerRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DeleteLoadBalancerRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DeleteLoadBalancerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DeleteLoadBalancerRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DeleteLoadBalancerRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DeleteLoadBalancerRequest::getOwnerId()const +{ + return ownerId_; +} + +void DeleteLoadBalancerRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DeleteLoadBalancerRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DeleteLoadBalancerRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DeleteLoadBalancerRequest::getTags()const +{ + return tags_; +} + +void DeleteLoadBalancerRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DeleteLoadBalancerResult.cc b/slb/src/model/DeleteLoadBalancerResult.cc new file mode 100644 index 000000000..e216a36c2 --- /dev/null +++ b/slb/src/model/DeleteLoadBalancerResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DeleteLoadBalancerResult::DeleteLoadBalancerResult() : + ServiceResult() +{} + +DeleteLoadBalancerResult::DeleteLoadBalancerResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteLoadBalancerResult::~DeleteLoadBalancerResult() +{} + +void DeleteLoadBalancerResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/DeleteMasterSlaveServerGroupRequest.cc b/slb/src/model/DeleteMasterSlaveServerGroupRequest.cc new file mode 100644 index 000000000..d3a808d15 --- /dev/null +++ b/slb/src/model/DeleteMasterSlaveServerGroupRequest.cc @@ -0,0 +1,127 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DeleteMasterSlaveServerGroupRequest::DeleteMasterSlaveServerGroupRequest() : + SlbRequest("DeleteMasterSlaveServerGroup") +{} + +DeleteMasterSlaveServerGroupRequest::~DeleteMasterSlaveServerGroupRequest() +{} + +std::string DeleteMasterSlaveServerGroupRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DeleteMasterSlaveServerGroupRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DeleteMasterSlaveServerGroupRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DeleteMasterSlaveServerGroupRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DeleteMasterSlaveServerGroupRequest::getMasterSlaveServerGroupId()const +{ + return masterSlaveServerGroupId_; +} + +void DeleteMasterSlaveServerGroupRequest::setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId) +{ + masterSlaveServerGroupId_ = masterSlaveServerGroupId; + setParameter("MasterSlaveServerGroupId", masterSlaveServerGroupId); +} + +std::string DeleteMasterSlaveServerGroupRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DeleteMasterSlaveServerGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DeleteMasterSlaveServerGroupRequest::getRegionId()const +{ + return regionId_; +} + +void DeleteMasterSlaveServerGroupRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DeleteMasterSlaveServerGroupRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DeleteMasterSlaveServerGroupRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DeleteMasterSlaveServerGroupRequest::getOwnerId()const +{ + return ownerId_; +} + +void DeleteMasterSlaveServerGroupRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DeleteMasterSlaveServerGroupRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DeleteMasterSlaveServerGroupRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DeleteMasterSlaveServerGroupRequest::getTags()const +{ + return tags_; +} + +void DeleteMasterSlaveServerGroupRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DeleteMasterSlaveServerGroupResult.cc b/slb/src/model/DeleteMasterSlaveServerGroupResult.cc new file mode 100644 index 000000000..51f448aff --- /dev/null +++ b/slb/src/model/DeleteMasterSlaveServerGroupResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DeleteMasterSlaveServerGroupResult::DeleteMasterSlaveServerGroupResult() : + ServiceResult() +{} + +DeleteMasterSlaveServerGroupResult::DeleteMasterSlaveServerGroupResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteMasterSlaveServerGroupResult::~DeleteMasterSlaveServerGroupResult() +{} + +void DeleteMasterSlaveServerGroupResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/DeleteMasterSlaveVServerGroupRequest.cc b/slb/src/model/DeleteMasterSlaveVServerGroupRequest.cc new file mode 100644 index 000000000..753f338b0 --- /dev/null +++ b/slb/src/model/DeleteMasterSlaveVServerGroupRequest.cc @@ -0,0 +1,127 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DeleteMasterSlaveVServerGroupRequest::DeleteMasterSlaveVServerGroupRequest() : + SlbRequest("DeleteMasterSlaveVServerGroup") +{} + +DeleteMasterSlaveVServerGroupRequest::~DeleteMasterSlaveVServerGroupRequest() +{} + +std::string DeleteMasterSlaveVServerGroupRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DeleteMasterSlaveVServerGroupRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DeleteMasterSlaveVServerGroupRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DeleteMasterSlaveVServerGroupRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DeleteMasterSlaveVServerGroupRequest::getMasterSlaveVServerGroupId()const +{ + return masterSlaveVServerGroupId_; +} + +void DeleteMasterSlaveVServerGroupRequest::setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId) +{ + masterSlaveVServerGroupId_ = masterSlaveVServerGroupId; + setParameter("MasterSlaveVServerGroupId", masterSlaveVServerGroupId); +} + +std::string DeleteMasterSlaveVServerGroupRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DeleteMasterSlaveVServerGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DeleteMasterSlaveVServerGroupRequest::getRegionId()const +{ + return regionId_; +} + +void DeleteMasterSlaveVServerGroupRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DeleteMasterSlaveVServerGroupRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DeleteMasterSlaveVServerGroupRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DeleteMasterSlaveVServerGroupRequest::getOwnerId()const +{ + return ownerId_; +} + +void DeleteMasterSlaveVServerGroupRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DeleteMasterSlaveVServerGroupRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DeleteMasterSlaveVServerGroupRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DeleteMasterSlaveVServerGroupRequest::getTags()const +{ + return tags_; +} + +void DeleteMasterSlaveVServerGroupRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DeleteMasterSlaveVServerGroupResult.cc b/slb/src/model/DeleteMasterSlaveVServerGroupResult.cc new file mode 100644 index 000000000..a85fe311a --- /dev/null +++ b/slb/src/model/DeleteMasterSlaveVServerGroupResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DeleteMasterSlaveVServerGroupResult::DeleteMasterSlaveVServerGroupResult() : + ServiceResult() +{} + +DeleteMasterSlaveVServerGroupResult::DeleteMasterSlaveVServerGroupResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteMasterSlaveVServerGroupResult::~DeleteMasterSlaveVServerGroupResult() +{} + +void DeleteMasterSlaveVServerGroupResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/DeleteRulesRequest.cc b/slb/src/model/DeleteRulesRequest.cc new file mode 100644 index 000000000..dde7028a7 --- /dev/null +++ b/slb/src/model/DeleteRulesRequest.cc @@ -0,0 +1,127 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DeleteRulesRequest::DeleteRulesRequest() : + SlbRequest("DeleteRules") +{} + +DeleteRulesRequest::~DeleteRulesRequest() +{} + +std::string DeleteRulesRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DeleteRulesRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DeleteRulesRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DeleteRulesRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DeleteRulesRequest::getRuleIds()const +{ + return ruleIds_; +} + +void DeleteRulesRequest::setRuleIds(const std::string& ruleIds) +{ + ruleIds_ = ruleIds; + setParameter("RuleIds", ruleIds); +} + +std::string DeleteRulesRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DeleteRulesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DeleteRulesRequest::getRegionId()const +{ + return regionId_; +} + +void DeleteRulesRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DeleteRulesRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DeleteRulesRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DeleteRulesRequest::getOwnerId()const +{ + return ownerId_; +} + +void DeleteRulesRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DeleteRulesRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DeleteRulesRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DeleteRulesRequest::getTags()const +{ + return tags_; +} + +void DeleteRulesRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DeleteRulesResult.cc b/slb/src/model/DeleteRulesResult.cc new file mode 100644 index 000000000..75ab2adb1 --- /dev/null +++ b/slb/src/model/DeleteRulesResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DeleteRulesResult::DeleteRulesResult() : + ServiceResult() +{} + +DeleteRulesResult::DeleteRulesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteRulesResult::~DeleteRulesResult() +{} + +void DeleteRulesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/DeleteServerCertificateRequest.cc b/slb/src/model/DeleteServerCertificateRequest.cc new file mode 100644 index 000000000..b17644135 --- /dev/null +++ b/slb/src/model/DeleteServerCertificateRequest.cc @@ -0,0 +1,127 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DeleteServerCertificateRequest::DeleteServerCertificateRequest() : + SlbRequest("DeleteServerCertificate") +{} + +DeleteServerCertificateRequest::~DeleteServerCertificateRequest() +{} + +std::string DeleteServerCertificateRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DeleteServerCertificateRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DeleteServerCertificateRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DeleteServerCertificateRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DeleteServerCertificateRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DeleteServerCertificateRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DeleteServerCertificateRequest::getRegionId()const +{ + return regionId_; +} + +void DeleteServerCertificateRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DeleteServerCertificateRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DeleteServerCertificateRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DeleteServerCertificateRequest::getOwnerId()const +{ + return ownerId_; +} + +void DeleteServerCertificateRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DeleteServerCertificateRequest::getServerCertificateId()const +{ + return serverCertificateId_; +} + +void DeleteServerCertificateRequest::setServerCertificateId(const std::string& serverCertificateId) +{ + serverCertificateId_ = serverCertificateId; + setParameter("ServerCertificateId", serverCertificateId); +} + +std::string DeleteServerCertificateRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DeleteServerCertificateRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DeleteServerCertificateRequest::getTags()const +{ + return tags_; +} + +void DeleteServerCertificateRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DeleteServerCertificateResult.cc b/slb/src/model/DeleteServerCertificateResult.cc new file mode 100644 index 000000000..9045e3d8a --- /dev/null +++ b/slb/src/model/DeleteServerCertificateResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DeleteServerCertificateResult::DeleteServerCertificateResult() : + ServiceResult() +{} + +DeleteServerCertificateResult::DeleteServerCertificateResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteServerCertificateResult::~DeleteServerCertificateResult() +{} + +void DeleteServerCertificateResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/DeleteVServerGroupRequest.cc b/slb/src/model/DeleteVServerGroupRequest.cc new file mode 100644 index 000000000..fe49a09fa --- /dev/null +++ b/slb/src/model/DeleteVServerGroupRequest.cc @@ -0,0 +1,127 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DeleteVServerGroupRequest::DeleteVServerGroupRequest() : + SlbRequest("DeleteVServerGroup") +{} + +DeleteVServerGroupRequest::~DeleteVServerGroupRequest() +{} + +std::string DeleteVServerGroupRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DeleteVServerGroupRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +std::string DeleteVServerGroupRequest::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void DeleteVServerGroupRequest::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; + setParameter("VServerGroupId", vServerGroupId); +} + +long DeleteVServerGroupRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DeleteVServerGroupRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DeleteVServerGroupRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DeleteVServerGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DeleteVServerGroupRequest::getRegionId()const +{ + return regionId_; +} + +void DeleteVServerGroupRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DeleteVServerGroupRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DeleteVServerGroupRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DeleteVServerGroupRequest::getOwnerId()const +{ + return ownerId_; +} + +void DeleteVServerGroupRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DeleteVServerGroupRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DeleteVServerGroupRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DeleteVServerGroupRequest::getTags()const +{ + return tags_; +} + +void DeleteVServerGroupRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DeleteVServerGroupResult.cc b/slb/src/model/DeleteVServerGroupResult.cc new file mode 100644 index 000000000..8bcb8495f --- /dev/null +++ b/slb/src/model/DeleteVServerGroupResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DeleteVServerGroupResult::DeleteVServerGroupResult() : + ServiceResult() +{} + +DeleteVServerGroupResult::DeleteVServerGroupResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteVServerGroupResult::~DeleteVServerGroupResult() +{} + +void DeleteVServerGroupResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/DescribeCACertificatesRequest.cc b/slb/src/model/DescribeCACertificatesRequest.cc new file mode 100644 index 000000000..52b47934d --- /dev/null +++ b/slb/src/model/DescribeCACertificatesRequest.cc @@ -0,0 +1,127 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeCACertificatesRequest::DescribeCACertificatesRequest() : + SlbRequest("DescribeCACertificates") +{} + +DescribeCACertificatesRequest::~DescribeCACertificatesRequest() +{} + +std::string DescribeCACertificatesRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeCACertificatesRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +std::string DescribeCACertificatesRequest::getResourceGroupId()const +{ + return resourceGroupId_; +} + +void DescribeCACertificatesRequest::setResourceGroupId(const std::string& resourceGroupId) +{ + resourceGroupId_ = resourceGroupId; + setParameter("ResourceGroupId", resourceGroupId); +} + +long DescribeCACertificatesRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeCACertificatesRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DescribeCACertificatesRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeCACertificatesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeCACertificatesRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeCACertificatesRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeCACertificatesRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeCACertificatesRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeCACertificatesRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeCACertificatesRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeCACertificatesRequest::getCACertificateId()const +{ + return cACertificateId_; +} + +void DescribeCACertificatesRequest::setCACertificateId(const std::string& cACertificateId) +{ + cACertificateId_ = cACertificateId; + setParameter("CACertificateId", cACertificateId); +} + +std::string DescribeCACertificatesRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeCACertificatesRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + diff --git a/slb/src/model/DescribeCACertificatesResult.cc b/slb/src/model/DescribeCACertificatesResult.cc new file mode 100644 index 000000000..84aee2b6e --- /dev/null +++ b/slb/src/model/DescribeCACertificatesResult.cc @@ -0,0 +1,58 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeCACertificatesResult::DescribeCACertificatesResult() : + ServiceResult() +{} + +DescribeCACertificatesResult::DescribeCACertificatesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeCACertificatesResult::~DescribeCACertificatesResult() +{} + +void DescribeCACertificatesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allCACertificates = value["CACertificates"]["CACertificate"]; + for (auto value : allCACertificates) + { + CACertificate cACertificateObject; + cACertificateObject.regionId = value["RegionId"].asString(); + cACertificateObject.cACertificateId = value["CACertificateId"].asString(); + cACertificateObject.cACertificateName = value["CACertificateName"].asString(); + cACertificateObject.fingerprint = value["Fingerprint"].asString(); + cACertificateObject.resourceGroupId = value["ResourceGroupId"].asString(); + cACertificateObject.createTime = value["CreateTime"].asString(); + cACertificateObject.createTimeStamp = std::stol(value["CreateTimeStamp"].asString()); + cACertificates_.push_back(cACertificateObject); + } + +} + diff --git a/slb/src/model/DescribeHealthStatusRequest.cc b/slb/src/model/DescribeHealthStatusRequest.cc new file mode 100644 index 000000000..a6a88f3e1 --- /dev/null +++ b/slb/src/model/DescribeHealthStatusRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeHealthStatusRequest::DescribeHealthStatusRequest() : + SlbRequest("DescribeHealthStatus") +{} + +DescribeHealthStatusRequest::~DescribeHealthStatusRequest() +{} + +std::string DescribeHealthStatusRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeHealthStatusRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DescribeHealthStatusRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeHealthStatusRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +int DescribeHealthStatusRequest::getListenerPort()const +{ + return listenerPort_; +} + +void DescribeHealthStatusRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string DescribeHealthStatusRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void DescribeHealthStatusRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string DescribeHealthStatusRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeHealthStatusRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeHealthStatusRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeHealthStatusRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeHealthStatusRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeHealthStatusRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeHealthStatusRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeHealthStatusRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeHealthStatusRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeHealthStatusRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeHealthStatusRequest::getTags()const +{ + return tags_; +} + +void DescribeHealthStatusRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DescribeHealthStatusResult.cc b/slb/src/model/DescribeHealthStatusResult.cc new file mode 100644 index 000000000..61ffb08b5 --- /dev/null +++ b/slb/src/model/DescribeHealthStatusResult.cc @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeHealthStatusResult::DescribeHealthStatusResult() : + ServiceResult() +{} + +DescribeHealthStatusResult::DescribeHealthStatusResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeHealthStatusResult::~DescribeHealthStatusResult() +{} + +void DescribeHealthStatusResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allBackendServers = value["BackendServers"]["BackendServer"]; + for (auto value : allBackendServers) + { + BackendServer backendServerObject; + backendServerObject.listenerPort = std::stoi(value["ListenerPort"].asString()); + backendServerObject.serverId = value["ServerId"].asString(); + backendServerObject.port = std::stoi(value["Port"].asString()); + backendServerObject.serverHealthStatus = value["ServerHealthStatus"].asString(); + backendServers_.push_back(backendServerObject); + } + +} + diff --git a/slb/src/model/DescribeListenerAccessControlAttributeRequest.cc b/slb/src/model/DescribeListenerAccessControlAttributeRequest.cc new file mode 100644 index 000000000..200dd49db --- /dev/null +++ b/slb/src/model/DescribeListenerAccessControlAttributeRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeListenerAccessControlAttributeRequest::DescribeListenerAccessControlAttributeRequest() : + SlbRequest("DescribeListenerAccessControlAttribute") +{} + +DescribeListenerAccessControlAttributeRequest::~DescribeListenerAccessControlAttributeRequest() +{} + +std::string DescribeListenerAccessControlAttributeRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeListenerAccessControlAttributeRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DescribeListenerAccessControlAttributeRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeListenerAccessControlAttributeRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +int DescribeListenerAccessControlAttributeRequest::getListenerPort()const +{ + return listenerPort_; +} + +void DescribeListenerAccessControlAttributeRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string DescribeListenerAccessControlAttributeRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void DescribeListenerAccessControlAttributeRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string DescribeListenerAccessControlAttributeRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeListenerAccessControlAttributeRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeListenerAccessControlAttributeRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeListenerAccessControlAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeListenerAccessControlAttributeRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeListenerAccessControlAttributeRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeListenerAccessControlAttributeRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeListenerAccessControlAttributeRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeListenerAccessControlAttributeRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeListenerAccessControlAttributeRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeListenerAccessControlAttributeRequest::getTags()const +{ + return tags_; +} + +void DescribeListenerAccessControlAttributeRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DescribeListenerAccessControlAttributeResult.cc b/slb/src/model/DescribeListenerAccessControlAttributeResult.cc new file mode 100644 index 000000000..7d6516895 --- /dev/null +++ b/slb/src/model/DescribeListenerAccessControlAttributeResult.cc @@ -0,0 +1,67 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeListenerAccessControlAttributeResult::DescribeListenerAccessControlAttributeResult() : + ServiceResult() +{} + +DescribeListenerAccessControlAttributeResult::DescribeListenerAccessControlAttributeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeListenerAccessControlAttributeResult::~DescribeListenerAccessControlAttributeResult() +{} + +void DescribeListenerAccessControlAttributeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + accessControlStatus_ = value["AccessControlStatus"].asString(); + sourceItems_ = value["SourceItems"].asString(); + +} + +std::string DescribeListenerAccessControlAttributeResult::getAccessControlStatus()const +{ + return accessControlStatus_; +} + +void DescribeListenerAccessControlAttributeResult::setAccessControlStatus(const std::string& accessControlStatus) +{ + accessControlStatus_ = accessControlStatus; +} + +std::string DescribeListenerAccessControlAttributeResult::getSourceItems()const +{ + return sourceItems_; +} + +void DescribeListenerAccessControlAttributeResult::setSourceItems(const std::string& sourceItems) +{ + sourceItems_ = sourceItems; +} + diff --git a/slb/src/model/DescribeLoadBalancerAttributeRequest.cc b/slb/src/model/DescribeLoadBalancerAttributeRequest.cc new file mode 100644 index 000000000..d80f4a611 --- /dev/null +++ b/slb/src/model/DescribeLoadBalancerAttributeRequest.cc @@ -0,0 +1,127 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeLoadBalancerAttributeRequest::DescribeLoadBalancerAttributeRequest() : + SlbRequest("DescribeLoadBalancerAttribute") +{} + +DescribeLoadBalancerAttributeRequest::~DescribeLoadBalancerAttributeRequest() +{} + +std::string DescribeLoadBalancerAttributeRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeLoadBalancerAttributeRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DescribeLoadBalancerAttributeRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeLoadBalancerAttributeRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DescribeLoadBalancerAttributeRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void DescribeLoadBalancerAttributeRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string DescribeLoadBalancerAttributeRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeLoadBalancerAttributeRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeLoadBalancerAttributeRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeLoadBalancerAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeLoadBalancerAttributeRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeLoadBalancerAttributeRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeLoadBalancerAttributeRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeLoadBalancerAttributeRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeLoadBalancerAttributeRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeLoadBalancerAttributeRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeLoadBalancerAttributeRequest::getTags()const +{ + return tags_; +} + +void DescribeLoadBalancerAttributeRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DescribeLoadBalancerAttributeResult.cc b/slb/src/model/DescribeLoadBalancerAttributeResult.cc new file mode 100644 index 000000000..53be42163 --- /dev/null +++ b/slb/src/model/DescribeLoadBalancerAttributeResult.cc @@ -0,0 +1,324 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeLoadBalancerAttributeResult::DescribeLoadBalancerAttributeResult() : + ServiceResult() +{} + +DescribeLoadBalancerAttributeResult::DescribeLoadBalancerAttributeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeLoadBalancerAttributeResult::~DescribeLoadBalancerAttributeResult() +{} + +void DescribeLoadBalancerAttributeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allListenerPortsAndProtocal = value["ListenerPortsAndProtocal"]["ListenerPortAndProtocal"]; + for (auto value : allListenerPortsAndProtocal) + { + ListenerPortAndProtocal listenerPortAndProtocalObject; + listenerPortAndProtocalObject.listenerPort = std::stoi(value["ListenerPort"].asString()); + listenerPortAndProtocalObject.listenerProtocal = value["ListenerProtocal"].asString(); + listenerPortsAndProtocal_.push_back(listenerPortAndProtocalObject); + } + auto allListenerPortsAndProtocol = value["ListenerPortsAndProtocol"]["ListenerPortAndProtocol"]; + for (auto value : allListenerPortsAndProtocol) + { + ListenerPortAndProtocol listenerPortAndProtocolObject; + listenerPortAndProtocolObject.listenerPort = std::stoi(value["ListenerPort"].asString()); + listenerPortAndProtocolObject.listenerProtocol = value["ListenerProtocol"].asString(); + listenerPortsAndProtocol_.push_back(listenerPortAndProtocolObject); + } + auto allBackendServers = value["BackendServers"]["BackendServer"]; + for (auto value : allBackendServers) + { + BackendServer backendServerObject; + backendServerObject.serverId = value["ServerId"].asString(); + backendServerObject.weight = std::stoi(value["Weight"].asString()); + backendServers_.push_back(backendServerObject); + } + auto allListenerPorts = value["ListenerPorts"]["ListenerPort"]; + for (const auto &item : allListenerPorts) + listenerPorts_.push_back(item.asString()); + loadBalancerId_ = value["LoadBalancerId"].asString(); + resourceGroupId_ = value["ResourceGroupId"].asString(); + loadBalancerName_ = value["LoadBalancerName"].asString(); + loadBalancerStatus_ = value["LoadBalancerStatus"].asString(); + regionId_ = value["RegionId"].asString(); + regionIdAlias_ = value["RegionIdAlias"].asString(); + address_ = value["Address"].asString(); + addressType_ = value["AddressType"].asString(); + vpcId_ = value["VpcId"].asString(); + vSwitchId_ = value["VSwitchId"].asString(); + networkType_ = value["NetworkType"].asString(); + internetChargeType_ = value["InternetChargeType"].asString(); + autoReleaseTime_ = std::stol(value["AutoReleaseTime"].asString()); + bandwidth_ = std::stoi(value["Bandwidth"].asString()); + loadBalancerSpec_ = value["LoadBalancerSpec"].asString(); + createTime_ = value["CreateTime"].asString(); + createTimeStamp_ = std::stol(value["CreateTimeStamp"].asString()); + endTime_ = value["EndTime"].asString(); + endTimeStamp_ = std::stol(value["EndTimeStamp"].asString()); + payType_ = value["PayType"].asString(); + masterZoneId_ = value["MasterZoneId"].asString(); + slaveZoneId_ = value["SlaveZoneId"].asString(); + +} + +std::string DescribeLoadBalancerAttributeResult::getResourceGroupId()const +{ + return resourceGroupId_; +} + +void DescribeLoadBalancerAttributeResult::setResourceGroupId(const std::string& resourceGroupId) +{ + resourceGroupId_ = resourceGroupId; +} + +std::string DescribeLoadBalancerAttributeResult::getAddress()const +{ + return address_; +} + +void DescribeLoadBalancerAttributeResult::setAddress(const std::string& address) +{ + address_ = address; +} + +std::string DescribeLoadBalancerAttributeResult::getEndTime()const +{ + return endTime_; +} + +void DescribeLoadBalancerAttributeResult::setEndTime(const std::string& endTime) +{ + endTime_ = endTime; +} + +std::string DescribeLoadBalancerAttributeResult::getVSwitchId()const +{ + return vSwitchId_; +} + +void DescribeLoadBalancerAttributeResult::setVSwitchId(const std::string& vSwitchId) +{ + vSwitchId_ = vSwitchId; +} + +std::string DescribeLoadBalancerAttributeResult::getCreateTime()const +{ + return createTime_; +} + +void DescribeLoadBalancerAttributeResult::setCreateTime(const std::string& createTime) +{ + createTime_ = createTime; +} + +std::string DescribeLoadBalancerAttributeResult::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void DescribeLoadBalancerAttributeResult::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; +} + +std::string DescribeLoadBalancerAttributeResult::getPayType()const +{ + return payType_; +} + +void DescribeLoadBalancerAttributeResult::setPayType(const std::string& payType) +{ + payType_ = payType; +} + +std::string DescribeLoadBalancerAttributeResult::getSlaveZoneId()const +{ + return slaveZoneId_; +} + +void DescribeLoadBalancerAttributeResult::setSlaveZoneId(const std::string& slaveZoneId) +{ + slaveZoneId_ = slaveZoneId; +} + +std::string DescribeLoadBalancerAttributeResult::getInternetChargeType()const +{ + return internetChargeType_; +} + +void DescribeLoadBalancerAttributeResult::setInternetChargeType(const std::string& internetChargeType) +{ + internetChargeType_ = internetChargeType; +} + +std::string DescribeLoadBalancerAttributeResult::getLoadBalancerSpec()const +{ + return loadBalancerSpec_; +} + +void DescribeLoadBalancerAttributeResult::setLoadBalancerSpec(const std::string& loadBalancerSpec) +{ + loadBalancerSpec_ = loadBalancerSpec; +} + +std::string DescribeLoadBalancerAttributeResult::getRegionIdAlias()const +{ + return regionIdAlias_; +} + +void DescribeLoadBalancerAttributeResult::setRegionIdAlias(const std::string& regionIdAlias) +{ + regionIdAlias_ = regionIdAlias; +} + +std::string DescribeLoadBalancerAttributeResult::getLoadBalancerName()const +{ + return loadBalancerName_; +} + +void DescribeLoadBalancerAttributeResult::setLoadBalancerName(const std::string& loadBalancerName) +{ + loadBalancerName_ = loadBalancerName; +} + +std::string DescribeLoadBalancerAttributeResult::getVpcId()const +{ + return vpcId_; +} + +void DescribeLoadBalancerAttributeResult::setVpcId(const std::string& vpcId) +{ + vpcId_ = vpcId; +} + +long DescribeLoadBalancerAttributeResult::getEndTimeStamp()const +{ + return endTimeStamp_; +} + +void DescribeLoadBalancerAttributeResult::setEndTimeStamp(long endTimeStamp) +{ + endTimeStamp_ = endTimeStamp; +} + +std::string DescribeLoadBalancerAttributeResult::getNetworkType()const +{ + return networkType_; +} + +void DescribeLoadBalancerAttributeResult::setNetworkType(const std::string& networkType) +{ + networkType_ = networkType; +} + +int DescribeLoadBalancerAttributeResult::getBandwidth()const +{ + return bandwidth_; +} + +void DescribeLoadBalancerAttributeResult::setBandwidth(int bandwidth) +{ + bandwidth_ = bandwidth; +} + +std::string DescribeLoadBalancerAttributeResult::getRegionId()const +{ + return regionId_; +} + +void DescribeLoadBalancerAttributeResult::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; +} + +std::string DescribeLoadBalancerAttributeResult::getAddressType()const +{ + return addressType_; +} + +void DescribeLoadBalancerAttributeResult::setAddressType(const std::string& addressType) +{ + addressType_ = addressType; +} + +std::string DescribeLoadBalancerAttributeResult::getLoadBalancerStatus()const +{ + return loadBalancerStatus_; +} + +void DescribeLoadBalancerAttributeResult::setLoadBalancerStatus(const std::string& loadBalancerStatus) +{ + loadBalancerStatus_ = loadBalancerStatus; +} + +std::vector DescribeLoadBalancerAttributeResult::getListenerPorts()const +{ + return listenerPorts_; +} + +void DescribeLoadBalancerAttributeResult::setListenerPorts(const std::vector& listenerPorts) +{ + listenerPorts_ = listenerPorts; +} + +long DescribeLoadBalancerAttributeResult::getCreateTimeStamp()const +{ + return createTimeStamp_; +} + +void DescribeLoadBalancerAttributeResult::setCreateTimeStamp(long createTimeStamp) +{ + createTimeStamp_ = createTimeStamp; +} + +std::string DescribeLoadBalancerAttributeResult::getMasterZoneId()const +{ + return masterZoneId_; +} + +void DescribeLoadBalancerAttributeResult::setMasterZoneId(const std::string& masterZoneId) +{ + masterZoneId_ = masterZoneId; +} + +long DescribeLoadBalancerAttributeResult::getAutoReleaseTime()const +{ + return autoReleaseTime_; +} + +void DescribeLoadBalancerAttributeResult::setAutoReleaseTime(long autoReleaseTime) +{ + autoReleaseTime_ = autoReleaseTime; +} + diff --git a/slb/src/model/DescribeLoadBalancerAutoReleaseTimeRequest.cc b/slb/src/model/DescribeLoadBalancerAutoReleaseTimeRequest.cc new file mode 100644 index 000000000..a88270331 --- /dev/null +++ b/slb/src/model/DescribeLoadBalancerAutoReleaseTimeRequest.cc @@ -0,0 +1,127 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeLoadBalancerAutoReleaseTimeRequest::DescribeLoadBalancerAutoReleaseTimeRequest() : + SlbRequest("DescribeLoadBalancerAutoReleaseTime") +{} + +DescribeLoadBalancerAutoReleaseTimeRequest::~DescribeLoadBalancerAutoReleaseTimeRequest() +{} + +std::string DescribeLoadBalancerAutoReleaseTimeRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeLoadBalancerAutoReleaseTimeRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DescribeLoadBalancerAutoReleaseTimeRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeLoadBalancerAutoReleaseTimeRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DescribeLoadBalancerAutoReleaseTimeRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void DescribeLoadBalancerAutoReleaseTimeRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string DescribeLoadBalancerAutoReleaseTimeRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeLoadBalancerAutoReleaseTimeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeLoadBalancerAutoReleaseTimeRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeLoadBalancerAutoReleaseTimeRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeLoadBalancerAutoReleaseTimeRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeLoadBalancerAutoReleaseTimeRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeLoadBalancerAutoReleaseTimeRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeLoadBalancerAutoReleaseTimeRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeLoadBalancerAutoReleaseTimeRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeLoadBalancerAutoReleaseTimeRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeLoadBalancerAutoReleaseTimeRequest::getTags()const +{ + return tags_; +} + +void DescribeLoadBalancerAutoReleaseTimeRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DescribeLoadBalancerAutoReleaseTimeResult.cc b/slb/src/model/DescribeLoadBalancerAutoReleaseTimeResult.cc new file mode 100644 index 000000000..59cef90f9 --- /dev/null +++ b/slb/src/model/DescribeLoadBalancerAutoReleaseTimeResult.cc @@ -0,0 +1,56 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeLoadBalancerAutoReleaseTimeResult::DescribeLoadBalancerAutoReleaseTimeResult() : + ServiceResult() +{} + +DescribeLoadBalancerAutoReleaseTimeResult::DescribeLoadBalancerAutoReleaseTimeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeLoadBalancerAutoReleaseTimeResult::~DescribeLoadBalancerAutoReleaseTimeResult() +{} + +void DescribeLoadBalancerAutoReleaseTimeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + autoReleaseTime_ = std::stol(value["AutoReleaseTime"].asString()); + +} + +long DescribeLoadBalancerAutoReleaseTimeResult::getAutoReleaseTime()const +{ + return autoReleaseTime_; +} + +void DescribeLoadBalancerAutoReleaseTimeResult::setAutoReleaseTime(long autoReleaseTime) +{ + autoReleaseTime_ = autoReleaseTime; +} + diff --git a/slb/src/model/DescribeLoadBalancerHTTPListenerAttributeRequest.cc b/slb/src/model/DescribeLoadBalancerHTTPListenerAttributeRequest.cc new file mode 100644 index 000000000..65efafa7b --- /dev/null +++ b/slb/src/model/DescribeLoadBalancerHTTPListenerAttributeRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeLoadBalancerHTTPListenerAttributeRequest::DescribeLoadBalancerHTTPListenerAttributeRequest() : + SlbRequest("DescribeLoadBalancerHTTPListenerAttribute") +{} + +DescribeLoadBalancerHTTPListenerAttributeRequest::~DescribeLoadBalancerHTTPListenerAttributeRequest() +{} + +std::string DescribeLoadBalancerHTTPListenerAttributeRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeLoadBalancerHTTPListenerAttributeRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DescribeLoadBalancerHTTPListenerAttributeRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeLoadBalancerHTTPListenerAttributeRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +int DescribeLoadBalancerHTTPListenerAttributeRequest::getListenerPort()const +{ + return listenerPort_; +} + +void DescribeLoadBalancerHTTPListenerAttributeRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string DescribeLoadBalancerHTTPListenerAttributeRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void DescribeLoadBalancerHTTPListenerAttributeRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string DescribeLoadBalancerHTTPListenerAttributeRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeLoadBalancerHTTPListenerAttributeRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeLoadBalancerHTTPListenerAttributeRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeLoadBalancerHTTPListenerAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeLoadBalancerHTTPListenerAttributeRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeLoadBalancerHTTPListenerAttributeRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeLoadBalancerHTTPListenerAttributeRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeLoadBalancerHTTPListenerAttributeRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeLoadBalancerHTTPListenerAttributeRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeLoadBalancerHTTPListenerAttributeRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeLoadBalancerHTTPListenerAttributeRequest::getTags()const +{ + return tags_; +} + +void DescribeLoadBalancerHTTPListenerAttributeRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DescribeLoadBalancerHTTPListenerAttributeResult.cc b/slb/src/model/DescribeLoadBalancerHTTPListenerAttributeResult.cc new file mode 100644 index 000000000..3a1a737ed --- /dev/null +++ b/slb/src/model/DescribeLoadBalancerHTTPListenerAttributeResult.cc @@ -0,0 +1,331 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeLoadBalancerHTTPListenerAttributeResult::DescribeLoadBalancerHTTPListenerAttributeResult() : + ServiceResult() +{} + +DescribeLoadBalancerHTTPListenerAttributeResult::DescribeLoadBalancerHTTPListenerAttributeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeLoadBalancerHTTPListenerAttributeResult::~DescribeLoadBalancerHTTPListenerAttributeResult() +{} + +void DescribeLoadBalancerHTTPListenerAttributeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + listenerPort_ = std::stoi(value["ListenerPort"].asString()); + backendServerPort_ = std::stoi(value["BackendServerPort"].asString()); + bandwidth_ = std::stoi(value["Bandwidth"].asString()); + status_ = value["Status"].asString(); + securityStatus_ = value["SecurityStatus"].asString(); + xForwardedFor_ = value["XForwardedFor"].asString(); + scheduler_ = value["Scheduler"].asString(); + stickySession_ = value["StickySession"].asString(); + stickySessionType_ = value["StickySessionType"].asString(); + cookieTimeout_ = std::stoi(value["CookieTimeout"].asString()); + cookie_ = value["Cookie"].asString(); + healthCheck_ = value["HealthCheck"].asString(); + healthCheckDomain_ = value["HealthCheckDomain"].asString(); + healthCheckURI_ = value["HealthCheckURI"].asString(); + healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString()); + unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString()); + healthCheckTimeout_ = std::stoi(value["HealthCheckTimeout"].asString()); + healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString()); + healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString()); + healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString(); + maxConnection_ = std::stoi(value["MaxConnection"].asString()); + vServerGroupId_ = value["VServerGroupId"].asString(); + gzip_ = value["Gzip"].asString(); + xForwardedFor_SLBIP_ = value["XForwardedFor_SLBIP"].asString(); + xForwardedFor_SLBID_ = value["XForwardedFor_SLBID"].asString(); + xForwardedFor_proto_ = value["XForwardedFor_proto"].asString(); + +} + +int DescribeLoadBalancerHTTPListenerAttributeResult::getCookieTimeout()const +{ + return cookieTimeout_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setCookieTimeout(int cookieTimeout) +{ + cookieTimeout_ = cookieTimeout; +} + +int DescribeLoadBalancerHTTPListenerAttributeResult::getMaxConnection()const +{ + return maxConnection_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setMaxConnection(int maxConnection) +{ + maxConnection_ = maxConnection; +} + +std::string DescribeLoadBalancerHTTPListenerAttributeResult::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; +} + +int DescribeLoadBalancerHTTPListenerAttributeResult::getUnhealthyThreshold()const +{ + return unhealthyThreshold_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setUnhealthyThreshold(int unhealthyThreshold) +{ + unhealthyThreshold_ = unhealthyThreshold; +} + +std::string DescribeLoadBalancerHTTPListenerAttributeResult::getScheduler()const +{ + return scheduler_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setScheduler(const std::string& scheduler) +{ + scheduler_ = scheduler; +} + +std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckURI()const +{ + return healthCheckURI_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setHealthCheckURI(const std::string& healthCheckURI) +{ + healthCheckURI_ = healthCheckURI; +} + +std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheck()const +{ + return healthCheck_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setHealthCheck(const std::string& healthCheck) +{ + healthCheck_ = healthCheck; +} + +int DescribeLoadBalancerHTTPListenerAttributeResult::getBackendServerPort()const +{ + return backendServerPort_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setBackendServerPort(int backendServerPort) +{ + backendServerPort_ = backendServerPort; +} + +std::string DescribeLoadBalancerHTTPListenerAttributeResult::getXForwardedFor_SLBID()const +{ + return xForwardedFor_SLBID_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setXForwardedFor_SLBID(const std::string& xForwardedFor_SLBID) +{ + xForwardedFor_SLBID_ = xForwardedFor_SLBID; +} + +int DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckConnectPort()const +{ + return healthCheckConnectPort_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setHealthCheckConnectPort(int healthCheckConnectPort) +{ + healthCheckConnectPort_ = healthCheckConnectPort; +} + +int DescribeLoadBalancerHTTPListenerAttributeResult::getBandwidth()const +{ + return bandwidth_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setBandwidth(int bandwidth) +{ + bandwidth_ = bandwidth; +} + +std::string DescribeLoadBalancerHTTPListenerAttributeResult::getSecurityStatus()const +{ + return securityStatus_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setSecurityStatus(const std::string& securityStatus) +{ + securityStatus_ = securityStatus; +} + +std::string DescribeLoadBalancerHTTPListenerAttributeResult::getGzip()const +{ + return gzip_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setGzip(const std::string& gzip) +{ + gzip_ = gzip; +} + +std::string DescribeLoadBalancerHTTPListenerAttributeResult::getStickySessionType()const +{ + return stickySessionType_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setStickySessionType(const std::string& stickySessionType) +{ + stickySessionType_ = stickySessionType; +} + +std::string DescribeLoadBalancerHTTPListenerAttributeResult::getXForwardedFor_SLBIP()const +{ + return xForwardedFor_SLBIP_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setXForwardedFor_SLBIP(const std::string& xForwardedFor_SLBIP) +{ + xForwardedFor_SLBIP_ = xForwardedFor_SLBIP; +} + +std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckHttpCode()const +{ + return healthCheckHttpCode_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setHealthCheckHttpCode(const std::string& healthCheckHttpCode) +{ + healthCheckHttpCode_ = healthCheckHttpCode; +} + +std::string DescribeLoadBalancerHTTPListenerAttributeResult::getStatus()const +{ + return status_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setStatus(const std::string& status) +{ + status_ = status; +} + +std::string DescribeLoadBalancerHTTPListenerAttributeResult::getCookie()const +{ + return cookie_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setCookie(const std::string& cookie) +{ + cookie_ = cookie; +} + +int DescribeLoadBalancerHTTPListenerAttributeResult::getListenerPort()const +{ + return listenerPort_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; +} + +int DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckInterval()const +{ + return healthCheckInterval_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setHealthCheckInterval(int healthCheckInterval) +{ + healthCheckInterval_ = healthCheckInterval; +} + +int DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckTimeout()const +{ + return healthCheckTimeout_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setHealthCheckTimeout(int healthCheckTimeout) +{ + healthCheckTimeout_ = healthCheckTimeout; +} + +std::string DescribeLoadBalancerHTTPListenerAttributeResult::getStickySession()const +{ + return stickySession_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setStickySession(const std::string& stickySession) +{ + stickySession_ = stickySession; +} + +int DescribeLoadBalancerHTTPListenerAttributeResult::getHealthyThreshold()const +{ + return healthyThreshold_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setHealthyThreshold(int healthyThreshold) +{ + healthyThreshold_ = healthyThreshold; +} + +std::string DescribeLoadBalancerHTTPListenerAttributeResult::getXForwardedFor()const +{ + return xForwardedFor_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setXForwardedFor(const std::string& xForwardedFor) +{ + xForwardedFor_ = xForwardedFor; +} + +std::string DescribeLoadBalancerHTTPListenerAttributeResult::getHealthCheckDomain()const +{ + return healthCheckDomain_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setHealthCheckDomain(const std::string& healthCheckDomain) +{ + healthCheckDomain_ = healthCheckDomain; +} + +std::string DescribeLoadBalancerHTTPListenerAttributeResult::getXForwardedFor_proto()const +{ + return xForwardedFor_proto_; +} + +void DescribeLoadBalancerHTTPListenerAttributeResult::setXForwardedFor_proto(const std::string& xForwardedFor_proto) +{ + xForwardedFor_proto_ = xForwardedFor_proto; +} + diff --git a/slb/src/model/DescribeLoadBalancerHTTPSListenerAttributeRequest.cc b/slb/src/model/DescribeLoadBalancerHTTPSListenerAttributeRequest.cc new file mode 100644 index 000000000..6bb3e2cac --- /dev/null +++ b/slb/src/model/DescribeLoadBalancerHTTPSListenerAttributeRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeLoadBalancerHTTPSListenerAttributeRequest::DescribeLoadBalancerHTTPSListenerAttributeRequest() : + SlbRequest("DescribeLoadBalancerHTTPSListenerAttribute") +{} + +DescribeLoadBalancerHTTPSListenerAttributeRequest::~DescribeLoadBalancerHTTPSListenerAttributeRequest() +{} + +std::string DescribeLoadBalancerHTTPSListenerAttributeRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DescribeLoadBalancerHTTPSListenerAttributeRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +int DescribeLoadBalancerHTTPSListenerAttributeRequest::getListenerPort()const +{ + return listenerPort_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeLoadBalancerHTTPSListenerAttributeRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeRequest::getTags()const +{ + return tags_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DescribeLoadBalancerHTTPSListenerAttributeResult.cc b/slb/src/model/DescribeLoadBalancerHTTPSListenerAttributeResult.cc new file mode 100644 index 000000000..2ab95237b --- /dev/null +++ b/slb/src/model/DescribeLoadBalancerHTTPSListenerAttributeResult.cc @@ -0,0 +1,353 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeLoadBalancerHTTPSListenerAttributeResult::DescribeLoadBalancerHTTPSListenerAttributeResult() : + ServiceResult() +{} + +DescribeLoadBalancerHTTPSListenerAttributeResult::DescribeLoadBalancerHTTPSListenerAttributeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeLoadBalancerHTTPSListenerAttributeResult::~DescribeLoadBalancerHTTPSListenerAttributeResult() +{} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + listenerPort_ = std::stoi(value["ListenerPort"].asString()); + backendServerPort_ = std::stoi(value["BackendServerPort"].asString()); + bandwidth_ = std::stoi(value["Bandwidth"].asString()); + status_ = value["Status"].asString(); + securityStatus_ = value["SecurityStatus"].asString(); + xForwardedFor_ = value["XForwardedFor"].asString(); + scheduler_ = value["Scheduler"].asString(); + stickySession_ = value["StickySession"].asString(); + stickySessionType_ = value["StickySessionType"].asString(); + cookieTimeout_ = std::stoi(value["CookieTimeout"].asString()); + cookie_ = value["Cookie"].asString(); + healthCheck_ = value["HealthCheck"].asString(); + healthCheckDomain_ = value["HealthCheckDomain"].asString(); + healthCheckURI_ = value["HealthCheckURI"].asString(); + healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString()); + unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString()); + healthCheckTimeout_ = std::stoi(value["HealthCheckTimeout"].asString()); + healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString()); + healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString()); + healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString(); + serverCertificateId_ = value["ServerCertificateId"].asString(); + cACertificateId_ = value["CACertificateId"].asString(); + maxConnection_ = std::stoi(value["MaxConnection"].asString()); + vServerGroupId_ = value["VServerGroupId"].asString(); + gzip_ = value["Gzip"].asString(); + xForwardedFor_SLBIP_ = value["XForwardedFor_SLBIP"].asString(); + xForwardedFor_SLBID_ = value["XForwardedFor_SLBID"].asString(); + xForwardedFor_proto_ = value["XForwardedFor_proto"].asString(); + +} + +int DescribeLoadBalancerHTTPSListenerAttributeResult::getCookieTimeout()const +{ + return cookieTimeout_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setCookieTimeout(int cookieTimeout) +{ + cookieTimeout_ = cookieTimeout; +} + +int DescribeLoadBalancerHTTPSListenerAttributeResult::getMaxConnection()const +{ + return maxConnection_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setMaxConnection(int maxConnection) +{ + maxConnection_ = maxConnection; +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; +} + +int DescribeLoadBalancerHTTPSListenerAttributeResult::getUnhealthyThreshold()const +{ + return unhealthyThreshold_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setUnhealthyThreshold(int unhealthyThreshold) +{ + unhealthyThreshold_ = unhealthyThreshold; +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getScheduler()const +{ + return scheduler_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setScheduler(const std::string& scheduler) +{ + scheduler_ = scheduler; +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckURI()const +{ + return healthCheckURI_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setHealthCheckURI(const std::string& healthCheckURI) +{ + healthCheckURI_ = healthCheckURI; +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheck()const +{ + return healthCheck_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setHealthCheck(const std::string& healthCheck) +{ + healthCheck_ = healthCheck; +} + +int DescribeLoadBalancerHTTPSListenerAttributeResult::getBackendServerPort()const +{ + return backendServerPort_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setBackendServerPort(int backendServerPort) +{ + backendServerPort_ = backendServerPort; +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_SLBID()const +{ + return xForwardedFor_SLBID_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setXForwardedFor_SLBID(const std::string& xForwardedFor_SLBID) +{ + xForwardedFor_SLBID_ = xForwardedFor_SLBID; +} + +int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckConnectPort()const +{ + return healthCheckConnectPort_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setHealthCheckConnectPort(int healthCheckConnectPort) +{ + healthCheckConnectPort_ = healthCheckConnectPort; +} + +int DescribeLoadBalancerHTTPSListenerAttributeResult::getBandwidth()const +{ + return bandwidth_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setBandwidth(int bandwidth) +{ + bandwidth_ = bandwidth; +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getSecurityStatus()const +{ + return securityStatus_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setSecurityStatus(const std::string& securityStatus) +{ + securityStatus_ = securityStatus; +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getGzip()const +{ + return gzip_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setGzip(const std::string& gzip) +{ + gzip_ = gzip; +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getServerCertificateId()const +{ + return serverCertificateId_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setServerCertificateId(const std::string& serverCertificateId) +{ + serverCertificateId_ = serverCertificateId; +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStickySessionType()const +{ + return stickySessionType_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setStickySessionType(const std::string& stickySessionType) +{ + stickySessionType_ = stickySessionType; +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_SLBIP()const +{ + return xForwardedFor_SLBIP_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setXForwardedFor_SLBIP(const std::string& xForwardedFor_SLBIP) +{ + xForwardedFor_SLBIP_ = xForwardedFor_SLBIP; +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckHttpCode()const +{ + return healthCheckHttpCode_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setHealthCheckHttpCode(const std::string& healthCheckHttpCode) +{ + healthCheckHttpCode_ = healthCheckHttpCode; +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStatus()const +{ + return status_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setStatus(const std::string& status) +{ + status_ = status; +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getCookie()const +{ + return cookie_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setCookie(const std::string& cookie) +{ + cookie_ = cookie; +} + +int DescribeLoadBalancerHTTPSListenerAttributeResult::getListenerPort()const +{ + return listenerPort_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; +} + +int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckInterval()const +{ + return healthCheckInterval_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setHealthCheckInterval(int healthCheckInterval) +{ + healthCheckInterval_ = healthCheckInterval; +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getCACertificateId()const +{ + return cACertificateId_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setCACertificateId(const std::string& cACertificateId) +{ + cACertificateId_ = cACertificateId; +} + +int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckTimeout()const +{ + return healthCheckTimeout_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setHealthCheckTimeout(int healthCheckTimeout) +{ + healthCheckTimeout_ = healthCheckTimeout; +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getStickySession()const +{ + return stickySession_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setStickySession(const std::string& stickySession) +{ + stickySession_ = stickySession; +} + +int DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthyThreshold()const +{ + return healthyThreshold_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setHealthyThreshold(int healthyThreshold) +{ + healthyThreshold_ = healthyThreshold; +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor()const +{ + return xForwardedFor_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setXForwardedFor(const std::string& xForwardedFor) +{ + xForwardedFor_ = xForwardedFor; +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getHealthCheckDomain()const +{ + return healthCheckDomain_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setHealthCheckDomain(const std::string& healthCheckDomain) +{ + healthCheckDomain_ = healthCheckDomain; +} + +std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_proto()const +{ + return xForwardedFor_proto_; +} + +void DescribeLoadBalancerHTTPSListenerAttributeResult::setXForwardedFor_proto(const std::string& xForwardedFor_proto) +{ + xForwardedFor_proto_ = xForwardedFor_proto; +} + diff --git a/slb/src/model/DescribeLoadBalancerTCPListenerAttributeRequest.cc b/slb/src/model/DescribeLoadBalancerTCPListenerAttributeRequest.cc new file mode 100644 index 000000000..20bc411bd --- /dev/null +++ b/slb/src/model/DescribeLoadBalancerTCPListenerAttributeRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeLoadBalancerTCPListenerAttributeRequest::DescribeLoadBalancerTCPListenerAttributeRequest() : + SlbRequest("DescribeLoadBalancerTCPListenerAttribute") +{} + +DescribeLoadBalancerTCPListenerAttributeRequest::~DescribeLoadBalancerTCPListenerAttributeRequest() +{} + +std::string DescribeLoadBalancerTCPListenerAttributeRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeLoadBalancerTCPListenerAttributeRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DescribeLoadBalancerTCPListenerAttributeRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeLoadBalancerTCPListenerAttributeRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +int DescribeLoadBalancerTCPListenerAttributeRequest::getListenerPort()const +{ + return listenerPort_; +} + +void DescribeLoadBalancerTCPListenerAttributeRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string DescribeLoadBalancerTCPListenerAttributeRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void DescribeLoadBalancerTCPListenerAttributeRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string DescribeLoadBalancerTCPListenerAttributeRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeLoadBalancerTCPListenerAttributeRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeLoadBalancerTCPListenerAttributeRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeLoadBalancerTCPListenerAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeLoadBalancerTCPListenerAttributeRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeLoadBalancerTCPListenerAttributeRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeLoadBalancerTCPListenerAttributeRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeLoadBalancerTCPListenerAttributeRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeLoadBalancerTCPListenerAttributeRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeLoadBalancerTCPListenerAttributeRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeLoadBalancerTCPListenerAttributeRequest::getTags()const +{ + return tags_; +} + +void DescribeLoadBalancerTCPListenerAttributeRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DescribeLoadBalancerTCPListenerAttributeResult.cc b/slb/src/model/DescribeLoadBalancerTCPListenerAttributeResult.cc new file mode 100644 index 000000000..ad2e2bc39 --- /dev/null +++ b/slb/src/model/DescribeLoadBalancerTCPListenerAttributeResult.cc @@ -0,0 +1,276 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeLoadBalancerTCPListenerAttributeResult::DescribeLoadBalancerTCPListenerAttributeResult() : + ServiceResult() +{} + +DescribeLoadBalancerTCPListenerAttributeResult::DescribeLoadBalancerTCPListenerAttributeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeLoadBalancerTCPListenerAttributeResult::~DescribeLoadBalancerTCPListenerAttributeResult() +{} + +void DescribeLoadBalancerTCPListenerAttributeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + listenerPort_ = std::stoi(value["ListenerPort"].asString()); + backendServerPort_ = std::stoi(value["BackendServerPort"].asString()); + status_ = value["Status"].asString(); + bandwidth_ = std::stoi(value["Bandwidth"].asString()); + scheduler_ = value["Scheduler"].asString(); + synProxy_ = value["SynProxy"].asString(); + persistenceTimeout_ = std::stoi(value["PersistenceTimeout"].asString()); + establishedTimeout_ = std::stoi(value["EstablishedTimeout"].asString()); + healthCheck_ = value["HealthCheck"].asString(); + healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString()); + unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString()); + healthCheckConnectTimeout_ = std::stoi(value["HealthCheckConnectTimeout"].asString()); + healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString()); + healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString()); + healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString(); + healthCheckDomain_ = value["HealthCheckDomain"].asString(); + healthCheckURI_ = value["HealthCheckURI"].asString(); + healthCheckType_ = value["HealthCheckType"].asString(); + maxConnection_ = std::stoi(value["MaxConnection"].asString()); + vServerGroupId_ = value["VServerGroupId"].asString(); + masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString(); + +} + +std::string DescribeLoadBalancerTCPListenerAttributeResult::getStatus()const +{ + return status_; +} + +void DescribeLoadBalancerTCPListenerAttributeResult::setStatus(const std::string& status) +{ + status_ = status; +} + +int DescribeLoadBalancerTCPListenerAttributeResult::getMaxConnection()const +{ + return maxConnection_; +} + +void DescribeLoadBalancerTCPListenerAttributeResult::setMaxConnection(int maxConnection) +{ + maxConnection_ = maxConnection; +} + +int DescribeLoadBalancerTCPListenerAttributeResult::getListenerPort()const +{ + return listenerPort_; +} + +void DescribeLoadBalancerTCPListenerAttributeResult::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; +} + +std::string DescribeLoadBalancerTCPListenerAttributeResult::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void DescribeLoadBalancerTCPListenerAttributeResult::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; +} + +std::string DescribeLoadBalancerTCPListenerAttributeResult::getSynProxy()const +{ + return synProxy_; +} + +void DescribeLoadBalancerTCPListenerAttributeResult::setSynProxy(const std::string& synProxy) +{ + synProxy_ = synProxy; +} + +int DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckInterval()const +{ + return healthCheckInterval_; +} + +void DescribeLoadBalancerTCPListenerAttributeResult::setHealthCheckInterval(int healthCheckInterval) +{ + healthCheckInterval_ = healthCheckInterval; +} + +int DescribeLoadBalancerTCPListenerAttributeResult::getUnhealthyThreshold()const +{ + return unhealthyThreshold_; +} + +void DescribeLoadBalancerTCPListenerAttributeResult::setUnhealthyThreshold(int unhealthyThreshold) +{ + unhealthyThreshold_ = unhealthyThreshold; +} + +std::string DescribeLoadBalancerTCPListenerAttributeResult::getScheduler()const +{ + return scheduler_; +} + +void DescribeLoadBalancerTCPListenerAttributeResult::setScheduler(const std::string& scheduler) +{ + scheduler_ = scheduler; +} + +std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckURI()const +{ + return healthCheckURI_; +} + +void DescribeLoadBalancerTCPListenerAttributeResult::setHealthCheckURI(const std::string& healthCheckURI) +{ + healthCheckURI_ = healthCheckURI; +} + +std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheck()const +{ + return healthCheck_; +} + +void DescribeLoadBalancerTCPListenerAttributeResult::setHealthCheck(const std::string& healthCheck) +{ + healthCheck_ = healthCheck; +} + +int DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckConnectTimeout()const +{ + return healthCheckConnectTimeout_; +} + +void DescribeLoadBalancerTCPListenerAttributeResult::setHealthCheckConnectTimeout(int healthCheckConnectTimeout) +{ + healthCheckConnectTimeout_ = healthCheckConnectTimeout; +} + +int DescribeLoadBalancerTCPListenerAttributeResult::getBackendServerPort()const +{ + return backendServerPort_; +} + +void DescribeLoadBalancerTCPListenerAttributeResult::setBackendServerPort(int backendServerPort) +{ + backendServerPort_ = backendServerPort; +} + +int DescribeLoadBalancerTCPListenerAttributeResult::getPersistenceTimeout()const +{ + return persistenceTimeout_; +} + +void DescribeLoadBalancerTCPListenerAttributeResult::setPersistenceTimeout(int persistenceTimeout) +{ + persistenceTimeout_ = persistenceTimeout; +} + +int DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckConnectPort()const +{ + return healthCheckConnectPort_; +} + +void DescribeLoadBalancerTCPListenerAttributeResult::setHealthCheckConnectPort(int healthCheckConnectPort) +{ + healthCheckConnectPort_ = healthCheckConnectPort; +} + +int DescribeLoadBalancerTCPListenerAttributeResult::getBandwidth()const +{ + return bandwidth_; +} + +void DescribeLoadBalancerTCPListenerAttributeResult::setBandwidth(int bandwidth) +{ + bandwidth_ = bandwidth; +} + +int DescribeLoadBalancerTCPListenerAttributeResult::getHealthyThreshold()const +{ + return healthyThreshold_; +} + +void DescribeLoadBalancerTCPListenerAttributeResult::setHealthyThreshold(int healthyThreshold) +{ + healthyThreshold_ = healthyThreshold; +} + +std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckDomain()const +{ + return healthCheckDomain_; +} + +void DescribeLoadBalancerTCPListenerAttributeResult::setHealthCheckDomain(const std::string& healthCheckDomain) +{ + healthCheckDomain_ = healthCheckDomain; +} + +std::string DescribeLoadBalancerTCPListenerAttributeResult::getMasterSlaveServerGroupId()const +{ + return masterSlaveServerGroupId_; +} + +void DescribeLoadBalancerTCPListenerAttributeResult::setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId) +{ + masterSlaveServerGroupId_ = masterSlaveServerGroupId; +} + +std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckHttpCode()const +{ + return healthCheckHttpCode_; +} + +void DescribeLoadBalancerTCPListenerAttributeResult::setHealthCheckHttpCode(const std::string& healthCheckHttpCode) +{ + healthCheckHttpCode_ = healthCheckHttpCode; +} + +std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckType()const +{ + return healthCheckType_; +} + +void DescribeLoadBalancerTCPListenerAttributeResult::setHealthCheckType(const std::string& healthCheckType) +{ + healthCheckType_ = healthCheckType; +} + +int DescribeLoadBalancerTCPListenerAttributeResult::getEstablishedTimeout()const +{ + return establishedTimeout_; +} + +void DescribeLoadBalancerTCPListenerAttributeResult::setEstablishedTimeout(int establishedTimeout) +{ + establishedTimeout_ = establishedTimeout; +} + diff --git a/slb/src/model/DescribeLoadBalancerUDPListenerAttributeRequest.cc b/slb/src/model/DescribeLoadBalancerUDPListenerAttributeRequest.cc new file mode 100644 index 000000000..98125e45f --- /dev/null +++ b/slb/src/model/DescribeLoadBalancerUDPListenerAttributeRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeLoadBalancerUDPListenerAttributeRequest::DescribeLoadBalancerUDPListenerAttributeRequest() : + SlbRequest("DescribeLoadBalancerUDPListenerAttribute") +{} + +DescribeLoadBalancerUDPListenerAttributeRequest::~DescribeLoadBalancerUDPListenerAttributeRequest() +{} + +std::string DescribeLoadBalancerUDPListenerAttributeRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeLoadBalancerUDPListenerAttributeRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DescribeLoadBalancerUDPListenerAttributeRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeLoadBalancerUDPListenerAttributeRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +int DescribeLoadBalancerUDPListenerAttributeRequest::getListenerPort()const +{ + return listenerPort_; +} + +void DescribeLoadBalancerUDPListenerAttributeRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string DescribeLoadBalancerUDPListenerAttributeRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void DescribeLoadBalancerUDPListenerAttributeRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string DescribeLoadBalancerUDPListenerAttributeRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeLoadBalancerUDPListenerAttributeRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeLoadBalancerUDPListenerAttributeRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeLoadBalancerUDPListenerAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeLoadBalancerUDPListenerAttributeRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeLoadBalancerUDPListenerAttributeRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeLoadBalancerUDPListenerAttributeRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeLoadBalancerUDPListenerAttributeRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeLoadBalancerUDPListenerAttributeRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeLoadBalancerUDPListenerAttributeRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeLoadBalancerUDPListenerAttributeRequest::getTags()const +{ + return tags_; +} + +void DescribeLoadBalancerUDPListenerAttributeRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DescribeLoadBalancerUDPListenerAttributeResult.cc b/slb/src/model/DescribeLoadBalancerUDPListenerAttributeResult.cc new file mode 100644 index 000000000..934e0006f --- /dev/null +++ b/slb/src/model/DescribeLoadBalancerUDPListenerAttributeResult.cc @@ -0,0 +1,232 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeLoadBalancerUDPListenerAttributeResult::DescribeLoadBalancerUDPListenerAttributeResult() : + ServiceResult() +{} + +DescribeLoadBalancerUDPListenerAttributeResult::DescribeLoadBalancerUDPListenerAttributeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeLoadBalancerUDPListenerAttributeResult::~DescribeLoadBalancerUDPListenerAttributeResult() +{} + +void DescribeLoadBalancerUDPListenerAttributeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + listenerPort_ = std::stoi(value["ListenerPort"].asString()); + backendServerPort_ = std::stoi(value["BackendServerPort"].asString()); + status_ = value["Status"].asString(); + bandwidth_ = std::stoi(value["Bandwidth"].asString()); + scheduler_ = value["Scheduler"].asString(); + persistenceTimeout_ = std::stoi(value["PersistenceTimeout"].asString()); + healthCheck_ = value["HealthCheck"].asString(); + healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString()); + unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString()); + healthCheckConnectTimeout_ = std::stoi(value["HealthCheckConnectTimeout"].asString()); + healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString()); + healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString()); + healthCheckReq_ = value["HealthCheckReq"].asString(); + healthCheckExp_ = value["HealthCheckExp"].asString(); + maxConnection_ = std::stoi(value["MaxConnection"].asString()); + vServerGroupId_ = value["VServerGroupId"].asString(); + masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString(); + +} + +std::string DescribeLoadBalancerUDPListenerAttributeResult::getStatus()const +{ + return status_; +} + +void DescribeLoadBalancerUDPListenerAttributeResult::setStatus(const std::string& status) +{ + status_ = status; +} + +int DescribeLoadBalancerUDPListenerAttributeResult::getMaxConnection()const +{ + return maxConnection_; +} + +void DescribeLoadBalancerUDPListenerAttributeResult::setMaxConnection(int maxConnection) +{ + maxConnection_ = maxConnection; +} + +int DescribeLoadBalancerUDPListenerAttributeResult::getListenerPort()const +{ + return listenerPort_; +} + +void DescribeLoadBalancerUDPListenerAttributeResult::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; +} + +std::string DescribeLoadBalancerUDPListenerAttributeResult::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void DescribeLoadBalancerUDPListenerAttributeResult::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; +} + +int DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckInterval()const +{ + return healthCheckInterval_; +} + +void DescribeLoadBalancerUDPListenerAttributeResult::setHealthCheckInterval(int healthCheckInterval) +{ + healthCheckInterval_ = healthCheckInterval; +} + +int DescribeLoadBalancerUDPListenerAttributeResult::getUnhealthyThreshold()const +{ + return unhealthyThreshold_; +} + +void DescribeLoadBalancerUDPListenerAttributeResult::setUnhealthyThreshold(int unhealthyThreshold) +{ + unhealthyThreshold_ = unhealthyThreshold; +} + +std::string DescribeLoadBalancerUDPListenerAttributeResult::getScheduler()const +{ + return scheduler_; +} + +void DescribeLoadBalancerUDPListenerAttributeResult::setScheduler(const std::string& scheduler) +{ + scheduler_ = scheduler; +} + +std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheck()const +{ + return healthCheck_; +} + +void DescribeLoadBalancerUDPListenerAttributeResult::setHealthCheck(const std::string& healthCheck) +{ + healthCheck_ = healthCheck; +} + +int DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckConnectTimeout()const +{ + return healthCheckConnectTimeout_; +} + +void DescribeLoadBalancerUDPListenerAttributeResult::setHealthCheckConnectTimeout(int healthCheckConnectTimeout) +{ + healthCheckConnectTimeout_ = healthCheckConnectTimeout; +} + +int DescribeLoadBalancerUDPListenerAttributeResult::getBackendServerPort()const +{ + return backendServerPort_; +} + +void DescribeLoadBalancerUDPListenerAttributeResult::setBackendServerPort(int backendServerPort) +{ + backendServerPort_ = backendServerPort; +} + +int DescribeLoadBalancerUDPListenerAttributeResult::getPersistenceTimeout()const +{ + return persistenceTimeout_; +} + +void DescribeLoadBalancerUDPListenerAttributeResult::setPersistenceTimeout(int persistenceTimeout) +{ + persistenceTimeout_ = persistenceTimeout; +} + +int DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckConnectPort()const +{ + return healthCheckConnectPort_; +} + +void DescribeLoadBalancerUDPListenerAttributeResult::setHealthCheckConnectPort(int healthCheckConnectPort) +{ + healthCheckConnectPort_ = healthCheckConnectPort; +} + +std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckReq()const +{ + return healthCheckReq_; +} + +void DescribeLoadBalancerUDPListenerAttributeResult::setHealthCheckReq(const std::string& healthCheckReq) +{ + healthCheckReq_ = healthCheckReq; +} + +int DescribeLoadBalancerUDPListenerAttributeResult::getBandwidth()const +{ + return bandwidth_; +} + +void DescribeLoadBalancerUDPListenerAttributeResult::setBandwidth(int bandwidth) +{ + bandwidth_ = bandwidth; +} + +int DescribeLoadBalancerUDPListenerAttributeResult::getHealthyThreshold()const +{ + return healthyThreshold_; +} + +void DescribeLoadBalancerUDPListenerAttributeResult::setHealthyThreshold(int healthyThreshold) +{ + healthyThreshold_ = healthyThreshold; +} + +std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckExp()const +{ + return healthCheckExp_; +} + +void DescribeLoadBalancerUDPListenerAttributeResult::setHealthCheckExp(const std::string& healthCheckExp) +{ + healthCheckExp_ = healthCheckExp; +} + +std::string DescribeLoadBalancerUDPListenerAttributeResult::getMasterSlaveServerGroupId()const +{ + return masterSlaveServerGroupId_; +} + +void DescribeLoadBalancerUDPListenerAttributeResult::setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId) +{ + masterSlaveServerGroupId_ = masterSlaveServerGroupId; +} + diff --git a/slb/src/model/DescribeLoadBalancersRelatedEcsRequest.cc b/slb/src/model/DescribeLoadBalancersRelatedEcsRequest.cc new file mode 100644 index 000000000..9570085fa --- /dev/null +++ b/slb/src/model/DescribeLoadBalancersRelatedEcsRequest.cc @@ -0,0 +1,127 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeLoadBalancersRelatedEcsRequest::DescribeLoadBalancersRelatedEcsRequest() : + SlbRequest("DescribeLoadBalancersRelatedEcs") +{} + +DescribeLoadBalancersRelatedEcsRequest::~DescribeLoadBalancersRelatedEcsRequest() +{} + +std::string DescribeLoadBalancersRelatedEcsRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeLoadBalancersRelatedEcsRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DescribeLoadBalancersRelatedEcsRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeLoadBalancersRelatedEcsRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DescribeLoadBalancersRelatedEcsRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void DescribeLoadBalancersRelatedEcsRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string DescribeLoadBalancersRelatedEcsRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeLoadBalancersRelatedEcsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeLoadBalancersRelatedEcsRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeLoadBalancersRelatedEcsRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeLoadBalancersRelatedEcsRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeLoadBalancersRelatedEcsRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeLoadBalancersRelatedEcsRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeLoadBalancersRelatedEcsRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeLoadBalancersRelatedEcsRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeLoadBalancersRelatedEcsRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeLoadBalancersRelatedEcsRequest::getTags()const +{ + return tags_; +} + +void DescribeLoadBalancersRelatedEcsRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DescribeLoadBalancersRelatedEcsResult.cc b/slb/src/model/DescribeLoadBalancersRelatedEcsResult.cc new file mode 100644 index 000000000..a8514fd0d --- /dev/null +++ b/slb/src/model/DescribeLoadBalancersRelatedEcsResult.cc @@ -0,0 +1,121 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeLoadBalancersRelatedEcsResult::DescribeLoadBalancersRelatedEcsResult() : + ServiceResult() +{} + +DescribeLoadBalancersRelatedEcsResult::DescribeLoadBalancersRelatedEcsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeLoadBalancersRelatedEcsResult::~DescribeLoadBalancersRelatedEcsResult() +{} + +void DescribeLoadBalancersRelatedEcsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allLoadBalancers = value["LoadBalancers"]["LoadBalancer"]; + for (auto value : allLoadBalancers) + { + LoadBalancer loadBalancerObject; + loadBalancerObject.loadBalancerId = value["LoadBalancerId"].asString(); + loadBalancerObject.count = std::stoi(value["Count"].asString()); + auto allMasterSlaveVServerGroups = value["MasterSlaveVServerGroups"]["MasterSlaveVServerGroup"]; + for (auto value : allMasterSlaveVServerGroups) + { + LoadBalancer::MasterSlaveVServerGroup masterSlaveVServerGroupObject; + masterSlaveVServerGroupObject.groupId = value["GroupId"].asString(); + masterSlaveVServerGroupObject.groupName = value["GroupName"].asString(); + auto allBackendServers = value["BackendServers"]["BackendServer"]; + for (auto value : allBackendServers) + { + LoadBalancer::MasterSlaveVServerGroup::BackendServer backendServerObject; + backendServerObject.vmName = value["VmName"].asString(); + backendServerObject.weight = std::stoi(value["Weight"].asString()); + backendServerObject.port = std::stoi(value["Port"].asString()); + backendServerObject.networkType = value["NetworkType"].asString(); + masterSlaveVServerGroupObject.backendServers1.push_back(backendServerObject); + } + loadBalancerObject.masterSlaveVServerGroups.push_back(masterSlaveVServerGroupObject); + } + auto allVServerGroups = value["VServerGroups"]["VServerGroup"]; + for (auto value : allVServerGroups) + { + LoadBalancer::VServerGroup vServerGroupObject; + vServerGroupObject.groupId = value["GroupId"].asString(); + vServerGroupObject.groupName = value["GroupName"].asString(); + auto allBackendServers = value["BackendServers"]["BackendServer"]; + for (auto value : allBackendServers) + { + LoadBalancer::VServerGroup::BackendServer backendServerObject; + backendServerObject.vmName = value["VmName"].asString(); + backendServerObject.weight = std::stoi(value["Weight"].asString()); + backendServerObject.port = std::stoi(value["Port"].asString()); + backendServerObject.networkType = value["NetworkType"].asString(); + vServerGroupObject.backendServers2.push_back(backendServerObject); + } + loadBalancerObject.vServerGroups.push_back(vServerGroupObject); + } + auto allBackendServers = value["BackendServers"]["BackendServer"]; + for (auto value : allBackendServers) + { + LoadBalancer::BackendServer backendServerObject; + backendServerObject.vmName = value["VmName"].asString(); + backendServerObject.weight = std::stoi(value["Weight"].asString()); + backendServerObject.port = std::stoi(value["Port"].asString()); + backendServerObject.networkType = value["NetworkType"].asString(); + loadBalancerObject.backendServers.push_back(backendServerObject); + } + loadBalancers_.push_back(loadBalancerObject); + } + message_ = value["Message"].asString(); + success_ = std::stoi(value["Success"].asString()); + +} + +std::string DescribeLoadBalancersRelatedEcsResult::getMessage()const +{ + return message_; +} + +void DescribeLoadBalancersRelatedEcsResult::setMessage(const std::string& message) +{ + message_ = message; +} + +bool DescribeLoadBalancersRelatedEcsResult::getSuccess()const +{ + return success_; +} + +void DescribeLoadBalancersRelatedEcsResult::setSuccess(bool success) +{ + success_ = success; +} + diff --git a/slb/src/model/DescribeLoadBalancersRequest.cc b/slb/src/model/DescribeLoadBalancersRequest.cc new file mode 100644 index 000000000..1eb2815bf --- /dev/null +++ b/slb/src/model/DescribeLoadBalancersRequest.cc @@ -0,0 +1,292 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeLoadBalancersRequest::DescribeLoadBalancersRequest() : + SlbRequest("DescribeLoadBalancers") +{} + +DescribeLoadBalancersRequest::~DescribeLoadBalancersRequest() +{} + +std::string DescribeLoadBalancersRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeLoadBalancersRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DescribeLoadBalancersRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeLoadBalancersRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DescribeLoadBalancersRequest::getNetworkType()const +{ + return networkType_; +} + +void DescribeLoadBalancersRequest::setNetworkType(const std::string& networkType) +{ + networkType_ = networkType; + setParameter("NetworkType", networkType); +} + +std::string DescribeLoadBalancersRequest::getMasterZoneId()const +{ + return masterZoneId_; +} + +void DescribeLoadBalancersRequest::setMasterZoneId(const std::string& masterZoneId) +{ + masterZoneId_ = masterZoneId; + setParameter("MasterZoneId", masterZoneId); +} + +int DescribeLoadBalancersRequest::getPageNumber()const +{ + return pageNumber_; +} + +void DescribeLoadBalancersRequest::setPageNumber(int pageNumber) +{ + pageNumber_ = pageNumber; + setParameter("PageNumber", std::to_string(pageNumber)); +} + +std::string DescribeLoadBalancersRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeLoadBalancersRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeLoadBalancersRequest::getResourceGroupId()const +{ + return resourceGroupId_; +} + +void DescribeLoadBalancersRequest::setResourceGroupId(const std::string& resourceGroupId) +{ + resourceGroupId_ = resourceGroupId; + setParameter("ResourceGroupId", resourceGroupId); +} + +std::string DescribeLoadBalancersRequest::getLoadBalancerName()const +{ + return loadBalancerName_; +} + +void DescribeLoadBalancersRequest::setLoadBalancerName(const std::string& loadBalancerName) +{ + loadBalancerName_ = loadBalancerName; + setParameter("LoadBalancerName", loadBalancerName); +} + +std::string DescribeLoadBalancersRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeLoadBalancersRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +int DescribeLoadBalancersRequest::getPageSize()const +{ + return pageSize_; +} + +void DescribeLoadBalancersRequest::setPageSize(int pageSize) +{ + pageSize_ = pageSize; + setParameter("PageSize", std::to_string(pageSize)); +} + +std::string DescribeLoadBalancersRequest::getAddressType()const +{ + return addressType_; +} + +void DescribeLoadBalancersRequest::setAddressType(const std::string& addressType) +{ + addressType_ = addressType; + setParameter("AddressType", addressType); +} + +std::string DescribeLoadBalancersRequest::getSlaveZoneId()const +{ + return slaveZoneId_; +} + +void DescribeLoadBalancersRequest::setSlaveZoneId(const std::string& slaveZoneId) +{ + slaveZoneId_ = slaveZoneId; + setParameter("SlaveZoneId", slaveZoneId); +} + +std::string DescribeLoadBalancersRequest::getAddress()const +{ + return address_; +} + +void DescribeLoadBalancersRequest::setAddress(const std::string& address) +{ + address_ = address; + setParameter("Address", address); +} + +std::string DescribeLoadBalancersRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeLoadBalancersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeLoadBalancersRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeLoadBalancersRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeLoadBalancersRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeLoadBalancersRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeLoadBalancersRequest::getServerId()const +{ + return serverId_; +} + +void DescribeLoadBalancersRequest::setServerId(const std::string& serverId) +{ + serverId_ = serverId; + setParameter("ServerId", serverId); +} + +std::string DescribeLoadBalancersRequest::getTags()const +{ + return tags_; +} + +void DescribeLoadBalancersRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + +std::string DescribeLoadBalancersRequest::getServerIntranetAddress()const +{ + return serverIntranetAddress_; +} + +void DescribeLoadBalancersRequest::setServerIntranetAddress(const std::string& serverIntranetAddress) +{ + serverIntranetAddress_ = serverIntranetAddress; + setParameter("ServerIntranetAddress", serverIntranetAddress); +} + +std::string DescribeLoadBalancersRequest::getVSwitchId()const +{ + return vSwitchId_; +} + +void DescribeLoadBalancersRequest::setVSwitchId(const std::string& vSwitchId) +{ + vSwitchId_ = vSwitchId; + setParameter("VSwitchId", vSwitchId); +} + +std::string DescribeLoadBalancersRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void DescribeLoadBalancersRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string DescribeLoadBalancersRequest::getInternetChargeType()const +{ + return internetChargeType_; +} + +void DescribeLoadBalancersRequest::setInternetChargeType(const std::string& internetChargeType) +{ + internetChargeType_ = internetChargeType; + setParameter("InternetChargeType", internetChargeType); +} + +std::string DescribeLoadBalancersRequest::getVpcId()const +{ + return vpcId_; +} + +void DescribeLoadBalancersRequest::setVpcId(const std::string& vpcId) +{ + vpcId_ = vpcId; + setParameter("VpcId", vpcId); +} + +std::string DescribeLoadBalancersRequest::getPayType()const +{ + return payType_; +} + +void DescribeLoadBalancersRequest::setPayType(const std::string& payType) +{ + payType_ = payType; + setParameter("PayType", payType); +} + diff --git a/slb/src/model/DescribeLoadBalancersResult.cc b/slb/src/model/DescribeLoadBalancersResult.cc new file mode 100644 index 000000000..7201bf4a4 --- /dev/null +++ b/slb/src/model/DescribeLoadBalancersResult.cc @@ -0,0 +1,101 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeLoadBalancersResult::DescribeLoadBalancersResult() : + ServiceResult() +{} + +DescribeLoadBalancersResult::DescribeLoadBalancersResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeLoadBalancersResult::~DescribeLoadBalancersResult() +{} + +void DescribeLoadBalancersResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allLoadBalancers = value["LoadBalancers"]["LoadBalancer"]; + for (auto value : allLoadBalancers) + { + LoadBalancer loadBalancerObject; + loadBalancerObject.loadBalancerId = value["LoadBalancerId"].asString(); + loadBalancerObject.loadBalancerName = value["LoadBalancerName"].asString(); + loadBalancerObject.loadBalancerStatus = value["LoadBalancerStatus"].asString(); + loadBalancerObject.address = value["Address"].asString(); + loadBalancerObject.addressType = value["AddressType"].asString(); + loadBalancerObject.regionId = value["RegionId"].asString(); + loadBalancerObject.regionIdAlias = value["RegionIdAlias"].asString(); + loadBalancerObject.vSwitchId = value["VSwitchId"].asString(); + loadBalancerObject.vpcId = value["VpcId"].asString(); + loadBalancerObject.networkType = value["NetworkType"].asString(); + loadBalancerObject.masterZoneId = value["MasterZoneId"].asString(); + loadBalancerObject.slaveZoneId = value["SlaveZoneId"].asString(); + loadBalancerObject.internetChargeType = value["InternetChargeType"].asString(); + loadBalancerObject.createTime = value["CreateTime"].asString(); + loadBalancerObject.createTimeStamp = std::stol(value["CreateTimeStamp"].asString()); + loadBalancerObject.payType = value["PayType"].asString(); + loadBalancerObject.resourceGroupId = value["ResourceGroupId"].asString(); + loadBalancers_.push_back(loadBalancerObject); + } + pageNumber_ = std::stoi(value["PageNumber"].asString()); + pageSize_ = std::stoi(value["PageSize"].asString()); + totalCount_ = std::stoi(value["TotalCount"].asString()); + +} + +int DescribeLoadBalancersResult::getTotalCount()const +{ + return totalCount_; +} + +void DescribeLoadBalancersResult::setTotalCount(int totalCount) +{ + totalCount_ = totalCount; +} + +int DescribeLoadBalancersResult::getPageSize()const +{ + return pageSize_; +} + +void DescribeLoadBalancersResult::setPageSize(int pageSize) +{ + pageSize_ = pageSize; +} + +int DescribeLoadBalancersResult::getPageNumber()const +{ + return pageNumber_; +} + +void DescribeLoadBalancersResult::setPageNumber(int pageNumber) +{ + pageNumber_ = pageNumber; +} + diff --git a/slb/src/model/DescribeMasterSlaveServerGroupAttributeRequest.cc b/slb/src/model/DescribeMasterSlaveServerGroupAttributeRequest.cc new file mode 100644 index 000000000..0be6f1878 --- /dev/null +++ b/slb/src/model/DescribeMasterSlaveServerGroupAttributeRequest.cc @@ -0,0 +1,127 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeMasterSlaveServerGroupAttributeRequest::DescribeMasterSlaveServerGroupAttributeRequest() : + SlbRequest("DescribeMasterSlaveServerGroupAttribute") +{} + +DescribeMasterSlaveServerGroupAttributeRequest::~DescribeMasterSlaveServerGroupAttributeRequest() +{} + +std::string DescribeMasterSlaveServerGroupAttributeRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeMasterSlaveServerGroupAttributeRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DescribeMasterSlaveServerGroupAttributeRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeMasterSlaveServerGroupAttributeRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DescribeMasterSlaveServerGroupAttributeRequest::getMasterSlaveServerGroupId()const +{ + return masterSlaveServerGroupId_; +} + +void DescribeMasterSlaveServerGroupAttributeRequest::setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId) +{ + masterSlaveServerGroupId_ = masterSlaveServerGroupId; + setParameter("MasterSlaveServerGroupId", masterSlaveServerGroupId); +} + +std::string DescribeMasterSlaveServerGroupAttributeRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeMasterSlaveServerGroupAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeMasterSlaveServerGroupAttributeRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeMasterSlaveServerGroupAttributeRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeMasterSlaveServerGroupAttributeRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeMasterSlaveServerGroupAttributeRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeMasterSlaveServerGroupAttributeRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeMasterSlaveServerGroupAttributeRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeMasterSlaveServerGroupAttributeRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeMasterSlaveServerGroupAttributeRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeMasterSlaveServerGroupAttributeRequest::getTags()const +{ + return tags_; +} + +void DescribeMasterSlaveServerGroupAttributeRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DescribeMasterSlaveServerGroupAttributeResult.cc b/slb/src/model/DescribeMasterSlaveServerGroupAttributeResult.cc new file mode 100644 index 000000000..86b932ee6 --- /dev/null +++ b/slb/src/model/DescribeMasterSlaveServerGroupAttributeResult.cc @@ -0,0 +1,77 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeMasterSlaveServerGroupAttributeResult::DescribeMasterSlaveServerGroupAttributeResult() : + ServiceResult() +{} + +DescribeMasterSlaveServerGroupAttributeResult::DescribeMasterSlaveServerGroupAttributeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeMasterSlaveServerGroupAttributeResult::~DescribeMasterSlaveServerGroupAttributeResult() +{} + +void DescribeMasterSlaveServerGroupAttributeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allMasterSlaveBackendServers = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"]; + for (auto value : allMasterSlaveBackendServers) + { + MasterSlaveBackendServer masterSlaveBackendServerObject; + masterSlaveBackendServerObject.serverId = value["ServerId"].asString(); + masterSlaveBackendServerObject.port = std::stoi(value["Port"].asString()); + masterSlaveBackendServerObject.weight = std::stoi(value["Weight"].asString()); + masterSlaveBackendServerObject.serverType = value["ServerType"].asString(); + masterSlaveBackendServers_.push_back(masterSlaveBackendServerObject); + } + masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString(); + masterSlaveServerGroupName_ = value["MasterSlaveServerGroupName"].asString(); + +} + +std::string DescribeMasterSlaveServerGroupAttributeResult::getMasterSlaveServerGroupId()const +{ + return masterSlaveServerGroupId_; +} + +void DescribeMasterSlaveServerGroupAttributeResult::setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId) +{ + masterSlaveServerGroupId_ = masterSlaveServerGroupId; +} + +std::string DescribeMasterSlaveServerGroupAttributeResult::getMasterSlaveServerGroupName()const +{ + return masterSlaveServerGroupName_; +} + +void DescribeMasterSlaveServerGroupAttributeResult::setMasterSlaveServerGroupName(const std::string& masterSlaveServerGroupName) +{ + masterSlaveServerGroupName_ = masterSlaveServerGroupName; +} + diff --git a/slb/src/model/DescribeMasterSlaveServerGroupsRequest.cc b/slb/src/model/DescribeMasterSlaveServerGroupsRequest.cc new file mode 100644 index 000000000..2809dac12 --- /dev/null +++ b/slb/src/model/DescribeMasterSlaveServerGroupsRequest.cc @@ -0,0 +1,127 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeMasterSlaveServerGroupsRequest::DescribeMasterSlaveServerGroupsRequest() : + SlbRequest("DescribeMasterSlaveServerGroups") +{} + +DescribeMasterSlaveServerGroupsRequest::~DescribeMasterSlaveServerGroupsRequest() +{} + +std::string DescribeMasterSlaveServerGroupsRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeMasterSlaveServerGroupsRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DescribeMasterSlaveServerGroupsRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeMasterSlaveServerGroupsRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DescribeMasterSlaveServerGroupsRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void DescribeMasterSlaveServerGroupsRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string DescribeMasterSlaveServerGroupsRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeMasterSlaveServerGroupsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeMasterSlaveServerGroupsRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeMasterSlaveServerGroupsRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeMasterSlaveServerGroupsRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeMasterSlaveServerGroupsRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeMasterSlaveServerGroupsRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeMasterSlaveServerGroupsRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeMasterSlaveServerGroupsRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeMasterSlaveServerGroupsRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeMasterSlaveServerGroupsRequest::getTags()const +{ + return tags_; +} + +void DescribeMasterSlaveServerGroupsRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DescribeMasterSlaveServerGroupsResult.cc b/slb/src/model/DescribeMasterSlaveServerGroupsResult.cc new file mode 100644 index 000000000..c944adc48 --- /dev/null +++ b/slb/src/model/DescribeMasterSlaveServerGroupsResult.cc @@ -0,0 +1,53 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeMasterSlaveServerGroupsResult::DescribeMasterSlaveServerGroupsResult() : + ServiceResult() +{} + +DescribeMasterSlaveServerGroupsResult::DescribeMasterSlaveServerGroupsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeMasterSlaveServerGroupsResult::~DescribeMasterSlaveServerGroupsResult() +{} + +void DescribeMasterSlaveServerGroupsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allMasterSlaveServerGroups = value["MasterSlaveServerGroups"]["MasterSlaveServerGroup"]; + for (auto value : allMasterSlaveServerGroups) + { + MasterSlaveServerGroup masterSlaveServerGroupObject; + masterSlaveServerGroupObject.masterSlaveServerGroupId = value["MasterSlaveServerGroupId"].asString(); + masterSlaveServerGroupObject.masterSlaveServerGroupName = value["MasterSlaveServerGroupName"].asString(); + masterSlaveServerGroups_.push_back(masterSlaveServerGroupObject); + } + +} + diff --git a/slb/src/model/DescribeMasterSlaveVServerGroupAttributeRequest.cc b/slb/src/model/DescribeMasterSlaveVServerGroupAttributeRequest.cc new file mode 100644 index 000000000..7cdec9afd --- /dev/null +++ b/slb/src/model/DescribeMasterSlaveVServerGroupAttributeRequest.cc @@ -0,0 +1,127 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeMasterSlaveVServerGroupAttributeRequest::DescribeMasterSlaveVServerGroupAttributeRequest() : + SlbRequest("DescribeMasterSlaveVServerGroupAttribute") +{} + +DescribeMasterSlaveVServerGroupAttributeRequest::~DescribeMasterSlaveVServerGroupAttributeRequest() +{} + +std::string DescribeMasterSlaveVServerGroupAttributeRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeMasterSlaveVServerGroupAttributeRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DescribeMasterSlaveVServerGroupAttributeRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeMasterSlaveVServerGroupAttributeRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DescribeMasterSlaveVServerGroupAttributeRequest::getMasterSlaveVServerGroupId()const +{ + return masterSlaveVServerGroupId_; +} + +void DescribeMasterSlaveVServerGroupAttributeRequest::setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId) +{ + masterSlaveVServerGroupId_ = masterSlaveVServerGroupId; + setParameter("MasterSlaveVServerGroupId", masterSlaveVServerGroupId); +} + +std::string DescribeMasterSlaveVServerGroupAttributeRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeMasterSlaveVServerGroupAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeMasterSlaveVServerGroupAttributeRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeMasterSlaveVServerGroupAttributeRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeMasterSlaveVServerGroupAttributeRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeMasterSlaveVServerGroupAttributeRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeMasterSlaveVServerGroupAttributeRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeMasterSlaveVServerGroupAttributeRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeMasterSlaveVServerGroupAttributeRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeMasterSlaveVServerGroupAttributeRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeMasterSlaveVServerGroupAttributeRequest::getTags()const +{ + return tags_; +} + +void DescribeMasterSlaveVServerGroupAttributeRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DescribeMasterSlaveVServerGroupAttributeResult.cc b/slb/src/model/DescribeMasterSlaveVServerGroupAttributeResult.cc new file mode 100644 index 000000000..dbc0fd1f7 --- /dev/null +++ b/slb/src/model/DescribeMasterSlaveVServerGroupAttributeResult.cc @@ -0,0 +1,77 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeMasterSlaveVServerGroupAttributeResult::DescribeMasterSlaveVServerGroupAttributeResult() : + ServiceResult() +{} + +DescribeMasterSlaveVServerGroupAttributeResult::DescribeMasterSlaveVServerGroupAttributeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeMasterSlaveVServerGroupAttributeResult::~DescribeMasterSlaveVServerGroupAttributeResult() +{} + +void DescribeMasterSlaveVServerGroupAttributeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allMasterSlaveBackendServers = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"]; + for (auto value : allMasterSlaveBackendServers) + { + MasterSlaveBackendServer masterSlaveBackendServerObject; + masterSlaveBackendServerObject.serverId = value["ServerId"].asString(); + masterSlaveBackendServerObject.port = std::stoi(value["Port"].asString()); + masterSlaveBackendServerObject.weight = std::stoi(value["Weight"].asString()); + masterSlaveBackendServerObject.isBackup = std::stoi(value["IsBackup"].asString()); + masterSlaveBackendServers_.push_back(masterSlaveBackendServerObject); + } + masterSlaveVServerGroupId_ = value["MasterSlaveVServerGroupId"].asString(); + masterSlaveVServerGroupName_ = value["MasterSlaveVServerGroupName"].asString(); + +} + +std::string DescribeMasterSlaveVServerGroupAttributeResult::getMasterSlaveVServerGroupId()const +{ + return masterSlaveVServerGroupId_; +} + +void DescribeMasterSlaveVServerGroupAttributeResult::setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId) +{ + masterSlaveVServerGroupId_ = masterSlaveVServerGroupId; +} + +std::string DescribeMasterSlaveVServerGroupAttributeResult::getMasterSlaveVServerGroupName()const +{ + return masterSlaveVServerGroupName_; +} + +void DescribeMasterSlaveVServerGroupAttributeResult::setMasterSlaveVServerGroupName(const std::string& masterSlaveVServerGroupName) +{ + masterSlaveVServerGroupName_ = masterSlaveVServerGroupName; +} + diff --git a/slb/src/model/DescribeMasterSlaveVServerGroupsRequest.cc b/slb/src/model/DescribeMasterSlaveVServerGroupsRequest.cc new file mode 100644 index 000000000..76094eab9 --- /dev/null +++ b/slb/src/model/DescribeMasterSlaveVServerGroupsRequest.cc @@ -0,0 +1,127 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeMasterSlaveVServerGroupsRequest::DescribeMasterSlaveVServerGroupsRequest() : + SlbRequest("DescribeMasterSlaveVServerGroups") +{} + +DescribeMasterSlaveVServerGroupsRequest::~DescribeMasterSlaveVServerGroupsRequest() +{} + +std::string DescribeMasterSlaveVServerGroupsRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeMasterSlaveVServerGroupsRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DescribeMasterSlaveVServerGroupsRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeMasterSlaveVServerGroupsRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DescribeMasterSlaveVServerGroupsRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void DescribeMasterSlaveVServerGroupsRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string DescribeMasterSlaveVServerGroupsRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeMasterSlaveVServerGroupsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeMasterSlaveVServerGroupsRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeMasterSlaveVServerGroupsRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeMasterSlaveVServerGroupsRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeMasterSlaveVServerGroupsRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeMasterSlaveVServerGroupsRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeMasterSlaveVServerGroupsRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeMasterSlaveVServerGroupsRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeMasterSlaveVServerGroupsRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeMasterSlaveVServerGroupsRequest::getTags()const +{ + return tags_; +} + +void DescribeMasterSlaveVServerGroupsRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DescribeMasterSlaveVServerGroupsResult.cc b/slb/src/model/DescribeMasterSlaveVServerGroupsResult.cc new file mode 100644 index 000000000..b8daaa22d --- /dev/null +++ b/slb/src/model/DescribeMasterSlaveVServerGroupsResult.cc @@ -0,0 +1,53 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeMasterSlaveVServerGroupsResult::DescribeMasterSlaveVServerGroupsResult() : + ServiceResult() +{} + +DescribeMasterSlaveVServerGroupsResult::DescribeMasterSlaveVServerGroupsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeMasterSlaveVServerGroupsResult::~DescribeMasterSlaveVServerGroupsResult() +{} + +void DescribeMasterSlaveVServerGroupsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allMasterSlaveVServerGroups = value["MasterSlaveVServerGroups"]["MasterSlaveVServerGroup"]; + for (auto value : allMasterSlaveVServerGroups) + { + MasterSlaveVServerGroup masterSlaveVServerGroupObject; + masterSlaveVServerGroupObject.masterSlaveVServerGroupId = value["MasterSlaveVServerGroupId"].asString(); + masterSlaveVServerGroupObject.masterSlaveVServerGroupName = value["MasterSlaveVServerGroupName"].asString(); + masterSlaveVServerGroups_.push_back(masterSlaveVServerGroupObject); + } + +} + diff --git a/slb/src/model/DescribeRegionsRequest.cc b/slb/src/model/DescribeRegionsRequest.cc new file mode 100644 index 000000000..2faa4adb1 --- /dev/null +++ b/slb/src/model/DescribeRegionsRequest.cc @@ -0,0 +1,116 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeRegionsRequest::DescribeRegionsRequest() : + SlbRequest("DescribeRegions") +{} + +DescribeRegionsRequest::~DescribeRegionsRequest() +{} + +std::string DescribeRegionsRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeRegionsRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DescribeRegionsRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeRegionsRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DescribeRegionsRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeRegionsRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeRegionsRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeRegionsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeRegionsRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeRegionsRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeRegionsRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeRegionsRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeRegionsRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeRegionsRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeRegionsRequest::getTags()const +{ + return tags_; +} + +void DescribeRegionsRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DescribeRegionsResult.cc b/slb/src/model/DescribeRegionsResult.cc new file mode 100644 index 000000000..8bb7cb84c --- /dev/null +++ b/slb/src/model/DescribeRegionsResult.cc @@ -0,0 +1,53 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::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 allRegions = value["Regions"]["Region"]; + for (auto value : allRegions) + { + Region regionObject; + regionObject.regionId = value["RegionId"].asString(); + regionObject.localName = value["LocalName"].asString(); + regions_.push_back(regionObject); + } + +} + diff --git a/slb/src/model/DescribeRuleAttributeRequest.cc b/slb/src/model/DescribeRuleAttributeRequest.cc new file mode 100644 index 000000000..51ec02280 --- /dev/null +++ b/slb/src/model/DescribeRuleAttributeRequest.cc @@ -0,0 +1,127 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeRuleAttributeRequest::DescribeRuleAttributeRequest() : + SlbRequest("DescribeRuleAttribute") +{} + +DescribeRuleAttributeRequest::~DescribeRuleAttributeRequest() +{} + +std::string DescribeRuleAttributeRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeRuleAttributeRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DescribeRuleAttributeRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeRuleAttributeRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DescribeRuleAttributeRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeRuleAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeRuleAttributeRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeRuleAttributeRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeRuleAttributeRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeRuleAttributeRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeRuleAttributeRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeRuleAttributeRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeRuleAttributeRequest::getRuleId()const +{ + return ruleId_; +} + +void DescribeRuleAttributeRequest::setRuleId(const std::string& ruleId) +{ + ruleId_ = ruleId; + setParameter("RuleId", ruleId); +} + +std::string DescribeRuleAttributeRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeRuleAttributeRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeRuleAttributeRequest::getTags()const +{ + return tags_; +} + +void DescribeRuleAttributeRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DescribeRuleAttributeResult.cc b/slb/src/model/DescribeRuleAttributeResult.cc new file mode 100644 index 000000000..f6bd9310d --- /dev/null +++ b/slb/src/model/DescribeRuleAttributeResult.cc @@ -0,0 +1,111 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeRuleAttributeResult::DescribeRuleAttributeResult() : + ServiceResult() +{} + +DescribeRuleAttributeResult::DescribeRuleAttributeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeRuleAttributeResult::~DescribeRuleAttributeResult() +{} + +void DescribeRuleAttributeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + ruleName_ = value["RuleName"].asString(); + loadBalancerId_ = value["LoadBalancerId"].asString(); + listenerPort_ = value["ListenerPort"].asString(); + domain_ = value["Domain"].asString(); + url_ = value["Url"].asString(); + vServerGroupId_ = value["VServerGroupId"].asString(); + +} + +std::string DescribeRuleAttributeResult::getListenerPort()const +{ + return listenerPort_; +} + +void DescribeRuleAttributeResult::setListenerPort(const std::string& listenerPort) +{ + listenerPort_ = listenerPort; +} + +std::string DescribeRuleAttributeResult::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void DescribeRuleAttributeResult::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; +} + +std::string DescribeRuleAttributeResult::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void DescribeRuleAttributeResult::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; +} + +std::string DescribeRuleAttributeResult::getDomain()const +{ + return domain_; +} + +void DescribeRuleAttributeResult::setDomain(const std::string& domain) +{ + domain_ = domain; +} + +std::string DescribeRuleAttributeResult::getRuleName()const +{ + return ruleName_; +} + +void DescribeRuleAttributeResult::setRuleName(const std::string& ruleName) +{ + ruleName_ = ruleName; +} + +std::string DescribeRuleAttributeResult::getUrl()const +{ + return url_; +} + +void DescribeRuleAttributeResult::setUrl(const std::string& url) +{ + url_ = url; +} + diff --git a/slb/src/model/DescribeRulesRequest.cc b/slb/src/model/DescribeRulesRequest.cc new file mode 100644 index 000000000..72fb5480e --- /dev/null +++ b/slb/src/model/DescribeRulesRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeRulesRequest::DescribeRulesRequest() : + SlbRequest("DescribeRules") +{} + +DescribeRulesRequest::~DescribeRulesRequest() +{} + +std::string DescribeRulesRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeRulesRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DescribeRulesRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeRulesRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +int DescribeRulesRequest::getListenerPort()const +{ + return listenerPort_; +} + +void DescribeRulesRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string DescribeRulesRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void DescribeRulesRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string DescribeRulesRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeRulesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeRulesRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeRulesRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeRulesRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeRulesRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeRulesRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeRulesRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeRulesRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeRulesRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeRulesRequest::getTags()const +{ + return tags_; +} + +void DescribeRulesRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DescribeRulesResult.cc b/slb/src/model/DescribeRulesResult.cc new file mode 100644 index 000000000..4bcef76c4 --- /dev/null +++ b/slb/src/model/DescribeRulesResult.cc @@ -0,0 +1,56 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeRulesResult::DescribeRulesResult() : + ServiceResult() +{} + +DescribeRulesResult::DescribeRulesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeRulesResult::~DescribeRulesResult() +{} + +void DescribeRulesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allRules = value["Rules"]["Rule"]; + for (auto value : allRules) + { + Rule ruleObject; + ruleObject.ruleId = value["RuleId"].asString(); + ruleObject.ruleName = value["RuleName"].asString(); + ruleObject.domain = value["Domain"].asString(); + ruleObject.url = value["Url"].asString(); + ruleObject.vServerGroupId = value["VServerGroupId"].asString(); + rules_.push_back(ruleObject); + } + +} + diff --git a/slb/src/model/DescribeServerCertificatesRequest.cc b/slb/src/model/DescribeServerCertificatesRequest.cc new file mode 100644 index 000000000..3ffd0ec6e --- /dev/null +++ b/slb/src/model/DescribeServerCertificatesRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeServerCertificatesRequest::DescribeServerCertificatesRequest() : + SlbRequest("DescribeServerCertificates") +{} + +DescribeServerCertificatesRequest::~DescribeServerCertificatesRequest() +{} + +std::string DescribeServerCertificatesRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeServerCertificatesRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +std::string DescribeServerCertificatesRequest::getResourceGroupId()const +{ + return resourceGroupId_; +} + +void DescribeServerCertificatesRequest::setResourceGroupId(const std::string& resourceGroupId) +{ + resourceGroupId_ = resourceGroupId; + setParameter("ResourceGroupId", resourceGroupId); +} + +long DescribeServerCertificatesRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeServerCertificatesRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DescribeServerCertificatesRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeServerCertificatesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeServerCertificatesRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeServerCertificatesRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeServerCertificatesRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeServerCertificatesRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeServerCertificatesRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeServerCertificatesRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeServerCertificatesRequest::getServerCertificateId()const +{ + return serverCertificateId_; +} + +void DescribeServerCertificatesRequest::setServerCertificateId(const std::string& serverCertificateId) +{ + serverCertificateId_ = serverCertificateId; + setParameter("ServerCertificateId", serverCertificateId); +} + +std::string DescribeServerCertificatesRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeServerCertificatesRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeServerCertificatesRequest::getTags()const +{ + return tags_; +} + +void DescribeServerCertificatesRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DescribeServerCertificatesResult.cc b/slb/src/model/DescribeServerCertificatesResult.cc new file mode 100644 index 000000000..f533eadf1 --- /dev/null +++ b/slb/src/model/DescribeServerCertificatesResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeServerCertificatesResult::DescribeServerCertificatesResult() : + ServiceResult() +{} + +DescribeServerCertificatesResult::DescribeServerCertificatesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeServerCertificatesResult::~DescribeServerCertificatesResult() +{} + +void DescribeServerCertificatesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allServerCertificates = value["ServerCertificates"]["ServerCertificate"]; + for (auto value : allServerCertificates) + { + ServerCertificate serverCertificateObject; + serverCertificateObject.serverCertificateId = value["ServerCertificateId"].asString(); + serverCertificateObject.fingerprint = value["Fingerprint"].asString(); + serverCertificateObject.serverCertificateName = value["ServerCertificateName"].asString(); + serverCertificateObject.regionId = value["RegionId"].asString(); + serverCertificateObject.regionIdAlias = value["RegionIdAlias"].asString(); + serverCertificateObject.aliCloudCertificateId = value["AliCloudCertificateId"].asString(); + serverCertificateObject.aliCloudCertificateName = value["AliCloudCertificateName"].asString(); + serverCertificateObject.isAliCloudCertificate = std::stoi(value["IsAliCloudCertificate"].asString()); + serverCertificateObject.resourceGroupId = value["ResourceGroupId"].asString(); + serverCertificateObject.createTime = value["CreateTime"].asString(); + serverCertificateObject.createTimeStamp = std::stol(value["CreateTimeStamp"].asString()); + serverCertificates_.push_back(serverCertificateObject); + } + +} + diff --git a/slb/src/model/DescribeTagsRequest.cc b/slb/src/model/DescribeTagsRequest.cc new file mode 100644 index 000000000..a010ba046 --- /dev/null +++ b/slb/src/model/DescribeTagsRequest.cc @@ -0,0 +1,160 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeTagsRequest::DescribeTagsRequest() : + SlbRequest("DescribeTags") +{} + +DescribeTagsRequest::~DescribeTagsRequest() +{} + +std::string DescribeTagsRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeTagsRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DescribeTagsRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeTagsRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DescribeTagsRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeTagsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeTagsRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeTagsRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +bool DescribeTagsRequest::getDistinctKey()const +{ + return distinctKey_; +} + +void DescribeTagsRequest::setDistinctKey(bool distinctKey) +{ + distinctKey_ = distinctKey; + setParameter("DistinctKey", std::to_string(distinctKey)); +} + +long DescribeTagsRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeTagsRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +int DescribeTagsRequest::getPageNumber()const +{ + return pageNumber_; +} + +void DescribeTagsRequest::setPageNumber(int pageNumber) +{ + pageNumber_ = pageNumber; + setParameter("PageNumber", std::to_string(pageNumber)); +} + +std::string DescribeTagsRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeTagsRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeTagsRequest::getTags()const +{ + return tags_; +} + +void DescribeTagsRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + +std::string DescribeTagsRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void DescribeTagsRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string DescribeTagsRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeTagsRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +int DescribeTagsRequest::getPageSize()const +{ + return pageSize_; +} + +void DescribeTagsRequest::setPageSize(int pageSize) +{ + pageSize_ = pageSize; + setParameter("PageSize", std::to_string(pageSize)); +} + diff --git a/slb/src/model/DescribeTagsResult.cc b/slb/src/model/DescribeTagsResult.cc new file mode 100644 index 000000000..2e41438ba --- /dev/null +++ b/slb/src/model/DescribeTagsResult.cc @@ -0,0 +1,87 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeTagsResult::DescribeTagsResult() : + ServiceResult() +{} + +DescribeTagsResult::DescribeTagsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeTagsResult::~DescribeTagsResult() +{} + +void DescribeTagsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allTagSets = value["TagSets"]["TagSet"]; + for (auto value : allTagSets) + { + TagSet tagSetObject; + tagSetObject.tagKey = value["TagKey"].asString(); + tagSetObject.tagValue = value["TagValue"].asString(); + tagSetObject.instanceCount = std::stoi(value["InstanceCount"].asString()); + tagSets_.push_back(tagSetObject); + } + pageSize_ = std::stoi(value["PageSize"].asString()); + pageNumber_ = std::stoi(value["PageNumber"].asString()); + totalCount_ = std::stoi(value["TotalCount"].asString()); + +} + +int DescribeTagsResult::getTotalCount()const +{ + return totalCount_; +} + +void DescribeTagsResult::setTotalCount(int totalCount) +{ + totalCount_ = totalCount; +} + +int DescribeTagsResult::getPageSize()const +{ + return pageSize_; +} + +void DescribeTagsResult::setPageSize(int pageSize) +{ + pageSize_ = pageSize; +} + +int DescribeTagsResult::getPageNumber()const +{ + return pageNumber_; +} + +void DescribeTagsResult::setPageNumber(int pageNumber) +{ + pageNumber_ = pageNumber; +} + diff --git a/slb/src/model/DescribeVServerGroupAttributeRequest.cc b/slb/src/model/DescribeVServerGroupAttributeRequest.cc new file mode 100644 index 000000000..eb2e75bfa --- /dev/null +++ b/slb/src/model/DescribeVServerGroupAttributeRequest.cc @@ -0,0 +1,127 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeVServerGroupAttributeRequest::DescribeVServerGroupAttributeRequest() : + SlbRequest("DescribeVServerGroupAttribute") +{} + +DescribeVServerGroupAttributeRequest::~DescribeVServerGroupAttributeRequest() +{} + +std::string DescribeVServerGroupAttributeRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeVServerGroupAttributeRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +std::string DescribeVServerGroupAttributeRequest::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void DescribeVServerGroupAttributeRequest::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; + setParameter("VServerGroupId", vServerGroupId); +} + +long DescribeVServerGroupAttributeRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeVServerGroupAttributeRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DescribeVServerGroupAttributeRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeVServerGroupAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeVServerGroupAttributeRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeVServerGroupAttributeRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeVServerGroupAttributeRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeVServerGroupAttributeRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeVServerGroupAttributeRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeVServerGroupAttributeRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeVServerGroupAttributeRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeVServerGroupAttributeRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeVServerGroupAttributeRequest::getTags()const +{ + return tags_; +} + +void DescribeVServerGroupAttributeRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DescribeVServerGroupAttributeResult.cc b/slb/src/model/DescribeVServerGroupAttributeResult.cc new file mode 100644 index 000000000..dc4edd4a7 --- /dev/null +++ b/slb/src/model/DescribeVServerGroupAttributeResult.cc @@ -0,0 +1,76 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeVServerGroupAttributeResult::DescribeVServerGroupAttributeResult() : + ServiceResult() +{} + +DescribeVServerGroupAttributeResult::DescribeVServerGroupAttributeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeVServerGroupAttributeResult::~DescribeVServerGroupAttributeResult() +{} + +void DescribeVServerGroupAttributeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allBackendServers = value["BackendServers"]["BackendServer"]; + for (auto value : allBackendServers) + { + BackendServer backendServerObject; + backendServerObject.serverId = value["ServerId"].asString(); + backendServerObject.port = std::stoi(value["Port"].asString()); + backendServerObject.weight = std::stoi(value["Weight"].asString()); + backendServers_.push_back(backendServerObject); + } + vServerGroupId_ = value["VServerGroupId"].asString(); + vServerGroupName_ = value["VServerGroupName"].asString(); + +} + +std::string DescribeVServerGroupAttributeResult::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void DescribeVServerGroupAttributeResult::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; +} + +std::string DescribeVServerGroupAttributeResult::getVServerGroupName()const +{ + return vServerGroupName_; +} + +void DescribeVServerGroupAttributeResult::setVServerGroupName(const std::string& vServerGroupName) +{ + vServerGroupName_ = vServerGroupName; +} + diff --git a/slb/src/model/DescribeVServerGroupsRequest.cc b/slb/src/model/DescribeVServerGroupsRequest.cc new file mode 100644 index 000000000..3a6304c6b --- /dev/null +++ b/slb/src/model/DescribeVServerGroupsRequest.cc @@ -0,0 +1,127 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeVServerGroupsRequest::DescribeVServerGroupsRequest() : + SlbRequest("DescribeVServerGroups") +{} + +DescribeVServerGroupsRequest::~DescribeVServerGroupsRequest() +{} + +std::string DescribeVServerGroupsRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeVServerGroupsRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DescribeVServerGroupsRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeVServerGroupsRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DescribeVServerGroupsRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void DescribeVServerGroupsRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string DescribeVServerGroupsRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeVServerGroupsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeVServerGroupsRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeVServerGroupsRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeVServerGroupsRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeVServerGroupsRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeVServerGroupsRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeVServerGroupsRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeVServerGroupsRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeVServerGroupsRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeVServerGroupsRequest::getTags()const +{ + return tags_; +} + +void DescribeVServerGroupsRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DescribeVServerGroupsResult.cc b/slb/src/model/DescribeVServerGroupsResult.cc new file mode 100644 index 000000000..965f1dada --- /dev/null +++ b/slb/src/model/DescribeVServerGroupsResult.cc @@ -0,0 +1,53 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeVServerGroupsResult::DescribeVServerGroupsResult() : + ServiceResult() +{} + +DescribeVServerGroupsResult::DescribeVServerGroupsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeVServerGroupsResult::~DescribeVServerGroupsResult() +{} + +void DescribeVServerGroupsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allVServerGroups = value["VServerGroups"]["VServerGroup"]; + for (auto value : allVServerGroups) + { + VServerGroup vServerGroupObject; + vServerGroupObject.vServerGroupId = value["VServerGroupId"].asString(); + vServerGroupObject.vServerGroupName = value["VServerGroupName"].asString(); + vServerGroups_.push_back(vServerGroupObject); + } + +} + diff --git a/slb/src/model/DescribeZonesRequest.cc b/slb/src/model/DescribeZonesRequest.cc new file mode 100644 index 000000000..6aba2729c --- /dev/null +++ b/slb/src/model/DescribeZonesRequest.cc @@ -0,0 +1,116 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeZonesRequest::DescribeZonesRequest() : + SlbRequest("DescribeZones") +{} + +DescribeZonesRequest::~DescribeZonesRequest() +{} + +std::string DescribeZonesRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void DescribeZonesRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long DescribeZonesRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void DescribeZonesRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string DescribeZonesRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeZonesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string DescribeZonesRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeZonesRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string DescribeZonesRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void DescribeZonesRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long DescribeZonesRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeZonesRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeZonesRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeZonesRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeZonesRequest::getTags()const +{ + return tags_; +} + +void DescribeZonesRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/DescribeZonesResult.cc b/slb/src/model/DescribeZonesResult.cc new file mode 100644 index 000000000..c7736a2ae --- /dev/null +++ b/slb/src/model/DescribeZonesResult.cc @@ -0,0 +1,61 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +DescribeZonesResult::DescribeZonesResult() : + ServiceResult() +{} + +DescribeZonesResult::DescribeZonesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeZonesResult::~DescribeZonesResult() +{} + +void DescribeZonesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allZones = value["Zones"]["Zone"]; + for (auto value : allZones) + { + Zone zoneObject; + zoneObject.zoneId = value["ZoneId"].asString(); + zoneObject.localName = value["LocalName"].asString(); + auto allSlaveZones = value["SlaveZones"]["SlaveZone"]; + for (auto value : allSlaveZones) + { + Zone::SlaveZone slaveZoneObject; + slaveZoneObject.zoneId = value["ZoneId"].asString(); + slaveZoneObject.localName = value["LocalName"].asString(); + zoneObject.slaveZones.push_back(slaveZoneObject); + } + zones_.push_back(zoneObject); + } + +} + diff --git a/slb/src/model/ModifyLoadBalancerInstanceSpecRequest.cc b/slb/src/model/ModifyLoadBalancerInstanceSpecRequest.cc new file mode 100644 index 000000000..3b5b933b5 --- /dev/null +++ b/slb/src/model/ModifyLoadBalancerInstanceSpecRequest.cc @@ -0,0 +1,149 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +ModifyLoadBalancerInstanceSpecRequest::ModifyLoadBalancerInstanceSpecRequest() : + SlbRequest("ModifyLoadBalancerInstanceSpec") +{} + +ModifyLoadBalancerInstanceSpecRequest::~ModifyLoadBalancerInstanceSpecRequest() +{} + +std::string ModifyLoadBalancerInstanceSpecRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void ModifyLoadBalancerInstanceSpecRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +std::string ModifyLoadBalancerInstanceSpecRequest::getLoadBalancerSpec()const +{ + return loadBalancerSpec_; +} + +void ModifyLoadBalancerInstanceSpecRequest::setLoadBalancerSpec(const std::string& loadBalancerSpec) +{ + loadBalancerSpec_ = loadBalancerSpec; + setParameter("LoadBalancerSpec", loadBalancerSpec); +} + +long ModifyLoadBalancerInstanceSpecRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void ModifyLoadBalancerInstanceSpecRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string ModifyLoadBalancerInstanceSpecRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void ModifyLoadBalancerInstanceSpecRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +bool ModifyLoadBalancerInstanceSpecRequest::getAutoPay()const +{ + return autoPay_; +} + +void ModifyLoadBalancerInstanceSpecRequest::setAutoPay(bool autoPay) +{ + autoPay_ = autoPay; + setParameter("AutoPay", std::to_string(autoPay)); +} + +std::string ModifyLoadBalancerInstanceSpecRequest::getRegionId()const +{ + return regionId_; +} + +void ModifyLoadBalancerInstanceSpecRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string ModifyLoadBalancerInstanceSpecRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void ModifyLoadBalancerInstanceSpecRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string ModifyLoadBalancerInstanceSpecRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void ModifyLoadBalancerInstanceSpecRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long ModifyLoadBalancerInstanceSpecRequest::getOwnerId()const +{ + return ownerId_; +} + +void ModifyLoadBalancerInstanceSpecRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string ModifyLoadBalancerInstanceSpecRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void ModifyLoadBalancerInstanceSpecRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string ModifyLoadBalancerInstanceSpecRequest::getTags()const +{ + return tags_; +} + +void ModifyLoadBalancerInstanceSpecRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/ModifyLoadBalancerInstanceSpecResult.cc b/slb/src/model/ModifyLoadBalancerInstanceSpecResult.cc new file mode 100644 index 000000000..539d039c7 --- /dev/null +++ b/slb/src/model/ModifyLoadBalancerInstanceSpecResult.cc @@ -0,0 +1,56 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +ModifyLoadBalancerInstanceSpecResult::ModifyLoadBalancerInstanceSpecResult() : + ServiceResult() +{} + +ModifyLoadBalancerInstanceSpecResult::ModifyLoadBalancerInstanceSpecResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ModifyLoadBalancerInstanceSpecResult::~ModifyLoadBalancerInstanceSpecResult() +{} + +void ModifyLoadBalancerInstanceSpecResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + orderId_ = std::stol(value["OrderId"].asString()); + +} + +long ModifyLoadBalancerInstanceSpecResult::getOrderId()const +{ + return orderId_; +} + +void ModifyLoadBalancerInstanceSpecResult::setOrderId(long orderId) +{ + orderId_ = orderId; +} + diff --git a/slb/src/model/ModifyLoadBalancerInternetSpecRequest.cc b/slb/src/model/ModifyLoadBalancerInternetSpecRequest.cc new file mode 100644 index 000000000..7bdd0a5e6 --- /dev/null +++ b/slb/src/model/ModifyLoadBalancerInternetSpecRequest.cc @@ -0,0 +1,160 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +ModifyLoadBalancerInternetSpecRequest::ModifyLoadBalancerInternetSpecRequest() : + SlbRequest("ModifyLoadBalancerInternetSpec") +{} + +ModifyLoadBalancerInternetSpecRequest::~ModifyLoadBalancerInternetSpecRequest() +{} + +std::string ModifyLoadBalancerInternetSpecRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void ModifyLoadBalancerInternetSpecRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long ModifyLoadBalancerInternetSpecRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void ModifyLoadBalancerInternetSpecRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +bool ModifyLoadBalancerInternetSpecRequest::getAutoPay()const +{ + return autoPay_; +} + +void ModifyLoadBalancerInternetSpecRequest::setAutoPay(bool autoPay) +{ + autoPay_ = autoPay; + setParameter("AutoPay", std::to_string(autoPay)); +} + +std::string ModifyLoadBalancerInternetSpecRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void ModifyLoadBalancerInternetSpecRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +int ModifyLoadBalancerInternetSpecRequest::getBandwidth()const +{ + return bandwidth_; +} + +void ModifyLoadBalancerInternetSpecRequest::setBandwidth(int bandwidth) +{ + bandwidth_ = bandwidth; + setParameter("Bandwidth", std::to_string(bandwidth)); +} + +std::string ModifyLoadBalancerInternetSpecRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void ModifyLoadBalancerInternetSpecRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long ModifyLoadBalancerInternetSpecRequest::getOwnerId()const +{ + return ownerId_; +} + +void ModifyLoadBalancerInternetSpecRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string ModifyLoadBalancerInternetSpecRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void ModifyLoadBalancerInternetSpecRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string ModifyLoadBalancerInternetSpecRequest::getTags()const +{ + return tags_; +} + +void ModifyLoadBalancerInternetSpecRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + +std::string ModifyLoadBalancerInternetSpecRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void ModifyLoadBalancerInternetSpecRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string ModifyLoadBalancerInternetSpecRequest::getRegionId()const +{ + return regionId_; +} + +void ModifyLoadBalancerInternetSpecRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string ModifyLoadBalancerInternetSpecRequest::getInternetChargeType()const +{ + return internetChargeType_; +} + +void ModifyLoadBalancerInternetSpecRequest::setInternetChargeType(const std::string& internetChargeType) +{ + internetChargeType_ = internetChargeType; + setParameter("InternetChargeType", internetChargeType); +} + diff --git a/slb/src/model/ModifyLoadBalancerInternetSpecResult.cc b/slb/src/model/ModifyLoadBalancerInternetSpecResult.cc new file mode 100644 index 000000000..c29b4f3f2 --- /dev/null +++ b/slb/src/model/ModifyLoadBalancerInternetSpecResult.cc @@ -0,0 +1,56 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +ModifyLoadBalancerInternetSpecResult::ModifyLoadBalancerInternetSpecResult() : + ServiceResult() +{} + +ModifyLoadBalancerInternetSpecResult::ModifyLoadBalancerInternetSpecResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ModifyLoadBalancerInternetSpecResult::~ModifyLoadBalancerInternetSpecResult() +{} + +void ModifyLoadBalancerInternetSpecResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + orderId_ = std::stol(value["OrderId"].asString()); + +} + +long ModifyLoadBalancerInternetSpecResult::getOrderId()const +{ + return orderId_; +} + +void ModifyLoadBalancerInternetSpecResult::setOrderId(long orderId) +{ + orderId_ = orderId; +} + diff --git a/slb/src/model/ModifyLoadBalancerPayTypeRequest.cc b/slb/src/model/ModifyLoadBalancerPayTypeRequest.cc new file mode 100644 index 000000000..77d79fb18 --- /dev/null +++ b/slb/src/model/ModifyLoadBalancerPayTypeRequest.cc @@ -0,0 +1,171 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +ModifyLoadBalancerPayTypeRequest::ModifyLoadBalancerPayTypeRequest() : + SlbRequest("ModifyLoadBalancerPayType") +{} + +ModifyLoadBalancerPayTypeRequest::~ModifyLoadBalancerPayTypeRequest() +{} + +std::string ModifyLoadBalancerPayTypeRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void ModifyLoadBalancerPayTypeRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long ModifyLoadBalancerPayTypeRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void ModifyLoadBalancerPayTypeRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +bool ModifyLoadBalancerPayTypeRequest::getAutoPay()const +{ + return autoPay_; +} + +void ModifyLoadBalancerPayTypeRequest::setAutoPay(bool autoPay) +{ + autoPay_ = autoPay; + setParameter("AutoPay", std::to_string(autoPay)); +} + +std::string ModifyLoadBalancerPayTypeRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void ModifyLoadBalancerPayTypeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string ModifyLoadBalancerPayTypeRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void ModifyLoadBalancerPayTypeRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long ModifyLoadBalancerPayTypeRequest::getOwnerId()const +{ + return ownerId_; +} + +void ModifyLoadBalancerPayTypeRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string ModifyLoadBalancerPayTypeRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void ModifyLoadBalancerPayTypeRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string ModifyLoadBalancerPayTypeRequest::getTags()const +{ + return tags_; +} + +void ModifyLoadBalancerPayTypeRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + +int ModifyLoadBalancerPayTypeRequest::getDuration()const +{ + return duration_; +} + +void ModifyLoadBalancerPayTypeRequest::setDuration(int duration) +{ + duration_ = duration; + setParameter("Duration", std::to_string(duration)); +} + +std::string ModifyLoadBalancerPayTypeRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void ModifyLoadBalancerPayTypeRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string ModifyLoadBalancerPayTypeRequest::getRegionId()const +{ + return regionId_; +} + +void ModifyLoadBalancerPayTypeRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string ModifyLoadBalancerPayTypeRequest::getPayType()const +{ + return payType_; +} + +void ModifyLoadBalancerPayTypeRequest::setPayType(const std::string& payType) +{ + payType_ = payType; + setParameter("PayType", payType); +} + +std::string ModifyLoadBalancerPayTypeRequest::getPricingCycle()const +{ + return pricingCycle_; +} + +void ModifyLoadBalancerPayTypeRequest::setPricingCycle(const std::string& pricingCycle) +{ + pricingCycle_ = pricingCycle; + setParameter("PricingCycle", pricingCycle); +} + diff --git a/slb/src/model/ModifyLoadBalancerPayTypeResult.cc b/slb/src/model/ModifyLoadBalancerPayTypeResult.cc new file mode 100644 index 000000000..4371a4714 --- /dev/null +++ b/slb/src/model/ModifyLoadBalancerPayTypeResult.cc @@ -0,0 +1,56 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +ModifyLoadBalancerPayTypeResult::ModifyLoadBalancerPayTypeResult() : + ServiceResult() +{} + +ModifyLoadBalancerPayTypeResult::ModifyLoadBalancerPayTypeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ModifyLoadBalancerPayTypeResult::~ModifyLoadBalancerPayTypeResult() +{} + +void ModifyLoadBalancerPayTypeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + orderId_ = std::stol(value["OrderId"].asString()); + +} + +long ModifyLoadBalancerPayTypeResult::getOrderId()const +{ + return orderId_; +} + +void ModifyLoadBalancerPayTypeResult::setOrderId(long orderId) +{ + orderId_ = orderId; +} + diff --git a/slb/src/model/ModifyVServerGroupBackendServersRequest.cc b/slb/src/model/ModifyVServerGroupBackendServersRequest.cc new file mode 100644 index 000000000..9297247bf --- /dev/null +++ b/slb/src/model/ModifyVServerGroupBackendServersRequest.cc @@ -0,0 +1,149 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +ModifyVServerGroupBackendServersRequest::ModifyVServerGroupBackendServersRequest() : + SlbRequest("ModifyVServerGroupBackendServers") +{} + +ModifyVServerGroupBackendServersRequest::~ModifyVServerGroupBackendServersRequest() +{} + +std::string ModifyVServerGroupBackendServersRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void ModifyVServerGroupBackendServersRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +std::string ModifyVServerGroupBackendServersRequest::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void ModifyVServerGroupBackendServersRequest::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; + setParameter("VServerGroupId", vServerGroupId); +} + +long ModifyVServerGroupBackendServersRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void ModifyVServerGroupBackendServersRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string ModifyVServerGroupBackendServersRequest::getOldBackendServers()const +{ + return oldBackendServers_; +} + +void ModifyVServerGroupBackendServersRequest::setOldBackendServers(const std::string& oldBackendServers) +{ + oldBackendServers_ = oldBackendServers; + setParameter("OldBackendServers", oldBackendServers); +} + +std::string ModifyVServerGroupBackendServersRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void ModifyVServerGroupBackendServersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string ModifyVServerGroupBackendServersRequest::getRegionId()const +{ + return regionId_; +} + +void ModifyVServerGroupBackendServersRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string ModifyVServerGroupBackendServersRequest::getNewBackendServers()const +{ + return newBackendServers_; +} + +void ModifyVServerGroupBackendServersRequest::setNewBackendServers(const std::string& newBackendServers) +{ + newBackendServers_ = newBackendServers; + setParameter("NewBackendServers", newBackendServers); +} + +std::string ModifyVServerGroupBackendServersRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void ModifyVServerGroupBackendServersRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long ModifyVServerGroupBackendServersRequest::getOwnerId()const +{ + return ownerId_; +} + +void ModifyVServerGroupBackendServersRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string ModifyVServerGroupBackendServersRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void ModifyVServerGroupBackendServersRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string ModifyVServerGroupBackendServersRequest::getTags()const +{ + return tags_; +} + +void ModifyVServerGroupBackendServersRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/ModifyVServerGroupBackendServersResult.cc b/slb/src/model/ModifyVServerGroupBackendServersResult.cc new file mode 100644 index 000000000..73e1f89f5 --- /dev/null +++ b/slb/src/model/ModifyVServerGroupBackendServersResult.cc @@ -0,0 +1,65 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +ModifyVServerGroupBackendServersResult::ModifyVServerGroupBackendServersResult() : + ServiceResult() +{} + +ModifyVServerGroupBackendServersResult::ModifyVServerGroupBackendServersResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ModifyVServerGroupBackendServersResult::~ModifyVServerGroupBackendServersResult() +{} + +void ModifyVServerGroupBackendServersResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allBackendServers = value["BackendServers"]["BackendServer"]; + for (auto value : allBackendServers) + { + BackendServer backendServerObject; + backendServerObject.serverId = value["ServerId"].asString(); + backendServerObject.port = std::stoi(value["Port"].asString()); + backendServerObject.weight = std::stoi(value["Weight"].asString()); + backendServers_.push_back(backendServerObject); + } + vServerGroupId_ = value["VServerGroupId"].asString(); + +} + +std::string ModifyVServerGroupBackendServersResult::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void ModifyVServerGroupBackendServersResult::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; +} + diff --git a/slb/src/model/MoveResourceGroupRequest.cc b/slb/src/model/MoveResourceGroupRequest.cc new file mode 100644 index 000000000..373e5141e --- /dev/null +++ b/slb/src/model/MoveResourceGroupRequest.cc @@ -0,0 +1,160 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +MoveResourceGroupRequest::MoveResourceGroupRequest() : + SlbRequest("MoveResourceGroup") +{} + +MoveResourceGroupRequest::~MoveResourceGroupRequest() +{} + +std::string MoveResourceGroupRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void MoveResourceGroupRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long MoveResourceGroupRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void MoveResourceGroupRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string MoveResourceGroupRequest::getResourceId()const +{ + return resourceId_; +} + +void MoveResourceGroupRequest::setResourceId(const std::string& resourceId) +{ + resourceId_ = resourceId; + setParameter("ResourceId", resourceId); +} + +std::string MoveResourceGroupRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void MoveResourceGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string MoveResourceGroupRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void MoveResourceGroupRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long MoveResourceGroupRequest::getOwnerId()const +{ + return ownerId_; +} + +void MoveResourceGroupRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string MoveResourceGroupRequest::getResourceType()const +{ + return resourceType_; +} + +void MoveResourceGroupRequest::setResourceType(const std::string& resourceType) +{ + resourceType_ = resourceType; + setParameter("ResourceType", resourceType); +} + +std::string MoveResourceGroupRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void MoveResourceGroupRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string MoveResourceGroupRequest::getTags()const +{ + return tags_; +} + +void MoveResourceGroupRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + +std::string MoveResourceGroupRequest::getResourceGroupId()const +{ + return resourceGroupId_; +} + +void MoveResourceGroupRequest::setResourceGroupId(const std::string& resourceGroupId) +{ + resourceGroupId_ = resourceGroupId; + setParameter("ResourceGroupId", resourceGroupId); +} + +std::string MoveResourceGroupRequest::getNewResourceGroupId()const +{ + return newResourceGroupId_; +} + +void MoveResourceGroupRequest::setNewResourceGroupId(const std::string& newResourceGroupId) +{ + newResourceGroupId_ = newResourceGroupId; + setParameter("NewResourceGroupId", newResourceGroupId); +} + +std::string MoveResourceGroupRequest::getRegionId()const +{ + return regionId_; +} + +void MoveResourceGroupRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + diff --git a/slb/src/model/MoveResourceGroupResult.cc b/slb/src/model/MoveResourceGroupResult.cc new file mode 100644 index 000000000..8b78d901d --- /dev/null +++ b/slb/src/model/MoveResourceGroupResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +MoveResourceGroupResult::MoveResourceGroupResult() : + ServiceResult() +{} + +MoveResourceGroupResult::MoveResourceGroupResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +MoveResourceGroupResult::~MoveResourceGroupResult() +{} + +void MoveResourceGroupResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/RemoveBackendServersRequest.cc b/slb/src/model/RemoveBackendServersRequest.cc new file mode 100644 index 000000000..35f7f4296 --- /dev/null +++ b/slb/src/model/RemoveBackendServersRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +RemoveBackendServersRequest::RemoveBackendServersRequest() : + SlbRequest("RemoveBackendServers") +{} + +RemoveBackendServersRequest::~RemoveBackendServersRequest() +{} + +std::string RemoveBackendServersRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void RemoveBackendServersRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long RemoveBackendServersRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void RemoveBackendServersRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string RemoveBackendServersRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void RemoveBackendServersRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string RemoveBackendServersRequest::getRegionId()const +{ + return regionId_; +} + +void RemoveBackendServersRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string RemoveBackendServersRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void RemoveBackendServersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string RemoveBackendServersRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void RemoveBackendServersRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long RemoveBackendServersRequest::getOwnerId()const +{ + return ownerId_; +} + +void RemoveBackendServersRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string RemoveBackendServersRequest::getBackendServers()const +{ + return backendServers_; +} + +void RemoveBackendServersRequest::setBackendServers(const std::string& backendServers) +{ + backendServers_ = backendServers; + setParameter("BackendServers", backendServers); +} + +std::string RemoveBackendServersRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void RemoveBackendServersRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string RemoveBackendServersRequest::getTags()const +{ + return tags_; +} + +void RemoveBackendServersRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/RemoveBackendServersResult.cc b/slb/src/model/RemoveBackendServersResult.cc new file mode 100644 index 000000000..edacf2d7e --- /dev/null +++ b/slb/src/model/RemoveBackendServersResult.cc @@ -0,0 +1,64 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +RemoveBackendServersResult::RemoveBackendServersResult() : + ServiceResult() +{} + +RemoveBackendServersResult::RemoveBackendServersResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +RemoveBackendServersResult::~RemoveBackendServersResult() +{} + +void RemoveBackendServersResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allBackendServers = value["BackendServers"]["BackendServer"]; + for (auto value : allBackendServers) + { + BackendServer backendServerObject; + backendServerObject.serverId = value["ServerId"].asString(); + backendServerObject.weight = std::stoi(value["Weight"].asString()); + backendServers_.push_back(backendServerObject); + } + loadBalancerId_ = value["LoadBalancerId"].asString(); + +} + +std::string RemoveBackendServersResult::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void RemoveBackendServersResult::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; +} + diff --git a/slb/src/model/RemoveListenerWhiteListItemRequest.cc b/slb/src/model/RemoveListenerWhiteListItemRequest.cc new file mode 100644 index 000000000..02b2263b5 --- /dev/null +++ b/slb/src/model/RemoveListenerWhiteListItemRequest.cc @@ -0,0 +1,149 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +RemoveListenerWhiteListItemRequest::RemoveListenerWhiteListItemRequest() : + SlbRequest("RemoveListenerWhiteListItem") +{} + +RemoveListenerWhiteListItemRequest::~RemoveListenerWhiteListItemRequest() +{} + +std::string RemoveListenerWhiteListItemRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void RemoveListenerWhiteListItemRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long RemoveListenerWhiteListItemRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void RemoveListenerWhiteListItemRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +int RemoveListenerWhiteListItemRequest::getListenerPort()const +{ + return listenerPort_; +} + +void RemoveListenerWhiteListItemRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string RemoveListenerWhiteListItemRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void RemoveListenerWhiteListItemRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string RemoveListenerWhiteListItemRequest::getSourceItems()const +{ + return sourceItems_; +} + +void RemoveListenerWhiteListItemRequest::setSourceItems(const std::string& sourceItems) +{ + sourceItems_ = sourceItems; + setParameter("SourceItems", sourceItems); +} + +std::string RemoveListenerWhiteListItemRequest::getRegionId()const +{ + return regionId_; +} + +void RemoveListenerWhiteListItemRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string RemoveListenerWhiteListItemRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void RemoveListenerWhiteListItemRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string RemoveListenerWhiteListItemRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void RemoveListenerWhiteListItemRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long RemoveListenerWhiteListItemRequest::getOwnerId()const +{ + return ownerId_; +} + +void RemoveListenerWhiteListItemRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string RemoveListenerWhiteListItemRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void RemoveListenerWhiteListItemRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string RemoveListenerWhiteListItemRequest::getTags()const +{ + return tags_; +} + +void RemoveListenerWhiteListItemRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/RemoveListenerWhiteListItemResult.cc b/slb/src/model/RemoveListenerWhiteListItemResult.cc new file mode 100644 index 000000000..b8a46f60e --- /dev/null +++ b/slb/src/model/RemoveListenerWhiteListItemResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +RemoveListenerWhiteListItemResult::RemoveListenerWhiteListItemResult() : + ServiceResult() +{} + +RemoveListenerWhiteListItemResult::RemoveListenerWhiteListItemResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +RemoveListenerWhiteListItemResult::~RemoveListenerWhiteListItemResult() +{} + +void RemoveListenerWhiteListItemResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/RemoveTagsRequest.cc b/slb/src/model/RemoveTagsRequest.cc new file mode 100644 index 000000000..aa80efbcb --- /dev/null +++ b/slb/src/model/RemoveTagsRequest.cc @@ -0,0 +1,127 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +RemoveTagsRequest::RemoveTagsRequest() : + SlbRequest("RemoveTags") +{} + +RemoveTagsRequest::~RemoveTagsRequest() +{} + +std::string RemoveTagsRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void RemoveTagsRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long RemoveTagsRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void RemoveTagsRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string RemoveTagsRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void RemoveTagsRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string RemoveTagsRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void RemoveTagsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string RemoveTagsRequest::getRegionId()const +{ + return regionId_; +} + +void RemoveTagsRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string RemoveTagsRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void RemoveTagsRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long RemoveTagsRequest::getOwnerId()const +{ + return ownerId_; +} + +void RemoveTagsRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string RemoveTagsRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void RemoveTagsRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string RemoveTagsRequest::getTags()const +{ + return tags_; +} + +void RemoveTagsRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/RemoveTagsResult.cc b/slb/src/model/RemoveTagsResult.cc new file mode 100644 index 000000000..80a38e701 --- /dev/null +++ b/slb/src/model/RemoveTagsResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +RemoveTagsResult::RemoveTagsResult() : + ServiceResult() +{} + +RemoveTagsResult::RemoveTagsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +RemoveTagsResult::~RemoveTagsResult() +{} + +void RemoveTagsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/RemoveVServerGroupBackendServersRequest.cc b/slb/src/model/RemoveVServerGroupBackendServersRequest.cc new file mode 100644 index 000000000..5cb32382a --- /dev/null +++ b/slb/src/model/RemoveVServerGroupBackendServersRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +RemoveVServerGroupBackendServersRequest::RemoveVServerGroupBackendServersRequest() : + SlbRequest("RemoveVServerGroupBackendServers") +{} + +RemoveVServerGroupBackendServersRequest::~RemoveVServerGroupBackendServersRequest() +{} + +std::string RemoveVServerGroupBackendServersRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void RemoveVServerGroupBackendServersRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +std::string RemoveVServerGroupBackendServersRequest::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void RemoveVServerGroupBackendServersRequest::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; + setParameter("VServerGroupId", vServerGroupId); +} + +long RemoveVServerGroupBackendServersRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void RemoveVServerGroupBackendServersRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string RemoveVServerGroupBackendServersRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void RemoveVServerGroupBackendServersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string RemoveVServerGroupBackendServersRequest::getRegionId()const +{ + return regionId_; +} + +void RemoveVServerGroupBackendServersRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string RemoveVServerGroupBackendServersRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void RemoveVServerGroupBackendServersRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long RemoveVServerGroupBackendServersRequest::getOwnerId()const +{ + return ownerId_; +} + +void RemoveVServerGroupBackendServersRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string RemoveVServerGroupBackendServersRequest::getBackendServers()const +{ + return backendServers_; +} + +void RemoveVServerGroupBackendServersRequest::setBackendServers(const std::string& backendServers) +{ + backendServers_ = backendServers; + setParameter("BackendServers", backendServers); +} + +std::string RemoveVServerGroupBackendServersRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void RemoveVServerGroupBackendServersRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string RemoveVServerGroupBackendServersRequest::getTags()const +{ + return tags_; +} + +void RemoveVServerGroupBackendServersRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/RemoveVServerGroupBackendServersResult.cc b/slb/src/model/RemoveVServerGroupBackendServersResult.cc new file mode 100644 index 000000000..0096f52e1 --- /dev/null +++ b/slb/src/model/RemoveVServerGroupBackendServersResult.cc @@ -0,0 +1,65 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +RemoveVServerGroupBackendServersResult::RemoveVServerGroupBackendServersResult() : + ServiceResult() +{} + +RemoveVServerGroupBackendServersResult::RemoveVServerGroupBackendServersResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +RemoveVServerGroupBackendServersResult::~RemoveVServerGroupBackendServersResult() +{} + +void RemoveVServerGroupBackendServersResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allBackendServers = value["BackendServers"]["BackendServer"]; + for (auto value : allBackendServers) + { + BackendServer backendServerObject; + backendServerObject.serverId = value["ServerId"].asString(); + backendServerObject.port = std::stoi(value["Port"].asString()); + backendServerObject.weight = std::stoi(value["Weight"].asString()); + backendServers_.push_back(backendServerObject); + } + vServerGroupId_ = value["VServerGroupId"].asString(); + +} + +std::string RemoveVServerGroupBackendServersResult::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void RemoveVServerGroupBackendServersResult::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; +} + diff --git a/slb/src/model/SetBackendServersRequest.cc b/slb/src/model/SetBackendServersRequest.cc new file mode 100644 index 000000000..9040b4745 --- /dev/null +++ b/slb/src/model/SetBackendServersRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetBackendServersRequest::SetBackendServersRequest() : + SlbRequest("SetBackendServers") +{} + +SetBackendServersRequest::~SetBackendServersRequest() +{} + +std::string SetBackendServersRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void SetBackendServersRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long SetBackendServersRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void SetBackendServersRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string SetBackendServersRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void SetBackendServersRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string SetBackendServersRequest::getRegionId()const +{ + return regionId_; +} + +void SetBackendServersRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string SetBackendServersRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void SetBackendServersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string SetBackendServersRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void SetBackendServersRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long SetBackendServersRequest::getOwnerId()const +{ + return ownerId_; +} + +void SetBackendServersRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string SetBackendServersRequest::getBackendServers()const +{ + return backendServers_; +} + +void SetBackendServersRequest::setBackendServers(const std::string& backendServers) +{ + backendServers_ = backendServers; + setParameter("BackendServers", backendServers); +} + +std::string SetBackendServersRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void SetBackendServersRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string SetBackendServersRequest::getTags()const +{ + return tags_; +} + +void SetBackendServersRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/SetBackendServersResult.cc b/slb/src/model/SetBackendServersResult.cc new file mode 100644 index 000000000..6bedf94ab --- /dev/null +++ b/slb/src/model/SetBackendServersResult.cc @@ -0,0 +1,64 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetBackendServersResult::SetBackendServersResult() : + ServiceResult() +{} + +SetBackendServersResult::SetBackendServersResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +SetBackendServersResult::~SetBackendServersResult() +{} + +void SetBackendServersResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allBackendServers = value["BackendServers"]["BackendServer"]; + for (auto value : allBackendServers) + { + BackendServer backendServerObject; + backendServerObject.serverId = value["ServerId"].asString(); + backendServerObject.weight = value["Weight"].asString(); + backendServers_.push_back(backendServerObject); + } + loadBalancerId_ = value["LoadBalancerId"].asString(); + +} + +std::string SetBackendServersResult::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void SetBackendServersResult::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; +} + diff --git a/slb/src/model/SetCACertificateNameRequest.cc b/slb/src/model/SetCACertificateNameRequest.cc new file mode 100644 index 000000000..787a36f9e --- /dev/null +++ b/slb/src/model/SetCACertificateNameRequest.cc @@ -0,0 +1,127 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetCACertificateNameRequest::SetCACertificateNameRequest() : + SlbRequest("SetCACertificateName") +{} + +SetCACertificateNameRequest::~SetCACertificateNameRequest() +{} + +std::string SetCACertificateNameRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void SetCACertificateNameRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long SetCACertificateNameRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void SetCACertificateNameRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string SetCACertificateNameRequest::getCACertificateName()const +{ + return cACertificateName_; +} + +void SetCACertificateNameRequest::setCACertificateName(const std::string& cACertificateName) +{ + cACertificateName_ = cACertificateName; + setParameter("CACertificateName", cACertificateName); +} + +std::string SetCACertificateNameRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void SetCACertificateNameRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string SetCACertificateNameRequest::getRegionId()const +{ + return regionId_; +} + +void SetCACertificateNameRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string SetCACertificateNameRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void SetCACertificateNameRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long SetCACertificateNameRequest::getOwnerId()const +{ + return ownerId_; +} + +void SetCACertificateNameRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string SetCACertificateNameRequest::getCACertificateId()const +{ + return cACertificateId_; +} + +void SetCACertificateNameRequest::setCACertificateId(const std::string& cACertificateId) +{ + cACertificateId_ = cACertificateId; + setParameter("CACertificateId", cACertificateId); +} + +std::string SetCACertificateNameRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void SetCACertificateNameRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + diff --git a/slb/src/model/SetCACertificateNameResult.cc b/slb/src/model/SetCACertificateNameResult.cc new file mode 100644 index 000000000..b478ec895 --- /dev/null +++ b/slb/src/model/SetCACertificateNameResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetCACertificateNameResult::SetCACertificateNameResult() : + ServiceResult() +{} + +SetCACertificateNameResult::SetCACertificateNameResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +SetCACertificateNameResult::~SetCACertificateNameResult() +{} + +void SetCACertificateNameResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/SetListenerAccessControlStatusRequest.cc b/slb/src/model/SetListenerAccessControlStatusRequest.cc new file mode 100644 index 000000000..ac1c51a31 --- /dev/null +++ b/slb/src/model/SetListenerAccessControlStatusRequest.cc @@ -0,0 +1,149 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetListenerAccessControlStatusRequest::SetListenerAccessControlStatusRequest() : + SlbRequest("SetListenerAccessControlStatus") +{} + +SetListenerAccessControlStatusRequest::~SetListenerAccessControlStatusRequest() +{} + +std::string SetListenerAccessControlStatusRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void SetListenerAccessControlStatusRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long SetListenerAccessControlStatusRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void SetListenerAccessControlStatusRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +int SetListenerAccessControlStatusRequest::getListenerPort()const +{ + return listenerPort_; +} + +void SetListenerAccessControlStatusRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string SetListenerAccessControlStatusRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void SetListenerAccessControlStatusRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string SetListenerAccessControlStatusRequest::getRegionId()const +{ + return regionId_; +} + +void SetListenerAccessControlStatusRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string SetListenerAccessControlStatusRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void SetListenerAccessControlStatusRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string SetListenerAccessControlStatusRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void SetListenerAccessControlStatusRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +std::string SetListenerAccessControlStatusRequest::getAccessControlStatus()const +{ + return accessControlStatus_; +} + +void SetListenerAccessControlStatusRequest::setAccessControlStatus(const std::string& accessControlStatus) +{ + accessControlStatus_ = accessControlStatus; + setParameter("AccessControlStatus", accessControlStatus); +} + +long SetListenerAccessControlStatusRequest::getOwnerId()const +{ + return ownerId_; +} + +void SetListenerAccessControlStatusRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string SetListenerAccessControlStatusRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void SetListenerAccessControlStatusRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string SetListenerAccessControlStatusRequest::getTags()const +{ + return tags_; +} + +void SetListenerAccessControlStatusRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/SetListenerAccessControlStatusResult.cc b/slb/src/model/SetListenerAccessControlStatusResult.cc new file mode 100644 index 000000000..56662bb7d --- /dev/null +++ b/slb/src/model/SetListenerAccessControlStatusResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetListenerAccessControlStatusResult::SetListenerAccessControlStatusResult() : + ServiceResult() +{} + +SetListenerAccessControlStatusResult::SetListenerAccessControlStatusResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +SetListenerAccessControlStatusResult::~SetListenerAccessControlStatusResult() +{} + +void SetListenerAccessControlStatusResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/SetLoadBalancerAutoReleaseTimeRequest.cc b/slb/src/model/SetLoadBalancerAutoReleaseTimeRequest.cc new file mode 100644 index 000000000..e409c3079 --- /dev/null +++ b/slb/src/model/SetLoadBalancerAutoReleaseTimeRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetLoadBalancerAutoReleaseTimeRequest::SetLoadBalancerAutoReleaseTimeRequest() : + SlbRequest("SetLoadBalancerAutoReleaseTime") +{} + +SetLoadBalancerAutoReleaseTimeRequest::~SetLoadBalancerAutoReleaseTimeRequest() +{} + +std::string SetLoadBalancerAutoReleaseTimeRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void SetLoadBalancerAutoReleaseTimeRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long SetLoadBalancerAutoReleaseTimeRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void SetLoadBalancerAutoReleaseTimeRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string SetLoadBalancerAutoReleaseTimeRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void SetLoadBalancerAutoReleaseTimeRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string SetLoadBalancerAutoReleaseTimeRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void SetLoadBalancerAutoReleaseTimeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string SetLoadBalancerAutoReleaseTimeRequest::getRegionId()const +{ + return regionId_; +} + +void SetLoadBalancerAutoReleaseTimeRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string SetLoadBalancerAutoReleaseTimeRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void SetLoadBalancerAutoReleaseTimeRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long SetLoadBalancerAutoReleaseTimeRequest::getAutoReleaseTime()const +{ + return autoReleaseTime_; +} + +void SetLoadBalancerAutoReleaseTimeRequest::setAutoReleaseTime(long autoReleaseTime) +{ + autoReleaseTime_ = autoReleaseTime; + setParameter("AutoReleaseTime", std::to_string(autoReleaseTime)); +} + +long SetLoadBalancerAutoReleaseTimeRequest::getOwnerId()const +{ + return ownerId_; +} + +void SetLoadBalancerAutoReleaseTimeRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string SetLoadBalancerAutoReleaseTimeRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void SetLoadBalancerAutoReleaseTimeRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string SetLoadBalancerAutoReleaseTimeRequest::getTags()const +{ + return tags_; +} + +void SetLoadBalancerAutoReleaseTimeRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/SetLoadBalancerAutoReleaseTimeResult.cc b/slb/src/model/SetLoadBalancerAutoReleaseTimeResult.cc new file mode 100644 index 000000000..fbbd7cda9 --- /dev/null +++ b/slb/src/model/SetLoadBalancerAutoReleaseTimeResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetLoadBalancerAutoReleaseTimeResult::SetLoadBalancerAutoReleaseTimeResult() : + ServiceResult() +{} + +SetLoadBalancerAutoReleaseTimeResult::SetLoadBalancerAutoReleaseTimeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +SetLoadBalancerAutoReleaseTimeResult::~SetLoadBalancerAutoReleaseTimeResult() +{} + +void SetLoadBalancerAutoReleaseTimeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/SetLoadBalancerHTTPListenerAttributeRequest.cc b/slb/src/model/SetLoadBalancerHTTPListenerAttributeRequest.cc new file mode 100644 index 000000000..25ecf3b76 --- /dev/null +++ b/slb/src/model/SetLoadBalancerHTTPListenerAttributeRequest.cc @@ -0,0 +1,391 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetLoadBalancerHTTPListenerAttributeRequest::SetLoadBalancerHTTPListenerAttributeRequest() : + SlbRequest("SetLoadBalancerHTTPListenerAttribute") +{} + +SetLoadBalancerHTTPListenerAttributeRequest::~SetLoadBalancerHTTPListenerAttributeRequest() +{} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long SetLoadBalancerHTTPListenerAttributeRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +int SetLoadBalancerHTTPListenerAttributeRequest::getHealthCheckTimeout()const +{ + return healthCheckTimeout_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setHealthCheckTimeout(int healthCheckTimeout) +{ + healthCheckTimeout_ = healthCheckTimeout; + setParameter("HealthCheckTimeout", std::to_string(healthCheckTimeout)); +} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getXForwardedFor()const +{ + return xForwardedFor_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setXForwardedFor(const std::string& xForwardedFor) +{ + xForwardedFor_ = xForwardedFor; + setParameter("XForwardedFor", xForwardedFor); +} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getHealthCheckURI()const +{ + return healthCheckURI_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setHealthCheckURI(const std::string& healthCheckURI) +{ + healthCheckURI_ = healthCheckURI; + setParameter("HealthCheckURI", healthCheckURI); +} + +int SetLoadBalancerHTTPListenerAttributeRequest::getUnhealthyThreshold()const +{ + return unhealthyThreshold_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setUnhealthyThreshold(int unhealthyThreshold) +{ + unhealthyThreshold_ = unhealthyThreshold; + setParameter("UnhealthyThreshold", std::to_string(unhealthyThreshold)); +} + +int SetLoadBalancerHTTPListenerAttributeRequest::getHealthyThreshold()const +{ + return healthyThreshold_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setHealthyThreshold(int healthyThreshold) +{ + healthyThreshold_ = healthyThreshold; + setParameter("HealthyThreshold", std::to_string(healthyThreshold)); +} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getScheduler()const +{ + return scheduler_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setScheduler(const std::string& scheduler) +{ + scheduler_ = scheduler; + setParameter("Scheduler", scheduler); +} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getHealthCheck()const +{ + return healthCheck_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setHealthCheck(const std::string& healthCheck) +{ + healthCheck_ = healthCheck; + setParameter("HealthCheck", healthCheck); +} + +int SetLoadBalancerHTTPListenerAttributeRequest::getMaxConnection()const +{ + return maxConnection_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setMaxConnection(int maxConnection) +{ + maxConnection_ = maxConnection; + setParameter("MaxConnection", std::to_string(maxConnection)); +} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getRegionId()const +{ + return regionId_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +int SetLoadBalancerHTTPListenerAttributeRequest::getCookieTimeout()const +{ + return cookieTimeout_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setCookieTimeout(int cookieTimeout) +{ + cookieTimeout_ = cookieTimeout; + setParameter("CookieTimeout", std::to_string(cookieTimeout)); +} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getStickySessionType()const +{ + return stickySessionType_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setStickySessionType(const std::string& stickySessionType) +{ + stickySessionType_ = stickySessionType; + setParameter("StickySessionType", stickySessionType); +} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; + setParameter("VServerGroupId", vServerGroupId); +} + +int SetLoadBalancerHTTPListenerAttributeRequest::getListenerPort()const +{ + return listenerPort_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getCookie()const +{ + return cookie_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setCookie(const std::string& cookie) +{ + cookie_ = cookie; + setParameter("Cookie", cookie); +} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +int SetLoadBalancerHTTPListenerAttributeRequest::getBandwidth()const +{ + return bandwidth_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setBandwidth(int bandwidth) +{ + bandwidth_ = bandwidth; + setParameter("Bandwidth", std::to_string(bandwidth)); +} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getStickySession()const +{ + return stickySession_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setStickySession(const std::string& stickySession) +{ + stickySession_ = stickySession; + setParameter("StickySession", stickySession); +} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getHealthCheckDomain()const +{ + return healthCheckDomain_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setHealthCheckDomain(const std::string& healthCheckDomain) +{ + healthCheckDomain_ = healthCheckDomain; + setParameter("HealthCheckDomain", healthCheckDomain); +} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getGzip()const +{ + return gzip_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setGzip(const std::string& gzip) +{ + gzip_ = gzip; + setParameter("Gzip", gzip); +} + +long SetLoadBalancerHTTPListenerAttributeRequest::getOwnerId()const +{ + return ownerId_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getTags()const +{ + return tags_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getXForwardedFor_SLBIP()const +{ + return xForwardedFor_SLBIP_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setXForwardedFor_SLBIP(const std::string& xForwardedFor_SLBIP) +{ + xForwardedFor_SLBIP_ = xForwardedFor_SLBIP; + setParameter("XForwardedFor_SLBIP", xForwardedFor_SLBIP); +} + +int SetLoadBalancerHTTPListenerAttributeRequest::getHealthCheckInterval()const +{ + return healthCheckInterval_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setHealthCheckInterval(int healthCheckInterval) +{ + healthCheckInterval_ = healthCheckInterval; + setParameter("HealthCheckInterval", std::to_string(healthCheckInterval)); +} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getXForwardedFor_proto()const +{ + return xForwardedFor_proto_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setXForwardedFor_proto(const std::string& xForwardedFor_proto) +{ + xForwardedFor_proto_ = xForwardedFor_proto; + setParameter("XForwardedFor_proto", xForwardedFor_proto); +} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getXForwardedFor_SLBID()const +{ + return xForwardedFor_SLBID_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setXForwardedFor_SLBID(const std::string& xForwardedFor_SLBID) +{ + xForwardedFor_SLBID_ = xForwardedFor_SLBID; + setParameter("XForwardedFor_SLBID", xForwardedFor_SLBID); +} + +int SetLoadBalancerHTTPListenerAttributeRequest::getHealthCheckConnectPort()const +{ + return healthCheckConnectPort_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setHealthCheckConnectPort(int healthCheckConnectPort) +{ + healthCheckConnectPort_ = healthCheckConnectPort; + setParameter("HealthCheckConnectPort", std::to_string(healthCheckConnectPort)); +} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getHealthCheckHttpCode()const +{ + return healthCheckHttpCode_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setHealthCheckHttpCode(const std::string& healthCheckHttpCode) +{ + healthCheckHttpCode_ = healthCheckHttpCode; + setParameter("HealthCheckHttpCode", healthCheckHttpCode); +} + +std::string SetLoadBalancerHTTPListenerAttributeRequest::getVServerGroup()const +{ + return vServerGroup_; +} + +void SetLoadBalancerHTTPListenerAttributeRequest::setVServerGroup(const std::string& vServerGroup) +{ + vServerGroup_ = vServerGroup; + setParameter("VServerGroup", vServerGroup); +} + diff --git a/slb/src/model/SetLoadBalancerHTTPListenerAttributeResult.cc b/slb/src/model/SetLoadBalancerHTTPListenerAttributeResult.cc new file mode 100644 index 000000000..fe8cffd89 --- /dev/null +++ b/slb/src/model/SetLoadBalancerHTTPListenerAttributeResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetLoadBalancerHTTPListenerAttributeResult::SetLoadBalancerHTTPListenerAttributeResult() : + ServiceResult() +{} + +SetLoadBalancerHTTPListenerAttributeResult::SetLoadBalancerHTTPListenerAttributeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +SetLoadBalancerHTTPListenerAttributeResult::~SetLoadBalancerHTTPListenerAttributeResult() +{} + +void SetLoadBalancerHTTPListenerAttributeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/SetLoadBalancerHTTPSListenerAttributeRequest.cc b/slb/src/model/SetLoadBalancerHTTPSListenerAttributeRequest.cc new file mode 100644 index 000000000..e3292e134 --- /dev/null +++ b/slb/src/model/SetLoadBalancerHTTPSListenerAttributeRequest.cc @@ -0,0 +1,413 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetLoadBalancerHTTPSListenerAttributeRequest::SetLoadBalancerHTTPSListenerAttributeRequest() : + SlbRequest("SetLoadBalancerHTTPSListenerAttribute") +{} + +SetLoadBalancerHTTPSListenerAttributeRequest::~SetLoadBalancerHTTPSListenerAttributeRequest() +{} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long SetLoadBalancerHTTPSListenerAttributeRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +int SetLoadBalancerHTTPSListenerAttributeRequest::getHealthCheckTimeout()const +{ + return healthCheckTimeout_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setHealthCheckTimeout(int healthCheckTimeout) +{ + healthCheckTimeout_ = healthCheckTimeout; + setParameter("HealthCheckTimeout", std::to_string(healthCheckTimeout)); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getXForwardedFor()const +{ + return xForwardedFor_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setXForwardedFor(const std::string& xForwardedFor) +{ + xForwardedFor_ = xForwardedFor; + setParameter("XForwardedFor", xForwardedFor); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getHealthCheckURI()const +{ + return healthCheckURI_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setHealthCheckURI(const std::string& healthCheckURI) +{ + healthCheckURI_ = healthCheckURI; + setParameter("HealthCheckURI", healthCheckURI); +} + +int SetLoadBalancerHTTPSListenerAttributeRequest::getUnhealthyThreshold()const +{ + return unhealthyThreshold_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setUnhealthyThreshold(int unhealthyThreshold) +{ + unhealthyThreshold_ = unhealthyThreshold; + setParameter("UnhealthyThreshold", std::to_string(unhealthyThreshold)); +} + +int SetLoadBalancerHTTPSListenerAttributeRequest::getHealthyThreshold()const +{ + return healthyThreshold_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setHealthyThreshold(int healthyThreshold) +{ + healthyThreshold_ = healthyThreshold; + setParameter("HealthyThreshold", std::to_string(healthyThreshold)); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getScheduler()const +{ + return scheduler_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setScheduler(const std::string& scheduler) +{ + scheduler_ = scheduler; + setParameter("Scheduler", scheduler); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getHealthCheck()const +{ + return healthCheck_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setHealthCheck(const std::string& healthCheck) +{ + healthCheck_ = healthCheck; + setParameter("HealthCheck", healthCheck); +} + +int SetLoadBalancerHTTPSListenerAttributeRequest::getMaxConnection()const +{ + return maxConnection_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setMaxConnection(int maxConnection) +{ + maxConnection_ = maxConnection; + setParameter("MaxConnection", std::to_string(maxConnection)); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getRegionId()const +{ + return regionId_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +int SetLoadBalancerHTTPSListenerAttributeRequest::getCookieTimeout()const +{ + return cookieTimeout_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setCookieTimeout(int cookieTimeout) +{ + cookieTimeout_ = cookieTimeout; + setParameter("CookieTimeout", std::to_string(cookieTimeout)); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getStickySessionType()const +{ + return stickySessionType_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setStickySessionType(const std::string& stickySessionType) +{ + stickySessionType_ = stickySessionType; + setParameter("StickySessionType", stickySessionType); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; + setParameter("VServerGroupId", vServerGroupId); +} + +int SetLoadBalancerHTTPSListenerAttributeRequest::getListenerPort()const +{ + return listenerPort_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getCookie()const +{ + return cookie_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setCookie(const std::string& cookie) +{ + cookie_ = cookie; + setParameter("Cookie", cookie); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +int SetLoadBalancerHTTPSListenerAttributeRequest::getBandwidth()const +{ + return bandwidth_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setBandwidth(int bandwidth) +{ + bandwidth_ = bandwidth; + setParameter("Bandwidth", std::to_string(bandwidth)); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getStickySession()const +{ + return stickySession_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setStickySession(const std::string& stickySession) +{ + stickySession_ = stickySession; + setParameter("StickySession", stickySession); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getHealthCheckDomain()const +{ + return healthCheckDomain_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setHealthCheckDomain(const std::string& healthCheckDomain) +{ + healthCheckDomain_ = healthCheckDomain; + setParameter("HealthCheckDomain", healthCheckDomain); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getGzip()const +{ + return gzip_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setGzip(const std::string& gzip) +{ + gzip_ = gzip; + setParameter("Gzip", gzip); +} + +long SetLoadBalancerHTTPSListenerAttributeRequest::getOwnerId()const +{ + return ownerId_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getServerCertificateId()const +{ + return serverCertificateId_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setServerCertificateId(const std::string& serverCertificateId) +{ + serverCertificateId_ = serverCertificateId; + setParameter("ServerCertificateId", serverCertificateId); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getCACertificateId()const +{ + return cACertificateId_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setCACertificateId(const std::string& cACertificateId) +{ + cACertificateId_ = cACertificateId; + setParameter("CACertificateId", cACertificateId); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getTags()const +{ + return tags_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getXForwardedFor_SLBIP()const +{ + return xForwardedFor_SLBIP_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setXForwardedFor_SLBIP(const std::string& xForwardedFor_SLBIP) +{ + xForwardedFor_SLBIP_ = xForwardedFor_SLBIP; + setParameter("XForwardedFor_SLBIP", xForwardedFor_SLBIP); +} + +int SetLoadBalancerHTTPSListenerAttributeRequest::getHealthCheckInterval()const +{ + return healthCheckInterval_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setHealthCheckInterval(int healthCheckInterval) +{ + healthCheckInterval_ = healthCheckInterval; + setParameter("HealthCheckInterval", std::to_string(healthCheckInterval)); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getXForwardedFor_proto()const +{ + return xForwardedFor_proto_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setXForwardedFor_proto(const std::string& xForwardedFor_proto) +{ + xForwardedFor_proto_ = xForwardedFor_proto; + setParameter("XForwardedFor_proto", xForwardedFor_proto); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getXForwardedFor_SLBID()const +{ + return xForwardedFor_SLBID_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setXForwardedFor_SLBID(const std::string& xForwardedFor_SLBID) +{ + xForwardedFor_SLBID_ = xForwardedFor_SLBID; + setParameter("XForwardedFor_SLBID", xForwardedFor_SLBID); +} + +int SetLoadBalancerHTTPSListenerAttributeRequest::getHealthCheckConnectPort()const +{ + return healthCheckConnectPort_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setHealthCheckConnectPort(int healthCheckConnectPort) +{ + healthCheckConnectPort_ = healthCheckConnectPort; + setParameter("HealthCheckConnectPort", std::to_string(healthCheckConnectPort)); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getHealthCheckHttpCode()const +{ + return healthCheckHttpCode_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setHealthCheckHttpCode(const std::string& healthCheckHttpCode) +{ + healthCheckHttpCode_ = healthCheckHttpCode; + setParameter("HealthCheckHttpCode", healthCheckHttpCode); +} + +std::string SetLoadBalancerHTTPSListenerAttributeRequest::getVServerGroup()const +{ + return vServerGroup_; +} + +void SetLoadBalancerHTTPSListenerAttributeRequest::setVServerGroup(const std::string& vServerGroup) +{ + vServerGroup_ = vServerGroup; + setParameter("VServerGroup", vServerGroup); +} + diff --git a/slb/src/model/SetLoadBalancerHTTPSListenerAttributeResult.cc b/slb/src/model/SetLoadBalancerHTTPSListenerAttributeResult.cc new file mode 100644 index 000000000..d6a020017 --- /dev/null +++ b/slb/src/model/SetLoadBalancerHTTPSListenerAttributeResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetLoadBalancerHTTPSListenerAttributeResult::SetLoadBalancerHTTPSListenerAttributeResult() : + ServiceResult() +{} + +SetLoadBalancerHTTPSListenerAttributeResult::SetLoadBalancerHTTPSListenerAttributeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +SetLoadBalancerHTTPSListenerAttributeResult::~SetLoadBalancerHTTPSListenerAttributeResult() +{} + +void SetLoadBalancerHTTPSListenerAttributeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/SetLoadBalancerNameRequest.cc b/slb/src/model/SetLoadBalancerNameRequest.cc new file mode 100644 index 000000000..f168f8c68 --- /dev/null +++ b/slb/src/model/SetLoadBalancerNameRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetLoadBalancerNameRequest::SetLoadBalancerNameRequest() : + SlbRequest("SetLoadBalancerName") +{} + +SetLoadBalancerNameRequest::~SetLoadBalancerNameRequest() +{} + +std::string SetLoadBalancerNameRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void SetLoadBalancerNameRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long SetLoadBalancerNameRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void SetLoadBalancerNameRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string SetLoadBalancerNameRequest::getLoadBalancerName()const +{ + return loadBalancerName_; +} + +void SetLoadBalancerNameRequest::setLoadBalancerName(const std::string& loadBalancerName) +{ + loadBalancerName_ = loadBalancerName; + setParameter("LoadBalancerName", loadBalancerName); +} + +std::string SetLoadBalancerNameRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void SetLoadBalancerNameRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string SetLoadBalancerNameRequest::getRegionId()const +{ + return regionId_; +} + +void SetLoadBalancerNameRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string SetLoadBalancerNameRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void SetLoadBalancerNameRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string SetLoadBalancerNameRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void SetLoadBalancerNameRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long SetLoadBalancerNameRequest::getOwnerId()const +{ + return ownerId_; +} + +void SetLoadBalancerNameRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string SetLoadBalancerNameRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void SetLoadBalancerNameRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string SetLoadBalancerNameRequest::getTags()const +{ + return tags_; +} + +void SetLoadBalancerNameRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/SetLoadBalancerNameResult.cc b/slb/src/model/SetLoadBalancerNameResult.cc new file mode 100644 index 000000000..242e79cca --- /dev/null +++ b/slb/src/model/SetLoadBalancerNameResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetLoadBalancerNameResult::SetLoadBalancerNameResult() : + ServiceResult() +{} + +SetLoadBalancerNameResult::SetLoadBalancerNameResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +SetLoadBalancerNameResult::~SetLoadBalancerNameResult() +{} + +void SetLoadBalancerNameResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/SetLoadBalancerStatusRequest.cc b/slb/src/model/SetLoadBalancerStatusRequest.cc new file mode 100644 index 000000000..656acaefd --- /dev/null +++ b/slb/src/model/SetLoadBalancerStatusRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetLoadBalancerStatusRequest::SetLoadBalancerStatusRequest() : + SlbRequest("SetLoadBalancerStatus") +{} + +SetLoadBalancerStatusRequest::~SetLoadBalancerStatusRequest() +{} + +std::string SetLoadBalancerStatusRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void SetLoadBalancerStatusRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long SetLoadBalancerStatusRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void SetLoadBalancerStatusRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string SetLoadBalancerStatusRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void SetLoadBalancerStatusRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string SetLoadBalancerStatusRequest::getRegionId()const +{ + return regionId_; +} + +void SetLoadBalancerStatusRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string SetLoadBalancerStatusRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void SetLoadBalancerStatusRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string SetLoadBalancerStatusRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void SetLoadBalancerStatusRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long SetLoadBalancerStatusRequest::getOwnerId()const +{ + return ownerId_; +} + +void SetLoadBalancerStatusRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string SetLoadBalancerStatusRequest::getLoadBalancerStatus()const +{ + return loadBalancerStatus_; +} + +void SetLoadBalancerStatusRequest::setLoadBalancerStatus(const std::string& loadBalancerStatus) +{ + loadBalancerStatus_ = loadBalancerStatus; + setParameter("LoadBalancerStatus", loadBalancerStatus); +} + +std::string SetLoadBalancerStatusRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void SetLoadBalancerStatusRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string SetLoadBalancerStatusRequest::getTags()const +{ + return tags_; +} + +void SetLoadBalancerStatusRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/SetLoadBalancerStatusResult.cc b/slb/src/model/SetLoadBalancerStatusResult.cc new file mode 100644 index 000000000..83a6f5bfd --- /dev/null +++ b/slb/src/model/SetLoadBalancerStatusResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetLoadBalancerStatusResult::SetLoadBalancerStatusResult() : + ServiceResult() +{} + +SetLoadBalancerStatusResult::SetLoadBalancerStatusResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +SetLoadBalancerStatusResult::~SetLoadBalancerStatusResult() +{} + +void SetLoadBalancerStatusResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/SetLoadBalancerTCPListenerAttributeRequest.cc b/slb/src/model/SetLoadBalancerTCPListenerAttributeRequest.cc new file mode 100644 index 000000000..f95122ade --- /dev/null +++ b/slb/src/model/SetLoadBalancerTCPListenerAttributeRequest.cc @@ -0,0 +1,347 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetLoadBalancerTCPListenerAttributeRequest::SetLoadBalancerTCPListenerAttributeRequest() : + SlbRequest("SetLoadBalancerTCPListenerAttribute") +{} + +SetLoadBalancerTCPListenerAttributeRequest::~SetLoadBalancerTCPListenerAttributeRequest() +{} + +std::string SetLoadBalancerTCPListenerAttributeRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +int SetLoadBalancerTCPListenerAttributeRequest::getHealthCheckConnectTimeout()const +{ + return healthCheckConnectTimeout_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setHealthCheckConnectTimeout(int healthCheckConnectTimeout) +{ + healthCheckConnectTimeout_ = healthCheckConnectTimeout; + setParameter("HealthCheckConnectTimeout", std::to_string(healthCheckConnectTimeout)); +} + +long SetLoadBalancerTCPListenerAttributeRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string SetLoadBalancerTCPListenerAttributeRequest::getHealthCheckURI()const +{ + return healthCheckURI_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setHealthCheckURI(const std::string& healthCheckURI) +{ + healthCheckURI_ = healthCheckURI; + setParameter("HealthCheckURI", healthCheckURI); +} + +int SetLoadBalancerTCPListenerAttributeRequest::getUnhealthyThreshold()const +{ + return unhealthyThreshold_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setUnhealthyThreshold(int unhealthyThreshold) +{ + unhealthyThreshold_ = unhealthyThreshold; + setParameter("UnhealthyThreshold", std::to_string(unhealthyThreshold)); +} + +int SetLoadBalancerTCPListenerAttributeRequest::getHealthyThreshold()const +{ + return healthyThreshold_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setHealthyThreshold(int healthyThreshold) +{ + healthyThreshold_ = healthyThreshold; + setParameter("HealthyThreshold", std::to_string(healthyThreshold)); +} + +std::string SetLoadBalancerTCPListenerAttributeRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string SetLoadBalancerTCPListenerAttributeRequest::getScheduler()const +{ + return scheduler_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setScheduler(const std::string& scheduler) +{ + scheduler_ = scheduler; + setParameter("Scheduler", scheduler); +} + +std::string SetLoadBalancerTCPListenerAttributeRequest::getMasterSlaveServerGroup()const +{ + return masterSlaveServerGroup_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setMasterSlaveServerGroup(const std::string& masterSlaveServerGroup) +{ + masterSlaveServerGroup_ = masterSlaveServerGroup; + setParameter("MasterSlaveServerGroup", masterSlaveServerGroup); +} + +int SetLoadBalancerTCPListenerAttributeRequest::getEstablishedTimeout()const +{ + return establishedTimeout_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setEstablishedTimeout(int establishedTimeout) +{ + establishedTimeout_ = establishedTimeout; + setParameter("EstablishedTimeout", std::to_string(establishedTimeout)); +} + +int SetLoadBalancerTCPListenerAttributeRequest::getMaxConnection()const +{ + return maxConnection_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setMaxConnection(int maxConnection) +{ + maxConnection_ = maxConnection; + setParameter("MaxConnection", std::to_string(maxConnection)); +} + +std::string SetLoadBalancerTCPListenerAttributeRequest::getRegionId()const +{ + return regionId_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +int SetLoadBalancerTCPListenerAttributeRequest::getPersistenceTimeout()const +{ + return persistenceTimeout_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setPersistenceTimeout(int persistenceTimeout) +{ + persistenceTimeout_ = persistenceTimeout; + setParameter("PersistenceTimeout", std::to_string(persistenceTimeout)); +} + +std::string SetLoadBalancerTCPListenerAttributeRequest::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; + setParameter("VServerGroupId", vServerGroupId); +} + +int SetLoadBalancerTCPListenerAttributeRequest::getListenerPort()const +{ + return listenerPort_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string SetLoadBalancerTCPListenerAttributeRequest::getHealthCheckType()const +{ + return healthCheckType_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setHealthCheckType(const std::string& healthCheckType) +{ + healthCheckType_ = healthCheckType; + setParameter("HealthCheckType", healthCheckType); +} + +std::string SetLoadBalancerTCPListenerAttributeRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +int SetLoadBalancerTCPListenerAttributeRequest::getBandwidth()const +{ + return bandwidth_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setBandwidth(int bandwidth) +{ + bandwidth_ = bandwidth; + setParameter("Bandwidth", std::to_string(bandwidth)); +} + +std::string SetLoadBalancerTCPListenerAttributeRequest::getHealthCheckDomain()const +{ + return healthCheckDomain_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setHealthCheckDomain(const std::string& healthCheckDomain) +{ + healthCheckDomain_ = healthCheckDomain; + setParameter("HealthCheckDomain", healthCheckDomain); +} + +std::string SetLoadBalancerTCPListenerAttributeRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +std::string SetLoadBalancerTCPListenerAttributeRequest::getSynProxy()const +{ + return synProxy_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setSynProxy(const std::string& synProxy) +{ + synProxy_ = synProxy; + setParameter("SynProxy", synProxy); +} + +long SetLoadBalancerTCPListenerAttributeRequest::getOwnerId()const +{ + return ownerId_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string SetLoadBalancerTCPListenerAttributeRequest::getTags()const +{ + return tags_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + +std::string SetLoadBalancerTCPListenerAttributeRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string SetLoadBalancerTCPListenerAttributeRequest::getMasterSlaveServerGroupId()const +{ + return masterSlaveServerGroupId_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId) +{ + masterSlaveServerGroupId_ = masterSlaveServerGroupId; + setParameter("MasterSlaveServerGroupId", masterSlaveServerGroupId); +} + +int SetLoadBalancerTCPListenerAttributeRequest::getHealthCheckInterval()const +{ + return healthCheckInterval_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setHealthCheckInterval(int healthCheckInterval) +{ + healthCheckInterval_ = healthCheckInterval; + setParameter("HealthCheckInterval", std::to_string(healthCheckInterval)); +} + +int SetLoadBalancerTCPListenerAttributeRequest::getHealthCheckConnectPort()const +{ + return healthCheckConnectPort_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setHealthCheckConnectPort(int healthCheckConnectPort) +{ + healthCheckConnectPort_ = healthCheckConnectPort; + setParameter("HealthCheckConnectPort", std::to_string(healthCheckConnectPort)); +} + +std::string SetLoadBalancerTCPListenerAttributeRequest::getHealthCheckHttpCode()const +{ + return healthCheckHttpCode_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setHealthCheckHttpCode(const std::string& healthCheckHttpCode) +{ + healthCheckHttpCode_ = healthCheckHttpCode; + setParameter("HealthCheckHttpCode", healthCheckHttpCode); +} + +std::string SetLoadBalancerTCPListenerAttributeRequest::getVServerGroup()const +{ + return vServerGroup_; +} + +void SetLoadBalancerTCPListenerAttributeRequest::setVServerGroup(const std::string& vServerGroup) +{ + vServerGroup_ = vServerGroup; + setParameter("VServerGroup", vServerGroup); +} + diff --git a/slb/src/model/SetLoadBalancerTCPListenerAttributeResult.cc b/slb/src/model/SetLoadBalancerTCPListenerAttributeResult.cc new file mode 100644 index 000000000..1385e9bae --- /dev/null +++ b/slb/src/model/SetLoadBalancerTCPListenerAttributeResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetLoadBalancerTCPListenerAttributeResult::SetLoadBalancerTCPListenerAttributeResult() : + ServiceResult() +{} + +SetLoadBalancerTCPListenerAttributeResult::SetLoadBalancerTCPListenerAttributeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +SetLoadBalancerTCPListenerAttributeResult::~SetLoadBalancerTCPListenerAttributeResult() +{} + +void SetLoadBalancerTCPListenerAttributeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/SetLoadBalancerUDPListenerAttributeRequest.cc b/slb/src/model/SetLoadBalancerUDPListenerAttributeRequest.cc new file mode 100644 index 000000000..f17806931 --- /dev/null +++ b/slb/src/model/SetLoadBalancerUDPListenerAttributeRequest.cc @@ -0,0 +1,303 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetLoadBalancerUDPListenerAttributeRequest::SetLoadBalancerUDPListenerAttributeRequest() : + SlbRequest("SetLoadBalancerUDPListenerAttribute") +{} + +SetLoadBalancerUDPListenerAttributeRequest::~SetLoadBalancerUDPListenerAttributeRequest() +{} + +std::string SetLoadBalancerUDPListenerAttributeRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +int SetLoadBalancerUDPListenerAttributeRequest::getHealthCheckConnectTimeout()const +{ + return healthCheckConnectTimeout_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setHealthCheckConnectTimeout(int healthCheckConnectTimeout) +{ + healthCheckConnectTimeout_ = healthCheckConnectTimeout; + setParameter("HealthCheckConnectTimeout", std::to_string(healthCheckConnectTimeout)); +} + +long SetLoadBalancerUDPListenerAttributeRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +int SetLoadBalancerUDPListenerAttributeRequest::getUnhealthyThreshold()const +{ + return unhealthyThreshold_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setUnhealthyThreshold(int unhealthyThreshold) +{ + unhealthyThreshold_ = unhealthyThreshold; + setParameter("UnhealthyThreshold", std::to_string(unhealthyThreshold)); +} + +int SetLoadBalancerUDPListenerAttributeRequest::getHealthyThreshold()const +{ + return healthyThreshold_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setHealthyThreshold(int healthyThreshold) +{ + healthyThreshold_ = healthyThreshold; + setParameter("HealthyThreshold", std::to_string(healthyThreshold)); +} + +std::string SetLoadBalancerUDPListenerAttributeRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string SetLoadBalancerUDPListenerAttributeRequest::getScheduler()const +{ + return scheduler_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setScheduler(const std::string& scheduler) +{ + scheduler_ = scheduler; + setParameter("Scheduler", scheduler); +} + +std::string SetLoadBalancerUDPListenerAttributeRequest::getMasterSlaveServerGroup()const +{ + return masterSlaveServerGroup_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setMasterSlaveServerGroup(const std::string& masterSlaveServerGroup) +{ + masterSlaveServerGroup_ = masterSlaveServerGroup; + setParameter("MasterSlaveServerGroup", masterSlaveServerGroup); +} + +int SetLoadBalancerUDPListenerAttributeRequest::getMaxConnection()const +{ + return maxConnection_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setMaxConnection(int maxConnection) +{ + maxConnection_ = maxConnection; + setParameter("MaxConnection", std::to_string(maxConnection)); +} + +std::string SetLoadBalancerUDPListenerAttributeRequest::getRegionId()const +{ + return regionId_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +int SetLoadBalancerUDPListenerAttributeRequest::getPersistenceTimeout()const +{ + return persistenceTimeout_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setPersistenceTimeout(int persistenceTimeout) +{ + persistenceTimeout_ = persistenceTimeout; + setParameter("PersistenceTimeout", std::to_string(persistenceTimeout)); +} + +std::string SetLoadBalancerUDPListenerAttributeRequest::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; + setParameter("VServerGroupId", vServerGroupId); +} + +int SetLoadBalancerUDPListenerAttributeRequest::getListenerPort()const +{ + return listenerPort_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string SetLoadBalancerUDPListenerAttributeRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +int SetLoadBalancerUDPListenerAttributeRequest::getBandwidth()const +{ + return bandwidth_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setBandwidth(int bandwidth) +{ + bandwidth_ = bandwidth; + setParameter("Bandwidth", std::to_string(bandwidth)); +} + +std::string SetLoadBalancerUDPListenerAttributeRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long SetLoadBalancerUDPListenerAttributeRequest::getOwnerId()const +{ + return ownerId_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string SetLoadBalancerUDPListenerAttributeRequest::getTags()const +{ + return tags_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + +std::string SetLoadBalancerUDPListenerAttributeRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string SetLoadBalancerUDPListenerAttributeRequest::getMasterSlaveServerGroupId()const +{ + return masterSlaveServerGroupId_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId) +{ + masterSlaveServerGroupId_ = masterSlaveServerGroupId; + setParameter("MasterSlaveServerGroupId", masterSlaveServerGroupId); +} + +std::string SetLoadBalancerUDPListenerAttributeRequest::getHealthCheckReq()const +{ + return healthCheckReq_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setHealthCheckReq(const std::string& healthCheckReq) +{ + healthCheckReq_ = healthCheckReq; + setParameter("HealthCheckReq", healthCheckReq); +} + +int SetLoadBalancerUDPListenerAttributeRequest::getHealthCheckInterval()const +{ + return healthCheckInterval_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setHealthCheckInterval(int healthCheckInterval) +{ + healthCheckInterval_ = healthCheckInterval; + setParameter("HealthCheckInterval", std::to_string(healthCheckInterval)); +} + +std::string SetLoadBalancerUDPListenerAttributeRequest::getHealthCheckExp()const +{ + return healthCheckExp_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setHealthCheckExp(const std::string& healthCheckExp) +{ + healthCheckExp_ = healthCheckExp; + setParameter("HealthCheckExp", healthCheckExp); +} + +int SetLoadBalancerUDPListenerAttributeRequest::getHealthCheckConnectPort()const +{ + return healthCheckConnectPort_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setHealthCheckConnectPort(int healthCheckConnectPort) +{ + healthCheckConnectPort_ = healthCheckConnectPort; + setParameter("HealthCheckConnectPort", std::to_string(healthCheckConnectPort)); +} + +std::string SetLoadBalancerUDPListenerAttributeRequest::getVServerGroup()const +{ + return vServerGroup_; +} + +void SetLoadBalancerUDPListenerAttributeRequest::setVServerGroup(const std::string& vServerGroup) +{ + vServerGroup_ = vServerGroup; + setParameter("VServerGroup", vServerGroup); +} + diff --git a/slb/src/model/SetLoadBalancerUDPListenerAttributeResult.cc b/slb/src/model/SetLoadBalancerUDPListenerAttributeResult.cc new file mode 100644 index 000000000..d5920e3a0 --- /dev/null +++ b/slb/src/model/SetLoadBalancerUDPListenerAttributeResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetLoadBalancerUDPListenerAttributeResult::SetLoadBalancerUDPListenerAttributeResult() : + ServiceResult() +{} + +SetLoadBalancerUDPListenerAttributeResult::SetLoadBalancerUDPListenerAttributeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +SetLoadBalancerUDPListenerAttributeResult::~SetLoadBalancerUDPListenerAttributeResult() +{} + +void SetLoadBalancerUDPListenerAttributeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/SetRuleRequest.cc b/slb/src/model/SetRuleRequest.cc new file mode 100644 index 000000000..d363c3065 --- /dev/null +++ b/slb/src/model/SetRuleRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetRuleRequest::SetRuleRequest() : + SlbRequest("SetRule") +{} + +SetRuleRequest::~SetRuleRequest() +{} + +std::string SetRuleRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void SetRuleRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +std::string SetRuleRequest::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void SetRuleRequest::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; + setParameter("VServerGroupId", vServerGroupId); +} + +long SetRuleRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void SetRuleRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string SetRuleRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void SetRuleRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string SetRuleRequest::getRegionId()const +{ + return regionId_; +} + +void SetRuleRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string SetRuleRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void SetRuleRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long SetRuleRequest::getOwnerId()const +{ + return ownerId_; +} + +void SetRuleRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string SetRuleRequest::getRuleId()const +{ + return ruleId_; +} + +void SetRuleRequest::setRuleId(const std::string& ruleId) +{ + ruleId_ = ruleId; + setParameter("RuleId", ruleId); +} + +std::string SetRuleRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void SetRuleRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string SetRuleRequest::getTags()const +{ + return tags_; +} + +void SetRuleRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/SetRuleResult.cc b/slb/src/model/SetRuleResult.cc new file mode 100644 index 000000000..187bcef40 --- /dev/null +++ b/slb/src/model/SetRuleResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetRuleResult::SetRuleResult() : + ServiceResult() +{} + +SetRuleResult::SetRuleResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +SetRuleResult::~SetRuleResult() +{} + +void SetRuleResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/SetServerCertificateNameRequest.cc b/slb/src/model/SetServerCertificateNameRequest.cc new file mode 100644 index 000000000..ca26a4030 --- /dev/null +++ b/slb/src/model/SetServerCertificateNameRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetServerCertificateNameRequest::SetServerCertificateNameRequest() : + SlbRequest("SetServerCertificateName") +{} + +SetServerCertificateNameRequest::~SetServerCertificateNameRequest() +{} + +std::string SetServerCertificateNameRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void SetServerCertificateNameRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long SetServerCertificateNameRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void SetServerCertificateNameRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string SetServerCertificateNameRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void SetServerCertificateNameRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string SetServerCertificateNameRequest::getRegionId()const +{ + return regionId_; +} + +void SetServerCertificateNameRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string SetServerCertificateNameRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void SetServerCertificateNameRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long SetServerCertificateNameRequest::getOwnerId()const +{ + return ownerId_; +} + +void SetServerCertificateNameRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string SetServerCertificateNameRequest::getServerCertificateId()const +{ + return serverCertificateId_; +} + +void SetServerCertificateNameRequest::setServerCertificateId(const std::string& serverCertificateId) +{ + serverCertificateId_ = serverCertificateId; + setParameter("ServerCertificateId", serverCertificateId); +} + +std::string SetServerCertificateNameRequest::getServerCertificateName()const +{ + return serverCertificateName_; +} + +void SetServerCertificateNameRequest::setServerCertificateName(const std::string& serverCertificateName) +{ + serverCertificateName_ = serverCertificateName; + setParameter("ServerCertificateName", serverCertificateName); +} + +std::string SetServerCertificateNameRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void SetServerCertificateNameRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string SetServerCertificateNameRequest::getTags()const +{ + return tags_; +} + +void SetServerCertificateNameRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/SetServerCertificateNameResult.cc b/slb/src/model/SetServerCertificateNameResult.cc new file mode 100644 index 000000000..5564ff787 --- /dev/null +++ b/slb/src/model/SetServerCertificateNameResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetServerCertificateNameResult::SetServerCertificateNameResult() : + ServiceResult() +{} + +SetServerCertificateNameResult::SetServerCertificateNameResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +SetServerCertificateNameResult::~SetServerCertificateNameResult() +{} + +void SetServerCertificateNameResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/SetVServerGroupAttributeRequest.cc b/slb/src/model/SetVServerGroupAttributeRequest.cc new file mode 100644 index 000000000..590129a53 --- /dev/null +++ b/slb/src/model/SetVServerGroupAttributeRequest.cc @@ -0,0 +1,149 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetVServerGroupAttributeRequest::SetVServerGroupAttributeRequest() : + SlbRequest("SetVServerGroupAttribute") +{} + +SetVServerGroupAttributeRequest::~SetVServerGroupAttributeRequest() +{} + +std::string SetVServerGroupAttributeRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void SetVServerGroupAttributeRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +std::string SetVServerGroupAttributeRequest::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void SetVServerGroupAttributeRequest::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; + setParameter("VServerGroupId", vServerGroupId); +} + +long SetVServerGroupAttributeRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void SetVServerGroupAttributeRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string SetVServerGroupAttributeRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void SetVServerGroupAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string SetVServerGroupAttributeRequest::getRegionId()const +{ + return regionId_; +} + +void SetVServerGroupAttributeRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string SetVServerGroupAttributeRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void SetVServerGroupAttributeRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long SetVServerGroupAttributeRequest::getOwnerId()const +{ + return ownerId_; +} + +void SetVServerGroupAttributeRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string SetVServerGroupAttributeRequest::getBackendServers()const +{ + return backendServers_; +} + +void SetVServerGroupAttributeRequest::setBackendServers(const std::string& backendServers) +{ + backendServers_ = backendServers; + setParameter("BackendServers", backendServers); +} + +std::string SetVServerGroupAttributeRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void SetVServerGroupAttributeRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string SetVServerGroupAttributeRequest::getTags()const +{ + return tags_; +} + +void SetVServerGroupAttributeRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + +std::string SetVServerGroupAttributeRequest::getVServerGroupName()const +{ + return vServerGroupName_; +} + +void SetVServerGroupAttributeRequest::setVServerGroupName(const std::string& vServerGroupName) +{ + vServerGroupName_ = vServerGroupName; + setParameter("VServerGroupName", vServerGroupName); +} + diff --git a/slb/src/model/SetVServerGroupAttributeResult.cc b/slb/src/model/SetVServerGroupAttributeResult.cc new file mode 100644 index 000000000..8c9407bac --- /dev/null +++ b/slb/src/model/SetVServerGroupAttributeResult.cc @@ -0,0 +1,76 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +SetVServerGroupAttributeResult::SetVServerGroupAttributeResult() : + ServiceResult() +{} + +SetVServerGroupAttributeResult::SetVServerGroupAttributeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +SetVServerGroupAttributeResult::~SetVServerGroupAttributeResult() +{} + +void SetVServerGroupAttributeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + auto allBackendServers = value["BackendServers"]["BackendServer"]; + for (auto value : allBackendServers) + { + BackendServer backendServerObject; + backendServerObject.serverId = value["ServerId"].asString(); + backendServerObject.port = std::stoi(value["Port"].asString()); + backendServerObject.weight = std::stoi(value["Weight"].asString()); + backendServers_.push_back(backendServerObject); + } + vServerGroupId_ = value["VServerGroupId"].asString(); + vServerGroupName_ = value["VServerGroupName"].asString(); + +} + +std::string SetVServerGroupAttributeResult::getVServerGroupId()const +{ + return vServerGroupId_; +} + +void SetVServerGroupAttributeResult::setVServerGroupId(const std::string& vServerGroupId) +{ + vServerGroupId_ = vServerGroupId; +} + +std::string SetVServerGroupAttributeResult::getVServerGroupName()const +{ + return vServerGroupName_; +} + +void SetVServerGroupAttributeResult::setVServerGroupName(const std::string& vServerGroupName) +{ + vServerGroupName_ = vServerGroupName; +} + diff --git a/slb/src/model/StartLoadBalancerListenerRequest.cc b/slb/src/model/StartLoadBalancerListenerRequest.cc new file mode 100644 index 000000000..c84d27619 --- /dev/null +++ b/slb/src/model/StartLoadBalancerListenerRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +StartLoadBalancerListenerRequest::StartLoadBalancerListenerRequest() : + SlbRequest("StartLoadBalancerListener") +{} + +StartLoadBalancerListenerRequest::~StartLoadBalancerListenerRequest() +{} + +std::string StartLoadBalancerListenerRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void StartLoadBalancerListenerRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long StartLoadBalancerListenerRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void StartLoadBalancerListenerRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +int StartLoadBalancerListenerRequest::getListenerPort()const +{ + return listenerPort_; +} + +void StartLoadBalancerListenerRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string StartLoadBalancerListenerRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void StartLoadBalancerListenerRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string StartLoadBalancerListenerRequest::getRegionId()const +{ + return regionId_; +} + +void StartLoadBalancerListenerRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string StartLoadBalancerListenerRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void StartLoadBalancerListenerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string StartLoadBalancerListenerRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void StartLoadBalancerListenerRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long StartLoadBalancerListenerRequest::getOwnerId()const +{ + return ownerId_; +} + +void StartLoadBalancerListenerRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string StartLoadBalancerListenerRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void StartLoadBalancerListenerRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string StartLoadBalancerListenerRequest::getTags()const +{ + return tags_; +} + +void StartLoadBalancerListenerRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/StartLoadBalancerListenerResult.cc b/slb/src/model/StartLoadBalancerListenerResult.cc new file mode 100644 index 000000000..b4ee825cd --- /dev/null +++ b/slb/src/model/StartLoadBalancerListenerResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +StartLoadBalancerListenerResult::StartLoadBalancerListenerResult() : + ServiceResult() +{} + +StartLoadBalancerListenerResult::StartLoadBalancerListenerResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +StartLoadBalancerListenerResult::~StartLoadBalancerListenerResult() +{} + +void StartLoadBalancerListenerResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/StopLoadBalancerListenerRequest.cc b/slb/src/model/StopLoadBalancerListenerRequest.cc new file mode 100644 index 000000000..d0b9a606f --- /dev/null +++ b/slb/src/model/StopLoadBalancerListenerRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +StopLoadBalancerListenerRequest::StopLoadBalancerListenerRequest() : + SlbRequest("StopLoadBalancerListener") +{} + +StopLoadBalancerListenerRequest::~StopLoadBalancerListenerRequest() +{} + +std::string StopLoadBalancerListenerRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void StopLoadBalancerListenerRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long StopLoadBalancerListenerRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void StopLoadBalancerListenerRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +int StopLoadBalancerListenerRequest::getListenerPort()const +{ + return listenerPort_; +} + +void StopLoadBalancerListenerRequest::setListenerPort(int listenerPort) +{ + listenerPort_ = listenerPort; + setParameter("ListenerPort", std::to_string(listenerPort)); +} + +std::string StopLoadBalancerListenerRequest::getLoadBalancerId()const +{ + return loadBalancerId_; +} + +void StopLoadBalancerListenerRequest::setLoadBalancerId(const std::string& loadBalancerId) +{ + loadBalancerId_ = loadBalancerId; + setParameter("LoadBalancerId", loadBalancerId); +} + +std::string StopLoadBalancerListenerRequest::getRegionId()const +{ + return regionId_; +} + +void StopLoadBalancerListenerRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string StopLoadBalancerListenerRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void StopLoadBalancerListenerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string StopLoadBalancerListenerRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void StopLoadBalancerListenerRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long StopLoadBalancerListenerRequest::getOwnerId()const +{ + return ownerId_; +} + +void StopLoadBalancerListenerRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string StopLoadBalancerListenerRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void StopLoadBalancerListenerRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string StopLoadBalancerListenerRequest::getTags()const +{ + return tags_; +} + +void StopLoadBalancerListenerRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + diff --git a/slb/src/model/StopLoadBalancerListenerResult.cc b/slb/src/model/StopLoadBalancerListenerResult.cc new file mode 100644 index 000000000..e15a25037 --- /dev/null +++ b/slb/src/model/StopLoadBalancerListenerResult.cc @@ -0,0 +1,45 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +StopLoadBalancerListenerResult::StopLoadBalancerListenerResult() : + ServiceResult() +{} + +StopLoadBalancerListenerResult::StopLoadBalancerListenerResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +StopLoadBalancerListenerResult::~StopLoadBalancerListenerResult() +{} + +void StopLoadBalancerListenerResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + +} + diff --git a/slb/src/model/UploadCACertificateRequest.cc b/slb/src/model/UploadCACertificateRequest.cc new file mode 100644 index 000000000..32a3b7281 --- /dev/null +++ b/slb/src/model/UploadCACertificateRequest.cc @@ -0,0 +1,138 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +UploadCACertificateRequest::UploadCACertificateRequest() : + SlbRequest("UploadCACertificate") +{} + +UploadCACertificateRequest::~UploadCACertificateRequest() +{} + +std::string UploadCACertificateRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void UploadCACertificateRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +std::string UploadCACertificateRequest::getResourceGroupId()const +{ + return resourceGroupId_; +} + +void UploadCACertificateRequest::setResourceGroupId(const std::string& resourceGroupId) +{ + resourceGroupId_ = resourceGroupId; + setParameter("ResourceGroupId", resourceGroupId); +} + +long UploadCACertificateRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void UploadCACertificateRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string UploadCACertificateRequest::getCACertificate()const +{ + return cACertificate_; +} + +void UploadCACertificateRequest::setCACertificate(const std::string& cACertificate) +{ + cACertificate_ = cACertificate; + setParameter("CACertificate", cACertificate); +} + +std::string UploadCACertificateRequest::getCACertificateName()const +{ + return cACertificateName_; +} + +void UploadCACertificateRequest::setCACertificateName(const std::string& cACertificateName) +{ + cACertificateName_ = cACertificateName; + setParameter("CACertificateName", cACertificateName); +} + +std::string UploadCACertificateRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void UploadCACertificateRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string UploadCACertificateRequest::getRegionId()const +{ + return regionId_; +} + +void UploadCACertificateRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string UploadCACertificateRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void UploadCACertificateRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +long UploadCACertificateRequest::getOwnerId()const +{ + return ownerId_; +} + +void UploadCACertificateRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string UploadCACertificateRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void UploadCACertificateRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + diff --git a/slb/src/model/UploadCACertificateResult.cc b/slb/src/model/UploadCACertificateResult.cc new file mode 100644 index 000000000..b279062c3 --- /dev/null +++ b/slb/src/model/UploadCACertificateResult.cc @@ -0,0 +1,111 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +UploadCACertificateResult::UploadCACertificateResult() : + ServiceResult() +{} + +UploadCACertificateResult::UploadCACertificateResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UploadCACertificateResult::~UploadCACertificateResult() +{} + +void UploadCACertificateResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + cACertificateId_ = value["CACertificateId"].asString(); + cACertificateName_ = value["CACertificateName"].asString(); + fingerprint_ = value["Fingerprint"].asString(); + resourceGroupId_ = value["ResourceGroupId"].asString(); + createTime_ = value["CreateTime"].asString(); + createTimeStamp_ = std::stol(value["CreateTimeStamp"].asString()); + +} + +std::string UploadCACertificateResult::getFingerprint()const +{ + return fingerprint_; +} + +void UploadCACertificateResult::setFingerprint(const std::string& fingerprint) +{ + fingerprint_ = fingerprint; +} + +std::string UploadCACertificateResult::getResourceGroupId()const +{ + return resourceGroupId_; +} + +void UploadCACertificateResult::setResourceGroupId(const std::string& resourceGroupId) +{ + resourceGroupId_ = resourceGroupId; +} + +std::string UploadCACertificateResult::getCACertificateId()const +{ + return cACertificateId_; +} + +void UploadCACertificateResult::setCACertificateId(const std::string& cACertificateId) +{ + cACertificateId_ = cACertificateId; +} + +std::string UploadCACertificateResult::getCreateTime()const +{ + return createTime_; +} + +void UploadCACertificateResult::setCreateTime(const std::string& createTime) +{ + createTime_ = createTime; +} + +std::string UploadCACertificateResult::getCACertificateName()const +{ + return cACertificateName_; +} + +void UploadCACertificateResult::setCACertificateName(const std::string& cACertificateName) +{ + cACertificateName_ = cACertificateName; +} + +long UploadCACertificateResult::getCreateTimeStamp()const +{ + return createTimeStamp_; +} + +void UploadCACertificateResult::setCreateTimeStamp(long createTimeStamp) +{ + createTimeStamp_ = createTimeStamp; +} + diff --git a/slb/src/model/UploadServerCertificateRequest.cc b/slb/src/model/UploadServerCertificateRequest.cc new file mode 100644 index 000000000..989a0f404 --- /dev/null +++ b/slb/src/model/UploadServerCertificateRequest.cc @@ -0,0 +1,182 @@ +/* + * 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 + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +UploadServerCertificateRequest::UploadServerCertificateRequest() : + SlbRequest("UploadServerCertificate") +{} + +UploadServerCertificateRequest::~UploadServerCertificateRequest() +{} + +std::string UploadServerCertificateRequest::getAccess_key_id()const +{ + return access_key_id_; +} + +void UploadServerCertificateRequest::setAccess_key_id(const std::string& access_key_id) +{ + access_key_id_ = access_key_id; + setParameter("Access_key_id", access_key_id); +} + +long UploadServerCertificateRequest::getResourceOwnerId()const +{ + return resourceOwnerId_; +} + +void UploadServerCertificateRequest::setResourceOwnerId(long resourceOwnerId) +{ + resourceOwnerId_ = resourceOwnerId; + setParameter("ResourceOwnerId", std::to_string(resourceOwnerId)); +} + +std::string UploadServerCertificateRequest::getServerCertificate()const +{ + return serverCertificate_; +} + +void UploadServerCertificateRequest::setServerCertificate(const std::string& serverCertificate) +{ + serverCertificate_ = serverCertificate; + setParameter("ServerCertificate", serverCertificate); +} + +std::string UploadServerCertificateRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void UploadServerCertificateRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string UploadServerCertificateRequest::getOwnerAccount()const +{ + return ownerAccount_; +} + +void UploadServerCertificateRequest::setOwnerAccount(const std::string& ownerAccount) +{ + ownerAccount_ = ownerAccount; + setParameter("OwnerAccount", ownerAccount); +} + +std::string UploadServerCertificateRequest::getAliCloudCertificateName()const +{ + return aliCloudCertificateName_; +} + +void UploadServerCertificateRequest::setAliCloudCertificateName(const std::string& aliCloudCertificateName) +{ + aliCloudCertificateName_ = aliCloudCertificateName; + setParameter("AliCloudCertificateName", aliCloudCertificateName); +} + +std::string UploadServerCertificateRequest::getAliCloudCertificateId()const +{ + return aliCloudCertificateId_; +} + +void UploadServerCertificateRequest::setAliCloudCertificateId(const std::string& aliCloudCertificateId) +{ + aliCloudCertificateId_ = aliCloudCertificateId; + setParameter("AliCloudCertificateId", aliCloudCertificateId); +} + +long UploadServerCertificateRequest::getOwnerId()const +{ + return ownerId_; +} + +void UploadServerCertificateRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setParameter("OwnerId", std::to_string(ownerId)); +} + +std::string UploadServerCertificateRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void UploadServerCertificateRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setParameter("AccessKeyId", accessKeyId); +} + +std::string UploadServerCertificateRequest::getTags()const +{ + return tags_; +} + +void UploadServerCertificateRequest::setTags(const std::string& tags) +{ + tags_ = tags; + setParameter("Tags", tags); +} + +std::string UploadServerCertificateRequest::getPrivateKey()const +{ + return privateKey_; +} + +void UploadServerCertificateRequest::setPrivateKey(const std::string& privateKey) +{ + privateKey_ = privateKey; + setParameter("PrivateKey", privateKey); +} + +std::string UploadServerCertificateRequest::getResourceGroupId()const +{ + return resourceGroupId_; +} + +void UploadServerCertificateRequest::setResourceGroupId(const std::string& resourceGroupId) +{ + resourceGroupId_ = resourceGroupId; + setParameter("ResourceGroupId", resourceGroupId); +} + +std::string UploadServerCertificateRequest::getRegionId()const +{ + return regionId_; +} + +void UploadServerCertificateRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setParameter("RegionId", regionId); +} + +std::string UploadServerCertificateRequest::getServerCertificateName()const +{ + return serverCertificateName_; +} + +void UploadServerCertificateRequest::setServerCertificateName(const std::string& serverCertificateName) +{ + serverCertificateName_ = serverCertificateName; + setParameter("ServerCertificateName", serverCertificateName); +} + diff --git a/slb/src/model/UploadServerCertificateResult.cc b/slb/src/model/UploadServerCertificateResult.cc new file mode 100644 index 000000000..b080b7238 --- /dev/null +++ b/slb/src/model/UploadServerCertificateResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Slb; +using namespace AlibabaCloud::Slb::Model; + +UploadServerCertificateResult::UploadServerCertificateResult() : + ServiceResult() +{} + +UploadServerCertificateResult::UploadServerCertificateResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UploadServerCertificateResult::~UploadServerCertificateResult() +{} + +void UploadServerCertificateResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + + setRequestId(value["RequestId"].asString()); + serverCertificateId_ = value["ServerCertificateId"].asString(); + fingerprint_ = value["Fingerprint"].asString(); + serverCertificateName_ = value["ServerCertificateName"].asString(); + regionId_ = value["RegionId"].asString(); + regionIdAlias_ = value["RegionIdAlias"].asString(); + aliCloudCertificateId_ = value["AliCloudCertificateId"].asString(); + aliCloudCertificateName_ = value["AliCloudCertificateName"].asString(); + isAliCloudCertificate_ = std::stoi(value["IsAliCloudCertificate"].asString()); + resourceGroupId_ = value["ResourceGroupId"].asString(); + createTime_ = value["CreateTime"].asString(); + createTimeStamp_ = std::stol(value["CreateTimeStamp"].asString()); + +} + +std::string UploadServerCertificateResult::getRegionIdAlias()const +{ + return regionIdAlias_; +} + +void UploadServerCertificateResult::setRegionIdAlias(const std::string& regionIdAlias) +{ + regionIdAlias_ = regionIdAlias; +} + +std::string UploadServerCertificateResult::getFingerprint()const +{ + return fingerprint_; +} + +void UploadServerCertificateResult::setFingerprint(const std::string& fingerprint) +{ + fingerprint_ = fingerprint; +} + +std::string UploadServerCertificateResult::getAliCloudCertificateName()const +{ + return aliCloudCertificateName_; +} + +void UploadServerCertificateResult::setAliCloudCertificateName(const std::string& aliCloudCertificateName) +{ + aliCloudCertificateName_ = aliCloudCertificateName; +} + +std::string UploadServerCertificateResult::getResourceGroupId()const +{ + return resourceGroupId_; +} + +void UploadServerCertificateResult::setResourceGroupId(const std::string& resourceGroupId) +{ + resourceGroupId_ = resourceGroupId; +} + +int UploadServerCertificateResult::getIsAliCloudCertificate()const +{ + return isAliCloudCertificate_; +} + +void UploadServerCertificateResult::setIsAliCloudCertificate(int isAliCloudCertificate) +{ + isAliCloudCertificate_ = isAliCloudCertificate; +} + +std::string UploadServerCertificateResult::getCreateTime()const +{ + return createTime_; +} + +void UploadServerCertificateResult::setCreateTime(const std::string& createTime) +{ + createTime_ = createTime; +} + +std::string UploadServerCertificateResult::getServerCertificateId()const +{ + return serverCertificateId_; +} + +void UploadServerCertificateResult::setServerCertificateId(const std::string& serverCertificateId) +{ + serverCertificateId_ = serverCertificateId; +} + +std::string UploadServerCertificateResult::getServerCertificateName()const +{ + return serverCertificateName_; +} + +void UploadServerCertificateResult::setServerCertificateName(const std::string& serverCertificateName) +{ + serverCertificateName_ = serverCertificateName; +} + +std::string UploadServerCertificateResult::getRegionId()const +{ + return regionId_; +} + +void UploadServerCertificateResult::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; +} + +long UploadServerCertificateResult::getCreateTimeStamp()const +{ + return createTimeStamp_; +} + +void UploadServerCertificateResult::setCreateTimeStamp(long createTimeStamp) +{ + createTimeStamp_ = createTimeStamp; +} + +std::string UploadServerCertificateResult::getAliCloudCertificateId()const +{ + return aliCloudCertificateId_; +} + +void UploadServerCertificateResult::setAliCloudCertificateId(const std::string& aliCloudCertificateId) +{ + aliCloudCertificateId_ = aliCloudCertificateId; +} +