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

VOD SDK Auto Released By guzhaoyuan,Version：1.33.2

Browse Source 
Signed-off-by: yixiong.jxy <yixiong.jxy@alibaba-inc.com>
This commit is contained in:
yixiong.jxy
2018-11-21 14:09:40 +08:00
parent 66cfddf930
commit ded565f3f3
44 changed files with 2339 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
CHANGELOG
View File

@@ -1,3 +1,8 @@
2018-11-21 Version: 1.33.2
1, Add new apis called AddWatermark, UpdateWatermark, DeleteWatermark, ListWatermarks, GetWatermark and SetDefaultWatermark which support watermark feature.
2, Add a new api called RegisterMedia which supports registration of audio and video media files that already exist in the OSS bucket.
3, Add the field named OverrideParams to SubmitTranscodeJobs api request.
2018-11-16 Version: 1.33.1
1, update version

2
VERSION
View File

@@ -1 +1 @@
1.33.1
1.33.2

28
vod/CMakeLists.txt
View File

@@ -61,8 +61,12 @@ set(vod_public_header_model
include/alibabacloud/vod/model/SubmitAIVideoCategoryJobResult.h
include/alibabacloud/vod/model/DescribeRefreshTasksRequest.h
include/alibabacloud/vod/model/DescribeRefreshTasksResult.h
include/alibabacloud/vod/model/DeleteWatermarkRequest.h
include/alibabacloud/vod/model/DeleteWatermarkResult.h
include/alibabacloud/vod/model/UpdateCategoryRequest.h
include/alibabacloud/vod/model/UpdateCategoryResult.h
include/alibabacloud/vod/model/RegisterMediaRequest.h
include/alibabacloud/vod/model/RegisterMediaResult.h
include/alibabacloud/vod/model/ListAIASRJobRequest.h
include/alibabacloud/vod/model/ListAIASRJobResult.h
include/alibabacloud/vod/model/ListAIVideoCensorJobRequest.h
@@ -85,6 +89,10 @@ set(vod_public_header_model
include/alibabacloud/vod/model/ListAIJobResult.h
include/alibabacloud/vod/model/GetVideoConfigRequest.h
include/alibabacloud/vod/model/GetVideoConfigResult.h
include/alibabacloud/vod/model/AddWatermarkRequest.h
include/alibabacloud/vod/model/AddWatermarkResult.h
include/alibabacloud/vod/model/ListWatermarkRequest.h
include/alibabacloud/vod/model/ListWatermarkResult.h
include/alibabacloud/vod/model/CreateUploadImageRequest.h
include/alibabacloud/vod/model/CreateUploadImageResult.h
include/alibabacloud/vod/model/UpdateVideoInfoRequest.h
@@ -95,6 +103,8 @@ set(vod_public_header_model
include/alibabacloud/vod/model/SearchMediaResult.h
include/alibabacloud/vod/model/DescribePlayTopVideosRequest.h
include/alibabacloud/vod/model/DescribePlayTopVideosResult.h
include/alibabacloud/vod/model/SetDefaultWatermarkRequest.h
include/alibabacloud/vod/model/SetDefaultWatermarkResult.h
include/alibabacloud/vod/model/PushObjectCacheRequest.h
include/alibabacloud/vod/model/PushObjectCacheResult.h
include/alibabacloud/vod/model/AddCategoryRequest.h
@@ -117,6 +127,10 @@ set(vod_public_header_model
include/alibabacloud/vod/model/SubmitAIVideoTerrorismRecogJobResult.h
include/alibabacloud/vod/model/SearchEditingProjectRequest.h
include/alibabacloud/vod/model/SearchEditingProjectResult.h
include/alibabacloud/vod/model/GetWatermarkRequest.h
include/alibabacloud/vod/model/GetWatermarkResult.h
include/alibabacloud/vod/model/UpdateWatermarkRequest.h
include/alibabacloud/vod/model/UpdateWatermarkResult.h
include/alibabacloud/vod/model/GetImageInfoRequest.h
include/alibabacloud/vod/model/GetImageInfoResult.h
include/alibabacloud/vod/model/GetMessageCallbackRequest.h
@@ -214,8 +228,12 @@ set(vod_src
src/model/SubmitAIVideoCategoryJobResult.cc
src/model/DescribeRefreshTasksRequest.cc
src/model/DescribeRefreshTasksResult.cc
src/model/DeleteWatermarkRequest.cc
src/model/DeleteWatermarkResult.cc
src/model/UpdateCategoryRequest.cc
src/model/UpdateCategoryResult.cc
src/model/RegisterMediaRequest.cc
src/model/RegisterMediaResult.cc
src/model/ListAIASRJobRequest.cc
src/model/ListAIASRJobResult.cc
src/model/ListAIVideoCensorJobRequest.cc
@@ -238,6 +256,10 @@ set(vod_src
src/model/ListAIJobResult.cc
src/model/GetVideoConfigRequest.cc
src/model/GetVideoConfigResult.cc
src/model/AddWatermarkRequest.cc
src/model/AddWatermarkResult.cc
src/model/ListWatermarkRequest.cc
src/model/ListWatermarkResult.cc
src/model/CreateUploadImageRequest.cc
src/model/CreateUploadImageResult.cc
src/model/UpdateVideoInfoRequest.cc
@@ -248,6 +270,8 @@ set(vod_src
src/model/SearchMediaResult.cc
src/model/DescribePlayTopVideosRequest.cc
src/model/DescribePlayTopVideosResult.cc
src/model/SetDefaultWatermarkRequest.cc
src/model/SetDefaultWatermarkResult.cc
src/model/PushObjectCacheRequest.cc
src/model/PushObjectCacheResult.cc
src/model/AddCategoryRequest.cc
@@ -270,6 +294,10 @@ set(vod_src
src/model/SubmitAIVideoTerrorismRecogJobResult.cc
src/model/SearchEditingProjectRequest.cc
src/model/SearchEditingProjectResult.cc
src/model/GetWatermarkRequest.cc
src/model/GetWatermarkResult.cc
src/model/UpdateWatermarkRequest.cc
src/model/UpdateWatermarkResult.cc
src/model/GetImageInfoRequest.cc
src/model/GetImageInfoResult.cc
src/model/GetMessageCallbackRequest.cc

BIN
vod/include/alibabacloud/vod/.DS_Store vendored
View File

Binary file not shown.

56
vod/include/alibabacloud/vod/VodClient.h
View File

@@ -62,8 +62,12 @@
#include "model/SubmitAIVideoCategoryJobResult.h"
#include "model/DescribeRefreshTasksRequest.h"
#include "model/DescribeRefreshTasksResult.h"
#include "model/DeleteWatermarkRequest.h"
#include "model/DeleteWatermarkResult.h"
#include "model/UpdateCategoryRequest.h"
#include "model/UpdateCategoryResult.h"
#include "model/RegisterMediaRequest.h"
#include "model/RegisterMediaResult.h"
#include "model/ListAIASRJobRequest.h"
#include "model/ListAIASRJobResult.h"
#include "model/ListAIVideoCensorJobRequest.h"
@@ -86,6 +90,10 @@
#include "model/ListAIJobResult.h"
#include "model/GetVideoConfigRequest.h"
#include "model/GetVideoConfigResult.h"
#include "model/AddWatermarkRequest.h"
#include "model/AddWatermarkResult.h"
#include "model/ListWatermarkRequest.h"
#include "model/ListWatermarkResult.h"
#include "model/CreateUploadImageRequest.h"
#include "model/CreateUploadImageResult.h"
#include "model/UpdateVideoInfoRequest.h"
@@ -96,6 +104,8 @@
#include "model/SearchMediaResult.h"
#include "model/DescribePlayTopVideosRequest.h"
#include "model/DescribePlayTopVideosResult.h"
#include "model/SetDefaultWatermarkRequest.h"
#include "model/SetDefaultWatermarkResult.h"
#include "model/PushObjectCacheRequest.h"
#include "model/PushObjectCacheResult.h"
#include "model/AddCategoryRequest.h"
@@ -118,6 +128,10 @@
#include "model/SubmitAIVideoTerrorismRecogJobResult.h"
#include "model/SearchEditingProjectRequest.h"
#include "model/SearchEditingProjectResult.h"
#include "model/GetWatermarkRequest.h"
#include "model/GetWatermarkResult.h"
#include "model/UpdateWatermarkRequest.h"
#include "model/UpdateWatermarkResult.h"
#include "model/GetImageInfoRequest.h"
#include "model/GetImageInfoResult.h"
#include "model/GetMessageCallbackRequest.h"
@@ -241,9 +255,15 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeRefreshTasksResult> DescribeRefreshTasksOutcome;
typedef std::future<DescribeRefreshTasksOutcome> DescribeRefreshTasksOutcomeCallable;
typedef std::function<void(const VodClient*, const Model::DescribeRefreshTasksRequest&, const DescribeRefreshTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRefreshTasksAsyncHandler;
typedef Outcome<Error, Model::DeleteWatermarkResult> DeleteWatermarkOutcome;
typedef std::future<DeleteWatermarkOutcome> DeleteWatermarkOutcomeCallable;
typedef std::function<void(const VodClient*, const Model::DeleteWatermarkRequest&, const DeleteWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteWatermarkAsyncHandler;
typedef Outcome<Error, Model::UpdateCategoryResult> UpdateCategoryOutcome;
typedef std::future<UpdateCategoryOutcome> UpdateCategoryOutcomeCallable;
typedef std::function<void(const VodClient*, const Model::UpdateCategoryRequest&, const UpdateCategoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateCategoryAsyncHandler;
typedef Outcome<Error, Model::RegisterMediaResult> RegisterMediaOutcome;
typedef std::future<RegisterMediaOutcome> RegisterMediaOutcomeCallable;
typedef std::function<void(const VodClient*, const Model::RegisterMediaRequest&, const RegisterMediaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RegisterMediaAsyncHandler;
typedef Outcome<Error, Model::ListAIASRJobResult> ListAIASRJobOutcome;
typedef std::future<ListAIASRJobOutcome> ListAIASRJobOutcomeCallable;
typedef std::function<void(const VodClient*, const Model::ListAIASRJobRequest&, const ListAIASRJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAIASRJobAsyncHandler;
@@ -277,6 +297,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::GetVideoConfigResult> GetVideoConfigOutcome;
typedef std::future<GetVideoConfigOutcome> GetVideoConfigOutcomeCallable;
typedef std::function<void(const VodClient*, const Model::GetVideoConfigRequest&, const GetVideoConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVideoConfigAsyncHandler;
typedef Outcome<Error, Model::AddWatermarkResult> AddWatermarkOutcome;
typedef std::future<AddWatermarkOutcome> AddWatermarkOutcomeCallable;
typedef std::function<void(const VodClient*, const Model::AddWatermarkRequest&, const AddWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddWatermarkAsyncHandler;
typedef Outcome<Error, Model::ListWatermarkResult> ListWatermarkOutcome;
typedef std::future<ListWatermarkOutcome> ListWatermarkOutcomeCallable;
typedef std::function<void(const VodClient*, const Model::ListWatermarkRequest&, const ListWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListWatermarkAsyncHandler;
typedef Outcome<Error, Model::CreateUploadImageResult> CreateUploadImageOutcome;
typedef std::future<CreateUploadImageOutcome> CreateUploadImageOutcomeCallable;
typedef std::function<void(const VodClient*, const Model::CreateUploadImageRequest&, const CreateUploadImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateUploadImageAsyncHandler;
@@ -292,6 +318,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribePlayTopVideosResult> DescribePlayTopVideosOutcome;
typedef std::future<DescribePlayTopVideosOutcome> DescribePlayTopVideosOutcomeCallable;
typedef std::function<void(const VodClient*, const Model::DescribePlayTopVideosRequest&, const DescribePlayTopVideosOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePlayTopVideosAsyncHandler;
typedef Outcome<Error, Model::SetDefaultWatermarkResult> SetDefaultWatermarkOutcome;
typedef std::future<SetDefaultWatermarkOutcome> SetDefaultWatermarkOutcomeCallable;
typedef std::function<void(const VodClient*, const Model::SetDefaultWatermarkRequest&, const SetDefaultWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetDefaultWatermarkAsyncHandler;
typedef Outcome<Error, Model::PushObjectCacheResult> PushObjectCacheOutcome;
typedef std::future<PushObjectCacheOutcome> PushObjectCacheOutcomeCallable;
typedef std::function<void(const VodClient*, const Model::PushObjectCacheRequest&, const PushObjectCacheOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PushObjectCacheAsyncHandler;
@@ -325,6 +354,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::SearchEditingProjectResult> SearchEditingProjectOutcome;
typedef std::future<SearchEditingProjectOutcome> SearchEditingProjectOutcomeCallable;
typedef std::function<void(const VodClient*, const Model::SearchEditingProjectRequest&, const SearchEditingProjectOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchEditingProjectAsyncHandler;
typedef Outcome<Error, Model::GetWatermarkResult> GetWatermarkOutcome;
typedef std::future<GetWatermarkOutcome> GetWatermarkOutcomeCallable;
typedef std::function<void(const VodClient*, const Model::GetWatermarkRequest&, const GetWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetWatermarkAsyncHandler;
typedef Outcome<Error, Model::UpdateWatermarkResult> UpdateWatermarkOutcome;
typedef std::future<UpdateWatermarkOutcome> UpdateWatermarkOutcomeCallable;
typedef std::function<void(const VodClient*, const Model::UpdateWatermarkRequest&, const UpdateWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateWatermarkAsyncHandler;
typedef Outcome<Error, Model::GetImageInfoResult> GetImageInfoOutcome;
typedef std::future<GetImageInfoOutcome> GetImageInfoOutcomeCallable;
typedef std::function<void(const VodClient*, const Model::GetImageInfoRequest&, const GetImageInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetImageInfoAsyncHandler;
@@ -471,9 +506,15 @@ namespace AlibabaCloud
DescribeRefreshTasksOutcome describeRefreshTasks(const Model::DescribeRefreshTasksRequest &request)const;
void describeRefreshTasksAsync(const Model::DescribeRefreshTasksRequest& request, const DescribeRefreshTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRefreshTasksOutcomeCallable describeRefreshTasksCallable(const Model::DescribeRefreshTasksRequest& request) const;
DeleteWatermarkOutcome deleteWatermark(const Model::DeleteWatermarkRequest &request)const;
void deleteWatermarkAsync(const Model::DeleteWatermarkRequest& request, const DeleteWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteWatermarkOutcomeCallable deleteWatermarkCallable(const Model::DeleteWatermarkRequest& request) const;
UpdateCategoryOutcome updateCategory(const Model::UpdateCategoryRequest &request)const;
void updateCategoryAsync(const Model::UpdateCategoryRequest& request, const UpdateCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateCategoryOutcomeCallable updateCategoryCallable(const Model::UpdateCategoryRequest& request) const;
RegisterMediaOutcome registerMedia(const Model::RegisterMediaRequest &request)const;
void registerMediaAsync(const Model::RegisterMediaRequest& request, const RegisterMediaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RegisterMediaOutcomeCallable registerMediaCallable(const Model::RegisterMediaRequest& request) const;
ListAIASRJobOutcome listAIASRJob(const Model::ListAIASRJobRequest &request)const;
void listAIASRJobAsync(const Model::ListAIASRJobRequest& request, const ListAIASRJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListAIASRJobOutcomeCallable listAIASRJobCallable(const Model::ListAIASRJobRequest& request) const;
@@ -507,6 +548,12 @@ namespace AlibabaCloud
GetVideoConfigOutcome getVideoConfig(const Model::GetVideoConfigRequest &request)const;
void getVideoConfigAsync(const Model::GetVideoConfigRequest& request, const GetVideoConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetVideoConfigOutcomeCallable getVideoConfigCallable(const Model::GetVideoConfigRequest& request) const;
AddWatermarkOutcome addWatermark(const Model::AddWatermarkRequest &request)const;
void addWatermarkAsync(const Model::AddWatermarkRequest& request, const AddWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddWatermarkOutcomeCallable addWatermarkCallable(const Model::AddWatermarkRequest& request) const;
ListWatermarkOutcome listWatermark(const Model::ListWatermarkRequest &request)const;
void listWatermarkAsync(const Model::ListWatermarkRequest& request, const ListWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListWatermarkOutcomeCallable listWatermarkCallable(const Model::ListWatermarkRequest& request) const;
CreateUploadImageOutcome createUploadImage(const Model::CreateUploadImageRequest &request)const;
void createUploadImageAsync(const Model::CreateUploadImageRequest& request, const CreateUploadImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateUploadImageOutcomeCallable createUploadImageCallable(const Model::CreateUploadImageRequest& request) const;
@@ -522,6 +569,9 @@ namespace AlibabaCloud
DescribePlayTopVideosOutcome describePlayTopVideos(const Model::DescribePlayTopVideosRequest &request)const;
void describePlayTopVideosAsync(const Model::DescribePlayTopVideosRequest& request, const DescribePlayTopVideosAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribePlayTopVideosOutcomeCallable describePlayTopVideosCallable(const Model::DescribePlayTopVideosRequest& request) const;
SetDefaultWatermarkOutcome setDefaultWatermark(const Model::SetDefaultWatermarkRequest &request)const;
void setDefaultWatermarkAsync(const Model::SetDefaultWatermarkRequest& request, const SetDefaultWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetDefaultWatermarkOutcomeCallable setDefaultWatermarkCallable(const Model::SetDefaultWatermarkRequest& request) const;
PushObjectCacheOutcome pushObjectCache(const Model::PushObjectCacheRequest &request)const;
void pushObjectCacheAsync(const Model::PushObjectCacheRequest& request, const PushObjectCacheAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
PushObjectCacheOutcomeCallable pushObjectCacheCallable(const Model::PushObjectCacheRequest& request) const;
@@ -555,6 +605,12 @@ namespace AlibabaCloud
SearchEditingProjectOutcome searchEditingProject(const Model::SearchEditingProjectRequest &request)const;
void searchEditingProjectAsync(const Model::SearchEditingProjectRequest& request, const SearchEditingProjectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SearchEditingProjectOutcomeCallable searchEditingProjectCallable(const Model::SearchEditingProjectRequest& request) const;
GetWatermarkOutcome getWatermark(const Model::GetWatermarkRequest &request)const;
void getWatermarkAsync(const Model::GetWatermarkRequest& request, const GetWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetWatermarkOutcomeCallable getWatermarkCallable(const Model::GetWatermarkRequest& request) const;
UpdateWatermarkOutcome updateWatermark(const Model::UpdateWatermarkRequest &request)const;
void updateWatermarkAsync(const Model::UpdateWatermarkRequest& request, const UpdateWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateWatermarkOutcomeCallable updateWatermarkCallable(const Model::UpdateWatermarkRequest& request) const;
GetImageInfoOutcome getImageInfo(const Model::GetImageInfoRequest &request)const;
void getImageInfoAsync(const Model::GetImageInfoRequest& request, const GetImageInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetImageInfoOutcomeCallable getImageInfoCallable(const Model::GetImageInfoRequest& request) const;

69
vod/include/alibabacloud/vod/model/AddWatermarkRequest.h Executable 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_VOD_MODEL_ADDWATERMARKREQUEST_H_
#define ALIBABACLOUD_VOD_MODEL_ADDWATERMARKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT AddWatermarkRequest : public RpcServiceRequest
{
public:
AddWatermarkRequest();
~AddWatermarkRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getName()const;
void setName(const std::string& name);
std::string getFileUrl()const;
void setFileUrl(const std::string& fileUrl);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getType()const;
void setType(const std::string& type);
std::string getWatermarkConfig()const;
void setWatermarkConfig(const std::string& watermarkConfig);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string name_;
std::string fileUrl_;
long ownerId_;
std::string type_;
std::string watermarkConfig_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_ADDWATERMARKREQUEST_H_

61
vod/include/alibabacloud/vod/model/AddWatermarkResult.h Executable 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_VOD_MODEL_ADDWATERMARKRESULT_H_
#define ALIBABACLOUD_VOD_MODEL_ADDWATERMARKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT AddWatermarkResult : public ServiceResult
{
public:
struct WatermarkInfo
{
std::string isDefault;
std::string fileUrl;
std::string type;
std::string watermarkId;
std::string creationTime;
std::string watermarkConfig;
std::string name;
};
AddWatermarkResult();
explicit AddWatermarkResult(const std::string &payload);
~AddWatermarkResult();
WatermarkInfo getWatermarkInfo()const;
protected:
void parse(const std::string &payload);
private:
WatermarkInfo watermarkInfo_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_ADDWATERMARKRESULT_H_

1
vod/include/alibabacloud/vod/model/DeleteMezzaninesRequest.h
View File

@@ -50,7 +50,6 @@ namespace AlibabaCloud
long resourceOwnerId_;
std::string resourceOwnerAccount_;
bool force_;
long resourceRealOwnerId_;
long ownerId_;
std::string videoIds_;

60
vod/include/alibabacloud/vod/model/DeleteWatermarkRequest.h Executable 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_VOD_MODEL_DELETEWATERMARKREQUEST_H_
#define ALIBABACLOUD_VOD_MODEL_DELETEWATERMARKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT DeleteWatermarkRequest : public RpcServiceRequest
{
public:
DeleteWatermarkRequest();
~DeleteWatermarkRequest();
std::string getWatermarkId()const;
void setWatermarkId(const std::string& watermarkId);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string watermarkId_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_DELETEWATERMARKREQUEST_H_

49
vod/include/alibabacloud/vod/model/DeleteWatermarkResult.h Executable file
View File

@@ -0,0 +1,49 @@
/*
* 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_VOD_MODEL_DELETEWATERMARKRESULT_H_
#define ALIBABACLOUD_VOD_MODEL_DELETEWATERMARKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT DeleteWatermarkResult : public ServiceResult
{
public:
DeleteWatermarkResult();
explicit DeleteWatermarkResult(const std::string &payload);
~DeleteWatermarkResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_DELETEWATERMARKRESULT_H_

3
vod/include/alibabacloud/vod/model/GetVideoListRequest.h
View File

@@ -55,6 +55,8 @@ namespace AlibabaCloud
void setOwnerId(long ownerId);
std::string getStatus()const;
void setStatus(const std::string& status);
std::string getStorageLocation()const;
void setStorageLocation(const std::string& storageLocation);
private:
long resourceOwnerId_;
@@ -67,6 +69,7 @@ namespace AlibabaCloud
std::string startTime_;
long ownerId_;
std::string status_;
std::string storageLocation_;
};
}

1
vod/include/alibabacloud/vod/model/GetVideoListResult.h
View File

@@ -47,6 +47,7 @@ namespace AlibabaCloud
std::string cateName;
std::string creationTime;
std::string coverURL;
std::string storageLocation;
std::vector<std::string> snapshots;
std::string tags;
};

60
vod/include/alibabacloud/vod/model/GetWatermarkRequest.h Executable 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_VOD_MODEL_GETWATERMARKREQUEST_H_
#define ALIBABACLOUD_VOD_MODEL_GETWATERMARKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT GetWatermarkRequest : public RpcServiceRequest
{
public:
GetWatermarkRequest();
~GetWatermarkRequest();
std::string getWatermarkId()const;
void setWatermarkId(const std::string& watermarkId);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string watermarkId_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_GETWATERMARKREQUEST_H_

61
vod/include/alibabacloud/vod/model/GetWatermarkResult.h Executable 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_VOD_MODEL_GETWATERMARKRESULT_H_
#define ALIBABACLOUD_VOD_MODEL_GETWATERMARKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT GetWatermarkResult : public ServiceResult
{
public:
struct WatermarkInfo
{
std::string isDefault;
std::string fileUrl;
std::string type;
std::string watermarkId;
std::string creationTime;
std::string watermarkConfig;
std::string name;
};
GetWatermarkResult();
explicit GetWatermarkResult(const std::string &payload);
~GetWatermarkResult();
WatermarkInfo getWatermarkInfo()const;
protected:
void parse(const std::string &payload);
private:
WatermarkInfo watermarkInfo_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_GETWATERMARKRESULT_H_

57
vod/include/alibabacloud/vod/model/ListWatermarkRequest.h Executable 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_VOD_MODEL_LISTWATERMARKREQUEST_H_
#define ALIBABACLOUD_VOD_MODEL_LISTWATERMARKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT ListWatermarkRequest : public RpcServiceRequest
{
public:
ListWatermarkRequest();
~ListWatermarkRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
long resourceOwnerId_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_LISTWATERMARKREQUEST_H_

61
vod/include/alibabacloud/vod/model/ListWatermarkResult.h Executable 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_VOD_MODEL_LISTWATERMARKRESULT_H_
#define ALIBABACLOUD_VOD_MODEL_LISTWATERMARKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT ListWatermarkResult : public ServiceResult
{
public:
struct WatermarkInfo
{
std::string isDefault;
std::string fileUrl;
std::string type;
std::string watermarkId;
std::string creationTime;
std::string watermarkConfig;
std::string name;
};
ListWatermarkResult();
explicit ListWatermarkResult(const std::string &payload);
~ListWatermarkResult();
std::vector<WatermarkInfo> getWatermarkInfos()const;
protected:
void parse(const std::string &payload);
private:
std::vector<WatermarkInfo> watermarkInfos_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_LISTWATERMARKRESULT_H_

69
vod/include/alibabacloud/vod/model/RegisterMediaRequest.h Executable 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_VOD_MODEL_REGISTERMEDIAREQUEST_H_
#define ALIBABACLOUD_VOD_MODEL_REGISTERMEDIAREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT RegisterMediaRequest : public RpcServiceRequest
{
public:
RegisterMediaRequest();
~RegisterMediaRequest();
std::string getUserData()const;
void setUserData(const std::string& userData);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getTemplateGroupId()const;
void setTemplateGroupId(const std::string& templateGroupId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getRegisterMetadatas()const;
void setRegisterMetadatas(const std::string& registerMetadatas);
std::string getWorkFlowId()const;
void setWorkFlowId(const std::string& workFlowId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string userData_;
long resourceOwnerId_;
std::string templateGroupId_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string registerMetadatas_;
std::string workFlowId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_REGISTERMEDIAREQUEST_H_

59
vod/include/alibabacloud/vod/model/RegisterMediaResult.h Executable file
View File

@@ -0,0 +1,59 @@
/*
* 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_VOD_MODEL_REGISTERMEDIARESULT_H_
#define ALIBABACLOUD_VOD_MODEL_REGISTERMEDIARESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT RegisterMediaResult : public ServiceResult
{
public:
struct RegisteredMedia
{
std::string fileURL;
std::string mediaId;
bool newRegister;
};
RegisterMediaResult();
explicit RegisterMediaResult(const std::string &payload);
~RegisterMediaResult();
std::vector<std::string> getFailedFileURLs()const;
std::vector<RegisteredMedia> getRegisteredMediaList()const;
protected:
void parse(const std::string &payload);
private:
std::vector<std::string> failedFileURLs_;
std::vector<RegisteredMedia> registeredMediaList_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_REGISTERMEDIARESULT_H_

18
vod/include/alibabacloud/vod/model/SearchMediaResult.h
View File

@@ -81,11 +81,29 @@ namespace AlibabaCloud
std::string tags;
std::string audioId;
};
struct Image
{
std::string ext;
std::string status;
std::string description;
std::string title;
std::string modificationTime;
long cateId;
std::string cateName;
std::string uRL;
std::string type;
std::string imageId;
std::string creationTime;
std::string regionId;
std::string storageLocation;
std::string tags;
};
std::string mediaId;
Video video;
std::string creationTime;
std::string mediaType;
Audio audio;
Image image;
};

60
vod/include/alibabacloud/vod/model/SetDefaultWatermarkRequest.h Executable 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_VOD_MODEL_SETDEFAULTWATERMARKREQUEST_H_
#define ALIBABACLOUD_VOD_MODEL_SETDEFAULTWATERMARKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT SetDefaultWatermarkRequest : public RpcServiceRequest
{
public:
SetDefaultWatermarkRequest();
~SetDefaultWatermarkRequest();
std::string getWatermarkId()const;
void setWatermarkId(const std::string& watermarkId);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string watermarkId_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_SETDEFAULTWATERMARKREQUEST_H_

49
vod/include/alibabacloud/vod/model/SetDefaultWatermarkResult.h Executable file
View File

@@ -0,0 +1,49 @@
/*
* 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_VOD_MODEL_SETDEFAULTWATERMARKRESULT_H_
#define ALIBABACLOUD_VOD_MODEL_SETDEFAULTWATERMARKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT SetDefaultWatermarkResult : public ServiceResult
{
public:
SetDefaultWatermarkResult();
explicit SetDefaultWatermarkResult(const std::string &payload);
~SetDefaultWatermarkResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_SETDEFAULTWATERMARKRESULT_H_

3
vod/include/alibabacloud/vod/model/SubmitTranscodeJobsRequest.h
View File

@@ -43,6 +43,8 @@ namespace AlibabaCloud
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getVideoId()const;
void setVideoId(const std::string& videoId);
std::string getOverrideParams()const;
void setOverrideParams(const std::string& overrideParams);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getEncryptConfig()const;
@@ -57,6 +59,7 @@ namespace AlibabaCloud
std::string templateGroupId_;
std::string resourceOwnerAccount_;
std::string videoId_;
std::string overrideParams_;
long ownerId_;
std::string encryptConfig_;
std::string accessKeyId_;

66
vod/include/alibabacloud/vod/model/UpdateWatermarkRequest.h Executable 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_VOD_MODEL_UPDATEWATERMARKREQUEST_H_
#define ALIBABACLOUD_VOD_MODEL_UPDATEWATERMARKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT UpdateWatermarkRequest : public RpcServiceRequest
{
public:
UpdateWatermarkRequest();
~UpdateWatermarkRequest();
std::string getWatermarkId()const;
void setWatermarkId(const std::string& watermarkId);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getName()const;
void setName(const std::string& name);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getWatermarkConfig()const;
void setWatermarkConfig(const std::string& watermarkConfig);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string watermarkId_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string name_;
long ownerId_;
std::string watermarkConfig_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_UPDATEWATERMARKREQUEST_H_

61
vod/include/alibabacloud/vod/model/UpdateWatermarkResult.h Executable 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_VOD_MODEL_UPDATEWATERMARKRESULT_H_
#define ALIBABACLOUD_VOD_MODEL_UPDATEWATERMARKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vod/VodExport.h>
namespace AlibabaCloud
{
namespace Vod
{
namespace Model
{
class ALIBABACLOUD_VOD_EXPORT UpdateWatermarkResult : public ServiceResult
{
public:
struct WatermarkInfo
{
std::string isDefault;
std::string fileUrl;
std::string type;
std::string watermarkId;
std::string creationTime;
std::string watermarkConfig;
std::string name;
};
UpdateWatermarkResult();
explicit UpdateWatermarkResult(const std::string &payload);
~UpdateWatermarkResult();
WatermarkInfo getWatermarkInfo()const;
protected:
void parse(const std::string &payload);
private:
WatermarkInfo watermarkInfo_;
};
}
}
}
#endif // !ALIBABACLOUD_VOD_MODEL_UPDATEWATERMARKRESULT_H_

BIN
vod/src/.DS_Store vendored
View File

Binary file not shown.

253
vod/src/VodClient.cc
View File

@@ -771,6 +771,42 @@ VodClient::DescribeRefreshTasksOutcomeCallable VodClient::describeRefreshTasksCa
return task->get_future();
}
VodClient::DeleteWatermarkOutcome VodClient::deleteWatermark(const DeleteWatermarkRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteWatermarkOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteWatermarkOutcome(DeleteWatermarkResult(outcome.result()));
else
return DeleteWatermarkOutcome(outcome.error());
}
void VodClient::deleteWatermarkAsync(const DeleteWatermarkRequest& request, const DeleteWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteWatermark(request), context);
};
asyncExecute(new Runnable(fn));
}
VodClient::DeleteWatermarkOutcomeCallable VodClient::deleteWatermarkCallable(const DeleteWatermarkRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteWatermarkOutcome()>>(
[this, request]()
{
return this->deleteWatermark(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VodClient::UpdateCategoryOutcome VodClient::updateCategory(const UpdateCategoryRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -807,6 +843,42 @@ VodClient::UpdateCategoryOutcomeCallable VodClient::updateCategoryCallable(const
return task->get_future();
}
VodClient::RegisterMediaOutcome VodClient::registerMedia(const RegisterMediaRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RegisterMediaOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RegisterMediaOutcome(RegisterMediaResult(outcome.result()));
else
return RegisterMediaOutcome(outcome.error());
}
void VodClient::registerMediaAsync(const RegisterMediaRequest& request, const RegisterMediaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, registerMedia(request), context);
};
asyncExecute(new Runnable(fn));
}
VodClient::RegisterMediaOutcomeCallable VodClient::registerMediaCallable(const RegisterMediaRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RegisterMediaOutcome()>>(
[this, request]()
{
return this->registerMedia(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VodClient::ListAIASRJobOutcome VodClient::listAIASRJob(const ListAIASRJobRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -878,6 +950,7 @@ VodClient::ListAIVideoCensorJobOutcomeCallable VodClient::listAIVideoCensorJobCa
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VodClient::DescribeRefreshQuotaOutcome VodClient::describeRefreshQuota(const DescribeRefreshQuotaRequest &request) const
{
@@ -1203,6 +1276,78 @@ VodClient::GetVideoConfigOutcomeCallable VodClient::getVideoConfigCallable(const
return task->get_future();
}
VodClient::AddWatermarkOutcome VodClient::addWatermark(const AddWatermarkRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AddWatermarkOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AddWatermarkOutcome(AddWatermarkResult(outcome.result()));
else
return AddWatermarkOutcome(outcome.error());
}
void VodClient::addWatermarkAsync(const AddWatermarkRequest& request, const AddWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, addWatermark(request), context);
};
asyncExecute(new Runnable(fn));
}
VodClient::AddWatermarkOutcomeCallable VodClient::addWatermarkCallable(const AddWatermarkRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AddWatermarkOutcome()>>(
[this, request]()
{
return this->addWatermark(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VodClient::ListWatermarkOutcome VodClient::listWatermark(const ListWatermarkRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListWatermarkOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListWatermarkOutcome(ListWatermarkResult(outcome.result()));
else
return ListWatermarkOutcome(outcome.error());
}
void VodClient::listWatermarkAsync(const ListWatermarkRequest& request, const ListWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listWatermark(request), context);
};
asyncExecute(new Runnable(fn));
}
VodClient::ListWatermarkOutcomeCallable VodClient::listWatermarkCallable(const ListWatermarkRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListWatermarkOutcome()>>(
[this, request]()
{
return this->listWatermark(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VodClient::CreateUploadImageOutcome VodClient::createUploadImage(const CreateUploadImageRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1383,6 +1528,42 @@ VodClient::DescribePlayTopVideosOutcomeCallable VodClient::describePlayTopVideos
return task->get_future();
}
VodClient::SetDefaultWatermarkOutcome VodClient::setDefaultWatermark(const SetDefaultWatermarkRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SetDefaultWatermarkOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SetDefaultWatermarkOutcome(SetDefaultWatermarkResult(outcome.result()));
else
return SetDefaultWatermarkOutcome(outcome.error());
}
void VodClient::setDefaultWatermarkAsync(const SetDefaultWatermarkRequest& request, const SetDefaultWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, setDefaultWatermark(request), context);
};
asyncExecute(new Runnable(fn));
}
VodClient::SetDefaultWatermarkOutcomeCallable VodClient::setDefaultWatermarkCallable(const SetDefaultWatermarkRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SetDefaultWatermarkOutcome()>>(
[this, request]()
{
return this->setDefaultWatermark(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VodClient::PushObjectCacheOutcome VodClient::pushObjectCache(const PushObjectCacheRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1779,6 +1960,78 @@ VodClient::SearchEditingProjectOutcomeCallable VodClient::searchEditingProjectCa
return task->get_future();
}
VodClient::GetWatermarkOutcome VodClient::getWatermark(const GetWatermarkRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetWatermarkOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetWatermarkOutcome(GetWatermarkResult(outcome.result()));
else
return GetWatermarkOutcome(outcome.error());
}
void VodClient::getWatermarkAsync(const GetWatermarkRequest& request, const GetWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getWatermark(request), context);
};
asyncExecute(new Runnable(fn));
}
VodClient::GetWatermarkOutcomeCallable VodClient::getWatermarkCallable(const GetWatermarkRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetWatermarkOutcome()>>(
[this, request]()
{
return this->getWatermark(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VodClient::UpdateWatermarkOutcome VodClient::updateWatermark(const UpdateWatermarkRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateWatermarkOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateWatermarkOutcome(UpdateWatermarkResult(outcome.result()));
else
return UpdateWatermarkOutcome(outcome.error());
}
void VodClient::updateWatermarkAsync(const UpdateWatermarkRequest& request, const UpdateWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateWatermark(request), context);
};
asyncExecute(new Runnable(fn));
}
VodClient::UpdateWatermarkOutcomeCallable VodClient::updateWatermarkCallable(const UpdateWatermarkRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateWatermarkOutcome()>>(
[this, request]()
{
return this->updateWatermark(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VodClient::GetImageInfoOutcome VodClient::getImageInfo(const GetImageInfoRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

115
vod/src/model/AddWatermarkRequest.cc Executable file
View File

@@ -0,0 +1,115 @@
/*
* 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/vod/model/AddWatermarkRequest.h>
using AlibabaCloud::Vod::Model::AddWatermarkRequest;
AddWatermarkRequest::AddWatermarkRequest() :
RpcServiceRequest("vod", "2017-03-21", "AddWatermark")
{}
AddWatermarkRequest::~AddWatermarkRequest()
{}
long AddWatermarkRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void AddWatermarkRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string AddWatermarkRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void AddWatermarkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string AddWatermarkRequest::getName()const
{
return name_;
}
void AddWatermarkRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}
std::string AddWatermarkRequest::getFileUrl()const
{
return fileUrl_;
}
void AddWatermarkRequest::setFileUrl(const std::string& fileUrl)
{
fileUrl_ = fileUrl;
setParameter("FileUrl", fileUrl);
}
long AddWatermarkRequest::getOwnerId()const
{
return ownerId_;
}
void AddWatermarkRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string AddWatermarkRequest::getType()const
{
return type_;
}
void AddWatermarkRequest::setType(const std::string& type)
{
type_ = type;
setParameter("Type", type);
}
std::string AddWatermarkRequest::getWatermarkConfig()const
{
return watermarkConfig_;
}
void AddWatermarkRequest::setWatermarkConfig(const std::string& watermarkConfig)
{
watermarkConfig_ = watermarkConfig;
setParameter("WatermarkConfig", watermarkConfig);
}
std::string AddWatermarkRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void AddWatermarkRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

65
vod/src/model/AddWatermarkResult.cc Executable 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/vod/model/AddWatermarkResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vod;
using namespace AlibabaCloud::Vod::Model;
AddWatermarkResult::AddWatermarkResult() :
ServiceResult()
{}
AddWatermarkResult::AddWatermarkResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
AddWatermarkResult::~AddWatermarkResult()
{}
void AddWatermarkResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto watermarkInfoNode = value["WatermarkInfo"];
if(!watermarkInfoNode["CreationTime"].isNull())
watermarkInfo_.creationTime = watermarkInfoNode["CreationTime"].asString();
if(!watermarkInfoNode["Type"].isNull())
watermarkInfo_.type = watermarkInfoNode["Type"].asString();
if(!watermarkInfoNode["IsDefault"].isNull())
watermarkInfo_.isDefault = watermarkInfoNode["IsDefault"].asString();
if(!watermarkInfoNode["WatermarkId"].isNull())
watermarkInfo_.watermarkId = watermarkInfoNode["WatermarkId"].asString();
if(!watermarkInfoNode["Name"].isNull())
watermarkInfo_.name = watermarkInfoNode["Name"].asString();
if(!watermarkInfoNode["FileUrl"].isNull())
watermarkInfo_.fileUrl = watermarkInfoNode["FileUrl"].asString();
if(!watermarkInfoNode["WatermarkConfig"].isNull())
watermarkInfo_.watermarkConfig = watermarkInfoNode["WatermarkConfig"].asString();
}
AddWatermarkResult::WatermarkInfo AddWatermarkResult::getWatermarkInfo()const
{
return watermarkInfo_;
}

82
vod/src/model/DeleteWatermarkRequest.cc Executable file
View File

@@ -0,0 +1,82 @@
/*
* 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/vod/model/DeleteWatermarkRequest.h>
using AlibabaCloud::Vod::Model::DeleteWatermarkRequest;
DeleteWatermarkRequest::DeleteWatermarkRequest() :
RpcServiceRequest("vod", "2017-03-21", "DeleteWatermark")
{}
DeleteWatermarkRequest::~DeleteWatermarkRequest()
{}
std::string DeleteWatermarkRequest::getWatermarkId()const
{
return watermarkId_;
}
void DeleteWatermarkRequest::setWatermarkId(const std::string& watermarkId)
{
watermarkId_ = watermarkId;
setParameter("WatermarkId", watermarkId);
}
long DeleteWatermarkRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteWatermarkRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteWatermarkRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteWatermarkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long DeleteWatermarkRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteWatermarkRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteWatermarkRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteWatermarkRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

45
vod/src/model/DeleteWatermarkResult.cc Executable file
View File

@@ -0,0 +1,45 @@
/*
* 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/vod/model/DeleteWatermarkResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vod;
using namespace AlibabaCloud::Vod::Model;
DeleteWatermarkResult::DeleteWatermarkResult() :
ServiceResult()
{}
DeleteWatermarkResult::DeleteWatermarkResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteWatermarkResult::~DeleteWatermarkResult()
{}
void DeleteWatermarkResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

11
vod/src/model/GetVideoListRequest.cc
View File

@@ -135,3 +135,14 @@ void GetVideoListRequest::setStatus(const std::string& status)
setParameter("Status", status);
}
std::string GetVideoListRequest::getStorageLocation()const
{
return storageLocation_;
}
void GetVideoListRequest::setStorageLocation(const std::string& storageLocation)
{
storageLocation_ = storageLocation;
setParameter("StorageLocation", storageLocation);
}

2
vod/src/model/GetVideoListResult.cc
View File

@@ -72,6 +72,8 @@ void GetVideoListResult::parse(const std::string &payload)
videoListObject.cateId = std::stol(value["CateId"].asString());
if(!value["CateName"].isNull())
videoListObject.cateName = value["CateName"].asString();
if(!value["StorageLocation"].isNull())
videoListObject.storageLocation = value["StorageLocation"].asString();
auto allSnapshots = value["Snapshots"]["Snapshot"];
for (auto value : allSnapshots)
videoListObject.snapshots.push_back(value.asString());

82
vod/src/model/GetWatermarkRequest.cc Executable file
View File

@@ -0,0 +1,82 @@
/*
* 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/vod/model/GetWatermarkRequest.h>
using AlibabaCloud::Vod::Model::GetWatermarkRequest;
GetWatermarkRequest::GetWatermarkRequest() :
RpcServiceRequest("vod", "2017-03-21", "GetWatermark")
{}
GetWatermarkRequest::~GetWatermarkRequest()
{}
std::string GetWatermarkRequest::getWatermarkId()const
{
return watermarkId_;
}
void GetWatermarkRequest::setWatermarkId(const std::string& watermarkId)
{
watermarkId_ = watermarkId;
setParameter("WatermarkId", watermarkId);
}
long GetWatermarkRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void GetWatermarkRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string GetWatermarkRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void GetWatermarkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long GetWatermarkRequest::getOwnerId()const
{
return ownerId_;
}
void GetWatermarkRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string GetWatermarkRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void GetWatermarkRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

65
vod/src/model/GetWatermarkResult.cc Executable 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/vod/model/GetWatermarkResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vod;
using namespace AlibabaCloud::Vod::Model;
GetWatermarkResult::GetWatermarkResult() :
ServiceResult()
{}
GetWatermarkResult::GetWatermarkResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetWatermarkResult::~GetWatermarkResult()
{}
void GetWatermarkResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto watermarkInfoNode = value["WatermarkInfo"];
if(!watermarkInfoNode["CreationTime"].isNull())
watermarkInfo_.creationTime = watermarkInfoNode["CreationTime"].asString();
if(!watermarkInfoNode["Type"].isNull())
watermarkInfo_.type = watermarkInfoNode["Type"].asString();
if(!watermarkInfoNode["IsDefault"].isNull())
watermarkInfo_.isDefault = watermarkInfoNode["IsDefault"].asString();
if(!watermarkInfoNode["WatermarkId"].isNull())
watermarkInfo_.watermarkId = watermarkInfoNode["WatermarkId"].asString();
if(!watermarkInfoNode["Name"].isNull())
watermarkInfo_.name = watermarkInfoNode["Name"].asString();
if(!watermarkInfoNode["FileUrl"].isNull())
watermarkInfo_.fileUrl = watermarkInfoNode["FileUrl"].asString();
if(!watermarkInfoNode["WatermarkConfig"].isNull())
watermarkInfo_.watermarkConfig = watermarkInfoNode["WatermarkConfig"].asString();
}
GetWatermarkResult::WatermarkInfo GetWatermarkResult::getWatermarkInfo()const
{
return watermarkInfo_;
}

71
vod/src/model/ListWatermarkRequest.cc Executable file
View File

@@ -0,0 +1,71 @@
/*
* 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/vod/model/ListWatermarkRequest.h>
using AlibabaCloud::Vod::Model::ListWatermarkRequest;
ListWatermarkRequest::ListWatermarkRequest() :
RpcServiceRequest("vod", "2017-03-21", "ListWatermark")
{}
ListWatermarkRequest::~ListWatermarkRequest()
{}
long ListWatermarkRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void ListWatermarkRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string ListWatermarkRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void ListWatermarkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long ListWatermarkRequest::getOwnerId()const
{
return ownerId_;
}
void ListWatermarkRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string ListWatermarkRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void ListWatermarkRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

70
vod/src/model/ListWatermarkResult.cc Executable 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/vod/model/ListWatermarkResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vod;
using namespace AlibabaCloud::Vod::Model;
ListWatermarkResult::ListWatermarkResult() :
ServiceResult()
{}
ListWatermarkResult::ListWatermarkResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListWatermarkResult::~ListWatermarkResult()
{}
void ListWatermarkResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allWatermarkInfos = value["WatermarkInfos"]["WatermarkInfo"];
for (auto value : allWatermarkInfos)
{
WatermarkInfo watermarkInfosObject;
if(!value["CreationTime"].isNull())
watermarkInfosObject.creationTime = value["CreationTime"].asString();
if(!value["Type"].isNull())
watermarkInfosObject.type = value["Type"].asString();
if(!value["IsDefault"].isNull())
watermarkInfosObject.isDefault = value["IsDefault"].asString();
if(!value["WatermarkId"].isNull())
watermarkInfosObject.watermarkId = value["WatermarkId"].asString();
if(!value["Name"].isNull())
watermarkInfosObject.name = value["Name"].asString();
if(!value["FileUrl"].isNull())
watermarkInfosObject.fileUrl = value["FileUrl"].asString();
if(!value["WatermarkConfig"].isNull())
watermarkInfosObject.watermarkConfig = value["WatermarkConfig"].asString();
watermarkInfos_.push_back(watermarkInfosObject);
}
}
std::vector<ListWatermarkResult::WatermarkInfo> ListWatermarkResult::getWatermarkInfos()const
{
return watermarkInfos_;
}

115
vod/src/model/RegisterMediaRequest.cc Executable file
View File

@@ -0,0 +1,115 @@
/*
* 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/vod/model/RegisterMediaRequest.h>
using AlibabaCloud::Vod::Model::RegisterMediaRequest;
RegisterMediaRequest::RegisterMediaRequest() :
RpcServiceRequest("vod", "2017-03-21", "RegisterMedia")
{}
RegisterMediaRequest::~RegisterMediaRequest()
{}
std::string RegisterMediaRequest::getUserData()const
{
return userData_;
}
void RegisterMediaRequest::setUserData(const std::string& userData)
{
userData_ = userData;
setParameter("UserData", userData);
}
long RegisterMediaRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void RegisterMediaRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string RegisterMediaRequest::getTemplateGroupId()const
{
return templateGroupId_;
}
void RegisterMediaRequest::setTemplateGroupId(const std::string& templateGroupId)
{
templateGroupId_ = templateGroupId;
setParameter("TemplateGroupId", templateGroupId);
}
std::string RegisterMediaRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void RegisterMediaRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long RegisterMediaRequest::getOwnerId()const
{
return ownerId_;
}
void RegisterMediaRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string RegisterMediaRequest::getRegisterMetadatas()const
{
return registerMetadatas_;
}
void RegisterMediaRequest::setRegisterMetadatas(const std::string& registerMetadatas)
{
registerMetadatas_ = registerMetadatas;
setParameter("RegisterMetadatas", registerMetadatas);
}
std::string RegisterMediaRequest::getWorkFlowId()const
{
return workFlowId_;
}
void RegisterMediaRequest::setWorkFlowId(const std::string& workFlowId)
{
workFlowId_ = workFlowId;
setParameter("WorkFlowId", workFlowId);
}
std::string RegisterMediaRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void RegisterMediaRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

70
vod/src/model/RegisterMediaResult.cc Executable 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/vod/model/RegisterMediaResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vod;
using namespace AlibabaCloud::Vod::Model;
RegisterMediaResult::RegisterMediaResult() :
ServiceResult()
{}
RegisterMediaResult::RegisterMediaResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RegisterMediaResult::~RegisterMediaResult()
{}
void RegisterMediaResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allRegisteredMediaList = value["RegisteredMediaList"]["RegisteredMedia"];
for (auto value : allRegisteredMediaList)
{
RegisteredMedia registeredMediaListObject;
if(!value["MediaId"].isNull())
registeredMediaListObject.mediaId = value["MediaId"].asString();
if(!value["FileURL"].isNull())
registeredMediaListObject.fileURL = value["FileURL"].asString();
if(!value["NewRegister"].isNull())
registeredMediaListObject.newRegister = value["NewRegister"].asString() == "true";
registeredMediaList_.push_back(registeredMediaListObject);
}
auto allFailedFileURLs = value["FailedFileURLs"]["FileURL"];
for (const auto &item : allFailedFileURLs)
failedFileURLs_.push_back(item.asString());
}
std::vector<std::string> RegisterMediaResult::getFailedFileURLs()const
{
return failedFileURLs_;
}
std::vector<RegisterMediaResult::RegisteredMedia> RegisterMediaResult::getRegisteredMediaList()const
{
return registeredMediaList_;
}

29
vod/src/model/SearchMediaResult.cc
View File

@@ -138,6 +138,35 @@ void SearchMediaResult::parse(const std::string &payload)
auto allSpriteSnapshots2 = audioNode["SpriteSnapshots"]["SpriteSnapshot"];
for (auto value : allSpriteSnapshots2)
mediaListObject.audio.spriteSnapshots2.push_back(value.asString());
auto imageNode = value["Image"];
if(!imageNode["Title"].isNull())
mediaListObject.image.title = imageNode["Title"].asString();
if(!imageNode["ImageId"].isNull())
mediaListObject.image.imageId = imageNode["ImageId"].asString();
if(!imageNode["CateId"].isNull())
mediaListObject.image.cateId = std::stol(imageNode["CateId"].asString());
if(!imageNode["CateName"].isNull())
mediaListObject.image.cateName = imageNode["CateName"].asString();
if(!imageNode["Ext"].isNull())
mediaListObject.image.ext = imageNode["Ext"].asString();
if(!imageNode["CreationTime"].isNull())
mediaListObject.image.creationTime = imageNode["CreationTime"].asString();
if(!imageNode["ModificationTime"].isNull())
mediaListObject.image.modificationTime = imageNode["ModificationTime"].asString();
if(!imageNode["Tags"].isNull())
mediaListObject.image.tags = imageNode["Tags"].asString();
if(!imageNode["Type"].isNull())
mediaListObject.image.type = imageNode["Type"].asString();
if(!imageNode["URL"].isNull())
mediaListObject.image.uRL = imageNode["URL"].asString();
if(!imageNode["Status"].isNull())
mediaListObject.image.status = imageNode["Status"].asString();
if(!imageNode["Description"].isNull())
mediaListObject.image.description = imageNode["Description"].asString();
if(!imageNode["StorageLocation"].isNull())
mediaListObject.image.storageLocation = imageNode["StorageLocation"].asString();
if(!imageNode["RegionId"].isNull())
mediaListObject.image.regionId = imageNode["RegionId"].asString();
mediaList_.push_back(mediaListObject);
}
if(!value["ScrollToken"].isNull())

82
vod/src/model/SetDefaultWatermarkRequest.cc Executable file
View File

@@ -0,0 +1,82 @@
/*
* 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/vod/model/SetDefaultWatermarkRequest.h>
using AlibabaCloud::Vod::Model::SetDefaultWatermarkRequest;
SetDefaultWatermarkRequest::SetDefaultWatermarkRequest() :
RpcServiceRequest("vod", "2017-03-21", "SetDefaultWatermark")
{}
SetDefaultWatermarkRequest::~SetDefaultWatermarkRequest()
{}
std::string SetDefaultWatermarkRequest::getWatermarkId()const
{
return watermarkId_;
}
void SetDefaultWatermarkRequest::setWatermarkId(const std::string& watermarkId)
{
watermarkId_ = watermarkId;
setParameter("WatermarkId", watermarkId);
}
long SetDefaultWatermarkRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void SetDefaultWatermarkRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string SetDefaultWatermarkRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void SetDefaultWatermarkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
long SetDefaultWatermarkRequest::getOwnerId()const
{
return ownerId_;
}
void SetDefaultWatermarkRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string SetDefaultWatermarkRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void SetDefaultWatermarkRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

45
vod/src/model/SetDefaultWatermarkResult.cc Executable file
View File

@@ -0,0 +1,45 @@
/*
* 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/vod/model/SetDefaultWatermarkResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vod;
using namespace AlibabaCloud::Vod::Model;
SetDefaultWatermarkResult::SetDefaultWatermarkResult() :
ServiceResult()
{}
SetDefaultWatermarkResult::SetDefaultWatermarkResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SetDefaultWatermarkResult::~SetDefaultWatermarkResult()
{}
void SetDefaultWatermarkResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

11
vod/src/model/SubmitTranscodeJobsRequest.cc
View File

@@ -69,6 +69,17 @@ void SubmitTranscodeJobsRequest::setVideoId(const std::string& videoId)
setParameter("VideoId", videoId);
}
std::string SubmitTranscodeJobsRequest::getOverrideParams()const
{
return overrideParams_;
}
void SubmitTranscodeJobsRequest::setOverrideParams(const std::string& overrideParams)
{
overrideParams_ = overrideParams;
setParameter("OverrideParams", overrideParams);
}
long SubmitTranscodeJobsRequest::getOwnerId()const
{
return ownerId_;

104
vod/src/model/UpdateWatermarkRequest.cc Executable file
View File

@@ -0,0 +1,104 @@
/*
* 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/vod/model/UpdateWatermarkRequest.h>
using AlibabaCloud::Vod::Model::UpdateWatermarkRequest;
UpdateWatermarkRequest::UpdateWatermarkRequest() :
RpcServiceRequest("vod", "2017-03-21", "UpdateWatermark")
{}
UpdateWatermarkRequest::~UpdateWatermarkRequest()
{}
std::string UpdateWatermarkRequest::getWatermarkId()const
{
return watermarkId_;
}
void UpdateWatermarkRequest::setWatermarkId(const std::string& watermarkId)
{
watermarkId_ = watermarkId;
setParameter("WatermarkId", watermarkId);
}
long UpdateWatermarkRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void UpdateWatermarkRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string UpdateWatermarkRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void UpdateWatermarkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string UpdateWatermarkRequest::getName()const
{
return name_;
}
void UpdateWatermarkRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}
long UpdateWatermarkRequest::getOwnerId()const
{
return ownerId_;
}
void UpdateWatermarkRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string UpdateWatermarkRequest::getWatermarkConfig()const
{
return watermarkConfig_;
}
void UpdateWatermarkRequest::setWatermarkConfig(const std::string& watermarkConfig)
{
watermarkConfig_ = watermarkConfig;
setParameter("WatermarkConfig", watermarkConfig);
}
std::string UpdateWatermarkRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void UpdateWatermarkRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}

65
vod/src/model/UpdateWatermarkResult.cc Executable 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/vod/model/UpdateWatermarkResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Vod;
using namespace AlibabaCloud::Vod::Model;
UpdateWatermarkResult::UpdateWatermarkResult() :
ServiceResult()
{}
UpdateWatermarkResult::UpdateWatermarkResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UpdateWatermarkResult::~UpdateWatermarkResult()
{}
void UpdateWatermarkResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto watermarkInfoNode = value["WatermarkInfo"];
if(!watermarkInfoNode["CreationTime"].isNull())
watermarkInfo_.creationTime = watermarkInfoNode["CreationTime"].asString();
if(!watermarkInfoNode["Type"].isNull())
watermarkInfo_.type = watermarkInfoNode["Type"].asString();
if(!watermarkInfoNode["IsDefault"].isNull())
watermarkInfo_.isDefault = watermarkInfoNode["IsDefault"].asString();
if(!watermarkInfoNode["WatermarkId"].isNull())
watermarkInfo_.watermarkId = watermarkInfoNode["WatermarkId"].asString();
if(!watermarkInfoNode["Name"].isNull())
watermarkInfo_.name = watermarkInfoNode["Name"].asString();
if(!watermarkInfoNode["FileUrl"].isNull())
watermarkInfo_.fileUrl = watermarkInfoNode["FileUrl"].asString();
if(!watermarkInfoNode["WatermarkConfig"].isNull())
watermarkInfo_.watermarkConfig = watermarkInfoNode["WatermarkConfig"].asString();
}
UpdateWatermarkResult::WatermarkInfo UpdateWatermarkResult::getWatermarkInfo()const
{
return watermarkInfo_;
}