From a25fc9202af1250f479f1a07a7d92b1a247f1bda Mon Sep 17 00:00:00 2001 From: sdk-team Date: Wed, 27 Nov 2019 18:05:30 +0800 Subject: [PATCH] CreateReplicationJob API supports the specified instance type. --- CHANGELOG | 3 + VERSION | 2 +- smc/CMakeLists.txt | 130 +++++ smc/include/alibabacloud/smc/SmcClient.h | 142 +++++ smc/include/alibabacloud/smc/SmcExport.h | 32 ++ .../smc/model/CreateReplicationJobRequest.h | 127 +++++ .../smc/model/CreateReplicationJobResult.h | 51 ++ .../smc/model/DeleteReplicationJobRequest.h | 57 ++ .../smc/model/DeleteReplicationJobResult.h | 49 ++ .../smc/model/DeleteSourceServerRequest.h | 60 +++ .../smc/model/DeleteSourceServerResult.h | 49 ++ .../model/DescribeReplicationJobsRequest.h | 78 +++ .../smc/model/DescribeReplicationJobsResult.h | 103 ++++ .../smc/model/DescribeSourceServersRequest.h | 72 +++ .../smc/model/DescribeSourceServersResult.h | 83 +++ .../smc/model/ListTagResourcesRequest.h | 71 +++ .../smc/model/ListTagResourcesResult.h | 60 +++ .../ModifyReplicationJobAttributeRequest.h | 95 ++++ .../ModifyReplicationJobAttributeResult.h | 49 ++ .../ModifySourceServerAttributeRequest.h | 63 +++ .../model/ModifySourceServerAttributeResult.h | 49 ++ .../smc/model/StartReplicationJobRequest.h | 57 ++ .../smc/model/StartReplicationJobResult.h | 49 ++ .../smc/model/StopReplicationJobRequest.h | 57 ++ .../smc/model/StopReplicationJobResult.h | 49 ++ .../smc/model/TagResourcesRequest.h | 68 +++ .../smc/model/TagResourcesResult.h | 49 ++ .../smc/model/UntagResourcesRequest.h | 66 +++ .../smc/model/UntagResourcesResult.h | 49 ++ smc/src/SmcClient.cc | 485 ++++++++++++++++++ smc/src/model/CreateReplicationJobRequest.cc | 303 +++++++++++ smc/src/model/CreateReplicationJobResult.cc | 51 ++ smc/src/model/DeleteReplicationJobRequest.cc | 73 +++ smc/src/model/DeleteReplicationJobResult.cc | 44 ++ smc/src/model/DeleteSourceServerRequest.cc | 84 +++ smc/src/model/DeleteSourceServerResult.cc | 44 ++ .../model/DescribeReplicationJobsRequest.cc | 154 ++++++ .../model/DescribeReplicationJobsResult.cc | 158 ++++++ smc/src/model/DescribeSourceServersRequest.cc | 130 +++++ smc/src/model/DescribeSourceServersResult.cc | 120 +++++ smc/src/model/ListTagResourcesRequest.cc | 113 ++++ smc/src/model/ListTagResourcesResult.cc | 70 +++ .../ModifyReplicationJobAttributeRequest.cc | 199 +++++++ .../ModifyReplicationJobAttributeResult.cc | 44 ++ .../ModifySourceServerAttributeRequest.cc | 95 ++++ .../ModifySourceServerAttributeResult.cc | 44 ++ smc/src/model/StartReplicationJobRequest.cc | 73 +++ smc/src/model/StartReplicationJobResult.cc | 44 ++ smc/src/model/StopReplicationJobRequest.cc | 73 +++ smc/src/model/StopReplicationJobResult.cc | 44 ++ smc/src/model/TagResourcesRequest.cc | 102 ++++ smc/src/model/TagResourcesResult.cc | 44 ++ smc/src/model/UntagResourcesRequest.cc | 110 ++++ smc/src/model/UntagResourcesResult.cc | 44 ++ 54 files changed, 4613 insertions(+), 1 deletion(-) create mode 100644 smc/CMakeLists.txt create mode 100644 smc/include/alibabacloud/smc/SmcClient.h create mode 100644 smc/include/alibabacloud/smc/SmcExport.h create mode 100644 smc/include/alibabacloud/smc/model/CreateReplicationJobRequest.h create mode 100644 smc/include/alibabacloud/smc/model/CreateReplicationJobResult.h create mode 100644 smc/include/alibabacloud/smc/model/DeleteReplicationJobRequest.h create mode 100644 smc/include/alibabacloud/smc/model/DeleteReplicationJobResult.h create mode 100644 smc/include/alibabacloud/smc/model/DeleteSourceServerRequest.h create mode 100644 smc/include/alibabacloud/smc/model/DeleteSourceServerResult.h create mode 100644 smc/include/alibabacloud/smc/model/DescribeReplicationJobsRequest.h create mode 100644 smc/include/alibabacloud/smc/model/DescribeReplicationJobsResult.h create mode 100644 smc/include/alibabacloud/smc/model/DescribeSourceServersRequest.h create mode 100644 smc/include/alibabacloud/smc/model/DescribeSourceServersResult.h create mode 100644 smc/include/alibabacloud/smc/model/ListTagResourcesRequest.h create mode 100644 smc/include/alibabacloud/smc/model/ListTagResourcesResult.h create mode 100644 smc/include/alibabacloud/smc/model/ModifyReplicationJobAttributeRequest.h create mode 100644 smc/include/alibabacloud/smc/model/ModifyReplicationJobAttributeResult.h create mode 100644 smc/include/alibabacloud/smc/model/ModifySourceServerAttributeRequest.h create mode 100644 smc/include/alibabacloud/smc/model/ModifySourceServerAttributeResult.h create mode 100644 smc/include/alibabacloud/smc/model/StartReplicationJobRequest.h create mode 100644 smc/include/alibabacloud/smc/model/StartReplicationJobResult.h create mode 100644 smc/include/alibabacloud/smc/model/StopReplicationJobRequest.h create mode 100644 smc/include/alibabacloud/smc/model/StopReplicationJobResult.h create mode 100644 smc/include/alibabacloud/smc/model/TagResourcesRequest.h create mode 100644 smc/include/alibabacloud/smc/model/TagResourcesResult.h create mode 100644 smc/include/alibabacloud/smc/model/UntagResourcesRequest.h create mode 100644 smc/include/alibabacloud/smc/model/UntagResourcesResult.h create mode 100644 smc/src/SmcClient.cc create mode 100644 smc/src/model/CreateReplicationJobRequest.cc create mode 100644 smc/src/model/CreateReplicationJobResult.cc create mode 100644 smc/src/model/DeleteReplicationJobRequest.cc create mode 100644 smc/src/model/DeleteReplicationJobResult.cc create mode 100644 smc/src/model/DeleteSourceServerRequest.cc create mode 100644 smc/src/model/DeleteSourceServerResult.cc create mode 100644 smc/src/model/DescribeReplicationJobsRequest.cc create mode 100644 smc/src/model/DescribeReplicationJobsResult.cc create mode 100644 smc/src/model/DescribeSourceServersRequest.cc create mode 100644 smc/src/model/DescribeSourceServersResult.cc create mode 100644 smc/src/model/ListTagResourcesRequest.cc create mode 100644 smc/src/model/ListTagResourcesResult.cc create mode 100644 smc/src/model/ModifyReplicationJobAttributeRequest.cc create mode 100644 smc/src/model/ModifyReplicationJobAttributeResult.cc create mode 100644 smc/src/model/ModifySourceServerAttributeRequest.cc create mode 100644 smc/src/model/ModifySourceServerAttributeResult.cc create mode 100644 smc/src/model/StartReplicationJobRequest.cc create mode 100644 smc/src/model/StartReplicationJobResult.cc create mode 100644 smc/src/model/StopReplicationJobRequest.cc create mode 100644 smc/src/model/StopReplicationJobResult.cc create mode 100644 smc/src/model/TagResourcesRequest.cc create mode 100644 smc/src/model/TagResourcesResult.cc create mode 100644 smc/src/model/UntagResourcesRequest.cc create mode 100644 smc/src/model/UntagResourcesResult.cc diff --git a/CHANGELOG b/CHANGELOG index 36405664f..773aafbfc 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,6 @@ +2019-11-27 Version 1.36.200 +- CreateReplicationJob API supports the specified instance type. + 2019-11-26 Version 1.36.199 - Modify QueryBill, add SubOrderId in item of response. diff --git a/VERSION b/VERSION index 65a85f9b5..d1c23b037 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.199 \ No newline at end of file +1.36.200 \ No newline at end of file diff --git a/smc/CMakeLists.txt b/smc/CMakeLists.txt new file mode 100644 index 000000000..4141d030b --- /dev/null +++ b/smc/CMakeLists.txt @@ -0,0 +1,130 @@ +# +# Copyright 2009-2017 Alibaba Cloud All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT 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(smc_public_header + include/alibabacloud/smc/SmcClient.h + include/alibabacloud/smc/SmcExport.h ) + +set(smc_public_header_model + include/alibabacloud/smc/model/CreateReplicationJobRequest.h + include/alibabacloud/smc/model/CreateReplicationJobResult.h + include/alibabacloud/smc/model/DeleteReplicationJobRequest.h + include/alibabacloud/smc/model/DeleteReplicationJobResult.h + include/alibabacloud/smc/model/DeleteSourceServerRequest.h + include/alibabacloud/smc/model/DeleteSourceServerResult.h + include/alibabacloud/smc/model/DescribeReplicationJobsRequest.h + include/alibabacloud/smc/model/DescribeReplicationJobsResult.h + include/alibabacloud/smc/model/DescribeSourceServersRequest.h + include/alibabacloud/smc/model/DescribeSourceServersResult.h + include/alibabacloud/smc/model/ListTagResourcesRequest.h + include/alibabacloud/smc/model/ListTagResourcesResult.h + include/alibabacloud/smc/model/ModifyReplicationJobAttributeRequest.h + include/alibabacloud/smc/model/ModifyReplicationJobAttributeResult.h + include/alibabacloud/smc/model/ModifySourceServerAttributeRequest.h + include/alibabacloud/smc/model/ModifySourceServerAttributeResult.h + include/alibabacloud/smc/model/StartReplicationJobRequest.h + include/alibabacloud/smc/model/StartReplicationJobResult.h + include/alibabacloud/smc/model/StopReplicationJobRequest.h + include/alibabacloud/smc/model/StopReplicationJobResult.h + include/alibabacloud/smc/model/TagResourcesRequest.h + include/alibabacloud/smc/model/TagResourcesResult.h + include/alibabacloud/smc/model/UntagResourcesRequest.h + include/alibabacloud/smc/model/UntagResourcesResult.h ) + +set(smc_src + src/SmcClient.cc + src/model/CreateReplicationJobRequest.cc + src/model/CreateReplicationJobResult.cc + src/model/DeleteReplicationJobRequest.cc + src/model/DeleteReplicationJobResult.cc + src/model/DeleteSourceServerRequest.cc + src/model/DeleteSourceServerResult.cc + src/model/DescribeReplicationJobsRequest.cc + src/model/DescribeReplicationJobsResult.cc + src/model/DescribeSourceServersRequest.cc + src/model/DescribeSourceServersResult.cc + src/model/ListTagResourcesRequest.cc + src/model/ListTagResourcesResult.cc + src/model/ModifyReplicationJobAttributeRequest.cc + src/model/ModifyReplicationJobAttributeResult.cc + src/model/ModifySourceServerAttributeRequest.cc + src/model/ModifySourceServerAttributeResult.cc + src/model/StartReplicationJobRequest.cc + src/model/StartReplicationJobResult.cc + src/model/StopReplicationJobRequest.cc + src/model/StopReplicationJobResult.cc + src/model/TagResourcesRequest.cc + src/model/TagResourcesResult.cc + src/model/UntagResourcesRequest.cc + src/model/UntagResourcesResult.cc ) + +add_library(smc ${LIB_TYPE} + ${smc_public_header} + ${smc_public_header_model} + ${smc_src}) + +set_target_properties(smc + 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}smc + ) + +if(${LIB_TYPE} STREQUAL "SHARED") + set_target_properties(smc + PROPERTIES + DEFINE_SYMBOL ALIBABACLOUD_SMC_LIBRARY) +endif() + +target_include_directories(smc + PRIVATE include + ${CMAKE_SOURCE_DIR}/core/include + ) +target_link_libraries(smc + core) + +if(CMAKE_HOST_WIN32) + ExternalProject_Get_Property(jsoncpp INSTALL_DIR) + set(jsoncpp_install_dir ${INSTALL_DIR}) + add_dependencies(smc + jsoncpp) + target_include_directories(smc + PRIVATE ${jsoncpp_install_dir}/include) + target_link_libraries(smc + ${jsoncpp_install_dir}/lib/jsoncpp.lib) + set_target_properties(smc + PROPERTIES + COMPILE_OPTIONS "/bigobj") +else() + target_include_directories(smc + PRIVATE /usr/include/jsoncpp) + target_link_libraries(smc + jsoncpp) +endif() + +install(FILES ${smc_public_header} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/smc) +install(FILES ${smc_public_header_model} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/smc/model) +install(TARGETS smc + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + ) \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/SmcClient.h b/smc/include/alibabacloud/smc/SmcClient.h new file mode 100644 index 000000000..6c06e7ab6 --- /dev/null +++ b/smc/include/alibabacloud/smc/SmcClient.h @@ -0,0 +1,142 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SMC_SMCCLIENT_H_ +#define ALIBABACLOUD_SMC_SMCCLIENT_H_ + +#include +#include +#include +#include +#include "SmcExport.h" +#include "model/CreateReplicationJobRequest.h" +#include "model/CreateReplicationJobResult.h" +#include "model/DeleteReplicationJobRequest.h" +#include "model/DeleteReplicationJobResult.h" +#include "model/DeleteSourceServerRequest.h" +#include "model/DeleteSourceServerResult.h" +#include "model/DescribeReplicationJobsRequest.h" +#include "model/DescribeReplicationJobsResult.h" +#include "model/DescribeSourceServersRequest.h" +#include "model/DescribeSourceServersResult.h" +#include "model/ListTagResourcesRequest.h" +#include "model/ListTagResourcesResult.h" +#include "model/ModifyReplicationJobAttributeRequest.h" +#include "model/ModifyReplicationJobAttributeResult.h" +#include "model/ModifySourceServerAttributeRequest.h" +#include "model/ModifySourceServerAttributeResult.h" +#include "model/StartReplicationJobRequest.h" +#include "model/StartReplicationJobResult.h" +#include "model/StopReplicationJobRequest.h" +#include "model/StopReplicationJobResult.h" +#include "model/TagResourcesRequest.h" +#include "model/TagResourcesResult.h" +#include "model/UntagResourcesRequest.h" +#include "model/UntagResourcesResult.h" + + +namespace AlibabaCloud +{ + namespace Smc + { + class ALIBABACLOUD_SMC_EXPORT SmcClient : public RpcServiceClient + { + public: + typedef Outcome CreateReplicationJobOutcome; + typedef std::future CreateReplicationJobOutcomeCallable; + typedef std::function&)> CreateReplicationJobAsyncHandler; + typedef Outcome DeleteReplicationJobOutcome; + typedef std::future DeleteReplicationJobOutcomeCallable; + typedef std::function&)> DeleteReplicationJobAsyncHandler; + typedef Outcome DeleteSourceServerOutcome; + typedef std::future DeleteSourceServerOutcomeCallable; + typedef std::function&)> DeleteSourceServerAsyncHandler; + typedef Outcome DescribeReplicationJobsOutcome; + typedef std::future DescribeReplicationJobsOutcomeCallable; + typedef std::function&)> DescribeReplicationJobsAsyncHandler; + typedef Outcome DescribeSourceServersOutcome; + typedef std::future DescribeSourceServersOutcomeCallable; + typedef std::function&)> DescribeSourceServersAsyncHandler; + typedef Outcome ListTagResourcesOutcome; + typedef std::future ListTagResourcesOutcomeCallable; + typedef std::function&)> ListTagResourcesAsyncHandler; + typedef Outcome ModifyReplicationJobAttributeOutcome; + typedef std::future ModifyReplicationJobAttributeOutcomeCallable; + typedef std::function&)> ModifyReplicationJobAttributeAsyncHandler; + typedef Outcome ModifySourceServerAttributeOutcome; + typedef std::future ModifySourceServerAttributeOutcomeCallable; + typedef std::function&)> ModifySourceServerAttributeAsyncHandler; + typedef Outcome StartReplicationJobOutcome; + typedef std::future StartReplicationJobOutcomeCallable; + typedef std::function&)> StartReplicationJobAsyncHandler; + typedef Outcome StopReplicationJobOutcome; + typedef std::future StopReplicationJobOutcomeCallable; + typedef std::function&)> StopReplicationJobAsyncHandler; + typedef Outcome TagResourcesOutcome; + typedef std::future TagResourcesOutcomeCallable; + typedef std::function&)> TagResourcesAsyncHandler; + typedef Outcome UntagResourcesOutcome; + typedef std::future UntagResourcesOutcomeCallable; + typedef std::function&)> UntagResourcesAsyncHandler; + + SmcClient(const Credentials &credentials, const ClientConfiguration &configuration); + SmcClient(const std::shared_ptr &credentialsProvider, const ClientConfiguration &configuration); + SmcClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration); + ~SmcClient(); + CreateReplicationJobOutcome createReplicationJob(const Model::CreateReplicationJobRequest &request)const; + void createReplicationJobAsync(const Model::CreateReplicationJobRequest& request, const CreateReplicationJobAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateReplicationJobOutcomeCallable createReplicationJobCallable(const Model::CreateReplicationJobRequest& request) const; + DeleteReplicationJobOutcome deleteReplicationJob(const Model::DeleteReplicationJobRequest &request)const; + void deleteReplicationJobAsync(const Model::DeleteReplicationJobRequest& request, const DeleteReplicationJobAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteReplicationJobOutcomeCallable deleteReplicationJobCallable(const Model::DeleteReplicationJobRequest& request) const; + DeleteSourceServerOutcome deleteSourceServer(const Model::DeleteSourceServerRequest &request)const; + void deleteSourceServerAsync(const Model::DeleteSourceServerRequest& request, const DeleteSourceServerAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteSourceServerOutcomeCallable deleteSourceServerCallable(const Model::DeleteSourceServerRequest& request) const; + DescribeReplicationJobsOutcome describeReplicationJobs(const Model::DescribeReplicationJobsRequest &request)const; + void describeReplicationJobsAsync(const Model::DescribeReplicationJobsRequest& request, const DescribeReplicationJobsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeReplicationJobsOutcomeCallable describeReplicationJobsCallable(const Model::DescribeReplicationJobsRequest& request) const; + DescribeSourceServersOutcome describeSourceServers(const Model::DescribeSourceServersRequest &request)const; + void describeSourceServersAsync(const Model::DescribeSourceServersRequest& request, const DescribeSourceServersAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeSourceServersOutcomeCallable describeSourceServersCallable(const Model::DescribeSourceServersRequest& request) const; + ListTagResourcesOutcome listTagResources(const Model::ListTagResourcesRequest &request)const; + void listTagResourcesAsync(const Model::ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const; + ModifyReplicationJobAttributeOutcome modifyReplicationJobAttribute(const Model::ModifyReplicationJobAttributeRequest &request)const; + void modifyReplicationJobAttributeAsync(const Model::ModifyReplicationJobAttributeRequest& request, const ModifyReplicationJobAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ModifyReplicationJobAttributeOutcomeCallable modifyReplicationJobAttributeCallable(const Model::ModifyReplicationJobAttributeRequest& request) const; + ModifySourceServerAttributeOutcome modifySourceServerAttribute(const Model::ModifySourceServerAttributeRequest &request)const; + void modifySourceServerAttributeAsync(const Model::ModifySourceServerAttributeRequest& request, const ModifySourceServerAttributeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ModifySourceServerAttributeOutcomeCallable modifySourceServerAttributeCallable(const Model::ModifySourceServerAttributeRequest& request) const; + StartReplicationJobOutcome startReplicationJob(const Model::StartReplicationJobRequest &request)const; + void startReplicationJobAsync(const Model::StartReplicationJobRequest& request, const StartReplicationJobAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + StartReplicationJobOutcomeCallable startReplicationJobCallable(const Model::StartReplicationJobRequest& request) const; + StopReplicationJobOutcome stopReplicationJob(const Model::StopReplicationJobRequest &request)const; + void stopReplicationJobAsync(const Model::StopReplicationJobRequest& request, const StopReplicationJobAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + StopReplicationJobOutcomeCallable stopReplicationJobCallable(const Model::StopReplicationJobRequest& request) const; + TagResourcesOutcome tagResources(const Model::TagResourcesRequest &request)const; + void tagResourcesAsync(const Model::TagResourcesRequest& request, const TagResourcesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + TagResourcesOutcomeCallable tagResourcesCallable(const Model::TagResourcesRequest& request) const; + UntagResourcesOutcome untagResources(const Model::UntagResourcesRequest &request)const; + void untagResourcesAsync(const Model::UntagResourcesRequest& request, const UntagResourcesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UntagResourcesOutcomeCallable untagResourcesCallable(const Model::UntagResourcesRequest& request) const; + + private: + std::shared_ptr endpointProvider_; + }; + } +} + +#endif // !ALIBABACLOUD_SMC_SMCCLIENT_H_ diff --git a/smc/include/alibabacloud/smc/SmcExport.h b/smc/include/alibabacloud/smc/SmcExport.h new file mode 100644 index 000000000..b9944d4bd --- /dev/null +++ b/smc/include/alibabacloud/smc/SmcExport.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_SMC_SMCEXPORT_H_ +#define ALIBABACLOUD_SMC_SMCEXPORT_H_ + +#include + +#if defined(ALIBABACLOUD_SHARED) +# if defined(ALIBABACLOUD_SMC_LIBRARY) +# define ALIBABACLOUD_SMC_EXPORT ALIBABACLOUD_DECL_EXPORT +# else +# define ALIBABACLOUD_SMC_EXPORT ALIBABACLOUD_DECL_IMPORT +# endif +#else +# define ALIBABACLOUD_SMC_EXPORT +#endif + +#endif // !ALIBABACLOUD_SMC_SMCEXPORT_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/CreateReplicationJobRequest.h b/smc/include/alibabacloud/smc/model/CreateReplicationJobRequest.h new file mode 100644 index 000000000..b8bad972e --- /dev/null +++ b/smc/include/alibabacloud/smc/model/CreateReplicationJobRequest.h @@ -0,0 +1,127 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SMC_MODEL_CREATEREPLICATIONJOBREQUEST_H_ +#define ALIBABACLOUD_SMC_MODEL_CREATEREPLICATIONJOBREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT CreateReplicationJobRequest : public RpcServiceRequest + { + struct Tag + { + std::string value; + std::string key; + }; + struct DataDisk + { + int size; + int index; + }; + + public: + CreateReplicationJobRequest(); + ~CreateReplicationJobRequest(); + + std::string getTargetType()const; + void setTargetType(const std::string& targetType); + std::string getClientToken()const; + void setClientToken(const std::string& clientToken); + std::string getDescription()const; + void setDescription(const std::string& description); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + int getFrequency()const; + void setFrequency(int frequency); + std::string getReplicationParameters()const; + void setReplicationParameters(const std::string& replicationParameters); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + std::string getImageName()const; + void setImageName(const std::string& imageName); + int getSystemDiskSize()const; + void setSystemDiskSize(int systemDiskSize); + std::string getInstanceType()const; + void setInstanceType(const std::string& instanceType); + std::vector getTag()const; + void setTag(const std::vector& tag); + int getNetMode()const; + void setNetMode(int netMode); + std::string getSourceId()const; + void setSourceId(const std::string& sourceId); + bool getRunOnce()const; + void setRunOnce(bool runOnce); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + std::string getValidTime()const; + void setValidTime(const std::string& validTime); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::vector getDataDisk()const; + void setDataDisk(const std::vector& dataDisk); + std::string getVSwitchId()const; + void setVSwitchId(const std::string& vSwitchId); + std::string getScheduledStartTime()const; + void setScheduledStartTime(const std::string& scheduledStartTime); + std::string getInstanceId()const; + void setInstanceId(const std::string& instanceId); + std::string getVpcId()const; + void setVpcId(const std::string& vpcId); + std::string getName()const; + void setName(const std::string& name); + int getMaxNumberOfImageToKeep()const; + void setMaxNumberOfImageToKeep(int maxNumberOfImageToKeep); + + private: + std::string targetType_; + std::string clientToken_; + std::string description_; + std::string accessKeyId_; + int frequency_; + std::string replicationParameters_; + std::string regionId_; + std::string imageName_; + int systemDiskSize_; + std::string instanceType_; + std::vector tag_; + int netMode_; + std::string sourceId_; + bool runOnce_; + std::string resourceOwnerAccount_; + std::string validTime_; + long ownerId_; + std::vector dataDisk_; + std::string vSwitchId_; + std::string scheduledStartTime_; + std::string instanceId_; + std::string vpcId_; + std::string name_; + int maxNumberOfImageToKeep_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_CREATEREPLICATIONJOBREQUEST_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/CreateReplicationJobResult.h b/smc/include/alibabacloud/smc/model/CreateReplicationJobResult.h new file mode 100644 index 000000000..c8523782c --- /dev/null +++ b/smc/include/alibabacloud/smc/model/CreateReplicationJobResult.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_SMC_MODEL_CREATEREPLICATIONJOBRESULT_H_ +#define ALIBABACLOUD_SMC_MODEL_CREATEREPLICATIONJOBRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT CreateReplicationJobResult : public ServiceResult + { + public: + + + CreateReplicationJobResult(); + explicit CreateReplicationJobResult(const std::string &payload); + ~CreateReplicationJobResult(); + std::string getJobId()const; + + protected: + void parse(const std::string &payload); + private: + std::string jobId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_CREATEREPLICATIONJOBRESULT_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/DeleteReplicationJobRequest.h b/smc/include/alibabacloud/smc/model/DeleteReplicationJobRequest.h new file mode 100644 index 000000000..2c26a2185 --- /dev/null +++ b/smc/include/alibabacloud/smc/model/DeleteReplicationJobRequest.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_SMC_MODEL_DELETEREPLICATIONJOBREQUEST_H_ +#define ALIBABACLOUD_SMC_MODEL_DELETEREPLICATIONJOBREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT DeleteReplicationJobRequest : public RpcServiceRequest + { + + public: + DeleteReplicationJobRequest(); + ~DeleteReplicationJobRequest(); + + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getJobId()const; + void setJobId(const std::string& jobId); + + private: + std::string resourceOwnerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string jobId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_DELETEREPLICATIONJOBREQUEST_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/DeleteReplicationJobResult.h b/smc/include/alibabacloud/smc/model/DeleteReplicationJobResult.h new file mode 100644 index 000000000..de707d9ad --- /dev/null +++ b/smc/include/alibabacloud/smc/model/DeleteReplicationJobResult.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_SMC_MODEL_DELETEREPLICATIONJOBRESULT_H_ +#define ALIBABACLOUD_SMC_MODEL_DELETEREPLICATIONJOBRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT DeleteReplicationJobResult : public ServiceResult + { + public: + + + DeleteReplicationJobResult(); + explicit DeleteReplicationJobResult(const std::string &payload); + ~DeleteReplicationJobResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_DELETEREPLICATIONJOBRESULT_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/DeleteSourceServerRequest.h b/smc/include/alibabacloud/smc/model/DeleteSourceServerRequest.h new file mode 100644 index 000000000..bf748f504 --- /dev/null +++ b/smc/include/alibabacloud/smc/model/DeleteSourceServerRequest.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_SMC_MODEL_DELETESOURCESERVERREQUEST_H_ +#define ALIBABACLOUD_SMC_MODEL_DELETESOURCESERVERREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT DeleteSourceServerRequest : public RpcServiceRequest + { + + public: + DeleteSourceServerRequest(); + ~DeleteSourceServerRequest(); + + std::string getSourceId()const; + void setSourceId(const std::string& sourceId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + bool getForce()const; + void setForce(bool force); + + private: + std::string sourceId_; + std::string resourceOwnerAccount_; + long ownerId_; + std::string accessKeyId_; + bool force_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_DELETESOURCESERVERREQUEST_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/DeleteSourceServerResult.h b/smc/include/alibabacloud/smc/model/DeleteSourceServerResult.h new file mode 100644 index 000000000..be6ba6d49 --- /dev/null +++ b/smc/include/alibabacloud/smc/model/DeleteSourceServerResult.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_SMC_MODEL_DELETESOURCESERVERRESULT_H_ +#define ALIBABACLOUD_SMC_MODEL_DELETESOURCESERVERRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT DeleteSourceServerResult : public ServiceResult + { + public: + + + DeleteSourceServerResult(); + explicit DeleteSourceServerResult(const std::string &payload); + ~DeleteSourceServerResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_DELETESOURCESERVERRESULT_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/DescribeReplicationJobsRequest.h b/smc/include/alibabacloud/smc/model/DescribeReplicationJobsRequest.h new file mode 100644 index 000000000..e57cccc25 --- /dev/null +++ b/smc/include/alibabacloud/smc/model/DescribeReplicationJobsRequest.h @@ -0,0 +1,78 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SMC_MODEL_DESCRIBEREPLICATIONJOBSREQUEST_H_ +#define ALIBABACLOUD_SMC_MODEL_DESCRIBEREPLICATIONJOBSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT DescribeReplicationJobsRequest : public RpcServiceRequest + { + + public: + DescribeReplicationJobsRequest(); + ~DescribeReplicationJobsRequest(); + + int getPageNumber()const; + void setPageNumber(int pageNumber); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::vector getJobId()const; + void setJobId(const std::vector& jobId); + std::string getRegionId()const; + void setRegionId(const std::string& regionId); + int getPageSize()const; + void setPageSize(int pageSize); + std::vector getSourceId()const; + void setSourceId(const std::vector& sourceId); + std::string getBusinessStatus()const; + void setBusinessStatus(const std::string& businessStatus); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getName()const; + void setName(const std::string& name); + std::string getStatus()const; + void setStatus(const std::string& status); + + private: + int pageNumber_; + std::string accessKeyId_; + std::vector jobId_; + std::string regionId_; + int pageSize_; + std::vector sourceId_; + std::string businessStatus_; + std::string resourceOwnerAccount_; + long ownerId_; + std::string name_; + std::string status_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_DESCRIBEREPLICATIONJOBSREQUEST_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/DescribeReplicationJobsResult.h b/smc/include/alibabacloud/smc/model/DescribeReplicationJobsResult.h new file mode 100644 index 000000000..1c0da475a --- /dev/null +++ b/smc/include/alibabacloud/smc/model/DescribeReplicationJobsResult.h @@ -0,0 +1,103 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SMC_MODEL_DESCRIBEREPLICATIONJOBSRESULT_H_ +#define ALIBABACLOUD_SMC_MODEL_DESCRIBEREPLICATIONJOBSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT DescribeReplicationJobsResult : public ServiceResult + { + public: + struct ReplicationJob + { + struct DataDisk + { + int size; + int index; + }; + struct ReplicationJobRun + { + std::string type; + std::string endTime; + std::string imageId; + std::string startTime; + }; + std::string description; + std::vector dataDisks; + std::string endTime; + std::string transitionInstanceId; + int systemDiskSize; + int netMode; + std::string sourceId; + std::string businessStatus; + std::string name; + std::string validTime; + int maxNumberOfImageToKeep; + bool runOnce; + std::string targetType; + std::string imageId; + std::string instanceType; + std::vector replicationJobRuns; + std::string jobId; + std::string status; + float progress; + std::string instanceId; + std::string vSwitchId; + std::string startTime; + std::string replicationParameters; + std::string imageName; + std::string vpcId; + std::string statusInfo; + std::string creationTime; + int frequency; + std::string regionId; + std::string scheduledStartTime; + std::string errorCode; + }; + + + DescribeReplicationJobsResult(); + explicit DescribeReplicationJobsResult(const std::string &payload); + ~DescribeReplicationJobsResult(); + int getTotalCount()const; + std::vector getReplicationJobs()const; + int getPageSize()const; + int getPageNumber()const; + + protected: + void parse(const std::string &payload); + private: + int totalCount_; + std::vector replicationJobs_; + int pageSize_; + int pageNumber_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_DESCRIBEREPLICATIONJOBSRESULT_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/DescribeSourceServersRequest.h b/smc/include/alibabacloud/smc/model/DescribeSourceServersRequest.h new file mode 100644 index 000000000..0e39cfa56 --- /dev/null +++ b/smc/include/alibabacloud/smc/model/DescribeSourceServersRequest.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_SMC_MODEL_DESCRIBESOURCESERVERSREQUEST_H_ +#define ALIBABACLOUD_SMC_MODEL_DESCRIBESOURCESERVERSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT DescribeSourceServersRequest : public RpcServiceRequest + { + + public: + DescribeSourceServersRequest(); + ~DescribeSourceServersRequest(); + + int getPageNumber()const; + void setPageNumber(int pageNumber); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getJobId()const; + void setJobId(const std::string& jobId); + int getPageSize()const; + void setPageSize(int pageSize); + std::string getState()const; + void setState(const std::string& state); + std::vector getSourceId()const; + void setSourceId(const std::vector& sourceId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getName()const; + void setName(const std::string& name); + + private: + int pageNumber_; + std::string accessKeyId_; + std::string jobId_; + int pageSize_; + std::string state_; + std::vector sourceId_; + std::string resourceOwnerAccount_; + long ownerId_; + std::string name_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_DESCRIBESOURCESERVERSREQUEST_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/DescribeSourceServersResult.h b/smc/include/alibabacloud/smc/model/DescribeSourceServersResult.h new file mode 100644 index 000000000..ba8ee9ddb --- /dev/null +++ b/smc/include/alibabacloud/smc/model/DescribeSourceServersResult.h @@ -0,0 +1,83 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SMC_MODEL_DESCRIBESOURCESERVERSRESULT_H_ +#define ALIBABACLOUD_SMC_MODEL_DESCRIBESOURCESERVERSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT DescribeSourceServersResult : public ServiceResult + { + public: + struct SourceServer + { + struct DataDisk + { + std::string path; + int size; + int index; + }; + std::string description; + std::string systemInfo; + std::vector dataDisks; + std::string platform; + std::string architecture; + std::string agentVersion; + int systemDiskSize; + std::string sourceId; + std::string name; + int kernelLevel; + std::string replicationDriver; + std::string statusInfo; + std::string state; + std::string creationTime; + int heartbeatRate; + std::string errorCode; + std::string jobId; + }; + + + DescribeSourceServersResult(); + explicit DescribeSourceServersResult(const std::string &payload); + ~DescribeSourceServersResult(); + std::vector getSourceServers()const; + int getTotalCount()const; + int getPageSize()const; + int getPageNumber()const; + + protected: + void parse(const std::string &payload); + private: + std::vector sourceServers_; + int totalCount_; + int pageSize_; + int pageNumber_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_DESCRIBESOURCESERVERSRESULT_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/ListTagResourcesRequest.h b/smc/include/alibabacloud/smc/model/ListTagResourcesRequest.h new file mode 100644 index 000000000..39487c9bf --- /dev/null +++ b/smc/include/alibabacloud/smc/model/ListTagResourcesRequest.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SMC_MODEL_LISTTAGRESOURCESREQUEST_H_ +#define ALIBABACLOUD_SMC_MODEL_LISTTAGRESOURCESREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT ListTagResourcesRequest : public RpcServiceRequest + { + struct Tag + { + std::string value; + std::string key; + }; + + public: + ListTagResourcesRequest(); + ~ListTagResourcesRequest(); + + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getNextToken()const; + void setNextToken(const std::string& nextToken); + std::vector getTag()const; + void setTag(const std::vector& tag); + std::vector getResourceId()const; + void setResourceId(const std::vector& resourceId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getResourceType()const; + void setResourceType(const std::string& resourceType); + + private: + std::string accessKeyId_; + std::string nextToken_; + std::vector tag_; + std::vector resourceId_; + std::string resourceOwnerAccount_; + long ownerId_; + std::string resourceType_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_LISTTAGRESOURCESREQUEST_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/ListTagResourcesResult.h b/smc/include/alibabacloud/smc/model/ListTagResourcesResult.h new file mode 100644 index 000000000..ec7794276 --- /dev/null +++ b/smc/include/alibabacloud/smc/model/ListTagResourcesResult.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_SMC_MODEL_LISTTAGRESOURCESRESULT_H_ +#define ALIBABACLOUD_SMC_MODEL_LISTTAGRESOURCESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT ListTagResourcesResult : public ServiceResult + { + public: + struct TagResource + { + std::string resourceId; + std::string tagKey; + std::string resourceType; + std::string tagValue; + }; + + + ListTagResourcesResult(); + explicit ListTagResourcesResult(const std::string &payload); + ~ListTagResourcesResult(); + std::string getNextToken()const; + std::vector getTagResources()const; + + protected: + void parse(const std::string &payload); + private: + std::string nextToken_; + std::vector tagResources_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_LISTTAGRESOURCESRESULT_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/ModifyReplicationJobAttributeRequest.h b/smc/include/alibabacloud/smc/model/ModifyReplicationJobAttributeRequest.h new file mode 100644 index 000000000..46e4c2ca7 --- /dev/null +++ b/smc/include/alibabacloud/smc/model/ModifyReplicationJobAttributeRequest.h @@ -0,0 +1,95 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SMC_MODEL_MODIFYREPLICATIONJOBATTRIBUTEREQUEST_H_ +#define ALIBABACLOUD_SMC_MODEL_MODIFYREPLICATIONJOBATTRIBUTEREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT ModifyReplicationJobAttributeRequest : public RpcServiceRequest + { + struct DataDisk + { + int size; + int index; + }; + + public: + ModifyReplicationJobAttributeRequest(); + ~ModifyReplicationJobAttributeRequest(); + + std::string getTargetType()const; + void setTargetType(const std::string& targetType); + std::string getDescription()const; + void setDescription(const std::string& description); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + int getFrequency()const; + void setFrequency(int frequency); + std::string getJobId()const; + void setJobId(const std::string& jobId); + std::string getImageName()const; + void setImageName(const std::string& imageName); + int getSystemDiskSize()const; + void setSystemDiskSize(int systemDiskSize); + std::string getInstanceType()const; + void setInstanceType(const std::string& instanceType); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::vector getDataDisk()const; + void setDataDisk(const std::vector& dataDisk); + std::string getScheduledStartTime()const; + void setScheduledStartTime(const std::string& scheduledStartTime); + std::string getInstanceId()const; + void setInstanceId(const std::string& instanceId); + std::string getName()const; + void setName(const std::string& name); + int getMaxNumberOfImageToKeep()const; + void setMaxNumberOfImageToKeep(int maxNumberOfImageToKeep); + + private: + std::string targetType_; + std::string description_; + std::string accessKeyId_; + int frequency_; + std::string jobId_; + std::string imageName_; + int systemDiskSize_; + std::string instanceType_; + std::string resourceOwnerAccount_; + long ownerId_; + std::vector dataDisk_; + std::string scheduledStartTime_; + std::string instanceId_; + std::string name_; + int maxNumberOfImageToKeep_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_MODIFYREPLICATIONJOBATTRIBUTEREQUEST_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/ModifyReplicationJobAttributeResult.h b/smc/include/alibabacloud/smc/model/ModifyReplicationJobAttributeResult.h new file mode 100644 index 000000000..b0e53a92d --- /dev/null +++ b/smc/include/alibabacloud/smc/model/ModifyReplicationJobAttributeResult.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_SMC_MODEL_MODIFYREPLICATIONJOBATTRIBUTERESULT_H_ +#define ALIBABACLOUD_SMC_MODEL_MODIFYREPLICATIONJOBATTRIBUTERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT ModifyReplicationJobAttributeResult : public ServiceResult + { + public: + + + ModifyReplicationJobAttributeResult(); + explicit ModifyReplicationJobAttributeResult(const std::string &payload); + ~ModifyReplicationJobAttributeResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_MODIFYREPLICATIONJOBATTRIBUTERESULT_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/ModifySourceServerAttributeRequest.h b/smc/include/alibabacloud/smc/model/ModifySourceServerAttributeRequest.h new file mode 100644 index 000000000..17b90d98b --- /dev/null +++ b/smc/include/alibabacloud/smc/model/ModifySourceServerAttributeRequest.h @@ -0,0 +1,63 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SMC_MODEL_MODIFYSOURCESERVERATTRIBUTEREQUEST_H_ +#define ALIBABACLOUD_SMC_MODEL_MODIFYSOURCESERVERATTRIBUTEREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT ModifySourceServerAttributeRequest : public RpcServiceRequest + { + + public: + ModifySourceServerAttributeRequest(); + ~ModifySourceServerAttributeRequest(); + + std::string getDescription()const; + void setDescription(const std::string& description); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getSourceId()const; + void setSourceId(const std::string& sourceId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getName()const; + void setName(const std::string& name); + + private: + std::string description_; + std::string accessKeyId_; + std::string sourceId_; + std::string resourceOwnerAccount_; + long ownerId_; + std::string name_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_MODIFYSOURCESERVERATTRIBUTEREQUEST_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/ModifySourceServerAttributeResult.h b/smc/include/alibabacloud/smc/model/ModifySourceServerAttributeResult.h new file mode 100644 index 000000000..8334c5019 --- /dev/null +++ b/smc/include/alibabacloud/smc/model/ModifySourceServerAttributeResult.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_SMC_MODEL_MODIFYSOURCESERVERATTRIBUTERESULT_H_ +#define ALIBABACLOUD_SMC_MODEL_MODIFYSOURCESERVERATTRIBUTERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT ModifySourceServerAttributeResult : public ServiceResult + { + public: + + + ModifySourceServerAttributeResult(); + explicit ModifySourceServerAttributeResult(const std::string &payload); + ~ModifySourceServerAttributeResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_MODIFYSOURCESERVERATTRIBUTERESULT_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/StartReplicationJobRequest.h b/smc/include/alibabacloud/smc/model/StartReplicationJobRequest.h new file mode 100644 index 000000000..312e81d42 --- /dev/null +++ b/smc/include/alibabacloud/smc/model/StartReplicationJobRequest.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_SMC_MODEL_STARTREPLICATIONJOBREQUEST_H_ +#define ALIBABACLOUD_SMC_MODEL_STARTREPLICATIONJOBREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT StartReplicationJobRequest : public RpcServiceRequest + { + + public: + StartReplicationJobRequest(); + ~StartReplicationJobRequest(); + + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getJobId()const; + void setJobId(const std::string& jobId); + + private: + std::string resourceOwnerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string jobId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_STARTREPLICATIONJOBREQUEST_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/StartReplicationJobResult.h b/smc/include/alibabacloud/smc/model/StartReplicationJobResult.h new file mode 100644 index 000000000..01dadc066 --- /dev/null +++ b/smc/include/alibabacloud/smc/model/StartReplicationJobResult.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_SMC_MODEL_STARTREPLICATIONJOBRESULT_H_ +#define ALIBABACLOUD_SMC_MODEL_STARTREPLICATIONJOBRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT StartReplicationJobResult : public ServiceResult + { + public: + + + StartReplicationJobResult(); + explicit StartReplicationJobResult(const std::string &payload); + ~StartReplicationJobResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_STARTREPLICATIONJOBRESULT_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/StopReplicationJobRequest.h b/smc/include/alibabacloud/smc/model/StopReplicationJobRequest.h new file mode 100644 index 000000000..9b34fa73f --- /dev/null +++ b/smc/include/alibabacloud/smc/model/StopReplicationJobRequest.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_SMC_MODEL_STOPREPLICATIONJOBREQUEST_H_ +#define ALIBABACLOUD_SMC_MODEL_STOPREPLICATIONJOBREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT StopReplicationJobRequest : public RpcServiceRequest + { + + public: + StopReplicationJobRequest(); + ~StopReplicationJobRequest(); + + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getJobId()const; + void setJobId(const std::string& jobId); + + private: + std::string resourceOwnerAccount_; + long ownerId_; + std::string accessKeyId_; + std::string jobId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_STOPREPLICATIONJOBREQUEST_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/StopReplicationJobResult.h b/smc/include/alibabacloud/smc/model/StopReplicationJobResult.h new file mode 100644 index 000000000..84c134cca --- /dev/null +++ b/smc/include/alibabacloud/smc/model/StopReplicationJobResult.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_SMC_MODEL_STOPREPLICATIONJOBRESULT_H_ +#define ALIBABACLOUD_SMC_MODEL_STOPREPLICATIONJOBRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT StopReplicationJobResult : public ServiceResult + { + public: + + + StopReplicationJobResult(); + explicit StopReplicationJobResult(const std::string &payload); + ~StopReplicationJobResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_STOPREPLICATIONJOBRESULT_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/TagResourcesRequest.h b/smc/include/alibabacloud/smc/model/TagResourcesRequest.h new file mode 100644 index 000000000..98a6f737b --- /dev/null +++ b/smc/include/alibabacloud/smc/model/TagResourcesRequest.h @@ -0,0 +1,68 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SMC_MODEL_TAGRESOURCESREQUEST_H_ +#define ALIBABACLOUD_SMC_MODEL_TAGRESOURCESREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT TagResourcesRequest : public RpcServiceRequest + { + struct Tag + { + std::string value; + std::string key; + }; + + public: + TagResourcesRequest(); + ~TagResourcesRequest(); + + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::vector getTag()const; + void setTag(const std::vector& tag); + std::vector getResourceId()const; + void setResourceId(const std::vector& resourceId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getResourceType()const; + void setResourceType(const std::string& resourceType); + + private: + std::string accessKeyId_; + std::vector tag_; + std::vector resourceId_; + std::string resourceOwnerAccount_; + long ownerId_; + std::string resourceType_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_TAGRESOURCESREQUEST_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/TagResourcesResult.h b/smc/include/alibabacloud/smc/model/TagResourcesResult.h new file mode 100644 index 000000000..f8a5c7dfe --- /dev/null +++ b/smc/include/alibabacloud/smc/model/TagResourcesResult.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_SMC_MODEL_TAGRESOURCESRESULT_H_ +#define ALIBABACLOUD_SMC_MODEL_TAGRESOURCESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT TagResourcesResult : public ServiceResult + { + public: + + + TagResourcesResult(); + explicit TagResourcesResult(const std::string &payload); + ~TagResourcesResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_TAGRESOURCESRESULT_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/UntagResourcesRequest.h b/smc/include/alibabacloud/smc/model/UntagResourcesRequest.h new file mode 100644 index 000000000..5fcce017e --- /dev/null +++ b/smc/include/alibabacloud/smc/model/UntagResourcesRequest.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_SMC_MODEL_UNTAGRESOURCESREQUEST_H_ +#define ALIBABACLOUD_SMC_MODEL_UNTAGRESOURCESREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT UntagResourcesRequest : public RpcServiceRequest + { + + public: + UntagResourcesRequest(); + ~UntagResourcesRequest(); + + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + bool getAll()const; + void setAll(bool all); + std::vector getResourceId()const; + void setResourceId(const std::vector& resourceId); + std::string getResourceOwnerAccount()const; + void setResourceOwnerAccount(const std::string& resourceOwnerAccount); + long getOwnerId()const; + void setOwnerId(long ownerId); + std::string getResourceType()const; + void setResourceType(const std::string& resourceType); + std::vector getTagKey()const; + void setTagKey(const std::vector& tagKey); + + private: + std::string accessKeyId_; + bool all_; + std::vector resourceId_; + std::string resourceOwnerAccount_; + long ownerId_; + std::string resourceType_; + std::vector tagKey_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_UNTAGRESOURCESREQUEST_H_ \ No newline at end of file diff --git a/smc/include/alibabacloud/smc/model/UntagResourcesResult.h b/smc/include/alibabacloud/smc/model/UntagResourcesResult.h new file mode 100644 index 000000000..e445dfe40 --- /dev/null +++ b/smc/include/alibabacloud/smc/model/UntagResourcesResult.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_SMC_MODEL_UNTAGRESOURCESRESULT_H_ +#define ALIBABACLOUD_SMC_MODEL_UNTAGRESOURCESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Smc + { + namespace Model + { + class ALIBABACLOUD_SMC_EXPORT UntagResourcesResult : public ServiceResult + { + public: + + + UntagResourcesResult(); + explicit UntagResourcesResult(const std::string &payload); + ~UntagResourcesResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SMC_MODEL_UNTAGRESOURCESRESULT_H_ \ No newline at end of file diff --git a/smc/src/SmcClient.cc b/smc/src/SmcClient.cc new file mode 100644 index 000000000..d5b11aba9 --- /dev/null +++ b/smc/src/SmcClient.cc @@ -0,0 +1,485 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::Smc; +using namespace AlibabaCloud::Smc::Model; + +namespace +{ + const std::string SERVICE_NAME = "smc"; +} + +SmcClient::SmcClient(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, "smc"); +} + +SmcClient::SmcClient(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, "smc"); +} + +SmcClient::SmcClient(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, "smc"); +} + +SmcClient::~SmcClient() +{} + +SmcClient::CreateReplicationJobOutcome SmcClient::createReplicationJob(const CreateReplicationJobRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CreateReplicationJobOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateReplicationJobOutcome(CreateReplicationJobResult(outcome.result())); + else + return CreateReplicationJobOutcome(outcome.error()); +} + +void SmcClient::createReplicationJobAsync(const CreateReplicationJobRequest& request, const CreateReplicationJobAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createReplicationJob(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SmcClient::CreateReplicationJobOutcomeCallable SmcClient::createReplicationJobCallable(const CreateReplicationJobRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createReplicationJob(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SmcClient::DeleteReplicationJobOutcome SmcClient::deleteReplicationJob(const DeleteReplicationJobRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteReplicationJobOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteReplicationJobOutcome(DeleteReplicationJobResult(outcome.result())); + else + return DeleteReplicationJobOutcome(outcome.error()); +} + +void SmcClient::deleteReplicationJobAsync(const DeleteReplicationJobRequest& request, const DeleteReplicationJobAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteReplicationJob(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SmcClient::DeleteReplicationJobOutcomeCallable SmcClient::deleteReplicationJobCallable(const DeleteReplicationJobRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteReplicationJob(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SmcClient::DeleteSourceServerOutcome SmcClient::deleteSourceServer(const DeleteSourceServerRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteSourceServerOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteSourceServerOutcome(DeleteSourceServerResult(outcome.result())); + else + return DeleteSourceServerOutcome(outcome.error()); +} + +void SmcClient::deleteSourceServerAsync(const DeleteSourceServerRequest& request, const DeleteSourceServerAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteSourceServer(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SmcClient::DeleteSourceServerOutcomeCallable SmcClient::deleteSourceServerCallable(const DeleteSourceServerRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteSourceServer(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SmcClient::DescribeReplicationJobsOutcome SmcClient::describeReplicationJobs(const DescribeReplicationJobsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeReplicationJobsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeReplicationJobsOutcome(DescribeReplicationJobsResult(outcome.result())); + else + return DescribeReplicationJobsOutcome(outcome.error()); +} + +void SmcClient::describeReplicationJobsAsync(const DescribeReplicationJobsRequest& request, const DescribeReplicationJobsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeReplicationJobs(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SmcClient::DescribeReplicationJobsOutcomeCallable SmcClient::describeReplicationJobsCallable(const DescribeReplicationJobsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeReplicationJobs(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SmcClient::DescribeSourceServersOutcome SmcClient::describeSourceServers(const DescribeSourceServersRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeSourceServersOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeSourceServersOutcome(DescribeSourceServersResult(outcome.result())); + else + return DescribeSourceServersOutcome(outcome.error()); +} + +void SmcClient::describeSourceServersAsync(const DescribeSourceServersRequest& request, const DescribeSourceServersAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeSourceServers(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SmcClient::DescribeSourceServersOutcomeCallable SmcClient::describeSourceServersCallable(const DescribeSourceServersRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeSourceServers(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SmcClient::ListTagResourcesOutcome SmcClient::listTagResources(const ListTagResourcesRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListTagResourcesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListTagResourcesOutcome(ListTagResourcesResult(outcome.result())); + else + return ListTagResourcesOutcome(outcome.error()); +} + +void SmcClient::listTagResourcesAsync(const ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listTagResources(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SmcClient::ListTagResourcesOutcomeCallable SmcClient::listTagResourcesCallable(const ListTagResourcesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listTagResources(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SmcClient::ModifyReplicationJobAttributeOutcome SmcClient::modifyReplicationJobAttribute(const ModifyReplicationJobAttributeRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ModifyReplicationJobAttributeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ModifyReplicationJobAttributeOutcome(ModifyReplicationJobAttributeResult(outcome.result())); + else + return ModifyReplicationJobAttributeOutcome(outcome.error()); +} + +void SmcClient::modifyReplicationJobAttributeAsync(const ModifyReplicationJobAttributeRequest& request, const ModifyReplicationJobAttributeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, modifyReplicationJobAttribute(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SmcClient::ModifyReplicationJobAttributeOutcomeCallable SmcClient::modifyReplicationJobAttributeCallable(const ModifyReplicationJobAttributeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->modifyReplicationJobAttribute(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SmcClient::ModifySourceServerAttributeOutcome SmcClient::modifySourceServerAttribute(const ModifySourceServerAttributeRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ModifySourceServerAttributeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ModifySourceServerAttributeOutcome(ModifySourceServerAttributeResult(outcome.result())); + else + return ModifySourceServerAttributeOutcome(outcome.error()); +} + +void SmcClient::modifySourceServerAttributeAsync(const ModifySourceServerAttributeRequest& request, const ModifySourceServerAttributeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, modifySourceServerAttribute(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SmcClient::ModifySourceServerAttributeOutcomeCallable SmcClient::modifySourceServerAttributeCallable(const ModifySourceServerAttributeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->modifySourceServerAttribute(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SmcClient::StartReplicationJobOutcome SmcClient::startReplicationJob(const StartReplicationJobRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return StartReplicationJobOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return StartReplicationJobOutcome(StartReplicationJobResult(outcome.result())); + else + return StartReplicationJobOutcome(outcome.error()); +} + +void SmcClient::startReplicationJobAsync(const StartReplicationJobRequest& request, const StartReplicationJobAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, startReplicationJob(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SmcClient::StartReplicationJobOutcomeCallable SmcClient::startReplicationJobCallable(const StartReplicationJobRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->startReplicationJob(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SmcClient::StopReplicationJobOutcome SmcClient::stopReplicationJob(const StopReplicationJobRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return StopReplicationJobOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return StopReplicationJobOutcome(StopReplicationJobResult(outcome.result())); + else + return StopReplicationJobOutcome(outcome.error()); +} + +void SmcClient::stopReplicationJobAsync(const StopReplicationJobRequest& request, const StopReplicationJobAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, stopReplicationJob(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SmcClient::StopReplicationJobOutcomeCallable SmcClient::stopReplicationJobCallable(const StopReplicationJobRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->stopReplicationJob(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SmcClient::TagResourcesOutcome SmcClient::tagResources(const TagResourcesRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return TagResourcesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return TagResourcesOutcome(TagResourcesResult(outcome.result())); + else + return TagResourcesOutcome(outcome.error()); +} + +void SmcClient::tagResourcesAsync(const TagResourcesRequest& request, const TagResourcesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, tagResources(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SmcClient::TagResourcesOutcomeCallable SmcClient::tagResourcesCallable(const TagResourcesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->tagResources(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +SmcClient::UntagResourcesOutcome SmcClient::untagResources(const UntagResourcesRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UntagResourcesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UntagResourcesOutcome(UntagResourcesResult(outcome.result())); + else + return UntagResourcesOutcome(outcome.error()); +} + +void SmcClient::untagResourcesAsync(const UntagResourcesRequest& request, const UntagResourcesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, untagResources(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +SmcClient::UntagResourcesOutcomeCallable SmcClient::untagResourcesCallable(const UntagResourcesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->untagResources(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + diff --git a/smc/src/model/CreateReplicationJobRequest.cc b/smc/src/model/CreateReplicationJobRequest.cc new file mode 100644 index 000000000..d56985aea --- /dev/null +++ b/smc/src/model/CreateReplicationJobRequest.cc @@ -0,0 +1,303 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Smc::Model::CreateReplicationJobRequest; + +CreateReplicationJobRequest::CreateReplicationJobRequest() : + RpcServiceRequest("smc", "2019-06-01", "CreateReplicationJob") +{ + setMethod(HttpRequest::Method::Post); +} + +CreateReplicationJobRequest::~CreateReplicationJobRequest() +{} + +std::string CreateReplicationJobRequest::getTargetType()const +{ + return targetType_; +} + +void CreateReplicationJobRequest::setTargetType(const std::string& targetType) +{ + targetType_ = targetType; + setCoreParameter("TargetType", targetType); +} + +std::string CreateReplicationJobRequest::getClientToken()const +{ + return clientToken_; +} + +void CreateReplicationJobRequest::setClientToken(const std::string& clientToken) +{ + clientToken_ = clientToken; + setCoreParameter("ClientToken", clientToken); +} + +std::string CreateReplicationJobRequest::getDescription()const +{ + return description_; +} + +void CreateReplicationJobRequest::setDescription(const std::string& description) +{ + description_ = description; + setCoreParameter("Description", description); +} + +std::string CreateReplicationJobRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void CreateReplicationJobRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + +int CreateReplicationJobRequest::getFrequency()const +{ + return frequency_; +} + +void CreateReplicationJobRequest::setFrequency(int frequency) +{ + frequency_ = frequency; + setCoreParameter("Frequency", std::to_string(frequency)); +} + +std::string CreateReplicationJobRequest::getReplicationParameters()const +{ + return replicationParameters_; +} + +void CreateReplicationJobRequest::setReplicationParameters(const std::string& replicationParameters) +{ + replicationParameters_ = replicationParameters; + setCoreParameter("ReplicationParameters", replicationParameters); +} + +std::string CreateReplicationJobRequest::getRegionId()const +{ + return regionId_; +} + +void CreateReplicationJobRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setCoreParameter("RegionId", regionId); +} + +std::string CreateReplicationJobRequest::getImageName()const +{ + return imageName_; +} + +void CreateReplicationJobRequest::setImageName(const std::string& imageName) +{ + imageName_ = imageName; + setCoreParameter("ImageName", imageName); +} + +int CreateReplicationJobRequest::getSystemDiskSize()const +{ + return systemDiskSize_; +} + +void CreateReplicationJobRequest::setSystemDiskSize(int systemDiskSize) +{ + systemDiskSize_ = systemDiskSize; + setCoreParameter("SystemDiskSize", std::to_string(systemDiskSize)); +} + +std::string CreateReplicationJobRequest::getInstanceType()const +{ + return instanceType_; +} + +void CreateReplicationJobRequest::setInstanceType(const std::string& instanceType) +{ + instanceType_ = instanceType; + setCoreParameter("InstanceType", instanceType); +} + +std::vector CreateReplicationJobRequest::getTag()const +{ + return tag_; +} + +void CreateReplicationJobRequest::setTag(const std::vector& tag) +{ + tag_ = tag; + for(int dep1 = 0; dep1!= tag.size(); dep1++) { + auto tagObj = tag.at(dep1); + std::string tagObjStr = "Tag." + std::to_string(dep1); + setCoreParameter(tagObjStr + ".Value", tagObj.value); + setCoreParameter(tagObjStr + ".Key", tagObj.key); + } +} + +int CreateReplicationJobRequest::getNetMode()const +{ + return netMode_; +} + +void CreateReplicationJobRequest::setNetMode(int netMode) +{ + netMode_ = netMode; + setCoreParameter("NetMode", std::to_string(netMode)); +} + +std::string CreateReplicationJobRequest::getSourceId()const +{ + return sourceId_; +} + +void CreateReplicationJobRequest::setSourceId(const std::string& sourceId) +{ + sourceId_ = sourceId; + setCoreParameter("SourceId", sourceId); +} + +bool CreateReplicationJobRequest::getRunOnce()const +{ + return runOnce_; +} + +void CreateReplicationJobRequest::setRunOnce(bool runOnce) +{ + runOnce_ = runOnce; + setCoreParameter("RunOnce", runOnce ? "true" : "false"); +} + +std::string CreateReplicationJobRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void CreateReplicationJobRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +std::string CreateReplicationJobRequest::getValidTime()const +{ + return validTime_; +} + +void CreateReplicationJobRequest::setValidTime(const std::string& validTime) +{ + validTime_ = validTime; + setCoreParameter("ValidTime", validTime); +} + +long CreateReplicationJobRequest::getOwnerId()const +{ + return ownerId_; +} + +void CreateReplicationJobRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setCoreParameter("OwnerId", std::to_string(ownerId)); +} + +std::vector CreateReplicationJobRequest::getDataDisk()const +{ + return dataDisk_; +} + +void CreateReplicationJobRequest::setDataDisk(const std::vector& dataDisk) +{ + dataDisk_ = dataDisk; + for(int dep1 = 0; dep1!= dataDisk.size(); dep1++) { + auto dataDiskObj = dataDisk.at(dep1); + std::string dataDiskObjStr = "DataDisk." + std::to_string(dep1); + setCoreParameter(dataDiskObjStr + ".Size", std::to_string(dataDiskObj.size)); + setCoreParameter(dataDiskObjStr + ".Index", std::to_string(dataDiskObj.index)); + } +} + +std::string CreateReplicationJobRequest::getVSwitchId()const +{ + return vSwitchId_; +} + +void CreateReplicationJobRequest::setVSwitchId(const std::string& vSwitchId) +{ + vSwitchId_ = vSwitchId; + setCoreParameter("VSwitchId", vSwitchId); +} + +std::string CreateReplicationJobRequest::getScheduledStartTime()const +{ + return scheduledStartTime_; +} + +void CreateReplicationJobRequest::setScheduledStartTime(const std::string& scheduledStartTime) +{ + scheduledStartTime_ = scheduledStartTime; + setCoreParameter("ScheduledStartTime", scheduledStartTime); +} + +std::string CreateReplicationJobRequest::getInstanceId()const +{ + return instanceId_; +} + +void CreateReplicationJobRequest::setInstanceId(const std::string& instanceId) +{ + instanceId_ = instanceId; + setCoreParameter("InstanceId", instanceId); +} + +std::string CreateReplicationJobRequest::getVpcId()const +{ + return vpcId_; +} + +void CreateReplicationJobRequest::setVpcId(const std::string& vpcId) +{ + vpcId_ = vpcId; + setCoreParameter("VpcId", vpcId); +} + +std::string CreateReplicationJobRequest::getName()const +{ + return name_; +} + +void CreateReplicationJobRequest::setName(const std::string& name) +{ + name_ = name; + setCoreParameter("Name", name); +} + +int CreateReplicationJobRequest::getMaxNumberOfImageToKeep()const +{ + return maxNumberOfImageToKeep_; +} + +void CreateReplicationJobRequest::setMaxNumberOfImageToKeep(int maxNumberOfImageToKeep) +{ + maxNumberOfImageToKeep_ = maxNumberOfImageToKeep; + setCoreParameter("MaxNumberOfImageToKeep", std::to_string(maxNumberOfImageToKeep)); +} + diff --git a/smc/src/model/CreateReplicationJobResult.cc b/smc/src/model/CreateReplicationJobResult.cc new file mode 100644 index 000000000..64b6a7d63 --- /dev/null +++ b/smc/src/model/CreateReplicationJobResult.cc @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Smc; +using namespace AlibabaCloud::Smc::Model; + +CreateReplicationJobResult::CreateReplicationJobResult() : + ServiceResult() +{} + +CreateReplicationJobResult::CreateReplicationJobResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateReplicationJobResult::~CreateReplicationJobResult() +{} + +void CreateReplicationJobResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["JobId"].isNull()) + jobId_ = value["JobId"].asString(); + +} + +std::string CreateReplicationJobResult::getJobId()const +{ + return jobId_; +} + diff --git a/smc/src/model/DeleteReplicationJobRequest.cc b/smc/src/model/DeleteReplicationJobRequest.cc new file mode 100644 index 000000000..7b4043e02 --- /dev/null +++ b/smc/src/model/DeleteReplicationJobRequest.cc @@ -0,0 +1,73 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Smc::Model::DeleteReplicationJobRequest; + +DeleteReplicationJobRequest::DeleteReplicationJobRequest() : + RpcServiceRequest("smc", "2019-06-01", "DeleteReplicationJob") +{ + setMethod(HttpRequest::Method::Post); +} + +DeleteReplicationJobRequest::~DeleteReplicationJobRequest() +{} + +std::string DeleteReplicationJobRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DeleteReplicationJobRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +long DeleteReplicationJobRequest::getOwnerId()const +{ + return ownerId_; +} + +void DeleteReplicationJobRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setCoreParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DeleteReplicationJobRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DeleteReplicationJobRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + +std::string DeleteReplicationJobRequest::getJobId()const +{ + return jobId_; +} + +void DeleteReplicationJobRequest::setJobId(const std::string& jobId) +{ + jobId_ = jobId; + setCoreParameter("JobId", jobId); +} + diff --git a/smc/src/model/DeleteReplicationJobResult.cc b/smc/src/model/DeleteReplicationJobResult.cc new file mode 100644 index 000000000..e8102eaa3 --- /dev/null +++ b/smc/src/model/DeleteReplicationJobResult.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::Smc; +using namespace AlibabaCloud::Smc::Model; + +DeleteReplicationJobResult::DeleteReplicationJobResult() : + ServiceResult() +{} + +DeleteReplicationJobResult::DeleteReplicationJobResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteReplicationJobResult::~DeleteReplicationJobResult() +{} + +void DeleteReplicationJobResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/smc/src/model/DeleteSourceServerRequest.cc b/smc/src/model/DeleteSourceServerRequest.cc new file mode 100644 index 000000000..98443b474 --- /dev/null +++ b/smc/src/model/DeleteSourceServerRequest.cc @@ -0,0 +1,84 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::Smc::Model::DeleteSourceServerRequest; + +DeleteSourceServerRequest::DeleteSourceServerRequest() : + RpcServiceRequest("smc", "2019-06-01", "DeleteSourceServer") +{ + setMethod(HttpRequest::Method::Post); +} + +DeleteSourceServerRequest::~DeleteSourceServerRequest() +{} + +std::string DeleteSourceServerRequest::getSourceId()const +{ + return sourceId_; +} + +void DeleteSourceServerRequest::setSourceId(const std::string& sourceId) +{ + sourceId_ = sourceId; + setCoreParameter("SourceId", sourceId); +} + +std::string DeleteSourceServerRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DeleteSourceServerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +long DeleteSourceServerRequest::getOwnerId()const +{ + return ownerId_; +} + +void DeleteSourceServerRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setCoreParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DeleteSourceServerRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DeleteSourceServerRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + +bool DeleteSourceServerRequest::getForce()const +{ + return force_; +} + +void DeleteSourceServerRequest::setForce(bool force) +{ + force_ = force; + setCoreParameter("Force", force ? "true" : "false"); +} + diff --git a/smc/src/model/DeleteSourceServerResult.cc b/smc/src/model/DeleteSourceServerResult.cc new file mode 100644 index 000000000..687b8381c --- /dev/null +++ b/smc/src/model/DeleteSourceServerResult.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::Smc; +using namespace AlibabaCloud::Smc::Model; + +DeleteSourceServerResult::DeleteSourceServerResult() : + ServiceResult() +{} + +DeleteSourceServerResult::DeleteSourceServerResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteSourceServerResult::~DeleteSourceServerResult() +{} + +void DeleteSourceServerResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/smc/src/model/DescribeReplicationJobsRequest.cc b/smc/src/model/DescribeReplicationJobsRequest.cc new file mode 100644 index 000000000..8027e1736 --- /dev/null +++ b/smc/src/model/DescribeReplicationJobsRequest.cc @@ -0,0 +1,154 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::Smc::Model::DescribeReplicationJobsRequest; + +DescribeReplicationJobsRequest::DescribeReplicationJobsRequest() : + RpcServiceRequest("smc", "2019-06-01", "DescribeReplicationJobs") +{ + setMethod(HttpRequest::Method::Post); +} + +DescribeReplicationJobsRequest::~DescribeReplicationJobsRequest() +{} + +int DescribeReplicationJobsRequest::getPageNumber()const +{ + return pageNumber_; +} + +void DescribeReplicationJobsRequest::setPageNumber(int pageNumber) +{ + pageNumber_ = pageNumber; + setCoreParameter("PageNumber", std::to_string(pageNumber)); +} + +std::string DescribeReplicationJobsRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeReplicationJobsRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + +std::vector DescribeReplicationJobsRequest::getJobId()const +{ + return jobId_; +} + +void DescribeReplicationJobsRequest::setJobId(const std::vector& jobId) +{ + jobId_ = jobId; + for(int dep1 = 0; dep1!= jobId.size(); dep1++) { + setCoreParameter("JobId."+ std::to_string(dep1), jobId.at(dep1)); + } +} + +std::string DescribeReplicationJobsRequest::getRegionId()const +{ + return regionId_; +} + +void DescribeReplicationJobsRequest::setRegionId(const std::string& regionId) +{ + regionId_ = regionId; + setCoreParameter("RegionId", regionId); +} + +int DescribeReplicationJobsRequest::getPageSize()const +{ + return pageSize_; +} + +void DescribeReplicationJobsRequest::setPageSize(int pageSize) +{ + pageSize_ = pageSize; + setCoreParameter("PageSize", std::to_string(pageSize)); +} + +std::vector DescribeReplicationJobsRequest::getSourceId()const +{ + return sourceId_; +} + +void DescribeReplicationJobsRequest::setSourceId(const std::vector& sourceId) +{ + sourceId_ = sourceId; + for(int dep1 = 0; dep1!= sourceId.size(); dep1++) { + setCoreParameter("SourceId."+ std::to_string(dep1), sourceId.at(dep1)); + } +} + +std::string DescribeReplicationJobsRequest::getBusinessStatus()const +{ + return businessStatus_; +} + +void DescribeReplicationJobsRequest::setBusinessStatus(const std::string& businessStatus) +{ + businessStatus_ = businessStatus; + setCoreParameter("BusinessStatus", businessStatus); +} + +std::string DescribeReplicationJobsRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeReplicationJobsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +long DescribeReplicationJobsRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeReplicationJobsRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setCoreParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeReplicationJobsRequest::getName()const +{ + return name_; +} + +void DescribeReplicationJobsRequest::setName(const std::string& name) +{ + name_ = name; + setCoreParameter("Name", name); +} + +std::string DescribeReplicationJobsRequest::getStatus()const +{ + return status_; +} + +void DescribeReplicationJobsRequest::setStatus(const std::string& status) +{ + status_ = status; + setCoreParameter("Status", status); +} + diff --git a/smc/src/model/DescribeReplicationJobsResult.cc b/smc/src/model/DescribeReplicationJobsResult.cc new file mode 100644 index 000000000..f1ec32e73 --- /dev/null +++ b/smc/src/model/DescribeReplicationJobsResult.cc @@ -0,0 +1,158 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::Smc; +using namespace AlibabaCloud::Smc::Model; + +DescribeReplicationJobsResult::DescribeReplicationJobsResult() : + ServiceResult() +{} + +DescribeReplicationJobsResult::DescribeReplicationJobsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeReplicationJobsResult::~DescribeReplicationJobsResult() +{} + +void DescribeReplicationJobsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allReplicationJobsNode = value["ReplicationJobs"]["ReplicationJob"]; + for (auto valueReplicationJobsReplicationJob : allReplicationJobsNode) + { + ReplicationJob replicationJobsObject; + if(!valueReplicationJobsReplicationJob["JobId"].isNull()) + replicationJobsObject.jobId = valueReplicationJobsReplicationJob["JobId"].asString(); + if(!valueReplicationJobsReplicationJob["SourceId"].isNull()) + replicationJobsObject.sourceId = valueReplicationJobsReplicationJob["SourceId"].asString(); + if(!valueReplicationJobsReplicationJob["Name"].isNull()) + replicationJobsObject.name = valueReplicationJobsReplicationJob["Name"].asString(); + if(!valueReplicationJobsReplicationJob["Description"].isNull()) + replicationJobsObject.description = valueReplicationJobsReplicationJob["Description"].asString(); + if(!valueReplicationJobsReplicationJob["RegionId"].isNull()) + replicationJobsObject.regionId = valueReplicationJobsReplicationJob["RegionId"].asString(); + if(!valueReplicationJobsReplicationJob["TargetType"].isNull()) + replicationJobsObject.targetType = valueReplicationJobsReplicationJob["TargetType"].asString(); + if(!valueReplicationJobsReplicationJob["ScheduledStartTime"].isNull()) + replicationJobsObject.scheduledStartTime = valueReplicationJobsReplicationJob["ScheduledStartTime"].asString(); + if(!valueReplicationJobsReplicationJob["ImageName"].isNull()) + replicationJobsObject.imageName = valueReplicationJobsReplicationJob["ImageName"].asString(); + if(!valueReplicationJobsReplicationJob["InstanceId"].isNull()) + replicationJobsObject.instanceId = valueReplicationJobsReplicationJob["InstanceId"].asString(); + if(!valueReplicationJobsReplicationJob["ImageId"].isNull()) + replicationJobsObject.imageId = valueReplicationJobsReplicationJob["ImageId"].asString(); + if(!valueReplicationJobsReplicationJob["Status"].isNull()) + replicationJobsObject.status = valueReplicationJobsReplicationJob["Status"].asString(); + if(!valueReplicationJobsReplicationJob["BusinessStatus"].isNull()) + replicationJobsObject.businessStatus = valueReplicationJobsReplicationJob["BusinessStatus"].asString(); + if(!valueReplicationJobsReplicationJob["ErrorCode"].isNull()) + replicationJobsObject.errorCode = valueReplicationJobsReplicationJob["ErrorCode"].asString(); + if(!valueReplicationJobsReplicationJob["Progress"].isNull()) + replicationJobsObject.progress = std::stof(valueReplicationJobsReplicationJob["Progress"].asString()); + if(!valueReplicationJobsReplicationJob["CreationTime"].isNull()) + replicationJobsObject.creationTime = valueReplicationJobsReplicationJob["CreationTime"].asString(); + if(!valueReplicationJobsReplicationJob["ValidTime"].isNull()) + replicationJobsObject.validTime = valueReplicationJobsReplicationJob["ValidTime"].asString(); + if(!valueReplicationJobsReplicationJob["StartTime"].isNull()) + replicationJobsObject.startTime = valueReplicationJobsReplicationJob["StartTime"].asString(); + if(!valueReplicationJobsReplicationJob["EndTime"].isNull()) + replicationJobsObject.endTime = valueReplicationJobsReplicationJob["EndTime"].asString(); + if(!valueReplicationJobsReplicationJob["NetMode"].isNull()) + replicationJobsObject.netMode = std::stoi(valueReplicationJobsReplicationJob["NetMode"].asString()); + if(!valueReplicationJobsReplicationJob["SystemDiskSize"].isNull()) + replicationJobsObject.systemDiskSize = std::stoi(valueReplicationJobsReplicationJob["SystemDiskSize"].asString()); + if(!valueReplicationJobsReplicationJob["VpcId"].isNull()) + replicationJobsObject.vpcId = valueReplicationJobsReplicationJob["VpcId"].asString(); + if(!valueReplicationJobsReplicationJob["VSwitchId"].isNull()) + replicationJobsObject.vSwitchId = valueReplicationJobsReplicationJob["VSwitchId"].asString(); + if(!valueReplicationJobsReplicationJob["TransitionInstanceId"].isNull()) + replicationJobsObject.transitionInstanceId = valueReplicationJobsReplicationJob["TransitionInstanceId"].asString(); + if(!valueReplicationJobsReplicationJob["StatusInfo"].isNull()) + replicationJobsObject.statusInfo = valueReplicationJobsReplicationJob["StatusInfo"].asString(); + if(!valueReplicationJobsReplicationJob["ReplicationParameters"].isNull()) + replicationJobsObject.replicationParameters = valueReplicationJobsReplicationJob["ReplicationParameters"].asString(); + if(!valueReplicationJobsReplicationJob["RunOnce"].isNull()) + replicationJobsObject.runOnce = valueReplicationJobsReplicationJob["RunOnce"].asString() == "true"; + if(!valueReplicationJobsReplicationJob["Frequency"].isNull()) + replicationJobsObject.frequency = std::stoi(valueReplicationJobsReplicationJob["Frequency"].asString()); + if(!valueReplicationJobsReplicationJob["MaxNumberOfImageToKeep"].isNull()) + replicationJobsObject.maxNumberOfImageToKeep = std::stoi(valueReplicationJobsReplicationJob["MaxNumberOfImageToKeep"].asString()); + if(!valueReplicationJobsReplicationJob["InstanceType"].isNull()) + replicationJobsObject.instanceType = valueReplicationJobsReplicationJob["InstanceType"].asString(); + auto allDataDisksNode = allReplicationJobsNode["DataDisks"]["DataDisk"]; + for (auto allReplicationJobsNodeDataDisksDataDisk : allDataDisksNode) + { + ReplicationJob::DataDisk dataDisksObject; + if(!allReplicationJobsNodeDataDisksDataDisk["Size"].isNull()) + dataDisksObject.size = std::stoi(allReplicationJobsNodeDataDisksDataDisk["Size"].asString()); + if(!allReplicationJobsNodeDataDisksDataDisk["Index"].isNull()) + dataDisksObject.index = std::stoi(allReplicationJobsNodeDataDisksDataDisk["Index"].asString()); + replicationJobsObject.dataDisks.push_back(dataDisksObject); + } + auto allReplicationJobRunsNode = allReplicationJobsNode["ReplicationJobRuns"]["ReplicationJobRun"]; + for (auto allReplicationJobsNodeReplicationJobRunsReplicationJobRun : allReplicationJobRunsNode) + { + ReplicationJob::ReplicationJobRun replicationJobRunsObject; + if(!allReplicationJobsNodeReplicationJobRunsReplicationJobRun["ImageId"].isNull()) + replicationJobRunsObject.imageId = allReplicationJobsNodeReplicationJobRunsReplicationJobRun["ImageId"].asString(); + if(!allReplicationJobsNodeReplicationJobRunsReplicationJobRun["Type"].isNull()) + replicationJobRunsObject.type = allReplicationJobsNodeReplicationJobRunsReplicationJobRun["Type"].asString(); + if(!allReplicationJobsNodeReplicationJobRunsReplicationJobRun["StartTime"].isNull()) + replicationJobRunsObject.startTime = allReplicationJobsNodeReplicationJobRunsReplicationJobRun["StartTime"].asString(); + if(!allReplicationJobsNodeReplicationJobRunsReplicationJobRun["EndTime"].isNull()) + replicationJobRunsObject.endTime = allReplicationJobsNodeReplicationJobRunsReplicationJobRun["EndTime"].asString(); + replicationJobsObject.replicationJobRuns.push_back(replicationJobRunsObject); + } + replicationJobs_.push_back(replicationJobsObject); + } + if(!value["TotalCount"].isNull()) + totalCount_ = std::stoi(value["TotalCount"].asString()); + if(!value["PageNumber"].isNull()) + pageNumber_ = std::stoi(value["PageNumber"].asString()); + if(!value["PageSize"].isNull()) + pageSize_ = std::stoi(value["PageSize"].asString()); + +} + +int DescribeReplicationJobsResult::getTotalCount()const +{ + return totalCount_; +} + +std::vector DescribeReplicationJobsResult::getReplicationJobs()const +{ + return replicationJobs_; +} + +int DescribeReplicationJobsResult::getPageSize()const +{ + return pageSize_; +} + +int DescribeReplicationJobsResult::getPageNumber()const +{ + return pageNumber_; +} + diff --git a/smc/src/model/DescribeSourceServersRequest.cc b/smc/src/model/DescribeSourceServersRequest.cc new file mode 100644 index 000000000..163edfd56 --- /dev/null +++ b/smc/src/model/DescribeSourceServersRequest.cc @@ -0,0 +1,130 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::Smc::Model::DescribeSourceServersRequest; + +DescribeSourceServersRequest::DescribeSourceServersRequest() : + RpcServiceRequest("smc", "2019-06-01", "DescribeSourceServers") +{ + setMethod(HttpRequest::Method::Post); +} + +DescribeSourceServersRequest::~DescribeSourceServersRequest() +{} + +int DescribeSourceServersRequest::getPageNumber()const +{ + return pageNumber_; +} + +void DescribeSourceServersRequest::setPageNumber(int pageNumber) +{ + pageNumber_ = pageNumber; + setCoreParameter("PageNumber", std::to_string(pageNumber)); +} + +std::string DescribeSourceServersRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void DescribeSourceServersRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + +std::string DescribeSourceServersRequest::getJobId()const +{ + return jobId_; +} + +void DescribeSourceServersRequest::setJobId(const std::string& jobId) +{ + jobId_ = jobId; + setCoreParameter("JobId", jobId); +} + +int DescribeSourceServersRequest::getPageSize()const +{ + return pageSize_; +} + +void DescribeSourceServersRequest::setPageSize(int pageSize) +{ + pageSize_ = pageSize; + setCoreParameter("PageSize", std::to_string(pageSize)); +} + +std::string DescribeSourceServersRequest::getState()const +{ + return state_; +} + +void DescribeSourceServersRequest::setState(const std::string& state) +{ + state_ = state; + setCoreParameter("State", state); +} + +std::vector DescribeSourceServersRequest::getSourceId()const +{ + return sourceId_; +} + +void DescribeSourceServersRequest::setSourceId(const std::vector& sourceId) +{ + sourceId_ = sourceId; + for(int dep1 = 0; dep1!= sourceId.size(); dep1++) { + setCoreParameter("SourceId."+ std::to_string(dep1), sourceId.at(dep1)); + } +} + +std::string DescribeSourceServersRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void DescribeSourceServersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +long DescribeSourceServersRequest::getOwnerId()const +{ + return ownerId_; +} + +void DescribeSourceServersRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setCoreParameter("OwnerId", std::to_string(ownerId)); +} + +std::string DescribeSourceServersRequest::getName()const +{ + return name_; +} + +void DescribeSourceServersRequest::setName(const std::string& name) +{ + name_ = name; + setCoreParameter("Name", name); +} + diff --git a/smc/src/model/DescribeSourceServersResult.cc b/smc/src/model/DescribeSourceServersResult.cc new file mode 100644 index 000000000..2e664a6cd --- /dev/null +++ b/smc/src/model/DescribeSourceServersResult.cc @@ -0,0 +1,120 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::Smc; +using namespace AlibabaCloud::Smc::Model; + +DescribeSourceServersResult::DescribeSourceServersResult() : + ServiceResult() +{} + +DescribeSourceServersResult::DescribeSourceServersResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeSourceServersResult::~DescribeSourceServersResult() +{} + +void DescribeSourceServersResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allSourceServersNode = value["SourceServers"]["SourceServer"]; + for (auto valueSourceServersSourceServer : allSourceServersNode) + { + SourceServer sourceServersObject; + if(!valueSourceServersSourceServer["SourceId"].isNull()) + sourceServersObject.sourceId = valueSourceServersSourceServer["SourceId"].asString(); + if(!valueSourceServersSourceServer["JobId"].isNull()) + sourceServersObject.jobId = valueSourceServersSourceServer["JobId"].asString(); + if(!valueSourceServersSourceServer["AgentVersion"].isNull()) + sourceServersObject.agentVersion = valueSourceServersSourceServer["AgentVersion"].asString(); + if(!valueSourceServersSourceServer["Name"].isNull()) + sourceServersObject.name = valueSourceServersSourceServer["Name"].asString(); + if(!valueSourceServersSourceServer["Description"].isNull()) + sourceServersObject.description = valueSourceServersSourceServer["Description"].asString(); + if(!valueSourceServersSourceServer["KernelLevel"].isNull()) + sourceServersObject.kernelLevel = std::stoi(valueSourceServersSourceServer["KernelLevel"].asString()); + if(!valueSourceServersSourceServer["Platform"].isNull()) + sourceServersObject.platform = valueSourceServersSourceServer["Platform"].asString(); + if(!valueSourceServersSourceServer["Architecture"].isNull()) + sourceServersObject.architecture = valueSourceServersSourceServer["Architecture"].asString(); + if(!valueSourceServersSourceServer["SystemDiskSize"].isNull()) + sourceServersObject.systemDiskSize = std::stoi(valueSourceServersSourceServer["SystemDiskSize"].asString()); + if(!valueSourceServersSourceServer["ReplicationDriver"].isNull()) + sourceServersObject.replicationDriver = valueSourceServersSourceServer["ReplicationDriver"].asString(); + if(!valueSourceServersSourceServer["SystemInfo"].isNull()) + sourceServersObject.systemInfo = valueSourceServersSourceServer["SystemInfo"].asString(); + if(!valueSourceServersSourceServer["CreationTime"].isNull()) + sourceServersObject.creationTime = valueSourceServersSourceServer["CreationTime"].asString(); + if(!valueSourceServersSourceServer["State"].isNull()) + sourceServersObject.state = valueSourceServersSourceServer["State"].asString(); + if(!valueSourceServersSourceServer["ErrorCode"].isNull()) + sourceServersObject.errorCode = valueSourceServersSourceServer["ErrorCode"].asString(); + if(!valueSourceServersSourceServer["StatusInfo"].isNull()) + sourceServersObject.statusInfo = valueSourceServersSourceServer["StatusInfo"].asString(); + if(!valueSourceServersSourceServer["HeartbeatRate"].isNull()) + sourceServersObject.heartbeatRate = std::stoi(valueSourceServersSourceServer["HeartbeatRate"].asString()); + auto allDataDisksNode = allSourceServersNode["DataDisks"]["DataDisk"]; + for (auto allSourceServersNodeDataDisksDataDisk : allDataDisksNode) + { + SourceServer::DataDisk dataDisksObject; + if(!allSourceServersNodeDataDisksDataDisk["Index"].isNull()) + dataDisksObject.index = std::stoi(allSourceServersNodeDataDisksDataDisk["Index"].asString()); + if(!allSourceServersNodeDataDisksDataDisk["Size"].isNull()) + dataDisksObject.size = std::stoi(allSourceServersNodeDataDisksDataDisk["Size"].asString()); + if(!allSourceServersNodeDataDisksDataDisk["Path"].isNull()) + dataDisksObject.path = allSourceServersNodeDataDisksDataDisk["Path"].asString(); + sourceServersObject.dataDisks.push_back(dataDisksObject); + } + sourceServers_.push_back(sourceServersObject); + } + if(!value["TotalCount"].isNull()) + totalCount_ = std::stoi(value["TotalCount"].asString()); + if(!value["PageNumber"].isNull()) + pageNumber_ = std::stoi(value["PageNumber"].asString()); + if(!value["PageSize"].isNull()) + pageSize_ = std::stoi(value["PageSize"].asString()); + +} + +std::vector DescribeSourceServersResult::getSourceServers()const +{ + return sourceServers_; +} + +int DescribeSourceServersResult::getTotalCount()const +{ + return totalCount_; +} + +int DescribeSourceServersResult::getPageSize()const +{ + return pageSize_; +} + +int DescribeSourceServersResult::getPageNumber()const +{ + return pageNumber_; +} + diff --git a/smc/src/model/ListTagResourcesRequest.cc b/smc/src/model/ListTagResourcesRequest.cc new file mode 100644 index 000000000..60b7ef8fd --- /dev/null +++ b/smc/src/model/ListTagResourcesRequest.cc @@ -0,0 +1,113 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::Smc::Model::ListTagResourcesRequest; + +ListTagResourcesRequest::ListTagResourcesRequest() : + RpcServiceRequest("smc", "2019-06-01", "ListTagResources") +{ + setMethod(HttpRequest::Method::Post); +} + +ListTagResourcesRequest::~ListTagResourcesRequest() +{} + +std::string ListTagResourcesRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void ListTagResourcesRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + +std::string ListTagResourcesRequest::getNextToken()const +{ + return nextToken_; +} + +void ListTagResourcesRequest::setNextToken(const std::string& nextToken) +{ + nextToken_ = nextToken; + setCoreParameter("NextToken", nextToken); +} + +std::vector ListTagResourcesRequest::getTag()const +{ + return tag_; +} + +void ListTagResourcesRequest::setTag(const std::vector& tag) +{ + tag_ = tag; + for(int dep1 = 0; dep1!= tag.size(); dep1++) { + auto tagObj = tag.at(dep1); + std::string tagObjStr = "Tag." + std::to_string(dep1); + setCoreParameter(tagObjStr + ".Value", tagObj.value); + setCoreParameter(tagObjStr + ".Key", tagObj.key); + } +} + +std::vector ListTagResourcesRequest::getResourceId()const +{ + return resourceId_; +} + +void ListTagResourcesRequest::setResourceId(const std::vector& resourceId) +{ + resourceId_ = resourceId; + for(int dep1 = 0; dep1!= resourceId.size(); dep1++) { + setCoreParameter("ResourceId."+ std::to_string(dep1), resourceId.at(dep1)); + } +} + +std::string ListTagResourcesRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void ListTagResourcesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +long ListTagResourcesRequest::getOwnerId()const +{ + return ownerId_; +} + +void ListTagResourcesRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setCoreParameter("OwnerId", std::to_string(ownerId)); +} + +std::string ListTagResourcesRequest::getResourceType()const +{ + return resourceType_; +} + +void ListTagResourcesRequest::setResourceType(const std::string& resourceType) +{ + resourceType_ = resourceType; + setCoreParameter("ResourceType", resourceType); +} + diff --git a/smc/src/model/ListTagResourcesResult.cc b/smc/src/model/ListTagResourcesResult.cc new file mode 100644 index 000000000..69d17dd54 --- /dev/null +++ b/smc/src/model/ListTagResourcesResult.cc @@ -0,0 +1,70 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Smc; +using namespace AlibabaCloud::Smc::Model; + +ListTagResourcesResult::ListTagResourcesResult() : + ServiceResult() +{} + +ListTagResourcesResult::ListTagResourcesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListTagResourcesResult::~ListTagResourcesResult() +{} + +void ListTagResourcesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allTagResourcesNode = value["TagResources"]["TagResource"]; + for (auto valueTagResourcesTagResource : allTagResourcesNode) + { + TagResource tagResourcesObject; + if(!valueTagResourcesTagResource["ResourceType"].isNull()) + tagResourcesObject.resourceType = valueTagResourcesTagResource["ResourceType"].asString(); + if(!valueTagResourcesTagResource["ResourceId"].isNull()) + tagResourcesObject.resourceId = valueTagResourcesTagResource["ResourceId"].asString(); + if(!valueTagResourcesTagResource["TagKey"].isNull()) + tagResourcesObject.tagKey = valueTagResourcesTagResource["TagKey"].asString(); + if(!valueTagResourcesTagResource["TagValue"].isNull()) + tagResourcesObject.tagValue = valueTagResourcesTagResource["TagValue"].asString(); + tagResources_.push_back(tagResourcesObject); + } + if(!value["NextToken"].isNull()) + nextToken_ = value["NextToken"].asString(); + +} + +std::string ListTagResourcesResult::getNextToken()const +{ + return nextToken_; +} + +std::vector ListTagResourcesResult::getTagResources()const +{ + return tagResources_; +} + diff --git a/smc/src/model/ModifyReplicationJobAttributeRequest.cc b/smc/src/model/ModifyReplicationJobAttributeRequest.cc new file mode 100644 index 000000000..18be48ba3 --- /dev/null +++ b/smc/src/model/ModifyReplicationJobAttributeRequest.cc @@ -0,0 +1,199 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::Smc::Model::ModifyReplicationJobAttributeRequest; + +ModifyReplicationJobAttributeRequest::ModifyReplicationJobAttributeRequest() : + RpcServiceRequest("smc", "2019-06-01", "ModifyReplicationJobAttribute") +{ + setMethod(HttpRequest::Method::Post); +} + +ModifyReplicationJobAttributeRequest::~ModifyReplicationJobAttributeRequest() +{} + +std::string ModifyReplicationJobAttributeRequest::getTargetType()const +{ + return targetType_; +} + +void ModifyReplicationJobAttributeRequest::setTargetType(const std::string& targetType) +{ + targetType_ = targetType; + setCoreParameter("TargetType", targetType); +} + +std::string ModifyReplicationJobAttributeRequest::getDescription()const +{ + return description_; +} + +void ModifyReplicationJobAttributeRequest::setDescription(const std::string& description) +{ + description_ = description; + setCoreParameter("Description", description); +} + +std::string ModifyReplicationJobAttributeRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void ModifyReplicationJobAttributeRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + +int ModifyReplicationJobAttributeRequest::getFrequency()const +{ + return frequency_; +} + +void ModifyReplicationJobAttributeRequest::setFrequency(int frequency) +{ + frequency_ = frequency; + setCoreParameter("Frequency", std::to_string(frequency)); +} + +std::string ModifyReplicationJobAttributeRequest::getJobId()const +{ + return jobId_; +} + +void ModifyReplicationJobAttributeRequest::setJobId(const std::string& jobId) +{ + jobId_ = jobId; + setCoreParameter("JobId", jobId); +} + +std::string ModifyReplicationJobAttributeRequest::getImageName()const +{ + return imageName_; +} + +void ModifyReplicationJobAttributeRequest::setImageName(const std::string& imageName) +{ + imageName_ = imageName; + setCoreParameter("ImageName", imageName); +} + +int ModifyReplicationJobAttributeRequest::getSystemDiskSize()const +{ + return systemDiskSize_; +} + +void ModifyReplicationJobAttributeRequest::setSystemDiskSize(int systemDiskSize) +{ + systemDiskSize_ = systemDiskSize; + setCoreParameter("SystemDiskSize", std::to_string(systemDiskSize)); +} + +std::string ModifyReplicationJobAttributeRequest::getInstanceType()const +{ + return instanceType_; +} + +void ModifyReplicationJobAttributeRequest::setInstanceType(const std::string& instanceType) +{ + instanceType_ = instanceType; + setCoreParameter("InstanceType", instanceType); +} + +std::string ModifyReplicationJobAttributeRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void ModifyReplicationJobAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +long ModifyReplicationJobAttributeRequest::getOwnerId()const +{ + return ownerId_; +} + +void ModifyReplicationJobAttributeRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setCoreParameter("OwnerId", std::to_string(ownerId)); +} + +std::vector ModifyReplicationJobAttributeRequest::getDataDisk()const +{ + return dataDisk_; +} + +void ModifyReplicationJobAttributeRequest::setDataDisk(const std::vector& dataDisk) +{ + dataDisk_ = dataDisk; + for(int dep1 = 0; dep1!= dataDisk.size(); dep1++) { + auto dataDiskObj = dataDisk.at(dep1); + std::string dataDiskObjStr = "DataDisk." + std::to_string(dep1); + setCoreParameter(dataDiskObjStr + ".Size", std::to_string(dataDiskObj.size)); + setCoreParameter(dataDiskObjStr + ".Index", std::to_string(dataDiskObj.index)); + } +} + +std::string ModifyReplicationJobAttributeRequest::getScheduledStartTime()const +{ + return scheduledStartTime_; +} + +void ModifyReplicationJobAttributeRequest::setScheduledStartTime(const std::string& scheduledStartTime) +{ + scheduledStartTime_ = scheduledStartTime; + setCoreParameter("ScheduledStartTime", scheduledStartTime); +} + +std::string ModifyReplicationJobAttributeRequest::getInstanceId()const +{ + return instanceId_; +} + +void ModifyReplicationJobAttributeRequest::setInstanceId(const std::string& instanceId) +{ + instanceId_ = instanceId; + setCoreParameter("InstanceId", instanceId); +} + +std::string ModifyReplicationJobAttributeRequest::getName()const +{ + return name_; +} + +void ModifyReplicationJobAttributeRequest::setName(const std::string& name) +{ + name_ = name; + setCoreParameter("Name", name); +} + +int ModifyReplicationJobAttributeRequest::getMaxNumberOfImageToKeep()const +{ + return maxNumberOfImageToKeep_; +} + +void ModifyReplicationJobAttributeRequest::setMaxNumberOfImageToKeep(int maxNumberOfImageToKeep) +{ + maxNumberOfImageToKeep_ = maxNumberOfImageToKeep; + setCoreParameter("MaxNumberOfImageToKeep", std::to_string(maxNumberOfImageToKeep)); +} + diff --git a/smc/src/model/ModifyReplicationJobAttributeResult.cc b/smc/src/model/ModifyReplicationJobAttributeResult.cc new file mode 100644 index 000000000..7f94a46a7 --- /dev/null +++ b/smc/src/model/ModifyReplicationJobAttributeResult.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::Smc; +using namespace AlibabaCloud::Smc::Model; + +ModifyReplicationJobAttributeResult::ModifyReplicationJobAttributeResult() : + ServiceResult() +{} + +ModifyReplicationJobAttributeResult::ModifyReplicationJobAttributeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ModifyReplicationJobAttributeResult::~ModifyReplicationJobAttributeResult() +{} + +void ModifyReplicationJobAttributeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/smc/src/model/ModifySourceServerAttributeRequest.cc b/smc/src/model/ModifySourceServerAttributeRequest.cc new file mode 100644 index 000000000..bbcccc736 --- /dev/null +++ b/smc/src/model/ModifySourceServerAttributeRequest.cc @@ -0,0 +1,95 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Smc::Model::ModifySourceServerAttributeRequest; + +ModifySourceServerAttributeRequest::ModifySourceServerAttributeRequest() : + RpcServiceRequest("smc", "2019-06-01", "ModifySourceServerAttribute") +{ + setMethod(HttpRequest::Method::Post); +} + +ModifySourceServerAttributeRequest::~ModifySourceServerAttributeRequest() +{} + +std::string ModifySourceServerAttributeRequest::getDescription()const +{ + return description_; +} + +void ModifySourceServerAttributeRequest::setDescription(const std::string& description) +{ + description_ = description; + setCoreParameter("Description", description); +} + +std::string ModifySourceServerAttributeRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void ModifySourceServerAttributeRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + +std::string ModifySourceServerAttributeRequest::getSourceId()const +{ + return sourceId_; +} + +void ModifySourceServerAttributeRequest::setSourceId(const std::string& sourceId) +{ + sourceId_ = sourceId; + setCoreParameter("SourceId", sourceId); +} + +std::string ModifySourceServerAttributeRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void ModifySourceServerAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +long ModifySourceServerAttributeRequest::getOwnerId()const +{ + return ownerId_; +} + +void ModifySourceServerAttributeRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setCoreParameter("OwnerId", std::to_string(ownerId)); +} + +std::string ModifySourceServerAttributeRequest::getName()const +{ + return name_; +} + +void ModifySourceServerAttributeRequest::setName(const std::string& name) +{ + name_ = name; + setCoreParameter("Name", name); +} + diff --git a/smc/src/model/ModifySourceServerAttributeResult.cc b/smc/src/model/ModifySourceServerAttributeResult.cc new file mode 100644 index 000000000..5147e9c0d --- /dev/null +++ b/smc/src/model/ModifySourceServerAttributeResult.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::Smc; +using namespace AlibabaCloud::Smc::Model; + +ModifySourceServerAttributeResult::ModifySourceServerAttributeResult() : + ServiceResult() +{} + +ModifySourceServerAttributeResult::ModifySourceServerAttributeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ModifySourceServerAttributeResult::~ModifySourceServerAttributeResult() +{} + +void ModifySourceServerAttributeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/smc/src/model/StartReplicationJobRequest.cc b/smc/src/model/StartReplicationJobRequest.cc new file mode 100644 index 000000000..745cad1d1 --- /dev/null +++ b/smc/src/model/StartReplicationJobRequest.cc @@ -0,0 +1,73 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Smc::Model::StartReplicationJobRequest; + +StartReplicationJobRequest::StartReplicationJobRequest() : + RpcServiceRequest("smc", "2019-06-01", "StartReplicationJob") +{ + setMethod(HttpRequest::Method::Post); +} + +StartReplicationJobRequest::~StartReplicationJobRequest() +{} + +std::string StartReplicationJobRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void StartReplicationJobRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +long StartReplicationJobRequest::getOwnerId()const +{ + return ownerId_; +} + +void StartReplicationJobRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setCoreParameter("OwnerId", std::to_string(ownerId)); +} + +std::string StartReplicationJobRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void StartReplicationJobRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + +std::string StartReplicationJobRequest::getJobId()const +{ + return jobId_; +} + +void StartReplicationJobRequest::setJobId(const std::string& jobId) +{ + jobId_ = jobId; + setCoreParameter("JobId", jobId); +} + diff --git a/smc/src/model/StartReplicationJobResult.cc b/smc/src/model/StartReplicationJobResult.cc new file mode 100644 index 000000000..67250b468 --- /dev/null +++ b/smc/src/model/StartReplicationJobResult.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::Smc; +using namespace AlibabaCloud::Smc::Model; + +StartReplicationJobResult::StartReplicationJobResult() : + ServiceResult() +{} + +StartReplicationJobResult::StartReplicationJobResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +StartReplicationJobResult::~StartReplicationJobResult() +{} + +void StartReplicationJobResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/smc/src/model/StopReplicationJobRequest.cc b/smc/src/model/StopReplicationJobRequest.cc new file mode 100644 index 000000000..4d88981ac --- /dev/null +++ b/smc/src/model/StopReplicationJobRequest.cc @@ -0,0 +1,73 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Smc::Model::StopReplicationJobRequest; + +StopReplicationJobRequest::StopReplicationJobRequest() : + RpcServiceRequest("smc", "2019-06-01", "StopReplicationJob") +{ + setMethod(HttpRequest::Method::Post); +} + +StopReplicationJobRequest::~StopReplicationJobRequest() +{} + +std::string StopReplicationJobRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void StopReplicationJobRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +long StopReplicationJobRequest::getOwnerId()const +{ + return ownerId_; +} + +void StopReplicationJobRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setCoreParameter("OwnerId", std::to_string(ownerId)); +} + +std::string StopReplicationJobRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void StopReplicationJobRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + +std::string StopReplicationJobRequest::getJobId()const +{ + return jobId_; +} + +void StopReplicationJobRequest::setJobId(const std::string& jobId) +{ + jobId_ = jobId; + setCoreParameter("JobId", jobId); +} + diff --git a/smc/src/model/StopReplicationJobResult.cc b/smc/src/model/StopReplicationJobResult.cc new file mode 100644 index 000000000..30e2059a1 --- /dev/null +++ b/smc/src/model/StopReplicationJobResult.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::Smc; +using namespace AlibabaCloud::Smc::Model; + +StopReplicationJobResult::StopReplicationJobResult() : + ServiceResult() +{} + +StopReplicationJobResult::StopReplicationJobResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +StopReplicationJobResult::~StopReplicationJobResult() +{} + +void StopReplicationJobResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/smc/src/model/TagResourcesRequest.cc b/smc/src/model/TagResourcesRequest.cc new file mode 100644 index 000000000..2b5fe64a2 --- /dev/null +++ b/smc/src/model/TagResourcesRequest.cc @@ -0,0 +1,102 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::Smc::Model::TagResourcesRequest; + +TagResourcesRequest::TagResourcesRequest() : + RpcServiceRequest("smc", "2019-06-01", "TagResources") +{ + setMethod(HttpRequest::Method::Post); +} + +TagResourcesRequest::~TagResourcesRequest() +{} + +std::string TagResourcesRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void TagResourcesRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + +std::vector TagResourcesRequest::getTag()const +{ + return tag_; +} + +void TagResourcesRequest::setTag(const std::vector& tag) +{ + tag_ = tag; + for(int dep1 = 0; dep1!= tag.size(); dep1++) { + auto tagObj = tag.at(dep1); + std::string tagObjStr = "Tag." + std::to_string(dep1); + setCoreParameter(tagObjStr + ".Value", tagObj.value); + setCoreParameter(tagObjStr + ".Key", tagObj.key); + } +} + +std::vector TagResourcesRequest::getResourceId()const +{ + return resourceId_; +} + +void TagResourcesRequest::setResourceId(const std::vector& resourceId) +{ + resourceId_ = resourceId; + for(int dep1 = 0; dep1!= resourceId.size(); dep1++) { + setCoreParameter("ResourceId."+ std::to_string(dep1), resourceId.at(dep1)); + } +} + +std::string TagResourcesRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void TagResourcesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +long TagResourcesRequest::getOwnerId()const +{ + return ownerId_; +} + +void TagResourcesRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setCoreParameter("OwnerId", std::to_string(ownerId)); +} + +std::string TagResourcesRequest::getResourceType()const +{ + return resourceType_; +} + +void TagResourcesRequest::setResourceType(const std::string& resourceType) +{ + resourceType_ = resourceType; + setCoreParameter("ResourceType", resourceType); +} + diff --git a/smc/src/model/TagResourcesResult.cc b/smc/src/model/TagResourcesResult.cc new file mode 100644 index 000000000..44d18d826 --- /dev/null +++ b/smc/src/model/TagResourcesResult.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::Smc; +using namespace AlibabaCloud::Smc::Model; + +TagResourcesResult::TagResourcesResult() : + ServiceResult() +{} + +TagResourcesResult::TagResourcesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +TagResourcesResult::~TagResourcesResult() +{} + +void TagResourcesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/smc/src/model/UntagResourcesRequest.cc b/smc/src/model/UntagResourcesRequest.cc new file mode 100644 index 000000000..6d6ae1d67 --- /dev/null +++ b/smc/src/model/UntagResourcesRequest.cc @@ -0,0 +1,110 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::Smc::Model::UntagResourcesRequest; + +UntagResourcesRequest::UntagResourcesRequest() : + RpcServiceRequest("smc", "2019-06-01", "UntagResources") +{ + setMethod(HttpRequest::Method::Post); +} + +UntagResourcesRequest::~UntagResourcesRequest() +{} + +std::string UntagResourcesRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void UntagResourcesRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + +bool UntagResourcesRequest::getAll()const +{ + return all_; +} + +void UntagResourcesRequest::setAll(bool all) +{ + all_ = all; + setCoreParameter("All", all ? "true" : "false"); +} + +std::vector UntagResourcesRequest::getResourceId()const +{ + return resourceId_; +} + +void UntagResourcesRequest::setResourceId(const std::vector& resourceId) +{ + resourceId_ = resourceId; + for(int dep1 = 0; dep1!= resourceId.size(); dep1++) { + setCoreParameter("ResourceId."+ std::to_string(dep1), resourceId.at(dep1)); + } +} + +std::string UntagResourcesRequest::getResourceOwnerAccount()const +{ + return resourceOwnerAccount_; +} + +void UntagResourcesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount) +{ + resourceOwnerAccount_ = resourceOwnerAccount; + setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount); +} + +long UntagResourcesRequest::getOwnerId()const +{ + return ownerId_; +} + +void UntagResourcesRequest::setOwnerId(long ownerId) +{ + ownerId_ = ownerId; + setCoreParameter("OwnerId", std::to_string(ownerId)); +} + +std::string UntagResourcesRequest::getResourceType()const +{ + return resourceType_; +} + +void UntagResourcesRequest::setResourceType(const std::string& resourceType) +{ + resourceType_ = resourceType; + setCoreParameter("ResourceType", resourceType); +} + +std::vector UntagResourcesRequest::getTagKey()const +{ + return tagKey_; +} + +void UntagResourcesRequest::setTagKey(const std::vector& tagKey) +{ + tagKey_ = tagKey; + for(int dep1 = 0; dep1!= tagKey.size(); dep1++) { + setCoreParameter("TagKey."+ std::to_string(dep1), tagKey.at(dep1)); + } +} + diff --git a/smc/src/model/UntagResourcesResult.cc b/smc/src/model/UntagResourcesResult.cc new file mode 100644 index 000000000..070f67308 --- /dev/null +++ b/smc/src/model/UntagResourcesResult.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::Smc; +using namespace AlibabaCloud::Smc::Model; + +UntagResourcesResult::UntagResourcesResult() : + ServiceResult() +{} + +UntagResourcesResult::UntagResourcesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UntagResourcesResult::~UntagResourcesResult() +{} + +void UntagResourcesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} +