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

Add video summarization related API.

Browse Source
This commit is contained in:
sdk-team
2020-07-07 23:35:51 +08:00
parent fc24f8e624
commit 161e51556b
43 changed files with 2824 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -1,3 +1,6 @@
2020-07-07 Version: 1.36.505
- Add video summarization related API.
2020-07-07 Version: 1.36.504
- Generated 2020-05-18 for `dataworks-public`.

2
VERSION
View File

@@ -1 +1 @@
1.36.504
1.36.505

40
vcs/CMakeLists.txt
View File

@@ -21,16 +21,26 @@ set(vcs_public_header
include/alibabacloud/vcs/VcsExport.h )
set(vcs_public_header_model
include/alibabacloud/vcs/model/AddDataSourceRequest.h
include/alibabacloud/vcs/model/AddDataSourceResult.h
include/alibabacloud/vcs/model/AddDeviceRequest.h
include/alibabacloud/vcs/model/AddDeviceResult.h
include/alibabacloud/vcs/model/AddMonitorRequest.h
include/alibabacloud/vcs/model/AddMonitorResult.h
include/alibabacloud/vcs/model/CreateCorpRequest.h
include/alibabacloud/vcs/model/CreateCorpResult.h
include/alibabacloud/vcs/model/CreateVideoComposeTaskRequest.h
include/alibabacloud/vcs/model/CreateVideoComposeTaskResult.h
include/alibabacloud/vcs/model/CreateVideoSummaryTaskRequest.h
include/alibabacloud/vcs/model/CreateVideoSummaryTaskResult.h
include/alibabacloud/vcs/model/DeleteDataSourceRequest.h
include/alibabacloud/vcs/model/DeleteDataSourceResult.h
include/alibabacloud/vcs/model/DeleteDeviceRequest.h
include/alibabacloud/vcs/model/DeleteDeviceResult.h
include/alibabacloud/vcs/model/DeleteRecordsRequest.h
include/alibabacloud/vcs/model/DeleteRecordsResult.h
include/alibabacloud/vcs/model/DeleteVideoSummaryTaskRequest.h
include/alibabacloud/vcs/model/DeleteVideoSummaryTaskResult.h
include/alibabacloud/vcs/model/GetBodyOptionsRequest.h
include/alibabacloud/vcs/model/GetBodyOptionsResult.h
include/alibabacloud/vcs/model/GetDeviceLiveUrlRequest.h
@@ -45,10 +55,16 @@ set(vcs_public_header_model
include/alibabacloud/vcs/model/GetMonitorResultResult.h
include/alibabacloud/vcs/model/GetPersonDetailRequest.h
include/alibabacloud/vcs/model/GetPersonDetailResult.h
include/alibabacloud/vcs/model/GetVideoComposeResultRequest.h
include/alibabacloud/vcs/model/GetVideoComposeResultResult.h
include/alibabacloud/vcs/model/GetVideoSummaryTaskResultRequest.h
include/alibabacloud/vcs/model/GetVideoSummaryTaskResultResult.h
include/alibabacloud/vcs/model/ListCorpsRequest.h
include/alibabacloud/vcs/model/ListCorpsResult.h
include/alibabacloud/vcs/model/ListDevicesRequest.h
include/alibabacloud/vcs/model/ListDevicesResult.h
include/alibabacloud/vcs/model/ListEventAlgorithmResultsRequest.h
include/alibabacloud/vcs/model/ListEventAlgorithmResultsResult.h
include/alibabacloud/vcs/model/ListFaceAlgorithmResultsRequest.h
include/alibabacloud/vcs/model/ListFaceAlgorithmResultsResult.h
include/alibabacloud/vcs/model/ListMetricsRequest.h
@@ -72,20 +88,32 @@ set(vcs_public_header_model
include/alibabacloud/vcs/model/UpdateDeviceRequest.h
include/alibabacloud/vcs/model/UpdateDeviceResult.h
include/alibabacloud/vcs/model/UpdateMonitorRequest.h
include/alibabacloud/vcs/model/UpdateMonitorResult.h )
include/alibabacloud/vcs/model/UpdateMonitorResult.h
include/alibabacloud/vcs/model/UploadFileRequest.h
include/alibabacloud/vcs/model/UploadFileResult.h )
set(vcs_src
src/VcsClient.cc
src/model/AddDataSourceRequest.cc
src/model/AddDataSourceResult.cc
src/model/AddDeviceRequest.cc
src/model/AddDeviceResult.cc
src/model/AddMonitorRequest.cc
src/model/AddMonitorResult.cc
src/model/CreateCorpRequest.cc
src/model/CreateCorpResult.cc
src/model/CreateVideoComposeTaskRequest.cc
src/model/CreateVideoComposeTaskResult.cc
src/model/CreateVideoSummaryTaskRequest.cc
src/model/CreateVideoSummaryTaskResult.cc
src/model/DeleteDataSourceRequest.cc
src/model/DeleteDataSourceResult.cc
src/model/DeleteDeviceRequest.cc
src/model/DeleteDeviceResult.cc
src/model/DeleteRecordsRequest.cc
src/model/DeleteRecordsResult.cc
src/model/DeleteVideoSummaryTaskRequest.cc
src/model/DeleteVideoSummaryTaskResult.cc
src/model/GetBodyOptionsRequest.cc
src/model/GetBodyOptionsResult.cc
src/model/GetDeviceLiveUrlRequest.cc
@@ -100,10 +128,16 @@ set(vcs_src
src/model/GetMonitorResultResult.cc
src/model/GetPersonDetailRequest.cc
src/model/GetPersonDetailResult.cc
src/model/GetVideoComposeResultRequest.cc
src/model/GetVideoComposeResultResult.cc
src/model/GetVideoSummaryTaskResultRequest.cc
src/model/GetVideoSummaryTaskResultResult.cc
src/model/ListCorpsRequest.cc
src/model/ListCorpsResult.cc
src/model/ListDevicesRequest.cc
src/model/ListDevicesResult.cc
src/model/ListEventAlgorithmResultsRequest.cc
src/model/ListEventAlgorithmResultsResult.cc
src/model/ListFaceAlgorithmResultsRequest.cc
src/model/ListFaceAlgorithmResultsResult.cc
src/model/ListMetricsRequest.cc
@@ -127,7 +161,9 @@ set(vcs_src
src/model/UpdateDeviceRequest.cc
src/model/UpdateDeviceResult.cc
src/model/UpdateMonitorRequest.cc
src/model/UpdateMonitorResult.cc )
src/model/UpdateMonitorResult.cc
src/model/UploadFileRequest.cc
src/model/UploadFileResult.cc )
add_library(vcs ${LIB_TYPE}
${vcs_public_header}

72
vcs/include/alibabacloud/vcs/VcsClient.h
View File

@@ -22,16 +22,26 @@
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "VcsExport.h"
#include "model/AddDataSourceRequest.h"
#include "model/AddDataSourceResult.h"
#include "model/AddDeviceRequest.h"
#include "model/AddDeviceResult.h"
#include "model/AddMonitorRequest.h"
#include "model/AddMonitorResult.h"
#include "model/CreateCorpRequest.h"
#include "model/CreateCorpResult.h"
#include "model/CreateVideoComposeTaskRequest.h"
#include "model/CreateVideoComposeTaskResult.h"
#include "model/CreateVideoSummaryTaskRequest.h"
#include "model/CreateVideoSummaryTaskResult.h"
#include "model/DeleteDataSourceRequest.h"
#include "model/DeleteDataSourceResult.h"
#include "model/DeleteDeviceRequest.h"
#include "model/DeleteDeviceResult.h"
#include "model/DeleteRecordsRequest.h"
#include "model/DeleteRecordsResult.h"
#include "model/DeleteVideoSummaryTaskRequest.h"
#include "model/DeleteVideoSummaryTaskResult.h"
#include "model/GetBodyOptionsRequest.h"
#include "model/GetBodyOptionsResult.h"
#include "model/GetDeviceLiveUrlRequest.h"
@@ -46,10 +56,16 @@
#include "model/GetMonitorResultResult.h"
#include "model/GetPersonDetailRequest.h"
#include "model/GetPersonDetailResult.h"
#include "model/GetVideoComposeResultRequest.h"
#include "model/GetVideoComposeResultResult.h"
#include "model/GetVideoSummaryTaskResultRequest.h"
#include "model/GetVideoSummaryTaskResultResult.h"
#include "model/ListCorpsRequest.h"
#include "model/ListCorpsResult.h"
#include "model/ListDevicesRequest.h"
#include "model/ListDevicesResult.h"
#include "model/ListEventAlgorithmResultsRequest.h"
#include "model/ListEventAlgorithmResultsResult.h"
#include "model/ListFaceAlgorithmResultsRequest.h"
#include "model/ListFaceAlgorithmResultsResult.h"
#include "model/ListMetricsRequest.h"
@@ -74,6 +90,8 @@
#include "model/UpdateDeviceResult.h"
#include "model/UpdateMonitorRequest.h"
#include "model/UpdateMonitorResult.h"
#include "model/UploadFileRequest.h"
#include "model/UploadFileResult.h"
namespace AlibabaCloud
@@ -83,6 +101,9 @@ namespace AlibabaCloud
class ALIBABACLOUD_VCS_EXPORT VcsClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::AddDataSourceResult> AddDataSourceOutcome;
typedef std::future<AddDataSourceOutcome> AddDataSourceOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::AddDataSourceRequest&, const AddDataSourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddDataSourceAsyncHandler;
typedef Outcome<Error, Model::AddDeviceResult> AddDeviceOutcome;
typedef std::future<AddDeviceOutcome> AddDeviceOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::AddDeviceRequest&, const AddDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddDeviceAsyncHandler;
@@ -92,12 +113,24 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CreateCorpResult> CreateCorpOutcome;
typedef std::future<CreateCorpOutcome> CreateCorpOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::CreateCorpRequest&, const CreateCorpOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCorpAsyncHandler;
typedef Outcome<Error, Model::CreateVideoComposeTaskResult> CreateVideoComposeTaskOutcome;
typedef std::future<CreateVideoComposeTaskOutcome> CreateVideoComposeTaskOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::CreateVideoComposeTaskRequest&, const CreateVideoComposeTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVideoComposeTaskAsyncHandler;
typedef Outcome<Error, Model::CreateVideoSummaryTaskResult> CreateVideoSummaryTaskOutcome;
typedef std::future<CreateVideoSummaryTaskOutcome> CreateVideoSummaryTaskOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::CreateVideoSummaryTaskRequest&, const CreateVideoSummaryTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVideoSummaryTaskAsyncHandler;
typedef Outcome<Error, Model::DeleteDataSourceResult> DeleteDataSourceOutcome;
typedef std::future<DeleteDataSourceOutcome> DeleteDataSourceOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::DeleteDataSourceRequest&, const DeleteDataSourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDataSourceAsyncHandler;
typedef Outcome<Error, Model::DeleteDeviceResult> DeleteDeviceOutcome;
typedef std::future<DeleteDeviceOutcome> DeleteDeviceOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::DeleteDeviceRequest&, const DeleteDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDeviceAsyncHandler;
typedef Outcome<Error, Model::DeleteRecordsResult> DeleteRecordsOutcome;
typedef std::future<DeleteRecordsOutcome> DeleteRecordsOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::DeleteRecordsRequest&, const DeleteRecordsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteRecordsAsyncHandler;
typedef Outcome<Error, Model::DeleteVideoSummaryTaskResult> DeleteVideoSummaryTaskOutcome;
typedef std::future<DeleteVideoSummaryTaskOutcome> DeleteVideoSummaryTaskOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::DeleteVideoSummaryTaskRequest&, const DeleteVideoSummaryTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVideoSummaryTaskAsyncHandler;
typedef Outcome<Error, Model::GetBodyOptionsResult> GetBodyOptionsOutcome;
typedef std::future<GetBodyOptionsOutcome> GetBodyOptionsOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::GetBodyOptionsRequest&, const GetBodyOptionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetBodyOptionsAsyncHandler;
@@ -119,12 +152,21 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::GetPersonDetailResult> GetPersonDetailOutcome;
typedef std::future<GetPersonDetailOutcome> GetPersonDetailOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::GetPersonDetailRequest&, const GetPersonDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPersonDetailAsyncHandler;
typedef Outcome<Error, Model::GetVideoComposeResultResult> GetVideoComposeResultOutcome;
typedef std::future<GetVideoComposeResultOutcome> GetVideoComposeResultOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::GetVideoComposeResultRequest&, const GetVideoComposeResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVideoComposeResultAsyncHandler;
typedef Outcome<Error, Model::GetVideoSummaryTaskResultResult> GetVideoSummaryTaskResultOutcome;
typedef std::future<GetVideoSummaryTaskResultOutcome> GetVideoSummaryTaskResultOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::GetVideoSummaryTaskResultRequest&, const GetVideoSummaryTaskResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVideoSummaryTaskResultAsyncHandler;
typedef Outcome<Error, Model::ListCorpsResult> ListCorpsOutcome;
typedef std::future<ListCorpsOutcome> ListCorpsOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::ListCorpsRequest&, const ListCorpsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListCorpsAsyncHandler;
typedef Outcome<Error, Model::ListDevicesResult> ListDevicesOutcome;
typedef std::future<ListDevicesOutcome> ListDevicesOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::ListDevicesRequest&, const ListDevicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDevicesAsyncHandler;
typedef Outcome<Error, Model::ListEventAlgorithmResultsResult> ListEventAlgorithmResultsOutcome;
typedef std::future<ListEventAlgorithmResultsOutcome> ListEventAlgorithmResultsOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::ListEventAlgorithmResultsRequest&, const ListEventAlgorithmResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListEventAlgorithmResultsAsyncHandler;
typedef Outcome<Error, Model::ListFaceAlgorithmResultsResult> ListFaceAlgorithmResultsOutcome;
typedef std::future<ListFaceAlgorithmResultsOutcome> ListFaceAlgorithmResultsOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::ListFaceAlgorithmResultsRequest&, const ListFaceAlgorithmResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFaceAlgorithmResultsAsyncHandler;
@@ -161,11 +203,17 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::UpdateMonitorResult> UpdateMonitorOutcome;
typedef std::future<UpdateMonitorOutcome> UpdateMonitorOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::UpdateMonitorRequest&, const UpdateMonitorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateMonitorAsyncHandler;
typedef Outcome<Error, Model::UploadFileResult> UploadFileOutcome;
typedef std::future<UploadFileOutcome> UploadFileOutcomeCallable;
typedef std::function<void(const VcsClient*, const Model::UploadFileRequest&, const UploadFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UploadFileAsyncHandler;
VcsClient(const Credentials &credentials, const ClientConfiguration &configuration);
VcsClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
VcsClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~VcsClient();
AddDataSourceOutcome addDataSource(const Model::AddDataSourceRequest &request)const;
void addDataSourceAsync(const Model::AddDataSourceRequest& request, const AddDataSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddDataSourceOutcomeCallable addDataSourceCallable(const Model::AddDataSourceRequest& request) const;
AddDeviceOutcome addDevice(const Model::AddDeviceRequest &request)const;
void addDeviceAsync(const Model::AddDeviceRequest& request, const AddDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddDeviceOutcomeCallable addDeviceCallable(const Model::AddDeviceRequest& request) const;
@@ -175,12 +223,24 @@ namespace AlibabaCloud
CreateCorpOutcome createCorp(const Model::CreateCorpRequest &request)const;
void createCorpAsync(const Model::CreateCorpRequest& request, const CreateCorpAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateCorpOutcomeCallable createCorpCallable(const Model::CreateCorpRequest& request) const;
CreateVideoComposeTaskOutcome createVideoComposeTask(const Model::CreateVideoComposeTaskRequest &request)const;
void createVideoComposeTaskAsync(const Model::CreateVideoComposeTaskRequest& request, const CreateVideoComposeTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateVideoComposeTaskOutcomeCallable createVideoComposeTaskCallable(const Model::CreateVideoComposeTaskRequest& request) const;
CreateVideoSummaryTaskOutcome createVideoSummaryTask(const Model::CreateVideoSummaryTaskRequest &request)const;
void createVideoSummaryTaskAsync(const Model::CreateVideoSummaryTaskRequest& request, const CreateVideoSummaryTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateVideoSummaryTaskOutcomeCallable createVideoSummaryTaskCallable(const Model::CreateVideoSummaryTaskRequest& request) const;
DeleteDataSourceOutcome deleteDataSource(const Model::DeleteDataSourceRequest &request)const;
void deleteDataSourceAsync(const Model::DeleteDataSourceRequest& request, const DeleteDataSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteDataSourceOutcomeCallable deleteDataSourceCallable(const Model::DeleteDataSourceRequest& request) const;
DeleteDeviceOutcome deleteDevice(const Model::DeleteDeviceRequest &request)const;
void deleteDeviceAsync(const Model::DeleteDeviceRequest& request, const DeleteDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteDeviceOutcomeCallable deleteDeviceCallable(const Model::DeleteDeviceRequest& request) const;
DeleteRecordsOutcome deleteRecords(const Model::DeleteRecordsRequest &request)const;
void deleteRecordsAsync(const Model::DeleteRecordsRequest& request, const DeleteRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteRecordsOutcomeCallable deleteRecordsCallable(const Model::DeleteRecordsRequest& request) const;
DeleteVideoSummaryTaskOutcome deleteVideoSummaryTask(const Model::DeleteVideoSummaryTaskRequest &request)const;
void deleteVideoSummaryTaskAsync(const Model::DeleteVideoSummaryTaskRequest& request, const DeleteVideoSummaryTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteVideoSummaryTaskOutcomeCallable deleteVideoSummaryTaskCallable(const Model::DeleteVideoSummaryTaskRequest& request) const;
GetBodyOptionsOutcome getBodyOptions(const Model::GetBodyOptionsRequest &request)const;
void getBodyOptionsAsync(const Model::GetBodyOptionsRequest& request, const GetBodyOptionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetBodyOptionsOutcomeCallable getBodyOptionsCallable(const Model::GetBodyOptionsRequest& request) const;
@@ -202,12 +262,21 @@ namespace AlibabaCloud
GetPersonDetailOutcome getPersonDetail(const Model::GetPersonDetailRequest &request)const;
void getPersonDetailAsync(const Model::GetPersonDetailRequest& request, const GetPersonDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetPersonDetailOutcomeCallable getPersonDetailCallable(const Model::GetPersonDetailRequest& request) const;
GetVideoComposeResultOutcome getVideoComposeResult(const Model::GetVideoComposeResultRequest &request)const;
void getVideoComposeResultAsync(const Model::GetVideoComposeResultRequest& request, const GetVideoComposeResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetVideoComposeResultOutcomeCallable getVideoComposeResultCallable(const Model::GetVideoComposeResultRequest& request) const;
GetVideoSummaryTaskResultOutcome getVideoSummaryTaskResult(const Model::GetVideoSummaryTaskResultRequest &request)const;
void getVideoSummaryTaskResultAsync(const Model::GetVideoSummaryTaskResultRequest& request, const GetVideoSummaryTaskResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetVideoSummaryTaskResultOutcomeCallable getVideoSummaryTaskResultCallable(const Model::GetVideoSummaryTaskResultRequest& request) const;
ListCorpsOutcome listCorps(const Model::ListCorpsRequest &request)const;
void listCorpsAsync(const Model::ListCorpsRequest& request, const ListCorpsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListCorpsOutcomeCallable listCorpsCallable(const Model::ListCorpsRequest& request) const;
ListDevicesOutcome listDevices(const Model::ListDevicesRequest &request)const;
void listDevicesAsync(const Model::ListDevicesRequest& request, const ListDevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListDevicesOutcomeCallable listDevicesCallable(const Model::ListDevicesRequest& request) const;
ListEventAlgorithmResultsOutcome listEventAlgorithmResults(const Model::ListEventAlgorithmResultsRequest &request)const;
void listEventAlgorithmResultsAsync(const Model::ListEventAlgorithmResultsRequest& request, const ListEventAlgorithmResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListEventAlgorithmResultsOutcomeCallable listEventAlgorithmResultsCallable(const Model::ListEventAlgorithmResultsRequest& request) const;
ListFaceAlgorithmResultsOutcome listFaceAlgorithmResults(const Model::ListFaceAlgorithmResultsRequest &request)const;
void listFaceAlgorithmResultsAsync(const Model::ListFaceAlgorithmResultsRequest& request, const ListFaceAlgorithmResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListFaceAlgorithmResultsOutcomeCallable listFaceAlgorithmResultsCallable(const Model::ListFaceAlgorithmResultsRequest& request) const;
@@ -244,6 +313,9 @@ namespace AlibabaCloud
UpdateMonitorOutcome updateMonitor(const Model::UpdateMonitorRequest &request)const;
void updateMonitorAsync(const Model::UpdateMonitorRequest& request, const UpdateMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateMonitorOutcomeCallable updateMonitorCallable(const Model::UpdateMonitorRequest& request) const;
UploadFileOutcome uploadFile(const Model::UploadFileRequest &request)const;
void uploadFileAsync(const Model::UploadFileRequest& request, const UploadFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UploadFileOutcomeCallable uploadFileCallable(const Model::UploadFileRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;

57
vcs/include/alibabacloud/vcs/model/AddDataSourceRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VCS_MODEL_ADDDATASOURCEREQUEST_H_
#define ALIBABACLOUD_VCS_MODEL_ADDDATASOURCEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT AddDataSourceRequest : public RpcServiceRequest
{
public:
AddDataSourceRequest();
~AddDataSourceRequest();
std::string getDataSourceType()const;
void setDataSourceType(const std::string& dataSourceType);
std::string getCorpId()const;
void setCorpId(const std::string& corpId);
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getDataSourceName()const;
void setDataSourceName(const std::string& dataSourceName);
private:
std::string dataSourceType_;
std::string corpId_;
std::string description_;
std::string dataSourceName_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_ADDDATASOURCEREQUEST_H_

61
vcs/include/alibabacloud/vcs/model/AddDataSourceResult.h Normal file
View File

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

69
vcs/include/alibabacloud/vcs/model/CreateVideoComposeTaskRequest.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* 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_VCS_MODEL_CREATEVIDEOCOMPOSETASKREQUEST_H_
#define ALIBABACLOUD_VCS_MODEL_CREATEVIDEOCOMPOSETASKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT CreateVideoComposeTaskRequest : public RpcServiceRequest
{
public:
CreateVideoComposeTaskRequest();
~CreateVideoComposeTaskRequest();
std::string getCorpId()const;
void setCorpId(const std::string& corpId);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getPicUrlList()const;
void setPicUrlList(const std::string& picUrlList);
std::string getAudioUrl()const;
void setAudioUrl(const std::string& audioUrl);
std::string getBucketName()const;
void setBucketName(const std::string& bucketName);
std::string getImageParameters()const;
void setImageParameters(const std::string& imageParameters);
std::string getVideoRate()const;
void setVideoRate(const std::string& videoRate);
std::string getVideoFormat()const;
void setVideoFormat(const std::string& videoFormat);
private:
std::string corpId_;
std::string domainName_;
std::string picUrlList_;
std::string audioUrl_;
std::string bucketName_;
std::string imageParameters_;
std::string videoRate_;
std::string videoFormat_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_CREATEVIDEOCOMPOSETASKREQUEST_H_

60
vcs/include/alibabacloud/vcs/model/CreateVideoComposeTaskResult.h Normal file
View File

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

63
vcs/include/alibabacloud/vcs/model/CreateVideoSummaryTaskRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* 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_VCS_MODEL_CREATEVIDEOSUMMARYTASKREQUEST_H_
#define ALIBABACLOUD_VCS_MODEL_CREATEVIDEOSUMMARYTASKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT CreateVideoSummaryTaskRequest : public RpcServiceRequest
{
public:
CreateVideoSummaryTaskRequest();
~CreateVideoSummaryTaskRequest();
std::string getCorpId()const;
void setCorpId(const std::string& corpId);
std::string getLiveVideoSummary()const;
void setLiveVideoSummary(const std::string& liveVideoSummary);
std::string getStartTimeStamp()const;
void setStartTimeStamp(const std::string& startTimeStamp);
std::string getDeviceId()const;
void setDeviceId(const std::string& deviceId);
std::string getEndTimeStamp()const;
void setEndTimeStamp(const std::string& endTimeStamp);
std::string getOptionList()const;
void setOptionList(const std::string& optionList);
private:
std::string corpId_;
std::string liveVideoSummary_;
std::string startTimeStamp_;
std::string deviceId_;
std::string endTimeStamp_;
std::string optionList_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_CREATEVIDEOSUMMARYTASKREQUEST_H_

55
vcs/include/alibabacloud/vcs/model/CreateVideoSummaryTaskResult.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_VCS_MODEL_CREATEVIDEOSUMMARYTASKRESULT_H_
#define ALIBABACLOUD_VCS_MODEL_CREATEVIDEOSUMMARYTASKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT CreateVideoSummaryTaskResult : public ServiceResult
{
public:
CreateVideoSummaryTaskResult();
explicit CreateVideoSummaryTaskResult(const std::string &payload);
~CreateVideoSummaryTaskResult();
std::string getMessage()const;
std::string getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_CREATEVIDEOSUMMARYTASKRESULT_H_

51
vcs/include/alibabacloud/vcs/model/DeleteDataSourceRequest.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_VCS_MODEL_DELETEDATASOURCEREQUEST_H_
#define ALIBABACLOUD_VCS_MODEL_DELETEDATASOURCEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT DeleteDataSourceRequest : public RpcServiceRequest
{
public:
DeleteDataSourceRequest();
~DeleteDataSourceRequest();
std::string getCorpId()const;
void setCorpId(const std::string& corpId);
std::string getDataSourceId()const;
void setDataSourceId(const std::string& dataSourceId);
private:
std::string corpId_;
std::string dataSourceId_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_DELETEDATASOURCEREQUEST_H_

55
vcs/include/alibabacloud/vcs/model/DeleteDataSourceResult.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_VCS_MODEL_DELETEDATASOURCERESULT_H_
#define ALIBABACLOUD_VCS_MODEL_DELETEDATASOURCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT DeleteDataSourceResult : public ServiceResult
{
public:
DeleteDataSourceResult();
explicit DeleteDataSourceResult(const std::string &payload);
~DeleteDataSourceResult();
std::string getMessage()const;
std::string getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_DELETEDATASOURCERESULT_H_

51
vcs/include/alibabacloud/vcs/model/DeleteVideoSummaryTaskRequest.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_VCS_MODEL_DELETEVIDEOSUMMARYTASKREQUEST_H_
#define ALIBABACLOUD_VCS_MODEL_DELETEVIDEOSUMMARYTASKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT DeleteVideoSummaryTaskRequest : public RpcServiceRequest
{
public:
DeleteVideoSummaryTaskRequest();
~DeleteVideoSummaryTaskRequest();
std::string getCorpId()const;
void setCorpId(const std::string& corpId);
std::string getTaskId()const;
void setTaskId(const std::string& taskId);
private:
std::string corpId_;
std::string taskId_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_DELETEVIDEOSUMMARYTASKREQUEST_H_

55
vcs/include/alibabacloud/vcs/model/DeleteVideoSummaryTaskResult.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_VCS_MODEL_DELETEVIDEOSUMMARYTASKRESULT_H_
#define ALIBABACLOUD_VCS_MODEL_DELETEVIDEOSUMMARYTASKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT DeleteVideoSummaryTaskResult : public ServiceResult
{
public:
DeleteVideoSummaryTaskResult();
explicit DeleteVideoSummaryTaskResult(const std::string &payload);
~DeleteVideoSummaryTaskResult();
std::string getMessage()const;
std::string getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_DELETEVIDEOSUMMARYTASKRESULT_H_

51
vcs/include/alibabacloud/vcs/model/GetVideoComposeResultRequest.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_VCS_MODEL_GETVIDEOCOMPOSERESULTREQUEST_H_
#define ALIBABACLOUD_VCS_MODEL_GETVIDEOCOMPOSERESULTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT GetVideoComposeResultRequest : public RpcServiceRequest
{
public:
GetVideoComposeResultRequest();
~GetVideoComposeResultRequest();
std::string getCorpId()const;
void setCorpId(const std::string& corpId);
std::string getTaskRequestId()const;
void setTaskRequestId(const std::string& taskRequestId);
private:
std::string corpId_;
std::string taskRequestId_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_GETVIDEOCOMPOSERESULTREQUEST_H_

53
vcs/include/alibabacloud/vcs/model/GetVideoComposeResultResult.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* 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_VCS_MODEL_GETVIDEOCOMPOSERESULTRESULT_H_
#define ALIBABACLOUD_VCS_MODEL_GETVIDEOCOMPOSERESULTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT GetVideoComposeResultResult : public ServiceResult
{
public:
GetVideoComposeResultResult();
explicit GetVideoComposeResultResult(const std::string &payload);
~GetVideoComposeResultResult();
std::string getMessage()const;
std::string getVideoUrl()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string videoUrl_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_GETVIDEOCOMPOSERESULTRESULT_H_

51
vcs/include/alibabacloud/vcs/model/GetVideoSummaryTaskResultRequest.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_VCS_MODEL_GETVIDEOSUMMARYTASKRESULTREQUEST_H_
#define ALIBABACLOUD_VCS_MODEL_GETVIDEOSUMMARYTASKRESULTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT GetVideoSummaryTaskResultRequest : public RpcServiceRequest
{
public:
GetVideoSummaryTaskResultRequest();
~GetVideoSummaryTaskResultRequest();
std::string getCorpId()const;
void setCorpId(const std::string& corpId);
std::string getTaskId()const;
void setTaskId(const std::string& taskId);
private:
std::string corpId_;
std::string taskId_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_GETVIDEOSUMMARYTASKRESULTREQUEST_H_

55
vcs/include/alibabacloud/vcs/model/GetVideoSummaryTaskResultResult.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_VCS_MODEL_GETVIDEOSUMMARYTASKRESULTRESULT_H_
#define ALIBABACLOUD_VCS_MODEL_GETVIDEOSUMMARYTASKRESULTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT GetVideoSummaryTaskResultResult : public ServiceResult
{
public:
GetVideoSummaryTaskResultResult();
explicit GetVideoSummaryTaskResultResult(const std::string &payload);
~GetVideoSummaryTaskResultResult();
std::string getMessage()const;
std::string getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_GETVIDEOSUMMARYTASKRESULTRESULT_H_

66
vcs/include/alibabacloud/vcs/model/ListEventAlgorithmResultsRequest.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VCS_MODEL_LISTEVENTALGORITHMRESULTSREQUEST_H_
#define ALIBABACLOUD_VCS_MODEL_LISTEVENTALGORITHMRESULTSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT ListEventAlgorithmResultsRequest : public RpcServiceRequest
{
public:
ListEventAlgorithmResultsRequest();
~ListEventAlgorithmResultsRequest();
std::string getCorpId()const;
void setCorpId(const std::string& corpId);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getPageNumber()const;
void setPageNumber(const std::string& pageNumber);
std::string getDataSourceId()const;
void setDataSourceId(const std::string& dataSourceId);
std::string getPageSize()const;
void setPageSize(const std::string& pageSize);
std::string getEventType()const;
void setEventType(const std::string& eventType);
private:
std::string corpId_;
std::string endTime_;
std::string startTime_;
std::string pageNumber_;
std::string dataSourceId_;
std::string pageSize_;
std::string eventType_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_LISTEVENTALGORITHMRESULTSREQUEST_H_

74
vcs/include/alibabacloud/vcs/model/ListEventAlgorithmResultsResult.h Normal file
View File

@@ -0,0 +1,74 @@
/*
* 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_VCS_MODEL_LISTEVENTALGORITHMRESULTSRESULT_H_
#define ALIBABACLOUD_VCS_MODEL_LISTEVENTALGORITHMRESULTSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT ListEventAlgorithmResultsResult : public ServiceResult
{
public:
struct Data
{
struct RecordsItem
{
std::string picUrlPath;
std::string corpId;
std::string eventType;
std::string targetPicUrlPath;
std::string shotTime;
std::string capStyle;
std::string faceCount;
std::string dataSourceId;
};
int totalCount;
int pageSize;
int totalPage;
int pageNumber;
std::vector<RecordsItem> records;
};
ListEventAlgorithmResultsResult();
explicit ListEventAlgorithmResultsResult(const std::string &payload);
~ListEventAlgorithmResultsResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_LISTEVENTALGORITHMRESULTSRESULT_H_

6
vcs/include/alibabacloud/vcs/model/ListMotorAlgorithmResultsResult.h
View File

@@ -36,16 +36,18 @@ namespace AlibabaCloud
{
struct RecordsItem
{
std::string motorId;
std::string picUrlPath;
std::string plateNumber;
std::string corpId;
float rightBottomX;
float rightBottomY;
std::string targetPicUrlPath;
std::string shotTime;
float leftTopY;
std::string motorModel;
float leftTopX;
std::string motorId;
std::string motorStyle;
std::string shotTime;
std::string dataSourceId;
};
int totalCount;

69
vcs/include/alibabacloud/vcs/model/UploadFileRequest.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* 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_VCS_MODEL_UPLOADFILEREQUEST_H_
#define ALIBABACLOUD_VCS_MODEL_UPLOADFILEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT UploadFileRequest : public RpcServiceRequest
{
public:
UploadFileRequest();
~UploadFileRequest();
std::string getFileType()const;
void setFileType(const std::string& fileType);
std::string getCorpId()const;
void setCorpId(const std::string& corpId);
std::string getFileAliasName()const;
void setFileAliasName(const std::string& fileAliasName);
std::string getFileName()const;
void setFileName(const std::string& fileName);
std::string getFilePath()const;
void setFilePath(const std::string& filePath);
std::string getFileContent()const;
void setFileContent(const std::string& fileContent);
std::string getDataSourceId()const;
void setDataSourceId(const std::string& dataSourceId);
std::string getMD5()const;
void setMD5(const std::string& mD5);
private:
std::string fileType_;
std::string corpId_;
std::string fileAliasName_;
std::string fileName_;
std::string filePath_;
std::string fileContent_;
std::string dataSourceId_;
std::string mD5_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_UPLOADFILEREQUEST_H_

55
vcs/include/alibabacloud/vcs/model/UploadFileResult.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_VCS_MODEL_UPLOADFILERESULT_H_
#define ALIBABACLOUD_VCS_MODEL_UPLOADFILERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vcs/VcsExport.h>
namespace AlibabaCloud
{
namespace Vcs
{
namespace Model
{
class ALIBABACLOUD_VCS_EXPORT UploadFileResult : public ServiceResult
{
public:
UploadFileResult();
explicit UploadFileResult(const std::string &payload);
~UploadFileResult();
std::string getMessage()const;
std::string getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::string data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_VCS_MODEL_UPLOADFILERESULT_H_

324
vcs/src/VcsClient.cc
View File

@@ -51,6 +51,42 @@ VcsClient::VcsClient(const std::string & accessKeyId, const std::string & access
VcsClient::~VcsClient()
{}
VcsClient::AddDataSourceOutcome VcsClient::addDataSource(const AddDataSourceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AddDataSourceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AddDataSourceOutcome(AddDataSourceResult(outcome.result()));
else
return AddDataSourceOutcome(outcome.error());
}
void VcsClient::addDataSourceAsync(const AddDataSourceRequest& request, const AddDataSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, addDataSource(request), context);
};
asyncExecute(new Runnable(fn));
}
VcsClient::AddDataSourceOutcomeCallable VcsClient::addDataSourceCallable(const AddDataSourceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AddDataSourceOutcome()>>(
[this, request]()
{
return this->addDataSource(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VcsClient::AddDeviceOutcome VcsClient::addDevice(const AddDeviceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -159,6 +195,114 @@ VcsClient::CreateCorpOutcomeCallable VcsClient::createCorpCallable(const CreateC
return task->get_future();
}
VcsClient::CreateVideoComposeTaskOutcome VcsClient::createVideoComposeTask(const CreateVideoComposeTaskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateVideoComposeTaskOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateVideoComposeTaskOutcome(CreateVideoComposeTaskResult(outcome.result()));
else
return CreateVideoComposeTaskOutcome(outcome.error());
}
void VcsClient::createVideoComposeTaskAsync(const CreateVideoComposeTaskRequest& request, const CreateVideoComposeTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createVideoComposeTask(request), context);
};
asyncExecute(new Runnable(fn));
}
VcsClient::CreateVideoComposeTaskOutcomeCallable VcsClient::createVideoComposeTaskCallable(const CreateVideoComposeTaskRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateVideoComposeTaskOutcome()>>(
[this, request]()
{
return this->createVideoComposeTask(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VcsClient::CreateVideoSummaryTaskOutcome VcsClient::createVideoSummaryTask(const CreateVideoSummaryTaskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateVideoSummaryTaskOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateVideoSummaryTaskOutcome(CreateVideoSummaryTaskResult(outcome.result()));
else
return CreateVideoSummaryTaskOutcome(outcome.error());
}
void VcsClient::createVideoSummaryTaskAsync(const CreateVideoSummaryTaskRequest& request, const CreateVideoSummaryTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createVideoSummaryTask(request), context);
};
asyncExecute(new Runnable(fn));
}
VcsClient::CreateVideoSummaryTaskOutcomeCallable VcsClient::createVideoSummaryTaskCallable(const CreateVideoSummaryTaskRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateVideoSummaryTaskOutcome()>>(
[this, request]()
{
return this->createVideoSummaryTask(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VcsClient::DeleteDataSourceOutcome VcsClient::deleteDataSource(const DeleteDataSourceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteDataSourceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteDataSourceOutcome(DeleteDataSourceResult(outcome.result()));
else
return DeleteDataSourceOutcome(outcome.error());
}
void VcsClient::deleteDataSourceAsync(const DeleteDataSourceRequest& request, const DeleteDataSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteDataSource(request), context);
};
asyncExecute(new Runnable(fn));
}
VcsClient::DeleteDataSourceOutcomeCallable VcsClient::deleteDataSourceCallable(const DeleteDataSourceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteDataSourceOutcome()>>(
[this, request]()
{
return this->deleteDataSource(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VcsClient::DeleteDeviceOutcome VcsClient::deleteDevice(const DeleteDeviceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -231,6 +375,42 @@ VcsClient::DeleteRecordsOutcomeCallable VcsClient::deleteRecordsCallable(const D
return task->get_future();
}
VcsClient::DeleteVideoSummaryTaskOutcome VcsClient::deleteVideoSummaryTask(const DeleteVideoSummaryTaskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteVideoSummaryTaskOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteVideoSummaryTaskOutcome(DeleteVideoSummaryTaskResult(outcome.result()));
else
return DeleteVideoSummaryTaskOutcome(outcome.error());
}
void VcsClient::deleteVideoSummaryTaskAsync(const DeleteVideoSummaryTaskRequest& request, const DeleteVideoSummaryTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteVideoSummaryTask(request), context);
};
asyncExecute(new Runnable(fn));
}
VcsClient::DeleteVideoSummaryTaskOutcomeCallable VcsClient::deleteVideoSummaryTaskCallable(const DeleteVideoSummaryTaskRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteVideoSummaryTaskOutcome()>>(
[this, request]()
{
return this->deleteVideoSummaryTask(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VcsClient::GetBodyOptionsOutcome VcsClient::getBodyOptions(const GetBodyOptionsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -483,6 +663,78 @@ VcsClient::GetPersonDetailOutcomeCallable VcsClient::getPersonDetailCallable(con
return task->get_future();
}
VcsClient::GetVideoComposeResultOutcome VcsClient::getVideoComposeResult(const GetVideoComposeResultRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetVideoComposeResultOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetVideoComposeResultOutcome(GetVideoComposeResultResult(outcome.result()));
else
return GetVideoComposeResultOutcome(outcome.error());
}
void VcsClient::getVideoComposeResultAsync(const GetVideoComposeResultRequest& request, const GetVideoComposeResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getVideoComposeResult(request), context);
};
asyncExecute(new Runnable(fn));
}
VcsClient::GetVideoComposeResultOutcomeCallable VcsClient::getVideoComposeResultCallable(const GetVideoComposeResultRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetVideoComposeResultOutcome()>>(
[this, request]()
{
return this->getVideoComposeResult(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VcsClient::GetVideoSummaryTaskResultOutcome VcsClient::getVideoSummaryTaskResult(const GetVideoSummaryTaskResultRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetVideoSummaryTaskResultOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetVideoSummaryTaskResultOutcome(GetVideoSummaryTaskResultResult(outcome.result()));
else
return GetVideoSummaryTaskResultOutcome(outcome.error());
}
void VcsClient::getVideoSummaryTaskResultAsync(const GetVideoSummaryTaskResultRequest& request, const GetVideoSummaryTaskResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getVideoSummaryTaskResult(request), context);
};
asyncExecute(new Runnable(fn));
}
VcsClient::GetVideoSummaryTaskResultOutcomeCallable VcsClient::getVideoSummaryTaskResultCallable(const GetVideoSummaryTaskResultRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetVideoSummaryTaskResultOutcome()>>(
[this, request]()
{
return this->getVideoSummaryTaskResult(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VcsClient::ListCorpsOutcome VcsClient::listCorps(const ListCorpsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -555,6 +807,42 @@ VcsClient::ListDevicesOutcomeCallable VcsClient::listDevicesCallable(const ListD
return task->get_future();
}
VcsClient::ListEventAlgorithmResultsOutcome VcsClient::listEventAlgorithmResults(const ListEventAlgorithmResultsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListEventAlgorithmResultsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListEventAlgorithmResultsOutcome(ListEventAlgorithmResultsResult(outcome.result()));
else
return ListEventAlgorithmResultsOutcome(outcome.error());
}
void VcsClient::listEventAlgorithmResultsAsync(const ListEventAlgorithmResultsRequest& request, const ListEventAlgorithmResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listEventAlgorithmResults(request), context);
};
asyncExecute(new Runnable(fn));
}
VcsClient::ListEventAlgorithmResultsOutcomeCallable VcsClient::listEventAlgorithmResultsCallable(const ListEventAlgorithmResultsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListEventAlgorithmResultsOutcome()>>(
[this, request]()
{
return this->listEventAlgorithmResults(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VcsClient::ListFaceAlgorithmResultsOutcome VcsClient::listFaceAlgorithmResults(const ListFaceAlgorithmResultsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -987,3 +1275,39 @@ VcsClient::UpdateMonitorOutcomeCallable VcsClient::updateMonitorCallable(const U
return task->get_future();
}
VcsClient::UploadFileOutcome VcsClient::uploadFile(const UploadFileRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UploadFileOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UploadFileOutcome(UploadFileResult(outcome.result()));
else
return UploadFileOutcome(outcome.error());
}
void VcsClient::uploadFileAsync(const UploadFileRequest& request, const UploadFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, uploadFile(request), context);
};
asyncExecute(new Runnable(fn));
}
VcsClient::UploadFileOutcomeCallable VcsClient::uploadFileCallable(const UploadFileRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UploadFileOutcome()>>(
[this, request]()
{
return this->uploadFile(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

73
vcs/src/model/AddDataSourceRequest.cc Normal file
View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/vcs/model/AddDataSourceRequest.h>
using AlibabaCloud::Vcs::Model::AddDataSourceRequest;
AddDataSourceRequest::AddDataSourceRequest() :
RpcServiceRequest("vcs", "2020-05-15", "AddDataSource")
{
setMethod(HttpRequest::Method::Post);
}
AddDataSourceRequest::~AddDataSourceRequest()
{}
std::string AddDataSourceRequest::getDataSourceType()const
{
return dataSourceType_;
}
void AddDataSourceRequest::setDataSourceType(const std::string& dataSourceType)
{
dataSourceType_ = dataSourceType;
setBodyParameter("DataSourceType", dataSourceType);
}
std::string AddDataSourceRequest::getCorpId()const
{
return corpId_;
}
void AddDataSourceRequest::setCorpId(const std::string& corpId)
{
corpId_ = corpId;
setBodyParameter("CorpId", corpId);
}
std::string AddDataSourceRequest::getDescription()const
{
return description_;
}
void AddDataSourceRequest::setDescription(const std::string& description)
{
description_ = description;
setBodyParameter("Description", description);
}
std::string AddDataSourceRequest::getDataSourceName()const
{
return dataSourceName_;
}
void AddDataSourceRequest::setDataSourceName(const std::string& dataSourceName)
{
dataSourceName_ = dataSourceName;
setBodyParameter("DataSourceName", dataSourceName);
}

70
vcs/src/model/AddDataSourceResult.cc Normal file
View File

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

117
vcs/src/model/CreateVideoComposeTaskRequest.cc Normal file
View File

@@ -0,0 +1,117 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/vcs/model/CreateVideoComposeTaskRequest.h>
using AlibabaCloud::Vcs::Model::CreateVideoComposeTaskRequest;
CreateVideoComposeTaskRequest::CreateVideoComposeTaskRequest() :
RpcServiceRequest("vcs", "2020-05-15", "CreateVideoComposeTask")
{
setMethod(HttpRequest::Method::Post);
}
CreateVideoComposeTaskRequest::~CreateVideoComposeTaskRequest()
{}
std::string CreateVideoComposeTaskRequest::getCorpId()const
{
return corpId_;
}
void CreateVideoComposeTaskRequest::setCorpId(const std::string& corpId)
{
corpId_ = corpId;
setBodyParameter("CorpId", corpId);
}
std::string CreateVideoComposeTaskRequest::getDomainName()const
{
return domainName_;
}
void CreateVideoComposeTaskRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setBodyParameter("DomainName", domainName);
}
std::string CreateVideoComposeTaskRequest::getPicUrlList()const
{
return picUrlList_;
}
void CreateVideoComposeTaskRequest::setPicUrlList(const std::string& picUrlList)
{
picUrlList_ = picUrlList;
setBodyParameter("PicUrlList", picUrlList);
}
std::string CreateVideoComposeTaskRequest::getAudioUrl()const
{
return audioUrl_;
}
void CreateVideoComposeTaskRequest::setAudioUrl(const std::string& audioUrl)
{
audioUrl_ = audioUrl;
setBodyParameter("AudioUrl", audioUrl);
}
std::string CreateVideoComposeTaskRequest::getBucketName()const
{
return bucketName_;
}
void CreateVideoComposeTaskRequest::setBucketName(const std::string& bucketName)
{
bucketName_ = bucketName;
setBodyParameter("BucketName", bucketName);
}
std::string CreateVideoComposeTaskRequest::getImageParameters()const
{
return imageParameters_;
}
void CreateVideoComposeTaskRequest::setImageParameters(const std::string& imageParameters)
{
imageParameters_ = imageParameters;
setBodyParameter("ImageParameters", imageParameters);
}
std::string CreateVideoComposeTaskRequest::getVideoRate()const
{
return videoRate_;
}
void CreateVideoComposeTaskRequest::setVideoRate(const std::string& videoRate)
{
videoRate_ = videoRate;
setBodyParameter("VideoRate", videoRate);
}
std::string CreateVideoComposeTaskRequest::getVideoFormat()const
{
return videoFormat_;
}
void CreateVideoComposeTaskRequest::setVideoFormat(const std::string& videoFormat)
{
videoFormat_ = videoFormat;
setBodyParameter("VideoFormat", videoFormat);
}

68
vcs/src/model/CreateVideoComposeTaskResult.cc Normal file
View File

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

95
vcs/src/model/CreateVideoSummaryTaskRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/vcs/model/CreateVideoSummaryTaskRequest.h>
using AlibabaCloud::Vcs::Model::CreateVideoSummaryTaskRequest;
CreateVideoSummaryTaskRequest::CreateVideoSummaryTaskRequest() :
RpcServiceRequest("vcs", "2020-05-15", "CreateVideoSummaryTask")
{
setMethod(HttpRequest::Method::Post);
}
CreateVideoSummaryTaskRequest::~CreateVideoSummaryTaskRequest()
{}
std::string CreateVideoSummaryTaskRequest::getCorpId()const
{
return corpId_;
}
void CreateVideoSummaryTaskRequest::setCorpId(const std::string& corpId)
{
corpId_ = corpId;
setBodyParameter("CorpId", corpId);
}
std::string CreateVideoSummaryTaskRequest::getLiveVideoSummary()const
{
return liveVideoSummary_;
}
void CreateVideoSummaryTaskRequest::setLiveVideoSummary(const std::string& liveVideoSummary)
{
liveVideoSummary_ = liveVideoSummary;
setBodyParameter("LiveVideoSummary", liveVideoSummary);
}
std::string CreateVideoSummaryTaskRequest::getStartTimeStamp()const
{
return startTimeStamp_;
}
void CreateVideoSummaryTaskRequest::setStartTimeStamp(const std::string& startTimeStamp)
{
startTimeStamp_ = startTimeStamp;
setBodyParameter("StartTimeStamp", startTimeStamp);
}
std::string CreateVideoSummaryTaskRequest::getDeviceId()const
{
return deviceId_;
}
void CreateVideoSummaryTaskRequest::setDeviceId(const std::string& deviceId)
{
deviceId_ = deviceId;
setBodyParameter("DeviceId", deviceId);
}
std::string CreateVideoSummaryTaskRequest::getEndTimeStamp()const
{
return endTimeStamp_;
}
void CreateVideoSummaryTaskRequest::setEndTimeStamp(const std::string& endTimeStamp)
{
endTimeStamp_ = endTimeStamp;
setBodyParameter("EndTimeStamp", endTimeStamp);
}
std::string CreateVideoSummaryTaskRequest::getOptionList()const
{
return optionList_;
}
void CreateVideoSummaryTaskRequest::setOptionList(const std::string& optionList)
{
optionList_ = optionList;
setBodyParameter("OptionList", optionList);
}

65
vcs/src/model/CreateVideoSummaryTaskResult.cc Normal file
View File

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

51
vcs/src/model/DeleteDataSourceRequest.cc 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.
*/
#include <alibabacloud/vcs/model/DeleteDataSourceRequest.h>
using AlibabaCloud::Vcs::Model::DeleteDataSourceRequest;
DeleteDataSourceRequest::DeleteDataSourceRequest() :
RpcServiceRequest("vcs", "2020-05-15", "DeleteDataSource")
{
setMethod(HttpRequest::Method::Post);
}
DeleteDataSourceRequest::~DeleteDataSourceRequest()
{}
std::string DeleteDataSourceRequest::getCorpId()const
{
return corpId_;
}
void DeleteDataSourceRequest::setCorpId(const std::string& corpId)
{
corpId_ = corpId;
setBodyParameter("CorpId", corpId);
}
std::string DeleteDataSourceRequest::getDataSourceId()const
{
return dataSourceId_;
}
void DeleteDataSourceRequest::setDataSourceId(const std::string& dataSourceId)
{
dataSourceId_ = dataSourceId;
setBodyParameter("DataSourceId", dataSourceId);
}

65
vcs/src/model/DeleteDataSourceResult.cc Normal file
View File

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

51
vcs/src/model/DeleteVideoSummaryTaskRequest.cc 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.
*/
#include <alibabacloud/vcs/model/DeleteVideoSummaryTaskRequest.h>
using AlibabaCloud::Vcs::Model::DeleteVideoSummaryTaskRequest;
DeleteVideoSummaryTaskRequest::DeleteVideoSummaryTaskRequest() :
RpcServiceRequest("vcs", "2020-05-15", "DeleteVideoSummaryTask")
{
setMethod(HttpRequest::Method::Post);
}
DeleteVideoSummaryTaskRequest::~DeleteVideoSummaryTaskRequest()
{}
std::string DeleteVideoSummaryTaskRequest::getCorpId()const
{
return corpId_;
}
void DeleteVideoSummaryTaskRequest::setCorpId(const std::string& corpId)
{
corpId_ = corpId;
setBodyParameter("CorpId", corpId);
}
std::string DeleteVideoSummaryTaskRequest::getTaskId()const
{
return taskId_;
}
void DeleteVideoSummaryTaskRequest::setTaskId(const std::string& taskId)
{
taskId_ = taskId;
setBodyParameter("TaskId", taskId);
}

65
vcs/src/model/DeleteVideoSummaryTaskResult.cc Normal file
View File

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

51
vcs/src/model/GetVideoComposeResultRequest.cc 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.
*/
#include <alibabacloud/vcs/model/GetVideoComposeResultRequest.h>
using AlibabaCloud::Vcs::Model::GetVideoComposeResultRequest;
GetVideoComposeResultRequest::GetVideoComposeResultRequest() :
RpcServiceRequest("vcs", "2020-05-15", "GetVideoComposeResult")
{
setMethod(HttpRequest::Method::Post);
}
GetVideoComposeResultRequest::~GetVideoComposeResultRequest()
{}
std::string GetVideoComposeResultRequest::getCorpId()const
{
return corpId_;
}
void GetVideoComposeResultRequest::setCorpId(const std::string& corpId)
{
corpId_ = corpId;
setBodyParameter("CorpId", corpId);
}
std::string GetVideoComposeResultRequest::getTaskRequestId()const
{
return taskRequestId_;
}
void GetVideoComposeResultRequest::setTaskRequestId(const std::string& taskRequestId)
{
taskRequestId_ = taskRequestId;
setBodyParameter("TaskRequestId", taskRequestId);
}

58
vcs/src/model/GetVideoComposeResultResult.cc Normal file
View File

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

51
vcs/src/model/GetVideoSummaryTaskResultRequest.cc 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.
*/
#include <alibabacloud/vcs/model/GetVideoSummaryTaskResultRequest.h>
using AlibabaCloud::Vcs::Model::GetVideoSummaryTaskResultRequest;
GetVideoSummaryTaskResultRequest::GetVideoSummaryTaskResultRequest() :
RpcServiceRequest("vcs", "2020-05-15", "GetVideoSummaryTaskResult")
{
setMethod(HttpRequest::Method::Post);
}
GetVideoSummaryTaskResultRequest::~GetVideoSummaryTaskResultRequest()
{}
std::string GetVideoSummaryTaskResultRequest::getCorpId()const
{
return corpId_;
}
void GetVideoSummaryTaskResultRequest::setCorpId(const std::string& corpId)
{
corpId_ = corpId;
setBodyParameter("CorpId", corpId);
}
std::string GetVideoSummaryTaskResultRequest::getTaskId()const
{
return taskId_;
}
void GetVideoSummaryTaskResultRequest::setTaskId(const std::string& taskId)
{
taskId_ = taskId;
setBodyParameter("TaskId", taskId);
}

65
vcs/src/model/GetVideoSummaryTaskResultResult.cc Normal file
View File

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

106
vcs/src/model/ListEventAlgorithmResultsRequest.cc Normal file
View File

@@ -0,0 +1,106 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/vcs/model/ListEventAlgorithmResultsRequest.h>
using AlibabaCloud::Vcs::Model::ListEventAlgorithmResultsRequest;
ListEventAlgorithmResultsRequest::ListEventAlgorithmResultsRequest() :
RpcServiceRequest("vcs", "2020-05-15", "ListEventAlgorithmResults")
{
setMethod(HttpRequest::Method::Post);
}
ListEventAlgorithmResultsRequest::~ListEventAlgorithmResultsRequest()
{}
std::string ListEventAlgorithmResultsRequest::getCorpId()const
{
return corpId_;
}
void ListEventAlgorithmResultsRequest::setCorpId(const std::string& corpId)
{
corpId_ = corpId;
setBodyParameter("CorpId", corpId);
}
std::string ListEventAlgorithmResultsRequest::getEndTime()const
{
return endTime_;
}
void ListEventAlgorithmResultsRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setBodyParameter("EndTime", endTime);
}
std::string ListEventAlgorithmResultsRequest::getStartTime()const
{
return startTime_;
}
void ListEventAlgorithmResultsRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setBodyParameter("StartTime", startTime);
}
std::string ListEventAlgorithmResultsRequest::getPageNumber()const
{
return pageNumber_;
}
void ListEventAlgorithmResultsRequest::setPageNumber(const std::string& pageNumber)
{
pageNumber_ = pageNumber;
setBodyParameter("PageNumber", pageNumber);
}
std::string ListEventAlgorithmResultsRequest::getDataSourceId()const
{
return dataSourceId_;
}
void ListEventAlgorithmResultsRequest::setDataSourceId(const std::string& dataSourceId)
{
dataSourceId_ = dataSourceId;
setBodyParameter("DataSourceId", dataSourceId);
}
std::string ListEventAlgorithmResultsRequest::getPageSize()const
{
return pageSize_;
}
void ListEventAlgorithmResultsRequest::setPageSize(const std::string& pageSize)
{
pageSize_ = pageSize;
setBodyParameter("PageSize", pageSize);
}
std::string ListEventAlgorithmResultsRequest::getEventType()const
{
return eventType_;
}
void ListEventAlgorithmResultsRequest::setEventType(const std::string& eventType)
{
eventType_ = eventType;
setBodyParameter("EventType", eventType);
}

94
vcs/src/model/ListEventAlgorithmResultsResult.cc Normal file
View File

@@ -0,0 +1,94 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/vcs/model/ListEventAlgorithmResultsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vcs;
using namespace AlibabaCloud::Vcs::Model;
ListEventAlgorithmResultsResult::ListEventAlgorithmResultsResult() :
ServiceResult()
{}
ListEventAlgorithmResultsResult::ListEventAlgorithmResultsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListEventAlgorithmResultsResult::~ListEventAlgorithmResultsResult()
{}
void ListEventAlgorithmResultsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["PageNumber"].isNull())
data_.pageNumber = std::stoi(dataNode["PageNumber"].asString());
if(!dataNode["PageSize"].isNull())
data_.pageSize = std::stoi(dataNode["PageSize"].asString());
if(!dataNode["TotalCount"].isNull())
data_.totalCount = std::stoi(dataNode["TotalCount"].asString());
if(!dataNode["TotalPage"].isNull())
data_.totalPage = std::stoi(dataNode["TotalPage"].asString());
auto allRecordsNode = dataNode["Records"]["RecordsItem"];
for (auto dataNodeRecordsRecordsItem : allRecordsNode)
{
Data::RecordsItem recordsItemObject;
if(!dataNodeRecordsRecordsItem["CapStyle"].isNull())
recordsItemObject.capStyle = dataNodeRecordsRecordsItem["CapStyle"].asString();
if(!dataNodeRecordsRecordsItem["CorpId"].isNull())
recordsItemObject.corpId = dataNodeRecordsRecordsItem["CorpId"].asString();
if(!dataNodeRecordsRecordsItem["DataSourceId"].isNull())
recordsItemObject.dataSourceId = dataNodeRecordsRecordsItem["DataSourceId"].asString();
if(!dataNodeRecordsRecordsItem["EventType"].isNull())
recordsItemObject.eventType = dataNodeRecordsRecordsItem["EventType"].asString();
if(!dataNodeRecordsRecordsItem["FaceCount"].isNull())
recordsItemObject.faceCount = dataNodeRecordsRecordsItem["FaceCount"].asString();
if(!dataNodeRecordsRecordsItem["PicUrlPath"].isNull())
recordsItemObject.picUrlPath = dataNodeRecordsRecordsItem["PicUrlPath"].asString();
if(!dataNodeRecordsRecordsItem["ShotTime"].isNull())
recordsItemObject.shotTime = dataNodeRecordsRecordsItem["ShotTime"].asString();
if(!dataNodeRecordsRecordsItem["TargetPicUrlPath"].isNull())
recordsItemObject.targetPicUrlPath = dataNodeRecordsRecordsItem["TargetPicUrlPath"].asString();
data_.records.push_back(recordsItemObject);
}
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string ListEventAlgorithmResultsResult::getMessage()const
{
return message_;
}
ListEventAlgorithmResultsResult::Data ListEventAlgorithmResultsResult::getData()const
{
return data_;
}
std::string ListEventAlgorithmResultsResult::getCode()const
{
return code_;
}

4
vcs/src/model/ListMotorAlgorithmResultsResult.cc
View File

@@ -74,6 +74,10 @@ void ListMotorAlgorithmResultsResult::parse(const std::string &payload)
recordsItemObject.shotTime = dataNodeRecordsRecordsItem["ShotTime"].asString();
if(!dataNodeRecordsRecordsItem["TargetPicUrlPath"].isNull())
recordsItemObject.targetPicUrlPath = dataNodeRecordsRecordsItem["TargetPicUrlPath"].asString();
if(!dataNodeRecordsRecordsItem["MotorStyle"].isNull())
recordsItemObject.motorStyle = dataNodeRecordsRecordsItem["MotorStyle"].asString();
if(!dataNodeRecordsRecordsItem["MotorModel"].isNull())
recordsItemObject.motorModel = dataNodeRecordsRecordsItem["MotorModel"].asString();
data_.records.push_back(recordsItemObject);
}
if(!value["Code"].isNull())

117
vcs/src/model/UploadFileRequest.cc Normal file
View File

@@ -0,0 +1,117 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/vcs/model/UploadFileRequest.h>
using AlibabaCloud::Vcs::Model::UploadFileRequest;
UploadFileRequest::UploadFileRequest() :
RpcServiceRequest("vcs", "2020-05-15", "UploadFile")
{
setMethod(HttpRequest::Method::Post);
}
UploadFileRequest::~UploadFileRequest()
{}
std::string UploadFileRequest::getFileType()const
{
return fileType_;
}
void UploadFileRequest::setFileType(const std::string& fileType)
{
fileType_ = fileType;
setBodyParameter("FileType", fileType);
}
std::string UploadFileRequest::getCorpId()const
{
return corpId_;
}
void UploadFileRequest::setCorpId(const std::string& corpId)
{
corpId_ = corpId;
setBodyParameter("CorpId", corpId);
}
std::string UploadFileRequest::getFileAliasName()const
{
return fileAliasName_;
}
void UploadFileRequest::setFileAliasName(const std::string& fileAliasName)
{
fileAliasName_ = fileAliasName;
setBodyParameter("FileAliasName", fileAliasName);
}
std::string UploadFileRequest::getFileName()const
{
return fileName_;
}
void UploadFileRequest::setFileName(const std::string& fileName)
{
fileName_ = fileName;
setBodyParameter("FileName", fileName);
}
std::string UploadFileRequest::getFilePath()const
{
return filePath_;
}
void UploadFileRequest::setFilePath(const std::string& filePath)
{
filePath_ = filePath;
setBodyParameter("FilePath", filePath);
}
std::string UploadFileRequest::getFileContent()const
{
return fileContent_;
}
void UploadFileRequest::setFileContent(const std::string& fileContent)
{
fileContent_ = fileContent;
setBodyParameter("FileContent", fileContent);
}
std::string UploadFileRequest::getDataSourceId()const
{
return dataSourceId_;
}
void UploadFileRequest::setDataSourceId(const std::string& dataSourceId)
{
dataSourceId_ = dataSourceId;
setBodyParameter("DataSourceId", dataSourceId);
}
std::string UploadFileRequest::getMD5()const
{
return mD5_;
}
void UploadFileRequest::setMD5(const std::string& mD5)
{
mD5_ = mD5;
setBodyParameter("MD5", mD5);
}

65
vcs/src/model/UploadFileResult.cc Normal file
View File

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