1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Video Content analytics template introduced to this SDK.

Browse Source
This commit is contained in:
sdk-team
2020-11-30 05:38:29 +00:00
parent c9bc61a9df
commit 934e283efb
33 changed files with 1899 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
multimediaai/include/alibabacloud/multimediaai/MultimediaaiClient.h
View File

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

51
multimediaai/include/alibabacloud/multimediaai/model/ProcessFaceAlgorithmRequest.h Normal file
View File

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

55
multimediaai/include/alibabacloud/multimediaai/model/ProcessFaceAlgorithmResult.h Normal file
View File

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

51
multimediaai/include/alibabacloud/multimediaai/model/ProcessImageTagAlgorithmRequest.h Normal file
View File

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

55
multimediaai/include/alibabacloud/multimediaai/model/ProcessImageTagAlgorithmResult.h Normal file
View File

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

51
multimediaai/include/alibabacloud/multimediaai/model/ProcessLandmarkAlgorithmRequest.h Normal file
View File

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

55
multimediaai/include/alibabacloud/multimediaai/model/ProcessLandmarkAlgorithmResult.h Normal file
View File

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

51
multimediaai/include/alibabacloud/multimediaai/model/ProcessLogoAlgorithmRequest.h Normal file
View File

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

55
multimediaai/include/alibabacloud/multimediaai/model/ProcessLogoAlgorithmResult.h Normal file
View File

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

51
multimediaai/include/alibabacloud/multimediaai/model/ProcessNewsAlgorithmRequest.h Normal file
View File

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

55
multimediaai/include/alibabacloud/multimediaai/model/ProcessNewsAlgorithmResult.h Normal file
View File

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

51
multimediaai/include/alibabacloud/multimediaai/model/ProcessNlpAlgorithmRequest.h Normal file
View File

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

55
multimediaai/include/alibabacloud/multimediaai/model/ProcessNlpAlgorithmResult.h Normal file
View File

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

51
multimediaai/include/alibabacloud/multimediaai/model/ProcessOcrAlgorithmRequest.h Normal file
View File

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

55
multimediaai/include/alibabacloud/multimediaai/model/ProcessOcrAlgorithmResult.h Normal file
View File

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