Video Content analytics template introduced to this SDK.

CHANGELOG

@@ -1,3 +1,6 @@
+2020-11-30 Version: patch
+- Video Content analytics template introduced to this SDK.
+
 2020-11-30 Version: patch
 - Supported all language sdk.
 - Fixed some bugs for polardbx.

multimediaai/CMakeLists.txt

@@ -53,6 +53,20 @@ set(multimediaai_public_header_model
 	include/alibabacloud/multimediaai/model/ListFacePersonsResult.h
 	include/alibabacloud/multimediaai/model/ListTemplatesRequest.h
 	include/alibabacloud/multimediaai/model/ListTemplatesResult.h
+	include/alibabacloud/multimediaai/model/ProcessFaceAlgorithmRequest.h
+	include/alibabacloud/multimediaai/model/ProcessFaceAlgorithmResult.h
+	include/alibabacloud/multimediaai/model/ProcessImageTagAlgorithmRequest.h
+	include/alibabacloud/multimediaai/model/ProcessImageTagAlgorithmResult.h
+	include/alibabacloud/multimediaai/model/ProcessLandmarkAlgorithmRequest.h
+	include/alibabacloud/multimediaai/model/ProcessLandmarkAlgorithmResult.h
+	include/alibabacloud/multimediaai/model/ProcessLogoAlgorithmRequest.h
+	include/alibabacloud/multimediaai/model/ProcessLogoAlgorithmResult.h
+	include/alibabacloud/multimediaai/model/ProcessNewsAlgorithmRequest.h
+	include/alibabacloud/multimediaai/model/ProcessNewsAlgorithmResult.h
+	include/alibabacloud/multimediaai/model/ProcessNlpAlgorithmRequest.h
+	include/alibabacloud/multimediaai/model/ProcessNlpAlgorithmResult.h
+	include/alibabacloud/multimediaai/model/ProcessOcrAlgorithmRequest.h
+	include/alibabacloud/multimediaai/model/ProcessOcrAlgorithmResult.h
 	include/alibabacloud/multimediaai/model/RegisterFaceImageRequest.h
 	include/alibabacloud/multimediaai/model/RegisterFaceImageResult.h
 	include/alibabacloud/multimediaai/model/UpdateTemplateRequest.h
@@ -92,6 +106,20 @@ set(multimediaai_src
 	src/model/ListFacePersonsResult.cc
 	src/model/ListTemplatesRequest.cc
 	src/model/ListTemplatesResult.cc
+	src/model/ProcessFaceAlgorithmRequest.cc
+	src/model/ProcessFaceAlgorithmResult.cc
+	src/model/ProcessImageTagAlgorithmRequest.cc
+	src/model/ProcessImageTagAlgorithmResult.cc
+	src/model/ProcessLandmarkAlgorithmRequest.cc
+	src/model/ProcessLandmarkAlgorithmResult.cc
+	src/model/ProcessLogoAlgorithmRequest.cc
+	src/model/ProcessLogoAlgorithmResult.cc
+	src/model/ProcessNewsAlgorithmRequest.cc
+	src/model/ProcessNewsAlgorithmResult.cc
+	src/model/ProcessNlpAlgorithmRequest.cc
+	src/model/ProcessNlpAlgorithmResult.cc
+	src/model/ProcessOcrAlgorithmRequest.cc
+	src/model/ProcessOcrAlgorithmResult.cc
 	src/model/RegisterFaceImageRequest.cc
 	src/model/RegisterFaceImageResult.cc
 	src/model/UpdateTemplateRequest.cc

multimediaai/include/alibabacloud/multimediaai/MultimediaaiClient.h

@@ -54,6 +54,20 @@
 #include "model/ListFacePersonsResult.h"
 #include "model/ListTemplatesRequest.h"
 #include "model/ListTemplatesResult.h"
+#include "model/ProcessFaceAlgorithmRequest.h"
+#include "model/ProcessFaceAlgorithmResult.h"
+#include "model/ProcessImageTagAlgorithmRequest.h"
+#include "model/ProcessImageTagAlgorithmResult.h"
+#include "model/ProcessLandmarkAlgorithmRequest.h"
+#include "model/ProcessLandmarkAlgorithmResult.h"
+#include "model/ProcessLogoAlgorithmRequest.h"
+#include "model/ProcessLogoAlgorithmResult.h"
+#include "model/ProcessNewsAlgorithmRequest.h"
+#include "model/ProcessNewsAlgorithmResult.h"
+#include "model/ProcessNlpAlgorithmRequest.h"
+#include "model/ProcessNlpAlgorithmResult.h"
+#include "model/ProcessOcrAlgorithmRequest.h"
+#include "model/ProcessOcrAlgorithmResult.h"
 #include "model/RegisterFaceImageRequest.h"
 #include "model/RegisterFaceImageResult.h"
 #include "model/UpdateTemplateRequest.h"
@@ -115,6 +129,27 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListTemplatesResult> ListTemplatesOutcome;
 			typedef std::future<ListTemplatesOutcome> ListTemplatesOutcomeCallable;
 			typedef std::function<void(const MultimediaaiClient*, const Model::ListTemplatesRequest&, const ListTemplatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTemplatesAsyncHandler;
+			typedef Outcome<Error, Model::ProcessFaceAlgorithmResult> ProcessFaceAlgorithmOutcome;
+			typedef std::future<ProcessFaceAlgorithmOutcome> ProcessFaceAlgorithmOutcomeCallable;
+			typedef std::function<void(const MultimediaaiClient*, const Model::ProcessFaceAlgorithmRequest&, const ProcessFaceAlgorithmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ProcessFaceAlgorithmAsyncHandler;
+			typedef Outcome<Error, Model::ProcessImageTagAlgorithmResult> ProcessImageTagAlgorithmOutcome;
+			typedef std::future<ProcessImageTagAlgorithmOutcome> ProcessImageTagAlgorithmOutcomeCallable;
+			typedef std::function<void(const MultimediaaiClient*, const Model::ProcessImageTagAlgorithmRequest&, const ProcessImageTagAlgorithmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ProcessImageTagAlgorithmAsyncHandler;
+			typedef Outcome<Error, Model::ProcessLandmarkAlgorithmResult> ProcessLandmarkAlgorithmOutcome;
+			typedef std::future<ProcessLandmarkAlgorithmOutcome> ProcessLandmarkAlgorithmOutcomeCallable;
+			typedef std::function<void(const MultimediaaiClient*, const Model::ProcessLandmarkAlgorithmRequest&, const ProcessLandmarkAlgorithmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ProcessLandmarkAlgorithmAsyncHandler;
+			typedef Outcome<Error, Model::ProcessLogoAlgorithmResult> ProcessLogoAlgorithmOutcome;
+			typedef std::future<ProcessLogoAlgorithmOutcome> ProcessLogoAlgorithmOutcomeCallable;
+			typedef std::function<void(const MultimediaaiClient*, const Model::ProcessLogoAlgorithmRequest&, const ProcessLogoAlgorithmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ProcessLogoAlgorithmAsyncHandler;
+			typedef Outcome<Error, Model::ProcessNewsAlgorithmResult> ProcessNewsAlgorithmOutcome;
+			typedef std::future<ProcessNewsAlgorithmOutcome> ProcessNewsAlgorithmOutcomeCallable;
+			typedef std::function<void(const MultimediaaiClient*, const Model::ProcessNewsAlgorithmRequest&, const ProcessNewsAlgorithmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ProcessNewsAlgorithmAsyncHandler;
+			typedef Outcome<Error, Model::ProcessNlpAlgorithmResult> ProcessNlpAlgorithmOutcome;
+			typedef std::future<ProcessNlpAlgorithmOutcome> ProcessNlpAlgorithmOutcomeCallable;
+			typedef std::function<void(const MultimediaaiClient*, const Model::ProcessNlpAlgorithmRequest&, const ProcessNlpAlgorithmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ProcessNlpAlgorithmAsyncHandler;
+			typedef Outcome<Error, Model::ProcessOcrAlgorithmResult> ProcessOcrAlgorithmOutcome;
+			typedef std::future<ProcessOcrAlgorithmOutcome> ProcessOcrAlgorithmOutcomeCallable;
+			typedef std::function<void(const MultimediaaiClient*, const Model::ProcessOcrAlgorithmRequest&, const ProcessOcrAlgorithmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ProcessOcrAlgorithmAsyncHandler;
 			typedef Outcome<Error, Model::RegisterFaceImageResult> RegisterFaceImageOutcome;
 			typedef std::future<RegisterFaceImageOutcome> RegisterFaceImageOutcomeCallable;
 			typedef std::function<void(const MultimediaaiClient*, const Model::RegisterFaceImageRequest&, const RegisterFaceImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RegisterFaceImageAsyncHandler;
@@ -174,6 +209,27 @@ namespace AlibabaCloud
 			ListTemplatesOutcome listTemplates(const Model::ListTemplatesRequest &request)const;
 			void listTemplatesAsync(const Model::ListTemplatesRequest& request, const ListTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListTemplatesOutcomeCallable listTemplatesCallable(const Model::ListTemplatesRequest& request) const;
+			ProcessFaceAlgorithmOutcome processFaceAlgorithm(const Model::ProcessFaceAlgorithmRequest &request)const;
+			void processFaceAlgorithmAsync(const Model::ProcessFaceAlgorithmRequest& request, const ProcessFaceAlgorithmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ProcessFaceAlgorithmOutcomeCallable processFaceAlgorithmCallable(const Model::ProcessFaceAlgorithmRequest& request) const;
+			ProcessImageTagAlgorithmOutcome processImageTagAlgorithm(const Model::ProcessImageTagAlgorithmRequest &request)const;
+			void processImageTagAlgorithmAsync(const Model::ProcessImageTagAlgorithmRequest& request, const ProcessImageTagAlgorithmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ProcessImageTagAlgorithmOutcomeCallable processImageTagAlgorithmCallable(const Model::ProcessImageTagAlgorithmRequest& request) const;
+			ProcessLandmarkAlgorithmOutcome processLandmarkAlgorithm(const Model::ProcessLandmarkAlgorithmRequest &request)const;
+			void processLandmarkAlgorithmAsync(const Model::ProcessLandmarkAlgorithmRequest& request, const ProcessLandmarkAlgorithmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ProcessLandmarkAlgorithmOutcomeCallable processLandmarkAlgorithmCallable(const Model::ProcessLandmarkAlgorithmRequest& request) const;
+			ProcessLogoAlgorithmOutcome processLogoAlgorithm(const Model::ProcessLogoAlgorithmRequest &request)const;
+			void processLogoAlgorithmAsync(const Model::ProcessLogoAlgorithmRequest& request, const ProcessLogoAlgorithmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ProcessLogoAlgorithmOutcomeCallable processLogoAlgorithmCallable(const Model::ProcessLogoAlgorithmRequest& request) const;
+			ProcessNewsAlgorithmOutcome processNewsAlgorithm(const Model::ProcessNewsAlgorithmRequest &request)const;
+			void processNewsAlgorithmAsync(const Model::ProcessNewsAlgorithmRequest& request, const ProcessNewsAlgorithmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ProcessNewsAlgorithmOutcomeCallable processNewsAlgorithmCallable(const Model::ProcessNewsAlgorithmRequest& request) const;
+			ProcessNlpAlgorithmOutcome processNlpAlgorithm(const Model::ProcessNlpAlgorithmRequest &request)const;
+			void processNlpAlgorithmAsync(const Model::ProcessNlpAlgorithmRequest& request, const ProcessNlpAlgorithmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ProcessNlpAlgorithmOutcomeCallable processNlpAlgorithmCallable(const Model::ProcessNlpAlgorithmRequest& request) const;
+			ProcessOcrAlgorithmOutcome processOcrAlgorithm(const Model::ProcessOcrAlgorithmRequest &request)const;
+			void processOcrAlgorithmAsync(const Model::ProcessOcrAlgorithmRequest& request, const ProcessOcrAlgorithmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ProcessOcrAlgorithmOutcomeCallable processOcrAlgorithmCallable(const Model::ProcessOcrAlgorithmRequest& request) const;
 			RegisterFaceImageOutcome registerFaceImage(const Model::RegisterFaceImageRequest &request)const;
 			void registerFaceImageAsync(const Model::RegisterFaceImageRequest& request, const RegisterFaceImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RegisterFaceImageOutcomeCallable registerFaceImageCallable(const Model::RegisterFaceImageRequest& request) const;

multimediaai/include/alibabacloud/multimediaai/model/ProcessFaceAlgorithmRequest.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_MULTIMEDIAAI_MODEL_PROCESSFACEALGORITHMREQUEST_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSFACEALGORITHMREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT ProcessFaceAlgorithmRequest : public RpcServiceRequest
+			{
+
+			public:
+				ProcessFaceAlgorithmRequest();
+				~ProcessFaceAlgorithmRequest();
+
+				std::string getData()const;
+				void setData(const std::string& data);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+
+            private:
+				std::string data_;
+				std::string appKey_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSFACEALGORITHMREQUEST_H_

multimediaai/include/alibabacloud/multimediaai/model/ProcessFaceAlgorithmResult.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_MULTIMEDIAAI_MODEL_PROCESSFACEALGORITHMRESULT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSFACEALGORITHMRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT ProcessFaceAlgorithmResult : public ServiceResult
+			{
+			public:
+
+
+				ProcessFaceAlgorithmResult();
+				explicit ProcessFaceAlgorithmResult(const std::string &payload);
+				~ProcessFaceAlgorithmResult();
+				std::string getMessage()const;
+				std::string getData()const;
+				int getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string data_;
+				int code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSFACEALGORITHMRESULT_H_

multimediaai/include/alibabacloud/multimediaai/model/ProcessImageTagAlgorithmRequest.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_MULTIMEDIAAI_MODEL_PROCESSIMAGETAGALGORITHMREQUEST_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSIMAGETAGALGORITHMREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT ProcessImageTagAlgorithmRequest : public RpcServiceRequest
+			{
+
+			public:
+				ProcessImageTagAlgorithmRequest();
+				~ProcessImageTagAlgorithmRequest();
+
+				std::string getData()const;
+				void setData(const std::string& data);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+
+            private:
+				std::string data_;
+				std::string appKey_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSIMAGETAGALGORITHMREQUEST_H_

multimediaai/include/alibabacloud/multimediaai/model/ProcessImageTagAlgorithmResult.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_MULTIMEDIAAI_MODEL_PROCESSIMAGETAGALGORITHMRESULT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSIMAGETAGALGORITHMRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT ProcessImageTagAlgorithmResult : public ServiceResult
+			{
+			public:
+
+
+				ProcessImageTagAlgorithmResult();
+				explicit ProcessImageTagAlgorithmResult(const std::string &payload);
+				~ProcessImageTagAlgorithmResult();
+				std::string getMessage()const;
+				std::string getData()const;
+				int getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string data_;
+				int code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSIMAGETAGALGORITHMRESULT_H_

multimediaai/include/alibabacloud/multimediaai/model/ProcessLandmarkAlgorithmRequest.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_MULTIMEDIAAI_MODEL_PROCESSLANDMARKALGORITHMREQUEST_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSLANDMARKALGORITHMREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT ProcessLandmarkAlgorithmRequest : public RpcServiceRequest
+			{
+
+			public:
+				ProcessLandmarkAlgorithmRequest();
+				~ProcessLandmarkAlgorithmRequest();
+
+				std::string getData()const;
+				void setData(const std::string& data);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+
+            private:
+				std::string data_;
+				std::string appKey_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSLANDMARKALGORITHMREQUEST_H_

multimediaai/include/alibabacloud/multimediaai/model/ProcessLandmarkAlgorithmResult.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_MULTIMEDIAAI_MODEL_PROCESSLANDMARKALGORITHMRESULT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSLANDMARKALGORITHMRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT ProcessLandmarkAlgorithmResult : public ServiceResult
+			{
+			public:
+
+
+				ProcessLandmarkAlgorithmResult();
+				explicit ProcessLandmarkAlgorithmResult(const std::string &payload);
+				~ProcessLandmarkAlgorithmResult();
+				std::string getMessage()const;
+				std::string getData()const;
+				int getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string data_;
+				int code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSLANDMARKALGORITHMRESULT_H_

multimediaai/include/alibabacloud/multimediaai/model/ProcessLogoAlgorithmRequest.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_MULTIMEDIAAI_MODEL_PROCESSLOGOALGORITHMREQUEST_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSLOGOALGORITHMREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT ProcessLogoAlgorithmRequest : public RpcServiceRequest
+			{
+
+			public:
+				ProcessLogoAlgorithmRequest();
+				~ProcessLogoAlgorithmRequest();
+
+				std::string getData()const;
+				void setData(const std::string& data);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+
+            private:
+				std::string data_;
+				std::string appKey_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSLOGOALGORITHMREQUEST_H_

multimediaai/include/alibabacloud/multimediaai/model/ProcessLogoAlgorithmResult.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_MULTIMEDIAAI_MODEL_PROCESSLOGOALGORITHMRESULT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSLOGOALGORITHMRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT ProcessLogoAlgorithmResult : public ServiceResult
+			{
+			public:
+
+
+				ProcessLogoAlgorithmResult();
+				explicit ProcessLogoAlgorithmResult(const std::string &payload);
+				~ProcessLogoAlgorithmResult();
+				std::string getMessage()const;
+				std::string getData()const;
+				int getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string data_;
+				int code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSLOGOALGORITHMRESULT_H_

multimediaai/include/alibabacloud/multimediaai/model/ProcessNewsAlgorithmRequest.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_MULTIMEDIAAI_MODEL_PROCESSNEWSALGORITHMREQUEST_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSNEWSALGORITHMREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT ProcessNewsAlgorithmRequest : public RpcServiceRequest
+			{
+
+			public:
+				ProcessNewsAlgorithmRequest();
+				~ProcessNewsAlgorithmRequest();
+
+				std::string getData()const;
+				void setData(const std::string& data);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+
+            private:
+				std::string data_;
+				std::string appKey_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSNEWSALGORITHMREQUEST_H_

multimediaai/include/alibabacloud/multimediaai/model/ProcessNewsAlgorithmResult.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_MULTIMEDIAAI_MODEL_PROCESSNEWSALGORITHMRESULT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSNEWSALGORITHMRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT ProcessNewsAlgorithmResult : public ServiceResult
+			{
+			public:
+
+
+				ProcessNewsAlgorithmResult();
+				explicit ProcessNewsAlgorithmResult(const std::string &payload);
+				~ProcessNewsAlgorithmResult();
+				std::string getMessage()const;
+				std::string getData()const;
+				int getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string data_;
+				int code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSNEWSALGORITHMRESULT_H_

multimediaai/include/alibabacloud/multimediaai/model/ProcessNlpAlgorithmRequest.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_MULTIMEDIAAI_MODEL_PROCESSNLPALGORITHMREQUEST_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSNLPALGORITHMREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT ProcessNlpAlgorithmRequest : public RpcServiceRequest
+			{
+
+			public:
+				ProcessNlpAlgorithmRequest();
+				~ProcessNlpAlgorithmRequest();
+
+				std::string getData()const;
+				void setData(const std::string& data);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+
+            private:
+				std::string data_;
+				std::string appKey_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSNLPALGORITHMREQUEST_H_

multimediaai/include/alibabacloud/multimediaai/model/ProcessNlpAlgorithmResult.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_MULTIMEDIAAI_MODEL_PROCESSNLPALGORITHMRESULT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSNLPALGORITHMRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT ProcessNlpAlgorithmResult : public ServiceResult
+			{
+			public:
+
+
+				ProcessNlpAlgorithmResult();
+				explicit ProcessNlpAlgorithmResult(const std::string &payload);
+				~ProcessNlpAlgorithmResult();
+				std::string getMessage()const;
+				std::string getData()const;
+				int getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string data_;
+				int code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSNLPALGORITHMRESULT_H_

multimediaai/include/alibabacloud/multimediaai/model/ProcessOcrAlgorithmRequest.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_MULTIMEDIAAI_MODEL_PROCESSOCRALGORITHMREQUEST_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSOCRALGORITHMREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT ProcessOcrAlgorithmRequest : public RpcServiceRequest
+			{
+
+			public:
+				ProcessOcrAlgorithmRequest();
+				~ProcessOcrAlgorithmRequest();
+
+				std::string getData()const;
+				void setData(const std::string& data);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+
+            private:
+				std::string data_;
+				std::string appKey_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSOCRALGORITHMREQUEST_H_

multimediaai/include/alibabacloud/multimediaai/model/ProcessOcrAlgorithmResult.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_MULTIMEDIAAI_MODEL_PROCESSOCRALGORITHMRESULT_H_
+#define ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSOCRALGORITHMRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/multimediaai/MultimediaaiExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Multimediaai
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MULTIMEDIAAI_EXPORT ProcessOcrAlgorithmResult : public ServiceResult
+			{
+			public:
+
+
+				ProcessOcrAlgorithmResult();
+				explicit ProcessOcrAlgorithmResult(const std::string &payload);
+				~ProcessOcrAlgorithmResult();
+				std::string getMessage()const;
+				std::string getData()const;
+				int getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string data_;
+				int code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MULTIMEDIAAI_MODEL_PROCESSOCRALGORITHMRESULT_H_

multimediaai/src/MultimediaaiClient.cc

@@ -627,6 +627,258 @@ MultimediaaiClient::ListTemplatesOutcomeCallable MultimediaaiClient::listTemplat
 	return task->get_future();
 }
 
+MultimediaaiClient::ProcessFaceAlgorithmOutcome MultimediaaiClient::processFaceAlgorithm(const ProcessFaceAlgorithmRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ProcessFaceAlgorithmOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ProcessFaceAlgorithmOutcome(ProcessFaceAlgorithmResult(outcome.result()));
+	else
+		return ProcessFaceAlgorithmOutcome(outcome.error());
+}
+
+void MultimediaaiClient::processFaceAlgorithmAsync(const ProcessFaceAlgorithmRequest& request, const ProcessFaceAlgorithmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, processFaceAlgorithm(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MultimediaaiClient::ProcessFaceAlgorithmOutcomeCallable MultimediaaiClient::processFaceAlgorithmCallable(const ProcessFaceAlgorithmRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ProcessFaceAlgorithmOutcome()>>(
+			[this, request]()
+			{
+			return this->processFaceAlgorithm(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MultimediaaiClient::ProcessImageTagAlgorithmOutcome MultimediaaiClient::processImageTagAlgorithm(const ProcessImageTagAlgorithmRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ProcessImageTagAlgorithmOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ProcessImageTagAlgorithmOutcome(ProcessImageTagAlgorithmResult(outcome.result()));
+	else
+		return ProcessImageTagAlgorithmOutcome(outcome.error());
+}
+
+void MultimediaaiClient::processImageTagAlgorithmAsync(const ProcessImageTagAlgorithmRequest& request, const ProcessImageTagAlgorithmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, processImageTagAlgorithm(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MultimediaaiClient::ProcessImageTagAlgorithmOutcomeCallable MultimediaaiClient::processImageTagAlgorithmCallable(const ProcessImageTagAlgorithmRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ProcessImageTagAlgorithmOutcome()>>(
+			[this, request]()
+			{
+			return this->processImageTagAlgorithm(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MultimediaaiClient::ProcessLandmarkAlgorithmOutcome MultimediaaiClient::processLandmarkAlgorithm(const ProcessLandmarkAlgorithmRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ProcessLandmarkAlgorithmOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ProcessLandmarkAlgorithmOutcome(ProcessLandmarkAlgorithmResult(outcome.result()));
+	else
+		return ProcessLandmarkAlgorithmOutcome(outcome.error());
+}
+
+void MultimediaaiClient::processLandmarkAlgorithmAsync(const ProcessLandmarkAlgorithmRequest& request, const ProcessLandmarkAlgorithmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, processLandmarkAlgorithm(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MultimediaaiClient::ProcessLandmarkAlgorithmOutcomeCallable MultimediaaiClient::processLandmarkAlgorithmCallable(const ProcessLandmarkAlgorithmRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ProcessLandmarkAlgorithmOutcome()>>(
+			[this, request]()
+			{
+			return this->processLandmarkAlgorithm(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MultimediaaiClient::ProcessLogoAlgorithmOutcome MultimediaaiClient::processLogoAlgorithm(const ProcessLogoAlgorithmRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ProcessLogoAlgorithmOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ProcessLogoAlgorithmOutcome(ProcessLogoAlgorithmResult(outcome.result()));
+	else
+		return ProcessLogoAlgorithmOutcome(outcome.error());
+}
+
+void MultimediaaiClient::processLogoAlgorithmAsync(const ProcessLogoAlgorithmRequest& request, const ProcessLogoAlgorithmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, processLogoAlgorithm(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MultimediaaiClient::ProcessLogoAlgorithmOutcomeCallable MultimediaaiClient::processLogoAlgorithmCallable(const ProcessLogoAlgorithmRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ProcessLogoAlgorithmOutcome()>>(
+			[this, request]()
+			{
+			return this->processLogoAlgorithm(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MultimediaaiClient::ProcessNewsAlgorithmOutcome MultimediaaiClient::processNewsAlgorithm(const ProcessNewsAlgorithmRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ProcessNewsAlgorithmOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ProcessNewsAlgorithmOutcome(ProcessNewsAlgorithmResult(outcome.result()));
+	else
+		return ProcessNewsAlgorithmOutcome(outcome.error());
+}
+
+void MultimediaaiClient::processNewsAlgorithmAsync(const ProcessNewsAlgorithmRequest& request, const ProcessNewsAlgorithmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, processNewsAlgorithm(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MultimediaaiClient::ProcessNewsAlgorithmOutcomeCallable MultimediaaiClient::processNewsAlgorithmCallable(const ProcessNewsAlgorithmRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ProcessNewsAlgorithmOutcome()>>(
+			[this, request]()
+			{
+			return this->processNewsAlgorithm(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MultimediaaiClient::ProcessNlpAlgorithmOutcome MultimediaaiClient::processNlpAlgorithm(const ProcessNlpAlgorithmRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ProcessNlpAlgorithmOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ProcessNlpAlgorithmOutcome(ProcessNlpAlgorithmResult(outcome.result()));
+	else
+		return ProcessNlpAlgorithmOutcome(outcome.error());
+}
+
+void MultimediaaiClient::processNlpAlgorithmAsync(const ProcessNlpAlgorithmRequest& request, const ProcessNlpAlgorithmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, processNlpAlgorithm(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MultimediaaiClient::ProcessNlpAlgorithmOutcomeCallable MultimediaaiClient::processNlpAlgorithmCallable(const ProcessNlpAlgorithmRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ProcessNlpAlgorithmOutcome()>>(
+			[this, request]()
+			{
+			return this->processNlpAlgorithm(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MultimediaaiClient::ProcessOcrAlgorithmOutcome MultimediaaiClient::processOcrAlgorithm(const ProcessOcrAlgorithmRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ProcessOcrAlgorithmOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ProcessOcrAlgorithmOutcome(ProcessOcrAlgorithmResult(outcome.result()));
+	else
+		return ProcessOcrAlgorithmOutcome(outcome.error());
+}
+
+void MultimediaaiClient::processOcrAlgorithmAsync(const ProcessOcrAlgorithmRequest& request, const ProcessOcrAlgorithmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, processOcrAlgorithm(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MultimediaaiClient::ProcessOcrAlgorithmOutcomeCallable MultimediaaiClient::processOcrAlgorithmCallable(const ProcessOcrAlgorithmRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ProcessOcrAlgorithmOutcome()>>(
+			[this, request]()
+			{
+			return this->processOcrAlgorithm(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 MultimediaaiClient::RegisterFaceImageOutcome MultimediaaiClient::registerFaceImage(const RegisterFaceImageRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

multimediaai/src/model/ListFaceGroupsResult.cc

@@ -53,14 +53,14 @@ void ListFaceGroupsResult::parse(const std::string &payload)
 			faceGroupsObject.personCount = std::stol(valueFaceGroupsFaceGroup["PersonCount"].asString());
 		if(!valueFaceGroupsFaceGroup["ImageCount"].isNull())
 			faceGroupsObject.imageCount = std::stol(valueFaceGroupsFaceGroup["ImageCount"].asString());
-		auto allTemplatesNode = allFaceGroupsNode["Templates"]["TemplatesItem"];
-		for (auto allFaceGroupsNodeTemplatesTemplatesItem : allTemplatesNode)
+		auto allTemplatesNode = valueFaceGroupsFaceGroup["Templates"]["TemplatesItem"];
+		for (auto valueFaceGroupsFaceGroupTemplatesTemplatesItem : allTemplatesNode)
 		{
 			FaceGroup::TemplatesItem templatesObject;
-			if(!allFaceGroupsNodeTemplatesTemplatesItem["Id"].isNull())
-				templatesObject.id = allFaceGroupsNodeTemplatesTemplatesItem["Id"].asString();
-			if(!allFaceGroupsNodeTemplatesTemplatesItem["Name"].isNull())
-				templatesObject.name = allFaceGroupsNodeTemplatesTemplatesItem["Name"].asString();
+			if(!valueFaceGroupsFaceGroupTemplatesTemplatesItem["Id"].isNull())
+				templatesObject.id = valueFaceGroupsFaceGroupTemplatesTemplatesItem["Id"].asString();
+			if(!valueFaceGroupsFaceGroupTemplatesTemplatesItem["Name"].isNull())
+				templatesObject.name = valueFaceGroupsFaceGroupTemplatesTemplatesItem["Name"].asString();
 			faceGroupsObject.templates.push_back(templatesObject);
 		}
 		faceGroups_.push_back(faceGroupsObject);

multimediaai/src/model/ProcessFaceAlgorithmRequest.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/multimediaai/model/ProcessFaceAlgorithmRequest.h>
+
+using AlibabaCloud::Multimediaai::Model::ProcessFaceAlgorithmRequest;
+
+ProcessFaceAlgorithmRequest::ProcessFaceAlgorithmRequest() :
+	RpcServiceRequest("multimediaai", "2019-08-10", "ProcessFaceAlgorithm")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ProcessFaceAlgorithmRequest::~ProcessFaceAlgorithmRequest()
+{}
+
+std::string ProcessFaceAlgorithmRequest::getData()const
+{
+	return data_;
+}
+
+void ProcessFaceAlgorithmRequest::setData(const std::string& data)
+{
+	data_ = data;
+	setBodyParameter("Data", data);
+}
+
+std::string ProcessFaceAlgorithmRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void ProcessFaceAlgorithmRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+

multimediaai/src/model/ProcessFaceAlgorithmResult.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/multimediaai/model/ProcessFaceAlgorithmResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+ProcessFaceAlgorithmResult::ProcessFaceAlgorithmResult() :
+	ServiceResult()
+{}
+
+ProcessFaceAlgorithmResult::ProcessFaceAlgorithmResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ProcessFaceAlgorithmResult::~ProcessFaceAlgorithmResult()
+{}
+
+void ProcessFaceAlgorithmResult::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();
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string ProcessFaceAlgorithmResult::getMessage()const
+{
+	return message_;
+}
+
+std::string ProcessFaceAlgorithmResult::getData()const
+{
+	return data_;
+}
+
+int ProcessFaceAlgorithmResult::getCode()const
+{
+	return code_;
+}
+

multimediaai/src/model/ProcessImageTagAlgorithmRequest.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/multimediaai/model/ProcessImageTagAlgorithmRequest.h>
+
+using AlibabaCloud::Multimediaai::Model::ProcessImageTagAlgorithmRequest;
+
+ProcessImageTagAlgorithmRequest::ProcessImageTagAlgorithmRequest() :
+	RpcServiceRequest("multimediaai", "2019-08-10", "ProcessImageTagAlgorithm")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ProcessImageTagAlgorithmRequest::~ProcessImageTagAlgorithmRequest()
+{}
+
+std::string ProcessImageTagAlgorithmRequest::getData()const
+{
+	return data_;
+}
+
+void ProcessImageTagAlgorithmRequest::setData(const std::string& data)
+{
+	data_ = data;
+	setBodyParameter("Data", data);
+}
+
+std::string ProcessImageTagAlgorithmRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void ProcessImageTagAlgorithmRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+

multimediaai/src/model/ProcessImageTagAlgorithmResult.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/multimediaai/model/ProcessImageTagAlgorithmResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+ProcessImageTagAlgorithmResult::ProcessImageTagAlgorithmResult() :
+	ServiceResult()
+{}
+
+ProcessImageTagAlgorithmResult::ProcessImageTagAlgorithmResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ProcessImageTagAlgorithmResult::~ProcessImageTagAlgorithmResult()
+{}
+
+void ProcessImageTagAlgorithmResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString();
+
+}
+
+std::string ProcessImageTagAlgorithmResult::getMessage()const
+{
+	return message_;
+}
+
+std::string ProcessImageTagAlgorithmResult::getData()const
+{
+	return data_;
+}
+
+int ProcessImageTagAlgorithmResult::getCode()const
+{
+	return code_;
+}
+

multimediaai/src/model/ProcessLandmarkAlgorithmRequest.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/multimediaai/model/ProcessLandmarkAlgorithmRequest.h>
+
+using AlibabaCloud::Multimediaai::Model::ProcessLandmarkAlgorithmRequest;
+
+ProcessLandmarkAlgorithmRequest::ProcessLandmarkAlgorithmRequest() :
+	RpcServiceRequest("multimediaai", "2019-08-10", "ProcessLandmarkAlgorithm")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ProcessLandmarkAlgorithmRequest::~ProcessLandmarkAlgorithmRequest()
+{}
+
+std::string ProcessLandmarkAlgorithmRequest::getData()const
+{
+	return data_;
+}
+
+void ProcessLandmarkAlgorithmRequest::setData(const std::string& data)
+{
+	data_ = data;
+	setBodyParameter("Data", data);
+}
+
+std::string ProcessLandmarkAlgorithmRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void ProcessLandmarkAlgorithmRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+

multimediaai/src/model/ProcessLandmarkAlgorithmResult.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/multimediaai/model/ProcessLandmarkAlgorithmResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+ProcessLandmarkAlgorithmResult::ProcessLandmarkAlgorithmResult() :
+	ServiceResult()
+{}
+
+ProcessLandmarkAlgorithmResult::ProcessLandmarkAlgorithmResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ProcessLandmarkAlgorithmResult::~ProcessLandmarkAlgorithmResult()
+{}
+
+void ProcessLandmarkAlgorithmResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString();
+
+}
+
+std::string ProcessLandmarkAlgorithmResult::getMessage()const
+{
+	return message_;
+}
+
+std::string ProcessLandmarkAlgorithmResult::getData()const
+{
+	return data_;
+}
+
+int ProcessLandmarkAlgorithmResult::getCode()const
+{
+	return code_;
+}
+

multimediaai/src/model/ProcessLogoAlgorithmRequest.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/multimediaai/model/ProcessLogoAlgorithmRequest.h>
+
+using AlibabaCloud::Multimediaai::Model::ProcessLogoAlgorithmRequest;
+
+ProcessLogoAlgorithmRequest::ProcessLogoAlgorithmRequest() :
+	RpcServiceRequest("multimediaai", "2019-08-10", "ProcessLogoAlgorithm")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ProcessLogoAlgorithmRequest::~ProcessLogoAlgorithmRequest()
+{}
+
+std::string ProcessLogoAlgorithmRequest::getData()const
+{
+	return data_;
+}
+
+void ProcessLogoAlgorithmRequest::setData(const std::string& data)
+{
+	data_ = data;
+	setBodyParameter("Data", data);
+}
+
+std::string ProcessLogoAlgorithmRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void ProcessLogoAlgorithmRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+

multimediaai/src/model/ProcessLogoAlgorithmResult.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/multimediaai/model/ProcessLogoAlgorithmResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+ProcessLogoAlgorithmResult::ProcessLogoAlgorithmResult() :
+	ServiceResult()
+{}
+
+ProcessLogoAlgorithmResult::ProcessLogoAlgorithmResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ProcessLogoAlgorithmResult::~ProcessLogoAlgorithmResult()
+{}
+
+void ProcessLogoAlgorithmResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString();
+
+}
+
+std::string ProcessLogoAlgorithmResult::getMessage()const
+{
+	return message_;
+}
+
+std::string ProcessLogoAlgorithmResult::getData()const
+{
+	return data_;
+}
+
+int ProcessLogoAlgorithmResult::getCode()const
+{
+	return code_;
+}
+

multimediaai/src/model/ProcessNewsAlgorithmRequest.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/multimediaai/model/ProcessNewsAlgorithmRequest.h>
+
+using AlibabaCloud::Multimediaai::Model::ProcessNewsAlgorithmRequest;
+
+ProcessNewsAlgorithmRequest::ProcessNewsAlgorithmRequest() :
+	RpcServiceRequest("multimediaai", "2019-08-10", "ProcessNewsAlgorithm")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ProcessNewsAlgorithmRequest::~ProcessNewsAlgorithmRequest()
+{}
+
+std::string ProcessNewsAlgorithmRequest::getData()const
+{
+	return data_;
+}
+
+void ProcessNewsAlgorithmRequest::setData(const std::string& data)
+{
+	data_ = data;
+	setBodyParameter("Data", data);
+}
+
+std::string ProcessNewsAlgorithmRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void ProcessNewsAlgorithmRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+

multimediaai/src/model/ProcessNewsAlgorithmResult.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/multimediaai/model/ProcessNewsAlgorithmResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+ProcessNewsAlgorithmResult::ProcessNewsAlgorithmResult() :
+	ServiceResult()
+{}
+
+ProcessNewsAlgorithmResult::ProcessNewsAlgorithmResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ProcessNewsAlgorithmResult::~ProcessNewsAlgorithmResult()
+{}
+
+void ProcessNewsAlgorithmResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString();
+
+}
+
+std::string ProcessNewsAlgorithmResult::getMessage()const
+{
+	return message_;
+}
+
+std::string ProcessNewsAlgorithmResult::getData()const
+{
+	return data_;
+}
+
+int ProcessNewsAlgorithmResult::getCode()const
+{
+	return code_;
+}
+

multimediaai/src/model/ProcessNlpAlgorithmRequest.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/multimediaai/model/ProcessNlpAlgorithmRequest.h>
+
+using AlibabaCloud::Multimediaai::Model::ProcessNlpAlgorithmRequest;
+
+ProcessNlpAlgorithmRequest::ProcessNlpAlgorithmRequest() :
+	RpcServiceRequest("multimediaai", "2019-08-10", "ProcessNlpAlgorithm")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ProcessNlpAlgorithmRequest::~ProcessNlpAlgorithmRequest()
+{}
+
+std::string ProcessNlpAlgorithmRequest::getData()const
+{
+	return data_;
+}
+
+void ProcessNlpAlgorithmRequest::setData(const std::string& data)
+{
+	data_ = data;
+	setBodyParameter("Data", data);
+}
+
+std::string ProcessNlpAlgorithmRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void ProcessNlpAlgorithmRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+

multimediaai/src/model/ProcessNlpAlgorithmResult.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/multimediaai/model/ProcessNlpAlgorithmResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+ProcessNlpAlgorithmResult::ProcessNlpAlgorithmResult() :
+	ServiceResult()
+{}
+
+ProcessNlpAlgorithmResult::ProcessNlpAlgorithmResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ProcessNlpAlgorithmResult::~ProcessNlpAlgorithmResult()
+{}
+
+void ProcessNlpAlgorithmResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString();
+
+}
+
+std::string ProcessNlpAlgorithmResult::getMessage()const
+{
+	return message_;
+}
+
+std::string ProcessNlpAlgorithmResult::getData()const
+{
+	return data_;
+}
+
+int ProcessNlpAlgorithmResult::getCode()const
+{
+	return code_;
+}
+

multimediaai/src/model/ProcessOcrAlgorithmRequest.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/multimediaai/model/ProcessOcrAlgorithmRequest.h>
+
+using AlibabaCloud::Multimediaai::Model::ProcessOcrAlgorithmRequest;
+
+ProcessOcrAlgorithmRequest::ProcessOcrAlgorithmRequest() :
+	RpcServiceRequest("multimediaai", "2019-08-10", "ProcessOcrAlgorithm")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ProcessOcrAlgorithmRequest::~ProcessOcrAlgorithmRequest()
+{}
+
+std::string ProcessOcrAlgorithmRequest::getData()const
+{
+	return data_;
+}
+
+void ProcessOcrAlgorithmRequest::setData(const std::string& data)
+{
+	data_ = data;
+	setBodyParameter("Data", data);
+}
+
+std::string ProcessOcrAlgorithmRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void ProcessOcrAlgorithmRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+

multimediaai/src/model/ProcessOcrAlgorithmResult.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/multimediaai/model/ProcessOcrAlgorithmResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Multimediaai;
+using namespace AlibabaCloud::Multimediaai::Model;
+
+ProcessOcrAlgorithmResult::ProcessOcrAlgorithmResult() :
+	ServiceResult()
+{}
+
+ProcessOcrAlgorithmResult::ProcessOcrAlgorithmResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ProcessOcrAlgorithmResult::~ProcessOcrAlgorithmResult()
+{}
+
+void ProcessOcrAlgorithmResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString();
+
+}
+
+std::string ProcessOcrAlgorithmResult::getMessage()const
+{
+	return message_;
+}
+
+std::string ProcessOcrAlgorithmResult::getData()const
+{
+	return data_;
+}
+
+int ProcessOcrAlgorithmResult::getCode()const
+{
+	return code_;
+}
+