Public.

CHANGELOG

@@ -1,3 +1,17 @@
+2020-11-28 Version: patch
+- Public.
+
+2020-11-27 Version: patch
+- Supported all language sdk.
+- Fixed some bugs for polardbx.
+
+2020-11-27 Version: patch
+- Supported all language sdk.
+- Fixed some bugs for polardbx.
+
+2020-11-27 Version: patch
+- Generated 2018-01-11 for `rtc`.
+
 2020-11-27 Version: patch
 - Add Certificate Manager Api.
 

polardbx/include/alibabacloud/polardbx/model/DescribeDBInstancesResult.h

@@ -34,6 +34,13 @@ namespace AlibabaCloud
 			public:
 				struct DBInstance
 				{
+					struct PolarDBXNode
+					{
+						std::string classCode;
+						std::string zoneId;
+						std::string id;
+						std::string regionId;
+					};
 					std::string status;
 					std::string description;
 					std::string zoneId;
@@ -45,6 +52,7 @@ namespace AlibabaCloud
 					std::string payType;
 					std::string dBType;
 					std::string lockMode;
+					std::vector<DBInstance::PolarDBXNode> nodes;
 					int storageUsed;
 					std::string nodeClass;
 					std::string dBVersion;
@@ -64,6 +72,7 @@ namespace AlibabaCloud
 				~DescribeDBInstancesResult();
 				int getPageSize()const;
 				int getPageNumber()const;
+				int getTotalNumber()const;
 				std::vector<DBInstance> getDBInstances()const;
 
 			protected:
@@ -71,6 +80,7 @@ namespace AlibabaCloud
 			private:
 				int pageSize_;
 				int pageNumber_;
+				int totalNumber_;
 				std::vector<DBInstance> dBInstances_;
 
 			};

polardbx/src/model/DescribeDBInstancesResult.cc

@@ -85,6 +85,20 @@ void DescribeDBInstancesResult::parse(const std::string &payload)
 			dBInstancesObject.commodityCode = valueDBInstancesDBInstance["CommodityCode"].asString();
 		if(!valueDBInstancesDBInstance["Type"].isNull())
 			dBInstancesObject.type = valueDBInstancesDBInstance["Type"].asString();
+		auto allNodesNode = valueDBInstancesDBInstance["Nodes"]["PolarDBXNode"];
+		for (auto valueDBInstancesDBInstanceNodesPolarDBXNode : allNodesNode)
+		{
+			DBInstance::PolarDBXNode nodesObject;
+			if(!valueDBInstancesDBInstanceNodesPolarDBXNode["Id"].isNull())
+				nodesObject.id = valueDBInstancesDBInstanceNodesPolarDBXNode["Id"].asString();
+			if(!valueDBInstancesDBInstanceNodesPolarDBXNode["ClassCode"].isNull())
+				nodesObject.classCode = valueDBInstancesDBInstanceNodesPolarDBXNode["ClassCode"].asString();
+			if(!valueDBInstancesDBInstanceNodesPolarDBXNode["RegionId"].isNull())
+				nodesObject.regionId = valueDBInstancesDBInstanceNodesPolarDBXNode["RegionId"].asString();
+			if(!valueDBInstancesDBInstanceNodesPolarDBXNode["ZoneId"].isNull())
+				nodesObject.zoneId = valueDBInstancesDBInstanceNodesPolarDBXNode["ZoneId"].asString();
+			dBInstancesObject.nodes.push_back(nodesObject);
+		}
 		auto allReadDBInstances = value["ReadDBInstances"]["ReadDBInstance"];
 		for (auto value : allReadDBInstances)
 			dBInstancesObject.readDBInstances.push_back(value.asString());
@@ -94,6 +108,8 @@ void DescribeDBInstancesResult::parse(const std::string &payload)
 		pageNumber_ = std::stoi(value["PageNumber"].asString());
 	if(!value["PageSize"].isNull())
 		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalNumber"].isNull())
+		totalNumber_ = std::stoi(value["TotalNumber"].asString());
 
 }
 
@@ -107,6 +123,11 @@ int DescribeDBInstancesResult::getPageNumber()const
 	return pageNumber_;
 }
 
+int DescribeDBInstancesResult::getTotalNumber()const
+{
+	return totalNumber_;
+}
+
 std::vector<DescribeDBInstancesResult::DBInstance> DescribeDBInstancesResult::getDBInstances()const
 {
 	return dBInstances_;

polardbx/src/model/DescribeDbListResult.cc

@@ -51,14 +51,14 @@ void DescribeDbListResult::parse(const std::string &payload)
 			dataObject.dBInstanceName = valueDataDB["DBInstanceName"].asString();
 		if(!valueDataDB["CharacterSetName"].isNull())
 			dataObject.characterSetName = valueDataDB["CharacterSetName"].asString();
-		auto allAccountsNode = allDataNode["Accounts"]["Account"];
-		for (auto allDataNodeAccountsAccount : allAccountsNode)
+		auto allAccountsNode = valueDataDB["Accounts"]["Account"];
+		for (auto valueDataDBAccountsAccount : allAccountsNode)
 		{
 			DB::Account accountsObject;
-			if(!allDataNodeAccountsAccount["AccountName"].isNull())
-				accountsObject.accountName = allDataNodeAccountsAccount["AccountName"].asString();
-			if(!allDataNodeAccountsAccount["AccountPrivilege"].isNull())
-				accountsObject.accountPrivilege = allDataNodeAccountsAccount["AccountPrivilege"].asString();
+			if(!valueDataDBAccountsAccount["AccountName"].isNull())
+				accountsObject.accountName = valueDataDBAccountsAccount["AccountName"].asString();
+			if(!valueDataDBAccountsAccount["AccountPrivilege"].isNull())
+				accountsObject.accountPrivilege = valueDataDBAccountsAccount["AccountPrivilege"].asString();
 			dataObject.accounts.push_back(accountsObject);
 		}
 		data_.push_back(dataObject);

polardbx/src/model/DescribeInstanceDbPerformanceResult.cc

@@ -48,14 +48,14 @@ void DescribeInstanceDbPerformanceResult::parse(const std::string &payload)
 			performanceItemObject.measurement = dataNodePerformanceItemsPerformanceItem["Measurement"].asString();
 		if(!dataNodePerformanceItemsPerformanceItem["MetricName"].isNull())
 			performanceItemObject.metricName = dataNodePerformanceItemsPerformanceItem["MetricName"].asString();
-		auto allPointsNode = allPerformanceItemsNode["Points"]["Point"];
-		for (auto allPerformanceItemsNodePointsPoint : allPointsNode)
+		auto allPointsNode = dataNodePerformanceItemsPerformanceItem["Points"]["Point"];
+		for (auto dataNodePerformanceItemsPerformanceItemPointsPoint : allPointsNode)
 		{
 			Data::PerformanceItem::Point pointsObject;
-			if(!allPerformanceItemsNodePointsPoint["Timestamp"].isNull())
-				pointsObject.timestamp = std::stol(allPerformanceItemsNodePointsPoint["Timestamp"].asString());
-			if(!allPerformanceItemsNodePointsPoint["Value"].isNull())
-				pointsObject.value = allPerformanceItemsNodePointsPoint["Value"].asString();
+			if(!dataNodePerformanceItemsPerformanceItemPointsPoint["Timestamp"].isNull())
+				pointsObject.timestamp = std::stol(dataNodePerformanceItemsPerformanceItemPointsPoint["Timestamp"].asString());
+			if(!dataNodePerformanceItemsPerformanceItemPointsPoint["Value"].isNull())
+				pointsObject.value = dataNodePerformanceItemsPerformanceItemPointsPoint["Value"].asString();
 			performanceItemObject.points.push_back(pointsObject);
 		}
 		data_.performanceItems.push_back(performanceItemObject);

polardbx/src/model/DescribeInstancePerformanceResult.cc

@@ -48,14 +48,14 @@ void DescribeInstancePerformanceResult::parse(const std::string &payload)
 			performanceItemObject.measurement = dataNodePerformanceItemsPerformanceItem["Measurement"].asString();
 		if(!dataNodePerformanceItemsPerformanceItem["MetricName"].isNull())
 			performanceItemObject.metricName = dataNodePerformanceItemsPerformanceItem["MetricName"].asString();
-		auto allPointsNode = allPerformanceItemsNode["Points"]["Point"];
-		for (auto allPerformanceItemsNodePointsPoint : allPointsNode)
+		auto allPointsNode = dataNodePerformanceItemsPerformanceItem["Points"]["Point"];
+		for (auto dataNodePerformanceItemsPerformanceItemPointsPoint : allPointsNode)
 		{
 			Data::PerformanceItem::Point pointsObject;
-			if(!allPerformanceItemsNodePointsPoint["Timestamp"].isNull())
-				pointsObject.timestamp = std::stol(allPerformanceItemsNodePointsPoint["Timestamp"].asString());
-			if(!allPerformanceItemsNodePointsPoint["Value"].isNull())
-				pointsObject.value = allPerformanceItemsNodePointsPoint["Value"].asString();
+			if(!dataNodePerformanceItemsPerformanceItemPointsPoint["Timestamp"].isNull())
+				pointsObject.timestamp = std::stol(dataNodePerformanceItemsPerformanceItemPointsPoint["Timestamp"].asString());
+			if(!dataNodePerformanceItemsPerformanceItemPointsPoint["Value"].isNull())
+				pointsObject.value = dataNodePerformanceItemsPerformanceItemPointsPoint["Value"].asString();
 			performanceItemObject.points.push_back(pointsObject);
 		}
 		data_.performanceItems.push_back(performanceItemObject);

polardbx/src/model/DescribeInstanceStoragePerformanceResult.cc

@@ -48,14 +48,14 @@ void DescribeInstanceStoragePerformanceResult::parse(const std::string &payload)
 			performanceItemObject.measurement = dataNodePerformanceItemsPerformanceItem["Measurement"].asString();
 		if(!dataNodePerformanceItemsPerformanceItem["MetricName"].isNull())
 			performanceItemObject.metricName = dataNodePerformanceItemsPerformanceItem["MetricName"].asString();
-		auto allPointsNode = allPerformanceItemsNode["Points"]["Point"];
-		for (auto allPerformanceItemsNodePointsPoint : allPointsNode)
+		auto allPointsNode = dataNodePerformanceItemsPerformanceItem["Points"]["Point"];
+		for (auto dataNodePerformanceItemsPerformanceItemPointsPoint : allPointsNode)
 		{
 			Data::PerformanceItem::Point pointsObject;
-			if(!allPerformanceItemsNodePointsPoint["Timestamp"].isNull())
-				pointsObject.timestamp = std::stol(allPerformanceItemsNodePointsPoint["Timestamp"].asString());
-			if(!allPerformanceItemsNodePointsPoint["Value"].isNull())
-				pointsObject.value = allPerformanceItemsNodePointsPoint["Value"].asString();
+			if(!dataNodePerformanceItemsPerformanceItemPointsPoint["Timestamp"].isNull())
+				pointsObject.timestamp = std::stol(dataNodePerformanceItemsPerformanceItemPointsPoint["Timestamp"].asString());
+			if(!dataNodePerformanceItemsPerformanceItemPointsPoint["Value"].isNull())
+				pointsObject.value = dataNodePerformanceItemsPerformanceItemPointsPoint["Value"].asString();
 			performanceItemObject.points.push_back(pointsObject);
 		}
 		data_.performanceItems.push_back(performanceItemObject);

polardbx/src/model/DescribeRegionsResult.cc

@@ -47,14 +47,14 @@ void DescribeRegionsResult::parse(const std::string &payload)
 			regionsObject.regionId = valueRegionsRegion["RegionId"].asString();
 		if(!valueRegionsRegion["SupportPolarx20"].isNull())
 			regionsObject.supportPolarx20 = valueRegionsRegion["SupportPolarx20"].asString() == "true";
-		auto allZonesNode = allRegionsNode["Zones"]["Zone"];
-		for (auto allRegionsNodeZonesZone : allZonesNode)
+		auto allZonesNode = valueRegionsRegion["Zones"]["Zone"];
+		for (auto valueRegionsRegionZonesZone : allZonesNode)
 		{
 			Region::Zone zonesObject;
-			if(!allRegionsNodeZonesZone["ZoneId"].isNull())
-				zonesObject.zoneId = allRegionsNodeZonesZone["ZoneId"].asString();
-			if(!allRegionsNodeZonesZone["VpcEnabled"].isNull())
-				zonesObject.vpcEnabled = allRegionsNodeZonesZone["VpcEnabled"].asString() == "true";
+			if(!valueRegionsRegionZonesZone["ZoneId"].isNull())
+				zonesObject.zoneId = valueRegionsRegionZonesZone["ZoneId"].asString();
+			if(!valueRegionsRegionZonesZone["VpcEnabled"].isNull())
+				zonesObject.vpcEnabled = valueRegionsRegionZonesZone["VpcEnabled"].asString() == "true";
 			regionsObject.zones.push_back(zonesObject);
 		}
 		regions_.push_back(regionsObject);

rsimganalys/CMakeLists.txt

@@ -0,0 +1,122 @@
+#
+# Copyright 2009-2017 Alibaba Cloud All rights reserved.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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(rsimganalys_public_header 
+	include/alibabacloud/rsimganalys/RsimganalysClient.h
+	include/alibabacloud/rsimganalys/RsimganalysExport.h )
+
+set(rsimganalys_public_header_model 
+	include/alibabacloud/rsimganalys/model/AccessAppkeyRequest.h
+	include/alibabacloud/rsimganalys/model/AccessAppkeyResult.h
+	include/alibabacloud/rsimganalys/model/AccessTokenRequest.h
+	include/alibabacloud/rsimganalys/model/AccessTokenResult.h
+	include/alibabacloud/rsimganalys/model/CreateImageRequest.h
+	include/alibabacloud/rsimganalys/model/CreateImageResult.h
+	include/alibabacloud/rsimganalys/model/CreateTaskRequest.h
+	include/alibabacloud/rsimganalys/model/CreateTaskResult.h
+	include/alibabacloud/rsimganalys/model/DeleteImageRequest.h
+	include/alibabacloud/rsimganalys/model/DeleteImageResult.h
+	include/alibabacloud/rsimganalys/model/DeleteTaskRequest.h
+	include/alibabacloud/rsimganalys/model/DeleteTaskResult.h
+	include/alibabacloud/rsimganalys/model/GetImageRequest.h
+	include/alibabacloud/rsimganalys/model/GetImageResult.h
+	include/alibabacloud/rsimganalys/model/GetShpInfoRequest.h
+	include/alibabacloud/rsimganalys/model/GetShpInfoResult.h
+	include/alibabacloud/rsimganalys/model/GetTaskRequest.h
+	include/alibabacloud/rsimganalys/model/GetTaskResult.h
+	include/alibabacloud/rsimganalys/model/ListTasksRequest.h
+	include/alibabacloud/rsimganalys/model/ListTasksResult.h )
+
+set(rsimganalys_src 
+	src/RsimganalysClient.cc
+	src/model/AccessAppkeyRequest.cc
+	src/model/AccessAppkeyResult.cc
+	src/model/AccessTokenRequest.cc
+	src/model/AccessTokenResult.cc
+	src/model/CreateImageRequest.cc
+	src/model/CreateImageResult.cc
+	src/model/CreateTaskRequest.cc
+	src/model/CreateTaskResult.cc
+	src/model/DeleteImageRequest.cc
+	src/model/DeleteImageResult.cc
+	src/model/DeleteTaskRequest.cc
+	src/model/DeleteTaskResult.cc
+	src/model/GetImageRequest.cc
+	src/model/GetImageResult.cc
+	src/model/GetShpInfoRequest.cc
+	src/model/GetShpInfoResult.cc
+	src/model/GetTaskRequest.cc
+	src/model/GetTaskResult.cc
+	src/model/ListTasksRequest.cc
+	src/model/ListTasksResult.cc )
+
+add_library(rsimganalys ${LIB_TYPE}
+	${rsimganalys_public_header}
+	${rsimganalys_public_header_model}
+	${rsimganalys_src})
+
+set_target_properties(rsimganalys
+	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}rsimganalys
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(rsimganalys
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_RSIMGANALYS_LIBRARY)
+endif()
+
+target_include_directories(rsimganalys
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(rsimganalys
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(rsimganalys
+		jsoncpp)
+	target_include_directories(rsimganalys
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(rsimganalys
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(rsimganalys
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(rsimganalys
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(rsimganalys
+		jsoncpp)
+endif()
+
+install(FILES ${rsimganalys_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/rsimganalys)
+install(FILES ${rsimganalys_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/rsimganalys/model)
+install(TARGETS rsimganalys
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

rsimganalys/include/alibabacloud/rsimganalys/RsimganalysClient.h

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RSIMGANALYS_RSIMGANALYSCLIENT_H_
+#define ALIBABACLOUD_RSIMGANALYS_RSIMGANALYSCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "RsimganalysExport.h"
+#include "model/AccessAppkeyRequest.h"
+#include "model/AccessAppkeyResult.h"
+#include "model/AccessTokenRequest.h"
+#include "model/AccessTokenResult.h"
+#include "model/CreateImageRequest.h"
+#include "model/CreateImageResult.h"
+#include "model/CreateTaskRequest.h"
+#include "model/CreateTaskResult.h"
+#include "model/DeleteImageRequest.h"
+#include "model/DeleteImageResult.h"
+#include "model/DeleteTaskRequest.h"
+#include "model/DeleteTaskResult.h"
+#include "model/GetImageRequest.h"
+#include "model/GetImageResult.h"
+#include "model/GetShpInfoRequest.h"
+#include "model/GetShpInfoResult.h"
+#include "model/GetTaskRequest.h"
+#include "model/GetTaskResult.h"
+#include "model/ListTasksRequest.h"
+#include "model/ListTasksResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Rsimganalys
+	{
+		class ALIBABACLOUD_RSIMGANALYS_EXPORT RsimganalysClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::AccessAppkeyResult> AccessAppkeyOutcome;
+			typedef std::future<AccessAppkeyOutcome> AccessAppkeyOutcomeCallable;
+			typedef std::function<void(const RsimganalysClient*, const Model::AccessAppkeyRequest&, const AccessAppkeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AccessAppkeyAsyncHandler;
+			typedef Outcome<Error, Model::AccessTokenResult> AccessTokenOutcome;
+			typedef std::future<AccessTokenOutcome> AccessTokenOutcomeCallable;
+			typedef std::function<void(const RsimganalysClient*, const Model::AccessTokenRequest&, const AccessTokenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AccessTokenAsyncHandler;
+			typedef Outcome<Error, Model::CreateImageResult> CreateImageOutcome;
+			typedef std::future<CreateImageOutcome> CreateImageOutcomeCallable;
+			typedef std::function<void(const RsimganalysClient*, const Model::CreateImageRequest&, const CreateImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateImageAsyncHandler;
+			typedef Outcome<Error, Model::CreateTaskResult> CreateTaskOutcome;
+			typedef std::future<CreateTaskOutcome> CreateTaskOutcomeCallable;
+			typedef std::function<void(const RsimganalysClient*, const Model::CreateTaskRequest&, const CreateTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateTaskAsyncHandler;
+			typedef Outcome<Error, Model::DeleteImageResult> DeleteImageOutcome;
+			typedef std::future<DeleteImageOutcome> DeleteImageOutcomeCallable;
+			typedef std::function<void(const RsimganalysClient*, const Model::DeleteImageRequest&, const DeleteImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteImageAsyncHandler;
+			typedef Outcome<Error, Model::DeleteTaskResult> DeleteTaskOutcome;
+			typedef std::future<DeleteTaskOutcome> DeleteTaskOutcomeCallable;
+			typedef std::function<void(const RsimganalysClient*, const Model::DeleteTaskRequest&, const DeleteTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTaskAsyncHandler;
+			typedef Outcome<Error, Model::GetImageResult> GetImageOutcome;
+			typedef std::future<GetImageOutcome> GetImageOutcomeCallable;
+			typedef std::function<void(const RsimganalysClient*, const Model::GetImageRequest&, const GetImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetImageAsyncHandler;
+			typedef Outcome<Error, Model::GetShpInfoResult> GetShpInfoOutcome;
+			typedef std::future<GetShpInfoOutcome> GetShpInfoOutcomeCallable;
+			typedef std::function<void(const RsimganalysClient*, const Model::GetShpInfoRequest&, const GetShpInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetShpInfoAsyncHandler;
+			typedef Outcome<Error, Model::GetTaskResult> GetTaskOutcome;
+			typedef std::future<GetTaskOutcome> GetTaskOutcomeCallable;
+			typedef std::function<void(const RsimganalysClient*, const Model::GetTaskRequest&, const GetTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTaskAsyncHandler;
+			typedef Outcome<Error, Model::ListTasksResult> ListTasksOutcome;
+			typedef std::future<ListTasksOutcome> ListTasksOutcomeCallable;
+			typedef std::function<void(const RsimganalysClient*, const Model::ListTasksRequest&, const ListTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTasksAsyncHandler;
+
+			RsimganalysClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			RsimganalysClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			RsimganalysClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~RsimganalysClient();
+			AccessAppkeyOutcome accessAppkey(const Model::AccessAppkeyRequest &request)const;
+			void accessAppkeyAsync(const Model::AccessAppkeyRequest& request, const AccessAppkeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AccessAppkeyOutcomeCallable accessAppkeyCallable(const Model::AccessAppkeyRequest& request) const;
+			AccessTokenOutcome accessToken(const Model::AccessTokenRequest &request)const;
+			void accessTokenAsync(const Model::AccessTokenRequest& request, const AccessTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AccessTokenOutcomeCallable accessTokenCallable(const Model::AccessTokenRequest& request) const;
+			CreateImageOutcome createImage(const Model::CreateImageRequest &request)const;
+			void createImageAsync(const Model::CreateImageRequest& request, const CreateImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateImageOutcomeCallable createImageCallable(const Model::CreateImageRequest& request) const;
+			CreateTaskOutcome createTask(const Model::CreateTaskRequest &request)const;
+			void createTaskAsync(const Model::CreateTaskRequest& request, const CreateTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateTaskOutcomeCallable createTaskCallable(const Model::CreateTaskRequest& request) const;
+			DeleteImageOutcome deleteImage(const Model::DeleteImageRequest &request)const;
+			void deleteImageAsync(const Model::DeleteImageRequest& request, const DeleteImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteImageOutcomeCallable deleteImageCallable(const Model::DeleteImageRequest& request) const;
+			DeleteTaskOutcome deleteTask(const Model::DeleteTaskRequest &request)const;
+			void deleteTaskAsync(const Model::DeleteTaskRequest& request, const DeleteTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteTaskOutcomeCallable deleteTaskCallable(const Model::DeleteTaskRequest& request) const;
+			GetImageOutcome getImage(const Model::GetImageRequest &request)const;
+			void getImageAsync(const Model::GetImageRequest& request, const GetImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetImageOutcomeCallable getImageCallable(const Model::GetImageRequest& request) const;
+			GetShpInfoOutcome getShpInfo(const Model::GetShpInfoRequest &request)const;
+			void getShpInfoAsync(const Model::GetShpInfoRequest& request, const GetShpInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetShpInfoOutcomeCallable getShpInfoCallable(const Model::GetShpInfoRequest& request) const;
+			GetTaskOutcome getTask(const Model::GetTaskRequest &request)const;
+			void getTaskAsync(const Model::GetTaskRequest& request, const GetTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetTaskOutcomeCallable getTaskCallable(const Model::GetTaskRequest& request) const;
+			ListTasksOutcome listTasks(const Model::ListTasksRequest &request)const;
+			void listTasksAsync(const Model::ListTasksRequest& request, const ListTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListTasksOutcomeCallable listTasksCallable(const Model::ListTasksRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_RSIMGANALYS_RSIMGANALYSCLIENT_H_

rsimganalys/include/alibabacloud/rsimganalys/RsimganalysExport.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_RSIMGANALYS_RSIMGANALYSEXPORT_H_
+#define ALIBABACLOUD_RSIMGANALYS_RSIMGANALYSEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_RSIMGANALYS_LIBRARY)
+#		define ALIBABACLOUD_RSIMGANALYS_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_RSIMGANALYS_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_RSIMGANALYS_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_RSIMGANALYS_RSIMGANALYSEXPORT_H_

rsimganalys/include/alibabacloud/rsimganalys/model/AccessAppkeyRequest.h

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

rsimganalys/include/alibabacloud/rsimganalys/model/AccessAppkeyResult.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_RSIMGANALYS_MODEL_ACCESSAPPKEYRESULT_H_
+#define ALIBABACLOUD_RSIMGANALYS_MODEL_ACCESSAPPKEYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rsimganalys/RsimganalysExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rsimganalys
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RSIMGANALYS_EXPORT AccessAppkeyResult : public ServiceResult
+			{
+			public:
+
+
+				AccessAppkeyResult();
+				explicit AccessAppkeyResult(const std::string &payload);
+				~AccessAppkeyResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RSIMGANALYS_MODEL_ACCESSAPPKEYRESULT_H_

rsimganalys/include/alibabacloud/rsimganalys/model/AccessTokenRequest.h

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

rsimganalys/include/alibabacloud/rsimganalys/model/AccessTokenResult.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_RSIMGANALYS_MODEL_ACCESSTOKENRESULT_H_
+#define ALIBABACLOUD_RSIMGANALYS_MODEL_ACCESSTOKENRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rsimganalys/RsimganalysExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rsimganalys
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RSIMGANALYS_EXPORT AccessTokenResult : public ServiceResult
+			{
+			public:
+
+
+				AccessTokenResult();
+				explicit AccessTokenResult(const std::string &payload);
+				~AccessTokenResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RSIMGANALYS_MODEL_ACCESSTOKENRESULT_H_

rsimganalys/include/alibabacloud/rsimganalys/model/CreateImageRequest.h

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

rsimganalys/include/alibabacloud/rsimganalys/model/CreateImageResult.h

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RSIMGANALYS_MODEL_CREATEIMAGERESULT_H_
+#define ALIBABACLOUD_RSIMGANALYS_MODEL_CREATEIMAGERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rsimganalys/RsimganalysExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rsimganalys
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RSIMGANALYS_EXPORT CreateImageResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string description;
+					std::string gmtModified;
+					int runStatus;
+					std::string downloadPath;
+					long fileTime;
+					std::string statusCode;
+					std::string statusMessage;
+					std::string imageName;
+					std::string gmtCreate;
+					std::string aliyunPK;
+					int imageId;
+					std::string jobId;
+					std::string urlUploadPath;
+				};
+
+
+				CreateImageResult();
+				explicit CreateImageResult(const std::string &payload);
+				~CreateImageResult();
+				std::string getUserResolution()const;
+				std::string getImageId()const;
+				Data getData()const;
+				std::string getResultMessage()const;
+				int getResultCode()const;
+				int getPublishStatus()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string userResolution_;
+				std::string imageId_;
+				Data data_;
+				std::string resultMessage_;
+				int resultCode_;
+				int publishStatus_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RSIMGANALYS_MODEL_CREATEIMAGERESULT_H_

rsimganalys/include/alibabacloud/rsimganalys/model/CreateTaskRequest.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_RSIMGANALYS_MODEL_CREATETASKREQUEST_H_
+#define ALIBABACLOUD_RSIMGANALYS_MODEL_CREATETASKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rsimganalys/RsimganalysExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rsimganalys
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RSIMGANALYS_EXPORT CreateTaskRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateTaskRequest();
+				~CreateTaskRequest();
+
+				float getConfidence()const;
+				void setConfidence(float confidence);
+				long getFilterValue()const;
+				void setFilterValue(long filterValue);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				std::string getShpFilter()const;
+				void setShpFilter(const std::string& shpFilter);
+				std::string getProductType()const;
+				void setProductType(const std::string& productType);
+				std::string getZoneList()const;
+				void setZoneList(const std::string& zoneList);
+				std::string getSrcImageId()const;
+				void setSrcImageId(const std::string& srcImageId);
+				std::string getAppkey()const;
+				void setAppkey(const std::string& appkey);
+				std::string getDstImageId()const;
+				void setDstImageId(const std::string& dstImageId);
+
+            private:
+				float confidence_;
+				long filterValue_;
+				std::string description_;
+				std::string shpFilter_;
+				std::string productType_;
+				std::string zoneList_;
+				std::string srcImageId_;
+				std::string appkey_;
+				std::string dstImageId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RSIMGANALYS_MODEL_CREATETASKREQUEST_H_

rsimganalys/include/alibabacloud/rsimganalys/model/CreateTaskResult.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_RSIMGANALYS_MODEL_CREATETASKRESULT_H_
+#define ALIBABACLOUD_RSIMGANALYS_MODEL_CREATETASKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rsimganalys/RsimganalysExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rsimganalys
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RSIMGANALYS_EXPORT CreateTaskResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string status;
+					int progress;
+					std::string version;
+					std::string userId;
+					std::string appkey;
+					std::string request;
+					std::string _namespace;
+					std::string jobId;
+				};
+
+
+				CreateTaskResult();
+				explicit CreateTaskResult(const std::string &payload);
+				~CreateTaskResult();
+				Data getData()const;
+				std::string getResultMessage()const;
+				int getResultCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+				std::string resultMessage_;
+				int resultCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RSIMGANALYS_MODEL_CREATETASKRESULT_H_

rsimganalys/include/alibabacloud/rsimganalys/model/DeleteImageRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RSIMGANALYS_MODEL_DELETEIMAGEREQUEST_H_
+#define ALIBABACLOUD_RSIMGANALYS_MODEL_DELETEIMAGEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rsimganalys/RsimganalysExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rsimganalys
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RSIMGANALYS_EXPORT DeleteImageRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteImageRequest();
+				~DeleteImageRequest();
+
+				long getImageId()const;
+				void setImageId(long imageId);
+
+            private:
+				long imageId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RSIMGANALYS_MODEL_DELETEIMAGEREQUEST_H_

rsimganalys/include/alibabacloud/rsimganalys/model/DeleteImageResult.h

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

rsimganalys/include/alibabacloud/rsimganalys/model/DeleteTaskRequest.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_RSIMGANALYS_MODEL_DELETETASKREQUEST_H_
+#define ALIBABACLOUD_RSIMGANALYS_MODEL_DELETETASKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rsimganalys/RsimganalysExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rsimganalys
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RSIMGANALYS_EXPORT DeleteTaskRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteTaskRequest();
+				~DeleteTaskRequest();
+
+				std::string getJobId()const;
+				void setJobId(const std::string& jobId);
+				std::string getAppkey()const;
+				void setAppkey(const std::string& appkey);
+
+            private:
+				std::string jobId_;
+				std::string appkey_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RSIMGANALYS_MODEL_DELETETASKREQUEST_H_

rsimganalys/include/alibabacloud/rsimganalys/model/DeleteTaskResult.h

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

rsimganalys/include/alibabacloud/rsimganalys/model/GetImageRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RSIMGANALYS_MODEL_GETIMAGEREQUEST_H_
+#define ALIBABACLOUD_RSIMGANALYS_MODEL_GETIMAGEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rsimganalys/RsimganalysExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rsimganalys
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RSIMGANALYS_EXPORT GetImageRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetImageRequest();
+				~GetImageRequest();
+
+				long getImageId()const;
+				void setImageId(long imageId);
+
+            private:
+				long imageId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RSIMGANALYS_MODEL_GETIMAGEREQUEST_H_

rsimganalys/include/alibabacloud/rsimganalys/model/GetImageResult.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_RSIMGANALYS_MODEL_GETIMAGERESULT_H_
+#define ALIBABACLOUD_RSIMGANALYS_MODEL_GETIMAGERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rsimganalys/RsimganalysExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rsimganalys
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RSIMGANALYS_EXPORT GetImageResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string imageName;
+					std::string description;
+					std::string uCS;
+					std::string aliyunPK;
+					std::string userResolution;
+					std::string appkey;
+					int runStatus;
+					long fileTime;
+					std::string pixelSize;
+					std::string resolution;
+					int publishStatus;
+				};
+
+
+				GetImageResult();
+				explicit GetImageResult(const std::string &payload);
+				~GetImageResult();
+				std::string getDownloadPath()const;
+				Data getData()const;
+				std::string getResultMessage()const;
+				std::string getResultCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string downloadPath_;
+				Data data_;
+				std::string resultMessage_;
+				std::string resultCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RSIMGANALYS_MODEL_GETIMAGERESULT_H_

rsimganalys/include/alibabacloud/rsimganalys/model/GetShpInfoRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RSIMGANALYS_MODEL_GETSHPINFOREQUEST_H_
+#define ALIBABACLOUD_RSIMGANALYS_MODEL_GETSHPINFOREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rsimganalys/RsimganalysExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rsimganalys
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RSIMGANALYS_EXPORT GetShpInfoRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetShpInfoRequest();
+				~GetShpInfoRequest();
+
+				std::string getFid()const;
+				void setFid(const std::string& fid);
+				std::string getTaskId()const;
+				void setTaskId(const std::string& taskId);
+				std::string getFileId()const;
+				void setFileId(const std::string& fileId);
+
+            private:
+				std::string fid_;
+				std::string taskId_;
+				std::string fileId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RSIMGANALYS_MODEL_GETSHPINFOREQUEST_H_

rsimganalys/include/alibabacloud/rsimganalys/model/GetShpInfoResult.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_RSIMGANALYS_MODEL_GETSHPINFORESULT_H_
+#define ALIBABACLOUD_RSIMGANALYS_MODEL_GETSHPINFORESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rsimganalys/RsimganalysExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rsimganalys
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RSIMGANALYS_EXPORT GetShpInfoResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string area;
+					std::string category;
+				};
+
+
+				GetShpInfoResult();
+				explicit GetShpInfoResult(const std::string &payload);
+				~GetShpInfoResult();
+				Data getData()const;
+				std::string getResultMessage()const;
+				int getResultCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+				std::string resultMessage_;
+				int resultCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RSIMGANALYS_MODEL_GETSHPINFORESULT_H_

rsimganalys/include/alibabacloud/rsimganalys/model/GetTaskRequest.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_RSIMGANALYS_MODEL_GETTASKREQUEST_H_
+#define ALIBABACLOUD_RSIMGANALYS_MODEL_GETTASKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rsimganalys/RsimganalysExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rsimganalys
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RSIMGANALYS_EXPORT GetTaskRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetTaskRequest();
+				~GetTaskRequest();
+
+				std::string getJobId()const;
+				void setJobId(const std::string& jobId);
+				std::string getAppkey()const;
+				void setAppkey(const std::string& appkey);
+
+            private:
+				std::string jobId_;
+				std::string appkey_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RSIMGANALYS_MODEL_GETTASKREQUEST_H_

rsimganalys/include/alibabacloud/rsimganalys/model/GetTaskResult.h

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RSIMGANALYS_MODEL_GETTASKRESULT_H_
+#define ALIBABACLOUD_RSIMGANALYS_MODEL_GETTASKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rsimganalys/RsimganalysExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rsimganalys
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RSIMGANALYS_EXPORT GetTaskResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string status;
+					int progress;
+					long createTime;
+					std::string request;
+					std::string _namespace;
+					std::string statusCode;
+					std::string statusMessage;
+					std::string response;
+					std::string destinationCoordinateSystem;
+					long lastUpdateTime;
+					int version;
+					std::string userId;
+					std::string taskStatistics;
+					std::string sourceCoordinateSystem;
+					std::string appkey;
+					std::string jobId;
+					std::string taskCoordinateSystem;
+					int publishStatus;
+				};
+
+
+				GetTaskResult();
+				explicit GetTaskResult(const std::string &payload);
+				~GetTaskResult();
+				Data getData()const;
+				std::string getResultMessage()const;
+				std::string getResultCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+				std::string resultMessage_;
+				std::string resultCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RSIMGANALYS_MODEL_GETTASKRESULT_H_

rsimganalys/include/alibabacloud/rsimganalys/model/ListTasksRequest.h

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

rsimganalys/include/alibabacloud/rsimganalys/model/ListTasksResult.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RSIMGANALYS_MODEL_LISTTASKSRESULT_H_
+#define ALIBABACLOUD_RSIMGANALYS_MODEL_LISTTASKSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rsimganalys/RsimganalysExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rsimganalys
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RSIMGANALYS_EXPORT ListTasksResult : public ServiceResult
+			{
+			public:
+				struct Contents
+				{
+					std::string status;
+					int progress;
+					long createTime;
+					std::string request;
+					std::string _namespace;
+					int statusCode;
+					std::string statusMessage;
+					std::string response;
+					std::string version;
+					long lastUpdateTime;
+					std::string userId;
+					std::string appkey;
+					int enableZoneIdentification;
+					std::string jobId;
+					int publishStatus;
+				};
+
+
+				ListTasksResult();
+				explicit ListTasksResult(const std::string &payload);
+				~ListTasksResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<Contents> getData()const;
+				std::string getResultMessage()const;
+				int getResultCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<Contents> data_;
+				std::string resultMessage_;
+				int resultCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RSIMGANALYS_MODEL_LISTTASKSRESULT_H_

rsimganalys/src/RsimganalysClient.cc

@@ -0,0 +1,413 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rsimganalys/RsimganalysClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::Rsimganalys;
+using namespace AlibabaCloud::Rsimganalys::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "rsimganalys";
+}
+
+RsimganalysClient::RsimganalysClient(const Credentials &credentials, const ClientConfiguration &configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+}
+
+RsimganalysClient::RsimganalysClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+}
+
+RsimganalysClient::RsimganalysClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+}
+
+RsimganalysClient::~RsimganalysClient()
+{}
+
+RsimganalysClient::AccessAppkeyOutcome RsimganalysClient::accessAppkey(const AccessAppkeyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AccessAppkeyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AccessAppkeyOutcome(AccessAppkeyResult(outcome.result()));
+	else
+		return AccessAppkeyOutcome(outcome.error());
+}
+
+void RsimganalysClient::accessAppkeyAsync(const AccessAppkeyRequest& request, const AccessAppkeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, accessAppkey(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RsimganalysClient::AccessAppkeyOutcomeCallable RsimganalysClient::accessAppkeyCallable(const AccessAppkeyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AccessAppkeyOutcome()>>(
+			[this, request]()
+			{
+			return this->accessAppkey(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+RsimganalysClient::AccessTokenOutcome RsimganalysClient::accessToken(const AccessTokenRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AccessTokenOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AccessTokenOutcome(AccessTokenResult(outcome.result()));
+	else
+		return AccessTokenOutcome(outcome.error());
+}
+
+void RsimganalysClient::accessTokenAsync(const AccessTokenRequest& request, const AccessTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, accessToken(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RsimganalysClient::AccessTokenOutcomeCallable RsimganalysClient::accessTokenCallable(const AccessTokenRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AccessTokenOutcome()>>(
+			[this, request]()
+			{
+			return this->accessToken(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+RsimganalysClient::CreateImageOutcome RsimganalysClient::createImage(const CreateImageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateImageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateImageOutcome(CreateImageResult(outcome.result()));
+	else
+		return CreateImageOutcome(outcome.error());
+}
+
+void RsimganalysClient::createImageAsync(const CreateImageRequest& request, const CreateImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createImage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RsimganalysClient::CreateImageOutcomeCallable RsimganalysClient::createImageCallable(const CreateImageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateImageOutcome()>>(
+			[this, request]()
+			{
+			return this->createImage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+RsimganalysClient::CreateTaskOutcome RsimganalysClient::createTask(const CreateTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateTaskOutcome(CreateTaskResult(outcome.result()));
+	else
+		return CreateTaskOutcome(outcome.error());
+}
+
+void RsimganalysClient::createTaskAsync(const CreateTaskRequest& request, const CreateTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RsimganalysClient::CreateTaskOutcomeCallable RsimganalysClient::createTaskCallable(const CreateTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->createTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+RsimganalysClient::DeleteImageOutcome RsimganalysClient::deleteImage(const DeleteImageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteImageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteImageOutcome(DeleteImageResult(outcome.result()));
+	else
+		return DeleteImageOutcome(outcome.error());
+}
+
+void RsimganalysClient::deleteImageAsync(const DeleteImageRequest& request, const DeleteImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteImage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RsimganalysClient::DeleteImageOutcomeCallable RsimganalysClient::deleteImageCallable(const DeleteImageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteImageOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteImage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+RsimganalysClient::DeleteTaskOutcome RsimganalysClient::deleteTask(const DeleteTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteTaskOutcome(DeleteTaskResult(outcome.result()));
+	else
+		return DeleteTaskOutcome(outcome.error());
+}
+
+void RsimganalysClient::deleteTaskAsync(const DeleteTaskRequest& request, const DeleteTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RsimganalysClient::DeleteTaskOutcomeCallable RsimganalysClient::deleteTaskCallable(const DeleteTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+RsimganalysClient::GetImageOutcome RsimganalysClient::getImage(const GetImageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetImageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetImageOutcome(GetImageResult(outcome.result()));
+	else
+		return GetImageOutcome(outcome.error());
+}
+
+void RsimganalysClient::getImageAsync(const GetImageRequest& request, const GetImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getImage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RsimganalysClient::GetImageOutcomeCallable RsimganalysClient::getImageCallable(const GetImageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetImageOutcome()>>(
+			[this, request]()
+			{
+			return this->getImage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+RsimganalysClient::GetShpInfoOutcome RsimganalysClient::getShpInfo(const GetShpInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetShpInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetShpInfoOutcome(GetShpInfoResult(outcome.result()));
+	else
+		return GetShpInfoOutcome(outcome.error());
+}
+
+void RsimganalysClient::getShpInfoAsync(const GetShpInfoRequest& request, const GetShpInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getShpInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RsimganalysClient::GetShpInfoOutcomeCallable RsimganalysClient::getShpInfoCallable(const GetShpInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetShpInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->getShpInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+RsimganalysClient::GetTaskOutcome RsimganalysClient::getTask(const GetTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetTaskOutcome(GetTaskResult(outcome.result()));
+	else
+		return GetTaskOutcome(outcome.error());
+}
+
+void RsimganalysClient::getTaskAsync(const GetTaskRequest& request, const GetTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RsimganalysClient::GetTaskOutcomeCallable RsimganalysClient::getTaskCallable(const GetTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->getTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+RsimganalysClient::ListTasksOutcome RsimganalysClient::listTasks(const ListTasksRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListTasksOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListTasksOutcome(ListTasksResult(outcome.result()));
+	else
+		return ListTasksOutcome(outcome.error());
+}
+
+void RsimganalysClient::listTasksAsync(const ListTasksRequest& request, const ListTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listTasks(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RsimganalysClient::ListTasksOutcomeCallable RsimganalysClient::listTasksCallable(const ListTasksRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListTasksOutcome()>>(
+			[this, request]()
+			{
+			return this->listTasks(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

rsimganalys/src/model/AccessAppkeyRequest.cc

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rsimganalys/model/AccessAppkeyRequest.h>
+
+using AlibabaCloud::Rsimganalys::Model::AccessAppkeyRequest;
+
+AccessAppkeyRequest::AccessAppkeyRequest() :
+	RpcServiceRequest("rsimganalys", "2019-08-01", "AccessAppkey")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AccessAppkeyRequest::~AccessAppkeyRequest()
+{}
+

rsimganalys/src/model/AccessAppkeyResult.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 <alibabacloud/rsimganalys/model/AccessAppkeyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rsimganalys;
+using namespace AlibabaCloud::Rsimganalys::Model;
+
+AccessAppkeyResult::AccessAppkeyResult() :
+	ServiceResult()
+{}
+
+AccessAppkeyResult::AccessAppkeyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AccessAppkeyResult::~AccessAppkeyResult()
+{}
+
+void AccessAppkeyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString();
+
+}
+
+std::string AccessAppkeyResult::getData()const
+{
+	return data_;
+}
+

rsimganalys/src/model/AccessTokenRequest.cc

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rsimganalys/model/AccessTokenRequest.h>
+
+using AlibabaCloud::Rsimganalys::Model::AccessTokenRequest;
+
+AccessTokenRequest::AccessTokenRequest() :
+	RpcServiceRequest("rsimganalys", "2019-08-01", "AccessToken")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AccessTokenRequest::~AccessTokenRequest()
+{}
+

rsimganalys/src/model/AccessTokenResult.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 <alibabacloud/rsimganalys/model/AccessTokenResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rsimganalys;
+using namespace AlibabaCloud::Rsimganalys::Model;
+
+AccessTokenResult::AccessTokenResult() :
+	ServiceResult()
+{}
+
+AccessTokenResult::AccessTokenResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AccessTokenResult::~AccessTokenResult()
+{}
+
+void AccessTokenResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString();
+
+}
+
+std::string AccessTokenResult::getData()const
+{
+	return data_;
+}
+

rsimganalys/src/model/CreateImageRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rsimganalys/model/CreateImageRequest.h>
+
+using AlibabaCloud::Rsimganalys::Model::CreateImageRequest;
+
+CreateImageRequest::CreateImageRequest() :
+	RpcServiceRequest("rsimganalys", "2019-08-01", "CreateImage")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateImageRequest::~CreateImageRequest()
+{}
+
+std::string CreateImageRequest::getImageList()const
+{
+	return imageList_;
+}
+
+void CreateImageRequest::setImageList(const std::string& imageList)
+{
+	imageList_ = imageList;
+	setBodyParameter("ImageList", imageList);
+}
+

rsimganalys/src/model/CreateImageResult.cc

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rsimganalys/model/CreateImageResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rsimganalys;
+using namespace AlibabaCloud::Rsimganalys::Model;
+
+CreateImageResult::CreateImageResult() :
+	ServiceResult()
+{}
+
+CreateImageResult::CreateImageResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateImageResult::~CreateImageResult()
+{}
+
+void CreateImageResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["AliyunPK"].isNull())
+		data_.aliyunPK = dataNode["AliyunPK"].asString();
+	if(!dataNode["Description"].isNull())
+		data_.description = dataNode["Description"].asString();
+	if(!dataNode["DownloadPath"].isNull())
+		data_.downloadPath = dataNode["DownloadPath"].asString();
+	if(!dataNode["GmtCreate"].isNull())
+		data_.gmtCreate = dataNode["GmtCreate"].asString();
+	if(!dataNode["GmtModified"].isNull())
+		data_.gmtModified = dataNode["GmtModified"].asString();
+	if(!dataNode["ImageId"].isNull())
+		data_.imageId = std::stoi(dataNode["ImageId"].asString());
+	if(!dataNode["JobId"].isNull())
+		data_.jobId = dataNode["JobId"].asString();
+	if(!dataNode["ImageName"].isNull())
+		data_.imageName = dataNode["ImageName"].asString();
+	if(!dataNode["RunStatus"].isNull())
+		data_.runStatus = std::stoi(dataNode["RunStatus"].asString());
+	if(!dataNode["UrlUploadPath"].isNull())
+		data_.urlUploadPath = dataNode["UrlUploadPath"].asString();
+	if(!dataNode["FileTime"].isNull())
+		data_.fileTime = std::stol(dataNode["FileTime"].asString());
+	if(!dataNode["StatusCode"].isNull())
+		data_.statusCode = dataNode["StatusCode"].asString();
+	if(!dataNode["StatusMessage"].isNull())
+		data_.statusMessage = dataNode["StatusMessage"].asString();
+	if(!value["ResultCode"].isNull())
+		resultCode_ = std::stoi(value["ResultCode"].asString());
+	if(!value["ImageId"].isNull())
+		imageId_ = value["ImageId"].asString();
+	if(!value["ResultMessage"].isNull())
+		resultMessage_ = value["ResultMessage"].asString();
+	if(!value["UserResolution"].isNull())
+		userResolution_ = value["UserResolution"].asString();
+	if(!value["PublishStatus"].isNull())
+		publishStatus_ = std::stoi(value["PublishStatus"].asString());
+
+}
+
+std::string CreateImageResult::getUserResolution()const
+{
+	return userResolution_;
+}
+
+std::string CreateImageResult::getImageId()const
+{
+	return imageId_;
+}
+
+CreateImageResult::Data CreateImageResult::getData()const
+{
+	return data_;
+}
+
+std::string CreateImageResult::getResultMessage()const
+{
+	return resultMessage_;
+}
+
+int CreateImageResult::getResultCode()const
+{
+	return resultCode_;
+}
+
+int CreateImageResult::getPublishStatus()const
+{
+	return publishStatus_;
+}
+

rsimganalys/src/model/CreateTaskRequest.cc

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rsimganalys/model/CreateTaskRequest.h>
+
+using AlibabaCloud::Rsimganalys::Model::CreateTaskRequest;
+
+CreateTaskRequest::CreateTaskRequest() :
+	RpcServiceRequest("rsimganalys", "2019-08-01", "CreateTask")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateTaskRequest::~CreateTaskRequest()
+{}
+
+float CreateTaskRequest::getConfidence()const
+{
+	return confidence_;
+}
+
+void CreateTaskRequest::setConfidence(float confidence)
+{
+	confidence_ = confidence;
+	setParameter("Confidence", std::to_string(confidence));
+}
+
+long CreateTaskRequest::getFilterValue()const
+{
+	return filterValue_;
+}
+
+void CreateTaskRequest::setFilterValue(long filterValue)
+{
+	filterValue_ = filterValue;
+	setParameter("FilterValue", std::to_string(filterValue));
+}
+
+std::string CreateTaskRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateTaskRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
+std::string CreateTaskRequest::getShpFilter()const
+{
+	return shpFilter_;
+}
+
+void CreateTaskRequest::setShpFilter(const std::string& shpFilter)
+{
+	shpFilter_ = shpFilter;
+	setParameter("ShpFilter", shpFilter);
+}
+
+std::string CreateTaskRequest::getProductType()const
+{
+	return productType_;
+}
+
+void CreateTaskRequest::setProductType(const std::string& productType)
+{
+	productType_ = productType;
+	setParameter("ProductType", productType);
+}
+
+std::string CreateTaskRequest::getZoneList()const
+{
+	return zoneList_;
+}
+
+void CreateTaskRequest::setZoneList(const std::string& zoneList)
+{
+	zoneList_ = zoneList;
+	setParameter("ZoneList", zoneList);
+}
+
+std::string CreateTaskRequest::getSrcImageId()const
+{
+	return srcImageId_;
+}
+
+void CreateTaskRequest::setSrcImageId(const std::string& srcImageId)
+{
+	srcImageId_ = srcImageId;
+	setParameter("SrcImageId", srcImageId);
+}
+
+std::string CreateTaskRequest::getAppkey()const
+{
+	return appkey_;
+}
+
+void CreateTaskRequest::setAppkey(const std::string& appkey)
+{
+	appkey_ = appkey;
+	setParameter("Appkey", appkey);
+}
+
+std::string CreateTaskRequest::getDstImageId()const
+{
+	return dstImageId_;
+}
+
+void CreateTaskRequest::setDstImageId(const std::string& dstImageId)
+{
+	dstImageId_ = dstImageId;
+	setParameter("DstImageId", dstImageId);
+}
+

rsimganalys/src/model/CreateTaskResult.cc

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rsimganalys/model/CreateTaskResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rsimganalys;
+using namespace AlibabaCloud::Rsimganalys::Model;
+
+CreateTaskResult::CreateTaskResult() :
+	ServiceResult()
+{}
+
+CreateTaskResult::CreateTaskResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateTaskResult::~CreateTaskResult()
+{}
+
+void CreateTaskResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["Appkey"].isNull())
+		data_.appkey = dataNode["Appkey"].asString();
+	if(!dataNode["UserId"].isNull())
+		data_.userId = dataNode["UserId"].asString();
+	if(!dataNode["JobId"].isNull())
+		data_.jobId = dataNode["JobId"].asString();
+	if(!dataNode["Status"].isNull())
+		data_.status = dataNode["Status"].asString();
+	if(!dataNode["Request"].isNull())
+		data_.request = dataNode["Request"].asString();
+	if(!dataNode["Progress"].isNull())
+		data_.progress = std::stoi(dataNode["Progress"].asString());
+	if(!dataNode["Namespace"].isNull())
+		data_._namespace = dataNode["Namespace"].asString();
+	if(!dataNode["Version"].isNull())
+		data_.version = dataNode["Version"].asString();
+	if(!value["ResultCode"].isNull())
+		resultCode_ = std::stoi(value["ResultCode"].asString());
+	if(!value["ResultMessage"].isNull())
+		resultMessage_ = value["ResultMessage"].asString();
+
+}
+
+CreateTaskResult::Data CreateTaskResult::getData()const
+{
+	return data_;
+}
+
+std::string CreateTaskResult::getResultMessage()const
+{
+	return resultMessage_;
+}
+
+int CreateTaskResult::getResultCode()const
+{
+	return resultCode_;
+}
+

rsimganalys/src/model/DeleteImageRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rsimganalys/model/DeleteImageRequest.h>
+
+using AlibabaCloud::Rsimganalys::Model::DeleteImageRequest;
+
+DeleteImageRequest::DeleteImageRequest() :
+	RpcServiceRequest("rsimganalys", "2019-08-01", "DeleteImage")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteImageRequest::~DeleteImageRequest()
+{}
+
+long DeleteImageRequest::getImageId()const
+{
+	return imageId_;
+}
+
+void DeleteImageRequest::setImageId(long imageId)
+{
+	imageId_ = imageId;
+	setParameter("ImageId", std::to_string(imageId));
+}
+

rsimganalys/src/model/DeleteImageResult.cc

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

rsimganalys/src/model/DeleteTaskRequest.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 <alibabacloud/rsimganalys/model/DeleteTaskRequest.h>
+
+using AlibabaCloud::Rsimganalys::Model::DeleteTaskRequest;
+
+DeleteTaskRequest::DeleteTaskRequest() :
+	RpcServiceRequest("rsimganalys", "2019-08-01", "DeleteTask")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteTaskRequest::~DeleteTaskRequest()
+{}
+
+std::string DeleteTaskRequest::getJobId()const
+{
+	return jobId_;
+}
+
+void DeleteTaskRequest::setJobId(const std::string& jobId)
+{
+	jobId_ = jobId;
+	setParameter("JobId", jobId);
+}
+
+std::string DeleteTaskRequest::getAppkey()const
+{
+	return appkey_;
+}
+
+void DeleteTaskRequest::setAppkey(const std::string& appkey)
+{
+	appkey_ = appkey;
+	setParameter("Appkey", appkey);
+}
+

rsimganalys/src/model/DeleteTaskResult.cc

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

rsimganalys/src/model/GetImageRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rsimganalys/model/GetImageRequest.h>
+
+using AlibabaCloud::Rsimganalys::Model::GetImageRequest;
+
+GetImageRequest::GetImageRequest() :
+	RpcServiceRequest("rsimganalys", "2019-08-01", "GetImage")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetImageRequest::~GetImageRequest()
+{}
+
+long GetImageRequest::getImageId()const
+{
+	return imageId_;
+}
+
+void GetImageRequest::setImageId(long imageId)
+{
+	imageId_ = imageId;
+	setParameter("ImageId", std::to_string(imageId));
+}
+

rsimganalys/src/model/GetImageResult.cc

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rsimganalys/model/GetImageResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rsimganalys;
+using namespace AlibabaCloud::Rsimganalys::Model;
+
+GetImageResult::GetImageResult() :
+	ServiceResult()
+{}
+
+GetImageResult::GetImageResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetImageResult::~GetImageResult()
+{}
+
+void GetImageResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["ImageName"].isNull())
+		data_.imageName = dataNode["ImageName"].asString();
+	if(!dataNode["Appkey"].isNull())
+		data_.appkey = dataNode["Appkey"].asString();
+	if(!dataNode["FileTime"].isNull())
+		data_.fileTime = std::stol(dataNode["FileTime"].asString());
+	if(!dataNode["Description"].isNull())
+		data_.description = dataNode["Description"].asString();
+	if(!dataNode["AliyunPK"].isNull())
+		data_.aliyunPK = dataNode["AliyunPK"].asString();
+	if(!dataNode["RunStatus"].isNull())
+		data_.runStatus = std::stoi(dataNode["RunStatus"].asString());
+	if(!dataNode["UserResolution"].isNull())
+		data_.userResolution = dataNode["UserResolution"].asString();
+	if(!dataNode["Resolution"].isNull())
+		data_.resolution = dataNode["Resolution"].asString();
+	if(!dataNode["UCS"].isNull())
+		data_.uCS = dataNode["UCS"].asString();
+	if(!dataNode["PixelSize"].isNull())
+		data_.pixelSize = dataNode["PixelSize"].asString();
+	if(!dataNode["PublishStatus"].isNull())
+		data_.publishStatus = std::stoi(dataNode["PublishStatus"].asString());
+	if(!value["ResultCode"].isNull())
+		resultCode_ = value["ResultCode"].asString();
+	if(!value["ResultMessage"].isNull())
+		resultMessage_ = value["ResultMessage"].asString();
+	if(!value["DownloadPath"].isNull())
+		downloadPath_ = value["DownloadPath"].asString();
+
+}
+
+std::string GetImageResult::getDownloadPath()const
+{
+	return downloadPath_;
+}
+
+GetImageResult::Data GetImageResult::getData()const
+{
+	return data_;
+}
+
+std::string GetImageResult::getResultMessage()const
+{
+	return resultMessage_;
+}
+
+std::string GetImageResult::getResultCode()const
+{
+	return resultCode_;
+}
+

rsimganalys/src/model/GetShpInfoRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rsimganalys/model/GetShpInfoRequest.h>
+
+using AlibabaCloud::Rsimganalys::Model::GetShpInfoRequest;
+
+GetShpInfoRequest::GetShpInfoRequest() :
+	RpcServiceRequest("rsimganalys", "2019-08-01", "GetShpInfo")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetShpInfoRequest::~GetShpInfoRequest()
+{}
+
+std::string GetShpInfoRequest::getFid()const
+{
+	return fid_;
+}
+
+void GetShpInfoRequest::setFid(const std::string& fid)
+{
+	fid_ = fid;
+	setParameter("Fid", fid);
+}
+
+std::string GetShpInfoRequest::getTaskId()const
+{
+	return taskId_;
+}
+
+void GetShpInfoRequest::setTaskId(const std::string& taskId)
+{
+	taskId_ = taskId;
+	setParameter("TaskId", taskId);
+}
+
+std::string GetShpInfoRequest::getFileId()const
+{
+	return fileId_;
+}
+
+void GetShpInfoRequest::setFileId(const std::string& fileId)
+{
+	fileId_ = fileId;
+	setParameter("FileId", fileId);
+}
+

rsimganalys/src/model/GetShpInfoResult.cc

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

rsimganalys/src/model/GetTaskRequest.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 <alibabacloud/rsimganalys/model/GetTaskRequest.h>
+
+using AlibabaCloud::Rsimganalys::Model::GetTaskRequest;
+
+GetTaskRequest::GetTaskRequest() :
+	RpcServiceRequest("rsimganalys", "2019-08-01", "GetTask")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetTaskRequest::~GetTaskRequest()
+{}
+
+std::string GetTaskRequest::getJobId()const
+{
+	return jobId_;
+}
+
+void GetTaskRequest::setJobId(const std::string& jobId)
+{
+	jobId_ = jobId;
+	setParameter("JobId", jobId);
+}
+
+std::string GetTaskRequest::getAppkey()const
+{
+	return appkey_;
+}
+
+void GetTaskRequest::setAppkey(const std::string& appkey)
+{
+	appkey_ = appkey;
+	setParameter("Appkey", appkey);
+}
+

rsimganalys/src/model/GetTaskResult.cc

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rsimganalys/model/GetTaskResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rsimganalys;
+using namespace AlibabaCloud::Rsimganalys::Model;
+
+GetTaskResult::GetTaskResult() :
+	ServiceResult()
+{}
+
+GetTaskResult::GetTaskResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetTaskResult::~GetTaskResult()
+{}
+
+void GetTaskResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["JobId"].isNull())
+		data_.jobId = dataNode["JobId"].asString();
+	if(!dataNode["Status"].isNull())
+		data_.status = dataNode["Status"].asString();
+	if(!dataNode["StatusCode"].isNull())
+		data_.statusCode = dataNode["StatusCode"].asString();
+	if(!dataNode["StatusMessage"].isNull())
+		data_.statusMessage = dataNode["StatusMessage"].asString();
+	if(!dataNode["Request"].isNull())
+		data_.request = dataNode["Request"].asString();
+	if(!dataNode["Response"].isNull())
+		data_.response = dataNode["Response"].asString();
+	if(!dataNode["Progress"].isNull())
+		data_.progress = std::stoi(dataNode["Progress"].asString());
+	if(!dataNode["Namespace"].isNull())
+		data_._namespace = dataNode["Namespace"].asString();
+	if(!dataNode["CreateTime"].isNull())
+		data_.createTime = std::stol(dataNode["CreateTime"].asString());
+	if(!dataNode["LastUpdateTime"].isNull())
+		data_.lastUpdateTime = std::stol(dataNode["LastUpdateTime"].asString());
+	if(!dataNode["Version"].isNull())
+		data_.version = std::stoi(dataNode["Version"].asString());
+	if(!dataNode["Appkey"].isNull())
+		data_.appkey = dataNode["Appkey"].asString();
+	if(!dataNode["UserId"].isNull())
+		data_.userId = dataNode["UserId"].asString();
+	if(!dataNode["PublishStatus"].isNull())
+		data_.publishStatus = std::stoi(dataNode["PublishStatus"].asString());
+	if(!dataNode["TaskCoordinateSystem"].isNull())
+		data_.taskCoordinateSystem = dataNode["TaskCoordinateSystem"].asString();
+	if(!dataNode["TaskStatistics"].isNull())
+		data_.taskStatistics = dataNode["TaskStatistics"].asString();
+	if(!dataNode["SourceCoordinateSystem"].isNull())
+		data_.sourceCoordinateSystem = dataNode["SourceCoordinateSystem"].asString();
+	if(!dataNode["DestinationCoordinateSystem"].isNull())
+		data_.destinationCoordinateSystem = dataNode["DestinationCoordinateSystem"].asString();
+	if(!value["ResultCode"].isNull())
+		resultCode_ = value["ResultCode"].asString();
+	if(!value["ResultMessage"].isNull())
+		resultMessage_ = value["ResultMessage"].asString();
+
+}
+
+GetTaskResult::Data GetTaskResult::getData()const
+{
+	return data_;
+}
+
+std::string GetTaskResult::getResultMessage()const
+{
+	return resultMessage_;
+}
+
+std::string GetTaskResult::getResultCode()const
+{
+	return resultCode_;
+}
+

rsimganalys/src/model/ListTasksRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rsimganalys/model/ListTasksRequest.h>
+
+using AlibabaCloud::Rsimganalys::Model::ListTasksRequest;
+
+ListTasksRequest::ListTasksRequest() :
+	RpcServiceRequest("rsimganalys", "2019-08-01", "ListTasks")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListTasksRequest::~ListTasksRequest()
+{}
+
+std::string ListTasksRequest::getAppkey()const
+{
+	return appkey_;
+}
+
+void ListTasksRequest::setAppkey(const std::string& appkey)
+{
+	appkey_ = appkey;
+	setParameter("Appkey", appkey);
+}
+

rsimganalys/src/model/ListTasksResult.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 <alibabacloud/rsimganalys/model/ListTasksResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rsimganalys;
+using namespace AlibabaCloud::Rsimganalys::Model;
+
+ListTasksResult::ListTasksResult() :
+	ServiceResult()
+{}
+
+ListTasksResult::ListTasksResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListTasksResult::~ListTasksResult()
+{}
+
+void ListTasksResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["Contents"];
+	for (auto valueDataContents : allDataNode)
+	{
+		Contents dataObject;
+		if(!valueDataContents["Appkey"].isNull())
+			dataObject.appkey = valueDataContents["Appkey"].asString();
+		if(!valueDataContents["UserId"].isNull())
+			dataObject.userId = valueDataContents["UserId"].asString();
+		if(!valueDataContents["JobId"].isNull())
+			dataObject.jobId = valueDataContents["JobId"].asString();
+		if(!valueDataContents["Status"].isNull())
+			dataObject.status = valueDataContents["Status"].asString();
+		if(!valueDataContents["Request"].isNull())
+			dataObject.request = valueDataContents["Request"].asString();
+		if(!valueDataContents["Progress"].isNull())
+			dataObject.progress = std::stoi(valueDataContents["Progress"].asString());
+		if(!valueDataContents["Namespace"].isNull())
+			dataObject._namespace = valueDataContents["Namespace"].asString();
+		if(!valueDataContents["Version"].isNull())
+			dataObject.version = valueDataContents["Version"].asString();
+		if(!valueDataContents["CreateTime"].isNull())
+			dataObject.createTime = std::stol(valueDataContents["CreateTime"].asString());
+		if(!valueDataContents["LastUpdateTime"].isNull())
+			dataObject.lastUpdateTime = std::stol(valueDataContents["LastUpdateTime"].asString());
+		if(!valueDataContents["Response"].isNull())
+			dataObject.response = valueDataContents["Response"].asString();
+		if(!valueDataContents["StatusMessage"].isNull())
+			dataObject.statusMessage = valueDataContents["StatusMessage"].asString();
+		if(!valueDataContents["StatusCode"].isNull())
+			dataObject.statusCode = std::stoi(valueDataContents["StatusCode"].asString());
+		if(!valueDataContents["EnableZoneIdentification"].isNull())
+			dataObject.enableZoneIdentification = std::stoi(valueDataContents["EnableZoneIdentification"].asString());
+		if(!valueDataContents["PublishStatus"].isNull())
+			dataObject.publishStatus = std::stoi(valueDataContents["PublishStatus"].asString());
+		data_.push_back(dataObject);
+	}
+	if(!value["ResultCode"].isNull())
+		resultCode_ = std::stoi(value["ResultCode"].asString());
+	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());
+	if(!value["ResultMessage"].isNull())
+		resultMessage_ = value["ResultMessage"].asString();
+
+}
+
+int ListTasksResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int ListTasksResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int ListTasksResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<ListTasksResult::Contents> ListTasksResult::getData()const
+{
+	return data_;
+}
+
+std::string ListTasksResult::getResultMessage()const
+{
+	return resultMessage_;
+}
+
+int ListTasksResult::getResultCode()const
+{
+	return resultCode_;
+}
+

rtc/CMakeLists.txt

@@ -89,6 +89,10 @@ set(rtc_public_header_model
 	include/alibabacloud/rtc/model/DescribeRtcPeakUserCntDataResult.h
 	include/alibabacloud/rtc/model/DescribeRtcQualityMetricRequest.h
 	include/alibabacloud/rtc/model/DescribeRtcQualityMetricResult.h
+	include/alibabacloud/rtc/model/DescribeRtcScaleRequest.h
+	include/alibabacloud/rtc/model/DescribeRtcScaleResult.h
+	include/alibabacloud/rtc/model/DescribeRtcScaleDetailRequest.h
+	include/alibabacloud/rtc/model/DescribeRtcScaleDetailResult.h
 	include/alibabacloud/rtc/model/DescribeRtcUserCntDataRequest.h
 	include/alibabacloud/rtc/model/DescribeRtcUserCntDataResult.h
 	include/alibabacloud/rtc/model/DescribeRtcUserEventsRequest.h
@@ -214,6 +218,10 @@ set(rtc_src
 	src/model/DescribeRtcPeakUserCntDataResult.cc
 	src/model/DescribeRtcQualityMetricRequest.cc
 	src/model/DescribeRtcQualityMetricResult.cc
+	src/model/DescribeRtcScaleRequest.cc
+	src/model/DescribeRtcScaleResult.cc
+	src/model/DescribeRtcScaleDetailRequest.cc
+	src/model/DescribeRtcScaleDetailResult.cc
 	src/model/DescribeRtcUserCntDataRequest.cc
 	src/model/DescribeRtcUserCntDataResult.cc
 	src/model/DescribeRtcUserEventsRequest.cc

rtc/include/alibabacloud/rtc/RtcClient.h

@@ -90,6 +90,10 @@
 #include "model/DescribeRtcPeakUserCntDataResult.h"
 #include "model/DescribeRtcQualityMetricRequest.h"
 #include "model/DescribeRtcQualityMetricResult.h"
+#include "model/DescribeRtcScaleRequest.h"
+#include "model/DescribeRtcScaleResult.h"
+#include "model/DescribeRtcScaleDetailRequest.h"
+#include "model/DescribeRtcScaleDetailResult.h"
 #include "model/DescribeRtcUserCntDataRequest.h"
 #include "model/DescribeRtcUserCntDataResult.h"
 #include "model/DescribeRtcUserEventsRequest.h"
@@ -255,6 +259,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeRtcQualityMetricResult> DescribeRtcQualityMetricOutcome;
 			typedef std::future<DescribeRtcQualityMetricOutcome> DescribeRtcQualityMetricOutcomeCallable;
 			typedef std::function<void(const RtcClient*, const Model::DescribeRtcQualityMetricRequest&, const DescribeRtcQualityMetricOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRtcQualityMetricAsyncHandler;
+			typedef Outcome<Error, Model::DescribeRtcScaleResult> DescribeRtcScaleOutcome;
+			typedef std::future<DescribeRtcScaleOutcome> DescribeRtcScaleOutcomeCallable;
+			typedef std::function<void(const RtcClient*, const Model::DescribeRtcScaleRequest&, const DescribeRtcScaleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRtcScaleAsyncHandler;
+			typedef Outcome<Error, Model::DescribeRtcScaleDetailResult> DescribeRtcScaleDetailOutcome;
+			typedef std::future<DescribeRtcScaleDetailOutcome> DescribeRtcScaleDetailOutcomeCallable;
+			typedef std::function<void(const RtcClient*, const Model::DescribeRtcScaleDetailRequest&, const DescribeRtcScaleDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRtcScaleDetailAsyncHandler;
 			typedef Outcome<Error, Model::DescribeRtcUserCntDataResult> DescribeRtcUserCntDataOutcome;
 			typedef std::future<DescribeRtcUserCntDataOutcome> DescribeRtcUserCntDataOutcomeCallable;
 			typedef std::function<void(const RtcClient*, const Model::DescribeRtcUserCntDataRequest&, const DescribeRtcUserCntDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRtcUserCntDataAsyncHandler;
@@ -443,6 +453,12 @@ namespace AlibabaCloud
 			DescribeRtcQualityMetricOutcome describeRtcQualityMetric(const Model::DescribeRtcQualityMetricRequest &request)const;
 			void describeRtcQualityMetricAsync(const Model::DescribeRtcQualityMetricRequest& request, const DescribeRtcQualityMetricAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeRtcQualityMetricOutcomeCallable describeRtcQualityMetricCallable(const Model::DescribeRtcQualityMetricRequest& request) const;
+			DescribeRtcScaleOutcome describeRtcScale(const Model::DescribeRtcScaleRequest &request)const;
+			void describeRtcScaleAsync(const Model::DescribeRtcScaleRequest& request, const DescribeRtcScaleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeRtcScaleOutcomeCallable describeRtcScaleCallable(const Model::DescribeRtcScaleRequest& request) const;
+			DescribeRtcScaleDetailOutcome describeRtcScaleDetail(const Model::DescribeRtcScaleDetailRequest &request)const;
+			void describeRtcScaleDetailAsync(const Model::DescribeRtcScaleDetailRequest& request, const DescribeRtcScaleDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeRtcScaleDetailOutcomeCallable describeRtcScaleDetailCallable(const Model::DescribeRtcScaleDetailRequest& request) const;
 			DescribeRtcUserCntDataOutcome describeRtcUserCntData(const Model::DescribeRtcUserCntDataRequest &request)const;
 			void describeRtcUserCntDataAsync(const Model::DescribeRtcUserCntDataRequest& request, const DescribeRtcUserCntDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeRtcUserCntDataOutcomeCallable describeRtcUserCntDataCallable(const Model::DescribeRtcUserCntDataRequest& request) const;

rtc/include/alibabacloud/rtc/model/DescribeRtcScaleDetailRequest.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_RTC_MODEL_DESCRIBERTCSCALEDETAILREQUEST_H_
+#define ALIBABACLOUD_RTC_MODEL_DESCRIBERTCSCALEDETAILREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rtc/RtcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rtc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RTC_EXPORT DescribeRtcScaleDetailRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeRtcScaleDetailRequest();
+				~DescribeRtcScaleDetailRequest();
+
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getShowLog()const;
+				void setShowLog(const std::string& showLog);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAppId()const;
+				void setAppId(const std::string& appId);
+
+            private:
+				std::string startTime_;
+				std::string showLog_;
+				std::string endTime_;
+				long ownerId_;
+				std::string appId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RTC_MODEL_DESCRIBERTCSCALEDETAILREQUEST_H_

rtc/include/alibabacloud/rtc/model/DescribeRtcScaleDetailResult.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_RTC_MODEL_DESCRIBERTCSCALEDETAILRESULT_H_
+#define ALIBABACLOUD_RTC_MODEL_DESCRIBERTCSCALEDETAILRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rtc/RtcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rtc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RTC_EXPORT DescribeRtcScaleDetailResult : public ServiceResult
+			{
+			public:
+				struct ScaleItem
+				{
+					long cC;
+					long uC;
+					std::string tS;
+				};
+
+
+				DescribeRtcScaleDetailResult();
+				explicit DescribeRtcScaleDetailResult(const std::string &payload);
+				~DescribeRtcScaleDetailResult();
+				std::vector<ScaleItem> getScale()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<ScaleItem> scale_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RTC_MODEL_DESCRIBERTCSCALEDETAILRESULT_H_

rtc/include/alibabacloud/rtc/model/DescribeRtcScaleRequest.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_RTC_MODEL_DESCRIBERTCSCALEREQUEST_H_
+#define ALIBABACLOUD_RTC_MODEL_DESCRIBERTCSCALEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rtc/RtcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rtc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RTC_EXPORT DescribeRtcScaleRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeRtcScaleRequest();
+				~DescribeRtcScaleRequest();
+
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getShowLog()const;
+				void setShowLog(const std::string& showLog);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAppId()const;
+				void setAppId(const std::string& appId);
+
+            private:
+				std::string startTime_;
+				std::string showLog_;
+				std::string endTime_;
+				long ownerId_;
+				std::string appId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RTC_MODEL_DESCRIBERTCSCALEREQUEST_H_

rtc/include/alibabacloud/rtc/model/DescribeRtcScaleResult.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_RTC_MODEL_DESCRIBERTCSCALERESULT_H_
+#define ALIBABACLOUD_RTC_MODEL_DESCRIBERTCSCALERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rtc/RtcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rtc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RTC_EXPORT DescribeRtcScaleResult : public ServiceResult
+			{
+			public:
+				struct ScaleItem
+				{
+					long channelCount;
+					long videoDuration;
+					long userCount;
+					std::string time;
+					long sessionCount;
+					long audioDuration;
+				};
+
+
+				DescribeRtcScaleResult();
+				explicit DescribeRtcScaleResult(const std::string &payload);
+				~DescribeRtcScaleResult();
+				std::vector<ScaleItem> getScale()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<ScaleItem> scale_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RTC_MODEL_DESCRIBERTCSCALERESULT_H_

rtc/include/alibabacloud/rtc/model/StartMPUTaskRequest.h

@@ -59,6 +59,15 @@ namespace AlibabaCloud
 					};
 					std::vector<Texts> texts;
 				};
+				struct ClockWidgets
+				{
+					float x;
+					float y;
+					int fontType;
+					int fontSize;
+					int fontColor;
+					int zOrder;
+				};
 				struct Watermarks
 				{
 					std::string url;
@@ -89,30 +98,38 @@ namespace AlibabaCloud
 				void setPayloadType(int payloadType);
 				std::vector<UserPanes> getUserPanes()const;
 				void setUserPanes(const std::vector<UserPanes>& userPanes);
-				int getRtpExtInfo()const;
-				void setRtpExtInfo(int rtpExtInfo);
 				int getBackgroundColor()const;
 				void setBackgroundColor(int backgroundColor);
-				int getCropMode()const;
-				void setCropMode(int cropMode);
 				int getReportVad()const;
 				void setReportVad(int reportVad);
-				std::string getTaskProfile()const;
-				void setTaskProfile(const std::string& taskProfile);
-				std::vector<long> getLayoutIds()const;
-				void setLayoutIds(const std::vector<long>& layoutIds);
+				std::string getSourceType()const;
+				void setSourceType(const std::string& sourceType);
 				std::string getTaskId()const;
 				void setTaskId(const std::string& taskId);
+				std::vector<ClockWidgets> getClockWidgets()const;
+				void setClockWidgets(const std::vector<ClockWidgets>& clockWidgets);
 				std::string getShowLog()const;
 				void setShowLog(const std::string& showLog);
-				std::string getStreamURL()const;
-				void setStreamURL(const std::string& streamURL);
 				long getVadInterval()const;
 				void setVadInterval(long vadInterval);
 				std::vector<Watermarks> getWatermarks()const;
 				void setWatermarks(const std::vector<Watermarks>& watermarks);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
+				int getMediaEncode()const;
+				void setMediaEncode(int mediaEncode);
+				int getRtpExtInfo()const;
+				void setRtpExtInfo(int rtpExtInfo);
+				int getCropMode()const;
+				void setCropMode(int cropMode);
+				std::string getTaskProfile()const;
+				void setTaskProfile(const std::string& taskProfile);
+				std::vector<long> getLayoutIds()const;
+				void setLayoutIds(const std::vector<long>& layoutIds);
+				std::string getStreamURL()const;
+				void setStreamURL(const std::string& streamURL);
+				int getStreamType()const;
+				void setStreamType(int streamType);
 				std::vector<std::string> getSubSpecUsers()const;
 				void setSubSpecUsers(const std::vector<std::string>& subSpecUsers);
 				std::string getAppId()const;
@@ -121,31 +138,35 @@ namespace AlibabaCloud
 				void setBackgrounds(const std::vector<Backgrounds>& backgrounds);
 				long getTimeStampRef()const;
 				void setTimeStampRef(long timeStampRef);
-				int getMediaEncode()const;
-				void setMediaEncode(int mediaEncode);
+				int getMixMode()const;
+				void setMixMode(int mixMode);
 				std::string getChannelId()const;
 				void setChannelId(const std::string& channelId);
 
             private:
 				int payloadType_;
 				std::vector<UserPanes> userPanes_;
-				int rtpExtInfo_;
 				int backgroundColor_;
-				int cropMode_;
 				int reportVad_;
-				std::string taskProfile_;
-				std::vector<long> layoutIds_;
+				std::string sourceType_;
 				std::string taskId_;
+				std::vector<ClockWidgets> clockWidgets_;
 				std::string showLog_;
-				std::string streamURL_;
 				long vadInterval_;
 				std::vector<Watermarks> watermarks_;
 				long ownerId_;
+				int mediaEncode_;
+				int rtpExtInfo_;
+				int cropMode_;
+				std::string taskProfile_;
+				std::vector<long> layoutIds_;
+				std::string streamURL_;
+				int streamType_;
 				std::vector<std::string> subSpecUsers_;
 				std::string appId_;
 				std::vector<Backgrounds> backgrounds_;
 				long timeStampRef_;
-				int mediaEncode_;
+				int mixMode_;
 				std::string channelId_;
 
 			};

rtc/include/alibabacloud/rtc/model/UpdateMPULayoutRequest.h

@@ -59,6 +59,15 @@ namespace AlibabaCloud
 					};
 					std::vector<Texts> texts;
 				};
+				struct ClockWidgets
+				{
+					float x;
+					float y;
+					int fontType;
+					int fontSize;
+					int fontColor;
+					int zOrder;
+				};
 				struct Watermarks
 				{
 					std::string url;
@@ -95,6 +104,8 @@ namespace AlibabaCloud
 				void setLayoutIds(const std::vector<long>& layoutIds);
 				std::string getTaskId()const;
 				void setTaskId(const std::string& taskId);
+				std::vector<ClockWidgets> getClockWidgets()const;
+				void setClockWidgets(const std::vector<ClockWidgets>& clockWidgets);
 				std::string getShowLog()const;
 				void setShowLog(const std::string& showLog);
 				std::vector<Watermarks> getWatermarks()const;
@@ -112,6 +123,7 @@ namespace AlibabaCloud
 				int cropMode_;
 				std::vector<long> layoutIds_;
 				std::string taskId_;
+				std::vector<ClockWidgets> clockWidgets_;
 				std::string showLog_;
 				std::vector<Watermarks> watermarks_;
 				long ownerId_;

rtc/src/RtcClient.cc

@@ -1275,6 +1275,78 @@ RtcClient::DescribeRtcQualityMetricOutcomeCallable RtcClient::describeRtcQuality
 	return task->get_future();
 }
 
+RtcClient::DescribeRtcScaleOutcome RtcClient::describeRtcScale(const DescribeRtcScaleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeRtcScaleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeRtcScaleOutcome(DescribeRtcScaleResult(outcome.result()));
+	else
+		return DescribeRtcScaleOutcome(outcome.error());
+}
+
+void RtcClient::describeRtcScaleAsync(const DescribeRtcScaleRequest& request, const DescribeRtcScaleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeRtcScale(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RtcClient::DescribeRtcScaleOutcomeCallable RtcClient::describeRtcScaleCallable(const DescribeRtcScaleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeRtcScaleOutcome()>>(
+			[this, request]()
+			{
+			return this->describeRtcScale(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+RtcClient::DescribeRtcScaleDetailOutcome RtcClient::describeRtcScaleDetail(const DescribeRtcScaleDetailRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeRtcScaleDetailOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeRtcScaleDetailOutcome(DescribeRtcScaleDetailResult(outcome.result()));
+	else
+		return DescribeRtcScaleDetailOutcome(outcome.error());
+}
+
+void RtcClient::describeRtcScaleDetailAsync(const DescribeRtcScaleDetailRequest& request, const DescribeRtcScaleDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeRtcScaleDetail(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RtcClient::DescribeRtcScaleDetailOutcomeCallable RtcClient::describeRtcScaleDetailCallable(const DescribeRtcScaleDetailRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeRtcScaleDetailOutcome()>>(
+			[this, request]()
+			{
+			return this->describeRtcScaleDetail(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 RtcClient::DescribeRtcUserCntDataOutcome RtcClient::describeRtcUserCntData(const DescribeRtcUserCntDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

rtc/src/model/DescribeRtcScaleDetailRequest.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 <alibabacloud/rtc/model/DescribeRtcScaleDetailRequest.h>
+
+using AlibabaCloud::Rtc::Model::DescribeRtcScaleDetailRequest;
+
+DescribeRtcScaleDetailRequest::DescribeRtcScaleDetailRequest() :
+	RpcServiceRequest("rtc", "2018-01-11", "DescribeRtcScaleDetail")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeRtcScaleDetailRequest::~DescribeRtcScaleDetailRequest()
+{}
+
+std::string DescribeRtcScaleDetailRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeRtcScaleDetailRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeRtcScaleDetailRequest::getShowLog()const
+{
+	return showLog_;
+}
+
+void DescribeRtcScaleDetailRequest::setShowLog(const std::string& showLog)
+{
+	showLog_ = showLog;
+	setParameter("ShowLog", showLog);
+}
+
+std::string DescribeRtcScaleDetailRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeRtcScaleDetailRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+long DescribeRtcScaleDetailRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeRtcScaleDetailRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeRtcScaleDetailRequest::getAppId()const
+{
+	return appId_;
+}
+
+void DescribeRtcScaleDetailRequest::setAppId(const std::string& appId)
+{
+	appId_ = appId;
+	setParameter("AppId", appId);
+}
+

rtc/src/model/DescribeRtcScaleDetailResult.cc

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

rtc/src/model/DescribeRtcScaleRequest.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 <alibabacloud/rtc/model/DescribeRtcScaleRequest.h>
+
+using AlibabaCloud::Rtc::Model::DescribeRtcScaleRequest;
+
+DescribeRtcScaleRequest::DescribeRtcScaleRequest() :
+	RpcServiceRequest("rtc", "2018-01-11", "DescribeRtcScale")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeRtcScaleRequest::~DescribeRtcScaleRequest()
+{}
+
+std::string DescribeRtcScaleRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeRtcScaleRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeRtcScaleRequest::getShowLog()const
+{
+	return showLog_;
+}
+
+void DescribeRtcScaleRequest::setShowLog(const std::string& showLog)
+{
+	showLog_ = showLog;
+	setParameter("ShowLog", showLog);
+}
+
+std::string DescribeRtcScaleRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeRtcScaleRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+long DescribeRtcScaleRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeRtcScaleRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeRtcScaleRequest::getAppId()const
+{
+	return appId_;
+}
+
+void DescribeRtcScaleRequest::setAppId(const std::string& appId)
+{
+	appId_ = appId;
+	setParameter("AppId", appId);
+}
+

rtc/src/model/DescribeRtcScaleResult.cc

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rtc/model/DescribeRtcScaleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rtc;
+using namespace AlibabaCloud::Rtc::Model;
+
+DescribeRtcScaleResult::DescribeRtcScaleResult() :
+	ServiceResult()
+{}
+
+DescribeRtcScaleResult::DescribeRtcScaleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeRtcScaleResult::~DescribeRtcScaleResult()
+{}
+
+void DescribeRtcScaleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allScaleNode = value["Scale"]["ScaleItem"];
+	for (auto valueScaleScaleItem : allScaleNode)
+	{
+		ScaleItem scaleObject;
+		if(!valueScaleScaleItem["Time"].isNull())
+			scaleObject.time = valueScaleScaleItem["Time"].asString();
+		if(!valueScaleScaleItem["ChannelCount"].isNull())
+			scaleObject.channelCount = std::stol(valueScaleScaleItem["ChannelCount"].asString());
+		if(!valueScaleScaleItem["UserCount"].isNull())
+			scaleObject.userCount = std::stol(valueScaleScaleItem["UserCount"].asString());
+		if(!valueScaleScaleItem["SessionCount"].isNull())
+			scaleObject.sessionCount = std::stol(valueScaleScaleItem["SessionCount"].asString());
+		if(!valueScaleScaleItem["AudioDuration"].isNull())
+			scaleObject.audioDuration = std::stol(valueScaleScaleItem["AudioDuration"].asString());
+		if(!valueScaleScaleItem["VideoDuration"].isNull())
+			scaleObject.videoDuration = std::stol(valueScaleScaleItem["VideoDuration"].asString());
+		scale_.push_back(scaleObject);
+	}
+
+}
+
+std::vector<DescribeRtcScaleResult::ScaleItem> DescribeRtcScaleResult::getScale()const
+{
+	return scale_;
+}
+

rtc/src/model/StartMPUTaskRequest.cc

@@ -77,17 +77,6 @@ void StartMPUTaskRequest::setUserPanes(const std::vector<UserPanes>& userPanes)
 	}
 }
 
-int StartMPUTaskRequest::getRtpExtInfo()const
-{
-	return rtpExtInfo_;
-}
-
-void StartMPUTaskRequest::setRtpExtInfo(int rtpExtInfo)
-{
-	rtpExtInfo_ = rtpExtInfo;
-	setParameter("RtpExtInfo", std::to_string(rtpExtInfo));
-}
-
 int StartMPUTaskRequest::getBackgroundColor()const
 {
 	return backgroundColor_;
@@ -99,17 +88,6 @@ void StartMPUTaskRequest::setBackgroundColor(int backgroundColor)
 	setParameter("BackgroundColor", std::to_string(backgroundColor));
 }
 
-int StartMPUTaskRequest::getCropMode()const
-{
-	return cropMode_;
-}
-
-void StartMPUTaskRequest::setCropMode(int cropMode)
-{
-	cropMode_ = cropMode;
-	setParameter("CropMode", std::to_string(cropMode));
-}
-
 int StartMPUTaskRequest::getReportVad()const
 {
 	return reportVad_;
@@ -121,28 +99,15 @@ void StartMPUTaskRequest::setReportVad(int reportVad)
 	setParameter("ReportVad", std::to_string(reportVad));
 }
 
-std::string StartMPUTaskRequest::getTaskProfile()const
+std::string StartMPUTaskRequest::getSourceType()const
 {
-	return taskProfile_;
+	return sourceType_;
 }
 
-void StartMPUTaskRequest::setTaskProfile(const std::string& taskProfile)
+void StartMPUTaskRequest::setSourceType(const std::string& sourceType)
 {
-	taskProfile_ = taskProfile;
-	setParameter("TaskProfile", taskProfile);
-}
-
-std::vector<long> StartMPUTaskRequest::getLayoutIds()const
-{
-	return layoutIds_;
-}
-
-void StartMPUTaskRequest::setLayoutIds(const std::vector<long>& layoutIds)
-{
-	layoutIds_ = layoutIds;
-	for(int dep1 = 0; dep1!= layoutIds.size(); dep1++) {
-		setParameter("LayoutIds."+ std::to_string(dep1), std::to_string(layoutIds.at(dep1)));
-	}
+	sourceType_ = sourceType;
+	setParameter("SourceType", sourceType);
 }
 
 std::string StartMPUTaskRequest::getTaskId()const
@@ -156,6 +121,26 @@ void StartMPUTaskRequest::setTaskId(const std::string& taskId)
 	setParameter("TaskId", taskId);
 }
 
+std::vector<StartMPUTaskRequest::ClockWidgets> StartMPUTaskRequest::getClockWidgets()const
+{
+	return clockWidgets_;
+}
+
+void StartMPUTaskRequest::setClockWidgets(const std::vector<ClockWidgets>& clockWidgets)
+{
+	clockWidgets_ = clockWidgets;
+	for(int dep1 = 0; dep1!= clockWidgets.size(); dep1++) {
+		auto clockWidgetsObj = clockWidgets.at(dep1);
+		std::string clockWidgetsObjStr = "ClockWidgets." + std::to_string(dep1 + 1);
+		setParameter(clockWidgetsObjStr + ".X", std::to_string(clockWidgetsObj.x));
+		setParameter(clockWidgetsObjStr + ".Y", std::to_string(clockWidgetsObj.y));
+		setParameter(clockWidgetsObjStr + ".FontType", std::to_string(clockWidgetsObj.fontType));
+		setParameter(clockWidgetsObjStr + ".FontSize", std::to_string(clockWidgetsObj.fontSize));
+		setParameter(clockWidgetsObjStr + ".FontColor", std::to_string(clockWidgetsObj.fontColor));
+		setParameter(clockWidgetsObjStr + ".ZOrder", std::to_string(clockWidgetsObj.zOrder));
+	}
+}
+
 std::string StartMPUTaskRequest::getShowLog()const
 {
 	return showLog_;
@@ -167,17 +152,6 @@ void StartMPUTaskRequest::setShowLog(const std::string& showLog)
 	setParameter("ShowLog", showLog);
 }
 
-std::string StartMPUTaskRequest::getStreamURL()const
-{
-	return streamURL_;
-}
-
-void StartMPUTaskRequest::setStreamURL(const std::string& streamURL)
-{
-	streamURL_ = streamURL;
-	setParameter("StreamURL", streamURL);
-}
-
 long StartMPUTaskRequest::getVadInterval()const
 {
 	return vadInterval_;
@@ -222,6 +196,85 @@ void StartMPUTaskRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
+int StartMPUTaskRequest::getMediaEncode()const
+{
+	return mediaEncode_;
+}
+
+void StartMPUTaskRequest::setMediaEncode(int mediaEncode)
+{
+	mediaEncode_ = mediaEncode;
+	setParameter("MediaEncode", std::to_string(mediaEncode));
+}
+
+int StartMPUTaskRequest::getRtpExtInfo()const
+{
+	return rtpExtInfo_;
+}
+
+void StartMPUTaskRequest::setRtpExtInfo(int rtpExtInfo)
+{
+	rtpExtInfo_ = rtpExtInfo;
+	setParameter("RtpExtInfo", std::to_string(rtpExtInfo));
+}
+
+int StartMPUTaskRequest::getCropMode()const
+{
+	return cropMode_;
+}
+
+void StartMPUTaskRequest::setCropMode(int cropMode)
+{
+	cropMode_ = cropMode;
+	setParameter("CropMode", std::to_string(cropMode));
+}
+
+std::string StartMPUTaskRequest::getTaskProfile()const
+{
+	return taskProfile_;
+}
+
+void StartMPUTaskRequest::setTaskProfile(const std::string& taskProfile)
+{
+	taskProfile_ = taskProfile;
+	setParameter("TaskProfile", taskProfile);
+}
+
+std::vector<long> StartMPUTaskRequest::getLayoutIds()const
+{
+	return layoutIds_;
+}
+
+void StartMPUTaskRequest::setLayoutIds(const std::vector<long>& layoutIds)
+{
+	layoutIds_ = layoutIds;
+	for(int dep1 = 0; dep1!= layoutIds.size(); dep1++) {
+		setParameter("LayoutIds."+ std::to_string(dep1), std::to_string(layoutIds.at(dep1)));
+	}
+}
+
+std::string StartMPUTaskRequest::getStreamURL()const
+{
+	return streamURL_;
+}
+
+void StartMPUTaskRequest::setStreamURL(const std::string& streamURL)
+{
+	streamURL_ = streamURL;
+	setParameter("StreamURL", streamURL);
+}
+
+int StartMPUTaskRequest::getStreamType()const
+{
+	return streamType_;
+}
+
+void StartMPUTaskRequest::setStreamType(int streamType)
+{
+	streamType_ = streamType;
+	setParameter("StreamType", std::to_string(streamType));
+}
+
 std::vector<std::string> StartMPUTaskRequest::getSubSpecUsers()const
 {
 	return subSpecUsers_;
@@ -278,15 +331,15 @@ void StartMPUTaskRequest::setTimeStampRef(long timeStampRef)
 	setParameter("TimeStampRef", std::to_string(timeStampRef));
 }
 
-int StartMPUTaskRequest::getMediaEncode()const
+int StartMPUTaskRequest::getMixMode()const
 {
-	return mediaEncode_;
+	return mixMode_;
 }
 
-void StartMPUTaskRequest::setMediaEncode(int mediaEncode)
+void StartMPUTaskRequest::setMixMode(int mixMode)
 {
-	mediaEncode_ = mediaEncode;
-	setParameter("MediaEncode", std::to_string(mediaEncode));
+	mixMode_ = mixMode;
+	setParameter("MixMode", std::to_string(mixMode));
 }
 
 std::string StartMPUTaskRequest::getChannelId()const

rtc/src/model/UpdateMPULayoutRequest.cc

@@ -112,6 +112,26 @@ void UpdateMPULayoutRequest::setTaskId(const std::string& taskId)
 	setParameter("TaskId", taskId);
 }
 
+std::vector<UpdateMPULayoutRequest::ClockWidgets> UpdateMPULayoutRequest::getClockWidgets()const
+{
+	return clockWidgets_;
+}
+
+void UpdateMPULayoutRequest::setClockWidgets(const std::vector<ClockWidgets>& clockWidgets)
+{
+	clockWidgets_ = clockWidgets;
+	for(int dep1 = 0; dep1!= clockWidgets.size(); dep1++) {
+		auto clockWidgetsObj = clockWidgets.at(dep1);
+		std::string clockWidgetsObjStr = "ClockWidgets." + std::to_string(dep1 + 1);
+		setParameter(clockWidgetsObjStr + ".X", std::to_string(clockWidgetsObj.x));
+		setParameter(clockWidgetsObjStr + ".Y", std::to_string(clockWidgetsObj.y));
+		setParameter(clockWidgetsObjStr + ".FontType", std::to_string(clockWidgetsObj.fontType));
+		setParameter(clockWidgetsObjStr + ".FontSize", std::to_string(clockWidgetsObj.fontSize));
+		setParameter(clockWidgetsObjStr + ".FontColor", std::to_string(clockWidgetsObj.fontColor));
+		setParameter(clockWidgetsObjStr + ".ZOrder", std::to_string(clockWidgetsObj.zOrder));
+	}
+}
+
 std::string UpdateMPULayoutRequest::getShowLog()const
 {
 	return showLog_;