From dabca8e080183d06c2755bb2ad5849fb128d3671 Mon Sep 17 00:00:00 2001 From: sdk-team Date: Tue, 3 Jan 2023 02:17:19 +0000 Subject: [PATCH] First publish. --- VERSION | 2 +- eflo/CMakeLists.txt | 142 +++++ eflo/include/alibabacloud/eflo/EfloClient.h | 166 +++++ eflo/include/alibabacloud/eflo/EfloExport.h | 32 + .../eflo/model/CreateSubnetRequest.h | 57 ++ .../eflo/model/CreateSubnetResult.h | 59 ++ .../eflo/model/CreateVccRequest.h | 66 ++ .../alibabacloud/eflo/model/CreateVccResult.h | 59 ++ .../eflo/model/CreateVpdRequest.h | 58 ++ .../alibabacloud/eflo/model/CreateVpdResult.h | 60 ++ .../eflo/model/DeleteSubnetRequest.h | 51 ++ .../eflo/model/DeleteSubnetResult.h | 49 ++ .../eflo/model/DeleteVpdRequest.h | 45 ++ .../alibabacloud/eflo/model/DeleteVpdResult.h | 49 ++ .../eflo/model/GetSubnetRequest.h | 42 ++ .../alibabacloud/eflo/model/GetSubnetResult.h | 82 +++ .../alibabacloud/eflo/model/GetVccRequest.h | 45 ++ .../alibabacloud/eflo/model/GetVccResult.h | 115 ++++ .../alibabacloud/eflo/model/GetVpdRequest.h | 42 ++ .../alibabacloud/eflo/model/GetVpdResult.h | 73 +++ .../eflo/model/InitializeVccRequest.h | 39 ++ .../eflo/model/InitializeVccResult.h | 60 ++ .../eflo/model/ListSubnetsRequest.h | 69 ++ .../eflo/model/ListSubnetsResult.h | 85 +++ .../alibabacloud/eflo/model/ListVccsRequest.h | 72 +++ .../alibabacloud/eflo/model/ListVccsResult.h | 89 +++ .../alibabacloud/eflo/model/ListVpdsRequest.h | 72 +++ .../alibabacloud/eflo/model/ListVpdsResult.h | 76 +++ .../eflo/model/UpdateSubnetRequest.h | 57 ++ .../eflo/model/UpdateSubnetResult.h | 59 ++ .../eflo/model/UpdateVccRequest.h | 54 ++ .../alibabacloud/eflo/model/UpdateVccResult.h | 59 ++ .../eflo/model/UpdateVpdRequest.h | 51 ++ .../alibabacloud/eflo/model/UpdateVpdResult.h | 59 ++ eflo/src/EfloClient.cc | 593 ++++++++++++++++++ eflo/src/model/CreateSubnetRequest.cc | 81 +++ eflo/src/model/CreateSubnetResult.cc | 66 ++ eflo/src/model/CreateVccRequest.cc | 108 ++++ eflo/src/model/CreateVccResult.cc | 66 ++ eflo/src/model/CreateVpdRequest.cc | 71 +++ eflo/src/model/CreateVpdResult.cc | 69 ++ eflo/src/model/DeleteSubnetRequest.cc | 63 ++ eflo/src/model/DeleteSubnetResult.cc | 44 ++ eflo/src/model/DeleteVpdRequest.cc | 45 ++ eflo/src/model/DeleteVpdResult.cc | 44 ++ eflo/src/model/GetSubnetRequest.cc | 36 ++ eflo/src/model/GetSubnetResult.cc | 105 ++++ eflo/src/model/GetVccRequest.cc | 45 ++ eflo/src/model/GetVccResult.cc | 165 +++++ eflo/src/model/GetVpdRequest.cc | 36 ++ eflo/src/model/GetVpdResult.cc | 94 +++ eflo/src/model/InitializeVccRequest.cc | 27 + eflo/src/model/InitializeVccResult.cc | 68 ++ eflo/src/model/ListSubnetsRequest.cc | 117 ++++ eflo/src/model/ListSubnetsResult.cc | 109 ++++ eflo/src/model/ListVccsRequest.cc | 126 ++++ eflo/src/model/ListVccsResult.cc | 117 ++++ eflo/src/model/ListVpdsRequest.cc | 126 ++++ eflo/src/model/ListVpdsResult.cc | 98 +++ eflo/src/model/UpdateSubnetRequest.cc | 81 +++ eflo/src/model/UpdateSubnetResult.cc | 66 ++ eflo/src/model/UpdateVccRequest.cc | 72 +++ eflo/src/model/UpdateVccResult.cc | 66 ++ eflo/src/model/UpdateVpdRequest.cc | 63 ++ eflo/src/model/UpdateVpdResult.cc | 66 ++ 65 files changed, 5127 insertions(+), 1 deletion(-) create mode 100644 eflo/CMakeLists.txt create mode 100644 eflo/include/alibabacloud/eflo/EfloClient.h create mode 100644 eflo/include/alibabacloud/eflo/EfloExport.h create mode 100644 eflo/include/alibabacloud/eflo/model/CreateSubnetRequest.h create mode 100644 eflo/include/alibabacloud/eflo/model/CreateSubnetResult.h create mode 100644 eflo/include/alibabacloud/eflo/model/CreateVccRequest.h create mode 100644 eflo/include/alibabacloud/eflo/model/CreateVccResult.h create mode 100644 eflo/include/alibabacloud/eflo/model/CreateVpdRequest.h create mode 100644 eflo/include/alibabacloud/eflo/model/CreateVpdResult.h create mode 100644 eflo/include/alibabacloud/eflo/model/DeleteSubnetRequest.h create mode 100644 eflo/include/alibabacloud/eflo/model/DeleteSubnetResult.h create mode 100644 eflo/include/alibabacloud/eflo/model/DeleteVpdRequest.h create mode 100644 eflo/include/alibabacloud/eflo/model/DeleteVpdResult.h create mode 100644 eflo/include/alibabacloud/eflo/model/GetSubnetRequest.h create mode 100644 eflo/include/alibabacloud/eflo/model/GetSubnetResult.h create mode 100644 eflo/include/alibabacloud/eflo/model/GetVccRequest.h create mode 100644 eflo/include/alibabacloud/eflo/model/GetVccResult.h create mode 100644 eflo/include/alibabacloud/eflo/model/GetVpdRequest.h create mode 100644 eflo/include/alibabacloud/eflo/model/GetVpdResult.h create mode 100644 eflo/include/alibabacloud/eflo/model/InitializeVccRequest.h create mode 100644 eflo/include/alibabacloud/eflo/model/InitializeVccResult.h create mode 100644 eflo/include/alibabacloud/eflo/model/ListSubnetsRequest.h create mode 100644 eflo/include/alibabacloud/eflo/model/ListSubnetsResult.h create mode 100644 eflo/include/alibabacloud/eflo/model/ListVccsRequest.h create mode 100644 eflo/include/alibabacloud/eflo/model/ListVccsResult.h create mode 100644 eflo/include/alibabacloud/eflo/model/ListVpdsRequest.h create mode 100644 eflo/include/alibabacloud/eflo/model/ListVpdsResult.h create mode 100644 eflo/include/alibabacloud/eflo/model/UpdateSubnetRequest.h create mode 100644 eflo/include/alibabacloud/eflo/model/UpdateSubnetResult.h create mode 100644 eflo/include/alibabacloud/eflo/model/UpdateVccRequest.h create mode 100644 eflo/include/alibabacloud/eflo/model/UpdateVccResult.h create mode 100644 eflo/include/alibabacloud/eflo/model/UpdateVpdRequest.h create mode 100644 eflo/include/alibabacloud/eflo/model/UpdateVpdResult.h create mode 100644 eflo/src/EfloClient.cc create mode 100644 eflo/src/model/CreateSubnetRequest.cc create mode 100644 eflo/src/model/CreateSubnetResult.cc create mode 100644 eflo/src/model/CreateVccRequest.cc create mode 100644 eflo/src/model/CreateVccResult.cc create mode 100644 eflo/src/model/CreateVpdRequest.cc create mode 100644 eflo/src/model/CreateVpdResult.cc create mode 100644 eflo/src/model/DeleteSubnetRequest.cc create mode 100644 eflo/src/model/DeleteSubnetResult.cc create mode 100644 eflo/src/model/DeleteVpdRequest.cc create mode 100644 eflo/src/model/DeleteVpdResult.cc create mode 100644 eflo/src/model/GetSubnetRequest.cc create mode 100644 eflo/src/model/GetSubnetResult.cc create mode 100644 eflo/src/model/GetVccRequest.cc create mode 100644 eflo/src/model/GetVccResult.cc create mode 100644 eflo/src/model/GetVpdRequest.cc create mode 100644 eflo/src/model/GetVpdResult.cc create mode 100644 eflo/src/model/InitializeVccRequest.cc create mode 100644 eflo/src/model/InitializeVccResult.cc create mode 100644 eflo/src/model/ListSubnetsRequest.cc create mode 100644 eflo/src/model/ListSubnetsResult.cc create mode 100644 eflo/src/model/ListVccsRequest.cc create mode 100644 eflo/src/model/ListVccsResult.cc create mode 100644 eflo/src/model/ListVpdsRequest.cc create mode 100644 eflo/src/model/ListVpdsResult.cc create mode 100644 eflo/src/model/UpdateSubnetRequest.cc create mode 100644 eflo/src/model/UpdateSubnetResult.cc create mode 100644 eflo/src/model/UpdateVccRequest.cc create mode 100644 eflo/src/model/UpdateVccResult.cc create mode 100644 eflo/src/model/UpdateVpdRequest.cc create mode 100644 eflo/src/model/UpdateVpdResult.cc diff --git a/VERSION b/VERSION index f09e81faf..5eadbcfd0 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.1406 \ No newline at end of file +1.36.1407 \ No newline at end of file diff --git a/eflo/CMakeLists.txt b/eflo/CMakeLists.txt new file mode 100644 index 000000000..346a050de --- /dev/null +++ b/eflo/CMakeLists.txt @@ -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. +# + +set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include) + +set(eflo_public_header + include/alibabacloud/eflo/EfloClient.h + include/alibabacloud/eflo/EfloExport.h ) + +set(eflo_public_header_model + include/alibabacloud/eflo/model/CreateSubnetRequest.h + include/alibabacloud/eflo/model/CreateSubnetResult.h + include/alibabacloud/eflo/model/CreateVccRequest.h + include/alibabacloud/eflo/model/CreateVccResult.h + include/alibabacloud/eflo/model/CreateVpdRequest.h + include/alibabacloud/eflo/model/CreateVpdResult.h + include/alibabacloud/eflo/model/DeleteSubnetRequest.h + include/alibabacloud/eflo/model/DeleteSubnetResult.h + include/alibabacloud/eflo/model/DeleteVpdRequest.h + include/alibabacloud/eflo/model/DeleteVpdResult.h + include/alibabacloud/eflo/model/GetSubnetRequest.h + include/alibabacloud/eflo/model/GetSubnetResult.h + include/alibabacloud/eflo/model/GetVccRequest.h + include/alibabacloud/eflo/model/GetVccResult.h + include/alibabacloud/eflo/model/GetVpdRequest.h + include/alibabacloud/eflo/model/GetVpdResult.h + include/alibabacloud/eflo/model/InitializeVccRequest.h + include/alibabacloud/eflo/model/InitializeVccResult.h + include/alibabacloud/eflo/model/ListSubnetsRequest.h + include/alibabacloud/eflo/model/ListSubnetsResult.h + include/alibabacloud/eflo/model/ListVccsRequest.h + include/alibabacloud/eflo/model/ListVccsResult.h + include/alibabacloud/eflo/model/ListVpdsRequest.h + include/alibabacloud/eflo/model/ListVpdsResult.h + include/alibabacloud/eflo/model/UpdateSubnetRequest.h + include/alibabacloud/eflo/model/UpdateSubnetResult.h + include/alibabacloud/eflo/model/UpdateVccRequest.h + include/alibabacloud/eflo/model/UpdateVccResult.h + include/alibabacloud/eflo/model/UpdateVpdRequest.h + include/alibabacloud/eflo/model/UpdateVpdResult.h ) + +set(eflo_src + src/EfloClient.cc + src/model/CreateSubnetRequest.cc + src/model/CreateSubnetResult.cc + src/model/CreateVccRequest.cc + src/model/CreateVccResult.cc + src/model/CreateVpdRequest.cc + src/model/CreateVpdResult.cc + src/model/DeleteSubnetRequest.cc + src/model/DeleteSubnetResult.cc + src/model/DeleteVpdRequest.cc + src/model/DeleteVpdResult.cc + src/model/GetSubnetRequest.cc + src/model/GetSubnetResult.cc + src/model/GetVccRequest.cc + src/model/GetVccResult.cc + src/model/GetVpdRequest.cc + src/model/GetVpdResult.cc + src/model/InitializeVccRequest.cc + src/model/InitializeVccResult.cc + src/model/ListSubnetsRequest.cc + src/model/ListSubnetsResult.cc + src/model/ListVccsRequest.cc + src/model/ListVccsResult.cc + src/model/ListVpdsRequest.cc + src/model/ListVpdsResult.cc + src/model/UpdateSubnetRequest.cc + src/model/UpdateSubnetResult.cc + src/model/UpdateVccRequest.cc + src/model/UpdateVccResult.cc + src/model/UpdateVpdRequest.cc + src/model/UpdateVpdResult.cc ) + +add_library(eflo ${LIB_TYPE} + ${eflo_public_header} + ${eflo_public_header_model} + ${eflo_src}) + +set_target_properties(eflo + 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}eflo + ) + +if(${LIB_TYPE} STREQUAL "SHARED") + set_target_properties(eflo + PROPERTIES + DEFINE_SYMBOL ALIBABACLOUD_EFLO_LIBRARY) +endif() + +target_include_directories(eflo + PRIVATE include + ${CMAKE_SOURCE_DIR}/core/include + ) +target_link_libraries(eflo + core) + +if(CMAKE_HOST_WIN32) + ExternalProject_Get_Property(jsoncpp INSTALL_DIR) + set(jsoncpp_install_dir ${INSTALL_DIR}) + add_dependencies(eflo + jsoncpp) + target_include_directories(eflo + PRIVATE ${jsoncpp_install_dir}/include) + target_link_libraries(eflo + ${jsoncpp_install_dir}/lib/jsoncpp.lib) + set_target_properties(eflo + PROPERTIES + COMPILE_OPTIONS "/bigobj") +else() + target_include_directories(eflo + PRIVATE /usr/include/jsoncpp) + target_link_libraries(eflo + jsoncpp) +endif() + +install(FILES ${eflo_public_header} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/eflo) +install(FILES ${eflo_public_header_model} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/eflo/model) +install(TARGETS eflo + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + ) \ No newline at end of file diff --git a/eflo/include/alibabacloud/eflo/EfloClient.h b/eflo/include/alibabacloud/eflo/EfloClient.h new file mode 100644 index 000000000..2d15bd390 --- /dev/null +++ b/eflo/include/alibabacloud/eflo/EfloClient.h @@ -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. + */ + +#ifndef ALIBABACLOUD_EFLO_EFLOCLIENT_H_ +#define ALIBABACLOUD_EFLO_EFLOCLIENT_H_ + +#include +#include +#include +#include +#include "EfloExport.h" +#include "model/CreateSubnetRequest.h" +#include "model/CreateSubnetResult.h" +#include "model/CreateVccRequest.h" +#include "model/CreateVccResult.h" +#include "model/CreateVpdRequest.h" +#include "model/CreateVpdResult.h" +#include "model/DeleteSubnetRequest.h" +#include "model/DeleteSubnetResult.h" +#include "model/DeleteVpdRequest.h" +#include "model/DeleteVpdResult.h" +#include "model/GetSubnetRequest.h" +#include "model/GetSubnetResult.h" +#include "model/GetVccRequest.h" +#include "model/GetVccResult.h" +#include "model/GetVpdRequest.h" +#include "model/GetVpdResult.h" +#include "model/InitializeVccRequest.h" +#include "model/InitializeVccResult.h" +#include "model/ListSubnetsRequest.h" +#include "model/ListSubnetsResult.h" +#include "model/ListVccsRequest.h" +#include "model/ListVccsResult.h" +#include "model/ListVpdsRequest.h" +#include "model/ListVpdsResult.h" +#include "model/UpdateSubnetRequest.h" +#include "model/UpdateSubnetResult.h" +#include "model/UpdateVccRequest.h" +#include "model/UpdateVccResult.h" +#include "model/UpdateVpdRequest.h" +#include "model/UpdateVpdResult.h" + + +namespace AlibabaCloud +{ + namespace Eflo + { + class ALIBABACLOUD_EFLO_EXPORT EfloClient : public RpcServiceClient + { + public: + typedef Outcome CreateSubnetOutcome; + typedef std::future CreateSubnetOutcomeCallable; + typedef std::function&)> CreateSubnetAsyncHandler; + typedef Outcome CreateVccOutcome; + typedef std::future CreateVccOutcomeCallable; + typedef std::function&)> CreateVccAsyncHandler; + typedef Outcome CreateVpdOutcome; + typedef std::future CreateVpdOutcomeCallable; + typedef std::function&)> CreateVpdAsyncHandler; + typedef Outcome DeleteSubnetOutcome; + typedef std::future DeleteSubnetOutcomeCallable; + typedef std::function&)> DeleteSubnetAsyncHandler; + typedef Outcome DeleteVpdOutcome; + typedef std::future DeleteVpdOutcomeCallable; + typedef std::function&)> DeleteVpdAsyncHandler; + typedef Outcome GetSubnetOutcome; + typedef std::future GetSubnetOutcomeCallable; + typedef std::function&)> GetSubnetAsyncHandler; + typedef Outcome GetVccOutcome; + typedef std::future GetVccOutcomeCallable; + typedef std::function&)> GetVccAsyncHandler; + typedef Outcome GetVpdOutcome; + typedef std::future GetVpdOutcomeCallable; + typedef std::function&)> GetVpdAsyncHandler; + typedef Outcome InitializeVccOutcome; + typedef std::future InitializeVccOutcomeCallable; + typedef std::function&)> InitializeVccAsyncHandler; + typedef Outcome ListSubnetsOutcome; + typedef std::future ListSubnetsOutcomeCallable; + typedef std::function&)> ListSubnetsAsyncHandler; + typedef Outcome ListVccsOutcome; + typedef std::future ListVccsOutcomeCallable; + typedef std::function&)> ListVccsAsyncHandler; + typedef Outcome ListVpdsOutcome; + typedef std::future ListVpdsOutcomeCallable; + typedef std::function&)> ListVpdsAsyncHandler; + typedef Outcome UpdateSubnetOutcome; + typedef std::future UpdateSubnetOutcomeCallable; + typedef std::function&)> UpdateSubnetAsyncHandler; + typedef Outcome UpdateVccOutcome; + typedef std::future UpdateVccOutcomeCallable; + typedef std::function&)> UpdateVccAsyncHandler; + typedef Outcome UpdateVpdOutcome; + typedef std::future UpdateVpdOutcomeCallable; + typedef std::function&)> UpdateVpdAsyncHandler; + + EfloClient(const Credentials &credentials, const ClientConfiguration &configuration); + EfloClient(const std::shared_ptr &credentialsProvider, const ClientConfiguration &configuration); + EfloClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration); + ~EfloClient(); + CreateSubnetOutcome createSubnet(const Model::CreateSubnetRequest &request)const; + void createSubnetAsync(const Model::CreateSubnetRequest& request, const CreateSubnetAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateSubnetOutcomeCallable createSubnetCallable(const Model::CreateSubnetRequest& request) const; + CreateVccOutcome createVcc(const Model::CreateVccRequest &request)const; + void createVccAsync(const Model::CreateVccRequest& request, const CreateVccAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateVccOutcomeCallable createVccCallable(const Model::CreateVccRequest& request) const; + CreateVpdOutcome createVpd(const Model::CreateVpdRequest &request)const; + void createVpdAsync(const Model::CreateVpdRequest& request, const CreateVpdAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateVpdOutcomeCallable createVpdCallable(const Model::CreateVpdRequest& request) const; + DeleteSubnetOutcome deleteSubnet(const Model::DeleteSubnetRequest &request)const; + void deleteSubnetAsync(const Model::DeleteSubnetRequest& request, const DeleteSubnetAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteSubnetOutcomeCallable deleteSubnetCallable(const Model::DeleteSubnetRequest& request) const; + DeleteVpdOutcome deleteVpd(const Model::DeleteVpdRequest &request)const; + void deleteVpdAsync(const Model::DeleteVpdRequest& request, const DeleteVpdAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteVpdOutcomeCallable deleteVpdCallable(const Model::DeleteVpdRequest& request) const; + GetSubnetOutcome getSubnet(const Model::GetSubnetRequest &request)const; + void getSubnetAsync(const Model::GetSubnetRequest& request, const GetSubnetAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetSubnetOutcomeCallable getSubnetCallable(const Model::GetSubnetRequest& request) const; + GetVccOutcome getVcc(const Model::GetVccRequest &request)const; + void getVccAsync(const Model::GetVccRequest& request, const GetVccAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetVccOutcomeCallable getVccCallable(const Model::GetVccRequest& request) const; + GetVpdOutcome getVpd(const Model::GetVpdRequest &request)const; + void getVpdAsync(const Model::GetVpdRequest& request, const GetVpdAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetVpdOutcomeCallable getVpdCallable(const Model::GetVpdRequest& request) const; + InitializeVccOutcome initializeVcc(const Model::InitializeVccRequest &request)const; + void initializeVccAsync(const Model::InitializeVccRequest& request, const InitializeVccAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + InitializeVccOutcomeCallable initializeVccCallable(const Model::InitializeVccRequest& request) const; + ListSubnetsOutcome listSubnets(const Model::ListSubnetsRequest &request)const; + void listSubnetsAsync(const Model::ListSubnetsRequest& request, const ListSubnetsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListSubnetsOutcomeCallable listSubnetsCallable(const Model::ListSubnetsRequest& request) const; + ListVccsOutcome listVccs(const Model::ListVccsRequest &request)const; + void listVccsAsync(const Model::ListVccsRequest& request, const ListVccsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListVccsOutcomeCallable listVccsCallable(const Model::ListVccsRequest& request) const; + ListVpdsOutcome listVpds(const Model::ListVpdsRequest &request)const; + void listVpdsAsync(const Model::ListVpdsRequest& request, const ListVpdsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListVpdsOutcomeCallable listVpdsCallable(const Model::ListVpdsRequest& request) const; + UpdateSubnetOutcome updateSubnet(const Model::UpdateSubnetRequest &request)const; + void updateSubnetAsync(const Model::UpdateSubnetRequest& request, const UpdateSubnetAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UpdateSubnetOutcomeCallable updateSubnetCallable(const Model::UpdateSubnetRequest& request) const; + UpdateVccOutcome updateVcc(const Model::UpdateVccRequest &request)const; + void updateVccAsync(const Model::UpdateVccRequest& request, const UpdateVccAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UpdateVccOutcomeCallable updateVccCallable(const Model::UpdateVccRequest& request) const; + UpdateVpdOutcome updateVpd(const Model::UpdateVpdRequest &request)const; + void updateVpdAsync(const Model::UpdateVpdRequest& request, const UpdateVpdAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UpdateVpdOutcomeCallable updateVpdCallable(const Model::UpdateVpdRequest& request) const; + + private: + std::shared_ptr endpointProvider_; + }; + } +} + +#endif // !ALIBABACLOUD_EFLO_EFLOCLIENT_H_ diff --git a/eflo/include/alibabacloud/eflo/EfloExport.h b/eflo/include/alibabacloud/eflo/EfloExport.h new file mode 100644 index 000000000..86664b06f --- /dev/null +++ b/eflo/include/alibabacloud/eflo/EfloExport.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_EFLO_EFLOEXPORT_H_ +#define ALIBABACLOUD_EFLO_EFLOEXPORT_H_ + +#include + +#if defined(ALIBABACLOUD_SHARED) +# if defined(ALIBABACLOUD_EFLO_LIBRARY) +# define ALIBABACLOUD_EFLO_EXPORT ALIBABACLOUD_DECL_EXPORT +# else +# define ALIBABACLOUD_EFLO_EXPORT ALIBABACLOUD_DECL_IMPORT +# endif +#else +# define ALIBABACLOUD_EFLO_EXPORT +#endif + +#endif // !ALIBABACLOUD_EFLO_EFLOEXPORT_H_ \ No newline at end of file diff --git a/eflo/include/alibabacloud/eflo/model/CreateSubnetRequest.h b/eflo/include/alibabacloud/eflo/model/CreateSubnetRequest.h new file mode 100644 index 000000000..a76565a57 --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/CreateSubnetRequest.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_EFLO_MODEL_CREATESUBNETREQUEST_H_ +#define ALIBABACLOUD_EFLO_MODEL_CREATESUBNETREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Eflo { +namespace Model { +class ALIBABACLOUD_EFLO_EXPORT CreateSubnetRequest : public RpcServiceRequest { +public: + CreateSubnetRequest(); + ~CreateSubnetRequest(); + std::string getType() const; + void setType(const std::string &type); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getVpdId() const; + void setVpdId(const std::string &vpdId); + std::string getName() const; + void setName(const std::string &name); + std::string getZoneId() const; + void setZoneId(const std::string &zoneId); + std::string getCidr() const; + void setCidr(const std::string &cidr); + +private: + std::string type_; + std::string regionId_; + std::string vpdId_; + std::string name_; + std::string zoneId_; + std::string cidr_; +}; +} // namespace Model +} // namespace Eflo +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_EFLO_MODEL_CREATESUBNETREQUEST_H_ diff --git a/eflo/include/alibabacloud/eflo/model/CreateSubnetResult.h b/eflo/include/alibabacloud/eflo/model/CreateSubnetResult.h new file mode 100644 index 000000000..0ef323b1e --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/CreateSubnetResult.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_EFLO_MODEL_CREATESUBNETRESULT_H_ +#define ALIBABACLOUD_EFLO_MODEL_CREATESUBNETRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Eflo + { + namespace Model + { + class ALIBABACLOUD_EFLO_EXPORT CreateSubnetResult : public ServiceResult + { + public: + struct Content + { + std::string subnetId; + }; + + + CreateSubnetResult(); + explicit CreateSubnetResult(const std::string &payload); + ~CreateSubnetResult(); + std::string getMessage()const; + Content getContent()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Content content_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EFLO_MODEL_CREATESUBNETRESULT_H_ \ No newline at end of file diff --git a/eflo/include/alibabacloud/eflo/model/CreateVccRequest.h b/eflo/include/alibabacloud/eflo/model/CreateVccRequest.h new file mode 100644 index 000000000..74e0e4168 --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/CreateVccRequest.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_EFLO_MODEL_CREATEVCCREQUEST_H_ +#define ALIBABACLOUD_EFLO_MODEL_CREATEVCCREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Eflo { +namespace Model { +class ALIBABACLOUD_EFLO_EXPORT CreateVccRequest : public RpcServiceRequest { +public: + CreateVccRequest(); + ~CreateVccRequest(); + std::string getBgpCidr() const; + void setBgpCidr(const std::string &bgpCidr); + std::string getCenId() const; + void setCenId(const std::string &cenId); + std::string getDescription() const; + void setDescription(const std::string &description); + bool getAccessCouldService() const; + void setAccessCouldService(bool accessCouldService); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getVccId() const; + void setVccId(const std::string &vccId); + std::string getVSwitchId() const; + void setVSwitchId(const std::string &vSwitchId); + std::string getVpdId() const; + void setVpdId(const std::string &vpdId); + std::string getVpcId() const; + void setVpcId(const std::string &vpcId); + +private: + std::string bgpCidr_; + std::string cenId_; + std::string description_; + bool accessCouldService_; + std::string regionId_; + std::string vccId_; + std::string vSwitchId_; + std::string vpdId_; + std::string vpcId_; +}; +} // namespace Model +} // namespace Eflo +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_EFLO_MODEL_CREATEVCCREQUEST_H_ diff --git a/eflo/include/alibabacloud/eflo/model/CreateVccResult.h b/eflo/include/alibabacloud/eflo/model/CreateVccResult.h new file mode 100644 index 000000000..5effbd989 --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/CreateVccResult.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_EFLO_MODEL_CREATEVCCRESULT_H_ +#define ALIBABACLOUD_EFLO_MODEL_CREATEVCCRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Eflo + { + namespace Model + { + class ALIBABACLOUD_EFLO_EXPORT CreateVccResult : public ServiceResult + { + public: + struct Content + { + std::string vccId; + }; + + + CreateVccResult(); + explicit CreateVccResult(const std::string &payload); + ~CreateVccResult(); + std::string getMessage()const; + Content getContent()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Content content_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EFLO_MODEL_CREATEVCCRESULT_H_ \ No newline at end of file diff --git a/eflo/include/alibabacloud/eflo/model/CreateVpdRequest.h b/eflo/include/alibabacloud/eflo/model/CreateVpdRequest.h new file mode 100644 index 000000000..13df76bf7 --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/CreateVpdRequest.h @@ -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. + */ + +#ifndef ALIBABACLOUD_EFLO_MODEL_CREATEVPDREQUEST_H_ +#define ALIBABACLOUD_EFLO_MODEL_CREATEVPDREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Eflo { +namespace Model { +class ALIBABACLOUD_EFLO_EXPORT CreateVpdRequest : public RpcServiceRequest { +public: + struct Subnets { + std::string regionId; + std::string name; + std::string zoneId; + std::string cidr; + std::string type; + }; + CreateVpdRequest(); + ~CreateVpdRequest(); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getName() const; + void setName(const std::string &name); + std::string getCidr() const; + void setCidr(const std::string &cidr); + std::vector getSubnets() const; + void setSubnets(const std::vector &subnets); + +private: + std::string regionId_; + std::string name_; + std::string cidr_; + std::vector subnets_; +}; +} // namespace Model +} // namespace Eflo +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_EFLO_MODEL_CREATEVPDREQUEST_H_ diff --git a/eflo/include/alibabacloud/eflo/model/CreateVpdResult.h b/eflo/include/alibabacloud/eflo/model/CreateVpdResult.h new file mode 100644 index 000000000..3cfaf5a7b --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/CreateVpdResult.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_EFLO_MODEL_CREATEVPDRESULT_H_ +#define ALIBABACLOUD_EFLO_MODEL_CREATEVPDRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Eflo + { + namespace Model + { + class ALIBABACLOUD_EFLO_EXPORT CreateVpdResult : public ServiceResult + { + public: + struct Content + { + std::string vpdId; + std::vector subnetIds; + }; + + + CreateVpdResult(); + explicit CreateVpdResult(const std::string &payload); + ~CreateVpdResult(); + std::string getMessage()const; + Content getContent()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Content content_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EFLO_MODEL_CREATEVPDRESULT_H_ \ No newline at end of file diff --git a/eflo/include/alibabacloud/eflo/model/DeleteSubnetRequest.h b/eflo/include/alibabacloud/eflo/model/DeleteSubnetRequest.h new file mode 100644 index 000000000..6d6fd98f0 --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/DeleteSubnetRequest.h @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_EFLO_MODEL_DELETESUBNETREQUEST_H_ +#define ALIBABACLOUD_EFLO_MODEL_DELETESUBNETREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Eflo { +namespace Model { +class ALIBABACLOUD_EFLO_EXPORT DeleteSubnetRequest : public RpcServiceRequest { +public: + DeleteSubnetRequest(); + ~DeleteSubnetRequest(); + std::string getSubnetId() const; + void setSubnetId(const std::string &subnetId); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getVpdId() const; + void setVpdId(const std::string &vpdId); + std::string getZoneId() const; + void setZoneId(const std::string &zoneId); + +private: + std::string subnetId_; + std::string regionId_; + std::string vpdId_; + std::string zoneId_; +}; +} // namespace Model +} // namespace Eflo +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_EFLO_MODEL_DELETESUBNETREQUEST_H_ diff --git a/eflo/include/alibabacloud/eflo/model/DeleteSubnetResult.h b/eflo/include/alibabacloud/eflo/model/DeleteSubnetResult.h new file mode 100644 index 000000000..6fec7e7f4 --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/DeleteSubnetResult.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_EFLO_MODEL_DELETESUBNETRESULT_H_ +#define ALIBABACLOUD_EFLO_MODEL_DELETESUBNETRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Eflo + { + namespace Model + { + class ALIBABACLOUD_EFLO_EXPORT DeleteSubnetResult : public ServiceResult + { + public: + + + DeleteSubnetResult(); + explicit DeleteSubnetResult(const std::string &payload); + ~DeleteSubnetResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_EFLO_MODEL_DELETESUBNETRESULT_H_ \ No newline at end of file diff --git a/eflo/include/alibabacloud/eflo/model/DeleteVpdRequest.h b/eflo/include/alibabacloud/eflo/model/DeleteVpdRequest.h new file mode 100644 index 000000000..a06a23a8b --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/DeleteVpdRequest.h @@ -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. + */ + +#ifndef ALIBABACLOUD_EFLO_MODEL_DELETEVPDREQUEST_H_ +#define ALIBABACLOUD_EFLO_MODEL_DELETEVPDREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Eflo { +namespace Model { +class ALIBABACLOUD_EFLO_EXPORT DeleteVpdRequest : public RpcServiceRequest { +public: + DeleteVpdRequest(); + ~DeleteVpdRequest(); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getVpdId() const; + void setVpdId(const std::string &vpdId); + +private: + std::string regionId_; + std::string vpdId_; +}; +} // namespace Model +} // namespace Eflo +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_EFLO_MODEL_DELETEVPDREQUEST_H_ diff --git a/eflo/include/alibabacloud/eflo/model/DeleteVpdResult.h b/eflo/include/alibabacloud/eflo/model/DeleteVpdResult.h new file mode 100644 index 000000000..689e72d35 --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/DeleteVpdResult.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_EFLO_MODEL_DELETEVPDRESULT_H_ +#define ALIBABACLOUD_EFLO_MODEL_DELETEVPDRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Eflo + { + namespace Model + { + class ALIBABACLOUD_EFLO_EXPORT DeleteVpdResult : public ServiceResult + { + public: + + + DeleteVpdResult(); + explicit DeleteVpdResult(const std::string &payload); + ~DeleteVpdResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_EFLO_MODEL_DELETEVPDRESULT_H_ \ No newline at end of file diff --git a/eflo/include/alibabacloud/eflo/model/GetSubnetRequest.h b/eflo/include/alibabacloud/eflo/model/GetSubnetRequest.h new file mode 100644 index 000000000..24e8a59ef --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/GetSubnetRequest.h @@ -0,0 +1,42 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_EFLO_MODEL_GETSUBNETREQUEST_H_ +#define ALIBABACLOUD_EFLO_MODEL_GETSUBNETREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Eflo { +namespace Model { +class ALIBABACLOUD_EFLO_EXPORT GetSubnetRequest : public RpcServiceRequest { +public: + GetSubnetRequest(); + ~GetSubnetRequest(); + std::string getSubnetId() const; + void setSubnetId(const std::string &subnetId); + +private: + std::string subnetId_; +}; +} // namespace Model +} // namespace Eflo +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_EFLO_MODEL_GETSUBNETREQUEST_H_ diff --git a/eflo/include/alibabacloud/eflo/model/GetSubnetResult.h b/eflo/include/alibabacloud/eflo/model/GetSubnetResult.h new file mode 100644 index 000000000..22ce519bb --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/GetSubnetResult.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_EFLO_MODEL_GETSUBNETRESULT_H_ +#define ALIBABACLOUD_EFLO_MODEL_GETSUBNETRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Eflo + { + namespace Model + { + class ALIBABACLOUD_EFLO_EXPORT GetSubnetResult : public ServiceResult + { + public: + struct Content + { + struct VpdBaseInfo + { + std::string gmtCreate; + std::string cidr; + std::string vpdId; + std::string name; + }; + std::string status; + long ncCount; + long lbCount; + VpdBaseInfo vpdBaseInfo; + std::string description; + std::string zoneId; + std::string message; + std::string gmtModified; + std::string subnetId; + std::string name; + std::string gmtCreate; + std::string tenantId; + std::string type; + std::string cidr; + std::string vpdId; + long id; + std::string regionId; + }; + + + GetSubnetResult(); + explicit GetSubnetResult(const std::string &payload); + ~GetSubnetResult(); + std::string getMessage()const; + Content getContent()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Content content_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EFLO_MODEL_GETSUBNETRESULT_H_ \ No newline at end of file diff --git a/eflo/include/alibabacloud/eflo/model/GetVccRequest.h b/eflo/include/alibabacloud/eflo/model/GetVccRequest.h new file mode 100644 index 000000000..c6ea07b89 --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/GetVccRequest.h @@ -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. + */ + +#ifndef ALIBABACLOUD_EFLO_MODEL_GETVCCREQUEST_H_ +#define ALIBABACLOUD_EFLO_MODEL_GETVCCREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Eflo { +namespace Model { +class ALIBABACLOUD_EFLO_EXPORT GetVccRequest : public RpcServiceRequest { +public: + GetVccRequest(); + ~GetVccRequest(); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getVccId() const; + void setVccId(const std::string &vccId); + +private: + std::string regionId_; + std::string vccId_; +}; +} // namespace Model +} // namespace Eflo +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_EFLO_MODEL_GETVCCREQUEST_H_ diff --git a/eflo/include/alibabacloud/eflo/model/GetVccResult.h b/eflo/include/alibabacloud/eflo/model/GetVccResult.h new file mode 100644 index 000000000..f6acc056d --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/GetVccResult.h @@ -0,0 +1,115 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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_EFLO_MODEL_GETVCCRESULT_H_ +#define ALIBABACLOUD_EFLO_MODEL_GETVCCRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Eflo + { + namespace Model + { + class ALIBABACLOUD_EFLO_EXPORT GetVccResult : public ServiceResult + { + public: + struct Content + { + struct VpdBaseInfo + { + std::string gmtCreate; + std::string cidr; + std::string vpdId; + std::string name; + }; + struct AliyunRouterInfoItem + { + std::string localGatewayIp; + std::string peerGatewayIp; + std::string mask; + std::string pcId; + std::string vbrId; + std::string vlanId; + }; + struct CisRouterInfoItem + { + struct CcInfo + { + std::string status; + std::string localGatewayIp; + std::string remoteGatewayIp; + std::string ccId; + std::string vlanId; + std::string subnetMask; + }; + std::string ccrId; + std::vector ccInfos; + }; + std::string message; + std::string lineOperator; + std::string pricingCycle; + std::string currentNode; + std::string gmtModified; + std::string bgpCidr; + std::string commodityCode; + std::string vccId; + std::string status; + VpdBaseInfo vpdBaseInfo; + std::string vSwitchId; + std::string createTime; + std::string duration; + std::string payType; + std::vector aliyunRouterInfo; + std::string internetChargeType; + std::string bandwidthStr; + std::vector cisRouterInfo; + std::string tenantId; + std::string vpcId; + std::string vpdId; + std::string cenId; + std::string accessPointId; + std::string regionId; + std::string spec; + std::string vccName; + std::string portType; + }; + + + GetVccResult(); + explicit GetVccResult(const std::string &payload); + ~GetVccResult(); + std::string getMessage()const; + Content getContent()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Content content_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EFLO_MODEL_GETVCCRESULT_H_ \ No newline at end of file diff --git a/eflo/include/alibabacloud/eflo/model/GetVpdRequest.h b/eflo/include/alibabacloud/eflo/model/GetVpdRequest.h new file mode 100644 index 000000000..a20ecc3c4 --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/GetVpdRequest.h @@ -0,0 +1,42 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_EFLO_MODEL_GETVPDREQUEST_H_ +#define ALIBABACLOUD_EFLO_MODEL_GETVPDREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Eflo { +namespace Model { +class ALIBABACLOUD_EFLO_EXPORT GetVpdRequest : public RpcServiceRequest { +public: + GetVpdRequest(); + ~GetVpdRequest(); + std::string getVpdId() const; + void setVpdId(const std::string &vpdId); + +private: + std::string vpdId_; +}; +} // namespace Model +} // namespace Eflo +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_EFLO_MODEL_GETVPDREQUEST_H_ diff --git a/eflo/include/alibabacloud/eflo/model/GetVpdResult.h b/eflo/include/alibabacloud/eflo/model/GetVpdResult.h new file mode 100644 index 000000000..c4e0c272f --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/GetVpdResult.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_EFLO_MODEL_GETVPDRESULT_H_ +#define ALIBABACLOUD_EFLO_MODEL_GETVPDRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Eflo + { + namespace Model + { + class ALIBABACLOUD_EFLO_EXPORT GetVpdResult : public ServiceResult + { + public: + struct Content + { + std::string status; + long ncCount; + long lbCount; + std::string description; + std::string message; + long subnetCount; + std::string gmtModified; + std::string name; + std::string gmtCreate; + std::string cidr; + std::string vpdId; + std::string serviceCidr; + std::string regionId; + long vccCount; + int route; + }; + + + GetVpdResult(); + explicit GetVpdResult(const std::string &payload); + ~GetVpdResult(); + std::string getMessage()const; + Content getContent()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Content content_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EFLO_MODEL_GETVPDRESULT_H_ \ No newline at end of file diff --git a/eflo/include/alibabacloud/eflo/model/InitializeVccRequest.h b/eflo/include/alibabacloud/eflo/model/InitializeVccRequest.h new file mode 100644 index 000000000..be1985221 --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/InitializeVccRequest.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_EFLO_MODEL_INITIALIZEVCCREQUEST_H_ +#define ALIBABACLOUD_EFLO_MODEL_INITIALIZEVCCREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Eflo { +namespace Model { +class ALIBABACLOUD_EFLO_EXPORT InitializeVccRequest : public RpcServiceRequest { +public: + InitializeVccRequest(); + ~InitializeVccRequest(); + +private: +}; +} // namespace Model +} // namespace Eflo +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_EFLO_MODEL_INITIALIZEVCCREQUEST_H_ diff --git a/eflo/include/alibabacloud/eflo/model/InitializeVccResult.h b/eflo/include/alibabacloud/eflo/model/InitializeVccResult.h new file mode 100644 index 000000000..5d7d23bc7 --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/InitializeVccResult.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_EFLO_MODEL_INITIALIZEVCCRESULT_H_ +#define ALIBABACLOUD_EFLO_MODEL_INITIALIZEVCCRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Eflo + { + namespace Model + { + class ALIBABACLOUD_EFLO_EXPORT InitializeVccResult : public ServiceResult + { + public: + struct Content + { + std::string roleName; + std::string requestId; + }; + + + InitializeVccResult(); + explicit InitializeVccResult(const std::string &payload); + ~InitializeVccResult(); + std::string getMessage()const; + Content getContent()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Content content_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EFLO_MODEL_INITIALIZEVCCRESULT_H_ \ No newline at end of file diff --git a/eflo/include/alibabacloud/eflo/model/ListSubnetsRequest.h b/eflo/include/alibabacloud/eflo/model/ListSubnetsRequest.h new file mode 100644 index 000000000..521b75aa1 --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/ListSubnetsRequest.h @@ -0,0 +1,69 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_EFLO_MODEL_LISTSUBNETSREQUEST_H_ +#define ALIBABACLOUD_EFLO_MODEL_LISTSUBNETSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Eflo { +namespace Model { +class ALIBABACLOUD_EFLO_EXPORT ListSubnetsRequest : public RpcServiceRequest { +public: + ListSubnetsRequest(); + ~ListSubnetsRequest(); + std::string getType() const; + void setType(const std::string &type); + int getPageNumber() const; + void setPageNumber(int pageNumber); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + int getPageSize() const; + void setPageSize(int pageSize); + std::string getSubnetId() const; + void setSubnetId(const std::string &subnetId); + std::string getVpdId() const; + void setVpdId(const std::string &vpdId); + bool getEnablePage() const; + void setEnablePage(bool enablePage); + std::string getName() const; + void setName(const std::string &name); + std::string getZoneId() const; + void setZoneId(const std::string &zoneId); + std::string getStatus() const; + void setStatus(const std::string &status); + +private: + std::string type_; + int pageNumber_; + std::string regionId_; + int pageSize_; + std::string subnetId_; + std::string vpdId_; + bool enablePage_; + std::string name_; + std::string zoneId_; + std::string status_; +}; +} // namespace Model +} // namespace Eflo +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_EFLO_MODEL_LISTSUBNETSREQUEST_H_ diff --git a/eflo/include/alibabacloud/eflo/model/ListSubnetsResult.h b/eflo/include/alibabacloud/eflo/model/ListSubnetsResult.h new file mode 100644 index 000000000..13cff52f9 --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/ListSubnetsResult.h @@ -0,0 +1,85 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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_EFLO_MODEL_LISTSUBNETSRESULT_H_ +#define ALIBABACLOUD_EFLO_MODEL_LISTSUBNETSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Eflo + { + namespace Model + { + class ALIBABACLOUD_EFLO_EXPORT ListSubnetsResult : public ServiceResult + { + public: + struct Content + { + struct DataItem + { + struct VpdBaseInfo + { + std::string gmtCreate; + std::string cidr; + std::string vpdId; + std::string name; + }; + std::string status; + long ncCount; + VpdBaseInfo vpdBaseInfo; + std::string zoneId; + std::string message; + std::string gmtModified; + std::string subnetId; + std::string name; + std::string gmtCreate; + std::string tenantId; + std::string type; + std::string cidr; + std::string vpdId; + long id; + std::string regionId; + }; + long total; + std::vector data; + }; + + + ListSubnetsResult(); + explicit ListSubnetsResult(const std::string &payload); + ~ListSubnetsResult(); + std::string getMessage()const; + Content getContent()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Content content_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EFLO_MODEL_LISTSUBNETSRESULT_H_ \ No newline at end of file diff --git a/eflo/include/alibabacloud/eflo/model/ListVccsRequest.h b/eflo/include/alibabacloud/eflo/model/ListVccsRequest.h new file mode 100644 index 000000000..9afdee3ce --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/ListVccsRequest.h @@ -0,0 +1,72 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_EFLO_MODEL_LISTVCCSREQUEST_H_ +#define ALIBABACLOUD_EFLO_MODEL_LISTVCCSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Eflo { +namespace Model { +class ALIBABACLOUD_EFLO_EXPORT ListVccsRequest : public RpcServiceRequest { +public: + ListVccsRequest(); + ~ListVccsRequest(); + std::string getCenId() const; + void setCenId(const std::string &cenId); + int getPageNumber() const; + void setPageNumber(int pageNumber); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + int getPageSize() const; + void setPageSize(int pageSize); + std::string getVccId() const; + void setVccId(const std::string &vccId); + int getBandwidth() const; + void setBandwidth(int bandwidth); + std::string getExStatus() const; + void setExStatus(const std::string &exStatus); + std::string getVpdId() const; + void setVpdId(const std::string &vpdId); + std::string getVpcId() const; + void setVpcId(const std::string &vpcId); + bool getEnablePage() const; + void setEnablePage(bool enablePage); + std::string getStatus() const; + void setStatus(const std::string &status); + +private: + std::string cenId_; + int pageNumber_; + std::string regionId_; + int pageSize_; + std::string vccId_; + int bandwidth_; + std::string exStatus_; + std::string vpdId_; + std::string vpcId_; + bool enablePage_; + std::string status_; +}; +} // namespace Model +} // namespace Eflo +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_EFLO_MODEL_LISTVCCSREQUEST_H_ diff --git a/eflo/include/alibabacloud/eflo/model/ListVccsResult.h b/eflo/include/alibabacloud/eflo/model/ListVccsResult.h new file mode 100644 index 000000000..408a4762c --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/ListVccsResult.h @@ -0,0 +1,89 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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_EFLO_MODEL_LISTVCCSRESULT_H_ +#define ALIBABACLOUD_EFLO_MODEL_LISTVCCSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Eflo + { + namespace Model + { + class ALIBABACLOUD_EFLO_EXPORT ListVccsResult : public ServiceResult + { + public: + struct Content + { + struct DataItem + { + struct VpdBaseInfo + { + std::string gmtCreate; + std::string cidr; + std::string vpdId; + std::string name; + }; + std::string status; + VpdBaseInfo vpdBaseInfo; + std::string message; + std::string lineOperator; + double rate; + std::string createTime; + std::string gmtModified; + std::string bandwidthStr; + std::string tenantId; + std::string vpcId; + std::string vpdId; + std::string bgpCidr; + std::string cenId; + std::string accessPointId; + std::string regionId; + std::string vccId; + std::string spec; + std::string vccName; + std::string portType; + }; + long total; + std::vector data; + }; + + + ListVccsResult(); + explicit ListVccsResult(const std::string &payload); + ~ListVccsResult(); + std::string getMessage()const; + Content getContent()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Content content_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EFLO_MODEL_LISTVCCSRESULT_H_ \ No newline at end of file diff --git a/eflo/include/alibabacloud/eflo/model/ListVpdsRequest.h b/eflo/include/alibabacloud/eflo/model/ListVpdsRequest.h new file mode 100644 index 000000000..eb6ad5b2c --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/ListVpdsRequest.h @@ -0,0 +1,72 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_EFLO_MODEL_LISTVPDSREQUEST_H_ +#define ALIBABACLOUD_EFLO_MODEL_LISTVPDSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Eflo { +namespace Model { +class ALIBABACLOUD_EFLO_EXPORT ListVpdsRequest : public RpcServiceRequest { +public: + ListVpdsRequest(); + ~ListVpdsRequest(); + int getPageNumber() const; + void setPageNumber(int pageNumber); + bool getWithDependence() const; + void setWithDependence(bool withDependence); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + bool getWithoutVcc() const; + void setWithoutVcc(bool withoutVcc); + int getPageSize() const; + void setPageSize(int pageSize); + bool getForSelect() const; + void setForSelect(bool forSelect); + std::string getFilterErId() const; + void setFilterErId(const std::string &filterErId); + std::string getVpdId() const; + void setVpdId(const std::string &vpdId); + bool getEnablePage() const; + void setEnablePage(bool enablePage); + std::string getName() const; + void setName(const std::string &name); + std::string getStatus() const; + void setStatus(const std::string &status); + +private: + int pageNumber_; + bool withDependence_; + std::string regionId_; + bool withoutVcc_; + int pageSize_; + bool forSelect_; + std::string filterErId_; + std::string vpdId_; + bool enablePage_; + std::string name_; + std::string status_; +}; +} // namespace Model +} // namespace Eflo +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_EFLO_MODEL_LISTVPDSREQUEST_H_ diff --git a/eflo/include/alibabacloud/eflo/model/ListVpdsResult.h b/eflo/include/alibabacloud/eflo/model/ListVpdsResult.h new file mode 100644 index 000000000..f4420c6b8 --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/ListVpdsResult.h @@ -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. + */ + +#ifndef ALIBABACLOUD_EFLO_MODEL_LISTVPDSRESULT_H_ +#define ALIBABACLOUD_EFLO_MODEL_LISTVPDSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Eflo + { + namespace Model + { + class ALIBABACLOUD_EFLO_EXPORT ListVpdsResult : public ServiceResult + { + public: + struct Content + { + struct DataItem + { + std::string status; + int ncCount; + std::string message; + int subnetCount; + std::string gmtModified; + std::string name; + std::string gmtCreate; + std::string cidr; + std::string vpdId; + std::string dependence; + std::string serviceCidr; + std::string regionId; + int route; + }; + long total; + std::vector data; + }; + + + ListVpdsResult(); + explicit ListVpdsResult(const std::string &payload); + ~ListVpdsResult(); + std::string getMessage()const; + Content getContent()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Content content_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EFLO_MODEL_LISTVPDSRESULT_H_ \ No newline at end of file diff --git a/eflo/include/alibabacloud/eflo/model/UpdateSubnetRequest.h b/eflo/include/alibabacloud/eflo/model/UpdateSubnetRequest.h new file mode 100644 index 000000000..8e5384d08 --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/UpdateSubnetRequest.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_EFLO_MODEL_UPDATESUBNETREQUEST_H_ +#define ALIBABACLOUD_EFLO_MODEL_UPDATESUBNETREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Eflo { +namespace Model { +class ALIBABACLOUD_EFLO_EXPORT UpdateSubnetRequest : public RpcServiceRequest { +public: + UpdateSubnetRequest(); + ~UpdateSubnetRequest(); + std::string getSubnetId() const; + void setSubnetId(const std::string &subnetId); + std::string getDescription() const; + void setDescription(const std::string &description); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getVpdId() const; + void setVpdId(const std::string &vpdId); + std::string getName() const; + void setName(const std::string &name); + std::string getZoneId() const; + void setZoneId(const std::string &zoneId); + +private: + std::string subnetId_; + std::string description_; + std::string regionId_; + std::string vpdId_; + std::string name_; + std::string zoneId_; +}; +} // namespace Model +} // namespace Eflo +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_EFLO_MODEL_UPDATESUBNETREQUEST_H_ diff --git a/eflo/include/alibabacloud/eflo/model/UpdateSubnetResult.h b/eflo/include/alibabacloud/eflo/model/UpdateSubnetResult.h new file mode 100644 index 000000000..d372fac37 --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/UpdateSubnetResult.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_EFLO_MODEL_UPDATESUBNETRESULT_H_ +#define ALIBABACLOUD_EFLO_MODEL_UPDATESUBNETRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Eflo + { + namespace Model + { + class ALIBABACLOUD_EFLO_EXPORT UpdateSubnetResult : public ServiceResult + { + public: + struct Content + { + std::string subnetId; + }; + + + UpdateSubnetResult(); + explicit UpdateSubnetResult(const std::string &payload); + ~UpdateSubnetResult(); + std::string getMessage()const; + Content getContent()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Content content_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EFLO_MODEL_UPDATESUBNETRESULT_H_ \ No newline at end of file diff --git a/eflo/include/alibabacloud/eflo/model/UpdateVccRequest.h b/eflo/include/alibabacloud/eflo/model/UpdateVccRequest.h new file mode 100644 index 000000000..2f4b46669 --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/UpdateVccRequest.h @@ -0,0 +1,54 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_EFLO_MODEL_UPDATEVCCREQUEST_H_ +#define ALIBABACLOUD_EFLO_MODEL_UPDATEVCCREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Eflo { +namespace Model { +class ALIBABACLOUD_EFLO_EXPORT UpdateVccRequest : public RpcServiceRequest { +public: + UpdateVccRequest(); + ~UpdateVccRequest(); + int getBandwidth() const; + void setBandwidth(int bandwidth); + std::string getOrderId() const; + void setOrderId(const std::string &orderId); + std::string getVccName() const; + void setVccName(const std::string &vccName); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getVccId() const; + void setVccId(const std::string &vccId); + +private: + int bandwidth_; + std::string orderId_; + std::string vccName_; + std::string regionId_; + std::string vccId_; +}; +} // namespace Model +} // namespace Eflo +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_EFLO_MODEL_UPDATEVCCREQUEST_H_ diff --git a/eflo/include/alibabacloud/eflo/model/UpdateVccResult.h b/eflo/include/alibabacloud/eflo/model/UpdateVccResult.h new file mode 100644 index 000000000..79cb30a6e --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/UpdateVccResult.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_EFLO_MODEL_UPDATEVCCRESULT_H_ +#define ALIBABACLOUD_EFLO_MODEL_UPDATEVCCRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Eflo + { + namespace Model + { + class ALIBABACLOUD_EFLO_EXPORT UpdateVccResult : public ServiceResult + { + public: + struct Content + { + std::string vccId; + }; + + + UpdateVccResult(); + explicit UpdateVccResult(const std::string &payload); + ~UpdateVccResult(); + std::string getMessage()const; + Content getContent()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Content content_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EFLO_MODEL_UPDATEVCCRESULT_H_ \ No newline at end of file diff --git a/eflo/include/alibabacloud/eflo/model/UpdateVpdRequest.h b/eflo/include/alibabacloud/eflo/model/UpdateVpdRequest.h new file mode 100644 index 000000000..cc2ab034e --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/UpdateVpdRequest.h @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_EFLO_MODEL_UPDATEVPDREQUEST_H_ +#define ALIBABACLOUD_EFLO_MODEL_UPDATEVPDREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Eflo { +namespace Model { +class ALIBABACLOUD_EFLO_EXPORT UpdateVpdRequest : public RpcServiceRequest { +public: + UpdateVpdRequest(); + ~UpdateVpdRequest(); + std::string getDescription() const; + void setDescription(const std::string &description); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getVpdId() const; + void setVpdId(const std::string &vpdId); + std::string getName() const; + void setName(const std::string &name); + +private: + std::string description_; + std::string regionId_; + std::string vpdId_; + std::string name_; +}; +} // namespace Model +} // namespace Eflo +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_EFLO_MODEL_UPDATEVPDREQUEST_H_ diff --git a/eflo/include/alibabacloud/eflo/model/UpdateVpdResult.h b/eflo/include/alibabacloud/eflo/model/UpdateVpdResult.h new file mode 100644 index 000000000..ae2329883 --- /dev/null +++ b/eflo/include/alibabacloud/eflo/model/UpdateVpdResult.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_EFLO_MODEL_UPDATEVPDRESULT_H_ +#define ALIBABACLOUD_EFLO_MODEL_UPDATEVPDRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Eflo + { + namespace Model + { + class ALIBABACLOUD_EFLO_EXPORT UpdateVpdResult : public ServiceResult + { + public: + struct Content + { + std::string vpdId; + }; + + + UpdateVpdResult(); + explicit UpdateVpdResult(const std::string &payload); + ~UpdateVpdResult(); + std::string getMessage()const; + Content getContent()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Content content_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_EFLO_MODEL_UPDATEVPDRESULT_H_ \ No newline at end of file diff --git a/eflo/src/EfloClient.cc b/eflo/src/EfloClient.cc new file mode 100644 index 000000000..269dcd1f7 --- /dev/null +++ b/eflo/src/EfloClient.cc @@ -0,0 +1,593 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::Eflo; +using namespace AlibabaCloud::Eflo::Model; + +namespace +{ + const std::string SERVICE_NAME = "eflo"; +} + +EfloClient::EfloClient(const Credentials &credentials, const ClientConfiguration &configuration) : + RpcServiceClient(SERVICE_NAME, std::make_shared(credentials), configuration) +{ + auto locationClient = std::make_shared(credentials, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "eflo"); +} + +EfloClient::EfloClient(const std::shared_ptr& credentialsProvider, const ClientConfiguration & configuration) : + RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration) +{ + auto locationClient = std::make_shared(credentialsProvider, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "eflo"); +} + +EfloClient::EfloClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) : + RpcServiceClient(SERVICE_NAME, std::make_shared(accessKeyId, accessKeySecret), configuration) +{ + auto locationClient = std::make_shared(accessKeyId, accessKeySecret, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "eflo"); +} + +EfloClient::~EfloClient() +{} + +EfloClient::CreateSubnetOutcome EfloClient::createSubnet(const CreateSubnetRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CreateSubnetOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateSubnetOutcome(CreateSubnetResult(outcome.result())); + else + return CreateSubnetOutcome(outcome.error()); +} + +void EfloClient::createSubnetAsync(const CreateSubnetRequest& request, const CreateSubnetAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createSubnet(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EfloClient::CreateSubnetOutcomeCallable EfloClient::createSubnetCallable(const CreateSubnetRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createSubnet(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +EfloClient::CreateVccOutcome EfloClient::createVcc(const CreateVccRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CreateVccOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateVccOutcome(CreateVccResult(outcome.result())); + else + return CreateVccOutcome(outcome.error()); +} + +void EfloClient::createVccAsync(const CreateVccRequest& request, const CreateVccAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createVcc(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EfloClient::CreateVccOutcomeCallable EfloClient::createVccCallable(const CreateVccRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createVcc(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +EfloClient::CreateVpdOutcome EfloClient::createVpd(const CreateVpdRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CreateVpdOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateVpdOutcome(CreateVpdResult(outcome.result())); + else + return CreateVpdOutcome(outcome.error()); +} + +void EfloClient::createVpdAsync(const CreateVpdRequest& request, const CreateVpdAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createVpd(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EfloClient::CreateVpdOutcomeCallable EfloClient::createVpdCallable(const CreateVpdRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createVpd(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +EfloClient::DeleteSubnetOutcome EfloClient::deleteSubnet(const DeleteSubnetRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteSubnetOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteSubnetOutcome(DeleteSubnetResult(outcome.result())); + else + return DeleteSubnetOutcome(outcome.error()); +} + +void EfloClient::deleteSubnetAsync(const DeleteSubnetRequest& request, const DeleteSubnetAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteSubnet(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EfloClient::DeleteSubnetOutcomeCallable EfloClient::deleteSubnetCallable(const DeleteSubnetRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteSubnet(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +EfloClient::DeleteVpdOutcome EfloClient::deleteVpd(const DeleteVpdRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteVpdOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteVpdOutcome(DeleteVpdResult(outcome.result())); + else + return DeleteVpdOutcome(outcome.error()); +} + +void EfloClient::deleteVpdAsync(const DeleteVpdRequest& request, const DeleteVpdAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteVpd(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EfloClient::DeleteVpdOutcomeCallable EfloClient::deleteVpdCallable(const DeleteVpdRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteVpd(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +EfloClient::GetSubnetOutcome EfloClient::getSubnet(const GetSubnetRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetSubnetOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetSubnetOutcome(GetSubnetResult(outcome.result())); + else + return GetSubnetOutcome(outcome.error()); +} + +void EfloClient::getSubnetAsync(const GetSubnetRequest& request, const GetSubnetAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getSubnet(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EfloClient::GetSubnetOutcomeCallable EfloClient::getSubnetCallable(const GetSubnetRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getSubnet(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +EfloClient::GetVccOutcome EfloClient::getVcc(const GetVccRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetVccOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetVccOutcome(GetVccResult(outcome.result())); + else + return GetVccOutcome(outcome.error()); +} + +void EfloClient::getVccAsync(const GetVccRequest& request, const GetVccAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getVcc(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EfloClient::GetVccOutcomeCallable EfloClient::getVccCallable(const GetVccRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getVcc(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +EfloClient::GetVpdOutcome EfloClient::getVpd(const GetVpdRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetVpdOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetVpdOutcome(GetVpdResult(outcome.result())); + else + return GetVpdOutcome(outcome.error()); +} + +void EfloClient::getVpdAsync(const GetVpdRequest& request, const GetVpdAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getVpd(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EfloClient::GetVpdOutcomeCallable EfloClient::getVpdCallable(const GetVpdRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getVpd(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +EfloClient::InitializeVccOutcome EfloClient::initializeVcc(const InitializeVccRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return InitializeVccOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return InitializeVccOutcome(InitializeVccResult(outcome.result())); + else + return InitializeVccOutcome(outcome.error()); +} + +void EfloClient::initializeVccAsync(const InitializeVccRequest& request, const InitializeVccAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, initializeVcc(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EfloClient::InitializeVccOutcomeCallable EfloClient::initializeVccCallable(const InitializeVccRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->initializeVcc(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +EfloClient::ListSubnetsOutcome EfloClient::listSubnets(const ListSubnetsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListSubnetsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListSubnetsOutcome(ListSubnetsResult(outcome.result())); + else + return ListSubnetsOutcome(outcome.error()); +} + +void EfloClient::listSubnetsAsync(const ListSubnetsRequest& request, const ListSubnetsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listSubnets(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EfloClient::ListSubnetsOutcomeCallable EfloClient::listSubnetsCallable(const ListSubnetsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listSubnets(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +EfloClient::ListVccsOutcome EfloClient::listVccs(const ListVccsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListVccsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListVccsOutcome(ListVccsResult(outcome.result())); + else + return ListVccsOutcome(outcome.error()); +} + +void EfloClient::listVccsAsync(const ListVccsRequest& request, const ListVccsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listVccs(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EfloClient::ListVccsOutcomeCallable EfloClient::listVccsCallable(const ListVccsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listVccs(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +EfloClient::ListVpdsOutcome EfloClient::listVpds(const ListVpdsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListVpdsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListVpdsOutcome(ListVpdsResult(outcome.result())); + else + return ListVpdsOutcome(outcome.error()); +} + +void EfloClient::listVpdsAsync(const ListVpdsRequest& request, const ListVpdsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listVpds(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EfloClient::ListVpdsOutcomeCallable EfloClient::listVpdsCallable(const ListVpdsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listVpds(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +EfloClient::UpdateSubnetOutcome EfloClient::updateSubnet(const UpdateSubnetRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UpdateSubnetOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UpdateSubnetOutcome(UpdateSubnetResult(outcome.result())); + else + return UpdateSubnetOutcome(outcome.error()); +} + +void EfloClient::updateSubnetAsync(const UpdateSubnetRequest& request, const UpdateSubnetAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, updateSubnet(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EfloClient::UpdateSubnetOutcomeCallable EfloClient::updateSubnetCallable(const UpdateSubnetRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->updateSubnet(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +EfloClient::UpdateVccOutcome EfloClient::updateVcc(const UpdateVccRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UpdateVccOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UpdateVccOutcome(UpdateVccResult(outcome.result())); + else + return UpdateVccOutcome(outcome.error()); +} + +void EfloClient::updateVccAsync(const UpdateVccRequest& request, const UpdateVccAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, updateVcc(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EfloClient::UpdateVccOutcomeCallable EfloClient::updateVccCallable(const UpdateVccRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->updateVcc(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +EfloClient::UpdateVpdOutcome EfloClient::updateVpd(const UpdateVpdRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UpdateVpdOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UpdateVpdOutcome(UpdateVpdResult(outcome.result())); + else + return UpdateVpdOutcome(outcome.error()); +} + +void EfloClient::updateVpdAsync(const UpdateVpdRequest& request, const UpdateVpdAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, updateVpd(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +EfloClient::UpdateVpdOutcomeCallable EfloClient::updateVpdCallable(const UpdateVpdRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->updateVpd(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + diff --git a/eflo/src/model/CreateSubnetRequest.cc b/eflo/src/model/CreateSubnetRequest.cc new file mode 100644 index 000000000..0396820f4 --- /dev/null +++ b/eflo/src/model/CreateSubnetRequest.cc @@ -0,0 +1,81 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Eflo::Model::CreateSubnetRequest; + +CreateSubnetRequest::CreateSubnetRequest() + : RpcServiceRequest("eflo", "2022-05-30", "CreateSubnet") { + setMethod(HttpRequest::Method::Post); +} + +CreateSubnetRequest::~CreateSubnetRequest() {} + +std::string CreateSubnetRequest::getType() const { + return type_; +} + +void CreateSubnetRequest::setType(const std::string &type) { + type_ = type; + setBodyParameter(std::string("Type"), type); +} + +std::string CreateSubnetRequest::getRegionId() const { + return regionId_; +} + +void CreateSubnetRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setBodyParameter(std::string("RegionId"), regionId); +} + +std::string CreateSubnetRequest::getVpdId() const { + return vpdId_; +} + +void CreateSubnetRequest::setVpdId(const std::string &vpdId) { + vpdId_ = vpdId; + setBodyParameter(std::string("VpdId"), vpdId); +} + +std::string CreateSubnetRequest::getName() const { + return name_; +} + +void CreateSubnetRequest::setName(const std::string &name) { + name_ = name; + setBodyParameter(std::string("Name"), name); +} + +std::string CreateSubnetRequest::getZoneId() const { + return zoneId_; +} + +void CreateSubnetRequest::setZoneId(const std::string &zoneId) { + zoneId_ = zoneId; + setBodyParameter(std::string("ZoneId"), zoneId); +} + +std::string CreateSubnetRequest::getCidr() const { + return cidr_; +} + +void CreateSubnetRequest::setCidr(const std::string &cidr) { + cidr_ = cidr; + setBodyParameter(std::string("Cidr"), cidr); +} + diff --git a/eflo/src/model/CreateSubnetResult.cc b/eflo/src/model/CreateSubnetResult.cc new file mode 100644 index 000000000..0e8be2d9b --- /dev/null +++ b/eflo/src/model/CreateSubnetResult.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::Eflo; +using namespace AlibabaCloud::Eflo::Model; + +CreateSubnetResult::CreateSubnetResult() : + ServiceResult() +{} + +CreateSubnetResult::CreateSubnetResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateSubnetResult::~CreateSubnetResult() +{} + +void CreateSubnetResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto contentNode = value["Content"]; + if(!contentNode["SubnetId"].isNull()) + content_.subnetId = contentNode["SubnetId"].asString(); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string CreateSubnetResult::getMessage()const +{ + return message_; +} + +CreateSubnetResult::Content CreateSubnetResult::getContent()const +{ + return content_; +} + +int CreateSubnetResult::getCode()const +{ + return code_; +} + diff --git a/eflo/src/model/CreateVccRequest.cc b/eflo/src/model/CreateVccRequest.cc new file mode 100644 index 000000000..0463b8e85 --- /dev/null +++ b/eflo/src/model/CreateVccRequest.cc @@ -0,0 +1,108 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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 AlibabaCloud::Eflo::Model::CreateVccRequest; + +CreateVccRequest::CreateVccRequest() + : RpcServiceRequest("eflo", "2022-05-30", "CreateVcc") { + setMethod(HttpRequest::Method::Post); +} + +CreateVccRequest::~CreateVccRequest() {} + +std::string CreateVccRequest::getBgpCidr() const { + return bgpCidr_; +} + +void CreateVccRequest::setBgpCidr(const std::string &bgpCidr) { + bgpCidr_ = bgpCidr; + setBodyParameter(std::string("BgpCidr"), bgpCidr); +} + +std::string CreateVccRequest::getCenId() const { + return cenId_; +} + +void CreateVccRequest::setCenId(const std::string &cenId) { + cenId_ = cenId; + setBodyParameter(std::string("CenId"), cenId); +} + +std::string CreateVccRequest::getDescription() const { + return description_; +} + +void CreateVccRequest::setDescription(const std::string &description) { + description_ = description; + setBodyParameter(std::string("Description"), description); +} + +bool CreateVccRequest::getAccessCouldService() const { + return accessCouldService_; +} + +void CreateVccRequest::setAccessCouldService(bool accessCouldService) { + accessCouldService_ = accessCouldService; + setBodyParameter(std::string("AccessCouldService"), accessCouldService ? "true" : "false"); +} + +std::string CreateVccRequest::getRegionId() const { + return regionId_; +} + +void CreateVccRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setBodyParameter(std::string("RegionId"), regionId); +} + +std::string CreateVccRequest::getVccId() const { + return vccId_; +} + +void CreateVccRequest::setVccId(const std::string &vccId) { + vccId_ = vccId; + setBodyParameter(std::string("VccId"), vccId); +} + +std::string CreateVccRequest::getVSwitchId() const { + return vSwitchId_; +} + +void CreateVccRequest::setVSwitchId(const std::string &vSwitchId) { + vSwitchId_ = vSwitchId; + setBodyParameter(std::string("VSwitchId"), vSwitchId); +} + +std::string CreateVccRequest::getVpdId() const { + return vpdId_; +} + +void CreateVccRequest::setVpdId(const std::string &vpdId) { + vpdId_ = vpdId; + setBodyParameter(std::string("VpdId"), vpdId); +} + +std::string CreateVccRequest::getVpcId() const { + return vpcId_; +} + +void CreateVccRequest::setVpcId(const std::string &vpcId) { + vpcId_ = vpcId; + setBodyParameter(std::string("VpcId"), vpcId); +} + diff --git a/eflo/src/model/CreateVccResult.cc b/eflo/src/model/CreateVccResult.cc new file mode 100644 index 000000000..562ad35a9 --- /dev/null +++ b/eflo/src/model/CreateVccResult.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::Eflo; +using namespace AlibabaCloud::Eflo::Model; + +CreateVccResult::CreateVccResult() : + ServiceResult() +{} + +CreateVccResult::CreateVccResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateVccResult::~CreateVccResult() +{} + +void CreateVccResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto contentNode = value["Content"]; + if(!contentNode["VccId"].isNull()) + content_.vccId = contentNode["VccId"].asString(); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string CreateVccResult::getMessage()const +{ + return message_; +} + +CreateVccResult::Content CreateVccResult::getContent()const +{ + return content_; +} + +int CreateVccResult::getCode()const +{ + return code_; +} + diff --git a/eflo/src/model/CreateVpdRequest.cc b/eflo/src/model/CreateVpdRequest.cc new file mode 100644 index 000000000..0209e8b0c --- /dev/null +++ b/eflo/src/model/CreateVpdRequest.cc @@ -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. + */ + +#include + +using AlibabaCloud::Eflo::Model::CreateVpdRequest; + +CreateVpdRequest::CreateVpdRequest() + : RpcServiceRequest("eflo", "2022-05-30", "CreateVpd") { + setMethod(HttpRequest::Method::Post); +} + +CreateVpdRequest::~CreateVpdRequest() {} + +std::string CreateVpdRequest::getRegionId() const { + return regionId_; +} + +void CreateVpdRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setBodyParameter(std::string("RegionId"), regionId); +} + +std::string CreateVpdRequest::getName() const { + return name_; +} + +void CreateVpdRequest::setName(const std::string &name) { + name_ = name; + setBodyParameter(std::string("Name"), name); +} + +std::string CreateVpdRequest::getCidr() const { + return cidr_; +} + +void CreateVpdRequest::setCidr(const std::string &cidr) { + cidr_ = cidr; + setBodyParameter(std::string("Cidr"), cidr); +} + +std::vector CreateVpdRequest::getSubnets() const { + return subnets_; +} + +void CreateVpdRequest::setSubnets(const std::vector &subnets) { + subnets_ = subnets; + for(int dep1 = 0; dep1 != subnets.size(); dep1++) { + auto subnetsObj = subnets.at(dep1); + std::string subnetsObjStr = std::string("Subnets") + "." + std::to_string(dep1 + 1); + setBodyParameter(subnetsObjStr + ".RegionId", subnetsObj.regionId); + setBodyParameter(subnetsObjStr + ".Name", subnetsObj.name); + setBodyParameter(subnetsObjStr + ".ZoneId", subnetsObj.zoneId); + setBodyParameter(subnetsObjStr + ".Cidr", subnetsObj.cidr); + setBodyParameter(subnetsObjStr + ".Type", subnetsObj.type); + } +} + diff --git a/eflo/src/model/CreateVpdResult.cc b/eflo/src/model/CreateVpdResult.cc new file mode 100644 index 000000000..6ebb3d470 --- /dev/null +++ b/eflo/src/model/CreateVpdResult.cc @@ -0,0 +1,69 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Eflo; +using namespace AlibabaCloud::Eflo::Model; + +CreateVpdResult::CreateVpdResult() : + ServiceResult() +{} + +CreateVpdResult::CreateVpdResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateVpdResult::~CreateVpdResult() +{} + +void CreateVpdResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto contentNode = value["Content"]; + if(!contentNode["VpdId"].isNull()) + content_.vpdId = contentNode["VpdId"].asString(); + auto allSubnetIds = contentNode["SubnetIds"]["SubnetId"]; + for (auto value : allSubnetIds) + content_.subnetIds.push_back(value.asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string CreateVpdResult::getMessage()const +{ + return message_; +} + +CreateVpdResult::Content CreateVpdResult::getContent()const +{ + return content_; +} + +int CreateVpdResult::getCode()const +{ + return code_; +} + diff --git a/eflo/src/model/DeleteSubnetRequest.cc b/eflo/src/model/DeleteSubnetRequest.cc new file mode 100644 index 000000000..d8eccc4a5 --- /dev/null +++ b/eflo/src/model/DeleteSubnetRequest.cc @@ -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. + */ + +#include + +using AlibabaCloud::Eflo::Model::DeleteSubnetRequest; + +DeleteSubnetRequest::DeleteSubnetRequest() + : RpcServiceRequest("eflo", "2022-05-30", "DeleteSubnet") { + setMethod(HttpRequest::Method::Post); +} + +DeleteSubnetRequest::~DeleteSubnetRequest() {} + +std::string DeleteSubnetRequest::getSubnetId() const { + return subnetId_; +} + +void DeleteSubnetRequest::setSubnetId(const std::string &subnetId) { + subnetId_ = subnetId; + setBodyParameter(std::string("SubnetId"), subnetId); +} + +std::string DeleteSubnetRequest::getRegionId() const { + return regionId_; +} + +void DeleteSubnetRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setBodyParameter(std::string("RegionId"), regionId); +} + +std::string DeleteSubnetRequest::getVpdId() const { + return vpdId_; +} + +void DeleteSubnetRequest::setVpdId(const std::string &vpdId) { + vpdId_ = vpdId; + setBodyParameter(std::string("VpdId"), vpdId); +} + +std::string DeleteSubnetRequest::getZoneId() const { + return zoneId_; +} + +void DeleteSubnetRequest::setZoneId(const std::string &zoneId) { + zoneId_ = zoneId; + setBodyParameter(std::string("ZoneId"), zoneId); +} + diff --git a/eflo/src/model/DeleteSubnetResult.cc b/eflo/src/model/DeleteSubnetResult.cc new file mode 100644 index 000000000..2c9b3a72c --- /dev/null +++ b/eflo/src/model/DeleteSubnetResult.cc @@ -0,0 +1,44 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Eflo; +using namespace AlibabaCloud::Eflo::Model; + +DeleteSubnetResult::DeleteSubnetResult() : + ServiceResult() +{} + +DeleteSubnetResult::DeleteSubnetResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteSubnetResult::~DeleteSubnetResult() +{} + +void DeleteSubnetResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/eflo/src/model/DeleteVpdRequest.cc b/eflo/src/model/DeleteVpdRequest.cc new file mode 100644 index 000000000..5869d7c67 --- /dev/null +++ b/eflo/src/model/DeleteVpdRequest.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 + +using AlibabaCloud::Eflo::Model::DeleteVpdRequest; + +DeleteVpdRequest::DeleteVpdRequest() + : RpcServiceRequest("eflo", "2022-05-30", "DeleteVpd") { + setMethod(HttpRequest::Method::Post); +} + +DeleteVpdRequest::~DeleteVpdRequest() {} + +std::string DeleteVpdRequest::getRegionId() const { + return regionId_; +} + +void DeleteVpdRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setBodyParameter(std::string("RegionId"), regionId); +} + +std::string DeleteVpdRequest::getVpdId() const { + return vpdId_; +} + +void DeleteVpdRequest::setVpdId(const std::string &vpdId) { + vpdId_ = vpdId; + setBodyParameter(std::string("VpdId"), vpdId); +} + diff --git a/eflo/src/model/DeleteVpdResult.cc b/eflo/src/model/DeleteVpdResult.cc new file mode 100644 index 000000000..04a31a6a2 --- /dev/null +++ b/eflo/src/model/DeleteVpdResult.cc @@ -0,0 +1,44 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Eflo; +using namespace AlibabaCloud::Eflo::Model; + +DeleteVpdResult::DeleteVpdResult() : + ServiceResult() +{} + +DeleteVpdResult::DeleteVpdResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteVpdResult::~DeleteVpdResult() +{} + +void DeleteVpdResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/eflo/src/model/GetSubnetRequest.cc b/eflo/src/model/GetSubnetRequest.cc new file mode 100644 index 000000000..35718ecd9 --- /dev/null +++ b/eflo/src/model/GetSubnetRequest.cc @@ -0,0 +1,36 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Eflo::Model::GetSubnetRequest; + +GetSubnetRequest::GetSubnetRequest() + : RpcServiceRequest("eflo", "2022-05-30", "GetSubnet") { + setMethod(HttpRequest::Method::Post); +} + +GetSubnetRequest::~GetSubnetRequest() {} + +std::string GetSubnetRequest::getSubnetId() const { + return subnetId_; +} + +void GetSubnetRequest::setSubnetId(const std::string &subnetId) { + subnetId_ = subnetId; + setBodyParameter(std::string("SubnetId"), subnetId); +} + diff --git a/eflo/src/model/GetSubnetResult.cc b/eflo/src/model/GetSubnetResult.cc new file mode 100644 index 000000000..6513e660d --- /dev/null +++ b/eflo/src/model/GetSubnetResult.cc @@ -0,0 +1,105 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::Eflo; +using namespace AlibabaCloud::Eflo::Model; + +GetSubnetResult::GetSubnetResult() : + ServiceResult() +{} + +GetSubnetResult::GetSubnetResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetSubnetResult::~GetSubnetResult() +{} + +void GetSubnetResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto contentNode = value["Content"]; + if(!contentNode["Id"].isNull()) + content_.id = std::stol(contentNode["Id"].asString()); + if(!contentNode["GmtCreate"].isNull()) + content_.gmtCreate = contentNode["GmtCreate"].asString(); + if(!contentNode["GmtModified"].isNull()) + content_.gmtModified = contentNode["GmtModified"].asString(); + if(!contentNode["TenantId"].isNull()) + content_.tenantId = contentNode["TenantId"].asString(); + if(!contentNode["RegionId"].isNull()) + content_.regionId = contentNode["RegionId"].asString(); + if(!contentNode["ZoneId"].isNull()) + content_.zoneId = contentNode["ZoneId"].asString(); + if(!contentNode["SubnetId"].isNull()) + content_.subnetId = contentNode["SubnetId"].asString(); + if(!contentNode["Name"].isNull()) + content_.name = contentNode["Name"].asString(); + if(!contentNode["Cidr"].isNull()) + content_.cidr = contentNode["Cidr"].asString(); + if(!contentNode["Description"].isNull()) + content_.description = contentNode["Description"].asString(); + if(!contentNode["VpdId"].isNull()) + content_.vpdId = contentNode["VpdId"].asString(); + if(!contentNode["Type"].isNull()) + content_.type = contentNode["Type"].asString(); + if(!contentNode["Status"].isNull()) + content_.status = contentNode["Status"].asString(); + if(!contentNode["Message"].isNull()) + content_.message = contentNode["Message"].asString(); + if(!contentNode["NcCount"].isNull()) + content_.ncCount = std::stol(contentNode["NcCount"].asString()); + if(!contentNode["LbCount"].isNull()) + content_.lbCount = std::stol(contentNode["LbCount"].asString()); + auto vpdBaseInfoNode = contentNode["VpdBaseInfo"]; + if(!vpdBaseInfoNode["VpdId"].isNull()) + content_.vpdBaseInfo.vpdId = vpdBaseInfoNode["VpdId"].asString(); + if(!vpdBaseInfoNode["Name"].isNull()) + content_.vpdBaseInfo.name = vpdBaseInfoNode["Name"].asString(); + if(!vpdBaseInfoNode["Cidr"].isNull()) + content_.vpdBaseInfo.cidr = vpdBaseInfoNode["Cidr"].asString(); + if(!vpdBaseInfoNode["GmtCreate"].isNull()) + content_.vpdBaseInfo.gmtCreate = vpdBaseInfoNode["GmtCreate"].asString(); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string GetSubnetResult::getMessage()const +{ + return message_; +} + +GetSubnetResult::Content GetSubnetResult::getContent()const +{ + return content_; +} + +int GetSubnetResult::getCode()const +{ + return code_; +} + diff --git a/eflo/src/model/GetVccRequest.cc b/eflo/src/model/GetVccRequest.cc new file mode 100644 index 000000000..45e60ff36 --- /dev/null +++ b/eflo/src/model/GetVccRequest.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 + +using AlibabaCloud::Eflo::Model::GetVccRequest; + +GetVccRequest::GetVccRequest() + : RpcServiceRequest("eflo", "2022-05-30", "GetVcc") { + setMethod(HttpRequest::Method::Post); +} + +GetVccRequest::~GetVccRequest() {} + +std::string GetVccRequest::getRegionId() const { + return regionId_; +} + +void GetVccRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setBodyParameter(std::string("RegionId"), regionId); +} + +std::string GetVccRequest::getVccId() const { + return vccId_; +} + +void GetVccRequest::setVccId(const std::string &vccId) { + vccId_ = vccId; + setBodyParameter(std::string("VccId"), vccId); +} + diff --git a/eflo/src/model/GetVccResult.cc b/eflo/src/model/GetVccResult.cc new file mode 100644 index 000000000..d60bde09a --- /dev/null +++ b/eflo/src/model/GetVccResult.cc @@ -0,0 +1,165 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::Eflo; +using namespace AlibabaCloud::Eflo::Model; + +GetVccResult::GetVccResult() : + ServiceResult() +{} + +GetVccResult::GetVccResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetVccResult::~GetVccResult() +{} + +void GetVccResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto contentNode = value["Content"]; + if(!contentNode["TenantId"].isNull()) + content_.tenantId = contentNode["TenantId"].asString(); + if(!contentNode["RegionId"].isNull()) + content_.regionId = contentNode["RegionId"].asString(); + if(!contentNode["VccId"].isNull()) + content_.vccId = contentNode["VccId"].asString(); + if(!contentNode["VpdId"].isNull()) + content_.vpdId = contentNode["VpdId"].asString(); + if(!contentNode["VpcId"].isNull()) + content_.vpcId = contentNode["VpcId"].asString(); + if(!contentNode["VSwitchId"].isNull()) + content_.vSwitchId = contentNode["VSwitchId"].asString(); + if(!contentNode["CenId"].isNull()) + content_.cenId = contentNode["CenId"].asString(); + if(!contentNode["VccName"].isNull()) + content_.vccName = contentNode["VccName"].asString(); + if(!contentNode["AccessPointId"].isNull()) + content_.accessPointId = contentNode["AccessPointId"].asString(); + if(!contentNode["LineOperator"].isNull()) + content_.lineOperator = contentNode["LineOperator"].asString(); + if(!contentNode["Spec"].isNull()) + content_.spec = contentNode["Spec"].asString(); + if(!contentNode["PortType"].isNull()) + content_.portType = contentNode["PortType"].asString(); + if(!contentNode["PricingCycle"].isNull()) + content_.pricingCycle = contentNode["PricingCycle"].asString(); + if(!contentNode["PayType"].isNull()) + content_.payType = contentNode["PayType"].asString(); + if(!contentNode["Duration"].isNull()) + content_.duration = contentNode["Duration"].asString(); + if(!contentNode["Status"].isNull()) + content_.status = contentNode["Status"].asString(); + if(!contentNode["CurrentNode"].isNull()) + content_.currentNode = contentNode["CurrentNode"].asString(); + if(!contentNode["InternetChargeType"].isNull()) + content_.internetChargeType = contentNode["InternetChargeType"].asString(); + if(!contentNode["BandwidthStr"].isNull()) + content_.bandwidthStr = contentNode["BandwidthStr"].asString(); + if(!contentNode["Message"].isNull()) + content_.message = contentNode["Message"].asString(); + if(!contentNode["CreateTime"].isNull()) + content_.createTime = contentNode["CreateTime"].asString(); + if(!contentNode["GmtModified"].isNull()) + content_.gmtModified = contentNode["GmtModified"].asString(); + if(!contentNode["CommodityCode"].isNull()) + content_.commodityCode = contentNode["CommodityCode"].asString(); + if(!contentNode["BgpCidr"].isNull()) + content_.bgpCidr = contentNode["BgpCidr"].asString(); + auto allAliyunRouterInfoNode = contentNode["AliyunRouterInfo"]["AliyunRouterInfoItem"]; + for (auto contentNodeAliyunRouterInfoAliyunRouterInfoItem : allAliyunRouterInfoNode) + { + Content::AliyunRouterInfoItem aliyunRouterInfoItemObject; + if(!contentNodeAliyunRouterInfoAliyunRouterInfoItem["PcId"].isNull()) + aliyunRouterInfoItemObject.pcId = contentNodeAliyunRouterInfoAliyunRouterInfoItem["PcId"].asString(); + if(!contentNodeAliyunRouterInfoAliyunRouterInfoItem["VbrId"].isNull()) + aliyunRouterInfoItemObject.vbrId = contentNodeAliyunRouterInfoAliyunRouterInfoItem["VbrId"].asString(); + if(!contentNodeAliyunRouterInfoAliyunRouterInfoItem["LocalGatewayIp"].isNull()) + aliyunRouterInfoItemObject.localGatewayIp = contentNodeAliyunRouterInfoAliyunRouterInfoItem["LocalGatewayIp"].asString(); + if(!contentNodeAliyunRouterInfoAliyunRouterInfoItem["PeerGatewayIp"].isNull()) + aliyunRouterInfoItemObject.peerGatewayIp = contentNodeAliyunRouterInfoAliyunRouterInfoItem["PeerGatewayIp"].asString(); + if(!contentNodeAliyunRouterInfoAliyunRouterInfoItem["Mask"].isNull()) + aliyunRouterInfoItemObject.mask = contentNodeAliyunRouterInfoAliyunRouterInfoItem["Mask"].asString(); + if(!contentNodeAliyunRouterInfoAliyunRouterInfoItem["VlanId"].isNull()) + aliyunRouterInfoItemObject.vlanId = contentNodeAliyunRouterInfoAliyunRouterInfoItem["VlanId"].asString(); + content_.aliyunRouterInfo.push_back(aliyunRouterInfoItemObject); + } + auto allCisRouterInfoNode = contentNode["CisRouterInfo"]["CisRouterInfoItem"]; + for (auto contentNodeCisRouterInfoCisRouterInfoItem : allCisRouterInfoNode) + { + Content::CisRouterInfoItem cisRouterInfoItemObject; + if(!contentNodeCisRouterInfoCisRouterInfoItem["CcrId"].isNull()) + cisRouterInfoItemObject.ccrId = contentNodeCisRouterInfoCisRouterInfoItem["CcrId"].asString(); + auto allCcInfosNode = contentNodeCisRouterInfoCisRouterInfoItem["CcInfos"]["CcInfo"]; + for (auto contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo : allCcInfosNode) + { + Content::CisRouterInfoItem::CcInfo ccInfosObject; + if(!contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["CcId"].isNull()) + ccInfosObject.ccId = contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["CcId"].asString(); + if(!contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["VlanId"].isNull()) + ccInfosObject.vlanId = contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["VlanId"].asString(); + if(!contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["LocalGatewayIp"].isNull()) + ccInfosObject.localGatewayIp = contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["LocalGatewayIp"].asString(); + if(!contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["RemoteGatewayIp"].isNull()) + ccInfosObject.remoteGatewayIp = contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["RemoteGatewayIp"].asString(); + if(!contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["SubnetMask"].isNull()) + ccInfosObject.subnetMask = contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["SubnetMask"].asString(); + if(!contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["Status"].isNull()) + ccInfosObject.status = contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["Status"].asString(); + cisRouterInfoItemObject.ccInfos.push_back(ccInfosObject); + } + content_.cisRouterInfo.push_back(cisRouterInfoItemObject); + } + auto vpdBaseInfoNode = contentNode["VpdBaseInfo"]; + if(!vpdBaseInfoNode["VpdId"].isNull()) + content_.vpdBaseInfo.vpdId = vpdBaseInfoNode["VpdId"].asString(); + if(!vpdBaseInfoNode["Name"].isNull()) + content_.vpdBaseInfo.name = vpdBaseInfoNode["Name"].asString(); + if(!vpdBaseInfoNode["Cidr"].isNull()) + content_.vpdBaseInfo.cidr = vpdBaseInfoNode["Cidr"].asString(); + if(!vpdBaseInfoNode["GmtCreate"].isNull()) + content_.vpdBaseInfo.gmtCreate = vpdBaseInfoNode["GmtCreate"].asString(); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string GetVccResult::getMessage()const +{ + return message_; +} + +GetVccResult::Content GetVccResult::getContent()const +{ + return content_; +} + +int GetVccResult::getCode()const +{ + return code_; +} + diff --git a/eflo/src/model/GetVpdRequest.cc b/eflo/src/model/GetVpdRequest.cc new file mode 100644 index 000000000..18d47a1ec --- /dev/null +++ b/eflo/src/model/GetVpdRequest.cc @@ -0,0 +1,36 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Eflo::Model::GetVpdRequest; + +GetVpdRequest::GetVpdRequest() + : RpcServiceRequest("eflo", "2022-05-30", "GetVpd") { + setMethod(HttpRequest::Method::Post); +} + +GetVpdRequest::~GetVpdRequest() {} + +std::string GetVpdRequest::getVpdId() const { + return vpdId_; +} + +void GetVpdRequest::setVpdId(const std::string &vpdId) { + vpdId_ = vpdId; + setBodyParameter(std::string("VpdId"), vpdId); +} + diff --git a/eflo/src/model/GetVpdResult.cc b/eflo/src/model/GetVpdResult.cc new file mode 100644 index 000000000..12b99e772 --- /dev/null +++ b/eflo/src/model/GetVpdResult.cc @@ -0,0 +1,94 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::Eflo; +using namespace AlibabaCloud::Eflo::Model; + +GetVpdResult::GetVpdResult() : + ServiceResult() +{} + +GetVpdResult::GetVpdResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetVpdResult::~GetVpdResult() +{} + +void GetVpdResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto contentNode = value["Content"]; + if(!contentNode["RegionId"].isNull()) + content_.regionId = contentNode["RegionId"].asString(); + if(!contentNode["VpdId"].isNull()) + content_.vpdId = contentNode["VpdId"].asString(); + if(!contentNode["Name"].isNull()) + content_.name = contentNode["Name"].asString(); + if(!contentNode["Cidr"].isNull()) + content_.cidr = contentNode["Cidr"].asString(); + if(!contentNode["ServiceCidr"].isNull()) + content_.serviceCidr = contentNode["ServiceCidr"].asString(); + if(!contentNode["Status"].isNull()) + content_.status = contentNode["Status"].asString(); + if(!contentNode["Description"].isNull()) + content_.description = contentNode["Description"].asString(); + if(!contentNode["Message"].isNull()) + content_.message = contentNode["Message"].asString(); + if(!contentNode["Route"].isNull()) + content_.route = std::stoi(contentNode["Route"].asString()); + if(!contentNode["NcCount"].isNull()) + content_.ncCount = std::stol(contentNode["NcCount"].asString()); + if(!contentNode["SubnetCount"].isNull()) + content_.subnetCount = std::stol(contentNode["SubnetCount"].asString()); + if(!contentNode["LbCount"].isNull()) + content_.lbCount = std::stol(contentNode["LbCount"].asString()); + if(!contentNode["VccCount"].isNull()) + content_.vccCount = std::stol(contentNode["VccCount"].asString()); + if(!contentNode["GmtCreate"].isNull()) + content_.gmtCreate = contentNode["GmtCreate"].asString(); + if(!contentNode["GmtModified"].isNull()) + content_.gmtModified = contentNode["GmtModified"].asString(); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string GetVpdResult::getMessage()const +{ + return message_; +} + +GetVpdResult::Content GetVpdResult::getContent()const +{ + return content_; +} + +int GetVpdResult::getCode()const +{ + return code_; +} + diff --git a/eflo/src/model/InitializeVccRequest.cc b/eflo/src/model/InitializeVccRequest.cc new file mode 100644 index 000000000..0ed98c6a0 --- /dev/null +++ b/eflo/src/model/InitializeVccRequest.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 AlibabaCloud::Eflo::Model::InitializeVccRequest; + +InitializeVccRequest::InitializeVccRequest() + : RpcServiceRequest("eflo", "2022-05-30", "InitializeVcc") { + setMethod(HttpRequest::Method::Post); +} + +InitializeVccRequest::~InitializeVccRequest() {} + diff --git a/eflo/src/model/InitializeVccResult.cc b/eflo/src/model/InitializeVccResult.cc new file mode 100644 index 000000000..14140179c --- /dev/null +++ b/eflo/src/model/InitializeVccResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Eflo; +using namespace AlibabaCloud::Eflo::Model; + +InitializeVccResult::InitializeVccResult() : + ServiceResult() +{} + +InitializeVccResult::InitializeVccResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +InitializeVccResult::~InitializeVccResult() +{} + +void InitializeVccResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto contentNode = value["Content"]; + if(!contentNode["RoleName"].isNull()) + content_.roleName = contentNode["RoleName"].asString(); + if(!contentNode["RequestId"].isNull()) + content_.requestId = contentNode["RequestId"].asString(); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string InitializeVccResult::getMessage()const +{ + return message_; +} + +InitializeVccResult::Content InitializeVccResult::getContent()const +{ + return content_; +} + +int InitializeVccResult::getCode()const +{ + return code_; +} + diff --git a/eflo/src/model/ListSubnetsRequest.cc b/eflo/src/model/ListSubnetsRequest.cc new file mode 100644 index 000000000..f51cf6492 --- /dev/null +++ b/eflo/src/model/ListSubnetsRequest.cc @@ -0,0 +1,117 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Eflo::Model::ListSubnetsRequest; + +ListSubnetsRequest::ListSubnetsRequest() + : RpcServiceRequest("eflo", "2022-05-30", "ListSubnets") { + setMethod(HttpRequest::Method::Post); +} + +ListSubnetsRequest::~ListSubnetsRequest() {} + +std::string ListSubnetsRequest::getType() const { + return type_; +} + +void ListSubnetsRequest::setType(const std::string &type) { + type_ = type; + setBodyParameter(std::string("Type"), type); +} + +int ListSubnetsRequest::getPageNumber() const { + return pageNumber_; +} + +void ListSubnetsRequest::setPageNumber(int pageNumber) { + pageNumber_ = pageNumber; + setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber)); +} + +std::string ListSubnetsRequest::getRegionId() const { + return regionId_; +} + +void ListSubnetsRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setBodyParameter(std::string("RegionId"), regionId); +} + +int ListSubnetsRequest::getPageSize() const { + return pageSize_; +} + +void ListSubnetsRequest::setPageSize(int pageSize) { + pageSize_ = pageSize; + setBodyParameter(std::string("PageSize"), std::to_string(pageSize)); +} + +std::string ListSubnetsRequest::getSubnetId() const { + return subnetId_; +} + +void ListSubnetsRequest::setSubnetId(const std::string &subnetId) { + subnetId_ = subnetId; + setBodyParameter(std::string("SubnetId"), subnetId); +} + +std::string ListSubnetsRequest::getVpdId() const { + return vpdId_; +} + +void ListSubnetsRequest::setVpdId(const std::string &vpdId) { + vpdId_ = vpdId; + setBodyParameter(std::string("VpdId"), vpdId); +} + +bool ListSubnetsRequest::getEnablePage() const { + return enablePage_; +} + +void ListSubnetsRequest::setEnablePage(bool enablePage) { + enablePage_ = enablePage; + setBodyParameter(std::string("EnablePage"), enablePage ? "true" : "false"); +} + +std::string ListSubnetsRequest::getName() const { + return name_; +} + +void ListSubnetsRequest::setName(const std::string &name) { + name_ = name; + setBodyParameter(std::string("Name"), name); +} + +std::string ListSubnetsRequest::getZoneId() const { + return zoneId_; +} + +void ListSubnetsRequest::setZoneId(const std::string &zoneId) { + zoneId_ = zoneId; + setBodyParameter(std::string("ZoneId"), zoneId); +} + +std::string ListSubnetsRequest::getStatus() const { + return status_; +} + +void ListSubnetsRequest::setStatus(const std::string &status) { + status_ = status; + setBodyParameter(std::string("Status"), status); +} + diff --git a/eflo/src/model/ListSubnetsResult.cc b/eflo/src/model/ListSubnetsResult.cc new file mode 100644 index 000000000..2534ed69a --- /dev/null +++ b/eflo/src/model/ListSubnetsResult.cc @@ -0,0 +1,109 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::Eflo; +using namespace AlibabaCloud::Eflo::Model; + +ListSubnetsResult::ListSubnetsResult() : + ServiceResult() +{} + +ListSubnetsResult::ListSubnetsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListSubnetsResult::~ListSubnetsResult() +{} + +void ListSubnetsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto contentNode = value["Content"]; + if(!contentNode["Total"].isNull()) + content_.total = std::stol(contentNode["Total"].asString()); + auto allDataNode = contentNode["Data"]["DataItem"]; + for (auto contentNodeDataDataItem : allDataNode) + { + Content::DataItem dataItemObject; + if(!contentNodeDataDataItem["Id"].isNull()) + dataItemObject.id = std::stol(contentNodeDataDataItem["Id"].asString()); + if(!contentNodeDataDataItem["GmtCreate"].isNull()) + dataItemObject.gmtCreate = contentNodeDataDataItem["GmtCreate"].asString(); + if(!contentNodeDataDataItem["GmtModified"].isNull()) + dataItemObject.gmtModified = contentNodeDataDataItem["GmtModified"].asString(); + if(!contentNodeDataDataItem["TenantId"].isNull()) + dataItemObject.tenantId = contentNodeDataDataItem["TenantId"].asString(); + if(!contentNodeDataDataItem["RegionId"].isNull()) + dataItemObject.regionId = contentNodeDataDataItem["RegionId"].asString(); + if(!contentNodeDataDataItem["ZoneId"].isNull()) + dataItemObject.zoneId = contentNodeDataDataItem["ZoneId"].asString(); + if(!contentNodeDataDataItem["Type"].isNull()) + dataItemObject.type = contentNodeDataDataItem["Type"].asString(); + if(!contentNodeDataDataItem["SubnetId"].isNull()) + dataItemObject.subnetId = contentNodeDataDataItem["SubnetId"].asString(); + if(!contentNodeDataDataItem["Name"].isNull()) + dataItemObject.name = contentNodeDataDataItem["Name"].asString(); + if(!contentNodeDataDataItem["Cidr"].isNull()) + dataItemObject.cidr = contentNodeDataDataItem["Cidr"].asString(); + if(!contentNodeDataDataItem["VpdId"].isNull()) + dataItemObject.vpdId = contentNodeDataDataItem["VpdId"].asString(); + if(!contentNodeDataDataItem["Status"].isNull()) + dataItemObject.status = contentNodeDataDataItem["Status"].asString(); + if(!contentNodeDataDataItem["Message"].isNull()) + dataItemObject.message = contentNodeDataDataItem["Message"].asString(); + if(!contentNodeDataDataItem["NcCount"].isNull()) + dataItemObject.ncCount = std::stol(contentNodeDataDataItem["NcCount"].asString()); + auto vpdBaseInfoNode = value["VpdBaseInfo"]; + if(!vpdBaseInfoNode["VpdId"].isNull()) + dataItemObject.vpdBaseInfo.vpdId = vpdBaseInfoNode["VpdId"].asString(); + if(!vpdBaseInfoNode["Name"].isNull()) + dataItemObject.vpdBaseInfo.name = vpdBaseInfoNode["Name"].asString(); + if(!vpdBaseInfoNode["Cidr"].isNull()) + dataItemObject.vpdBaseInfo.cidr = vpdBaseInfoNode["Cidr"].asString(); + if(!vpdBaseInfoNode["GmtCreate"].isNull()) + dataItemObject.vpdBaseInfo.gmtCreate = vpdBaseInfoNode["GmtCreate"].asString(); + content_.data.push_back(dataItemObject); + } + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string ListSubnetsResult::getMessage()const +{ + return message_; +} + +ListSubnetsResult::Content ListSubnetsResult::getContent()const +{ + return content_; +} + +int ListSubnetsResult::getCode()const +{ + return code_; +} + diff --git a/eflo/src/model/ListVccsRequest.cc b/eflo/src/model/ListVccsRequest.cc new file mode 100644 index 000000000..4580afdb3 --- /dev/null +++ b/eflo/src/model/ListVccsRequest.cc @@ -0,0 +1,126 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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 AlibabaCloud::Eflo::Model::ListVccsRequest; + +ListVccsRequest::ListVccsRequest() + : RpcServiceRequest("eflo", "2022-05-30", "ListVccs") { + setMethod(HttpRequest::Method::Post); +} + +ListVccsRequest::~ListVccsRequest() {} + +std::string ListVccsRequest::getCenId() const { + return cenId_; +} + +void ListVccsRequest::setCenId(const std::string &cenId) { + cenId_ = cenId; + setBodyParameter(std::string("CenId"), cenId); +} + +int ListVccsRequest::getPageNumber() const { + return pageNumber_; +} + +void ListVccsRequest::setPageNumber(int pageNumber) { + pageNumber_ = pageNumber; + setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber)); +} + +std::string ListVccsRequest::getRegionId() const { + return regionId_; +} + +void ListVccsRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setBodyParameter(std::string("RegionId"), regionId); +} + +int ListVccsRequest::getPageSize() const { + return pageSize_; +} + +void ListVccsRequest::setPageSize(int pageSize) { + pageSize_ = pageSize; + setBodyParameter(std::string("PageSize"), std::to_string(pageSize)); +} + +std::string ListVccsRequest::getVccId() const { + return vccId_; +} + +void ListVccsRequest::setVccId(const std::string &vccId) { + vccId_ = vccId; + setBodyParameter(std::string("VccId"), vccId); +} + +int ListVccsRequest::getBandwidth() const { + return bandwidth_; +} + +void ListVccsRequest::setBandwidth(int bandwidth) { + bandwidth_ = bandwidth; + setBodyParameter(std::string("Bandwidth"), std::to_string(bandwidth)); +} + +std::string ListVccsRequest::getExStatus() const { + return exStatus_; +} + +void ListVccsRequest::setExStatus(const std::string &exStatus) { + exStatus_ = exStatus; + setBodyParameter(std::string("ExStatus"), exStatus); +} + +std::string ListVccsRequest::getVpdId() const { + return vpdId_; +} + +void ListVccsRequest::setVpdId(const std::string &vpdId) { + vpdId_ = vpdId; + setBodyParameter(std::string("VpdId"), vpdId); +} + +std::string ListVccsRequest::getVpcId() const { + return vpcId_; +} + +void ListVccsRequest::setVpcId(const std::string &vpcId) { + vpcId_ = vpcId; + setBodyParameter(std::string("VpcId"), vpcId); +} + +bool ListVccsRequest::getEnablePage() const { + return enablePage_; +} + +void ListVccsRequest::setEnablePage(bool enablePage) { + enablePage_ = enablePage; + setBodyParameter(std::string("EnablePage"), enablePage ? "true" : "false"); +} + +std::string ListVccsRequest::getStatus() const { + return status_; +} + +void ListVccsRequest::setStatus(const std::string &status) { + status_ = status; + setBodyParameter(std::string("Status"), status); +} + diff --git a/eflo/src/model/ListVccsResult.cc b/eflo/src/model/ListVccsResult.cc new file mode 100644 index 000000000..9cf9cdae8 --- /dev/null +++ b/eflo/src/model/ListVccsResult.cc @@ -0,0 +1,117 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Eflo; +using namespace AlibabaCloud::Eflo::Model; + +ListVccsResult::ListVccsResult() : + ServiceResult() +{} + +ListVccsResult::ListVccsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListVccsResult::~ListVccsResult() +{} + +void ListVccsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto contentNode = value["Content"]; + if(!contentNode["Total"].isNull()) + content_.total = std::stol(contentNode["Total"].asString()); + auto allDataNode = contentNode["Data"]["DataItem"]; + for (auto contentNodeDataDataItem : allDataNode) + { + Content::DataItem dataItemObject; + if(!contentNodeDataDataItem["TenantId"].isNull()) + dataItemObject.tenantId = contentNodeDataDataItem["TenantId"].asString(); + if(!contentNodeDataDataItem["RegionId"].isNull()) + dataItemObject.regionId = contentNodeDataDataItem["RegionId"].asString(); + if(!contentNodeDataDataItem["VccId"].isNull()) + dataItemObject.vccId = contentNodeDataDataItem["VccId"].asString(); + if(!contentNodeDataDataItem["VpdId"].isNull()) + dataItemObject.vpdId = contentNodeDataDataItem["VpdId"].asString(); + if(!contentNodeDataDataItem["VpcId"].isNull()) + dataItemObject.vpcId = contentNodeDataDataItem["VpcId"].asString(); + if(!contentNodeDataDataItem["CenId"].isNull()) + dataItemObject.cenId = contentNodeDataDataItem["CenId"].asString(); + if(!contentNodeDataDataItem["VccName"].isNull()) + dataItemObject.vccName = contentNodeDataDataItem["VccName"].asString(); + if(!contentNodeDataDataItem["AccessPointId"].isNull()) + dataItemObject.accessPointId = contentNodeDataDataItem["AccessPointId"].asString(); + if(!contentNodeDataDataItem["LineOperator"].isNull()) + dataItemObject.lineOperator = contentNodeDataDataItem["LineOperator"].asString(); + if(!contentNodeDataDataItem["Spec"].isNull()) + dataItemObject.spec = contentNodeDataDataItem["Spec"].asString(); + if(!contentNodeDataDataItem["PortType"].isNull()) + dataItemObject.portType = contentNodeDataDataItem["PortType"].asString(); + if(!contentNodeDataDataItem["Status"].isNull()) + dataItemObject.status = contentNodeDataDataItem["Status"].asString(); + if(!contentNodeDataDataItem["Message"].isNull()) + dataItemObject.message = contentNodeDataDataItem["Message"].asString(); + if(!contentNodeDataDataItem["CreateTime"].isNull()) + dataItemObject.createTime = contentNodeDataDataItem["CreateTime"].asString(); + if(!contentNodeDataDataItem["GmtModified"].isNull()) + dataItemObject.gmtModified = contentNodeDataDataItem["GmtModified"].asString(); + if(!contentNodeDataDataItem["Rate"].isNull()) + dataItemObject.rate = contentNodeDataDataItem["Rate"].asString(); + if(!contentNodeDataDataItem["BandwidthStr"].isNull()) + dataItemObject.bandwidthStr = contentNodeDataDataItem["BandwidthStr"].asString(); + if(!contentNodeDataDataItem["BgpCidr"].isNull()) + dataItemObject.bgpCidr = contentNodeDataDataItem["BgpCidr"].asString(); + auto vpdBaseInfoNode = value["VpdBaseInfo"]; + if(!vpdBaseInfoNode["VpdId"].isNull()) + dataItemObject.vpdBaseInfo.vpdId = vpdBaseInfoNode["VpdId"].asString(); + if(!vpdBaseInfoNode["Name"].isNull()) + dataItemObject.vpdBaseInfo.name = vpdBaseInfoNode["Name"].asString(); + if(!vpdBaseInfoNode["Cidr"].isNull()) + dataItemObject.vpdBaseInfo.cidr = vpdBaseInfoNode["Cidr"].asString(); + if(!vpdBaseInfoNode["GmtCreate"].isNull()) + dataItemObject.vpdBaseInfo.gmtCreate = vpdBaseInfoNode["GmtCreate"].asString(); + content_.data.push_back(dataItemObject); + } + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string ListVccsResult::getMessage()const +{ + return message_; +} + +ListVccsResult::Content ListVccsResult::getContent()const +{ + return content_; +} + +int ListVccsResult::getCode()const +{ + return code_; +} + diff --git a/eflo/src/model/ListVpdsRequest.cc b/eflo/src/model/ListVpdsRequest.cc new file mode 100644 index 000000000..fbccedcd2 --- /dev/null +++ b/eflo/src/model/ListVpdsRequest.cc @@ -0,0 +1,126 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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 AlibabaCloud::Eflo::Model::ListVpdsRequest; + +ListVpdsRequest::ListVpdsRequest() + : RpcServiceRequest("eflo", "2022-05-30", "ListVpds") { + setMethod(HttpRequest::Method::Post); +} + +ListVpdsRequest::~ListVpdsRequest() {} + +int ListVpdsRequest::getPageNumber() const { + return pageNumber_; +} + +void ListVpdsRequest::setPageNumber(int pageNumber) { + pageNumber_ = pageNumber; + setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber)); +} + +bool ListVpdsRequest::getWithDependence() const { + return withDependence_; +} + +void ListVpdsRequest::setWithDependence(bool withDependence) { + withDependence_ = withDependence; + setBodyParameter(std::string("WithDependence"), withDependence ? "true" : "false"); +} + +std::string ListVpdsRequest::getRegionId() const { + return regionId_; +} + +void ListVpdsRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setBodyParameter(std::string("RegionId"), regionId); +} + +bool ListVpdsRequest::getWithoutVcc() const { + return withoutVcc_; +} + +void ListVpdsRequest::setWithoutVcc(bool withoutVcc) { + withoutVcc_ = withoutVcc; + setBodyParameter(std::string("WithoutVcc"), withoutVcc ? "true" : "false"); +} + +int ListVpdsRequest::getPageSize() const { + return pageSize_; +} + +void ListVpdsRequest::setPageSize(int pageSize) { + pageSize_ = pageSize; + setBodyParameter(std::string("PageSize"), std::to_string(pageSize)); +} + +bool ListVpdsRequest::getForSelect() const { + return forSelect_; +} + +void ListVpdsRequest::setForSelect(bool forSelect) { + forSelect_ = forSelect; + setBodyParameter(std::string("ForSelect"), forSelect ? "true" : "false"); +} + +std::string ListVpdsRequest::getFilterErId() const { + return filterErId_; +} + +void ListVpdsRequest::setFilterErId(const std::string &filterErId) { + filterErId_ = filterErId; + setBodyParameter(std::string("FilterErId"), filterErId); +} + +std::string ListVpdsRequest::getVpdId() const { + return vpdId_; +} + +void ListVpdsRequest::setVpdId(const std::string &vpdId) { + vpdId_ = vpdId; + setBodyParameter(std::string("VpdId"), vpdId); +} + +bool ListVpdsRequest::getEnablePage() const { + return enablePage_; +} + +void ListVpdsRequest::setEnablePage(bool enablePage) { + enablePage_ = enablePage; + setBodyParameter(std::string("EnablePage"), enablePage ? "true" : "false"); +} + +std::string ListVpdsRequest::getName() const { + return name_; +} + +void ListVpdsRequest::setName(const std::string &name) { + name_ = name; + setBodyParameter(std::string("Name"), name); +} + +std::string ListVpdsRequest::getStatus() const { + return status_; +} + +void ListVpdsRequest::setStatus(const std::string &status) { + status_ = status; + setBodyParameter(std::string("Status"), status); +} + diff --git a/eflo/src/model/ListVpdsResult.cc b/eflo/src/model/ListVpdsResult.cc new file mode 100644 index 000000000..b1e41dcf1 --- /dev/null +++ b/eflo/src/model/ListVpdsResult.cc @@ -0,0 +1,98 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::Eflo; +using namespace AlibabaCloud::Eflo::Model; + +ListVpdsResult::ListVpdsResult() : + ServiceResult() +{} + +ListVpdsResult::ListVpdsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListVpdsResult::~ListVpdsResult() +{} + +void ListVpdsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto contentNode = value["Content"]; + if(!contentNode["Total"].isNull()) + content_.total = std::stol(contentNode["Total"].asString()); + auto allDataNode = contentNode["Data"]["DataItem"]; + for (auto contentNodeDataDataItem : allDataNode) + { + Content::DataItem dataItemObject; + if(!contentNodeDataDataItem["RegionId"].isNull()) + dataItemObject.regionId = contentNodeDataDataItem["RegionId"].asString(); + if(!contentNodeDataDataItem["VpdId"].isNull()) + dataItemObject.vpdId = contentNodeDataDataItem["VpdId"].asString(); + if(!contentNodeDataDataItem["Name"].isNull()) + dataItemObject.name = contentNodeDataDataItem["Name"].asString(); + if(!contentNodeDataDataItem["Cidr"].isNull()) + dataItemObject.cidr = contentNodeDataDataItem["Cidr"].asString(); + if(!contentNodeDataDataItem["ServiceCidr"].isNull()) + dataItemObject.serviceCidr = contentNodeDataDataItem["ServiceCidr"].asString(); + if(!contentNodeDataDataItem["Status"].isNull()) + dataItemObject.status = contentNodeDataDataItem["Status"].asString(); + if(!contentNodeDataDataItem["Message"].isNull()) + dataItemObject.message = contentNodeDataDataItem["Message"].asString(); + if(!contentNodeDataDataItem["Route"].isNull()) + dataItemObject.route = std::stoi(contentNodeDataDataItem["Route"].asString()); + if(!contentNodeDataDataItem["NcCount"].isNull()) + dataItemObject.ncCount = std::stoi(contentNodeDataDataItem["NcCount"].asString()); + if(!contentNodeDataDataItem["SubnetCount"].isNull()) + dataItemObject.subnetCount = std::stoi(contentNodeDataDataItem["SubnetCount"].asString()); + if(!contentNodeDataDataItem["GmtCreate"].isNull()) + dataItemObject.gmtCreate = contentNodeDataDataItem["GmtCreate"].asString(); + if(!contentNodeDataDataItem["GmtModified"].isNull()) + dataItemObject.gmtModified = contentNodeDataDataItem["GmtModified"].asString(); + if(!contentNodeDataDataItem["Dependence"].isNull()) + dataItemObject.dependence = contentNodeDataDataItem["Dependence"].asString(); + content_.data.push_back(dataItemObject); + } + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string ListVpdsResult::getMessage()const +{ + return message_; +} + +ListVpdsResult::Content ListVpdsResult::getContent()const +{ + return content_; +} + +int ListVpdsResult::getCode()const +{ + return code_; +} + diff --git a/eflo/src/model/UpdateSubnetRequest.cc b/eflo/src/model/UpdateSubnetRequest.cc new file mode 100644 index 000000000..75c27aeef --- /dev/null +++ b/eflo/src/model/UpdateSubnetRequest.cc @@ -0,0 +1,81 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Eflo::Model::UpdateSubnetRequest; + +UpdateSubnetRequest::UpdateSubnetRequest() + : RpcServiceRequest("eflo", "2022-05-30", "UpdateSubnet") { + setMethod(HttpRequest::Method::Post); +} + +UpdateSubnetRequest::~UpdateSubnetRequest() {} + +std::string UpdateSubnetRequest::getSubnetId() const { + return subnetId_; +} + +void UpdateSubnetRequest::setSubnetId(const std::string &subnetId) { + subnetId_ = subnetId; + setBodyParameter(std::string("SubnetId"), subnetId); +} + +std::string UpdateSubnetRequest::getDescription() const { + return description_; +} + +void UpdateSubnetRequest::setDescription(const std::string &description) { + description_ = description; + setBodyParameter(std::string("Description"), description); +} + +std::string UpdateSubnetRequest::getRegionId() const { + return regionId_; +} + +void UpdateSubnetRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setBodyParameter(std::string("RegionId"), regionId); +} + +std::string UpdateSubnetRequest::getVpdId() const { + return vpdId_; +} + +void UpdateSubnetRequest::setVpdId(const std::string &vpdId) { + vpdId_ = vpdId; + setBodyParameter(std::string("VpdId"), vpdId); +} + +std::string UpdateSubnetRequest::getName() const { + return name_; +} + +void UpdateSubnetRequest::setName(const std::string &name) { + name_ = name; + setBodyParameter(std::string("Name"), name); +} + +std::string UpdateSubnetRequest::getZoneId() const { + return zoneId_; +} + +void UpdateSubnetRequest::setZoneId(const std::string &zoneId) { + zoneId_ = zoneId; + setBodyParameter(std::string("ZoneId"), zoneId); +} + diff --git a/eflo/src/model/UpdateSubnetResult.cc b/eflo/src/model/UpdateSubnetResult.cc new file mode 100644 index 000000000..1977c34e2 --- /dev/null +++ b/eflo/src/model/UpdateSubnetResult.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::Eflo; +using namespace AlibabaCloud::Eflo::Model; + +UpdateSubnetResult::UpdateSubnetResult() : + ServiceResult() +{} + +UpdateSubnetResult::UpdateSubnetResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UpdateSubnetResult::~UpdateSubnetResult() +{} + +void UpdateSubnetResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto contentNode = value["Content"]; + if(!contentNode["SubnetId"].isNull()) + content_.subnetId = contentNode["SubnetId"].asString(); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string UpdateSubnetResult::getMessage()const +{ + return message_; +} + +UpdateSubnetResult::Content UpdateSubnetResult::getContent()const +{ + return content_; +} + +int UpdateSubnetResult::getCode()const +{ + return code_; +} + diff --git a/eflo/src/model/UpdateVccRequest.cc b/eflo/src/model/UpdateVccRequest.cc new file mode 100644 index 000000000..b35337db5 --- /dev/null +++ b/eflo/src/model/UpdateVccRequest.cc @@ -0,0 +1,72 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Eflo::Model::UpdateVccRequest; + +UpdateVccRequest::UpdateVccRequest() + : RpcServiceRequest("eflo", "2022-05-30", "UpdateVcc") { + setMethod(HttpRequest::Method::Post); +} + +UpdateVccRequest::~UpdateVccRequest() {} + +int UpdateVccRequest::getBandwidth() const { + return bandwidth_; +} + +void UpdateVccRequest::setBandwidth(int bandwidth) { + bandwidth_ = bandwidth; + setBodyParameter(std::string("Bandwidth"), std::to_string(bandwidth)); +} + +std::string UpdateVccRequest::getOrderId() const { + return orderId_; +} + +void UpdateVccRequest::setOrderId(const std::string &orderId) { + orderId_ = orderId; + setBodyParameter(std::string("OrderId"), orderId); +} + +std::string UpdateVccRequest::getVccName() const { + return vccName_; +} + +void UpdateVccRequest::setVccName(const std::string &vccName) { + vccName_ = vccName; + setBodyParameter(std::string("VccName"), vccName); +} + +std::string UpdateVccRequest::getRegionId() const { + return regionId_; +} + +void UpdateVccRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setBodyParameter(std::string("RegionId"), regionId); +} + +std::string UpdateVccRequest::getVccId() const { + return vccId_; +} + +void UpdateVccRequest::setVccId(const std::string &vccId) { + vccId_ = vccId; + setBodyParameter(std::string("VccId"), vccId); +} + diff --git a/eflo/src/model/UpdateVccResult.cc b/eflo/src/model/UpdateVccResult.cc new file mode 100644 index 000000000..36c7ec814 --- /dev/null +++ b/eflo/src/model/UpdateVccResult.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::Eflo; +using namespace AlibabaCloud::Eflo::Model; + +UpdateVccResult::UpdateVccResult() : + ServiceResult() +{} + +UpdateVccResult::UpdateVccResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UpdateVccResult::~UpdateVccResult() +{} + +void UpdateVccResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto contentNode = value["Content"]; + if(!contentNode["VccId"].isNull()) + content_.vccId = contentNode["VccId"].asString(); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string UpdateVccResult::getMessage()const +{ + return message_; +} + +UpdateVccResult::Content UpdateVccResult::getContent()const +{ + return content_; +} + +int UpdateVccResult::getCode()const +{ + return code_; +} + diff --git a/eflo/src/model/UpdateVpdRequest.cc b/eflo/src/model/UpdateVpdRequest.cc new file mode 100644 index 000000000..1417b5cb7 --- /dev/null +++ b/eflo/src/model/UpdateVpdRequest.cc @@ -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. + */ + +#include + +using AlibabaCloud::Eflo::Model::UpdateVpdRequest; + +UpdateVpdRequest::UpdateVpdRequest() + : RpcServiceRequest("eflo", "2022-05-30", "UpdateVpd") { + setMethod(HttpRequest::Method::Post); +} + +UpdateVpdRequest::~UpdateVpdRequest() {} + +std::string UpdateVpdRequest::getDescription() const { + return description_; +} + +void UpdateVpdRequest::setDescription(const std::string &description) { + description_ = description; + setBodyParameter(std::string("Description"), description); +} + +std::string UpdateVpdRequest::getRegionId() const { + return regionId_; +} + +void UpdateVpdRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setBodyParameter(std::string("RegionId"), regionId); +} + +std::string UpdateVpdRequest::getVpdId() const { + return vpdId_; +} + +void UpdateVpdRequest::setVpdId(const std::string &vpdId) { + vpdId_ = vpdId; + setBodyParameter(std::string("VpdId"), vpdId); +} + +std::string UpdateVpdRequest::getName() const { + return name_; +} + +void UpdateVpdRequest::setName(const std::string &name) { + name_ = name; + setBodyParameter(std::string("Name"), name); +} + diff --git a/eflo/src/model/UpdateVpdResult.cc b/eflo/src/model/UpdateVpdResult.cc new file mode 100644 index 000000000..7b75504ce --- /dev/null +++ b/eflo/src/model/UpdateVpdResult.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::Eflo; +using namespace AlibabaCloud::Eflo::Model; + +UpdateVpdResult::UpdateVpdResult() : + ServiceResult() +{} + +UpdateVpdResult::UpdateVpdResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UpdateVpdResult::~UpdateVpdResult() +{} + +void UpdateVpdResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto contentNode = value["Content"]; + if(!contentNode["VpdId"].isNull()) + content_.vpdId = contentNode["VpdId"].asString(); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string UpdateVpdResult::getMessage()const +{ + return message_; +} + +UpdateVpdResult::Content UpdateVpdResult::getContent()const +{ + return content_; +} + +int UpdateVpdResult::getCode()const +{ + return code_; +} +