diff --git a/CHANGELOG b/CHANGELOG index 24c9e4376..ebe1e238e 100644 --- a/CHANGELOG +++ b/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. diff --git a/multimediaai/CMakeLists.txt b/multimediaai/CMakeLists.txt index e00977a74..46c0b9983 100644 --- a/multimediaai/CMakeLists.txt +++ b/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 diff --git a/multimediaai/include/alibabacloud/multimediaai/MultimediaaiClient.h b/multimediaai/include/alibabacloud/multimediaai/MultimediaaiClient.h index d9b72e443..31524920f 100644 --- a/multimediaai/include/alibabacloud/multimediaai/MultimediaaiClient.h +++ b/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 ListTemplatesOutcome; typedef std::future ListTemplatesOutcomeCallable; typedef std::function&)> ListTemplatesAsyncHandler; + typedef Outcome ProcessFaceAlgorithmOutcome; + typedef std::future ProcessFaceAlgorithmOutcomeCallable; + typedef std::function&)> ProcessFaceAlgorithmAsyncHandler; + typedef Outcome ProcessImageTagAlgorithmOutcome; + typedef std::future ProcessImageTagAlgorithmOutcomeCallable; + typedef std::function&)> ProcessImageTagAlgorithmAsyncHandler; + typedef Outcome ProcessLandmarkAlgorithmOutcome; + typedef std::future ProcessLandmarkAlgorithmOutcomeCallable; + typedef std::function&)> ProcessLandmarkAlgorithmAsyncHandler; + typedef Outcome ProcessLogoAlgorithmOutcome; + typedef std::future ProcessLogoAlgorithmOutcomeCallable; + typedef std::function&)> ProcessLogoAlgorithmAsyncHandler; + typedef Outcome ProcessNewsAlgorithmOutcome; + typedef std::future ProcessNewsAlgorithmOutcomeCallable; + typedef std::function&)> ProcessNewsAlgorithmAsyncHandler; + typedef Outcome ProcessNlpAlgorithmOutcome; + typedef std::future ProcessNlpAlgorithmOutcomeCallable; + typedef std::function&)> ProcessNlpAlgorithmAsyncHandler; + typedef Outcome ProcessOcrAlgorithmOutcome; + typedef std::future ProcessOcrAlgorithmOutcomeCallable; + typedef std::function&)> ProcessOcrAlgorithmAsyncHandler; typedef Outcome RegisterFaceImageOutcome; typedef std::future RegisterFaceImageOutcomeCallable; typedef std::function&)> 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& 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& 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& 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& 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& 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& 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& 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& 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& context = nullptr) const; RegisterFaceImageOutcomeCallable registerFaceImageCallable(const Model::RegisterFaceImageRequest& request) const; diff --git a/multimediaai/include/alibabacloud/multimediaai/model/ProcessFaceAlgorithmRequest.h b/multimediaai/include/alibabacloud/multimediaai/model/ProcessFaceAlgorithmRequest.h new file mode 100644 index 000000000..967937277 --- /dev/null +++ b/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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/multimediaai/include/alibabacloud/multimediaai/model/ProcessFaceAlgorithmResult.h b/multimediaai/include/alibabacloud/multimediaai/model/ProcessFaceAlgorithmResult.h new file mode 100644 index 000000000..79b3e82dc --- /dev/null +++ b/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 +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/multimediaai/include/alibabacloud/multimediaai/model/ProcessImageTagAlgorithmRequest.h b/multimediaai/include/alibabacloud/multimediaai/model/ProcessImageTagAlgorithmRequest.h new file mode 100644 index 000000000..10267f501 --- /dev/null +++ b/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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/multimediaai/include/alibabacloud/multimediaai/model/ProcessImageTagAlgorithmResult.h b/multimediaai/include/alibabacloud/multimediaai/model/ProcessImageTagAlgorithmResult.h new file mode 100644 index 000000000..989bd13ac --- /dev/null +++ b/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 +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/multimediaai/include/alibabacloud/multimediaai/model/ProcessLandmarkAlgorithmRequest.h b/multimediaai/include/alibabacloud/multimediaai/model/ProcessLandmarkAlgorithmRequest.h new file mode 100644 index 000000000..337ac9191 --- /dev/null +++ b/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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/multimediaai/include/alibabacloud/multimediaai/model/ProcessLandmarkAlgorithmResult.h b/multimediaai/include/alibabacloud/multimediaai/model/ProcessLandmarkAlgorithmResult.h new file mode 100644 index 000000000..af7a0650e --- /dev/null +++ b/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 +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/multimediaai/include/alibabacloud/multimediaai/model/ProcessLogoAlgorithmRequest.h b/multimediaai/include/alibabacloud/multimediaai/model/ProcessLogoAlgorithmRequest.h new file mode 100644 index 000000000..aa5ee75b5 --- /dev/null +++ b/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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/multimediaai/include/alibabacloud/multimediaai/model/ProcessLogoAlgorithmResult.h b/multimediaai/include/alibabacloud/multimediaai/model/ProcessLogoAlgorithmResult.h new file mode 100644 index 000000000..fc5711150 --- /dev/null +++ b/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 +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/multimediaai/include/alibabacloud/multimediaai/model/ProcessNewsAlgorithmRequest.h b/multimediaai/include/alibabacloud/multimediaai/model/ProcessNewsAlgorithmRequest.h new file mode 100644 index 000000000..63c98021e --- /dev/null +++ b/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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/multimediaai/include/alibabacloud/multimediaai/model/ProcessNewsAlgorithmResult.h b/multimediaai/include/alibabacloud/multimediaai/model/ProcessNewsAlgorithmResult.h new file mode 100644 index 000000000..550c19ca2 --- /dev/null +++ b/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 +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/multimediaai/include/alibabacloud/multimediaai/model/ProcessNlpAlgorithmRequest.h b/multimediaai/include/alibabacloud/multimediaai/model/ProcessNlpAlgorithmRequest.h new file mode 100644 index 000000000..859cb6b6e --- /dev/null +++ b/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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/multimediaai/include/alibabacloud/multimediaai/model/ProcessNlpAlgorithmResult.h b/multimediaai/include/alibabacloud/multimediaai/model/ProcessNlpAlgorithmResult.h new file mode 100644 index 000000000..1c188cc18 --- /dev/null +++ b/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 +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/multimediaai/include/alibabacloud/multimediaai/model/ProcessOcrAlgorithmRequest.h b/multimediaai/include/alibabacloud/multimediaai/model/ProcessOcrAlgorithmRequest.h new file mode 100644 index 000000000..58a2b33c4 --- /dev/null +++ b/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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/multimediaai/include/alibabacloud/multimediaai/model/ProcessOcrAlgorithmResult.h b/multimediaai/include/alibabacloud/multimediaai/model/ProcessOcrAlgorithmResult.h new file mode 100644 index 000000000..9bd539d89 --- /dev/null +++ b/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 +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/multimediaai/src/MultimediaaiClient.cc b/multimediaai/src/MultimediaaiClient.cc index b06754d10..3e2bfd02a 100644 --- a/multimediaai/src/MultimediaaiClient.cc +++ b/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& 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>( + [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& 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>( + [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& 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>( + [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& 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>( + [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& 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>( + [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& 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>( + [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& 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>( + [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(); diff --git a/multimediaai/src/model/ListFaceGroupsResult.cc b/multimediaai/src/model/ListFaceGroupsResult.cc index ce32e1216..bad09bb98 100644 --- a/multimediaai/src/model/ListFaceGroupsResult.cc +++ b/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); diff --git a/multimediaai/src/model/ProcessFaceAlgorithmRequest.cc b/multimediaai/src/model/ProcessFaceAlgorithmRequest.cc new file mode 100644 index 000000000..bdb8fad78 --- /dev/null +++ b/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 + +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); +} + diff --git a/multimediaai/src/model/ProcessFaceAlgorithmResult.cc b/multimediaai/src/model/ProcessFaceAlgorithmResult.cc new file mode 100644 index 000000000..bc7afedb2 --- /dev/null +++ b/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 +#include + +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_; +} + diff --git a/multimediaai/src/model/ProcessImageTagAlgorithmRequest.cc b/multimediaai/src/model/ProcessImageTagAlgorithmRequest.cc new file mode 100644 index 000000000..a15d890fd --- /dev/null +++ b/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 + +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); +} + diff --git a/multimediaai/src/model/ProcessImageTagAlgorithmResult.cc b/multimediaai/src/model/ProcessImageTagAlgorithmResult.cc new file mode 100644 index 000000000..172c4eb2c --- /dev/null +++ b/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 +#include + +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_; +} + diff --git a/multimediaai/src/model/ProcessLandmarkAlgorithmRequest.cc b/multimediaai/src/model/ProcessLandmarkAlgorithmRequest.cc new file mode 100644 index 000000000..96c565b45 --- /dev/null +++ b/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 + +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); +} + diff --git a/multimediaai/src/model/ProcessLandmarkAlgorithmResult.cc b/multimediaai/src/model/ProcessLandmarkAlgorithmResult.cc new file mode 100644 index 000000000..695c49a40 --- /dev/null +++ b/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 +#include + +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_; +} + diff --git a/multimediaai/src/model/ProcessLogoAlgorithmRequest.cc b/multimediaai/src/model/ProcessLogoAlgorithmRequest.cc new file mode 100644 index 000000000..18b0cf464 --- /dev/null +++ b/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 + +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); +} + diff --git a/multimediaai/src/model/ProcessLogoAlgorithmResult.cc b/multimediaai/src/model/ProcessLogoAlgorithmResult.cc new file mode 100644 index 000000000..3226b4fa2 --- /dev/null +++ b/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 +#include + +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_; +} + diff --git a/multimediaai/src/model/ProcessNewsAlgorithmRequest.cc b/multimediaai/src/model/ProcessNewsAlgorithmRequest.cc new file mode 100644 index 000000000..daa87c102 --- /dev/null +++ b/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 + +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); +} + diff --git a/multimediaai/src/model/ProcessNewsAlgorithmResult.cc b/multimediaai/src/model/ProcessNewsAlgorithmResult.cc new file mode 100644 index 000000000..f84d9233b --- /dev/null +++ b/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 +#include + +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_; +} + diff --git a/multimediaai/src/model/ProcessNlpAlgorithmRequest.cc b/multimediaai/src/model/ProcessNlpAlgorithmRequest.cc new file mode 100644 index 000000000..92e49f8cc --- /dev/null +++ b/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 + +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); +} + diff --git a/multimediaai/src/model/ProcessNlpAlgorithmResult.cc b/multimediaai/src/model/ProcessNlpAlgorithmResult.cc new file mode 100644 index 000000000..3664bd385 --- /dev/null +++ b/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 +#include + +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_; +} + diff --git a/multimediaai/src/model/ProcessOcrAlgorithmRequest.cc b/multimediaai/src/model/ProcessOcrAlgorithmRequest.cc new file mode 100644 index 000000000..a4ed0b51a --- /dev/null +++ b/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 + +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); +} + diff --git a/multimediaai/src/model/ProcessOcrAlgorithmResult.cc b/multimediaai/src/model/ProcessOcrAlgorithmResult.cc new file mode 100644 index 000000000..c1f617a73 --- /dev/null +++ b/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 +#include + +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_; +} +