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

Update to support new apis.

Browse Source
This commit is contained in:
sdk-team
2024-06-04 02:36:19 +00:00
parent 886cef155f
commit c8d90808f0
52 changed files with 3923 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

432
live/src/LiveClient.cc
View File

@@ -339,6 +339,78 @@ LiveClient::AddCustomLiveStreamTranscodeOutcomeCallable LiveClient::addCustomLiv
return task->get_future();
}
LiveClient::AddLiveAIProduceRulesOutcome LiveClient::addLiveAIProduceRules(const AddLiveAIProduceRulesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AddLiveAIProduceRulesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AddLiveAIProduceRulesOutcome(AddLiveAIProduceRulesResult(outcome.result()));
else
return AddLiveAIProduceRulesOutcome(outcome.error());
}
void LiveClient::addLiveAIProduceRulesAsync(const AddLiveAIProduceRulesRequest& request, const AddLiveAIProduceRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, addLiveAIProduceRules(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::AddLiveAIProduceRulesOutcomeCallable LiveClient::addLiveAIProduceRulesCallable(const AddLiveAIProduceRulesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AddLiveAIProduceRulesOutcome()>>(
[this, request]()
{
return this->addLiveAIProduceRules(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::AddLiveAISubtitleOutcome LiveClient::addLiveAISubtitle(const AddLiveAISubtitleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AddLiveAISubtitleOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AddLiveAISubtitleOutcome(AddLiveAISubtitleResult(outcome.result()));
else
return AddLiveAISubtitleOutcome(outcome.error());
}
void LiveClient::addLiveAISubtitleAsync(const AddLiveAISubtitleRequest& request, const AddLiveAISubtitleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, addLiveAISubtitle(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::AddLiveAISubtitleOutcomeCallable LiveClient::addLiveAISubtitleCallable(const AddLiveAISubtitleRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AddLiveAISubtitleOutcome()>>(
[this, request]()
{
return this->addLiveAISubtitle(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::AddLiveAppRecordConfigOutcome LiveClient::addLiveAppRecordConfig(const AddLiveAppRecordConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2211,6 +2283,42 @@ LiveClient::CreateRoomRealTimeStreamAddressOutcomeCallable LiveClient::createRoo
return task->get_future();
}
LiveClient::CreateRtcAsrTaskOutcome LiveClient::createRtcAsrTask(const CreateRtcAsrTaskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateRtcAsrTaskOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateRtcAsrTaskOutcome(CreateRtcAsrTaskResult(outcome.result()));
else
return CreateRtcAsrTaskOutcome(outcome.error());
}
void LiveClient::createRtcAsrTaskAsync(const CreateRtcAsrTaskRequest& request, const CreateRtcAsrTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createRtcAsrTask(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::CreateRtcAsrTaskOutcomeCallable LiveClient::createRtcAsrTaskCallable(const CreateRtcAsrTaskRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateRtcAsrTaskOutcome()>>(
[this, request]()
{
return this->createRtcAsrTask(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DeleteCasterOutcome LiveClient::deleteCaster(const DeleteCasterRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2643,6 +2751,78 @@ LiveClient::DeleteEventSubOutcomeCallable LiveClient::deleteEventSubCallable(con
return task->get_future();
}
LiveClient::DeleteLiveAIProduceRulesOutcome LiveClient::deleteLiveAIProduceRules(const DeleteLiveAIProduceRulesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteLiveAIProduceRulesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteLiveAIProduceRulesOutcome(DeleteLiveAIProduceRulesResult(outcome.result()));
else
return DeleteLiveAIProduceRulesOutcome(outcome.error());
}
void LiveClient::deleteLiveAIProduceRulesAsync(const DeleteLiveAIProduceRulesRequest& request, const DeleteLiveAIProduceRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteLiveAIProduceRules(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DeleteLiveAIProduceRulesOutcomeCallable LiveClient::deleteLiveAIProduceRulesCallable(const DeleteLiveAIProduceRulesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteLiveAIProduceRulesOutcome()>>(
[this, request]()
{
return this->deleteLiveAIProduceRules(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DeleteLiveAISubtitleOutcome LiveClient::deleteLiveAISubtitle(const DeleteLiveAISubtitleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteLiveAISubtitleOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteLiveAISubtitleOutcome(DeleteLiveAISubtitleResult(outcome.result()));
else
return DeleteLiveAISubtitleOutcome(outcome.error());
}
void LiveClient::deleteLiveAISubtitleAsync(const DeleteLiveAISubtitleRequest& request, const DeleteLiveAISubtitleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteLiveAISubtitle(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DeleteLiveAISubtitleOutcomeCallable LiveClient::deleteLiveAISubtitleCallable(const DeleteLiveAISubtitleRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteLiveAISubtitleOutcome()>>(
[this, request]()
{
return this->deleteLiveAISubtitle(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DeleteLiveAppRecordConfigOutcome LiveClient::deleteLiveAppRecordConfig(const DeleteLiveAppRecordConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4803,6 +4983,78 @@ LiveClient::DescribeHlsLiveStreamRealTimeBpsDataOutcomeCallable LiveClient::desc
return task->get_future();
}
LiveClient::DescribeLiveAIProduceRulesOutcome LiveClient::describeLiveAIProduceRules(const DescribeLiveAIProduceRulesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeLiveAIProduceRulesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeLiveAIProduceRulesOutcome(DescribeLiveAIProduceRulesResult(outcome.result()));
else
return DescribeLiveAIProduceRulesOutcome(outcome.error());
}
void LiveClient::describeLiveAIProduceRulesAsync(const DescribeLiveAIProduceRulesRequest& request, const DescribeLiveAIProduceRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeLiveAIProduceRules(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DescribeLiveAIProduceRulesOutcomeCallable LiveClient::describeLiveAIProduceRulesCallable(const DescribeLiveAIProduceRulesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeLiveAIProduceRulesOutcome()>>(
[this, request]()
{
return this->describeLiveAIProduceRules(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DescribeLiveAISubtitleOutcome LiveClient::describeLiveAISubtitle(const DescribeLiveAISubtitleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeLiveAISubtitleOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeLiveAISubtitleOutcome(DescribeLiveAISubtitleResult(outcome.result()));
else
return DescribeLiveAISubtitleOutcome(outcome.error());
}
void LiveClient::describeLiveAISubtitleAsync(const DescribeLiveAISubtitleRequest& request, const DescribeLiveAISubtitleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeLiveAISubtitle(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::DescribeLiveAISubtitleOutcomeCallable LiveClient::describeLiveAISubtitleCallable(const DescribeLiveAISubtitleRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeLiveAISubtitleOutcome()>>(
[this, request]()
{
return this->describeLiveAISubtitle(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::DescribeLiveAudioAuditConfigOutcome LiveClient::describeLiveAudioAuditConfig(const DescribeLiveAudioAuditConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -10455,6 +10707,42 @@ LiveClient::ListLiveMessageAppsOutcomeCallable LiveClient::listLiveMessageAppsCa
return task->get_future();
}
LiveClient::ListLiveMessageGroupByPageOutcome LiveClient::listLiveMessageGroupByPage(const ListLiveMessageGroupByPageRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListLiveMessageGroupByPageOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListLiveMessageGroupByPageOutcome(ListLiveMessageGroupByPageResult(outcome.result()));
else
return ListLiveMessageGroupByPageOutcome(outcome.error());
}
void LiveClient::listLiveMessageGroupByPageAsync(const ListLiveMessageGroupByPageRequest& request, const ListLiveMessageGroupByPageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listLiveMessageGroupByPage(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::ListLiveMessageGroupByPageOutcomeCallable LiveClient::listLiveMessageGroupByPageCallable(const ListLiveMessageGroupByPageRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListLiveMessageGroupByPageOutcome()>>(
[this, request]()
{
return this->listLiveMessageGroupByPage(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::ListLiveMessageGroupMessagesOutcome LiveClient::listLiveMessageGroupMessages(const ListLiveMessageGroupMessagesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -11787,6 +12075,42 @@ LiveClient::QueryMessageAppOutcomeCallable LiveClient::queryMessageAppCallable(c
return task->get_future();
}
LiveClient::QueryRtcAsrTasksOutcome LiveClient::queryRtcAsrTasks(const QueryRtcAsrTasksRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return QueryRtcAsrTasksOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return QueryRtcAsrTasksOutcome(QueryRtcAsrTasksResult(outcome.result()));
else
return QueryRtcAsrTasksOutcome(outcome.error());
}
void LiveClient::queryRtcAsrTasksAsync(const QueryRtcAsrTasksRequest& request, const QueryRtcAsrTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, queryRtcAsrTasks(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::QueryRtcAsrTasksOutcomeCallable LiveClient::queryRtcAsrTasksCallable(const QueryRtcAsrTasksRequest &request) const
{
auto task = std::make_shared<std::packaged_task<QueryRtcAsrTasksOutcome()>>(
[this, request]()
{
return this->queryRtcAsrTasks(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::QuerySnapshotCallbackAuthOutcome LiveClient::querySnapshotCallbackAuth(const QuerySnapshotCallbackAuthRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -13443,6 +13767,42 @@ LiveClient::StopPlaylistOutcomeCallable LiveClient::stopPlaylistCallable(const S
return task->get_future();
}
LiveClient::StopRtcAsrTaskOutcome LiveClient::stopRtcAsrTask(const StopRtcAsrTaskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StopRtcAsrTaskOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StopRtcAsrTaskOutcome(StopRtcAsrTaskResult(outcome.result()));
else
return StopRtcAsrTaskOutcome(outcome.error());
}
void LiveClient::stopRtcAsrTaskAsync(const StopRtcAsrTaskRequest& request, const StopRtcAsrTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, stopRtcAsrTask(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::StopRtcAsrTaskOutcomeCallable LiveClient::stopRtcAsrTaskCallable(const StopRtcAsrTaskRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StopRtcAsrTaskOutcome()>>(
[this, request]()
{
return this->stopRtcAsrTask(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::TagLiveResourcesOutcome LiveClient::tagLiveResources(const TagLiveResourcesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -13659,6 +14019,78 @@ LiveClient::UpdateEventSubOutcomeCallable LiveClient::updateEventSubCallable(con
return task->get_future();
}
LiveClient::UpdateLiveAIProduceRulesOutcome LiveClient::updateLiveAIProduceRules(const UpdateLiveAIProduceRulesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateLiveAIProduceRulesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateLiveAIProduceRulesOutcome(UpdateLiveAIProduceRulesResult(outcome.result()));
else
return UpdateLiveAIProduceRulesOutcome(outcome.error());
}
void LiveClient::updateLiveAIProduceRulesAsync(const UpdateLiveAIProduceRulesRequest& request, const UpdateLiveAIProduceRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateLiveAIProduceRules(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::UpdateLiveAIProduceRulesOutcomeCallable LiveClient::updateLiveAIProduceRulesCallable(const UpdateLiveAIProduceRulesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateLiveAIProduceRulesOutcome()>>(
[this, request]()
{
return this->updateLiveAIProduceRules(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::UpdateLiveAISubtitleOutcome LiveClient::updateLiveAISubtitle(const UpdateLiveAISubtitleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateLiveAISubtitleOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateLiveAISubtitleOutcome(UpdateLiveAISubtitleResult(outcome.result()));
else
return UpdateLiveAISubtitleOutcome(outcome.error());
}
void LiveClient::updateLiveAISubtitleAsync(const UpdateLiveAISubtitleRequest& request, const UpdateLiveAISubtitleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateLiveAISubtitle(request), context);
};
asyncExecute(new Runnable(fn));
}
LiveClient::UpdateLiveAISubtitleOutcomeCallable LiveClient::updateLiveAISubtitleCallable(const UpdateLiveAISubtitleRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateLiveAISubtitleOutcome()>>(
[this, request]()
{
return this->updateLiveAISubtitle(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LiveClient::UpdateLiveAppRecordConfigOutcome LiveClient::updateLiveAppRecordConfig(const UpdateLiveAppRecordConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

99
live/src/model/AddLiveAIProduceRulesRequest.cc Normal file
View File

@@ -0,0 +1,99 @@
/*
* 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/live/model/AddLiveAIProduceRulesRequest.h>
using AlibabaCloud::Live::Model::AddLiveAIProduceRulesRequest;
AddLiveAIProduceRulesRequest::AddLiveAIProduceRulesRequest()
: RpcServiceRequest("live", "2016-11-01", "AddLiveAIProduceRules") {
setMethod(HttpRequest::Method::Post);
}
AddLiveAIProduceRulesRequest::~AddLiveAIProduceRulesRequest() {}
std::string AddLiveAIProduceRulesRequest::getDescription() const {
return description_;
}
void AddLiveAIProduceRulesRequest::setDescription(const std::string &description) {
description_ = description;
setParameter(std::string("Description"), description);
}
std::string AddLiveAIProduceRulesRequest::getSubtitleName() const {
return subtitleName_;
}
void AddLiveAIProduceRulesRequest::setSubtitleName(const std::string &subtitleName) {
subtitleName_ = subtitleName;
setParameter(std::string("SubtitleName"), subtitleName);
}
std::string AddLiveAIProduceRulesRequest::getApp() const {
return app_;
}
void AddLiveAIProduceRulesRequest::setApp(const std::string &app) {
app_ = app;
setParameter(std::string("App"), app);
}
long AddLiveAIProduceRulesRequest::getOwnerId() const {
return ownerId_;
}
void AddLiveAIProduceRulesRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
bool AddLiveAIProduceRulesRequest::getIsLazy() const {
return isLazy_;
}
void AddLiveAIProduceRulesRequest::setIsLazy(bool isLazy) {
isLazy_ = isLazy;
setParameter(std::string("IsLazy"), isLazy ? "true" : "false");
}
std::string AddLiveAIProduceRulesRequest::getLiveTemplate() const {
return liveTemplate_;
}
void AddLiveAIProduceRulesRequest::setLiveTemplate(const std::string &liveTemplate) {
liveTemplate_ = liveTemplate;
setParameter(std::string("LiveTemplate"), liveTemplate);
}
std::string AddLiveAIProduceRulesRequest::getDomain() const {
return domain_;
}
void AddLiveAIProduceRulesRequest::setDomain(const std::string &domain) {
domain_ = domain;
setParameter(std::string("Domain"), domain);
}
bool AddLiveAIProduceRulesRequest::getIsOrigin() const {
return isOrigin_;
}
void AddLiveAIProduceRulesRequest::setIsOrigin(bool isOrigin) {
isOrigin_ = isOrigin;
setParameter(std::string("IsOrigin"), isOrigin ? "true" : "false");
}

51
live/src/model/AddLiveAIProduceRulesResult.cc Normal file
View File

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

191
live/src/model/AddLiveAISubtitleRequest.cc Normal file
View File

@@ -0,0 +1,191 @@
/*
* 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/live/model/AddLiveAISubtitleRequest.h>
using AlibabaCloud::Live::Model::AddLiveAISubtitleRequest;
AddLiveAISubtitleRequest::AddLiveAISubtitleRequest()
: RpcServiceRequest("live", "2016-11-01", "AddLiveAISubtitle") {
setMethod(HttpRequest::Method::Post);
}
AddLiveAISubtitleRequest::~AddLiveAISubtitleRequest() {}
std::string AddLiveAISubtitleRequest::getSrcLanguage() const {
return srcLanguage_;
}
void AddLiveAISubtitleRequest::setSrcLanguage(const std::string &srcLanguage) {
srcLanguage_ = srcLanguage;
setParameter(std::string("SrcLanguage"), srcLanguage);
}
std::string AddLiveAISubtitleRequest::getDescription() const {
return description_;
}
void AddLiveAISubtitleRequest::setDescription(const std::string &description) {
description_ = description;
setParameter(std::string("Description"), description);
}
std::string AddLiveAISubtitleRequest::getFontName() const {
return fontName_;
}
void AddLiveAISubtitleRequest::setFontName(const std::string &fontName) {
fontName_ = fontName;
setParameter(std::string("FontName"), fontName);
}
std::string AddLiveAISubtitleRequest::getSubtitleName() const {
return subtitleName_;
}
void AddLiveAISubtitleRequest::setSubtitleName(const std::string &subtitleName) {
subtitleName_ = subtitleName;
setParameter(std::string("SubtitleName"), subtitleName);
}
float AddLiveAISubtitleRequest::getFontSizeNormalized() const {
return fontSizeNormalized_;
}
void AddLiveAISubtitleRequest::setFontSizeNormalized(float fontSizeNormalized) {
fontSizeNormalized_ = fontSizeNormalized;
setParameter(std::string("FontSizeNormalized"), std::to_string(fontSizeNormalized));
}
std::string AddLiveAISubtitleRequest::getFontColor() const {
return fontColor_;
}
void AddLiveAISubtitleRequest::setFontColor(const std::string &fontColor) {
fontColor_ = fontColor;
setParameter(std::string("FontColor"), fontColor);
}
bool AddLiveAISubtitleRequest::getShowSourceLan() const {
return showSourceLan_;
}
void AddLiveAISubtitleRequest::setShowSourceLan(bool showSourceLan) {
showSourceLan_ = showSourceLan;
setParameter(std::string("ShowSourceLan"), showSourceLan ? "true" : "false");
}
std::vector<AddLiveAISubtitleRequest::float> AddLiveAISubtitleRequest::getPositionNormalized() const {
return positionNormalized_;
}
void AddLiveAISubtitleRequest::setPositionNormalized(const std::vector<AddLiveAISubtitleRequest::float> &positionNormalized) {
positionNormalized_ = positionNormalized;
for(int dep1 = 0; dep1 != positionNormalized.size(); dep1++) {
setParameter(std::string("PositionNormalized") + "." + std::to_string(dep1 + 1), std::to_string(positionNormalized[dep1]));
}
}
float AddLiveAISubtitleRequest::getBorderWidthNormalized() const {
return borderWidthNormalized_;
}
void AddLiveAISubtitleRequest::setBorderWidthNormalized(float borderWidthNormalized) {
borderWidthNormalized_ = borderWidthNormalized;
setParameter(std::string("BorderWidthNormalized"), std::to_string(borderWidthNormalized));
}
int AddLiveAISubtitleRequest::getMaxLines() const {
return maxLines_;
}
void AddLiveAISubtitleRequest::setMaxLines(int maxLines) {
maxLines_ = maxLines;
setParameter(std::string("MaxLines"), std::to_string(maxLines));
}
std::string AddLiveAISubtitleRequest::getHeight() const {
return height_;
}
void AddLiveAISubtitleRequest::setHeight(const std::string &height) {
height_ = height;
setParameter(std::string("Height"), height);
}
int AddLiveAISubtitleRequest::getWordPerLine() const {
return wordPerLine_;
}
void AddLiveAISubtitleRequest::setWordPerLine(int wordPerLine) {
wordPerLine_ = wordPerLine;
setParameter(std::string("WordPerLine"), std::to_string(wordPerLine));
}
long AddLiveAISubtitleRequest::getOwnerId() const {
return ownerId_;
}
void AddLiveAISubtitleRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
float AddLiveAISubtitleRequest::getBgWidthNormalized() const {
return bgWidthNormalized_;
}
void AddLiveAISubtitleRequest::setBgWidthNormalized(float bgWidthNormalized) {
bgWidthNormalized_ = bgWidthNormalized;
setParameter(std::string("BgWidthNormalized"), std::to_string(bgWidthNormalized));
}
std::string AddLiveAISubtitleRequest::getBgColor() const {
return bgColor_;
}
void AddLiveAISubtitleRequest::setBgColor(const std::string &bgColor) {
bgColor_ = bgColor;
setParameter(std::string("BgColor"), bgColor);
}
std::string AddLiveAISubtitleRequest::getDstLanguage() const {
return dstLanguage_;
}
void AddLiveAISubtitleRequest::setDstLanguage(const std::string &dstLanguage) {
dstLanguage_ = dstLanguage;
setParameter(std::string("DstLanguage"), dstLanguage);
}
std::string AddLiveAISubtitleRequest::getWidth() const {
return width_;
}
void AddLiveAISubtitleRequest::setWidth(const std::string &width) {
width_ = width;
setParameter(std::string("Width"), width);
}
std::string AddLiveAISubtitleRequest::getCopyFrom() const {
return copyFrom_;
}
void AddLiveAISubtitleRequest::setCopyFrom(const std::string &copyFrom) {
copyFrom_ = copyFrom;
setParameter(std::string("CopyFrom"), copyFrom);
}

51
live/src/model/AddLiveAISubtitleResult.cc Normal file
View File

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

162
live/src/model/CreateRtcAsrTaskRequest.cc Normal file
View File

@@ -0,0 +1,162 @@
/*
* 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/live/model/CreateRtcAsrTaskRequest.h>
using AlibabaCloud::Live::Model::CreateRtcAsrTaskRequest;
CreateRtcAsrTaskRequest::CreateRtcAsrTaskRequest()
: RpcServiceRequest("live", "2016-11-01", "CreateRtcAsrTask") {
setMethod(HttpRequest::Method::Post);
}
CreateRtcAsrTaskRequest::~CreateRtcAsrTaskRequest() {}
std::string CreateRtcAsrTaskRequest::getAuthKey() const {
return authKey_;
}
void CreateRtcAsrTaskRequest::setAuthKey(const std::string &authKey) {
authKey_ = authKey;
setParameter(std::string("AuthKey"), authKey);
}
std::string CreateRtcAsrTaskRequest::getLanguage() const {
return language_;
}
void CreateRtcAsrTaskRequest::setLanguage(const std::string &language) {
language_ = language;
setParameter(std::string("Language"), language);
}
std::string CreateRtcAsrTaskRequest::getMode() const {
return mode_;
}
void CreateRtcAsrTaskRequest::setMode(const std::string &mode) {
mode_ = mode;
setParameter(std::string("Mode"), mode);
}
bool CreateRtcAsrTaskRequest::getTranslateEnabled() const {
return translateEnabled_;
}
void CreateRtcAsrTaskRequest::setTranslateEnabled(bool translateEnabled) {
translateEnabled_ = translateEnabled;
setParameter(std::string("TranslateEnabled"), translateEnabled ? "true" : "false");
}
std::string CreateRtcAsrTaskRequest::getTag() const {
return tag_;
}
void CreateRtcAsrTaskRequest::setTag(const std::string &tag) {
tag_ = tag;
setParameter(std::string("Tag"), tag);
}
std::string CreateRtcAsrTaskRequest::getStreamURL() const {
return streamURL_;
}
void CreateRtcAsrTaskRequest::setStreamURL(const std::string &streamURL) {
streamURL_ = streamURL;
setParameter(std::string("StreamURL"), streamURL);
}
std::string CreateRtcAsrTaskRequest::getTargetLanguages() const {
return targetLanguages_;
}
void CreateRtcAsrTaskRequest::setTargetLanguages(const std::string &targetLanguages) {
targetLanguages_ = targetLanguages;
setParameter(std::string("TargetLanguages"), targetLanguages);
}
bool CreateRtcAsrTaskRequest::getAutoTerminateEnabled() const {
return autoTerminateEnabled_;
}
void CreateRtcAsrTaskRequest::setAutoTerminateEnabled(bool autoTerminateEnabled) {
autoTerminateEnabled_ = autoTerminateEnabled;
setParameter(std::string("AutoTerminateEnabled"), autoTerminateEnabled ? "true" : "false");
}
long CreateRtcAsrTaskRequest::getOwnerId() const {
return ownerId_;
}
void CreateRtcAsrTaskRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::string CreateRtcAsrTaskRequest::getRtcUserId() const {
return rtcUserId_;
}
void CreateRtcAsrTaskRequest::setRtcUserId(const std::string &rtcUserId) {
rtcUserId_ = rtcUserId;
setParameter(std::string("RtcUserId"), rtcUserId);
}
long CreateRtcAsrTaskRequest::getReportInterval() const {
return reportInterval_;
}
void CreateRtcAsrTaskRequest::setReportInterval(long reportInterval) {
reportInterval_ = reportInterval;
setParameter(std::string("ReportInterval"), std::to_string(reportInterval));
}
long CreateRtcAsrTaskRequest::getAutoTerminateDelay() const {
return autoTerminateDelay_;
}
void CreateRtcAsrTaskRequest::setAutoTerminateDelay(long autoTerminateDelay) {
autoTerminateDelay_ = autoTerminateDelay;
setParameter(std::string("AutoTerminateDelay"), std::to_string(autoTerminateDelay));
}
std::string CreateRtcAsrTaskRequest::getSDKAppID() const {
return sDKAppID_;
}
void CreateRtcAsrTaskRequest::setSDKAppID(const std::string &sDKAppID) {
sDKAppID_ = sDKAppID;
setParameter(std::string("SDKAppID"), sDKAppID);
}
std::string CreateRtcAsrTaskRequest::getCallbackURL() const {
return callbackURL_;
}
void CreateRtcAsrTaskRequest::setCallbackURL(const std::string &callbackURL) {
callbackURL_ = callbackURL;
setParameter(std::string("CallbackURL"), callbackURL);
}
std::string CreateRtcAsrTaskRequest::getChannelID() const {
return channelID_;
}
void CreateRtcAsrTaskRequest::setChannelID(const std::string &channelID) {
channelID_ = channelID;
setParameter(std::string("ChannelID"), channelID);
}

65
live/src/model/CreateRtcAsrTaskResult.cc Normal file
View File

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

72
live/src/model/DeleteLiveAIProduceRulesRequest.cc Normal file
View File

@@ -0,0 +1,72 @@
/*
* 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/live/model/DeleteLiveAIProduceRulesRequest.h>
using AlibabaCloud::Live::Model::DeleteLiveAIProduceRulesRequest;
DeleteLiveAIProduceRulesRequest::DeleteLiveAIProduceRulesRequest()
: RpcServiceRequest("live", "2016-11-01", "DeleteLiveAIProduceRules") {
setMethod(HttpRequest::Method::Post);
}
DeleteLiveAIProduceRulesRequest::~DeleteLiveAIProduceRulesRequest() {}
std::string DeleteLiveAIProduceRulesRequest::getRulesId() const {
return rulesId_;
}
void DeleteLiveAIProduceRulesRequest::setRulesId(const std::string &rulesId) {
rulesId_ = rulesId;
setParameter(std::string("RulesId"), rulesId);
}
std::string DeleteLiveAIProduceRulesRequest::getApp() const {
return app_;
}
void DeleteLiveAIProduceRulesRequest::setApp(const std::string &app) {
app_ = app;
setParameter(std::string("App"), app);
}
long DeleteLiveAIProduceRulesRequest::getOwnerId() const {
return ownerId_;
}
void DeleteLiveAIProduceRulesRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::string DeleteLiveAIProduceRulesRequest::getSuffixName() const {
return suffixName_;
}
void DeleteLiveAIProduceRulesRequest::setSuffixName(const std::string &suffixName) {
suffixName_ = suffixName;
setParameter(std::string("SuffixName"), suffixName);
}
std::string DeleteLiveAIProduceRulesRequest::getDomain() const {
return domain_;
}
void DeleteLiveAIProduceRulesRequest::setDomain(const std::string &domain) {
domain_ = domain;
setParameter(std::string("Domain"), domain);
}

44
live/src/model/DeleteLiveAIProduceRulesResult.cc Normal file
View File

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

54
live/src/model/DeleteLiveAISubtitleRequest.cc Normal file
View File

@@ -0,0 +1,54 @@
/*
* 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/live/model/DeleteLiveAISubtitleRequest.h>
using AlibabaCloud::Live::Model::DeleteLiveAISubtitleRequest;
DeleteLiveAISubtitleRequest::DeleteLiveAISubtitleRequest()
: RpcServiceRequest("live", "2016-11-01", "DeleteLiveAISubtitle") {
setMethod(HttpRequest::Method::Post);
}
DeleteLiveAISubtitleRequest::~DeleteLiveAISubtitleRequest() {}
std::string DeleteLiveAISubtitleRequest::getSubtitleName() const {
return subtitleName_;
}
void DeleteLiveAISubtitleRequest::setSubtitleName(const std::string &subtitleName) {
subtitleName_ = subtitleName;
setParameter(std::string("SubtitleName"), subtitleName);
}
long DeleteLiveAISubtitleRequest::getOwnerId() const {
return ownerId_;
}
void DeleteLiveAISubtitleRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::string DeleteLiveAISubtitleRequest::getSubtitleId() const {
return subtitleId_;
}
void DeleteLiveAISubtitleRequest::setSubtitleId(const std::string &subtitleId) {
subtitleId_ = subtitleId;
setParameter(std::string("SubtitleId"), subtitleId);
}

44
live/src/model/DeleteLiveAISubtitleResult.cc Normal file
View File

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

90
live/src/model/DescribeLiveAIProduceRulesRequest.cc Normal file
View File

@@ -0,0 +1,90 @@
/*
* 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/live/model/DescribeLiveAIProduceRulesRequest.h>
using AlibabaCloud::Live::Model::DescribeLiveAIProduceRulesRequest;
DescribeLiveAIProduceRulesRequest::DescribeLiveAIProduceRulesRequest()
: RpcServiceRequest("live", "2016-11-01", "DescribeLiveAIProduceRules") {
setMethod(HttpRequest::Method::Post);
}
DescribeLiveAIProduceRulesRequest::~DescribeLiveAIProduceRulesRequest() {}
std::string DescribeLiveAIProduceRulesRequest::getPageNumber() const {
return pageNumber_;
}
void DescribeLiveAIProduceRulesRequest::setPageNumber(const std::string &pageNumber) {
pageNumber_ = pageNumber;
setParameter(std::string("PageNumber"), pageNumber);
}
std::string DescribeLiveAIProduceRulesRequest::getPageSize() const {
return pageSize_;
}
void DescribeLiveAIProduceRulesRequest::setPageSize(const std::string &pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), pageSize);
}
std::string DescribeLiveAIProduceRulesRequest::getRulesId() const {
return rulesId_;
}
void DescribeLiveAIProduceRulesRequest::setRulesId(const std::string &rulesId) {
rulesId_ = rulesId;
setParameter(std::string("RulesId"), rulesId);
}
std::string DescribeLiveAIProduceRulesRequest::getApp() const {
return app_;
}
void DescribeLiveAIProduceRulesRequest::setApp(const std::string &app) {
app_ = app;
setParameter(std::string("App"), app);
}
long DescribeLiveAIProduceRulesRequest::getOwnerId() const {
return ownerId_;
}
void DescribeLiveAIProduceRulesRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::string DescribeLiveAIProduceRulesRequest::getSuffixName() const {
return suffixName_;
}
void DescribeLiveAIProduceRulesRequest::setSuffixName(const std::string &suffixName) {
suffixName_ = suffixName;
setParameter(std::string("SuffixName"), suffixName);
}
std::string DescribeLiveAIProduceRulesRequest::getDomain() const {
return domain_;
}
void DescribeLiveAIProduceRulesRequest::setDomain(const std::string &domain) {
domain_ = domain;
setParameter(std::string("Domain"), domain);
}

75
live/src/model/DescribeLiveAIProduceRulesResult.cc Normal file
View File

@@ -0,0 +1,75 @@
/*
* 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/live/model/DescribeLiveAIProduceRulesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
DescribeLiveAIProduceRulesResult::DescribeLiveAIProduceRulesResult() :
ServiceResult()
{}
DescribeLiveAIProduceRulesResult::DescribeLiveAIProduceRulesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeLiveAIProduceRulesResult::~DescribeLiveAIProduceRulesResult()
{}
void DescribeLiveAIProduceRulesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allRuleInfoListNode = value["RuleInfoList"]["RuleInfo"];
for (auto valueRuleInfoListRuleInfo : allRuleInfoListNode)
{
RuleInfo ruleInfoListObject;
if(!valueRuleInfoListRuleInfo["Domain"].isNull())
ruleInfoListObject.domain = valueRuleInfoListRuleInfo["Domain"].asString();
if(!valueRuleInfoListRuleInfo["App"].isNull())
ruleInfoListObject.app = valueRuleInfoListRuleInfo["App"].asString();
if(!valueRuleInfoListRuleInfo["SubtitleName"].isNull())
ruleInfoListObject.subtitleName = valueRuleInfoListRuleInfo["SubtitleName"].asString();
if(!valueRuleInfoListRuleInfo["IsLazy"].isNull())
ruleInfoListObject.isLazy = valueRuleInfoListRuleInfo["IsLazy"].asString() == "true";
if(!valueRuleInfoListRuleInfo["IsOrigin"].isNull())
ruleInfoListObject.isOrigin = valueRuleInfoListRuleInfo["IsOrigin"].asString() == "true";
if(!valueRuleInfoListRuleInfo["RulesId"].isNull())
ruleInfoListObject.rulesId = valueRuleInfoListRuleInfo["RulesId"].asString();
if(!valueRuleInfoListRuleInfo["LiveTemplate"].isNull())
ruleInfoListObject.liveTemplate = valueRuleInfoListRuleInfo["LiveTemplate"].asString();
if(!valueRuleInfoListRuleInfo["GmtModifyTime"].isNull())
ruleInfoListObject.gmtModifyTime = valueRuleInfoListRuleInfo["GmtModifyTime"].asString();
if(!valueRuleInfoListRuleInfo["SuffixName"].isNull())
ruleInfoListObject.suffixName = valueRuleInfoListRuleInfo["SuffixName"].asString();
if(!valueRuleInfoListRuleInfo["Description"].isNull())
ruleInfoListObject.description = valueRuleInfoListRuleInfo["Description"].asString();
ruleInfoList_.push_back(ruleInfoListObject);
}
}
std::vector<DescribeLiveAIProduceRulesResult::RuleInfo> DescribeLiveAIProduceRulesResult::getRuleInfoList()const
{
return ruleInfoList_;
}

72
live/src/model/DescribeLiveAISubtitleRequest.cc Normal file
View File

@@ -0,0 +1,72 @@
/*
* 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/live/model/DescribeLiveAISubtitleRequest.h>
using AlibabaCloud::Live::Model::DescribeLiveAISubtitleRequest;
DescribeLiveAISubtitleRequest::DescribeLiveAISubtitleRequest()
: RpcServiceRequest("live", "2016-11-01", "DescribeLiveAISubtitle") {
setMethod(HttpRequest::Method::Post);
}
DescribeLiveAISubtitleRequest::~DescribeLiveAISubtitleRequest() {}
std::string DescribeLiveAISubtitleRequest::getSubtitleName() const {
return subtitleName_;
}
void DescribeLiveAISubtitleRequest::setSubtitleName(const std::string &subtitleName) {
subtitleName_ = subtitleName;
setParameter(std::string("SubtitleName"), subtitleName);
}
std::string DescribeLiveAISubtitleRequest::getPageNumber() const {
return pageNumber_;
}
void DescribeLiveAISubtitleRequest::setPageNumber(const std::string &pageNumber) {
pageNumber_ = pageNumber;
setParameter(std::string("PageNumber"), pageNumber);
}
std::string DescribeLiveAISubtitleRequest::getPageSize() const {
return pageSize_;
}
void DescribeLiveAISubtitleRequest::setPageSize(const std::string &pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), pageSize);
}
long DescribeLiveAISubtitleRequest::getOwnerId() const {
return ownerId_;
}
void DescribeLiveAISubtitleRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
std::string DescribeLiveAISubtitleRequest::getSubtitleId() const {
return subtitleId_;
}
void DescribeLiveAISubtitleRequest::setSubtitleId(const std::string &subtitleId) {
subtitleId_ = subtitleId;
setParameter(std::string("SubtitleId"), subtitleId);
}

93
live/src/model/DescribeLiveAISubtitleResult.cc Normal file
View File

@@ -0,0 +1,93 @@
/*
* 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/live/model/DescribeLiveAISubtitleResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
DescribeLiveAISubtitleResult::DescribeLiveAISubtitleResult() :
ServiceResult()
{}
DescribeLiveAISubtitleResult::DescribeLiveAISubtitleResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeLiveAISubtitleResult::~DescribeLiveAISubtitleResult()
{}
void DescribeLiveAISubtitleResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allSubtitleConfigsNode = value["SubtitleConfigs"]["SubtitleConfig"];
for (auto valueSubtitleConfigsSubtitleConfig : allSubtitleConfigsNode)
{
SubtitleConfig subtitleConfigsObject;
if(!valueSubtitleConfigsSubtitleConfig["DstLanguage"].isNull())
subtitleConfigsObject.dstLanguage = valueSubtitleConfigsSubtitleConfig["DstLanguage"].asString();
if(!valueSubtitleConfigsSubtitleConfig["SrcLanguage"].isNull())
subtitleConfigsObject.srcLanguage = valueSubtitleConfigsSubtitleConfig["SrcLanguage"].asString();
if(!valueSubtitleConfigsSubtitleConfig["FontColor"].isNull())
subtitleConfigsObject.fontColor = valueSubtitleConfigsSubtitleConfig["FontColor"].asString();
if(!valueSubtitleConfigsSubtitleConfig["FontName"].isNull())
subtitleConfigsObject.fontName = valueSubtitleConfigsSubtitleConfig["FontName"].asString();
if(!valueSubtitleConfigsSubtitleConfig["ShowSourceLan"].isNull())
subtitleConfigsObject.showSourceLan = std::stoi(valueSubtitleConfigsSubtitleConfig["ShowSourceLan"].asString());
if(!valueSubtitleConfigsSubtitleConfig["MaxLines"].isNull())
subtitleConfigsObject.maxLines = std::stoi(valueSubtitleConfigsSubtitleConfig["MaxLines"].asString());
if(!valueSubtitleConfigsSubtitleConfig["WordPerline"].isNull())
subtitleConfigsObject.wordPerline = std::stoi(valueSubtitleConfigsSubtitleConfig["WordPerline"].asString());
if(!valueSubtitleConfigsSubtitleConfig["BgColor"].isNull())
subtitleConfigsObject.bgColor = valueSubtitleConfigsSubtitleConfig["BgColor"].asString();
if(!valueSubtitleConfigsSubtitleConfig["BgWidthNormalized"].isNull())
subtitleConfigsObject.bgWidthNormalized = std::stof(valueSubtitleConfigsSubtitleConfig["BgWidthNormalized"].asString());
if(!valueSubtitleConfigsSubtitleConfig["BorderWidthNormalized"].isNull())
subtitleConfigsObject.borderWidthNormalized = std::stof(valueSubtitleConfigsSubtitleConfig["BorderWidthNormalized"].asString());
if(!valueSubtitleConfigsSubtitleConfig["Width"].isNull())
subtitleConfigsObject.width = valueSubtitleConfigsSubtitleConfig["Width"].asString();
if(!valueSubtitleConfigsSubtitleConfig["Height"].isNull())
subtitleConfigsObject.height = valueSubtitleConfigsSubtitleConfig["Height"].asString();
if(!valueSubtitleConfigsSubtitleConfig["SubtitleName"].isNull())
subtitleConfigsObject.subtitleName = valueSubtitleConfigsSubtitleConfig["SubtitleName"].asString();
if(!valueSubtitleConfigsSubtitleConfig["SubtitleId"].isNull())
subtitleConfigsObject.subtitleId = valueSubtitleConfigsSubtitleConfig["SubtitleId"].asString();
if(!valueSubtitleConfigsSubtitleConfig["FontSizeNormalized"].isNull())
subtitleConfigsObject.fontSizeNormalized = valueSubtitleConfigsSubtitleConfig["FontSizeNormalized"].asString();
if(!valueSubtitleConfigsSubtitleConfig["Description"].isNull())
subtitleConfigsObject.description = valueSubtitleConfigsSubtitleConfig["Description"].asString();
auto allPositionNormalized = value["PositionNormalized"]["Position"];
for (auto value : allPositionNormalized)
subtitleConfigsObject.positionNormalized.push_back(value.asString());
auto allRulesRefer = value["RulesRefer"]["RulesId"];
for (auto value : allRulesRefer)
subtitleConfigsObject.rulesRefer.push_back(value.asString());
subtitleConfigs_.push_back(subtitleConfigsObject);
}
}
std::vector<DescribeLiveAISubtitleResult::SubtitleConfig> DescribeLiveAISubtitleResult::getSubtitleConfigs()const
{
return subtitleConfigs_;
}

81
live/src/model/ListLiveMessageGroupByPageRequest.cc Normal file
View File

@@ -0,0 +1,81 @@
/*
* 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/live/model/ListLiveMessageGroupByPageRequest.h>
using AlibabaCloud::Live::Model::ListLiveMessageGroupByPageRequest;
ListLiveMessageGroupByPageRequest::ListLiveMessageGroupByPageRequest()
: RpcServiceRequest("live", "2016-11-01", "ListLiveMessageGroupByPage") {
setMethod(HttpRequest::Method::Get);
}
ListLiveMessageGroupByPageRequest::~ListLiveMessageGroupByPageRequest() {}
int ListLiveMessageGroupByPageRequest::getSortType() const {
return sortType_;
}
void ListLiveMessageGroupByPageRequest::setSortType(int sortType) {
sortType_ = sortType;
setParameter(std::string("SortType"), std::to_string(sortType));
}
int ListLiveMessageGroupByPageRequest::getGroupStatus() const {
return groupStatus_;
}
void ListLiveMessageGroupByPageRequest::setGroupStatus(int groupStatus) {
groupStatus_ = groupStatus;
setParameter(std::string("GroupStatus"), std::to_string(groupStatus));
}
std::string ListLiveMessageGroupByPageRequest::getDataCenter() const {
return dataCenter_;
}
void ListLiveMessageGroupByPageRequest::setDataCenter(const std::string &dataCenter) {
dataCenter_ = dataCenter;
setParameter(std::string("DataCenter"), dataCenter);
}
int ListLiveMessageGroupByPageRequest::getPageNumber() const {
return pageNumber_;
}
void ListLiveMessageGroupByPageRequest::setPageNumber(int pageNumber) {
pageNumber_ = pageNumber;
setParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
std::string ListLiveMessageGroupByPageRequest::getAppId() const {
return appId_;
}
void ListLiveMessageGroupByPageRequest::setAppId(const std::string &appId) {
appId_ = appId;
setParameter(std::string("AppId"), appId);
}
int ListLiveMessageGroupByPageRequest::getPageSize() const {
return pageSize_;
}
void ListLiveMessageGroupByPageRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setParameter(std::string("PageSize"), std::to_string(pageSize));
}

91
live/src/model/ListLiveMessageGroupByPageResult.cc Normal file
View File

@@ -0,0 +1,91 @@
/*
* 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/live/model/ListLiveMessageGroupByPageResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Live;
using namespace AlibabaCloud::Live::Model;
ListLiveMessageGroupByPageResult::ListLiveMessageGroupByPageResult() :
ServiceResult()
{}
ListLiveMessageGroupByPageResult::ListLiveMessageGroupByPageResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListLiveMessageGroupByPageResult::~ListLiveMessageGroupByPageResult()
{}
void ListLiveMessageGroupByPageResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allGroupListNode = value["GroupList"]["Groups"];
for (auto valueGroupListGroups : allGroupListNode)
{
Groups groupListObject;
if(!valueGroupListGroups["GroupId"].isNull())
groupListObject.groupId = valueGroupListGroups["GroupId"].asString();
if(!valueGroupListGroups["CreatorId"].isNull())
groupListObject.creatorId = valueGroupListGroups["CreatorId"].asString();
if(!valueGroupListGroups["Createtime"].isNull())
groupListObject.createtime = std::stol(valueGroupListGroups["Createtime"].asString());
if(!valueGroupListGroups["GroupName"].isNull())
groupListObject.groupName = valueGroupListGroups["GroupName"].asString();
if(!valueGroupListGroups["GroupInfo"].isNull())
groupListObject.groupInfo = valueGroupListGroups["GroupInfo"].asString();
if(!valueGroupListGroups["Delete"].isNull())
groupListObject._delete = valueGroupListGroups["Delete"].asString() == "true";
auto allAdminList = value["AdminList"]["Admins"];
for (auto value : allAdminList)
groupListObject.adminList.push_back(value.asString());
groupList_.push_back(groupListObject);
}
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
}
int ListLiveMessageGroupByPageResult::getTotalCount()const
{
return totalCount_;
}
std::vector<ListLiveMessageGroupByPageResult::Groups> ListLiveMessageGroupByPageResult::getGroupList()const
{
return groupList_;
}
int ListLiveMessageGroupByPageResult::getPageSize()const
{
return pageSize_;
}
int ListLiveMessageGroupByPageResult::getPageNumber()const
{
return pageNumber_;
}

45
live/src/model/QueryRtcAsrTasksRequest.cc Normal 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/live/model/QueryRtcAsrTasksRequest.h>
using AlibabaCloud::Live::Model::QueryRtcAsrTasksRequest;
QueryRtcAsrTasksRequest::QueryRtcAsrTasksRequest()
: RpcServiceRequest("live", "2016-11-01", "QueryRtcAsrTasks") {
setMethod(HttpRequest::Method::Post);
}
QueryRtcAsrTasksRequest::~QueryRtcAsrTasksRequest() {}
std::string QueryRtcAsrTasksRequest::getTaskId() const {
return taskId_;
}
void QueryRtcAsrTasksRequest::setTaskId(const std::string &taskId) {
taskId_ = taskId;
setParameter(std::string("TaskId"), taskId);
}
long QueryRtcAsrTasksRequest::getOwnerId() const {
return ownerId_;
}
void QueryRtcAsrTasksRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}

44
live/src/model/QueryRtcAsrTasksResult.cc Normal file
View File

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

45
live/src/model/StopRtcAsrTaskRequest.cc Normal 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/live/model/StopRtcAsrTaskRequest.h>
using AlibabaCloud::Live::Model::StopRtcAsrTaskRequest;
StopRtcAsrTaskRequest::StopRtcAsrTaskRequest()
: RpcServiceRequest("live", "2016-11-01", "StopRtcAsrTask") {
setMethod(HttpRequest::Method::Post);
}
StopRtcAsrTaskRequest::~StopRtcAsrTaskRequest() {}
std::string StopRtcAsrTaskRequest::getTaskId() const {
return taskId_;
}
void StopRtcAsrTaskRequest::setTaskId(const std::string &taskId) {
taskId_ = taskId;
setParameter(std::string("TaskId"), taskId);
}
long StopRtcAsrTaskRequest::getOwnerId() const {
return ownerId_;
}
void StopRtcAsrTaskRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}

58
live/src/model/StopRtcAsrTaskResult.cc Normal file
View File

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

117
live/src/model/UpdateLiveAIProduceRulesRequest.cc Normal file
View File

@@ -0,0 +1,117 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/live/model/UpdateLiveAIProduceRulesRequest.h>
using AlibabaCloud::Live::Model::UpdateLiveAIProduceRulesRequest;
UpdateLiveAIProduceRulesRequest::UpdateLiveAIProduceRulesRequest()
: RpcServiceRequest("live", "2016-11-01", "UpdateLiveAIProduceRules") {
setMethod(HttpRequest::Method::Post);
}
UpdateLiveAIProduceRulesRequest::~UpdateLiveAIProduceRulesRequest() {}
std::string UpdateLiveAIProduceRulesRequest::getDescription() const {
return description_;
}
void UpdateLiveAIProduceRulesRequest::setDescription(const std::string &description) {
description_ = description;
setParameter(std::string("Description"), description);
}
std::string UpdateLiveAIProduceRulesRequest::getSubtitleName() const {
return subtitleName_;
}
void UpdateLiveAIProduceRulesRequest::setSubtitleName(const std::string &subtitleName) {
subtitleName_ = subtitleName;
setParameter(std::string("SubtitleName"), subtitleName);
}
std::string UpdateLiveAIProduceRulesRequest::getRulesId() const {
return rulesId_;
}
void UpdateLiveAIProduceRulesRequest::setRulesId(const std::string &rulesId) {
rulesId_ = rulesId;
setParameter(std::string("RulesId"), rulesId);
}
std::string UpdateLiveAIProduceRulesRequest::getApp() const {
return app_;
}
void UpdateLiveAIProduceRulesRequest::setApp(const std::string &app) {
app_ = app;
setParameter(std::string("App"), app);
}
long UpdateLiveAIProduceRulesRequest::getOwnerId() const {
return ownerId_;
}
void UpdateLiveAIProduceRulesRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
bool UpdateLiveAIProduceRulesRequest::getIsLazy() const {
return isLazy_;
}
void UpdateLiveAIProduceRulesRequest::setIsLazy(bool isLazy) {
isLazy_ = isLazy;
setParameter(std::string("IsLazy"), isLazy ? "true" : "false");
}
std::string UpdateLiveAIProduceRulesRequest::getLiveTemplate() const {
return liveTemplate_;
}
void UpdateLiveAIProduceRulesRequest::setLiveTemplate(const std::string &liveTemplate) {
liveTemplate_ = liveTemplate;
setParameter(std::string("LiveTemplate"), liveTemplate);
}
std::string UpdateLiveAIProduceRulesRequest::getDomain() const {
return domain_;
}
void UpdateLiveAIProduceRulesRequest::setDomain(const std::string &domain) {
domain_ = domain;
setParameter(std::string("Domain"), domain);
}
bool UpdateLiveAIProduceRulesRequest::getIsOrigin() const {
return isOrigin_;
}
void UpdateLiveAIProduceRulesRequest::setIsOrigin(bool isOrigin) {
isOrigin_ = isOrigin;
setParameter(std::string("IsOrigin"), isOrigin ? "true" : "false");
}
std::string UpdateLiveAIProduceRulesRequest::getSubtitleId() const {
return subtitleId_;
}
void UpdateLiveAIProduceRulesRequest::setSubtitleId(const std::string &subtitleId) {
subtitleId_ = subtitleId;
setParameter(std::string("SubtitleId"), subtitleId);
}

44
live/src/model/UpdateLiveAIProduceRulesResult.cc Normal file
View File

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

191
live/src/model/UpdateLiveAISubtitleRequest.cc Normal file
View File

@@ -0,0 +1,191 @@
/*
* 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/live/model/UpdateLiveAISubtitleRequest.h>
using AlibabaCloud::Live::Model::UpdateLiveAISubtitleRequest;
UpdateLiveAISubtitleRequest::UpdateLiveAISubtitleRequest()
: RpcServiceRequest("live", "2016-11-01", "UpdateLiveAISubtitle") {
setMethod(HttpRequest::Method::Post);
}
UpdateLiveAISubtitleRequest::~UpdateLiveAISubtitleRequest() {}
std::string UpdateLiveAISubtitleRequest::getSrcLanguage() const {
return srcLanguage_;
}
void UpdateLiveAISubtitleRequest::setSrcLanguage(const std::string &srcLanguage) {
srcLanguage_ = srcLanguage;
setParameter(std::string("SrcLanguage"), srcLanguage);
}
std::string UpdateLiveAISubtitleRequest::getDescription() const {
return description_;
}
void UpdateLiveAISubtitleRequest::setDescription(const std::string &description) {
description_ = description;
setParameter(std::string("Description"), description);
}
std::string UpdateLiveAISubtitleRequest::getFontName() const {
return fontName_;
}
void UpdateLiveAISubtitleRequest::setFontName(const std::string &fontName) {
fontName_ = fontName;
setParameter(std::string("FontName"), fontName);
}
std::string UpdateLiveAISubtitleRequest::getSubtitleName() const {
return subtitleName_;
}
void UpdateLiveAISubtitleRequest::setSubtitleName(const std::string &subtitleName) {
subtitleName_ = subtitleName;
setParameter(std::string("SubtitleName"), subtitleName);
}
float UpdateLiveAISubtitleRequest::getFontSizeNormalized() const {
return fontSizeNormalized_;
}
void UpdateLiveAISubtitleRequest::setFontSizeNormalized(float fontSizeNormalized) {
fontSizeNormalized_ = fontSizeNormalized;
setParameter(std::string("FontSizeNormalized"), std::to_string(fontSizeNormalized));
}
std::string UpdateLiveAISubtitleRequest::getFontColor() const {
return fontColor_;
}
void UpdateLiveAISubtitleRequest::setFontColor(const std::string &fontColor) {
fontColor_ = fontColor;
setParameter(std::string("FontColor"), fontColor);
}
bool UpdateLiveAISubtitleRequest::getShowSourceLan() const {
return showSourceLan_;
}
void UpdateLiveAISubtitleRequest::setShowSourceLan(bool showSourceLan) {
showSourceLan_ = showSourceLan;
setParameter(std::string("ShowSourceLan"), showSourceLan ? "true" : "false");
}
std::vector<UpdateLiveAISubtitleRequest::float> UpdateLiveAISubtitleRequest::getPositionNormalized() const {
return positionNormalized_;
}
void UpdateLiveAISubtitleRequest::setPositionNormalized(const std::vector<UpdateLiveAISubtitleRequest::float> &positionNormalized) {
positionNormalized_ = positionNormalized;
for(int dep1 = 0; dep1 != positionNormalized.size(); dep1++) {
setParameter(std::string("PositionNormalized") + "." + std::to_string(dep1 + 1), std::to_string(positionNormalized[dep1]));
}
}
float UpdateLiveAISubtitleRequest::getBorderWidthNormalized() const {
return borderWidthNormalized_;
}
void UpdateLiveAISubtitleRequest::setBorderWidthNormalized(float borderWidthNormalized) {
borderWidthNormalized_ = borderWidthNormalized;
setParameter(std::string("BorderWidthNormalized"), std::to_string(borderWidthNormalized));
}
int UpdateLiveAISubtitleRequest::getMaxLines() const {
return maxLines_;
}
void UpdateLiveAISubtitleRequest::setMaxLines(int maxLines) {
maxLines_ = maxLines;
setParameter(std::string("MaxLines"), std::to_string(maxLines));
}
std::string UpdateLiveAISubtitleRequest::getHeight() const {
return height_;
}
void UpdateLiveAISubtitleRequest::setHeight(const std::string &height) {
height_ = height;
setParameter(std::string("Height"), height);
}
int UpdateLiveAISubtitleRequest::getWordPerLine() const {
return wordPerLine_;
}
void UpdateLiveAISubtitleRequest::setWordPerLine(int wordPerLine) {
wordPerLine_ = wordPerLine;
setParameter(std::string("WordPerLine"), std::to_string(wordPerLine));
}
long UpdateLiveAISubtitleRequest::getOwnerId() const {
return ownerId_;
}
void UpdateLiveAISubtitleRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}
float UpdateLiveAISubtitleRequest::getBgWidthNormalized() const {
return bgWidthNormalized_;
}
void UpdateLiveAISubtitleRequest::setBgWidthNormalized(float bgWidthNormalized) {
bgWidthNormalized_ = bgWidthNormalized;
setParameter(std::string("BgWidthNormalized"), std::to_string(bgWidthNormalized));
}
std::string UpdateLiveAISubtitleRequest::getBgColor() const {
return bgColor_;
}
void UpdateLiveAISubtitleRequest::setBgColor(const std::string &bgColor) {
bgColor_ = bgColor;
setParameter(std::string("BgColor"), bgColor);
}
std::string UpdateLiveAISubtitleRequest::getDstLanguage() const {
return dstLanguage_;
}
void UpdateLiveAISubtitleRequest::setDstLanguage(const std::string &dstLanguage) {
dstLanguage_ = dstLanguage;
setParameter(std::string("DstLanguage"), dstLanguage);
}
std::string UpdateLiveAISubtitleRequest::getWidth() const {
return width_;
}
void UpdateLiveAISubtitleRequest::setWidth(const std::string &width) {
width_ = width;
setParameter(std::string("Width"), width);
}
std::string UpdateLiveAISubtitleRequest::getSubtitleId() const {
return subtitleId_;
}
void UpdateLiveAISubtitleRequest::setSubtitleId(const std::string &subtitleId) {
subtitleId_ = subtitleId;
setParameter(std::string("SubtitleId"), subtitleId);
}

44
live/src/model/UpdateLiveAISubtitleResult.cc Normal file
View File

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