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

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