Video Content analytics template introduced to this SDK.

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_;
+}
+